1 /* 2 * Copyright (c) 2000, 2023, 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 sun.misc; 27 28 import jdk.internal.vm.annotation.ForceInline; 29 import jdk.internal.misc.VM; 30 import jdk.internal.reflect.CallerSensitive; 31 import jdk.internal.reflect.Reflection; 32 33 import java.lang.reflect.Field; 34 import java.util.Set; 35 36 37 /** 38 * A collection of methods for performing low-level, unsafe operations. 39 * Although the class and all methods are public, use of this class is 40 * limited because only trusted code can obtain instances of it. 41 * 42 * <em>Note:</em> It is the responsibility of the caller to make sure 43 * arguments are checked before methods of this class are 44 * called. While some rudimentary checks are performed on the input, 45 * the checks are best effort and when performance is an overriding 46 * priority, as when methods of this class are optimized by the 47 * runtime compiler, some or all checks (if any) may be elided. Hence, 48 * the caller must not rely on the checks and corresponding 49 * exceptions! 50 * 51 * @author John R. Rose 52 * @see #getUnsafe 53 */ 54 55 public final class Unsafe { 56 57 static { 58 Reflection.registerMethodsToFilter(Unsafe.class, Set.of("getUnsafe")); 59 } 60 61 private Unsafe() {} 62 63 private static final Unsafe theUnsafe = new Unsafe(); 64 private static final jdk.internal.misc.Unsafe theInternalUnsafe = jdk.internal.misc.Unsafe.getUnsafe(); 65 66 /** 67 * Provides the caller with the capability of performing unsafe 68 * operations. 69 * 70 * <p>The returned {@code Unsafe} object should be carefully guarded 71 * by the caller, since it can be used to read and write data at arbitrary 72 * memory addresses. It must never be passed to untrusted code. 73 * 74 * <p>Most methods in this class are very low-level, and correspond to a 75 * small number of hardware instructions (on typical machines). Compilers 76 * are encouraged to optimize these methods accordingly. 77 * 78 * <p>Here is a suggested idiom for using unsafe operations: 79 * 80 * <pre> {@code 81 * class MyTrustedClass { 82 * private static final Unsafe unsafe = Unsafe.getUnsafe(); 83 * ... 84 * private long myCountAddress = ...; 85 * public int getCount() { return unsafe.getByte(myCountAddress); } 86 * }}</pre> 87 * 88 * (It may assist compilers to make the local variable {@code final}.) 89 * 90 * @throws SecurityException if the class loader of the caller 91 * class is not in the system domain in which all permissions 92 * are granted. 93 */ 94 @CallerSensitive 95 public static Unsafe getUnsafe() { 96 Class<?> caller = Reflection.getCallerClass(); 97 if (!VM.isSystemDomainLoader(caller.getClassLoader())) 98 throw new SecurityException("Unsafe"); 99 return theUnsafe; 100 } 101 102 /// peek and poke operations 103 /// (compilers should optimize these to memory ops) 104 105 // These work on object fields in the Java heap. 106 // They will not work on elements of packed arrays. 107 108 /** 109 * Fetches a value from a given Java variable. 110 * More specifically, fetches a field or array element within the given 111 * object {@code o} at the given offset, or (if {@code o} is null) 112 * from the memory address whose numerical value is the given offset. 113 * <p> 114 * The results are undefined unless one of the following cases is true: 115 * <ul> 116 * <li>The offset was obtained from {@link #objectFieldOffset} on 117 * the {@link java.lang.reflect.Field} of some Java field and the object 118 * referred to by {@code o} is of a class compatible with that 119 * field's class. 120 * 121 * <li>The offset and object reference {@code o} (either null or 122 * non-null) were both obtained via {@link #staticFieldOffset} 123 * and {@link #staticFieldBase} (respectively) from the 124 * reflective {@link Field} representation of some Java field. 125 * 126 * <li>The object referred to by {@code o} is an array, and the offset 127 * is an integer of the form {@code B+N*S}, where {@code N} is 128 * a valid index into the array, and {@code B} and {@code S} are 129 * the values obtained by {@link #arrayBaseOffset} and {@link 130 * #arrayIndexScale} (respectively) from the array's class. The value 131 * referred to is the {@code N}<em>th</em> element of the array. 132 * 133 * </ul> 134 * <p> 135 * If one of the above cases is true, the call references a specific Java 136 * variable (field or array element). However, the results are undefined 137 * if that variable is not in fact of the type returned by this method. 138 * <p> 139 * This method refers to a variable by means of two parameters, and so 140 * it provides (in effect) a <em>double-register</em> addressing mode 141 * for Java variables. When the object reference is null, this method 142 * uses its offset as an absolute address. This is similar in operation 143 * to methods such as {@link #getInt(long)}, which provide (in effect) a 144 * <em>single-register</em> addressing mode for non-Java variables. 145 * However, because Java variables may have a different layout in memory 146 * from non-Java variables, programmers should not assume that these 147 * two addressing modes are ever equivalent. Also, programmers should 148 * remember that offsets from the double-register addressing mode cannot 149 * be portably confused with longs used in the single-register addressing 150 * mode. 151 * 152 * @param o Java heap object in which the variable resides, if any, else 153 * null 154 * @param offset indication of where the variable resides in a Java heap 155 * object, if any, else a memory address locating the variable 156 * statically 157 * @return the value fetched from the indicated Java variable 158 * @throws RuntimeException No defined exceptions are thrown, not even 159 * {@link NullPointerException} 160 */ 161 @ForceInline 162 public int getInt(Object o, long offset) { 163 return theInternalUnsafe.getInt(o, offset); 164 } 165 166 /** 167 * Stores a value into a given Java variable. 168 * <p> 169 * The first two parameters are interpreted exactly as with 170 * {@link #getInt(Object, long)} to refer to a specific 171 * Java variable (field or array element). The given value 172 * is stored into that variable. 173 * <p> 174 * The variable must be of the same type as the method 175 * parameter {@code x}. 176 * 177 * @param o Java heap object in which the variable resides, if any, else 178 * null 179 * @param offset indication of where the variable resides in a Java heap 180 * object, if any, else a memory address locating the variable 181 * statically 182 * @param x the value to store into the indicated Java variable 183 * @throws RuntimeException No defined exceptions are thrown, not even 184 * {@link NullPointerException} 185 */ 186 @ForceInline 187 public void putInt(Object o, long offset, int x) { 188 theInternalUnsafe.putInt(o, offset, x); 189 } 190 191 /** 192 * Fetches a reference value from a given Java variable. 193 * @see #getInt(Object, long) 194 */ 195 @ForceInline 196 public Object getObject(Object o, long offset) { 197 return theInternalUnsafe.getReference(o, offset); 198 } 199 200 /** 201 * Stores a reference value into a given Java variable. 202 * <p> 203 * Unless the reference {@code x} being stored is either null 204 * or matches the field type, the results are undefined. 205 * If the reference {@code o} is non-null, card marks or 206 * other store barriers for that object (if the VM requires them) 207 * are updated. 208 * @see #putInt(Object, long, int) 209 */ 210 @ForceInline 211 public void putObject(Object o, long offset, Object x) { 212 theInternalUnsafe.putReference(o, offset, x); 213 } 214 215 /** @see #getInt(Object, long) */ 216 @ForceInline 217 public boolean getBoolean(Object o, long offset) { 218 return theInternalUnsafe.getBoolean(o, offset); 219 } 220 221 /** @see #putInt(Object, long, int) */ 222 @ForceInline 223 public void putBoolean(Object o, long offset, boolean x) { 224 theInternalUnsafe.putBoolean(o, offset, x); 225 } 226 227 /** @see #getInt(Object, long) */ 228 @ForceInline 229 public byte getByte(Object o, long offset) { 230 return theInternalUnsafe.getByte(o, offset); 231 } 232 233 /** @see #putInt(Object, long, int) */ 234 @ForceInline 235 public void putByte(Object o, long offset, byte x) { 236 theInternalUnsafe.putByte(o, offset, x); 237 } 238 239 /** @see #getInt(Object, long) */ 240 @ForceInline 241 public short getShort(Object o, long offset) { 242 return theInternalUnsafe.getShort(o, offset); 243 } 244 245 /** @see #putInt(Object, long, int) */ 246 @ForceInline 247 public void putShort(Object o, long offset, short x) { 248 theInternalUnsafe.putShort(o, offset, x); 249 } 250 251 /** @see #getInt(Object, long) */ 252 @ForceInline 253 public char getChar(Object o, long offset) { 254 return theInternalUnsafe.getChar(o, offset); 255 } 256 257 /** @see #putInt(Object, long, int) */ 258 @ForceInline 259 public void putChar(Object o, long offset, char x) { 260 theInternalUnsafe.putChar(o, offset, x); 261 } 262 263 /** @see #getInt(Object, long) */ 264 @ForceInline 265 public long getLong(Object o, long offset) { 266 return theInternalUnsafe.getLong(o, offset); 267 } 268 269 /** @see #putInt(Object, long, int) */ 270 @ForceInline 271 public void putLong(Object o, long offset, long x) { 272 theInternalUnsafe.putLong(o, offset, x); 273 } 274 275 /** @see #getInt(Object, long) */ 276 @ForceInline 277 public float getFloat(Object o, long offset) { 278 return theInternalUnsafe.getFloat(o, offset); 279 } 280 281 /** @see #putInt(Object, long, int) */ 282 @ForceInline 283 public void putFloat(Object o, long offset, float x) { 284 theInternalUnsafe.putFloat(o, offset, x); 285 } 286 287 /** @see #getInt(Object, long) */ 288 @ForceInline 289 public double getDouble(Object o, long offset) { 290 return theInternalUnsafe.getDouble(o, offset); 291 } 292 293 /** @see #putInt(Object, long, int) */ 294 @ForceInline 295 public void putDouble(Object o, long offset, double x) { 296 theInternalUnsafe.putDouble(o, offset, x); 297 } 298 299 // These work on values in the C heap. 300 301 /** 302 * Fetches a value from a given memory address. If the address is zero, or 303 * does not point into a block obtained from {@link #allocateMemory}, the 304 * results are undefined. 305 * 306 * @see #allocateMemory 307 */ 308 @ForceInline 309 public byte getByte(long address) { 310 return theInternalUnsafe.getByte(address); 311 } 312 313 /** 314 * Stores a value into 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 #getByte(long) 319 */ 320 @ForceInline 321 public void putByte(long address, byte x) { 322 theInternalUnsafe.putByte(address, x); 323 } 324 325 /** @see #getByte(long) */ 326 @ForceInline 327 public short getShort(long address) { 328 return theInternalUnsafe.getShort(address); 329 } 330 331 /** @see #putByte(long, byte) */ 332 @ForceInline 333 public void putShort(long address, short x) { 334 theInternalUnsafe.putShort(address, x); 335 } 336 337 /** @see #getByte(long) */ 338 @ForceInline 339 public char getChar(long address) { 340 return theInternalUnsafe.getChar(address); 341 } 342 343 /** @see #putByte(long, byte) */ 344 @ForceInline 345 public void putChar(long address, char x) { 346 theInternalUnsafe.putChar(address, x); 347 } 348 349 /** @see #getByte(long) */ 350 @ForceInline 351 public int getInt(long address) { 352 return theInternalUnsafe.getInt(address); 353 } 354 355 /** @see #putByte(long, byte) */ 356 @ForceInline 357 public void putInt(long address, int x) { 358 theInternalUnsafe.putInt(address, x); 359 } 360 361 /** @see #getByte(long) */ 362 @ForceInline 363 public long getLong(long address) { 364 return theInternalUnsafe.getLong(address); 365 } 366 367 /** @see #putByte(long, byte) */ 368 @ForceInline 369 public void putLong(long address, long x) { 370 theInternalUnsafe.putLong(address, x); 371 } 372 373 /** @see #getByte(long) */ 374 @ForceInline 375 public float getFloat(long address) { 376 return theInternalUnsafe.getFloat(address); 377 } 378 379 /** @see #putByte(long, byte) */ 380 @ForceInline 381 public void putFloat(long address, float x) { 382 theInternalUnsafe.putFloat(address, x); 383 } 384 385 /** @see #getByte(long) */ 386 @ForceInline 387 public double getDouble(long address) { 388 return theInternalUnsafe.getDouble(address); 389 } 390 391 /** @see #putByte(long, byte) */ 392 @ForceInline 393 public void putDouble(long address, double x) { 394 theInternalUnsafe.putDouble(address, x); 395 } 396 397 398 /** 399 * Fetches a native pointer from a given memory address. If the address is 400 * zero, or does not point into a block obtained from {@link 401 * #allocateMemory}, the results are undefined. 402 * 403 * <p>If the native pointer is less than 64 bits wide, it is extended as 404 * an unsigned number to a Java long. The pointer may be indexed by any 405 * given byte offset, simply by adding that offset (as a simple integer) to 406 * the long representing the pointer. The number of bytes actually read 407 * from the target address may be determined by consulting {@link 408 * #addressSize}. 409 * 410 * @see #allocateMemory 411 */ 412 @ForceInline 413 public long getAddress(long address) { 414 return theInternalUnsafe.getAddress(address); 415 } 416 417 /** 418 * Stores a native pointer into a given memory address. If the address is 419 * zero, or does not point into a block obtained from {@link 420 * #allocateMemory}, the results are undefined. 421 * 422 * <p>The number of bytes actually written at the target address may be 423 * determined by consulting {@link #addressSize}. 424 * 425 * @see #getAddress(long) 426 */ 427 @ForceInline 428 public void putAddress(long address, long x) { 429 theInternalUnsafe.putAddress(address, x); 430 } 431 432 433 /// wrappers for malloc, realloc, free: 434 435 /** 436 * Allocates a new block of native memory, of the given size in bytes. The 437 * contents of the memory are uninitialized; they will generally be 438 * garbage. The resulting native pointer will never be zero, and will be 439 * aligned for all value types. Dispose of this memory by calling {@link 440 * #freeMemory}, or resize it with {@link #reallocateMemory}. 441 * 442 * <em>Note:</em> It is the responsibility of the caller to make 443 * sure arguments are checked before the methods are called. While 444 * some rudimentary checks are performed on the input, the checks 445 * are best effort and when performance is an overriding priority, 446 * as when methods of this class are optimized by the runtime 447 * compiler, some or all checks (if any) may be elided. Hence, the 448 * caller must not rely on the checks and corresponding 449 * exceptions! 450 * 451 * @throws RuntimeException if the size is negative or too large 452 * for the native size_t type 453 * 454 * @throws OutOfMemoryError if the allocation is refused by the system 455 * 456 * @see #getByte(long) 457 * @see #putByte(long, byte) 458 */ 459 @ForceInline 460 public long allocateMemory(long bytes) { 461 return theInternalUnsafe.allocateMemory(bytes); 462 } 463 464 /** 465 * Resizes a new block of native memory, to the given size in bytes. The 466 * contents of the new block past the size of the old block are 467 * uninitialized; they will generally be garbage. The resulting native 468 * pointer will be zero if and only if the requested size is zero. The 469 * resulting native pointer will be aligned for all value types. Dispose 470 * of this memory by calling {@link #freeMemory}, or resize it with {@link 471 * #reallocateMemory}. The address passed to this method may be null, in 472 * which case an allocation will be performed. 473 * 474 * <em>Note:</em> It is the responsibility of the caller to make 475 * sure arguments are checked before the methods are called. While 476 * some rudimentary checks are performed on the input, the checks 477 * are best effort and when performance is an overriding priority, 478 * as when methods of this class are optimized by the runtime 479 * compiler, some or all checks (if any) may be elided. Hence, the 480 * caller must not rely on the checks and corresponding 481 * exceptions! 482 * 483 * @throws RuntimeException if the size is negative or too large 484 * for the native size_t type 485 * 486 * @throws OutOfMemoryError if the allocation is refused by the system 487 * 488 * @see #allocateMemory 489 */ 490 @ForceInline 491 public long reallocateMemory(long address, long bytes) { 492 return theInternalUnsafe.reallocateMemory(address, bytes); 493 } 494 495 /** 496 * Sets all bytes in a given block of memory to a fixed value 497 * (usually zero). 498 * 499 * <p>This method determines a block's base address by means of two parameters, 500 * and so it provides (in effect) a <em>double-register</em> addressing mode, 501 * as discussed in {@link #getInt(Object,long)}. When the object reference is null, 502 * the offset supplies an absolute base address. 503 * 504 * <p>The stores are in coherent (atomic) units of a size determined 505 * by the address and length parameters. If the effective address and 506 * length are all even modulo 8, the stores take place in 'long' units. 507 * If the effective address and length are (resp.) even modulo 4 or 2, 508 * the stores take place in units of 'int' or 'short'. 509 * 510 * <em>Note:</em> It is the responsibility of the caller to make 511 * sure arguments are checked before the methods are called. While 512 * some rudimentary checks are performed on the input, the checks 513 * are best effort and when performance is an overriding priority, 514 * as when methods of this class are optimized by the runtime 515 * compiler, some or all checks (if any) may be elided. Hence, the 516 * caller must not rely on the checks and corresponding 517 * exceptions! 518 * 519 * @throws RuntimeException if any of the arguments is invalid 520 * 521 * @since 1.7 522 */ 523 @ForceInline 524 public void setMemory(Object o, long offset, long bytes, byte value) { 525 theInternalUnsafe.setMemory(o, offset, bytes, value); 526 } 527 528 /** 529 * Sets all bytes in a given block of memory to a fixed value 530 * (usually zero). This provides a <em>single-register</em> addressing mode, 531 * as discussed in {@link #getInt(Object,long)}. 532 * 533 * <p>Equivalent to {@code setMemory(null, address, bytes, value)}. 534 */ 535 @ForceInline 536 public void setMemory(long address, long bytes, byte value) { 537 theInternalUnsafe.setMemory(address, bytes, value); 538 } 539 540 /** 541 * Sets all bytes in a given block of memory to a copy of another 542 * block. 543 * 544 * <p>This method determines each block's base address by means of two parameters, 545 * and so it provides (in effect) a <em>double-register</em> addressing mode, 546 * as discussed in {@link #getInt(Object,long)}. When the object reference is null, 547 * the offset supplies an absolute base address. 548 * 549 * <p>The transfers are in coherent (atomic) units of a size determined 550 * by the address and length parameters. If the effective addresses and 551 * length are all even modulo 8, the transfer takes place in 'long' units. 552 * If the effective addresses and length are (resp.) even modulo 4 or 2, 553 * the transfer takes place in units of 'int' or 'short'. 554 * 555 * <em>Note:</em> It is the responsibility of the caller to make 556 * sure arguments are checked before the methods are called. While 557 * some rudimentary checks are performed on the input, the checks 558 * are best effort and when performance is an overriding priority, 559 * as when methods of this class are optimized by the runtime 560 * compiler, some or all checks (if any) may be elided. Hence, the 561 * caller must not rely on the checks and corresponding 562 * exceptions! 563 * 564 * @throws RuntimeException if any of the arguments is invalid 565 * 566 * @since 1.7 567 */ 568 @ForceInline 569 public void copyMemory(Object srcBase, long srcOffset, 570 Object destBase, long destOffset, 571 long bytes) { 572 theInternalUnsafe.copyMemory(srcBase, srcOffset, destBase, destOffset, bytes); 573 } 574 575 /** 576 * Sets all bytes in a given block of memory to a copy of another 577 * block. This provides a <em>single-register</em> addressing mode, 578 * as discussed in {@link #getInt(Object,long)}. 579 * 580 * Equivalent to {@code copyMemory(null, srcAddress, null, destAddress, bytes)}. 581 */ 582 @ForceInline 583 public void copyMemory(long srcAddress, long destAddress, long bytes) { 584 theInternalUnsafe.copyMemory(srcAddress, destAddress, bytes); 585 } 586 587 /** 588 * Disposes of a block of native memory, as obtained from {@link 589 * #allocateMemory} or {@link #reallocateMemory}. The address passed to 590 * this method may be null, in which case no action is taken. 591 * 592 * <em>Note:</em> It is the responsibility of the caller to make 593 * sure arguments are checked before the methods are called. While 594 * some rudimentary checks are performed on the input, the checks 595 * are best effort and when performance is an overriding priority, 596 * as when methods of this class are optimized by the runtime 597 * compiler, some or all checks (if any) may be elided. Hence, the 598 * caller must not rely on the checks and corresponding 599 * exceptions! 600 * 601 * @throws RuntimeException if any of the arguments is invalid 602 * 603 * @see #allocateMemory 604 */ 605 @ForceInline 606 public void freeMemory(long address) { 607 theInternalUnsafe.freeMemory(address); 608 } 609 610 /// random queries 611 612 /** 613 * This constant differs from all results that will ever be returned from 614 * {@link #staticFieldOffset}, {@link #objectFieldOffset}, 615 * or {@link #arrayBaseOffset}. 616 */ 617 public static final int INVALID_FIELD_OFFSET = jdk.internal.misc.Unsafe.INVALID_FIELD_OFFSET; 618 619 /** 620 * Reports the location of a given field in the storage allocation of its 621 * class. Do not expect to perform any sort of arithmetic on this offset; 622 * it is just a cookie which is passed to the unsafe heap memory accessors. 623 * 624 * <p>Any given field will always have the same offset and base, and no 625 * two distinct fields of the same class will ever have the same offset 626 * and base. 627 * 628 * <p>As of 1.4.1, offsets for fields are represented as long values, 629 * although the Sun JVM does not use the most significant 32 bits. 630 * However, JVM implementations which store static fields at absolute 631 * addresses can use long offsets and null base pointers to express 632 * the field locations in a form usable by {@link #getInt(Object,long)}. 633 * Therefore, code which will be ported to such JVMs on 64-bit platforms 634 * must preserve all bits of static field offsets. 635 * 636 * @deprecated The guarantee that a field will always have the same offset 637 * and base may not be true in a future release. The ability to provide an 638 * offset and object reference to a heap memory accessor will be removed 639 * in a future release. Use {@link java.lang.invoke.VarHandle} instead. 640 * 641 * @see #getInt(Object, long) 642 */ 643 @Deprecated(since="18") 644 @ForceInline 645 public long objectFieldOffset(Field f) { 646 if (f == null) { 647 throw new NullPointerException(); 648 } 649 Class<?> declaringClass = f.getDeclaringClass(); 650 if (declaringClass.isHidden()) { 651 throw new UnsupportedOperationException("can't get field offset on a hidden class: " + f); 652 } 653 if (declaringClass.isRecord()) { 654 throw new UnsupportedOperationException("can't get field offset on a record class: " + f); 655 } 656 return theInternalUnsafe.objectFieldOffset(f); 657 } 658 659 /** 660 * Reports the location of a given static field, in conjunction with {@link 661 * #staticFieldBase}. 662 * <p>Do not expect to perform any sort of arithmetic on this offset; 663 * it is just a cookie which is passed to the unsafe heap memory accessors. 664 * 665 * <p>Any given field will always have the same offset, and no two distinct 666 * fields of the same class will ever have the same offset. 667 * 668 * <p>As of 1.4.1, offsets for fields are represented as long values, 669 * although the Sun JVM does not use the most significant 32 bits. 670 * It is hard to imagine a JVM technology which needs more than 671 * a few bits to encode an offset within a non-array object, 672 * However, for consistency with other methods in this class, 673 * this method reports its result as a long value. 674 * 675 * @deprecated The guarantee that a field will always have the same offset 676 * and base may not be true in a future release. The ability to provide an 677 * offset and object reference to a heap memory accessor will be removed 678 * in a future release. Use {@link java.lang.invoke.VarHandle} instead. 679 * 680 * @see #getInt(Object, long) 681 */ 682 @Deprecated(since="18") 683 @ForceInline 684 public long staticFieldOffset(Field f) { 685 if (f == null) { 686 throw new NullPointerException(); 687 } 688 Class<?> declaringClass = f.getDeclaringClass(); 689 if (declaringClass.isHidden()) { 690 throw new UnsupportedOperationException("can't get field offset on a hidden class: " + f); 691 } 692 if (declaringClass.isRecord()) { 693 throw new UnsupportedOperationException("can't get field offset on a record class: " + f); 694 } 695 return theInternalUnsafe.staticFieldOffset(f); 696 } 697 698 /** 699 * Reports the location of a given static field, in conjunction with {@link 700 * #staticFieldOffset}. 701 * <p>Fetch the base "Object", if any, with which static fields of the 702 * given class can be accessed via methods like {@link #getInt(Object, 703 * long)}. This value may be null. This value may refer to an object 704 * which is a "cookie", not guaranteed to be a real Object, and it should 705 * not be used in any way except as argument to the get and put routines in 706 * this class. 707 * 708 * @deprecated The guarantee that a field will always have the same offset 709 * and base may not be true in a future release. The ability to provide an 710 * offset and object reference to a heap memory accessor will be removed 711 * in a future release. Use {@link java.lang.invoke.VarHandle} instead. 712 */ 713 @Deprecated(since="18") 714 @ForceInline 715 public Object staticFieldBase(Field f) { 716 if (f == null) { 717 throw new NullPointerException(); 718 } 719 Class<?> declaringClass = f.getDeclaringClass(); 720 if (declaringClass.isHidden()) { 721 throw new UnsupportedOperationException("can't get base address on a hidden class: " + f); 722 } 723 if (declaringClass.isRecord()) { 724 throw new UnsupportedOperationException("can't get base address on a record class: " + f); 725 } 726 return theInternalUnsafe.staticFieldBase(f); 727 } 728 729 /** 730 * Reports the offset of the first element in the storage allocation of a 731 * given array class. If {@link #arrayIndexScale} returns a non-zero value 732 * for the same class, you may use that scale factor, together with this 733 * base offset, to form new offsets to access elements of arrays of the 734 * given class. 735 * 736 * @see #getInt(Object, long) 737 * @see #putInt(Object, long, int) 738 */ 739 @ForceInline 740 public int arrayBaseOffset(Class<?> arrayClass) { 741 return theInternalUnsafe.arrayBaseOffset(arrayClass); 742 } 743 744 /** The value of {@code arrayBaseOffset(boolean[].class)} */ 745 public static final int ARRAY_BOOLEAN_BASE_OFFSET = jdk.internal.misc.Unsafe.ARRAY_BOOLEAN_BASE_OFFSET; 746 747 /** The value of {@code arrayBaseOffset(byte[].class)} */ 748 public static final int ARRAY_BYTE_BASE_OFFSET = jdk.internal.misc.Unsafe.ARRAY_BYTE_BASE_OFFSET; 749 750 /** The value of {@code arrayBaseOffset(short[].class)} */ 751 public static final int ARRAY_SHORT_BASE_OFFSET = jdk.internal.misc.Unsafe.ARRAY_SHORT_BASE_OFFSET; 752 753 /** The value of {@code arrayBaseOffset(char[].class)} */ 754 public static final int ARRAY_CHAR_BASE_OFFSET = jdk.internal.misc.Unsafe.ARRAY_CHAR_BASE_OFFSET; 755 756 /** The value of {@code arrayBaseOffset(int[].class)} */ 757 public static final int ARRAY_INT_BASE_OFFSET = jdk.internal.misc.Unsafe.ARRAY_INT_BASE_OFFSET; 758 759 /** The value of {@code arrayBaseOffset(long[].class)} */ 760 public static final int ARRAY_LONG_BASE_OFFSET = jdk.internal.misc.Unsafe.ARRAY_LONG_BASE_OFFSET; 761 762 /** The value of {@code arrayBaseOffset(float[].class)} */ 763 public static final int ARRAY_FLOAT_BASE_OFFSET = jdk.internal.misc.Unsafe.ARRAY_FLOAT_BASE_OFFSET; 764 765 /** The value of {@code arrayBaseOffset(double[].class)} */ 766 public static final int ARRAY_DOUBLE_BASE_OFFSET = jdk.internal.misc.Unsafe.ARRAY_DOUBLE_BASE_OFFSET; 767 768 /** The value of {@code arrayBaseOffset(Object[].class)} */ 769 public static final int ARRAY_OBJECT_BASE_OFFSET = jdk.internal.misc.Unsafe.ARRAY_OBJECT_BASE_OFFSET; 770 771 /** 772 * Reports the scale factor for addressing elements in the storage 773 * allocation of a given array class. However, arrays of "narrow" types 774 * will generally not work properly with accessors like {@link 775 * #getByte(Object, long)}, so the scale factor for such classes is reported 776 * as zero. 777 * 778 * @see #arrayBaseOffset 779 * @see #getInt(Object, long) 780 * @see #putInt(Object, long, int) 781 */ 782 @ForceInline 783 public int arrayIndexScale(Class<?> arrayClass) { 784 return theInternalUnsafe.arrayIndexScale(arrayClass); 785 } 786 787 /** The value of {@code arrayIndexScale(boolean[].class)} */ 788 public static final int ARRAY_BOOLEAN_INDEX_SCALE = jdk.internal.misc.Unsafe.ARRAY_BOOLEAN_INDEX_SCALE; 789 790 /** The value of {@code arrayIndexScale(byte[].class)} */ 791 public static final int ARRAY_BYTE_INDEX_SCALE = jdk.internal.misc.Unsafe.ARRAY_BYTE_INDEX_SCALE; 792 793 /** The value of {@code arrayIndexScale(short[].class)} */ 794 public static final int ARRAY_SHORT_INDEX_SCALE = jdk.internal.misc.Unsafe.ARRAY_SHORT_INDEX_SCALE; 795 796 /** The value of {@code arrayIndexScale(char[].class)} */ 797 public static final int ARRAY_CHAR_INDEX_SCALE = jdk.internal.misc.Unsafe.ARRAY_CHAR_INDEX_SCALE; 798 799 /** The value of {@code arrayIndexScale(int[].class)} */ 800 public static final int ARRAY_INT_INDEX_SCALE = jdk.internal.misc.Unsafe.ARRAY_INT_INDEX_SCALE; 801 802 /** The value of {@code arrayIndexScale(long[].class)} */ 803 public static final int ARRAY_LONG_INDEX_SCALE = jdk.internal.misc.Unsafe.ARRAY_LONG_INDEX_SCALE; 804 805 /** The value of {@code arrayIndexScale(float[].class)} */ 806 public static final int ARRAY_FLOAT_INDEX_SCALE = jdk.internal.misc.Unsafe.ARRAY_FLOAT_INDEX_SCALE; 807 808 /** The value of {@code arrayIndexScale(double[].class)} */ 809 public static final int ARRAY_DOUBLE_INDEX_SCALE = jdk.internal.misc.Unsafe.ARRAY_DOUBLE_INDEX_SCALE; 810 811 /** The value of {@code arrayIndexScale(Object[].class)} */ 812 public static final int ARRAY_OBJECT_INDEX_SCALE = jdk.internal.misc.Unsafe.ARRAY_OBJECT_INDEX_SCALE; 813 814 /** 815 * Reports the size in bytes of a native pointer, as stored via {@link 816 * #putAddress}. This value will be either 4 or 8. Note that the sizes of 817 * other primitive types (as stored in native memory blocks) is determined 818 * fully by their information content. 819 */ 820 @ForceInline 821 public int addressSize() { 822 return theInternalUnsafe.addressSize(); 823 } 824 825 /** The value of {@code addressSize()} */ 826 public static final int ADDRESS_SIZE = theInternalUnsafe.addressSize(); 827 828 /** 829 * Reports the size in bytes of a native memory page (whatever that is). 830 * This value will always be a power of two. 831 */ 832 @ForceInline 833 public int pageSize() { 834 return theInternalUnsafe.pageSize(); 835 } 836 837 838 /// random trusted operations from JNI: 839 840 /** 841 * Allocates an instance but does not run any constructor. 842 * Initializes the class if it has not yet been. 843 */ 844 @ForceInline 845 public Object allocateInstance(Class<?> cls) 846 throws InstantiationException { 847 return theInternalUnsafe.allocateInstance(cls); 848 } 849 850 /** Throws the exception without telling the verifier. */ 851 @ForceInline 852 public void throwException(Throwable ee) { 853 theInternalUnsafe.throwException(ee); 854 } 855 856 /** 857 * Atomically updates Java variable to {@code x} if it is currently 858 * holding {@code expected}. 859 * 860 * <p>This operation has memory semantics of a {@code volatile} read 861 * and write. Corresponds to C11 atomic_compare_exchange_strong. 862 * 863 * @return {@code true} if successful 864 */ 865 @ForceInline 866 public final boolean compareAndSwapObject(Object o, long offset, 867 Object expected, 868 Object x) { 869 return theInternalUnsafe.compareAndSetReference(o, offset, expected, x); 870 } 871 872 /** 873 * Atomically updates Java variable to {@code x} if it is currently 874 * holding {@code expected}. 875 * 876 * <p>This operation has memory semantics of a {@code volatile} read 877 * and write. Corresponds to C11 atomic_compare_exchange_strong. 878 * 879 * @return {@code true} if successful 880 */ 881 @ForceInline 882 public final boolean compareAndSwapInt(Object o, long offset, 883 int expected, 884 int x) { 885 return theInternalUnsafe.compareAndSetInt(o, offset, expected, x); 886 } 887 888 /** 889 * Atomically updates Java variable to {@code x} if it is currently 890 * holding {@code expected}. 891 * 892 * <p>This operation has memory semantics of a {@code volatile} read 893 * and write. Corresponds to C11 atomic_compare_exchange_strong. 894 * 895 * @return {@code true} if successful 896 */ 897 @ForceInline 898 public final boolean compareAndSwapLong(Object o, long offset, 899 long expected, 900 long x) { 901 return theInternalUnsafe.compareAndSetLong(o, offset, expected, x); 902 } 903 904 /** 905 * Fetches a reference value from a given Java variable, with volatile 906 * load semantics. Otherwise identical to {@link #getObject(Object, long)} 907 */ 908 @ForceInline 909 public Object getObjectVolatile(Object o, long offset) { 910 return theInternalUnsafe.getReferenceVolatile(o, offset); 911 } 912 913 /** 914 * Stores a reference value into a given Java variable, with 915 * volatile store semantics. Otherwise identical to {@link #putObject(Object, long, Object)} 916 */ 917 @ForceInline 918 public void putObjectVolatile(Object o, long offset, Object x) { 919 theInternalUnsafe.putReferenceVolatile(o, offset, x); 920 } 921 922 /** Volatile version of {@link #getInt(Object, long)} */ 923 @ForceInline 924 public int getIntVolatile(Object o, long offset) { 925 return theInternalUnsafe.getIntVolatile(o, offset); 926 } 927 928 /** Volatile version of {@link #putInt(Object, long, int)} */ 929 @ForceInline 930 public void putIntVolatile(Object o, long offset, int x) { 931 theInternalUnsafe.putIntVolatile(o, offset, x); 932 } 933 934 /** Volatile version of {@link #getBoolean(Object, long)} */ 935 @ForceInline 936 public boolean getBooleanVolatile(Object o, long offset) { 937 return theInternalUnsafe.getBooleanVolatile(o, offset); 938 } 939 940 /** Volatile version of {@link #putBoolean(Object, long, boolean)} */ 941 @ForceInline 942 public void putBooleanVolatile(Object o, long offset, boolean x) { 943 theInternalUnsafe.putBooleanVolatile(o, offset, x); 944 } 945 946 /** Volatile version of {@link #getByte(Object, long)} */ 947 @ForceInline 948 public byte getByteVolatile(Object o, long offset) { 949 return theInternalUnsafe.getByteVolatile(o, offset); 950 } 951 952 /** Volatile version of {@link #putByte(Object, long, byte)} */ 953 @ForceInline 954 public void putByteVolatile(Object o, long offset, byte x) { 955 theInternalUnsafe.putByteVolatile(o, offset, x); 956 } 957 958 /** Volatile version of {@link #getShort(Object, long)} */ 959 @ForceInline 960 public short getShortVolatile(Object o, long offset) { 961 return theInternalUnsafe.getShortVolatile(o, offset); 962 } 963 964 /** Volatile version of {@link #putShort(Object, long, short)} */ 965 @ForceInline 966 public void putShortVolatile(Object o, long offset, short x) { 967 theInternalUnsafe.putShortVolatile(o, offset, x); 968 } 969 970 /** Volatile version of {@link #getChar(Object, long)} */ 971 @ForceInline 972 public char getCharVolatile(Object o, long offset) { 973 return theInternalUnsafe.getCharVolatile(o, offset); 974 } 975 976 /** Volatile version of {@link #putChar(Object, long, char)} */ 977 @ForceInline 978 public void putCharVolatile(Object o, long offset, char x) { 979 theInternalUnsafe.putCharVolatile(o, offset, x); 980 } 981 982 /** Volatile version of {@link #getLong(Object, long)} */ 983 @ForceInline 984 public long getLongVolatile(Object o, long offset) { 985 return theInternalUnsafe.getLongVolatile(o, offset); 986 } 987 988 /** Volatile version of {@link #putLong(Object, long, long)} */ 989 @ForceInline 990 public void putLongVolatile(Object o, long offset, long x) { 991 theInternalUnsafe.putLongVolatile(o, offset, x); 992 } 993 994 /** Volatile version of {@link #getFloat(Object, long)} */ 995 @ForceInline 996 public float getFloatVolatile(Object o, long offset) { 997 return theInternalUnsafe.getFloatVolatile(o, offset); 998 } 999 1000 /** Volatile version of {@link #putFloat(Object, long, float)} */ 1001 @ForceInline 1002 public void putFloatVolatile(Object o, long offset, float x) { 1003 theInternalUnsafe.putFloatVolatile(o, offset, x); 1004 } 1005 1006 /** Volatile version of {@link #getDouble(Object, long)} */ 1007 @ForceInline 1008 public double getDoubleVolatile(Object o, long offset) { 1009 return theInternalUnsafe.getDoubleVolatile(o, offset); 1010 } 1011 1012 /** Volatile version of {@link #putDouble(Object, long, double)} */ 1013 @ForceInline 1014 public void putDoubleVolatile(Object o, long offset, double x) { 1015 theInternalUnsafe.putDoubleVolatile(o, offset, x); 1016 } 1017 1018 /** 1019 * Version of {@link #putObjectVolatile(Object, long, Object)} 1020 * that does not guarantee immediate visibility of the store to 1021 * other threads. This method is generally only useful if the 1022 * underlying field is a Java volatile (or if an array cell, one 1023 * that is otherwise only accessed using volatile accesses). 1024 * 1025 * Corresponds to C11 atomic_store_explicit(..., memory_order_release). 1026 */ 1027 @ForceInline 1028 public void putOrderedObject(Object o, long offset, Object x) { 1029 theInternalUnsafe.putReferenceRelease(o, offset, x); 1030 } 1031 1032 /** Ordered/Lazy version of {@link #putIntVolatile(Object, long, int)} */ 1033 @ForceInline 1034 public void putOrderedInt(Object o, long offset, int x) { 1035 theInternalUnsafe.putIntRelease(o, offset, x); 1036 } 1037 1038 /** Ordered/Lazy version of {@link #putLongVolatile(Object, long, long)} */ 1039 @ForceInline 1040 public void putOrderedLong(Object o, long offset, long x) { 1041 theInternalUnsafe.putLongRelease(o, offset, x); 1042 } 1043 1044 /** 1045 * Unblocks the given thread blocked on {@code park}, or, if it is 1046 * not blocked, causes the subsequent call to {@code park} not to 1047 * block. Note: this operation is "unsafe" solely because the 1048 * caller must somehow ensure that the thread has not been 1049 * destroyed. Nothing special is usually required to ensure this 1050 * when called from Java (in which there will ordinarily be a live 1051 * reference to the thread) but this is not nearly-automatically 1052 * so when calling from native code. 1053 * 1054 * @param thread the thread to unpark. 1055 * 1056 * @deprecated Use {@link java.util.concurrent.locks.LockSupport#unpark(Thread)} instead. 1057 */ 1058 @Deprecated(since="22", forRemoval=true) 1059 @ForceInline 1060 public void unpark(Object thread) { 1061 theInternalUnsafe.unpark(thread); 1062 } 1063 1064 /** 1065 * Blocks current thread, returning when a balancing 1066 * {@code unpark} occurs, or a balancing {@code unpark} has 1067 * already occurred, or the thread is interrupted, or, if not 1068 * absolute and time is not zero, the given time nanoseconds have 1069 * elapsed, or if absolute, the given deadline in milliseconds 1070 * since Epoch has passed, or spuriously (i.e., returning for no 1071 * "reason"). Note: This operation is in the Unsafe class only 1072 * because {@code unpark} is, so it would be strange to place it 1073 * elsewhere. 1074 * 1075 * @deprecated Use {@link java.util.concurrent.locks.LockSupport#parkNanos(long)} or 1076 * {@link java.util.concurrent.locks.LockSupport#parkUntil(long)} instead. 1077 */ 1078 @Deprecated(since="22", forRemoval=true) 1079 @ForceInline 1080 public void park(boolean isAbsolute, long time) { 1081 theInternalUnsafe.park(isAbsolute, time); 1082 } 1083 1084 /** 1085 * Gets the load average in the system run queue assigned 1086 * to the available processors averaged over various periods of time. 1087 * This method retrieves the given {@code nelem} samples and 1088 * assigns to the elements of the given {@code loadavg} array. 1089 * The system imposes a maximum of 3 samples, representing 1090 * averages over the last 1, 5, and 15 minutes, respectively. 1091 * 1092 * @param loadavg an array of double of size nelems 1093 * @param nelems the number of samples to be retrieved and 1094 * must be 1 to 3. 1095 * 1096 * @return the number of samples actually retrieved; or -1 1097 * if the load average is unobtainable. 1098 * 1099 * @deprecated Use {@link java.lang.management.OperatingSystemMXBean#getSystemLoadAverage()} 1100 * instead. 1101 */ 1102 @Deprecated(since="22", forRemoval=true) 1103 @ForceInline 1104 public int getLoadAverage(double[] loadavg, int nelems) { 1105 return theInternalUnsafe.getLoadAverage(loadavg, nelems); 1106 } 1107 1108 // The following contain CAS-based Java implementations used on 1109 // platforms not supporting native instructions 1110 1111 /** 1112 * Atomically adds the given value to the current value of a field 1113 * or array element within the given object {@code o} 1114 * at the given {@code offset}. 1115 * 1116 * @param o object/array to update the field/element in 1117 * @param offset field/element offset 1118 * @param delta the value to add 1119 * @return the previous value 1120 * @since 1.8 1121 */ 1122 @ForceInline 1123 public final int getAndAddInt(Object o, long offset, int delta) { 1124 return theInternalUnsafe.getAndAddInt(o, offset, delta); 1125 } 1126 1127 /** 1128 * Atomically adds the given value to the current value of a field 1129 * or array element within the given object {@code o} 1130 * at the given {@code offset}. 1131 * 1132 * @param o object/array to update the field/element in 1133 * @param offset field/element offset 1134 * @param delta the value to add 1135 * @return the previous value 1136 * @since 1.8 1137 */ 1138 @ForceInline 1139 public final long getAndAddLong(Object o, long offset, long delta) { 1140 return theInternalUnsafe.getAndAddLong(o, offset, delta); 1141 } 1142 1143 /** 1144 * Atomically exchanges the given value with the current value of 1145 * a field or array element within the given object {@code o} 1146 * at the given {@code offset}. 1147 * 1148 * @param o object/array to update the field/element in 1149 * @param offset field/element offset 1150 * @param newValue new value 1151 * @return the previous value 1152 * @since 1.8 1153 */ 1154 @ForceInline 1155 public final int getAndSetInt(Object o, long offset, int newValue) { 1156 return theInternalUnsafe.getAndSetInt(o, offset, newValue); 1157 } 1158 1159 /** 1160 * Atomically exchanges the given value with the current value of 1161 * a field or array element within the given object {@code o} 1162 * at the given {@code offset}. 1163 * 1164 * @param o object/array to update the field/element in 1165 * @param offset field/element offset 1166 * @param newValue new value 1167 * @return the previous value 1168 * @since 1.8 1169 */ 1170 @ForceInline 1171 public final long getAndSetLong(Object o, long offset, long newValue) { 1172 return theInternalUnsafe.getAndSetLong(o, offset, newValue); 1173 } 1174 1175 /** 1176 * Atomically exchanges the given reference value with the current 1177 * reference value of a field or array element within the given 1178 * object {@code o} at the given {@code offset}. 1179 * 1180 * @param o object/array to update the field/element in 1181 * @param offset field/element offset 1182 * @param newValue new value 1183 * @return the previous value 1184 * @since 1.8 1185 */ 1186 @ForceInline 1187 public final Object getAndSetObject(Object o, long offset, Object newValue) { 1188 return theInternalUnsafe.getAndSetReference(o, offset, newValue); 1189 } 1190 1191 /** 1192 * Ensures that loads before the fence will not be reordered with loads and 1193 * stores after the fence; a "LoadLoad plus LoadStore barrier". 1194 * 1195 * Corresponds to C11 atomic_thread_fence(memory_order_acquire) 1196 * (an "acquire fence"). 1197 * 1198 * A pure LoadLoad fence is not provided, since the addition of LoadStore 1199 * is almost always desired, and most current hardware instructions that 1200 * provide a LoadLoad barrier also provide a LoadStore barrier for free. 1201 * 1202 * @deprecated Use {@link java.lang.invoke.VarHandle#acquireFence()} instead. 1203 * @since 1.8 1204 */ 1205 @Deprecated(since="22", forRemoval=true) 1206 @ForceInline 1207 public void loadFence() { 1208 theInternalUnsafe.loadFence(); 1209 } 1210 1211 /** 1212 * Ensures that loads and stores before the fence will not be reordered with 1213 * stores after the fence; a "StoreStore plus LoadStore barrier". 1214 * 1215 * Corresponds to C11 atomic_thread_fence(memory_order_release) 1216 * (a "release fence"). 1217 * 1218 * A pure StoreStore fence is not provided, since the addition of LoadStore 1219 * is almost always desired, and most current hardware instructions that 1220 * provide a StoreStore barrier also provide a LoadStore barrier for free. 1221 * 1222 * @deprecated Use {@link java.lang.invoke.VarHandle#releaseFence()} instead. 1223 * @since 1.8 1224 */ 1225 @Deprecated(since="22", forRemoval=true) 1226 @ForceInline 1227 public void storeFence() { 1228 theInternalUnsafe.storeFence(); 1229 } 1230 1231 /** 1232 * Ensures that loads and stores before the fence will not be reordered 1233 * with loads and stores after the fence. Implies the effects of both 1234 * loadFence() and storeFence(), and in addition, the effect of a StoreLoad 1235 * barrier. 1236 * 1237 * Corresponds to C11 atomic_thread_fence(memory_order_seq_cst). 1238 * 1239 * @deprecated Use {@link java.lang.invoke.VarHandle#fullFence()} instead. 1240 * @since 1.8 1241 */ 1242 @Deprecated(since="22", forRemoval=true) 1243 @ForceInline 1244 public void fullFence() { 1245 theInternalUnsafe.fullFence(); 1246 } 1247 1248 /** 1249 * Invokes the given direct byte buffer's cleaner, if any. 1250 * 1251 * @param directBuffer a direct byte buffer 1252 * @throws NullPointerException if {@code directBuffer} is null 1253 * @throws IllegalArgumentException if {@code directBuffer} is non-direct, 1254 * or is a {@link java.nio.Buffer#slice slice}, or is a 1255 * {@link java.nio.Buffer#duplicate duplicate} 1256 * @since 9 1257 */ 1258 public void invokeCleaner(java.nio.ByteBuffer directBuffer) { 1259 if (!directBuffer.isDirect()) 1260 throw new IllegalArgumentException("buffer is non-direct"); 1261 1262 theInternalUnsafe.invokeCleaner(directBuffer); 1263 } 1264 }