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