1 /* 2 * Copyright (c) 2000, 2019, 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. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package jdk.internal.misc; 27 28 import jdk.internal.HotSpotIntrinsicCandidate; 29 import jdk.internal.ref.Cleaner; 30 import jdk.internal.vm.annotation.ForceInline; 31 import sun.nio.ch.DirectBuffer; 32 33 import java.lang.reflect.Field; 34 import java.security.ProtectionDomain; 35 36 import static jdk.internal.misc.UnsafeConstants.*; 37 38 /** 39 * A collection of methods for performing low-level, unsafe operations. 40 * Although the class and all methods are public, use of this class is 41 * limited because only trusted code can obtain instances of it. 42 * 43 * <em>Note:</em> It is the resposibility of the caller to make sure 44 * arguments are checked before methods of this class are 45 * called. While some rudimentary checks are performed on the input, 46 * the checks are best effort and when performance is an overriding 47 * priority, as when methods of this class are optimized by the 48 * runtime compiler, some or all checks (if any) may be elided. Hence, 49 * the caller must not rely on the checks and corresponding 50 * exceptions! 51 * 52 * @author John R. Rose 53 * @see #getUnsafe 54 */ 55 56 public final class Unsafe { 57 58 private static native void registerNatives(); 59 static { 60 registerNatives(); 61 } 62 63 private Unsafe() {} 64 65 private static final Unsafe theUnsafe = new Unsafe(); 66 67 /** 68 * Provides the caller with the capability of performing unsafe 69 * operations. 70 * 71 * <p>The returned {@code Unsafe} object should be carefully guarded 72 * by the caller, since it can be used to read and write data at arbitrary 73 * memory addresses. It must never be passed to untrusted code. 74 * 75 * <p>Most methods in this class are very low-level, and correspond to a 76 * small number of hardware instructions (on typical machines). Compilers 77 * are encouraged to optimize these methods accordingly. 78 * 79 * <p>Here is a suggested idiom for using unsafe operations: 80 * 81 * <pre> {@code 82 * class MyTrustedClass { 83 * private static final Unsafe unsafe = Unsafe.getUnsafe(); 84 * ... 85 * private long myCountAddress = ...; 86 * public int getCount() { return unsafe.getByte(myCountAddress); } 87 * }}</pre> 88 * 89 * (It may assist compilers to make the local variable {@code final}.) 90 */ 91 public static Unsafe getUnsafe() { 92 return theUnsafe; 93 } 94 95 /// peek and poke operations 96 /// (compilers should optimize these to memory ops) 97 98 // These work on object fields in the Java heap. 99 // They will not work on elements of packed arrays. 100 101 /** 102 * Fetches a value from a given Java variable. 103 * More specifically, fetches a field or array element within the given 104 * object {@code o} at the given offset, or (if {@code o} is null) 105 * from the memory address whose numerical value is the given offset. 106 * <p> 107 * The results are undefined unless one of the following cases is true: 108 * <ul> 109 * <li>The offset was obtained from {@link #objectFieldOffset} on 110 * the {@link java.lang.reflect.Field} of some Java field and the object 111 * referred to by {@code o} is of a class compatible with that 112 * field's class. 113 * 114 * <li>The offset and object reference {@code o} (either null or 115 * non-null) were both obtained via {@link #staticFieldOffset} 116 * and {@link #staticFieldBase} (respectively) from the 117 * reflective {@link Field} representation of some Java field. 118 * 119 * <li>The object referred to by {@code o} is an array, and the offset 120 * is an integer of the form {@code B+N*S}, where {@code N} is 121 * a valid index into the array, and {@code B} and {@code S} are 122 * the values obtained by {@link #arrayBaseOffset} and {@link 123 * #arrayIndexScale} (respectively) from the array's class. The value 124 * referred to is the {@code N}<em>th</em> element of the array. 125 * 126 * </ul> 127 * <p> 128 * If one of the above cases is true, the call references a specific Java 129 * variable (field or array element). However, the results are undefined 130 * if that variable is not in fact of the type returned by this method. 131 * <p> 132 * This method refers to a variable by means of two parameters, and so 133 * it provides (in effect) a <em>double-register</em> addressing mode 134 * for Java variables. When the object reference is null, this method 135 * uses its offset as an absolute address. This is similar in operation 136 * to methods such as {@link #getInt(long)}, which provide (in effect) a 137 * <em>single-register</em> addressing mode for non-Java variables. 138 * However, because Java variables may have a different layout in memory 139 * from non-Java variables, programmers should not assume that these 140 * two addressing modes are ever equivalent. Also, programmers should 141 * remember that offsets from the double-register addressing mode cannot 142 * be portably confused with longs used in the single-register addressing 143 * mode. 144 * 145 * @param o Java heap object in which the variable resides, if any, else 146 * null 147 * @param offset indication of where the variable resides in a Java heap 148 * object, if any, else a memory address locating the variable 149 * statically 150 * @return the value fetched from the indicated Java variable 151 * @throws RuntimeException No defined exceptions are thrown, not even 152 * {@link NullPointerException} 153 */ 154 @HotSpotIntrinsicCandidate 155 public native int getInt(Object o, long offset); 156 157 /** 158 * Stores a value into a given Java variable. 159 * <p> 160 * The first two parameters are interpreted exactly as with 161 * {@link #getInt(Object, long)} to refer to a specific 162 * Java variable (field or array element). The given value 163 * is stored into that variable. 164 * <p> 165 * The variable must be of the same type as the method 166 * parameter {@code x}. 167 * 168 * @param o Java heap object in which the variable resides, if any, else 169 * null 170 * @param offset indication of where the variable resides in a Java heap 171 * object, if any, else a memory address locating the variable 172 * statically 173 * @param x the value to store into the indicated Java variable 174 * @throws RuntimeException No defined exceptions are thrown, not even 175 * {@link NullPointerException} 176 */ 177 @HotSpotIntrinsicCandidate 178 public native void putInt(Object o, long offset, int x); 179 180 /** 181 * Fetches a reference value from a given Java variable. 182 * @see #getInt(Object, long) 183 */ 184 @HotSpotIntrinsicCandidate 185 public native Object getReference(Object o, long offset); 186 187 /** 188 * Stores a reference value into a given Java variable. 189 * <p> 190 * Unless the reference {@code x} being stored is either null 191 * or matches the field type, the results are undefined. 192 * If the reference {@code o} is non-null, card marks or 193 * other store barriers for that object (if the VM requires them) 194 * are updated. 195 * @see #putInt(Object, long, int) 196 */ 197 @HotSpotIntrinsicCandidate 198 public native void putReference(Object o, long offset, Object x); 199 200 /** @see #getInt(Object, long) */ 201 @HotSpotIntrinsicCandidate 202 public native boolean getBoolean(Object o, long offset); 203 204 /** @see #putInt(Object, long, int) */ 205 @HotSpotIntrinsicCandidate 206 public native void putBoolean(Object o, long offset, boolean x); 207 208 /** @see #getInt(Object, long) */ 209 @HotSpotIntrinsicCandidate 210 public native byte getByte(Object o, long offset); 211 212 /** @see #putInt(Object, long, int) */ 213 @HotSpotIntrinsicCandidate 214 public native void putByte(Object o, long offset, byte x); 215 216 /** @see #getInt(Object, long) */ 217 @HotSpotIntrinsicCandidate 218 public native short getShort(Object o, long offset); 219 220 /** @see #putInt(Object, long, int) */ 221 @HotSpotIntrinsicCandidate 222 public native void putShort(Object o, long offset, short x); 223 224 /** @see #getInt(Object, long) */ 225 @HotSpotIntrinsicCandidate 226 public native char getChar(Object o, long offset); 227 228 /** @see #putInt(Object, long, int) */ 229 @HotSpotIntrinsicCandidate 230 public native void putChar(Object o, long offset, char x); 231 232 /** @see #getInt(Object, long) */ 233 @HotSpotIntrinsicCandidate 234 public native long getLong(Object o, long offset); 235 236 /** @see #putInt(Object, long, int) */ 237 @HotSpotIntrinsicCandidate 238 public native void putLong(Object o, long offset, long x); 239 240 /** @see #getInt(Object, long) */ 241 @HotSpotIntrinsicCandidate 242 public native float getFloat(Object o, long offset); 243 244 /** @see #putInt(Object, long, int) */ 245 @HotSpotIntrinsicCandidate 246 public native void putFloat(Object o, long offset, float x); 247 248 /** @see #getInt(Object, long) */ 249 @HotSpotIntrinsicCandidate 250 public native double getDouble(Object o, long offset); 251 252 /** @see #putInt(Object, long, int) */ 253 @HotSpotIntrinsicCandidate 254 public native void putDouble(Object o, long offset, double x); 255 256 /** 257 * Fetches a native pointer from a given memory address. If the address is 258 * zero, or does not point into a block obtained from {@link 259 * #allocateMemory}, the results are undefined. 260 * 261 * <p>If the native pointer is less than 64 bits wide, it is extended as 262 * an unsigned number to a Java long. The pointer may be indexed by any 263 * given byte offset, simply by adding that offset (as a simple integer) to 264 * the long representing the pointer. The number of bytes actually read 265 * from the target address may be determined by consulting {@link 266 * #addressSize}. 267 * 268 * @see #allocateMemory 269 * @see #getInt(Object, long) 270 */ 271 @ForceInline 272 public long getAddress(Object o, long offset) { 273 if (ADDRESS_SIZE == 4) { 274 return Integer.toUnsignedLong(getInt(o, offset)); 275 } else { 276 return getLong(o, offset); 277 } 278 } 279 280 /** 281 * Stores a native pointer into a given memory address. If the address is 282 * zero, or does not point into a block obtained from {@link 283 * #allocateMemory}, the results are undefined. 284 * 285 * <p>The number of bytes actually written at the target address may be 286 * determined by consulting {@link #addressSize}. 287 * 288 * @see #allocateMemory 289 * @see #putInt(Object, long, int) 290 */ 291 @ForceInline 292 public void putAddress(Object o, long offset, long x) { 293 if (ADDRESS_SIZE == 4) { 294 putInt(o, offset, (int)x); 295 } else { 296 putLong(o, offset, x); 297 } 298 } 299 300 // These read VM internal data. 301 302 /** 303 * Fetches an uncompressed reference value from a given native variable 304 * ignoring the VM's compressed references mode. 305 * 306 * @param address a memory address locating the variable 307 * @return the value fetched from the indicated native variable 308 */ 309 public native Object getUncompressedObject(long address); 310 311 // These work on values in the C heap. 312 313 /** 314 * Fetches a value from a given memory address. If the address is zero, or 315 * does not point into a block obtained from {@link #allocateMemory}, the 316 * results are undefined. 317 * 318 * @see #allocateMemory 319 */ 320 @ForceInline 321 public byte getByte(long address) { 322 return getByte(null, address); 323 } 324 325 /** 326 * Stores a value into a given memory address. If the address is zero, or 327 * does not point into a block obtained from {@link #allocateMemory}, the 328 * results are undefined. 329 * 330 * @see #getByte(long) 331 */ 332 @ForceInline 333 public void putByte(long address, byte x) { 334 putByte(null, address, x); 335 } 336 337 /** @see #getByte(long) */ 338 @ForceInline 339 public short getShort(long address) { 340 return getShort(null, address); 341 } 342 343 /** @see #putByte(long, byte) */ 344 @ForceInline 345 public void putShort(long address, short x) { 346 putShort(null, address, x); 347 } 348 349 /** @see #getByte(long) */ 350 @ForceInline 351 public char getChar(long address) { 352 return getChar(null, address); 353 } 354 355 /** @see #putByte(long, byte) */ 356 @ForceInline 357 public void putChar(long address, char x) { 358 putChar(null, address, x); 359 } 360 361 /** @see #getByte(long) */ 362 @ForceInline 363 public int getInt(long address) { 364 return getInt(null, address); 365 } 366 367 /** @see #putByte(long, byte) */ 368 @ForceInline 369 public void putInt(long address, int x) { 370 putInt(null, address, x); 371 } 372 373 /** @see #getByte(long) */ 374 @ForceInline 375 public long getLong(long address) { 376 return getLong(null, address); 377 } 378 379 /** @see #putByte(long, byte) */ 380 @ForceInline 381 public void putLong(long address, long x) { 382 putLong(null, address, x); 383 } 384 385 /** @see #getByte(long) */ 386 @ForceInline 387 public float getFloat(long address) { 388 return getFloat(null, address); 389 } 390 391 /** @see #putByte(long, byte) */ 392 @ForceInline 393 public void putFloat(long address, float x) { 394 putFloat(null, address, x); 395 } 396 397 /** @see #getByte(long) */ 398 @ForceInline 399 public double getDouble(long address) { 400 return getDouble(null, address); 401 } 402 403 /** @see #putByte(long, byte) */ 404 @ForceInline 405 public void putDouble(long address, double x) { 406 putDouble(null, address, x); 407 } 408 409 /** @see #getAddress(Object, long) */ 410 @ForceInline 411 public long getAddress(long address) { 412 return getAddress(null, address); 413 } 414 415 /** @see #putAddress(Object, long, long) */ 416 @ForceInline 417 public void putAddress(long address, long x) { 418 putAddress(null, address, x); 419 } 420 421 422 423 /// helper methods for validating various types of objects/values 424 425 /** 426 * Create an exception reflecting that some of the input was invalid 427 * 428 * <em>Note:</em> It is the resposibility of the caller to make 429 * sure arguments are checked before the methods are called. While 430 * some rudimentary checks are performed on the input, the checks 431 * are best effort and when performance is an overriding priority, 432 * as when methods of this class are optimized by the runtime 433 * compiler, some or all checks (if any) may be elided. Hence, the 434 * caller must not rely on the checks and corresponding 435 * exceptions! 436 * 437 * @return an exception object 438 */ 439 private RuntimeException invalidInput() { 440 return new IllegalArgumentException(); 441 } 442 443 /** 444 * Check if a value is 32-bit clean (32 MSB are all zero) 445 * 446 * @param value the 64-bit value to check 447 * 448 * @return true if the value is 32-bit clean 449 */ 450 private boolean is32BitClean(long value) { 451 return value >>> 32 == 0; 452 } 453 454 /** 455 * Check the validity of a size (the equivalent of a size_t) 456 * 457 * @throws RuntimeException if the size is invalid 458 * (<em>Note:</em> after optimization, invalid inputs may 459 * go undetected, which will lead to unpredictable 460 * behavior) 461 */ 462 private void checkSize(long size) { 463 if (ADDRESS_SIZE == 4) { 464 // Note: this will also check for negative sizes 465 if (!is32BitClean(size)) { 466 throw invalidInput(); 467 } 468 } else if (size < 0) { 469 throw invalidInput(); 470 } 471 } 472 473 /** 474 * Check the validity of a native address (the equivalent of void*) 475 * 476 * @throws RuntimeException if the address is invalid 477 * (<em>Note:</em> after optimization, invalid inputs may 478 * go undetected, which will lead to unpredictable 479 * behavior) 480 */ 481 private void checkNativeAddress(long address) { 482 if (ADDRESS_SIZE == 4) { 483 // Accept both zero and sign extended pointers. A valid 484 // pointer will, after the +1 below, either have produced 485 // the value 0x0 or 0x1. Masking off the low bit allows 486 // for testing against 0. 487 if ((((address >> 32) + 1) & ~1) != 0) { 488 throw invalidInput(); 489 } 490 } 491 } 492 493 /** 494 * Check the validity of an offset, relative to a base object 495 * 496 * @param o the base object 497 * @param offset the offset to check 498 * 499 * @throws RuntimeException if the size is invalid 500 * (<em>Note:</em> after optimization, invalid inputs may 501 * go undetected, which will lead to unpredictable 502 * behavior) 503 */ 504 private void checkOffset(Object o, long offset) { 505 if (ADDRESS_SIZE == 4) { 506 // Note: this will also check for negative offsets 507 if (!is32BitClean(offset)) { 508 throw invalidInput(); 509 } 510 } else if (offset < 0) { 511 throw invalidInput(); 512 } 513 } 514 515 /** 516 * Check the validity of a double-register pointer 517 * 518 * Note: This code deliberately does *not* check for NPE for (at 519 * least) three reasons: 520 * 521 * 1) NPE is not just NULL/0 - there is a range of values all 522 * resulting in an NPE, which is not trivial to check for 523 * 524 * 2) It is the responsibility of the callers of Unsafe methods 525 * to verify the input, so throwing an exception here is not really 526 * useful - passing in a NULL pointer is a critical error and the 527 * must not expect an exception to be thrown anyway. 528 * 529 * 3) the actual operations will detect NULL pointers anyway by 530 * means of traps and signals (like SIGSEGV). 531 * 532 * @param o Java heap object, or null 533 * @param offset indication of where the variable resides in a Java heap 534 * object, if any, else a memory address locating the variable 535 * statically 536 * 537 * @throws RuntimeException if the pointer is invalid 538 * (<em>Note:</em> after optimization, invalid inputs may 539 * go undetected, which will lead to unpredictable 540 * behavior) 541 */ 542 private void checkPointer(Object o, long offset) { 543 if (o == null) { 544 checkNativeAddress(offset); 545 } else { 546 checkOffset(o, offset); 547 } 548 } 549 550 /** 551 * Check if a type is a primitive array type 552 * 553 * @param c the type to check 554 * 555 * @return true if the type is a primitive array type 556 */ 557 private void checkPrimitiveArray(Class<?> c) { 558 Class<?> componentType = c.getComponentType(); 559 if (componentType == null || !componentType.isPrimitive()) { 560 throw invalidInput(); 561 } 562 } 563 564 /** 565 * Check that a pointer is a valid primitive array type pointer 566 * 567 * Note: pointers off-heap are considered to be primitive arrays 568 * 569 * @throws RuntimeException if the pointer is invalid 570 * (<em>Note:</em> after optimization, invalid inputs may 571 * go undetected, which will lead to unpredictable 572 * behavior) 573 */ 574 private void checkPrimitivePointer(Object o, long offset) { 575 checkPointer(o, offset); 576 577 if (o != null) { 578 // If on heap, it must be a primitive array 579 checkPrimitiveArray(o.getClass()); 580 } 581 } 582 583 584 /// wrappers for malloc, realloc, free: 585 586 /** 587 * Allocates a new block of native memory, of the given size in bytes. The 588 * contents of the memory are uninitialized; they will generally be 589 * garbage. The resulting native pointer will never be zero, and will be 590 * aligned for all value types. Dispose of this memory by calling {@link 591 * #freeMemory}, or resize it with {@link #reallocateMemory}. 592 * 593 * <em>Note:</em> It is the resposibility of the caller to make 594 * sure arguments are checked before the methods are called. While 595 * some rudimentary checks are performed on the input, the checks 596 * are best effort and when performance is an overriding priority, 597 * as when methods of this class are optimized by the runtime 598 * compiler, some or all checks (if any) may be elided. Hence, the 599 * caller must not rely on the checks and corresponding 600 * exceptions! 601 * 602 * @throws RuntimeException if the size is negative or too large 603 * for the native size_t type 604 * 605 * @throws OutOfMemoryError if the allocation is refused by the system 606 * 607 * @see #getByte(long) 608 * @see #putByte(long, byte) 609 */ 610 public long allocateMemory(long bytes) { 611 allocateMemoryChecks(bytes); 612 613 if (bytes == 0) { 614 return 0; 615 } 616 617 long p = allocateMemory0(bytes); 618 if (p == 0) { 619 throw new OutOfMemoryError(); 620 } 621 622 return p; 623 } 624 625 /** 626 * Validate the arguments to allocateMemory 627 * 628 * @throws RuntimeException if the arguments are invalid 629 * (<em>Note:</em> after optimization, invalid inputs may 630 * go undetected, which will lead to unpredictable 631 * behavior) 632 */ 633 private void allocateMemoryChecks(long bytes) { 634 checkSize(bytes); 635 } 636 637 /** 638 * Resizes a new block of native memory, to the given size in bytes. The 639 * contents of the new block past the size of the old block are 640 * uninitialized; they will generally be garbage. The resulting native 641 * pointer will be zero if and only if the requested size is zero. The 642 * resulting native pointer will be aligned for all value types. Dispose 643 * of this memory by calling {@link #freeMemory}, or resize it with {@link 644 * #reallocateMemory}. The address passed to this method may be null, in 645 * which case an allocation will be performed. 646 * 647 * <em>Note:</em> It is the resposibility of the caller to make 648 * sure arguments are checked before the methods are called. While 649 * some rudimentary checks are performed on the input, the checks 650 * are best effort and when performance is an overriding priority, 651 * as when methods of this class are optimized by the runtime 652 * compiler, some or all checks (if any) may be elided. Hence, the 653 * caller must not rely on the checks and corresponding 654 * exceptions! 655 * 656 * @throws RuntimeException if the size is negative or too large 657 * for the native size_t type 658 * 659 * @throws OutOfMemoryError if the allocation is refused by the system 660 * 661 * @see #allocateMemory 662 */ 663 public long reallocateMemory(long address, long bytes) { 664 reallocateMemoryChecks(address, bytes); 665 666 if (bytes == 0) { 667 freeMemory(address); 668 return 0; 669 } 670 671 long p = (address == 0) ? allocateMemory0(bytes) : reallocateMemory0(address, bytes); 672 if (p == 0) { 673 throw new OutOfMemoryError(); 674 } 675 676 return p; 677 } 678 679 /** 680 * Validate the arguments to reallocateMemory 681 * 682 * @throws RuntimeException if the arguments are invalid 683 * (<em>Note:</em> after optimization, invalid inputs may 684 * go undetected, which will lead to unpredictable 685 * behavior) 686 */ 687 private void reallocateMemoryChecks(long address, long bytes) { 688 checkPointer(null, address); 689 checkSize(bytes); 690 } 691 692 /** 693 * Sets all bytes in a given block of memory to a fixed value 694 * (usually zero). 695 * 696 * <p>This method determines a block's base address by means of two parameters, 697 * and so it provides (in effect) a <em>double-register</em> addressing mode, 698 * as discussed in {@link #getInt(Object,long)}. When the object reference is null, 699 * the offset supplies an absolute base address. 700 * 701 * <p>The stores are in coherent (atomic) units of a size determined 702 * by the address and length parameters. If the effective address and 703 * length are all even modulo 8, the stores take place in 'long' units. 704 * If the effective address and length are (resp.) even modulo 4 or 2, 705 * the stores take place in units of 'int' or 'short'. 706 * 707 * <em>Note:</em> It is the resposibility of the caller to make 708 * sure arguments are checked before the methods are called. While 709 * some rudimentary checks are performed on the input, the checks 710 * are best effort and when performance is an overriding priority, 711 * as when methods of this class are optimized by the runtime 712 * compiler, some or all checks (if any) may be elided. Hence, the 713 * caller must not rely on the checks and corresponding 714 * exceptions! 715 * 716 * @throws RuntimeException if any of the arguments is invalid 717 * 718 * @since 1.7 719 */ 720 public void setMemory(Object o, long offset, long bytes, byte value) { 721 setMemoryChecks(o, offset, bytes, value); 722 723 if (bytes == 0) { 724 return; 725 } 726 727 setMemory0(o, offset, bytes, value); 728 } 729 730 /** 731 * Sets all bytes in a given block of memory to a fixed value 732 * (usually zero). This provides a <em>single-register</em> addressing mode, 733 * as discussed in {@link #getInt(Object,long)}. 734 * 735 * <p>Equivalent to {@code setMemory(null, address, bytes, value)}. 736 */ 737 public void setMemory(long address, long bytes, byte value) { 738 setMemory(null, address, bytes, value); 739 } 740 741 /** 742 * Validate the arguments to setMemory 743 * 744 * @throws RuntimeException if the arguments are invalid 745 * (<em>Note:</em> after optimization, invalid inputs may 746 * go undetected, which will lead to unpredictable 747 * behavior) 748 */ 749 private void setMemoryChecks(Object o, long offset, long bytes, byte value) { 750 checkPrimitivePointer(o, offset); 751 checkSize(bytes); 752 } 753 754 /** 755 * Sets all bytes in a given block of memory to a copy of another 756 * block. 757 * 758 * <p>This method determines each block's base address by means of two parameters, 759 * and so it provides (in effect) a <em>double-register</em> addressing mode, 760 * as discussed in {@link #getInt(Object,long)}. When the object reference is null, 761 * the offset supplies an absolute base address. 762 * 763 * <p>The transfers are in coherent (atomic) units of a size determined 764 * by the address and length parameters. If the effective addresses and 765 * length are all even modulo 8, the transfer takes place in 'long' units. 766 * If the effective addresses and length are (resp.) even modulo 4 or 2, 767 * the transfer takes place in units of 'int' or 'short'. 768 * 769 * <em>Note:</em> It is the resposibility of the caller to make 770 * sure arguments are checked before the methods are called. While 771 * some rudimentary checks are performed on the input, the checks 772 * are best effort and when performance is an overriding priority, 773 * as when methods of this class are optimized by the runtime 774 * compiler, some or all checks (if any) may be elided. Hence, the 775 * caller must not rely on the checks and corresponding 776 * exceptions! 777 * 778 * @throws RuntimeException if any of the arguments is invalid 779 * 780 * @since 1.7 781 */ 782 public void copyMemory(Object srcBase, long srcOffset, 783 Object destBase, long destOffset, 784 long bytes) { 785 copyMemoryChecks(srcBase, srcOffset, destBase, destOffset, bytes); 786 787 if (bytes == 0) { 788 return; 789 } 790 791 copyMemory0(srcBase, srcOffset, destBase, destOffset, bytes); 792 } 793 794 /** 795 * Sets all bytes in a given block of memory to a copy of another 796 * block. This provides a <em>single-register</em> addressing mode, 797 * as discussed in {@link #getInt(Object,long)}. 798 * 799 * Equivalent to {@code copyMemory(null, srcAddress, null, destAddress, bytes)}. 800 */ 801 public void copyMemory(long srcAddress, long destAddress, long bytes) { 802 copyMemory(null, srcAddress, null, destAddress, bytes); 803 } 804 805 /** 806 * Validate the arguments to copyMemory 807 * 808 * @throws RuntimeException if any of the arguments is invalid 809 * (<em>Note:</em> after optimization, invalid inputs may 810 * go undetected, which will lead to unpredictable 811 * behavior) 812 */ 813 private void copyMemoryChecks(Object srcBase, long srcOffset, 814 Object destBase, long destOffset, 815 long bytes) { 816 checkSize(bytes); 817 checkPrimitivePointer(srcBase, srcOffset); 818 checkPrimitivePointer(destBase, destOffset); 819 } 820 821 /** 822 * Copies all elements from one block of memory to another block, 823 * *unconditionally* byte swapping the elements on the fly. 824 * 825 * <p>This method determines each block's base address by means of two parameters, 826 * and so it provides (in effect) a <em>double-register</em> addressing mode, 827 * as discussed in {@link #getInt(Object,long)}. When the object reference is null, 828 * the offset supplies an absolute base address. 829 * 830 * <em>Note:</em> It is the resposibility of the caller to make 831 * sure arguments are checked before the methods are called. While 832 * some rudimentary checks are performed on the input, the checks 833 * are best effort and when performance is an overriding priority, 834 * as when methods of this class are optimized by the runtime 835 * compiler, some or all checks (if any) may be elided. Hence, the 836 * caller must not rely on the checks and corresponding 837 * exceptions! 838 * 839 * @throws RuntimeException if any of the arguments is invalid 840 * 841 * @since 9 842 */ 843 public void copySwapMemory(Object srcBase, long srcOffset, 844 Object destBase, long destOffset, 845 long bytes, long elemSize) { 846 copySwapMemoryChecks(srcBase, srcOffset, destBase, destOffset, bytes, elemSize); 847 848 if (bytes == 0) { 849 return; 850 } 851 852 copySwapMemory0(srcBase, srcOffset, destBase, destOffset, bytes, elemSize); 853 } 854 855 private void copySwapMemoryChecks(Object srcBase, long srcOffset, 856 Object destBase, long destOffset, 857 long bytes, long elemSize) { 858 checkSize(bytes); 859 860 if (elemSize != 2 && elemSize != 4 && elemSize != 8) { 861 throw invalidInput(); 862 } 863 if (bytes % elemSize != 0) { 864 throw invalidInput(); 865 } 866 867 checkPrimitivePointer(srcBase, srcOffset); 868 checkPrimitivePointer(destBase, destOffset); 869 } 870 871 /** 872 * Copies all elements from one block of memory to another block, byte swapping the 873 * elements on the fly. 874 * 875 * This provides a <em>single-register</em> addressing mode, as 876 * discussed in {@link #getInt(Object,long)}. 877 * 878 * Equivalent to {@code copySwapMemory(null, srcAddress, null, destAddress, bytes, elemSize)}. 879 */ 880 public void copySwapMemory(long srcAddress, long destAddress, long bytes, long elemSize) { 881 copySwapMemory(null, srcAddress, null, destAddress, bytes, elemSize); 882 } 883 884 /** 885 * Disposes of a block of native memory, as obtained from {@link 886 * #allocateMemory} or {@link #reallocateMemory}. The address passed to 887 * this method may be null, in which case no action is taken. 888 * 889 * <em>Note:</em> It is the resposibility of the caller to make 890 * sure arguments are checked before the methods are called. While 891 * some rudimentary checks are performed on the input, the checks 892 * are best effort and when performance is an overriding priority, 893 * as when methods of this class are optimized by the runtime 894 * compiler, some or all checks (if any) may be elided. Hence, the 895 * caller must not rely on the checks and corresponding 896 * exceptions! 897 * 898 * @throws RuntimeException if any of the arguments is invalid 899 * 900 * @see #allocateMemory 901 */ 902 public void freeMemory(long address) { 903 freeMemoryChecks(address); 904 905 if (address == 0) { 906 return; 907 } 908 909 freeMemory0(address); 910 } 911 912 /** 913 * Validate the arguments to freeMemory 914 * 915 * @throws RuntimeException if the arguments are invalid 916 * (<em>Note:</em> after optimization, invalid inputs may 917 * go undetected, which will lead to unpredictable 918 * behavior) 919 */ 920 private void freeMemoryChecks(long address) { 921 checkPointer(null, address); 922 } 923 924 /** 925 * Ensure writeback of a specified virtual memory address range 926 * from cache to physical memory. All bytes in the address range 927 * are guaranteed to have been written back to physical memory on 928 * return from this call i.e. subsequently executed store 929 * instructions are guaranteed not to be visible before the 930 * writeback is completed. 931 * 932 * @param address 933 * the lowest byte address that must be guaranteed written 934 * back to memory. bytes at lower addresses may also be 935 * written back. 936 * 937 * @param length 938 * the length in bytes of the region starting at address 939 * that must be guaranteed written back to memory. 940 * 941 * @throws RuntimeException if memory writeback is not supported 942 * on the current hardware of if the arguments are invalid. 943 * (<em>Note:</em> after optimization, invalid inputs may 944 * go undetected, which will lead to unpredictable 945 * behavior) 946 * 947 * @since 14 948 */ 949 950 public void writebackMemory(long address, long length) { 951 checkWritebackEnabled(); 952 checkWritebackMemory(address, length); 953 954 // perform any required pre-writeback barrier 955 writebackPreSync0(); 956 957 // write back one cache line at a time 958 long line = dataCacheLineAlignDown(address); 959 long end = address + length; 960 while (line < end) { 961 writeback0(line); 962 line += dataCacheLineFlushSize(); 963 } 964 965 // perform any required post-writeback barrier 966 writebackPostSync0(); 967 } 968 969 /** 970 * Validate the arguments to writebackMemory 971 * 972 * @throws RuntimeException if the arguments are invalid 973 * (<em>Note:</em> after optimization, invalid inputs may 974 * go undetected, which will lead to unpredictable 975 * behavior) 976 */ 977 private void checkWritebackMemory(long address, long length) { 978 checkNativeAddress(address); 979 checkSize(length); 980 } 981 982 /** 983 * Validate that the current hardware supports memory writeback. 984 * (<em>Note:</em> this is a belt and braces check. Clients are 985 * expected to test whether writeback is enabled by calling 986 * ({@link isWritebackEnabled #isWritebackEnabled} and avoid 987 * calling method {@link writeback #writeback} if it is disabled). 988 * 989 * 990 * @throws RuntimeException if memory writeback is not supported 991 */ 992 private void checkWritebackEnabled() { 993 if (!isWritebackEnabled()) { 994 throw new RuntimeException("writebackMemory not enabled!"); 995 } 996 } 997 998 /** 999 * force writeback of an individual cache line. 1000 * 1001 * @param address 1002 * the start address of the cache line to be written back 1003 */ 1004 @HotSpotIntrinsicCandidate 1005 private native void writeback0(long address); 1006 1007 /** 1008 * Serialize writeback operations relative to preceding memory writes. 1009 */ 1010 @HotSpotIntrinsicCandidate 1011 private native void writebackPreSync0(); 1012 1013 /** 1014 * Serialize writeback operations relative to following memory writes. 1015 */ 1016 @HotSpotIntrinsicCandidate 1017 private native void writebackPostSync0(); 1018 1019 /// random queries 1020 1021 /** 1022 * This constant differs from all results that will ever be returned from 1023 * {@link #staticFieldOffset}, {@link #objectFieldOffset}, 1024 * or {@link #arrayBaseOffset}. 1025 */ 1026 public static final int INVALID_FIELD_OFFSET = -1; 1027 1028 /** 1029 * Reports the location of a given field in the storage allocation of its 1030 * class. Do not expect to perform any sort of arithmetic on this offset; 1031 * it is just a cookie which is passed to the unsafe heap memory accessors. 1032 * 1033 * <p>Any given field will always have the same offset and base, and no 1034 * two distinct fields of the same class will ever have the same offset 1035 * and base. 1036 * 1037 * <p>As of 1.4.1, offsets for fields are represented as long values, 1038 * although the Sun JVM does not use the most significant 32 bits. 1039 * However, JVM implementations which store static fields at absolute 1040 * addresses can use long offsets and null base pointers to express 1041 * the field locations in a form usable by {@link #getInt(Object,long)}. 1042 * Therefore, code which will be ported to such JVMs on 64-bit platforms 1043 * must preserve all bits of static field offsets. 1044 * @see #getInt(Object, long) 1045 */ 1046 public long objectFieldOffset(Field f) { 1047 if (f == null) { 1048 throw new NullPointerException(); 1049 } 1050 1051 return objectFieldOffset0(f); 1052 } 1053 1054 /** 1055 * Reports the location of the field with a given name in the storage 1056 * allocation of its class. 1057 * 1058 * @throws NullPointerException if any parameter is {@code null}. 1059 * @throws InternalError if there is no field named {@code name} declared 1060 * in class {@code c}, i.e., if {@code c.getDeclaredField(name)} 1061 * would throw {@code java.lang.NoSuchFieldException}. 1062 * 1063 * @see #objectFieldOffset(Field) 1064 */ 1065 public long objectFieldOffset(Class<?> c, String name) { 1066 if (c == null || name == null) { 1067 throw new NullPointerException(); 1068 } 1069 1070 return objectFieldOffset1(c, name); 1071 } 1072 1073 /** 1074 * Reports the location of a given static field, in conjunction with {@link 1075 * #staticFieldBase}. 1076 * <p>Do not expect to perform any sort of arithmetic on this offset; 1077 * it is just a cookie which is passed to the unsafe heap memory accessors. 1078 * 1079 * <p>Any given field will always have the same offset, and no two distinct 1080 * fields of the same class will ever have the same offset. 1081 * 1082 * <p>As of 1.4.1, offsets for fields are represented as long values, 1083 * although the Sun JVM does not use the most significant 32 bits. 1084 * It is hard to imagine a JVM technology which needs more than 1085 * a few bits to encode an offset within a non-array object, 1086 * However, for consistency with other methods in this class, 1087 * this method reports its result as a long value. 1088 * @see #getInt(Object, long) 1089 */ 1090 public long staticFieldOffset(Field f) { 1091 if (f == null) { 1092 throw new NullPointerException(); 1093 } 1094 1095 return staticFieldOffset0(f); 1096 } 1097 1098 /** 1099 * Reports the location of a given static field, in conjunction with {@link 1100 * #staticFieldOffset}. 1101 * <p>Fetch the base "Object", if any, with which static fields of the 1102 * given class can be accessed via methods like {@link #getInt(Object, 1103 * long)}. This value may be null. This value may refer to an object 1104 * which is a "cookie", not guaranteed to be a real Object, and it should 1105 * not be used in any way except as argument to the get and put routines in 1106 * this class. 1107 */ 1108 public Object staticFieldBase(Field f) { 1109 if (f == null) { 1110 throw new NullPointerException(); 1111 } 1112 1113 return staticFieldBase0(f); 1114 } 1115 1116 /** 1117 * Detects if the given class may need to be initialized. This is often 1118 * needed in conjunction with obtaining the static field base of a 1119 * class. 1120 * @return false only if a call to {@code ensureClassInitialized} would have no effect 1121 */ 1122 public boolean shouldBeInitialized(Class<?> c) { 1123 if (c == null) { 1124 throw new NullPointerException(); 1125 } 1126 1127 return shouldBeInitialized0(c); 1128 } 1129 1130 /** 1131 * Ensures the given class has been initialized. This is often 1132 * needed in conjunction with obtaining the static field base of a 1133 * class. 1134 */ 1135 public void ensureClassInitialized(Class<?> c) { 1136 if (c == null) { 1137 throw new NullPointerException(); 1138 } 1139 1140 ensureClassInitialized0(c); 1141 } 1142 1143 /** 1144 * Reports the offset of the first element in the storage allocation of a 1145 * given array class. If {@link #arrayIndexScale} returns a non-zero value 1146 * for the same class, you may use that scale factor, together with this 1147 * base offset, to form new offsets to access elements of arrays of the 1148 * given class. 1149 * 1150 * @see #getInt(Object, long) 1151 * @see #putInt(Object, long, int) 1152 */ 1153 public int arrayBaseOffset(Class<?> arrayClass) { 1154 if (arrayClass == null) { 1155 throw new NullPointerException(); 1156 } 1157 1158 return arrayBaseOffset0(arrayClass); 1159 } 1160 1161 1162 /** The value of {@code arrayBaseOffset(boolean[].class)} */ 1163 public static final int ARRAY_BOOLEAN_BASE_OFFSET 1164 = theUnsafe.arrayBaseOffset(boolean[].class); 1165 1166 /** The value of {@code arrayBaseOffset(byte[].class)} */ 1167 public static final int ARRAY_BYTE_BASE_OFFSET 1168 = theUnsafe.arrayBaseOffset(byte[].class); 1169 1170 /** The value of {@code arrayBaseOffset(short[].class)} */ 1171 public static final int ARRAY_SHORT_BASE_OFFSET 1172 = theUnsafe.arrayBaseOffset(short[].class); 1173 1174 /** The value of {@code arrayBaseOffset(char[].class)} */ 1175 public static final int ARRAY_CHAR_BASE_OFFSET 1176 = theUnsafe.arrayBaseOffset(char[].class); 1177 1178 /** The value of {@code arrayBaseOffset(int[].class)} */ 1179 public static final int ARRAY_INT_BASE_OFFSET 1180 = theUnsafe.arrayBaseOffset(int[].class); 1181 1182 /** The value of {@code arrayBaseOffset(long[].class)} */ 1183 public static final int ARRAY_LONG_BASE_OFFSET 1184 = theUnsafe.arrayBaseOffset(long[].class); 1185 1186 /** The value of {@code arrayBaseOffset(float[].class)} */ 1187 public static final int ARRAY_FLOAT_BASE_OFFSET 1188 = theUnsafe.arrayBaseOffset(float[].class); 1189 1190 /** The value of {@code arrayBaseOffset(double[].class)} */ 1191 public static final int ARRAY_DOUBLE_BASE_OFFSET 1192 = theUnsafe.arrayBaseOffset(double[].class); 1193 1194 /** The value of {@code arrayBaseOffset(Object[].class)} */ 1195 public static final int ARRAY_OBJECT_BASE_OFFSET 1196 = theUnsafe.arrayBaseOffset(Object[].class); 1197 1198 /** 1199 * Reports the scale factor for addressing elements in the storage 1200 * allocation of a given array class. However, arrays of "narrow" types 1201 * will generally not work properly with accessors like {@link 1202 * #getByte(Object, long)}, so the scale factor for such classes is reported 1203 * as zero. 1204 * 1205 * @see #arrayBaseOffset 1206 * @see #getInt(Object, long) 1207 * @see #putInt(Object, long, int) 1208 */ 1209 public int arrayIndexScale(Class<?> arrayClass) { 1210 if (arrayClass == null) { 1211 throw new NullPointerException(); 1212 } 1213 1214 return arrayIndexScale0(arrayClass); 1215 } 1216 1217 1218 /** The value of {@code arrayIndexScale(boolean[].class)} */ 1219 public static final int ARRAY_BOOLEAN_INDEX_SCALE 1220 = theUnsafe.arrayIndexScale(boolean[].class); 1221 1222 /** The value of {@code arrayIndexScale(byte[].class)} */ 1223 public static final int ARRAY_BYTE_INDEX_SCALE 1224 = theUnsafe.arrayIndexScale(byte[].class); 1225 1226 /** The value of {@code arrayIndexScale(short[].class)} */ 1227 public static final int ARRAY_SHORT_INDEX_SCALE 1228 = theUnsafe.arrayIndexScale(short[].class); 1229 1230 /** The value of {@code arrayIndexScale(char[].class)} */ 1231 public static final int ARRAY_CHAR_INDEX_SCALE 1232 = theUnsafe.arrayIndexScale(char[].class); 1233 1234 /** The value of {@code arrayIndexScale(int[].class)} */ 1235 public static final int ARRAY_INT_INDEX_SCALE 1236 = theUnsafe.arrayIndexScale(int[].class); 1237 1238 /** The value of {@code arrayIndexScale(long[].class)} */ 1239 public static final int ARRAY_LONG_INDEX_SCALE 1240 = theUnsafe.arrayIndexScale(long[].class); 1241 1242 /** The value of {@code arrayIndexScale(float[].class)} */ 1243 public static final int ARRAY_FLOAT_INDEX_SCALE 1244 = theUnsafe.arrayIndexScale(float[].class); 1245 1246 /** The value of {@code arrayIndexScale(double[].class)} */ 1247 public static final int ARRAY_DOUBLE_INDEX_SCALE 1248 = theUnsafe.arrayIndexScale(double[].class); 1249 1250 /** The value of {@code arrayIndexScale(Object[].class)} */ 1251 public static final int ARRAY_OBJECT_INDEX_SCALE 1252 = theUnsafe.arrayIndexScale(Object[].class); 1253 1254 /** 1255 * Reports the size in bytes of a native pointer, as stored via {@link 1256 * #putAddress}. This value will be either 4 or 8. Note that the sizes of 1257 * other primitive types (as stored in native memory blocks) is determined 1258 * fully by their information content. 1259 */ 1260 public int addressSize() { 1261 return ADDRESS_SIZE; 1262 } 1263 1264 /** The value of {@code addressSize()} */ 1265 public static final int ADDRESS_SIZE = ADDRESS_SIZE0; 1266 1267 /** 1268 * Reports the size in bytes of a native memory page (whatever that is). 1269 * This value will always be a power of two. 1270 */ 1271 public int pageSize() { return PAGE_SIZE; } 1272 1273 /** 1274 * Reports the size in bytes of a data cache line written back by 1275 * the hardware cache line flush operation available to the JVM or 1276 * 0 if data cache line flushing is not enabled. 1277 */ 1278 public int dataCacheLineFlushSize() { return DATA_CACHE_LINE_FLUSH_SIZE; } 1279 1280 /** 1281 * Rounds down address to a data cache line boundary as 1282 * determined by {@link #dataCacheLineFlushSize} 1283 * @return the rounded down address 1284 */ 1285 public long dataCacheLineAlignDown(long address) { 1286 return (address & ~(DATA_CACHE_LINE_FLUSH_SIZE - 1)); 1287 } 1288 1289 /** 1290 * Returns true if data cache line writeback 1291 */ 1292 public static boolean isWritebackEnabled() { return DATA_CACHE_LINE_FLUSH_SIZE != 0; } 1293 1294 /// random trusted operations from JNI: 1295 1296 /** 1297 * Tells the VM to define a class, without security checks. By default, the 1298 * class loader and protection domain come from the caller's class. 1299 */ 1300 public Class<?> defineClass(String name, byte[] b, int off, int len, 1301 ClassLoader loader, 1302 ProtectionDomain protectionDomain) { 1303 if (b == null) { 1304 throw new NullPointerException(); 1305 } 1306 if (len < 0) { 1307 throw new ArrayIndexOutOfBoundsException(); 1308 } 1309 1310 return defineClass0(name, b, off, len, loader, protectionDomain); 1311 } 1312 1313 public native Class<?> defineClass0(String name, byte[] b, int off, int len, 1314 ClassLoader loader, 1315 ProtectionDomain protectionDomain); 1316 1317 /** 1318 * Defines a class but does not make it known to the class loader or system dictionary. 1319 * <p> 1320 * For each CP entry, the corresponding CP patch must either be null or have 1321 * the a format that matches its tag: 1322 * <ul> 1323 * <li>Integer, Long, Float, Double: the corresponding wrapper object type from java.lang 1324 * <li>Utf8: a string (must have suitable syntax if used as signature or name) 1325 * <li>Class: any java.lang.Class object 1326 * <li>String: any object (not just a java.lang.String) 1327 * <li>InterfaceMethodRef: (NYI) a method handle to invoke on that call site's arguments 1328 * </ul> 1329 * @param hostClass context for linkage, access control, protection domain, and class loader 1330 * @param data bytes of a class file 1331 * @param cpPatches where non-null entries exist, they replace corresponding CP entries in data 1332 */ 1333 public Class<?> defineAnonymousClass(Class<?> hostClass, byte[] data, Object[] cpPatches) { 1334 if (hostClass == null || data == null) { 1335 throw new NullPointerException(); 1336 } 1337 if (hostClass.isArray() || hostClass.isPrimitive()) { 1338 throw new IllegalArgumentException(); 1339 } 1340 1341 return defineAnonymousClass0(hostClass, data, cpPatches); 1342 } 1343 1344 /** 1345 * Allocates an instance but does not run any constructor. 1346 * Initializes the class if it has not yet been. 1347 */ 1348 @HotSpotIntrinsicCandidate 1349 public native Object allocateInstance(Class<?> cls) 1350 throws InstantiationException; 1351 1352 /** 1353 * Allocates an array of a given type, but does not do zeroing. 1354 * <p> 1355 * This method should only be used in the very rare cases where a high-performance code 1356 * overwrites the destination array completely, and compilers cannot assist in zeroing elimination. 1357 * In an overwhelming majority of cases, a normal Java allocation should be used instead. 1358 * <p> 1359 * Users of this method are <b>required</b> to overwrite the initial (garbage) array contents 1360 * before allowing untrusted code, or code in other threads, to observe the reference 1361 * to the newly allocated array. In addition, the publication of the array reference must be 1362 * safe according to the Java Memory Model requirements. 1363 * <p> 1364 * The safest approach to deal with an uninitialized array is to keep the reference to it in local 1365 * variable at least until the initialization is complete, and then publish it <b>once</b>, either 1366 * by writing it to a <em>volatile</em> field, or storing it into a <em>final</em> field in constructor, 1367 * or issuing a {@link #storeFence} before publishing the reference. 1368 * <p> 1369 * @implnote This method can only allocate primitive arrays, to avoid garbage reference 1370 * elements that could break heap integrity. 1371 * 1372 * @param componentType array component type to allocate 1373 * @param length array size to allocate 1374 * @throws IllegalArgumentException if component type is null, or not a primitive class; 1375 * or the length is negative 1376 */ 1377 public Object allocateUninitializedArray(Class<?> componentType, int length) { 1378 if (componentType == null) { 1379 throw new IllegalArgumentException("Component type is null"); 1380 } 1381 if (!componentType.isPrimitive()) { 1382 throw new IllegalArgumentException("Component type is not primitive"); 1383 } 1384 if (length < 0) { 1385 throw new IllegalArgumentException("Negative length"); 1386 } 1387 return allocateUninitializedArray0(componentType, length); 1388 } 1389 1390 @HotSpotIntrinsicCandidate 1391 private Object allocateUninitializedArray0(Class<?> componentType, int length) { 1392 // These fallbacks provide zeroed arrays, but intrinsic is not required to 1393 // return the zeroed arrays. 1394 if (componentType == byte.class) return new byte[length]; 1395 if (componentType == boolean.class) return new boolean[length]; 1396 if (componentType == short.class) return new short[length]; 1397 if (componentType == char.class) return new char[length]; 1398 if (componentType == int.class) return new int[length]; 1399 if (componentType == float.class) return new float[length]; 1400 if (componentType == long.class) return new long[length]; 1401 if (componentType == double.class) return new double[length]; 1402 return null; 1403 } 1404 1405 /** Throws the exception without telling the verifier. */ 1406 public native void throwException(Throwable ee); 1407 1408 /** 1409 * Atomically updates Java variable to {@code x} if it is currently 1410 * holding {@code expected}. 1411 * 1412 * <p>This operation has memory semantics of a {@code volatile} read 1413 * and write. Corresponds to C11 atomic_compare_exchange_strong. 1414 * 1415 * @return {@code true} if successful 1416 */ 1417 @HotSpotIntrinsicCandidate 1418 public final native boolean compareAndSetReference(Object o, long offset, 1419 Object expected, 1420 Object x); 1421 1422 @HotSpotIntrinsicCandidate 1423 public final native Object compareAndExchangeReference(Object o, long offset, 1424 Object expected, 1425 Object x); 1426 1427 @HotSpotIntrinsicCandidate 1428 public final Object compareAndExchangeReferenceAcquire(Object o, long offset, 1429 Object expected, 1430 Object x) { 1431 return compareAndExchangeReference(o, offset, expected, x); 1432 } 1433 1434 @HotSpotIntrinsicCandidate 1435 public final Object compareAndExchangeReferenceRelease(Object o, long offset, 1436 Object expected, 1437 Object x) { 1438 return compareAndExchangeReference(o, offset, expected, x); 1439 } 1440 1441 @HotSpotIntrinsicCandidate 1442 public final boolean weakCompareAndSetReferencePlain(Object o, long offset, 1443 Object expected, 1444 Object x) { 1445 return compareAndSetReference(o, offset, expected, x); 1446 } 1447 1448 @HotSpotIntrinsicCandidate 1449 public final boolean weakCompareAndSetReferenceAcquire(Object o, long offset, 1450 Object expected, 1451 Object x) { 1452 return compareAndSetReference(o, offset, expected, x); 1453 } 1454 1455 @HotSpotIntrinsicCandidate 1456 public final boolean weakCompareAndSetReferenceRelease(Object o, long offset, 1457 Object expected, 1458 Object x) { 1459 return compareAndSetReference(o, offset, expected, x); 1460 } 1461 1462 @HotSpotIntrinsicCandidate 1463 public final boolean weakCompareAndSetReference(Object o, long offset, 1464 Object expected, 1465 Object x) { 1466 return compareAndSetReference(o, offset, expected, x); 1467 } 1468 1469 /** 1470 * Atomically updates Java variable to {@code x} if it is currently 1471 * holding {@code expected}. 1472 * 1473 * <p>This operation has memory semantics of a {@code volatile} read 1474 * and write. Corresponds to C11 atomic_compare_exchange_strong. 1475 * 1476 * @return {@code true} if successful 1477 */ 1478 @HotSpotIntrinsicCandidate 1479 public final native boolean compareAndSetInt(Object o, long offset, 1480 int expected, 1481 int x); 1482 1483 @HotSpotIntrinsicCandidate 1484 public final native int compareAndExchangeInt(Object o, long offset, 1485 int expected, 1486 int x); 1487 1488 @HotSpotIntrinsicCandidate 1489 public final int compareAndExchangeIntAcquire(Object o, long offset, 1490 int expected, 1491 int x) { 1492 return compareAndExchangeInt(o, offset, expected, x); 1493 } 1494 1495 @HotSpotIntrinsicCandidate 1496 public final int compareAndExchangeIntRelease(Object o, long offset, 1497 int expected, 1498 int x) { 1499 return compareAndExchangeInt(o, offset, expected, x); 1500 } 1501 1502 @HotSpotIntrinsicCandidate 1503 public final boolean weakCompareAndSetIntPlain(Object o, long offset, 1504 int expected, 1505 int x) { 1506 return compareAndSetInt(o, offset, expected, x); 1507 } 1508 1509 @HotSpotIntrinsicCandidate 1510 public final boolean weakCompareAndSetIntAcquire(Object o, long offset, 1511 int expected, 1512 int x) { 1513 return compareAndSetInt(o, offset, expected, x); 1514 } 1515 1516 @HotSpotIntrinsicCandidate 1517 public final boolean weakCompareAndSetIntRelease(Object o, long offset, 1518 int expected, 1519 int x) { 1520 return compareAndSetInt(o, offset, expected, x); 1521 } 1522 1523 @HotSpotIntrinsicCandidate 1524 public final boolean weakCompareAndSetInt(Object o, long offset, 1525 int expected, 1526 int x) { 1527 return compareAndSetInt(o, offset, expected, x); 1528 } 1529 1530 @HotSpotIntrinsicCandidate 1531 public final byte compareAndExchangeByte(Object o, long offset, 1532 byte expected, 1533 byte x) { 1534 long wordOffset = offset & ~3; 1535 int shift = (int) (offset & 3) << 3; 1536 if (BIG_ENDIAN) { 1537 shift = 24 - shift; 1538 } 1539 int mask = 0xFF << shift; 1540 int maskedExpected = (expected & 0xFF) << shift; 1541 int maskedX = (x & 0xFF) << shift; 1542 int fullWord; 1543 do { 1544 fullWord = getIntVolatile(o, wordOffset); 1545 if ((fullWord & mask) != maskedExpected) 1546 return (byte) ((fullWord & mask) >> shift); 1547 } while (!weakCompareAndSetInt(o, wordOffset, 1548 fullWord, (fullWord & ~mask) | maskedX)); 1549 return expected; 1550 } 1551 1552 @HotSpotIntrinsicCandidate 1553 public final boolean compareAndSetByte(Object o, long offset, 1554 byte expected, 1555 byte x) { 1556 return compareAndExchangeByte(o, offset, expected, x) == expected; 1557 } 1558 1559 @HotSpotIntrinsicCandidate 1560 public final boolean weakCompareAndSetByte(Object o, long offset, 1561 byte expected, 1562 byte x) { 1563 return compareAndSetByte(o, offset, expected, x); 1564 } 1565 1566 @HotSpotIntrinsicCandidate 1567 public final boolean weakCompareAndSetByteAcquire(Object o, long offset, 1568 byte expected, 1569 byte x) { 1570 return weakCompareAndSetByte(o, offset, expected, x); 1571 } 1572 1573 @HotSpotIntrinsicCandidate 1574 public final boolean weakCompareAndSetByteRelease(Object o, long offset, 1575 byte expected, 1576 byte x) { 1577 return weakCompareAndSetByte(o, offset, expected, x); 1578 } 1579 1580 @HotSpotIntrinsicCandidate 1581 public final boolean weakCompareAndSetBytePlain(Object o, long offset, 1582 byte expected, 1583 byte x) { 1584 return weakCompareAndSetByte(o, offset, expected, x); 1585 } 1586 1587 @HotSpotIntrinsicCandidate 1588 public final byte compareAndExchangeByteAcquire(Object o, long offset, 1589 byte expected, 1590 byte x) { 1591 return compareAndExchangeByte(o, offset, expected, x); 1592 } 1593 1594 @HotSpotIntrinsicCandidate 1595 public final byte compareAndExchangeByteRelease(Object o, long offset, 1596 byte expected, 1597 byte x) { 1598 return compareAndExchangeByte(o, offset, expected, x); 1599 } 1600 1601 @HotSpotIntrinsicCandidate 1602 public final short compareAndExchangeShort(Object o, long offset, 1603 short expected, 1604 short x) { 1605 if ((offset & 3) == 3) { 1606 throw new IllegalArgumentException("Update spans the word, not supported"); 1607 } 1608 long wordOffset = offset & ~3; 1609 int shift = (int) (offset & 3) << 3; 1610 if (BIG_ENDIAN) { 1611 shift = 16 - shift; 1612 } 1613 int mask = 0xFFFF << shift; 1614 int maskedExpected = (expected & 0xFFFF) << shift; 1615 int maskedX = (x & 0xFFFF) << shift; 1616 int fullWord; 1617 do { 1618 fullWord = getIntVolatile(o, wordOffset); 1619 if ((fullWord & mask) != maskedExpected) { 1620 return (short) ((fullWord & mask) >> shift); 1621 } 1622 } while (!weakCompareAndSetInt(o, wordOffset, 1623 fullWord, (fullWord & ~mask) | maskedX)); 1624 return expected; 1625 } 1626 1627 @HotSpotIntrinsicCandidate 1628 public final boolean compareAndSetShort(Object o, long offset, 1629 short expected, 1630 short x) { 1631 return compareAndExchangeShort(o, offset, expected, x) == expected; 1632 } 1633 1634 @HotSpotIntrinsicCandidate 1635 public final boolean weakCompareAndSetShort(Object o, long offset, 1636 short expected, 1637 short x) { 1638 return compareAndSetShort(o, offset, expected, x); 1639 } 1640 1641 @HotSpotIntrinsicCandidate 1642 public final boolean weakCompareAndSetShortAcquire(Object o, long offset, 1643 short expected, 1644 short x) { 1645 return weakCompareAndSetShort(o, offset, expected, x); 1646 } 1647 1648 @HotSpotIntrinsicCandidate 1649 public final boolean weakCompareAndSetShortRelease(Object o, long offset, 1650 short expected, 1651 short x) { 1652 return weakCompareAndSetShort(o, offset, expected, x); 1653 } 1654 1655 @HotSpotIntrinsicCandidate 1656 public final boolean weakCompareAndSetShortPlain(Object o, long offset, 1657 short expected, 1658 short x) { 1659 return weakCompareAndSetShort(o, offset, expected, x); 1660 } 1661 1662 1663 @HotSpotIntrinsicCandidate 1664 public final short compareAndExchangeShortAcquire(Object o, long offset, 1665 short expected, 1666 short x) { 1667 return compareAndExchangeShort(o, offset, expected, x); 1668 } 1669 1670 @HotSpotIntrinsicCandidate 1671 public final short compareAndExchangeShortRelease(Object o, long offset, 1672 short expected, 1673 short x) { 1674 return compareAndExchangeShort(o, offset, expected, x); 1675 } 1676 1677 @ForceInline 1678 private char s2c(short s) { 1679 return (char) s; 1680 } 1681 1682 @ForceInline 1683 private short c2s(char s) { 1684 return (short) s; 1685 } 1686 1687 @ForceInline 1688 public final boolean compareAndSetChar(Object o, long offset, 1689 char expected, 1690 char x) { 1691 return compareAndSetShort(o, offset, c2s(expected), c2s(x)); 1692 } 1693 1694 @ForceInline 1695 public final char compareAndExchangeChar(Object o, long offset, 1696 char expected, 1697 char x) { 1698 return s2c(compareAndExchangeShort(o, offset, c2s(expected), c2s(x))); 1699 } 1700 1701 @ForceInline 1702 public final char compareAndExchangeCharAcquire(Object o, long offset, 1703 char expected, 1704 char x) { 1705 return s2c(compareAndExchangeShortAcquire(o, offset, c2s(expected), c2s(x))); 1706 } 1707 1708 @ForceInline 1709 public final char compareAndExchangeCharRelease(Object o, long offset, 1710 char expected, 1711 char x) { 1712 return s2c(compareAndExchangeShortRelease(o, offset, c2s(expected), c2s(x))); 1713 } 1714 1715 @ForceInline 1716 public final boolean weakCompareAndSetChar(Object o, long offset, 1717 char expected, 1718 char x) { 1719 return weakCompareAndSetShort(o, offset, c2s(expected), c2s(x)); 1720 } 1721 1722 @ForceInline 1723 public final boolean weakCompareAndSetCharAcquire(Object o, long offset, 1724 char expected, 1725 char x) { 1726 return weakCompareAndSetShortAcquire(o, offset, c2s(expected), c2s(x)); 1727 } 1728 1729 @ForceInline 1730 public final boolean weakCompareAndSetCharRelease(Object o, long offset, 1731 char expected, 1732 char x) { 1733 return weakCompareAndSetShortRelease(o, offset, c2s(expected), c2s(x)); 1734 } 1735 1736 @ForceInline 1737 public final boolean weakCompareAndSetCharPlain(Object o, long offset, 1738 char expected, 1739 char x) { 1740 return weakCompareAndSetShortPlain(o, offset, c2s(expected), c2s(x)); 1741 } 1742 1743 /** 1744 * The JVM converts integral values to boolean values using two 1745 * different conventions, byte testing against zero and truncation 1746 * to least-significant bit. 1747 * 1748 * <p>The JNI documents specify that, at least for returning 1749 * values from native methods, a Java boolean value is converted 1750 * to the value-set 0..1 by first truncating to a byte (0..255 or 1751 * maybe -128..127) and then testing against zero. Thus, Java 1752 * booleans in non-Java data structures are by convention 1753 * represented as 8-bit containers containing either zero (for 1754 * false) or any non-zero value (for true). 1755 * 1756 * <p>Java booleans in the heap are also stored in bytes, but are 1757 * strongly normalized to the value-set 0..1 (i.e., they are 1758 * truncated to the least-significant bit). 1759 * 1760 * <p>The main reason for having different conventions for 1761 * conversion is performance: Truncation to the least-significant 1762 * bit can be usually implemented with fewer (machine) 1763 * instructions than byte testing against zero. 1764 * 1765 * <p>A number of Unsafe methods load boolean values from the heap 1766 * as bytes. Unsafe converts those values according to the JNI 1767 * rules (i.e, using the "testing against zero" convention). The 1768 * method {@code byte2bool} implements that conversion. 1769 * 1770 * @param b the byte to be converted to boolean 1771 * @return the result of the conversion 1772 */ 1773 @ForceInline 1774 private boolean byte2bool(byte b) { 1775 return b != 0; 1776 } 1777 1778 /** 1779 * Convert a boolean value to a byte. The return value is strongly 1780 * normalized to the value-set 0..1 (i.e., the value is truncated 1781 * to the least-significant bit). See {@link #byte2bool(byte)} for 1782 * more details on conversion conventions. 1783 * 1784 * @param b the boolean to be converted to byte (and then normalized) 1785 * @return the result of the conversion 1786 */ 1787 @ForceInline 1788 private byte bool2byte(boolean b) { 1789 return b ? (byte)1 : (byte)0; 1790 } 1791 1792 @ForceInline 1793 public final boolean compareAndSetBoolean(Object o, long offset, 1794 boolean expected, 1795 boolean x) { 1796 return compareAndSetByte(o, offset, bool2byte(expected), bool2byte(x)); 1797 } 1798 1799 @ForceInline 1800 public final boolean compareAndExchangeBoolean(Object o, long offset, 1801 boolean expected, 1802 boolean x) { 1803 return byte2bool(compareAndExchangeByte(o, offset, bool2byte(expected), bool2byte(x))); 1804 } 1805 1806 @ForceInline 1807 public final boolean compareAndExchangeBooleanAcquire(Object o, long offset, 1808 boolean expected, 1809 boolean x) { 1810 return byte2bool(compareAndExchangeByteAcquire(o, offset, bool2byte(expected), bool2byte(x))); 1811 } 1812 1813 @ForceInline 1814 public final boolean compareAndExchangeBooleanRelease(Object o, long offset, 1815 boolean expected, 1816 boolean x) { 1817 return byte2bool(compareAndExchangeByteRelease(o, offset, bool2byte(expected), bool2byte(x))); 1818 } 1819 1820 @ForceInline 1821 public final boolean weakCompareAndSetBoolean(Object o, long offset, 1822 boolean expected, 1823 boolean x) { 1824 return weakCompareAndSetByte(o, offset, bool2byte(expected), bool2byte(x)); 1825 } 1826 1827 @ForceInline 1828 public final boolean weakCompareAndSetBooleanAcquire(Object o, long offset, 1829 boolean expected, 1830 boolean x) { 1831 return weakCompareAndSetByteAcquire(o, offset, bool2byte(expected), bool2byte(x)); 1832 } 1833 1834 @ForceInline 1835 public final boolean weakCompareAndSetBooleanRelease(Object o, long offset, 1836 boolean expected, 1837 boolean x) { 1838 return weakCompareAndSetByteRelease(o, offset, bool2byte(expected), bool2byte(x)); 1839 } 1840 1841 @ForceInline 1842 public final boolean weakCompareAndSetBooleanPlain(Object o, long offset, 1843 boolean expected, 1844 boolean x) { 1845 return weakCompareAndSetBytePlain(o, offset, bool2byte(expected), bool2byte(x)); 1846 } 1847 1848 /** 1849 * Atomically updates Java variable to {@code x} if it is currently 1850 * holding {@code expected}. 1851 * 1852 * <p>This operation has memory semantics of a {@code volatile} read 1853 * and write. Corresponds to C11 atomic_compare_exchange_strong. 1854 * 1855 * @return {@code true} if successful 1856 */ 1857 @ForceInline 1858 public final boolean compareAndSetFloat(Object o, long offset, 1859 float expected, 1860 float x) { 1861 return compareAndSetInt(o, offset, 1862 Float.floatToRawIntBits(expected), 1863 Float.floatToRawIntBits(x)); 1864 } 1865 1866 @ForceInline 1867 public final float compareAndExchangeFloat(Object o, long offset, 1868 float expected, 1869 float x) { 1870 int w = compareAndExchangeInt(o, offset, 1871 Float.floatToRawIntBits(expected), 1872 Float.floatToRawIntBits(x)); 1873 return Float.intBitsToFloat(w); 1874 } 1875 1876 @ForceInline 1877 public final float compareAndExchangeFloatAcquire(Object o, long offset, 1878 float expected, 1879 float x) { 1880 int w = compareAndExchangeIntAcquire(o, offset, 1881 Float.floatToRawIntBits(expected), 1882 Float.floatToRawIntBits(x)); 1883 return Float.intBitsToFloat(w); 1884 } 1885 1886 @ForceInline 1887 public final float compareAndExchangeFloatRelease(Object o, long offset, 1888 float expected, 1889 float x) { 1890 int w = compareAndExchangeIntRelease(o, offset, 1891 Float.floatToRawIntBits(expected), 1892 Float.floatToRawIntBits(x)); 1893 return Float.intBitsToFloat(w); 1894 } 1895 1896 @ForceInline 1897 public final boolean weakCompareAndSetFloatPlain(Object o, long offset, 1898 float expected, 1899 float x) { 1900 return weakCompareAndSetIntPlain(o, offset, 1901 Float.floatToRawIntBits(expected), 1902 Float.floatToRawIntBits(x)); 1903 } 1904 1905 @ForceInline 1906 public final boolean weakCompareAndSetFloatAcquire(Object o, long offset, 1907 float expected, 1908 float x) { 1909 return weakCompareAndSetIntAcquire(o, offset, 1910 Float.floatToRawIntBits(expected), 1911 Float.floatToRawIntBits(x)); 1912 } 1913 1914 @ForceInline 1915 public final boolean weakCompareAndSetFloatRelease(Object o, long offset, 1916 float expected, 1917 float x) { 1918 return weakCompareAndSetIntRelease(o, offset, 1919 Float.floatToRawIntBits(expected), 1920 Float.floatToRawIntBits(x)); 1921 } 1922 1923 @ForceInline 1924 public final boolean weakCompareAndSetFloat(Object o, long offset, 1925 float expected, 1926 float x) { 1927 return weakCompareAndSetInt(o, offset, 1928 Float.floatToRawIntBits(expected), 1929 Float.floatToRawIntBits(x)); 1930 } 1931 1932 /** 1933 * Atomically updates Java variable to {@code x} if it is currently 1934 * holding {@code expected}. 1935 * 1936 * <p>This operation has memory semantics of a {@code volatile} read 1937 * and write. Corresponds to C11 atomic_compare_exchange_strong. 1938 * 1939 * @return {@code true} if successful 1940 */ 1941 @ForceInline 1942 public final boolean compareAndSetDouble(Object o, long offset, 1943 double expected, 1944 double x) { 1945 return compareAndSetLong(o, offset, 1946 Double.doubleToRawLongBits(expected), 1947 Double.doubleToRawLongBits(x)); 1948 } 1949 1950 @ForceInline 1951 public final double compareAndExchangeDouble(Object o, long offset, 1952 double expected, 1953 double x) { 1954 long w = compareAndExchangeLong(o, offset, 1955 Double.doubleToRawLongBits(expected), 1956 Double.doubleToRawLongBits(x)); 1957 return Double.longBitsToDouble(w); 1958 } 1959 1960 @ForceInline 1961 public final double compareAndExchangeDoubleAcquire(Object o, long offset, 1962 double expected, 1963 double x) { 1964 long w = compareAndExchangeLongAcquire(o, offset, 1965 Double.doubleToRawLongBits(expected), 1966 Double.doubleToRawLongBits(x)); 1967 return Double.longBitsToDouble(w); 1968 } 1969 1970 @ForceInline 1971 public final double compareAndExchangeDoubleRelease(Object o, long offset, 1972 double expected, 1973 double x) { 1974 long w = compareAndExchangeLongRelease(o, offset, 1975 Double.doubleToRawLongBits(expected), 1976 Double.doubleToRawLongBits(x)); 1977 return Double.longBitsToDouble(w); 1978 } 1979 1980 @ForceInline 1981 public final boolean weakCompareAndSetDoublePlain(Object o, long offset, 1982 double expected, 1983 double x) { 1984 return weakCompareAndSetLongPlain(o, offset, 1985 Double.doubleToRawLongBits(expected), 1986 Double.doubleToRawLongBits(x)); 1987 } 1988 1989 @ForceInline 1990 public final boolean weakCompareAndSetDoubleAcquire(Object o, long offset, 1991 double expected, 1992 double x) { 1993 return weakCompareAndSetLongAcquire(o, offset, 1994 Double.doubleToRawLongBits(expected), 1995 Double.doubleToRawLongBits(x)); 1996 } 1997 1998 @ForceInline 1999 public final boolean weakCompareAndSetDoubleRelease(Object o, long offset, 2000 double expected, 2001 double x) { 2002 return weakCompareAndSetLongRelease(o, offset, 2003 Double.doubleToRawLongBits(expected), 2004 Double.doubleToRawLongBits(x)); 2005 } 2006 2007 @ForceInline 2008 public final boolean weakCompareAndSetDouble(Object o, long offset, 2009 double expected, 2010 double x) { 2011 return weakCompareAndSetLong(o, offset, 2012 Double.doubleToRawLongBits(expected), 2013 Double.doubleToRawLongBits(x)); 2014 } 2015 2016 /** 2017 * Atomically updates Java variable to {@code x} if it is currently 2018 * holding {@code expected}. 2019 * 2020 * <p>This operation has memory semantics of a {@code volatile} read 2021 * and write. Corresponds to C11 atomic_compare_exchange_strong. 2022 * 2023 * @return {@code true} if successful 2024 */ 2025 @HotSpotIntrinsicCandidate 2026 public final native boolean compareAndSetLong(Object o, long offset, 2027 long expected, 2028 long x); 2029 2030 @HotSpotIntrinsicCandidate 2031 public final native long compareAndExchangeLong(Object o, long offset, 2032 long expected, 2033 long x); 2034 2035 @HotSpotIntrinsicCandidate 2036 public final long compareAndExchangeLongAcquire(Object o, long offset, 2037 long expected, 2038 long x) { 2039 return compareAndExchangeLong(o, offset, expected, x); 2040 } 2041 2042 @HotSpotIntrinsicCandidate 2043 public final long compareAndExchangeLongRelease(Object o, long offset, 2044 long expected, 2045 long x) { 2046 return compareAndExchangeLong(o, offset, expected, x); 2047 } 2048 2049 @HotSpotIntrinsicCandidate 2050 public final boolean weakCompareAndSetLongPlain(Object o, long offset, 2051 long expected, 2052 long x) { 2053 return compareAndSetLong(o, offset, expected, x); 2054 } 2055 2056 @HotSpotIntrinsicCandidate 2057 public final boolean weakCompareAndSetLongAcquire(Object o, long offset, 2058 long expected, 2059 long x) { 2060 return compareAndSetLong(o, offset, expected, x); 2061 } 2062 2063 @HotSpotIntrinsicCandidate 2064 public final boolean weakCompareAndSetLongRelease(Object o, long offset, 2065 long expected, 2066 long x) { 2067 return compareAndSetLong(o, offset, expected, x); 2068 } 2069 2070 @HotSpotIntrinsicCandidate 2071 public final boolean weakCompareAndSetLong(Object o, long offset, 2072 long expected, 2073 long x) { 2074 return compareAndSetLong(o, offset, expected, x); 2075 } 2076 2077 /** 2078 * Fetches a reference value from a given Java variable, with volatile 2079 * load semantics. Otherwise identical to {@link #getReference(Object, long)} 2080 */ 2081 @HotSpotIntrinsicCandidate 2082 public native Object getReferenceVolatile(Object o, long offset); 2083 2084 /** 2085 * Stores a reference value into a given Java variable, with 2086 * volatile store semantics. Otherwise identical to {@link #putReference(Object, long, Object)} 2087 */ 2088 @HotSpotIntrinsicCandidate 2089 public native void putReferenceVolatile(Object o, long offset, Object x); 2090 2091 /** Volatile version of {@link #getInt(Object, long)} */ 2092 @HotSpotIntrinsicCandidate 2093 public native int getIntVolatile(Object o, long offset); 2094 2095 /** Volatile version of {@link #putInt(Object, long, int)} */ 2096 @HotSpotIntrinsicCandidate 2097 public native void putIntVolatile(Object o, long offset, int x); 2098 2099 /** Volatile version of {@link #getBoolean(Object, long)} */ 2100 @HotSpotIntrinsicCandidate 2101 public native boolean getBooleanVolatile(Object o, long offset); 2102 2103 /** Volatile version of {@link #putBoolean(Object, long, boolean)} */ 2104 @HotSpotIntrinsicCandidate 2105 public native void putBooleanVolatile(Object o, long offset, boolean x); 2106 2107 /** Volatile version of {@link #getByte(Object, long)} */ 2108 @HotSpotIntrinsicCandidate 2109 public native byte getByteVolatile(Object o, long offset); 2110 2111 /** Volatile version of {@link #putByte(Object, long, byte)} */ 2112 @HotSpotIntrinsicCandidate 2113 public native void putByteVolatile(Object o, long offset, byte x); 2114 2115 /** Volatile version of {@link #getShort(Object, long)} */ 2116 @HotSpotIntrinsicCandidate 2117 public native short getShortVolatile(Object o, long offset); 2118 2119 /** Volatile version of {@link #putShort(Object, long, short)} */ 2120 @HotSpotIntrinsicCandidate 2121 public native void putShortVolatile(Object o, long offset, short x); 2122 2123 /** Volatile version of {@link #getChar(Object, long)} */ 2124 @HotSpotIntrinsicCandidate 2125 public native char getCharVolatile(Object o, long offset); 2126 2127 /** Volatile version of {@link #putChar(Object, long, char)} */ 2128 @HotSpotIntrinsicCandidate 2129 public native void putCharVolatile(Object o, long offset, char x); 2130 2131 /** Volatile version of {@link #getLong(Object, long)} */ 2132 @HotSpotIntrinsicCandidate 2133 public native long getLongVolatile(Object o, long offset); 2134 2135 /** Volatile version of {@link #putLong(Object, long, long)} */ 2136 @HotSpotIntrinsicCandidate 2137 public native void putLongVolatile(Object o, long offset, long x); 2138 2139 /** Volatile version of {@link #getFloat(Object, long)} */ 2140 @HotSpotIntrinsicCandidate 2141 public native float getFloatVolatile(Object o, long offset); 2142 2143 /** Volatile version of {@link #putFloat(Object, long, float)} */ 2144 @HotSpotIntrinsicCandidate 2145 public native void putFloatVolatile(Object o, long offset, float x); 2146 2147 /** Volatile version of {@link #getDouble(Object, long)} */ 2148 @HotSpotIntrinsicCandidate 2149 public native double getDoubleVolatile(Object o, long offset); 2150 2151 /** Volatile version of {@link #putDouble(Object, long, double)} */ 2152 @HotSpotIntrinsicCandidate 2153 public native void putDoubleVolatile(Object o, long offset, double x); 2154 2155 2156 2157 /** Acquire version of {@link #getReferenceVolatile(Object, long)} */ 2158 @HotSpotIntrinsicCandidate 2159 public final Object getReferenceAcquire(Object o, long offset) { 2160 return getReferenceVolatile(o, offset); 2161 } 2162 2163 /** Acquire version of {@link #getBooleanVolatile(Object, long)} */ 2164 @HotSpotIntrinsicCandidate 2165 public final boolean getBooleanAcquire(Object o, long offset) { 2166 return getBooleanVolatile(o, offset); 2167 } 2168 2169 /** Acquire version of {@link #getByteVolatile(Object, long)} */ 2170 @HotSpotIntrinsicCandidate 2171 public final byte getByteAcquire(Object o, long offset) { 2172 return getByteVolatile(o, offset); 2173 } 2174 2175 /** Acquire version of {@link #getShortVolatile(Object, long)} */ 2176 @HotSpotIntrinsicCandidate 2177 public final short getShortAcquire(Object o, long offset) { 2178 return getShortVolatile(o, offset); 2179 } 2180 2181 /** Acquire version of {@link #getCharVolatile(Object, long)} */ 2182 @HotSpotIntrinsicCandidate 2183 public final char getCharAcquire(Object o, long offset) { 2184 return getCharVolatile(o, offset); 2185 } 2186 2187 /** Acquire version of {@link #getIntVolatile(Object, long)} */ 2188 @HotSpotIntrinsicCandidate 2189 public final int getIntAcquire(Object o, long offset) { 2190 return getIntVolatile(o, offset); 2191 } 2192 2193 /** Acquire version of {@link #getFloatVolatile(Object, long)} */ 2194 @HotSpotIntrinsicCandidate 2195 public final float getFloatAcquire(Object o, long offset) { 2196 return getFloatVolatile(o, offset); 2197 } 2198 2199 /** Acquire version of {@link #getLongVolatile(Object, long)} */ 2200 @HotSpotIntrinsicCandidate 2201 public final long getLongAcquire(Object o, long offset) { 2202 return getLongVolatile(o, offset); 2203 } 2204 2205 /** Acquire version of {@link #getDoubleVolatile(Object, long)} */ 2206 @HotSpotIntrinsicCandidate 2207 public final double getDoubleAcquire(Object o, long offset) { 2208 return getDoubleVolatile(o, offset); 2209 } 2210 2211 /* 2212 * Versions of {@link #putReferenceVolatile(Object, long, Object)} 2213 * that do not guarantee immediate visibility of the store to 2214 * other threads. This method is generally only useful if the 2215 * underlying field is a Java volatile (or if an array cell, one 2216 * that is otherwise only accessed using volatile accesses). 2217 * 2218 * Corresponds to C11 atomic_store_explicit(..., memory_order_release). 2219 */ 2220 2221 /** Release version of {@link #putReferenceVolatile(Object, long, Object)} */ 2222 @HotSpotIntrinsicCandidate 2223 public final void putReferenceRelease(Object o, long offset, Object x) { 2224 putReferenceVolatile(o, offset, x); 2225 } 2226 2227 /** Release version of {@link #putBooleanVolatile(Object, long, boolean)} */ 2228 @HotSpotIntrinsicCandidate 2229 public final void putBooleanRelease(Object o, long offset, boolean x) { 2230 putBooleanVolatile(o, offset, x); 2231 } 2232 2233 /** Release version of {@link #putByteVolatile(Object, long, byte)} */ 2234 @HotSpotIntrinsicCandidate 2235 public final void putByteRelease(Object o, long offset, byte x) { 2236 putByteVolatile(o, offset, x); 2237 } 2238 2239 /** Release version of {@link #putShortVolatile(Object, long, short)} */ 2240 @HotSpotIntrinsicCandidate 2241 public final void putShortRelease(Object o, long offset, short x) { 2242 putShortVolatile(o, offset, x); 2243 } 2244 2245 /** Release version of {@link #putCharVolatile(Object, long, char)} */ 2246 @HotSpotIntrinsicCandidate 2247 public final void putCharRelease(Object o, long offset, char x) { 2248 putCharVolatile(o, offset, x); 2249 } 2250 2251 /** Release version of {@link #putIntVolatile(Object, long, int)} */ 2252 @HotSpotIntrinsicCandidate 2253 public final void putIntRelease(Object o, long offset, int x) { 2254 putIntVolatile(o, offset, x); 2255 } 2256 2257 /** Release version of {@link #putFloatVolatile(Object, long, float)} */ 2258 @HotSpotIntrinsicCandidate 2259 public final void putFloatRelease(Object o, long offset, float x) { 2260 putFloatVolatile(o, offset, x); 2261 } 2262 2263 /** Release version of {@link #putLongVolatile(Object, long, long)} */ 2264 @HotSpotIntrinsicCandidate 2265 public final void putLongRelease(Object o, long offset, long x) { 2266 putLongVolatile(o, offset, x); 2267 } 2268 2269 /** Release version of {@link #putDoubleVolatile(Object, long, double)} */ 2270 @HotSpotIntrinsicCandidate 2271 public final void putDoubleRelease(Object o, long offset, double x) { 2272 putDoubleVolatile(o, offset, x); 2273 } 2274 2275 // ------------------------------ Opaque -------------------------------------- 2276 2277 /** Opaque version of {@link #getReferenceVolatile(Object, long)} */ 2278 @HotSpotIntrinsicCandidate 2279 public final Object getReferenceOpaque(Object o, long offset) { 2280 return getReferenceVolatile(o, offset); 2281 } 2282 2283 /** Opaque version of {@link #getBooleanVolatile(Object, long)} */ 2284 @HotSpotIntrinsicCandidate 2285 public final boolean getBooleanOpaque(Object o, long offset) { 2286 return getBooleanVolatile(o, offset); 2287 } 2288 2289 /** Opaque version of {@link #getByteVolatile(Object, long)} */ 2290 @HotSpotIntrinsicCandidate 2291 public final byte getByteOpaque(Object o, long offset) { 2292 return getByteVolatile(o, offset); 2293 } 2294 2295 /** Opaque version of {@link #getShortVolatile(Object, long)} */ 2296 @HotSpotIntrinsicCandidate 2297 public final short getShortOpaque(Object o, long offset) { 2298 return getShortVolatile(o, offset); 2299 } 2300 2301 /** Opaque version of {@link #getCharVolatile(Object, long)} */ 2302 @HotSpotIntrinsicCandidate 2303 public final char getCharOpaque(Object o, long offset) { 2304 return getCharVolatile(o, offset); 2305 } 2306 2307 /** Opaque version of {@link #getIntVolatile(Object, long)} */ 2308 @HotSpotIntrinsicCandidate 2309 public final int getIntOpaque(Object o, long offset) { 2310 return getIntVolatile(o, offset); 2311 } 2312 2313 /** Opaque version of {@link #getFloatVolatile(Object, long)} */ 2314 @HotSpotIntrinsicCandidate 2315 public final float getFloatOpaque(Object o, long offset) { 2316 return getFloatVolatile(o, offset); 2317 } 2318 2319 /** Opaque version of {@link #getLongVolatile(Object, long)} */ 2320 @HotSpotIntrinsicCandidate 2321 public final long getLongOpaque(Object o, long offset) { 2322 return getLongVolatile(o, offset); 2323 } 2324 2325 /** Opaque version of {@link #getDoubleVolatile(Object, long)} */ 2326 @HotSpotIntrinsicCandidate 2327 public final double getDoubleOpaque(Object o, long offset) { 2328 return getDoubleVolatile(o, offset); 2329 } 2330 2331 /** Opaque version of {@link #putReferenceVolatile(Object, long, Object)} */ 2332 @HotSpotIntrinsicCandidate 2333 public final void putReferenceOpaque(Object o, long offset, Object x) { 2334 putReferenceVolatile(o, offset, x); 2335 } 2336 2337 /** Opaque version of {@link #putBooleanVolatile(Object, long, boolean)} */ 2338 @HotSpotIntrinsicCandidate 2339 public final void putBooleanOpaque(Object o, long offset, boolean x) { 2340 putBooleanVolatile(o, offset, x); 2341 } 2342 2343 /** Opaque version of {@link #putByteVolatile(Object, long, byte)} */ 2344 @HotSpotIntrinsicCandidate 2345 public final void putByteOpaque(Object o, long offset, byte x) { 2346 putByteVolatile(o, offset, x); 2347 } 2348 2349 /** Opaque version of {@link #putShortVolatile(Object, long, short)} */ 2350 @HotSpotIntrinsicCandidate 2351 public final void putShortOpaque(Object o, long offset, short x) { 2352 putShortVolatile(o, offset, x); 2353 } 2354 2355 /** Opaque version of {@link #putCharVolatile(Object, long, char)} */ 2356 @HotSpotIntrinsicCandidate 2357 public final void putCharOpaque(Object o, long offset, char x) { 2358 putCharVolatile(o, offset, x); 2359 } 2360 2361 /** Opaque version of {@link #putIntVolatile(Object, long, int)} */ 2362 @HotSpotIntrinsicCandidate 2363 public final void putIntOpaque(Object o, long offset, int x) { 2364 putIntVolatile(o, offset, x); 2365 } 2366 2367 /** Opaque version of {@link #putFloatVolatile(Object, long, float)} */ 2368 @HotSpotIntrinsicCandidate 2369 public final void putFloatOpaque(Object o, long offset, float x) { 2370 putFloatVolatile(o, offset, x); 2371 } 2372 2373 /** Opaque version of {@link #putLongVolatile(Object, long, long)} */ 2374 @HotSpotIntrinsicCandidate 2375 public final void putLongOpaque(Object o, long offset, long x) { 2376 putLongVolatile(o, offset, x); 2377 } 2378 2379 /** Opaque version of {@link #putDoubleVolatile(Object, long, double)} */ 2380 @HotSpotIntrinsicCandidate 2381 public final void putDoubleOpaque(Object o, long offset, double x) { 2382 putDoubleVolatile(o, offset, x); 2383 } 2384 2385 /** 2386 * Unblocks the given thread blocked on {@code park}, or, if it is 2387 * not blocked, causes the subsequent call to {@code park} not to 2388 * block. Note: this operation is "unsafe" solely because the 2389 * caller must somehow ensure that the thread has not been 2390 * destroyed. Nothing special is usually required to ensure this 2391 * when called from Java (in which there will ordinarily be a live 2392 * reference to the thread) but this is not nearly-automatically 2393 * so when calling from native code. 2394 * 2395 * @param thread the thread to unpark. 2396 */ 2397 @HotSpotIntrinsicCandidate 2398 public native void unpark(Object thread); 2399 2400 /** 2401 * Blocks current thread, returning when a balancing 2402 * {@code unpark} occurs, or a balancing {@code unpark} has 2403 * already occurred, or the thread is interrupted, or, if not 2404 * absolute and time is not zero, the given time nanoseconds have 2405 * elapsed, or if absolute, the given deadline in milliseconds 2406 * since Epoch has passed, or spuriously (i.e., returning for no 2407 * "reason"). Note: This operation is in the Unsafe class only 2408 * because {@code unpark} is, so it would be strange to place it 2409 * elsewhere. 2410 */ 2411 @HotSpotIntrinsicCandidate 2412 public native void park(boolean isAbsolute, long time); 2413 2414 /** 2415 * Gets the load average in the system run queue assigned 2416 * to the available processors averaged over various periods of time. 2417 * This method retrieves the given {@code nelem} samples and 2418 * assigns to the elements of the given {@code loadavg} array. 2419 * The system imposes a maximum of 3 samples, representing 2420 * averages over the last 1, 5, and 15 minutes, respectively. 2421 * 2422 * @param loadavg an array of double of size nelems 2423 * @param nelems the number of samples to be retrieved and 2424 * must be 1 to 3. 2425 * 2426 * @return the number of samples actually retrieved; or -1 2427 * if the load average is unobtainable. 2428 */ 2429 public int getLoadAverage(double[] loadavg, int nelems) { 2430 if (nelems < 0 || nelems > 3 || nelems > loadavg.length) { 2431 throw new ArrayIndexOutOfBoundsException(); 2432 } 2433 2434 return getLoadAverage0(loadavg, nelems); 2435 } 2436 2437 // The following contain CAS-based Java implementations used on 2438 // platforms not supporting native instructions 2439 2440 /** 2441 * Atomically adds the given value to the current value of a field 2442 * or array element within the given object {@code o} 2443 * at the given {@code offset}. 2444 * 2445 * @param o object/array to update the field/element in 2446 * @param offset field/element offset 2447 * @param delta the value to add 2448 * @return the previous value 2449 * @since 1.8 2450 */ 2451 @HotSpotIntrinsicCandidate 2452 public final int getAndAddInt(Object o, long offset, int delta) { 2453 int v; 2454 do { 2455 v = getIntVolatile(o, offset); 2456 } while (!weakCompareAndSetInt(o, offset, v, v + delta)); 2457 return v; 2458 } 2459 2460 @ForceInline 2461 public final int getAndAddIntRelease(Object o, long offset, int delta) { 2462 int v; 2463 do { 2464 v = getInt(o, offset); 2465 } while (!weakCompareAndSetIntRelease(o, offset, v, v + delta)); 2466 return v; 2467 } 2468 2469 @ForceInline 2470 public final int getAndAddIntAcquire(Object o, long offset, int delta) { 2471 int v; 2472 do { 2473 v = getIntAcquire(o, offset); 2474 } while (!weakCompareAndSetIntAcquire(o, offset, v, v + delta)); 2475 return v; 2476 } 2477 2478 /** 2479 * Atomically adds the given value to the current value of a field 2480 * or array element within the given object {@code o} 2481 * at the given {@code offset}. 2482 * 2483 * @param o object/array to update the field/element in 2484 * @param offset field/element offset 2485 * @param delta the value to add 2486 * @return the previous value 2487 * @since 1.8 2488 */ 2489 @HotSpotIntrinsicCandidate 2490 public final long getAndAddLong(Object o, long offset, long delta) { 2491 long v; 2492 do { 2493 v = getLongVolatile(o, offset); 2494 } while (!weakCompareAndSetLong(o, offset, v, v + delta)); 2495 return v; 2496 } 2497 2498 @ForceInline 2499 public final long getAndAddLongRelease(Object o, long offset, long delta) { 2500 long v; 2501 do { 2502 v = getLong(o, offset); 2503 } while (!weakCompareAndSetLongRelease(o, offset, v, v + delta)); 2504 return v; 2505 } 2506 2507 @ForceInline 2508 public final long getAndAddLongAcquire(Object o, long offset, long delta) { 2509 long v; 2510 do { 2511 v = getLongAcquire(o, offset); 2512 } while (!weakCompareAndSetLongAcquire(o, offset, v, v + delta)); 2513 return v; 2514 } 2515 2516 @HotSpotIntrinsicCandidate 2517 public final byte getAndAddByte(Object o, long offset, byte delta) { 2518 byte v; 2519 do { 2520 v = getByteVolatile(o, offset); 2521 } while (!weakCompareAndSetByte(o, offset, v, (byte) (v + delta))); 2522 return v; 2523 } 2524 2525 @ForceInline 2526 public final byte getAndAddByteRelease(Object o, long offset, byte delta) { 2527 byte v; 2528 do { 2529 v = getByte(o, offset); 2530 } while (!weakCompareAndSetByteRelease(o, offset, v, (byte) (v + delta))); 2531 return v; 2532 } 2533 2534 @ForceInline 2535 public final byte getAndAddByteAcquire(Object o, long offset, byte delta) { 2536 byte v; 2537 do { 2538 v = getByteAcquire(o, offset); 2539 } while (!weakCompareAndSetByteAcquire(o, offset, v, (byte) (v + delta))); 2540 return v; 2541 } 2542 2543 @HotSpotIntrinsicCandidate 2544 public final short getAndAddShort(Object o, long offset, short delta) { 2545 short v; 2546 do { 2547 v = getShortVolatile(o, offset); 2548 } while (!weakCompareAndSetShort(o, offset, v, (short) (v + delta))); 2549 return v; 2550 } 2551 2552 @ForceInline 2553 public final short getAndAddShortRelease(Object o, long offset, short delta) { 2554 short v; 2555 do { 2556 v = getShort(o, offset); 2557 } while (!weakCompareAndSetShortRelease(o, offset, v, (short) (v + delta))); 2558 return v; 2559 } 2560 2561 @ForceInline 2562 public final short getAndAddShortAcquire(Object o, long offset, short delta) { 2563 short v; 2564 do { 2565 v = getShortAcquire(o, offset); 2566 } while (!weakCompareAndSetShortAcquire(o, offset, v, (short) (v + delta))); 2567 return v; 2568 } 2569 2570 @ForceInline 2571 public final char getAndAddChar(Object o, long offset, char delta) { 2572 return (char) getAndAddShort(o, offset, (short) delta); 2573 } 2574 2575 @ForceInline 2576 public final char getAndAddCharRelease(Object o, long offset, char delta) { 2577 return (char) getAndAddShortRelease(o, offset, (short) delta); 2578 } 2579 2580 @ForceInline 2581 public final char getAndAddCharAcquire(Object o, long offset, char delta) { 2582 return (char) getAndAddShortAcquire(o, offset, (short) delta); 2583 } 2584 2585 @ForceInline 2586 public final float getAndAddFloat(Object o, long offset, float delta) { 2587 int expectedBits; 2588 float v; 2589 do { 2590 // Load and CAS with the raw bits to avoid issues with NaNs and 2591 // possible bit conversion from signaling NaNs to quiet NaNs that 2592 // may result in the loop not terminating. 2593 expectedBits = getIntVolatile(o, offset); 2594 v = Float.intBitsToFloat(expectedBits); 2595 } while (!weakCompareAndSetInt(o, offset, 2596 expectedBits, Float.floatToRawIntBits(v + delta))); 2597 return v; 2598 } 2599 2600 @ForceInline 2601 public final float getAndAddFloatRelease(Object o, long offset, float delta) { 2602 int expectedBits; 2603 float v; 2604 do { 2605 // Load and CAS with the raw bits to avoid issues with NaNs and 2606 // possible bit conversion from signaling NaNs to quiet NaNs that 2607 // may result in the loop not terminating. 2608 expectedBits = getInt(o, offset); 2609 v = Float.intBitsToFloat(expectedBits); 2610 } while (!weakCompareAndSetIntRelease(o, offset, 2611 expectedBits, Float.floatToRawIntBits(v + delta))); 2612 return v; 2613 } 2614 2615 @ForceInline 2616 public final float getAndAddFloatAcquire(Object o, long offset, float delta) { 2617 int expectedBits; 2618 float v; 2619 do { 2620 // Load and CAS with the raw bits to avoid issues with NaNs and 2621 // possible bit conversion from signaling NaNs to quiet NaNs that 2622 // may result in the loop not terminating. 2623 expectedBits = getIntAcquire(o, offset); 2624 v = Float.intBitsToFloat(expectedBits); 2625 } while (!weakCompareAndSetIntAcquire(o, offset, 2626 expectedBits, Float.floatToRawIntBits(v + delta))); 2627 return v; 2628 } 2629 2630 @ForceInline 2631 public final double getAndAddDouble(Object o, long offset, double delta) { 2632 long expectedBits; 2633 double v; 2634 do { 2635 // Load and CAS with the raw bits to avoid issues with NaNs and 2636 // possible bit conversion from signaling NaNs to quiet NaNs that 2637 // may result in the loop not terminating. 2638 expectedBits = getLongVolatile(o, offset); 2639 v = Double.longBitsToDouble(expectedBits); 2640 } while (!weakCompareAndSetLong(o, offset, 2641 expectedBits, Double.doubleToRawLongBits(v + delta))); 2642 return v; 2643 } 2644 2645 @ForceInline 2646 public final double getAndAddDoubleRelease(Object o, long offset, double delta) { 2647 long expectedBits; 2648 double v; 2649 do { 2650 // Load and CAS with the raw bits to avoid issues with NaNs and 2651 // possible bit conversion from signaling NaNs to quiet NaNs that 2652 // may result in the loop not terminating. 2653 expectedBits = getLong(o, offset); 2654 v = Double.longBitsToDouble(expectedBits); 2655 } while (!weakCompareAndSetLongRelease(o, offset, 2656 expectedBits, Double.doubleToRawLongBits(v + delta))); 2657 return v; 2658 } 2659 2660 @ForceInline 2661 public final double getAndAddDoubleAcquire(Object o, long offset, double delta) { 2662 long expectedBits; 2663 double v; 2664 do { 2665 // Load and CAS with the raw bits to avoid issues with NaNs and 2666 // possible bit conversion from signaling NaNs to quiet NaNs that 2667 // may result in the loop not terminating. 2668 expectedBits = getLongAcquire(o, offset); 2669 v = Double.longBitsToDouble(expectedBits); 2670 } while (!weakCompareAndSetLongAcquire(o, offset, 2671 expectedBits, Double.doubleToRawLongBits(v + delta))); 2672 return v; 2673 } 2674 2675 /** 2676 * Atomically exchanges the given value with the current value of 2677 * a field or array element within the given object {@code o} 2678 * at the given {@code offset}. 2679 * 2680 * @param o object/array to update the field/element in 2681 * @param offset field/element offset 2682 * @param newValue new value 2683 * @return the previous value 2684 * @since 1.8 2685 */ 2686 @HotSpotIntrinsicCandidate 2687 public final int getAndSetInt(Object o, long offset, int newValue) { 2688 int v; 2689 do { 2690 v = getIntVolatile(o, offset); 2691 } while (!weakCompareAndSetInt(o, offset, v, newValue)); 2692 return v; 2693 } 2694 2695 @ForceInline 2696 public final int getAndSetIntRelease(Object o, long offset, int newValue) { 2697 int v; 2698 do { 2699 v = getInt(o, offset); 2700 } while (!weakCompareAndSetIntRelease(o, offset, v, newValue)); 2701 return v; 2702 } 2703 2704 @ForceInline 2705 public final int getAndSetIntAcquire(Object o, long offset, int newValue) { 2706 int v; 2707 do { 2708 v = getIntAcquire(o, offset); 2709 } while (!weakCompareAndSetIntAcquire(o, offset, v, newValue)); 2710 return v; 2711 } 2712 2713 /** 2714 * Atomically exchanges the given value with the current value of 2715 * a field or array element within the given object {@code o} 2716 * at the given {@code offset}. 2717 * 2718 * @param o object/array to update the field/element in 2719 * @param offset field/element offset 2720 * @param newValue new value 2721 * @return the previous value 2722 * @since 1.8 2723 */ 2724 @HotSpotIntrinsicCandidate 2725 public final long getAndSetLong(Object o, long offset, long newValue) { 2726 long v; 2727 do { 2728 v = getLongVolatile(o, offset); 2729 } while (!weakCompareAndSetLong(o, offset, v, newValue)); 2730 return v; 2731 } 2732 2733 @ForceInline 2734 public final long getAndSetLongRelease(Object o, long offset, long newValue) { 2735 long v; 2736 do { 2737 v = getLong(o, offset); 2738 } while (!weakCompareAndSetLongRelease(o, offset, v, newValue)); 2739 return v; 2740 } 2741 2742 @ForceInline 2743 public final long getAndSetLongAcquire(Object o, long offset, long newValue) { 2744 long v; 2745 do { 2746 v = getLongAcquire(o, offset); 2747 } while (!weakCompareAndSetLongAcquire(o, offset, v, newValue)); 2748 return v; 2749 } 2750 2751 /** 2752 * Atomically exchanges the given reference value with the current 2753 * reference value of a field or array element within the given 2754 * object {@code o} at the given {@code offset}. 2755 * 2756 * @param o object/array to update the field/element in 2757 * @param offset field/element offset 2758 * @param newValue new value 2759 * @return the previous value 2760 * @since 1.8 2761 */ 2762 @HotSpotIntrinsicCandidate 2763 public final Object getAndSetReference(Object o, long offset, Object newValue) { 2764 Object v; 2765 do { 2766 v = getReferenceVolatile(o, offset); 2767 } while (!weakCompareAndSetReference(o, offset, v, newValue)); 2768 return v; 2769 } 2770 2771 @ForceInline 2772 public final Object getAndSetReferenceRelease(Object o, long offset, Object newValue) { 2773 Object v; 2774 do { 2775 v = getReference(o, offset); 2776 } while (!weakCompareAndSetReferenceRelease(o, offset, v, newValue)); 2777 return v; 2778 } 2779 2780 @ForceInline 2781 public final Object getAndSetReferenceAcquire(Object o, long offset, Object newValue) { 2782 Object v; 2783 do { 2784 v = getReferenceAcquire(o, offset); 2785 } while (!weakCompareAndSetReferenceAcquire(o, offset, v, newValue)); 2786 return v; 2787 } 2788 2789 @HotSpotIntrinsicCandidate 2790 public final byte getAndSetByte(Object o, long offset, byte newValue) { 2791 byte v; 2792 do { 2793 v = getByteVolatile(o, offset); 2794 } while (!weakCompareAndSetByte(o, offset, v, newValue)); 2795 return v; 2796 } 2797 2798 @ForceInline 2799 public final byte getAndSetByteRelease(Object o, long offset, byte newValue) { 2800 byte v; 2801 do { 2802 v = getByte(o, offset); 2803 } while (!weakCompareAndSetByteRelease(o, offset, v, newValue)); 2804 return v; 2805 } 2806 2807 @ForceInline 2808 public final byte getAndSetByteAcquire(Object o, long offset, byte newValue) { 2809 byte v; 2810 do { 2811 v = getByteAcquire(o, offset); 2812 } while (!weakCompareAndSetByteAcquire(o, offset, v, newValue)); 2813 return v; 2814 } 2815 2816 @ForceInline 2817 public final boolean getAndSetBoolean(Object o, long offset, boolean newValue) { 2818 return byte2bool(getAndSetByte(o, offset, bool2byte(newValue))); 2819 } 2820 2821 @ForceInline 2822 public final boolean getAndSetBooleanRelease(Object o, long offset, boolean newValue) { 2823 return byte2bool(getAndSetByteRelease(o, offset, bool2byte(newValue))); 2824 } 2825 2826 @ForceInline 2827 public final boolean getAndSetBooleanAcquire(Object o, long offset, boolean newValue) { 2828 return byte2bool(getAndSetByteAcquire(o, offset, bool2byte(newValue))); 2829 } 2830 2831 @HotSpotIntrinsicCandidate 2832 public final short getAndSetShort(Object o, long offset, short newValue) { 2833 short v; 2834 do { 2835 v = getShortVolatile(o, offset); 2836 } while (!weakCompareAndSetShort(o, offset, v, newValue)); 2837 return v; 2838 } 2839 2840 @ForceInline 2841 public final short getAndSetShortRelease(Object o, long offset, short newValue) { 2842 short v; 2843 do { 2844 v = getShort(o, offset); 2845 } while (!weakCompareAndSetShortRelease(o, offset, v, newValue)); 2846 return v; 2847 } 2848 2849 @ForceInline 2850 public final short getAndSetShortAcquire(Object o, long offset, short newValue) { 2851 short v; 2852 do { 2853 v = getShortAcquire(o, offset); 2854 } while (!weakCompareAndSetShortAcquire(o, offset, v, newValue)); 2855 return v; 2856 } 2857 2858 @ForceInline 2859 public final char getAndSetChar(Object o, long offset, char newValue) { 2860 return s2c(getAndSetShort(o, offset, c2s(newValue))); 2861 } 2862 2863 @ForceInline 2864 public final char getAndSetCharRelease(Object o, long offset, char newValue) { 2865 return s2c(getAndSetShortRelease(o, offset, c2s(newValue))); 2866 } 2867 2868 @ForceInline 2869 public final char getAndSetCharAcquire(Object o, long offset, char newValue) { 2870 return s2c(getAndSetShortAcquire(o, offset, c2s(newValue))); 2871 } 2872 2873 @ForceInline 2874 public final float getAndSetFloat(Object o, long offset, float newValue) { 2875 int v = getAndSetInt(o, offset, Float.floatToRawIntBits(newValue)); 2876 return Float.intBitsToFloat(v); 2877 } 2878 2879 @ForceInline 2880 public final float getAndSetFloatRelease(Object o, long offset, float newValue) { 2881 int v = getAndSetIntRelease(o, offset, Float.floatToRawIntBits(newValue)); 2882 return Float.intBitsToFloat(v); 2883 } 2884 2885 @ForceInline 2886 public final float getAndSetFloatAcquire(Object o, long offset, float newValue) { 2887 int v = getAndSetIntAcquire(o, offset, Float.floatToRawIntBits(newValue)); 2888 return Float.intBitsToFloat(v); 2889 } 2890 2891 @ForceInline 2892 public final double getAndSetDouble(Object o, long offset, double newValue) { 2893 long v = getAndSetLong(o, offset, Double.doubleToRawLongBits(newValue)); 2894 return Double.longBitsToDouble(v); 2895 } 2896 2897 @ForceInline 2898 public final double getAndSetDoubleRelease(Object o, long offset, double newValue) { 2899 long v = getAndSetLongRelease(o, offset, Double.doubleToRawLongBits(newValue)); 2900 return Double.longBitsToDouble(v); 2901 } 2902 2903 @ForceInline 2904 public final double getAndSetDoubleAcquire(Object o, long offset, double newValue) { 2905 long v = getAndSetLongAcquire(o, offset, Double.doubleToRawLongBits(newValue)); 2906 return Double.longBitsToDouble(v); 2907 } 2908 2909 2910 // The following contain CAS-based Java implementations used on 2911 // platforms not supporting native instructions 2912 2913 @ForceInline 2914 public final boolean getAndBitwiseOrBoolean(Object o, long offset, boolean mask) { 2915 return byte2bool(getAndBitwiseOrByte(o, offset, bool2byte(mask))); 2916 } 2917 2918 @ForceInline 2919 public final boolean getAndBitwiseOrBooleanRelease(Object o, long offset, boolean mask) { 2920 return byte2bool(getAndBitwiseOrByteRelease(o, offset, bool2byte(mask))); 2921 } 2922 2923 @ForceInline 2924 public final boolean getAndBitwiseOrBooleanAcquire(Object o, long offset, boolean mask) { 2925 return byte2bool(getAndBitwiseOrByteAcquire(o, offset, bool2byte(mask))); 2926 } 2927 2928 @ForceInline 2929 public final boolean getAndBitwiseAndBoolean(Object o, long offset, boolean mask) { 2930 return byte2bool(getAndBitwiseAndByte(o, offset, bool2byte(mask))); 2931 } 2932 2933 @ForceInline 2934 public final boolean getAndBitwiseAndBooleanRelease(Object o, long offset, boolean mask) { 2935 return byte2bool(getAndBitwiseAndByteRelease(o, offset, bool2byte(mask))); 2936 } 2937 2938 @ForceInline 2939 public final boolean getAndBitwiseAndBooleanAcquire(Object o, long offset, boolean mask) { 2940 return byte2bool(getAndBitwiseAndByteAcquire(o, offset, bool2byte(mask))); 2941 } 2942 2943 @ForceInline 2944 public final boolean getAndBitwiseXorBoolean(Object o, long offset, boolean mask) { 2945 return byte2bool(getAndBitwiseXorByte(o, offset, bool2byte(mask))); 2946 } 2947 2948 @ForceInline 2949 public final boolean getAndBitwiseXorBooleanRelease(Object o, long offset, boolean mask) { 2950 return byte2bool(getAndBitwiseXorByteRelease(o, offset, bool2byte(mask))); 2951 } 2952 2953 @ForceInline 2954 public final boolean getAndBitwiseXorBooleanAcquire(Object o, long offset, boolean mask) { 2955 return byte2bool(getAndBitwiseXorByteAcquire(o, offset, bool2byte(mask))); 2956 } 2957 2958 2959 @ForceInline 2960 public final byte getAndBitwiseOrByte(Object o, long offset, byte mask) { 2961 byte current; 2962 do { 2963 current = getByteVolatile(o, offset); 2964 } while (!weakCompareAndSetByte(o, offset, 2965 current, (byte) (current | mask))); 2966 return current; 2967 } 2968 2969 @ForceInline 2970 public final byte getAndBitwiseOrByteRelease(Object o, long offset, byte mask) { 2971 byte current; 2972 do { 2973 current = getByte(o, offset); 2974 } while (!weakCompareAndSetByteRelease(o, offset, 2975 current, (byte) (current | mask))); 2976 return current; 2977 } 2978 2979 @ForceInline 2980 public final byte getAndBitwiseOrByteAcquire(Object o, long offset, byte mask) { 2981 byte current; 2982 do { 2983 // Plain read, the value is a hint, the acquire CAS does the work 2984 current = getByte(o, offset); 2985 } while (!weakCompareAndSetByteAcquire(o, offset, 2986 current, (byte) (current | mask))); 2987 return current; 2988 } 2989 2990 @ForceInline 2991 public final byte getAndBitwiseAndByte(Object o, long offset, byte mask) { 2992 byte current; 2993 do { 2994 current = getByteVolatile(o, offset); 2995 } while (!weakCompareAndSetByte(o, offset, 2996 current, (byte) (current & mask))); 2997 return current; 2998 } 2999 3000 @ForceInline 3001 public final byte getAndBitwiseAndByteRelease(Object o, long offset, byte mask) { 3002 byte current; 3003 do { 3004 current = getByte(o, offset); 3005 } while (!weakCompareAndSetByteRelease(o, offset, 3006 current, (byte) (current & mask))); 3007 return current; 3008 } 3009 3010 @ForceInline 3011 public final byte getAndBitwiseAndByteAcquire(Object o, long offset, byte mask) { 3012 byte current; 3013 do { 3014 // Plain read, the value is a hint, the acquire CAS does the work 3015 current = getByte(o, offset); 3016 } while (!weakCompareAndSetByteAcquire(o, offset, 3017 current, (byte) (current & mask))); 3018 return current; 3019 } 3020 3021 @ForceInline 3022 public final byte getAndBitwiseXorByte(Object o, long offset, byte mask) { 3023 byte current; 3024 do { 3025 current = getByteVolatile(o, offset); 3026 } while (!weakCompareAndSetByte(o, offset, 3027 current, (byte) (current ^ mask))); 3028 return current; 3029 } 3030 3031 @ForceInline 3032 public final byte getAndBitwiseXorByteRelease(Object o, long offset, byte mask) { 3033 byte current; 3034 do { 3035 current = getByte(o, offset); 3036 } while (!weakCompareAndSetByteRelease(o, offset, 3037 current, (byte) (current ^ mask))); 3038 return current; 3039 } 3040 3041 @ForceInline 3042 public final byte getAndBitwiseXorByteAcquire(Object o, long offset, byte mask) { 3043 byte current; 3044 do { 3045 // Plain read, the value is a hint, the acquire CAS does the work 3046 current = getByte(o, offset); 3047 } while (!weakCompareAndSetByteAcquire(o, offset, 3048 current, (byte) (current ^ mask))); 3049 return current; 3050 } 3051 3052 3053 @ForceInline 3054 public final char getAndBitwiseOrChar(Object o, long offset, char mask) { 3055 return s2c(getAndBitwiseOrShort(o, offset, c2s(mask))); 3056 } 3057 3058 @ForceInline 3059 public final char getAndBitwiseOrCharRelease(Object o, long offset, char mask) { 3060 return s2c(getAndBitwiseOrShortRelease(o, offset, c2s(mask))); 3061 } 3062 3063 @ForceInline 3064 public final char getAndBitwiseOrCharAcquire(Object o, long offset, char mask) { 3065 return s2c(getAndBitwiseOrShortAcquire(o, offset, c2s(mask))); 3066 } 3067 3068 @ForceInline 3069 public final char getAndBitwiseAndChar(Object o, long offset, char mask) { 3070 return s2c(getAndBitwiseAndShort(o, offset, c2s(mask))); 3071 } 3072 3073 @ForceInline 3074 public final char getAndBitwiseAndCharRelease(Object o, long offset, char mask) { 3075 return s2c(getAndBitwiseAndShortRelease(o, offset, c2s(mask))); 3076 } 3077 3078 @ForceInline 3079 public final char getAndBitwiseAndCharAcquire(Object o, long offset, char mask) { 3080 return s2c(getAndBitwiseAndShortAcquire(o, offset, c2s(mask))); 3081 } 3082 3083 @ForceInline 3084 public final char getAndBitwiseXorChar(Object o, long offset, char mask) { 3085 return s2c(getAndBitwiseXorShort(o, offset, c2s(mask))); 3086 } 3087 3088 @ForceInline 3089 public final char getAndBitwiseXorCharRelease(Object o, long offset, char mask) { 3090 return s2c(getAndBitwiseXorShortRelease(o, offset, c2s(mask))); 3091 } 3092 3093 @ForceInline 3094 public final char getAndBitwiseXorCharAcquire(Object o, long offset, char mask) { 3095 return s2c(getAndBitwiseXorShortAcquire(o, offset, c2s(mask))); 3096 } 3097 3098 3099 @ForceInline 3100 public final short getAndBitwiseOrShort(Object o, long offset, short mask) { 3101 short current; 3102 do { 3103 current = getShortVolatile(o, offset); 3104 } while (!weakCompareAndSetShort(o, offset, 3105 current, (short) (current | mask))); 3106 return current; 3107 } 3108 3109 @ForceInline 3110 public final short getAndBitwiseOrShortRelease(Object o, long offset, short mask) { 3111 short current; 3112 do { 3113 current = getShort(o, offset); 3114 } while (!weakCompareAndSetShortRelease(o, offset, 3115 current, (short) (current | mask))); 3116 return current; 3117 } 3118 3119 @ForceInline 3120 public final short getAndBitwiseOrShortAcquire(Object o, long offset, short mask) { 3121 short current; 3122 do { 3123 // Plain read, the value is a hint, the acquire CAS does the work 3124 current = getShort(o, offset); 3125 } while (!weakCompareAndSetShortAcquire(o, offset, 3126 current, (short) (current | mask))); 3127 return current; 3128 } 3129 3130 @ForceInline 3131 public final short getAndBitwiseAndShort(Object o, long offset, short mask) { 3132 short current; 3133 do { 3134 current = getShortVolatile(o, offset); 3135 } while (!weakCompareAndSetShort(o, offset, 3136 current, (short) (current & mask))); 3137 return current; 3138 } 3139 3140 @ForceInline 3141 public final short getAndBitwiseAndShortRelease(Object o, long offset, short mask) { 3142 short current; 3143 do { 3144 current = getShort(o, offset); 3145 } while (!weakCompareAndSetShortRelease(o, offset, 3146 current, (short) (current & mask))); 3147 return current; 3148 } 3149 3150 @ForceInline 3151 public final short getAndBitwiseAndShortAcquire(Object o, long offset, short mask) { 3152 short current; 3153 do { 3154 // Plain read, the value is a hint, the acquire CAS does the work 3155 current = getShort(o, offset); 3156 } while (!weakCompareAndSetShortAcquire(o, offset, 3157 current, (short) (current & mask))); 3158 return current; 3159 } 3160 3161 @ForceInline 3162 public final short getAndBitwiseXorShort(Object o, long offset, short mask) { 3163 short current; 3164 do { 3165 current = getShortVolatile(o, offset); 3166 } while (!weakCompareAndSetShort(o, offset, 3167 current, (short) (current ^ mask))); 3168 return current; 3169 } 3170 3171 @ForceInline 3172 public final short getAndBitwiseXorShortRelease(Object o, long offset, short mask) { 3173 short current; 3174 do { 3175 current = getShort(o, offset); 3176 } while (!weakCompareAndSetShortRelease(o, offset, 3177 current, (short) (current ^ mask))); 3178 return current; 3179 } 3180 3181 @ForceInline 3182 public final short getAndBitwiseXorShortAcquire(Object o, long offset, short mask) { 3183 short current; 3184 do { 3185 // Plain read, the value is a hint, the acquire CAS does the work 3186 current = getShort(o, offset); 3187 } while (!weakCompareAndSetShortAcquire(o, offset, 3188 current, (short) (current ^ mask))); 3189 return current; 3190 } 3191 3192 3193 @ForceInline 3194 public final int getAndBitwiseOrInt(Object o, long offset, int mask) { 3195 int current; 3196 do { 3197 current = getIntVolatile(o, offset); 3198 } while (!weakCompareAndSetInt(o, offset, 3199 current, current | mask)); 3200 return current; 3201 } 3202 3203 @ForceInline 3204 public final int getAndBitwiseOrIntRelease(Object o, long offset, int mask) { 3205 int current; 3206 do { 3207 current = getInt(o, offset); 3208 } while (!weakCompareAndSetIntRelease(o, offset, 3209 current, current | mask)); 3210 return current; 3211 } 3212 3213 @ForceInline 3214 public final int getAndBitwiseOrIntAcquire(Object o, long offset, int mask) { 3215 int current; 3216 do { 3217 // Plain read, the value is a hint, the acquire CAS does the work 3218 current = getInt(o, offset); 3219 } while (!weakCompareAndSetIntAcquire(o, offset, 3220 current, current | mask)); 3221 return current; 3222 } 3223 3224 /** 3225 * Atomically replaces the current value of a field or array element within 3226 * the given object with the result of bitwise AND between the current value 3227 * and mask. 3228 * 3229 * @param o object/array to update the field/element in 3230 * @param offset field/element offset 3231 * @param mask the mask value 3232 * @return the previous value 3233 * @since 9 3234 */ 3235 @ForceInline 3236 public final int getAndBitwiseAndInt(Object o, long offset, int mask) { 3237 int current; 3238 do { 3239 current = getIntVolatile(o, offset); 3240 } while (!weakCompareAndSetInt(o, offset, 3241 current, current & mask)); 3242 return current; 3243 } 3244 3245 @ForceInline 3246 public final int getAndBitwiseAndIntRelease(Object o, long offset, int mask) { 3247 int current; 3248 do { 3249 current = getInt(o, offset); 3250 } while (!weakCompareAndSetIntRelease(o, offset, 3251 current, current & mask)); 3252 return current; 3253 } 3254 3255 @ForceInline 3256 public final int getAndBitwiseAndIntAcquire(Object o, long offset, int mask) { 3257 int current; 3258 do { 3259 // Plain read, the value is a hint, the acquire CAS does the work 3260 current = getInt(o, offset); 3261 } while (!weakCompareAndSetIntAcquire(o, offset, 3262 current, current & mask)); 3263 return current; 3264 } 3265 3266 @ForceInline 3267 public final int getAndBitwiseXorInt(Object o, long offset, int mask) { 3268 int current; 3269 do { 3270 current = getIntVolatile(o, offset); 3271 } while (!weakCompareAndSetInt(o, offset, 3272 current, current ^ mask)); 3273 return current; 3274 } 3275 3276 @ForceInline 3277 public final int getAndBitwiseXorIntRelease(Object o, long offset, int mask) { 3278 int current; 3279 do { 3280 current = getInt(o, offset); 3281 } while (!weakCompareAndSetIntRelease(o, offset, 3282 current, current ^ mask)); 3283 return current; 3284 } 3285 3286 @ForceInline 3287 public final int getAndBitwiseXorIntAcquire(Object o, long offset, int mask) { 3288 int current; 3289 do { 3290 // Plain read, the value is a hint, the acquire CAS does the work 3291 current = getInt(o, offset); 3292 } while (!weakCompareAndSetIntAcquire(o, offset, 3293 current, current ^ mask)); 3294 return current; 3295 } 3296 3297 3298 @ForceInline 3299 public final long getAndBitwiseOrLong(Object o, long offset, long mask) { 3300 long current; 3301 do { 3302 current = getLongVolatile(o, offset); 3303 } while (!weakCompareAndSetLong(o, offset, 3304 current, current | mask)); 3305 return current; 3306 } 3307 3308 @ForceInline 3309 public final long getAndBitwiseOrLongRelease(Object o, long offset, long mask) { 3310 long current; 3311 do { 3312 current = getLong(o, offset); 3313 } while (!weakCompareAndSetLongRelease(o, offset, 3314 current, current | mask)); 3315 return current; 3316 } 3317 3318 @ForceInline 3319 public final long getAndBitwiseOrLongAcquire(Object o, long offset, long mask) { 3320 long current; 3321 do { 3322 // Plain read, the value is a hint, the acquire CAS does the work 3323 current = getLong(o, offset); 3324 } while (!weakCompareAndSetLongAcquire(o, offset, 3325 current, current | mask)); 3326 return current; 3327 } 3328 3329 @ForceInline 3330 public final long getAndBitwiseAndLong(Object o, long offset, long mask) { 3331 long current; 3332 do { 3333 current = getLongVolatile(o, offset); 3334 } while (!weakCompareAndSetLong(o, offset, 3335 current, current & mask)); 3336 return current; 3337 } 3338 3339 @ForceInline 3340 public final long getAndBitwiseAndLongRelease(Object o, long offset, long mask) { 3341 long current; 3342 do { 3343 current = getLong(o, offset); 3344 } while (!weakCompareAndSetLongRelease(o, offset, 3345 current, current & mask)); 3346 return current; 3347 } 3348 3349 @ForceInline 3350 public final long getAndBitwiseAndLongAcquire(Object o, long offset, long mask) { 3351 long current; 3352 do { 3353 // Plain read, the value is a hint, the acquire CAS does the work 3354 current = getLong(o, offset); 3355 } while (!weakCompareAndSetLongAcquire(o, offset, 3356 current, current & mask)); 3357 return current; 3358 } 3359 3360 @ForceInline 3361 public final long getAndBitwiseXorLong(Object o, long offset, long mask) { 3362 long current; 3363 do { 3364 current = getLongVolatile(o, offset); 3365 } while (!weakCompareAndSetLong(o, offset, 3366 current, current ^ mask)); 3367 return current; 3368 } 3369 3370 @ForceInline 3371 public final long getAndBitwiseXorLongRelease(Object o, long offset, long mask) { 3372 long current; 3373 do { 3374 current = getLong(o, offset); 3375 } while (!weakCompareAndSetLongRelease(o, offset, 3376 current, current ^ mask)); 3377 return current; 3378 } 3379 3380 @ForceInline 3381 public final long getAndBitwiseXorLongAcquire(Object o, long offset, long mask) { 3382 long current; 3383 do { 3384 // Plain read, the value is a hint, the acquire CAS does the work 3385 current = getLong(o, offset); 3386 } while (!weakCompareAndSetLongAcquire(o, offset, 3387 current, current ^ mask)); 3388 return current; 3389 } 3390 3391 3392 3393 /** 3394 * Ensures that loads before the fence will not be reordered with loads and 3395 * stores after the fence; a "LoadLoad plus LoadStore barrier". 3396 * 3397 * Corresponds to C11 atomic_thread_fence(memory_order_acquire) 3398 * (an "acquire fence"). 3399 * 3400 * A pure LoadLoad fence is not provided, since the addition of LoadStore 3401 * is almost always desired, and most current hardware instructions that 3402 * provide a LoadLoad barrier also provide a LoadStore barrier for free. 3403 * @since 1.8 3404 */ 3405 @HotSpotIntrinsicCandidate 3406 public native void loadFence(); 3407 3408 /** 3409 * Ensures that loads and stores before the fence will not be reordered with 3410 * stores after the fence; a "StoreStore plus LoadStore barrier". 3411 * 3412 * Corresponds to C11 atomic_thread_fence(memory_order_release) 3413 * (a "release fence"). 3414 * 3415 * A pure StoreStore fence is not provided, since the addition of LoadStore 3416 * is almost always desired, and most current hardware instructions that 3417 * provide a StoreStore barrier also provide a LoadStore barrier for free. 3418 * @since 1.8 3419 */ 3420 @HotSpotIntrinsicCandidate 3421 public native void storeFence(); 3422 3423 /** 3424 * Ensures that loads and stores before the fence will not be reordered 3425 * with loads and stores after the fence. Implies the effects of both 3426 * loadFence() and storeFence(), and in addition, the effect of a StoreLoad 3427 * barrier. 3428 * 3429 * Corresponds to C11 atomic_thread_fence(memory_order_seq_cst). 3430 * @since 1.8 3431 */ 3432 @HotSpotIntrinsicCandidate 3433 public native void fullFence(); 3434 3435 /** 3436 * Ensures that loads before the fence will not be reordered with 3437 * loads after the fence. 3438 */ 3439 public final void loadLoadFence() { 3440 loadFence(); 3441 } 3442 3443 /** 3444 * Ensures that stores before the fence will not be reordered with 3445 * stores after the fence. 3446 */ 3447 public final void storeStoreFence() { 3448 storeFence(); 3449 } 3450 3451 3452 /** 3453 * Throws IllegalAccessError; for use by the VM for access control 3454 * error support. 3455 * @since 1.8 3456 */ 3457 private static void throwIllegalAccessError() { 3458 throw new IllegalAccessError(); 3459 } 3460 3461 /** 3462 * Throws NoSuchMethodError; for use by the VM for redefinition support. 3463 * @since 13 3464 */ 3465 private static void throwNoSuchMethodError() { 3466 throw new NoSuchMethodError(); 3467 } 3468 3469 /** 3470 * @return Returns true if the native byte ordering of this 3471 * platform is big-endian, false if it is little-endian. 3472 */ 3473 public final boolean isBigEndian() { return BIG_ENDIAN; } 3474 3475 /** 3476 * @return Returns true if this platform is capable of performing 3477 * accesses at addresses which are not aligned for the type of the 3478 * primitive type being accessed, false otherwise. 3479 */ 3480 public final boolean unalignedAccess() { return UNALIGNED_ACCESS; } 3481 3482 /** 3483 * Fetches a value at some byte offset into a given Java object. 3484 * More specifically, fetches a value within the given object 3485 * <code>o</code> at the given offset, or (if <code>o</code> is 3486 * null) from the memory address whose numerical value is the 3487 * given offset. <p> 3488 * 3489 * The specification of this method is the same as {@link 3490 * #getLong(Object, long)} except that the offset does not need to 3491 * have been obtained from {@link #objectFieldOffset} on the 3492 * {@link java.lang.reflect.Field} of some Java field. The value 3493 * in memory is raw data, and need not correspond to any Java 3494 * variable. Unless <code>o</code> is null, the value accessed 3495 * must be entirely within the allocated object. The endianness 3496 * of the value in memory is the endianness of the native platform. 3497 * 3498 * <p> The read will be atomic with respect to the largest power 3499 * of two that divides the GCD of the offset and the storage size. 3500 * For example, getLongUnaligned will make atomic reads of 2-, 4-, 3501 * or 8-byte storage units if the offset is zero mod 2, 4, or 8, 3502 * respectively. There are no other guarantees of atomicity. 3503 * <p> 3504 * 8-byte atomicity is only guaranteed on platforms on which 3505 * support atomic accesses to longs. 3506 * 3507 * @param o Java heap object in which the value resides, if any, else 3508 * null 3509 * @param offset The offset in bytes from the start of the object 3510 * @return the value fetched from the indicated object 3511 * @throws RuntimeException No defined exceptions are thrown, not even 3512 * {@link NullPointerException} 3513 * @since 9 3514 */ 3515 @HotSpotIntrinsicCandidate 3516 public final long getLongUnaligned(Object o, long offset) { 3517 if ((offset & 7) == 0) { 3518 return getLong(o, offset); 3519 } else if ((offset & 3) == 0) { 3520 return makeLong(getInt(o, offset), 3521 getInt(o, offset + 4)); 3522 } else if ((offset & 1) == 0) { 3523 return makeLong(getShort(o, offset), 3524 getShort(o, offset + 2), 3525 getShort(o, offset + 4), 3526 getShort(o, offset + 6)); 3527 } else { 3528 return makeLong(getByte(o, offset), 3529 getByte(o, offset + 1), 3530 getByte(o, offset + 2), 3531 getByte(o, offset + 3), 3532 getByte(o, offset + 4), 3533 getByte(o, offset + 5), 3534 getByte(o, offset + 6), 3535 getByte(o, offset + 7)); 3536 } 3537 } 3538 /** 3539 * As {@link #getLongUnaligned(Object, long)} but with an 3540 * additional argument which specifies the endianness of the value 3541 * as stored in memory. 3542 * 3543 * @param o Java heap object in which the variable resides 3544 * @param offset The offset in bytes from the start of the object 3545 * @param bigEndian The endianness of the value 3546 * @return the value fetched from the indicated object 3547 * @since 9 3548 */ 3549 public final long getLongUnaligned(Object o, long offset, boolean bigEndian) { 3550 return convEndian(bigEndian, getLongUnaligned(o, offset)); 3551 } 3552 3553 /** @see #getLongUnaligned(Object, long) */ 3554 @HotSpotIntrinsicCandidate 3555 public final int getIntUnaligned(Object o, long offset) { 3556 if ((offset & 3) == 0) { 3557 return getInt(o, offset); 3558 } else if ((offset & 1) == 0) { 3559 return makeInt(getShort(o, offset), 3560 getShort(o, offset + 2)); 3561 } else { 3562 return makeInt(getByte(o, offset), 3563 getByte(o, offset + 1), 3564 getByte(o, offset + 2), 3565 getByte(o, offset + 3)); 3566 } 3567 } 3568 /** @see #getLongUnaligned(Object, long, boolean) */ 3569 public final int getIntUnaligned(Object o, long offset, boolean bigEndian) { 3570 return convEndian(bigEndian, getIntUnaligned(o, offset)); 3571 } 3572 3573 /** @see #getLongUnaligned(Object, long) */ 3574 @HotSpotIntrinsicCandidate 3575 public final short getShortUnaligned(Object o, long offset) { 3576 if ((offset & 1) == 0) { 3577 return getShort(o, offset); 3578 } else { 3579 return makeShort(getByte(o, offset), 3580 getByte(o, offset + 1)); 3581 } 3582 } 3583 /** @see #getLongUnaligned(Object, long, boolean) */ 3584 public final short getShortUnaligned(Object o, long offset, boolean bigEndian) { 3585 return convEndian(bigEndian, getShortUnaligned(o, offset)); 3586 } 3587 3588 /** @see #getLongUnaligned(Object, long) */ 3589 @HotSpotIntrinsicCandidate 3590 public final char getCharUnaligned(Object o, long offset) { 3591 if ((offset & 1) == 0) { 3592 return getChar(o, offset); 3593 } else { 3594 return (char)makeShort(getByte(o, offset), 3595 getByte(o, offset + 1)); 3596 } 3597 } 3598 3599 /** @see #getLongUnaligned(Object, long, boolean) */ 3600 public final char getCharUnaligned(Object o, long offset, boolean bigEndian) { 3601 return convEndian(bigEndian, getCharUnaligned(o, offset)); 3602 } 3603 3604 /** 3605 * Stores a value at some byte offset into a given Java object. 3606 * <p> 3607 * The specification of this method is the same as {@link 3608 * #getLong(Object, long)} except that the offset does not need to 3609 * have been obtained from {@link #objectFieldOffset} on the 3610 * {@link java.lang.reflect.Field} of some Java field. The value 3611 * in memory is raw data, and need not correspond to any Java 3612 * variable. The endianness of the value in memory is the 3613 * endianness of the native platform. 3614 * <p> 3615 * The write will be atomic with respect to the largest power of 3616 * two that divides the GCD of the offset and the storage size. 3617 * For example, putLongUnaligned will make atomic writes of 2-, 4-, 3618 * or 8-byte storage units if the offset is zero mod 2, 4, or 8, 3619 * respectively. There are no other guarantees of atomicity. 3620 * <p> 3621 * 8-byte atomicity is only guaranteed on platforms on which 3622 * support atomic accesses to longs. 3623 * 3624 * @param o Java heap object in which the value resides, if any, else 3625 * null 3626 * @param offset The offset in bytes from the start of the object 3627 * @param x the value to store 3628 * @throws RuntimeException No defined exceptions are thrown, not even 3629 * {@link NullPointerException} 3630 * @since 9 3631 */ 3632 @HotSpotIntrinsicCandidate 3633 public final void putLongUnaligned(Object o, long offset, long x) { 3634 if ((offset & 7) == 0) { 3635 putLong(o, offset, x); 3636 } else if ((offset & 3) == 0) { 3637 putLongParts(o, offset, 3638 (int)(x >> 0), 3639 (int)(x >>> 32)); 3640 } else if ((offset & 1) == 0) { 3641 putLongParts(o, offset, 3642 (short)(x >>> 0), 3643 (short)(x >>> 16), 3644 (short)(x >>> 32), 3645 (short)(x >>> 48)); 3646 } else { 3647 putLongParts(o, offset, 3648 (byte)(x >>> 0), 3649 (byte)(x >>> 8), 3650 (byte)(x >>> 16), 3651 (byte)(x >>> 24), 3652 (byte)(x >>> 32), 3653 (byte)(x >>> 40), 3654 (byte)(x >>> 48), 3655 (byte)(x >>> 56)); 3656 } 3657 } 3658 3659 /** 3660 * As {@link #putLongUnaligned(Object, long, long)} but with an additional 3661 * argument which specifies the endianness of the value as stored in memory. 3662 * @param o Java heap object in which the value resides 3663 * @param offset The offset in bytes from the start of the object 3664 * @param x the value to store 3665 * @param bigEndian The endianness of the value 3666 * @throws RuntimeException No defined exceptions are thrown, not even 3667 * {@link NullPointerException} 3668 * @since 9 3669 */ 3670 public final void putLongUnaligned(Object o, long offset, long x, boolean bigEndian) { 3671 putLongUnaligned(o, offset, convEndian(bigEndian, x)); 3672 } 3673 3674 /** @see #putLongUnaligned(Object, long, long) */ 3675 @HotSpotIntrinsicCandidate 3676 public final void putIntUnaligned(Object o, long offset, int x) { 3677 if ((offset & 3) == 0) { 3678 putInt(o, offset, x); 3679 } else if ((offset & 1) == 0) { 3680 putIntParts(o, offset, 3681 (short)(x >> 0), 3682 (short)(x >>> 16)); 3683 } else { 3684 putIntParts(o, offset, 3685 (byte)(x >>> 0), 3686 (byte)(x >>> 8), 3687 (byte)(x >>> 16), 3688 (byte)(x >>> 24)); 3689 } 3690 } 3691 /** @see #putLongUnaligned(Object, long, long, boolean) */ 3692 public final void putIntUnaligned(Object o, long offset, int x, boolean bigEndian) { 3693 putIntUnaligned(o, offset, convEndian(bigEndian, x)); 3694 } 3695 3696 /** @see #putLongUnaligned(Object, long, long) */ 3697 @HotSpotIntrinsicCandidate 3698 public final void putShortUnaligned(Object o, long offset, short x) { 3699 if ((offset & 1) == 0) { 3700 putShort(o, offset, x); 3701 } else { 3702 putShortParts(o, offset, 3703 (byte)(x >>> 0), 3704 (byte)(x >>> 8)); 3705 } 3706 } 3707 /** @see #putLongUnaligned(Object, long, long, boolean) */ 3708 public final void putShortUnaligned(Object o, long offset, short x, boolean bigEndian) { 3709 putShortUnaligned(o, offset, convEndian(bigEndian, x)); 3710 } 3711 3712 /** @see #putLongUnaligned(Object, long, long) */ 3713 @HotSpotIntrinsicCandidate 3714 public final void putCharUnaligned(Object o, long offset, char x) { 3715 putShortUnaligned(o, offset, (short)x); 3716 } 3717 /** @see #putLongUnaligned(Object, long, long, boolean) */ 3718 public final void putCharUnaligned(Object o, long offset, char x, boolean bigEndian) { 3719 putCharUnaligned(o, offset, convEndian(bigEndian, x)); 3720 } 3721 3722 private static int pickPos(int top, int pos) { return BIG_ENDIAN ? top - pos : pos; } 3723 3724 // These methods construct integers from bytes. The byte ordering 3725 // is the native endianness of this platform. 3726 private static long makeLong(byte i0, byte i1, byte i2, byte i3, byte i4, byte i5, byte i6, byte i7) { 3727 return ((toUnsignedLong(i0) << pickPos(56, 0)) 3728 | (toUnsignedLong(i1) << pickPos(56, 8)) 3729 | (toUnsignedLong(i2) << pickPos(56, 16)) 3730 | (toUnsignedLong(i3) << pickPos(56, 24)) 3731 | (toUnsignedLong(i4) << pickPos(56, 32)) 3732 | (toUnsignedLong(i5) << pickPos(56, 40)) 3733 | (toUnsignedLong(i6) << pickPos(56, 48)) 3734 | (toUnsignedLong(i7) << pickPos(56, 56))); 3735 } 3736 private static long makeLong(short i0, short i1, short i2, short i3) { 3737 return ((toUnsignedLong(i0) << pickPos(48, 0)) 3738 | (toUnsignedLong(i1) << pickPos(48, 16)) 3739 | (toUnsignedLong(i2) << pickPos(48, 32)) 3740 | (toUnsignedLong(i3) << pickPos(48, 48))); 3741 } 3742 private static long makeLong(int i0, int i1) { 3743 return (toUnsignedLong(i0) << pickPos(32, 0)) 3744 | (toUnsignedLong(i1) << pickPos(32, 32)); 3745 } 3746 private static int makeInt(short i0, short i1) { 3747 return (toUnsignedInt(i0) << pickPos(16, 0)) 3748 | (toUnsignedInt(i1) << pickPos(16, 16)); 3749 } 3750 private static int makeInt(byte i0, byte i1, byte i2, byte i3) { 3751 return ((toUnsignedInt(i0) << pickPos(24, 0)) 3752 | (toUnsignedInt(i1) << pickPos(24, 8)) 3753 | (toUnsignedInt(i2) << pickPos(24, 16)) 3754 | (toUnsignedInt(i3) << pickPos(24, 24))); 3755 } 3756 private static short makeShort(byte i0, byte i1) { 3757 return (short)((toUnsignedInt(i0) << pickPos(8, 0)) 3758 | (toUnsignedInt(i1) << pickPos(8, 8))); 3759 } 3760 3761 private static byte pick(byte le, byte be) { return BIG_ENDIAN ? be : le; } 3762 private static short pick(short le, short be) { return BIG_ENDIAN ? be : le; } 3763 private static int pick(int le, int be) { return BIG_ENDIAN ? be : le; } 3764 3765 // These methods write integers to memory from smaller parts 3766 // provided by their caller. The ordering in which these parts 3767 // are written is the native endianness of this platform. 3768 private void putLongParts(Object o, long offset, byte i0, byte i1, byte i2, byte i3, byte i4, byte i5, byte i6, byte i7) { 3769 putByte(o, offset + 0, pick(i0, i7)); 3770 putByte(o, offset + 1, pick(i1, i6)); 3771 putByte(o, offset + 2, pick(i2, i5)); 3772 putByte(o, offset + 3, pick(i3, i4)); 3773 putByte(o, offset + 4, pick(i4, i3)); 3774 putByte(o, offset + 5, pick(i5, i2)); 3775 putByte(o, offset + 6, pick(i6, i1)); 3776 putByte(o, offset + 7, pick(i7, i0)); 3777 } 3778 private void putLongParts(Object o, long offset, short i0, short i1, short i2, short i3) { 3779 putShort(o, offset + 0, pick(i0, i3)); 3780 putShort(o, offset + 2, pick(i1, i2)); 3781 putShort(o, offset + 4, pick(i2, i1)); 3782 putShort(o, offset + 6, pick(i3, i0)); 3783 } 3784 private void putLongParts(Object o, long offset, int i0, int i1) { 3785 putInt(o, offset + 0, pick(i0, i1)); 3786 putInt(o, offset + 4, pick(i1, i0)); 3787 } 3788 private void putIntParts(Object o, long offset, short i0, short i1) { 3789 putShort(o, offset + 0, pick(i0, i1)); 3790 putShort(o, offset + 2, pick(i1, i0)); 3791 } 3792 private void putIntParts(Object o, long offset, byte i0, byte i1, byte i2, byte i3) { 3793 putByte(o, offset + 0, pick(i0, i3)); 3794 putByte(o, offset + 1, pick(i1, i2)); 3795 putByte(o, offset + 2, pick(i2, i1)); 3796 putByte(o, offset + 3, pick(i3, i0)); 3797 } 3798 private void putShortParts(Object o, long offset, byte i0, byte i1) { 3799 putByte(o, offset + 0, pick(i0, i1)); 3800 putByte(o, offset + 1, pick(i1, i0)); 3801 } 3802 3803 // Zero-extend an integer 3804 private static int toUnsignedInt(byte n) { return n & 0xff; } 3805 private static int toUnsignedInt(short n) { return n & 0xffff; } 3806 private static long toUnsignedLong(byte n) { return n & 0xffl; } 3807 private static long toUnsignedLong(short n) { return n & 0xffffl; } 3808 private static long toUnsignedLong(int n) { return n & 0xffffffffl; } 3809 3810 // Maybe byte-reverse an integer 3811 private static char convEndian(boolean big, char n) { return big == BIG_ENDIAN ? n : Character.reverseBytes(n); } 3812 private static short convEndian(boolean big, short n) { return big == BIG_ENDIAN ? n : Short.reverseBytes(n) ; } 3813 private static int convEndian(boolean big, int n) { return big == BIG_ENDIAN ? n : Integer.reverseBytes(n) ; } 3814 private static long convEndian(boolean big, long n) { return big == BIG_ENDIAN ? n : Long.reverseBytes(n) ; } 3815 3816 3817 3818 private native long allocateMemory0(long bytes); 3819 private native long reallocateMemory0(long address, long bytes); 3820 private native void freeMemory0(long address); 3821 private native void setMemory0(Object o, long offset, long bytes, byte value); 3822 @HotSpotIntrinsicCandidate 3823 private native void copyMemory0(Object srcBase, long srcOffset, Object destBase, long destOffset, long bytes); 3824 private native void copySwapMemory0(Object srcBase, long srcOffset, Object destBase, long destOffset, long bytes, long elemSize); 3825 private native long objectFieldOffset0(Field f); 3826 private native long objectFieldOffset1(Class<?> c, String name); 3827 private native long staticFieldOffset0(Field f); 3828 private native Object staticFieldBase0(Field f); 3829 private native boolean shouldBeInitialized0(Class<?> c); 3830 private native void ensureClassInitialized0(Class<?> c); 3831 private native int arrayBaseOffset0(Class<?> arrayClass); 3832 private native int arrayIndexScale0(Class<?> arrayClass); 3833 private native Class<?> defineAnonymousClass0(Class<?> hostClass, byte[] data, Object[] cpPatches); 3834 private native int getLoadAverage0(double[] loadavg, int nelems); 3835 3836 3837 /** 3838 * Invokes the given direct byte buffer's cleaner, if any. 3839 * 3840 * @param directBuffer a direct byte buffer 3841 * @throws NullPointerException if {@code directBuffer} is null 3842 * @throws IllegalArgumentException if {@code directBuffer} is non-direct, 3843 * or is a {@link java.nio.Buffer#slice slice}, or is a 3844 * {@link java.nio.Buffer#duplicate duplicate} 3845 */ 3846 public void invokeCleaner(java.nio.ByteBuffer directBuffer) { 3847 if (!directBuffer.isDirect()) 3848 throw new IllegalArgumentException("buffer is non-direct"); 3849 3850 DirectBuffer db = (DirectBuffer) directBuffer; 3851 if (db.attachment() != null) 3852 throw new IllegalArgumentException("duplicate or slice"); 3853 3854 Cleaner cleaner = db.cleaner(); 3855 if (cleaner != null) { 3856 cleaner.clean(); 3857 } 3858 } 3859 3860 // The following deprecated methods are used by JSR 166. 3861 3862 @Deprecated(since="12", forRemoval=true) 3863 public final Object getObject(Object o, long offset) { 3864 return getReference(o, offset); 3865 } 3866 @Deprecated(since="12", forRemoval=true) 3867 public final Object getObjectVolatile(Object o, long offset) { 3868 return getReferenceVolatile(o, offset); 3869 } 3870 @Deprecated(since="12", forRemoval=true) 3871 public final Object getObjectAcquire(Object o, long offset) { 3872 return getReferenceAcquire(o, offset); 3873 } 3874 @Deprecated(since="12", forRemoval=true) 3875 public final Object getObjectOpaque(Object o, long offset) { 3876 return getReferenceOpaque(o, offset); 3877 } 3878 3879 3880 @Deprecated(since="12", forRemoval=true) 3881 public final void putObject(Object o, long offset, Object x) { 3882 putReference(o, offset, x); 3883 } 3884 @Deprecated(since="12", forRemoval=true) 3885 public final void putObjectVolatile(Object o, long offset, Object x) { 3886 putReferenceVolatile(o, offset, x); 3887 } 3888 @Deprecated(since="12", forRemoval=true) 3889 public final void putObjectOpaque(Object o, long offset, Object x) { 3890 putReferenceOpaque(o, offset, x); 3891 } 3892 @Deprecated(since="12", forRemoval=true) 3893 public final void putObjectRelease(Object o, long offset, Object x) { 3894 putReferenceRelease(o, offset, x); 3895 } 3896 3897 3898 @Deprecated(since="12", forRemoval=true) 3899 public final Object getAndSetObject(Object o, long offset, Object newValue) { 3900 return getAndSetReference(o, offset, newValue); 3901 } 3902 @Deprecated(since="12", forRemoval=true) 3903 public final Object getAndSetObjectAcquire(Object o, long offset, Object newValue) { 3904 return getAndSetReferenceAcquire(o, offset, newValue); 3905 } 3906 @Deprecated(since="12", forRemoval=true) 3907 public final Object getAndSetObjectRelease(Object o, long offset, Object newValue) { 3908 return getAndSetReferenceRelease(o, offset, newValue); 3909 } 3910 3911 3912 @Deprecated(since="12", forRemoval=true) 3913 public final boolean compareAndSetObject(Object o, long offset, Object expected, Object x) { 3914 return compareAndSetReference(o, offset, expected, x); 3915 } 3916 @Deprecated(since="12", forRemoval=true) 3917 public final Object compareAndExchangeObject(Object o, long offset, Object expected, Object x) { 3918 return compareAndExchangeReference(o, offset, expected, x); 3919 } 3920 @Deprecated(since="12", forRemoval=true) 3921 public final Object compareAndExchangeObjectAcquire(Object o, long offset, Object expected, Object x) { 3922 return compareAndExchangeReferenceAcquire(o, offset, expected, x); 3923 } 3924 @Deprecated(since="12", forRemoval=true) 3925 public final Object compareAndExchangeObjectRelease(Object o, long offset, Object expected, Object x) { 3926 return compareAndExchangeReferenceRelease(o, offset, expected, x); 3927 } 3928 3929 3930 @Deprecated(since="12", forRemoval=true) 3931 public final boolean weakCompareAndSetObject(Object o, long offset, Object expected, Object x) { 3932 return weakCompareAndSetReference(o, offset, expected, x); 3933 } 3934 @Deprecated(since="12", forRemoval=true) 3935 public final boolean weakCompareAndSetObjectAcquire(Object o, long offset, Object expected, Object x) { 3936 return weakCompareAndSetReferenceAcquire(o, offset, expected, x); 3937 } 3938 @Deprecated(since="12", forRemoval=true) 3939 public final boolean weakCompareAndSetObjectPlain(Object o, long offset, Object expected, Object x) { 3940 return weakCompareAndSetReferencePlain(o, offset, expected, x); 3941 } 3942 @Deprecated(since="12", forRemoval=true) 3943 public final boolean weakCompareAndSetObjectRelease(Object o, long offset, Object expected, Object x) { 3944 return weakCompareAndSetReferenceRelease(o, offset, expected, x); 3945 } 3946 }