https://openjdk.java.net/ 
/*
 * Copyright (c) 2000, 2006, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package sun.misc;

import java.security.*;
import java.lang.reflect.*;

import sun.reflect.CallerSensitive;
import sun.reflect.Reflection;



A collection of methods for performing low-level, unsafe operations.
Although the class and all methods are public, use of this class is
limited because only trusted code can obtain instances of it.

Author:John R. Rose
See Also:
/**
 * A collection of methods for performing low-level, unsafe operations.
 * Although the class and all methods are public, use of this class is
 * limited because only trusted code can obtain instances of it.
 *
 * @author John R. Rose
 * @see #getUnsafe
 */

public final class Unsafe {

    private static native void registerNatives();
    static {
        registerNatives();
        sun.reflect.Reflection.registerMethodsToFilter(Unsafe.class, "getUnsafe");
    }

    private Unsafe() {}

    private static final Unsafe theUnsafe = new Unsafe();

    
Provides the caller with the capability of performing unsafe
operations.

 The returned Unsafe object should be carefully guarded
by the caller, since it can be used to read and write data at arbitrary
memory addresses.  It must never be passed to untrusted code.

 Most methods in this class are very low-level, and correspond to a
small number of hardware instructions (on typical machines).  Compilers
are encouraged to optimize these methods accordingly.

 Here is a suggested idiom for using unsafe operations:

class MyTrustedClass {
  private static final Unsafe unsafe = Unsafe.getUnsafe();
  ...
  private long myCountAddress = ...;
  public int getCount() { return unsafe.getByte(myCountAddress); }
}


(It may assist compilers to make the local variable be
final.)

Throws:
  • SecurityException –  if a security manager exists and its
            checkPropertiesAccess method doesn't allow
            access to the system properties.
/**
     * Provides the caller with the capability of performing unsafe
     * operations.
     *
     * <p> The returned <code>Unsafe</code> object should be carefully guarded
     * by the caller, since it can be used to read and write data at arbitrary
     * memory addresses.  It must never be passed to untrusted code.
     *
     * <p> Most methods in this class are very low-level, and correspond to a
     * small number of hardware instructions (on typical machines).  Compilers
     * are encouraged to optimize these methods accordingly.
     *
     * <p> Here is a suggested idiom for using unsafe operations:
     *
     * <blockquote><pre>
     * class MyTrustedClass {
     *   private static final Unsafe unsafe = Unsafe.getUnsafe();
     *   ...
     *   private long myCountAddress = ...;
     *   public int getCount() { return unsafe.getByte(myCountAddress); }
     * }
     * </pre></blockquote>
     *
     * (It may assist compilers to make the local variable be
     * <code>final</code>.)
     *
     * @exception  SecurityException  if a security manager exists and its
     *             <code>checkPropertiesAccess</code> method doesn't allow
     *             access to the system properties.
     */
    @CallerSensitive
    public static Unsafe getUnsafe() {
        Class cc = Reflection.getCallerClass();
        if (cc.getClassLoader() != null)
            throw new SecurityException("Unsafe");
        return theUnsafe;
    }

    /// peek and poke operations
    /// (compilers should optimize these to memory ops)

    // These work on object fields in the Java heap.
    // They will not work on elements of packed arrays.

    
Fetches a value from a given Java variable.
More specifically, fetches a field or array element within the given
object o at the given offset, or (if o is
null) from the memory address whose numerical value is the given
offset.


The results are undefined unless one of the following cases is true:

    

  • The offset was obtained from objectFieldOffset on the Field of some Java field and the object referred to by o is of a class compatible with that
field's class.

  • The offset and object reference o (either null or non-null) were both obtained via staticFieldOffset and staticFieldBase (respectively) from the reflective Field representation of some Java field. 
  • The object referred to by o is an array, and the offset
is an integer of the form B+N*S, where N is
a valid index into the array, and B and S are the values obtained by arrayBaseOffset and arrayIndexScale (respectively) from the array's class. The value referred to is the Nth element of the array.




If one of the above cases is true, the call references a specific Java
variable (field or array element).  However, the results are undefined
if that variable is not in fact of the type returned by this method.


This method refers to a variable by means of two parameters, and so
it provides (in effect) a double-register addressing mode for Java variables. When the object reference is null, this method uses its offset as an absolute address. This is similar in operation to methods such as getInt(long), which provide (in effect) a single-register addressing mode for non-Java variables.
However, because Java variables may have a different layout in memory
from non-Java variables, programmers should not assume that these
two addressing modes are ever equivalent.  Also, programmers should
remember that offsets from the double-register addressing mode cannot
be portably confused with longs used in the single-register addressing
mode.

Params:
  • o – Java heap object in which the variable resides, if any, else
       null
  • offset – indication of where the variable resides in a Java heap
       object, if any, else a memory address locating the variable
       statically
Throws:
Returns:the value fetched from the indicated Java variable
/**
     * Fetches a value from a given Java variable.
     * More specifically, fetches a field or array element within the given
     * object <code>o</code> at the given offset, or (if <code>o</code> is
     * null) from the memory address whose numerical value is the given
     * offset.
     * <p>
     * The results are undefined unless one of the following cases is true:
     * <ul>
     * <li>The offset was obtained from {@link #objectFieldOffset} on
     * the {@link java.lang.reflect.Field} of some Java field and the object
     * referred to by <code>o</code> is of a class compatible with that
     * field's class.
     *
     * <li>The offset and object reference <code>o</code> (either null or
     * non-null) were both obtained via {@link #staticFieldOffset}
     * and {@link #staticFieldBase} (respectively) from the
     * reflective {@link Field} representation of some Java field.
     *
     * <li>The object referred to by <code>o</code> is an array, and the offset
     * is an integer of the form <code>B+N*S</code>, where <code>N</code> is
     * a valid index into the array, and <code>B</code> and <code>S</code> are
     * the values obtained by {@link #arrayBaseOffset} and {@link
     * #arrayIndexScale} (respectively) from the array's class.  The value
     * referred to is the <code>N</code><em>th</em> element of the array.
     *
     * </ul>
     * <p>
     * If one of the above cases is true, the call references a specific Java
     * variable (field or array element).  However, the results are undefined
     * if that variable is not in fact of the type returned by this method.
     * <p>
     * This method refers to a variable by means of two parameters, and so
     * it provides (in effect) a <em>double-register</em> addressing mode
     * for Java variables.  When the object reference is null, this method
     * uses its offset as an absolute address.  This is similar in operation
     * to methods such as {@link #getInt(long)}, which provide (in effect) a
     * <em>single-register</em> addressing mode for non-Java variables.
     * However, because Java variables may have a different layout in memory
     * from non-Java variables, programmers should not assume that these
     * two addressing modes are ever equivalent.  Also, programmers should
     * remember that offsets from the double-register addressing mode cannot
     * be portably confused with longs used in the single-register addressing
     * mode.
     *
     * @param o Java heap object in which the variable resides, if any, else
     *        null
     * @param offset indication of where the variable resides in a Java heap
     *        object, if any, else a memory address locating the variable
     *        statically
     * @return the value fetched from the indicated Java variable
     * @throws RuntimeException No defined exceptions are thrown, not even
     *         {@link NullPointerException}
     */
    public native int getInt(Object o, long offset);

    
Stores a value into a given Java variable.

 The first two parameters are interpreted exactly as with getInt(Object, long) to refer to a specific Java variable (field or array element). The given value is stored into that variable. 

The variable must be of the same type as the method
parameter x.

Params:
  • o – Java heap object in which the variable resides, if any, else
       null
  • offset – indication of where the variable resides in a Java heap
       object, if any, else a memory address locating the variable
       statically
  • x – the value to store into the indicated Java variable
Throws:
/**
     * Stores a value into a given Java variable.
     * <p>
     * The first two parameters are interpreted exactly as with
     * {@link #getInt(Object, long)} to refer to a specific
     * Java variable (field or array element).  The given value
     * is stored into that variable.
     * <p>
     * The variable must be of the same type as the method
     * parameter <code>x</code>.
     *
     * @param o Java heap object in which the variable resides, if any, else
     *        null
     * @param offset indication of where the variable resides in a Java heap
     *        object, if any, else a memory address locating the variable
     *        statically
     * @param x the value to store into the indicated Java variable
     * @throws RuntimeException No defined exceptions are thrown, not even
     *         {@link NullPointerException}
     */
    public native void putInt(Object o, long offset, int x);

    
Fetches a reference value from a given Java variable.

See Also:
  • getInt(Object, long)
/**
     * Fetches a reference value from a given Java variable.
     * @see #getInt(Object, long)
     */
    public native Object getObject(Object o, long offset);

    
Stores a reference value into a given Java variable.


Unless the reference x being stored is either null
or matches the field type, the results are undefined.
If the reference o is non-null, car marks or
other store barriers for that object (if the VM requires them)
are updated.

See Also:
  • putInt(Object, int, int)
/**
     * Stores a reference value into a given Java variable.
     * <p>
     * Unless the reference <code>x</code> being stored is either null
     * or matches the field type, the results are undefined.
     * If the reference <code>o</code> is non-null, car marks or
     * other store barriers for that object (if the VM requires them)
     * are updated.
     * @see #putInt(Object, int, int)
     */
    public native void putObject(Object o, long offset, Object x);

    
See Also:
/** @see #getInt(Object, long) */
    public native boolean getBoolean(Object o, long offset);
    
See Also:
/** @see #putInt(Object, int, int) */
    public native void    putBoolean(Object o, long offset, boolean x);
    
See Also:
/** @see #getInt(Object, long) */
    public native byte    getByte(Object o, long offset);
    
See Also:
/** @see #putInt(Object, int, int) */
    public native void    putByte(Object o, long offset, byte x);
    
See Also:
/** @see #getInt(Object, long) */
    public native short   getShort(Object o, long offset);
    
See Also:
/** @see #putInt(Object, int, int) */
    public native void    putShort(Object o, long offset, short x);
    
See Also:
/** @see #getInt(Object, long) */
    public native char    getChar(Object o, long offset);
    
See Also:
/** @see #putInt(Object, int, int) */
    public native void    putChar(Object o, long offset, char x);
    
See Also:
/** @see #getInt(Object, long) */
    public native long    getLong(Object o, long offset);
    
See Also:
/** @see #putInt(Object, int, int) */
    public native void    putLong(Object o, long offset, long x);
    
See Also:
/** @see #getInt(Object, long) */
    public native float   getFloat(Object o, long offset);
    
See Also:
/** @see #putInt(Object, int, int) */
    public native void    putFloat(Object o, long offset, float x);
    
See Also:
/** @see #getInt(Object, long) */
    public native double  getDouble(Object o, long offset);
    
See Also:
/** @see #putInt(Object, int, int) */
    public native void    putDouble(Object o, long offset, double x);

    
This method, like all others with 32-bit offsets, was native
in a previous release but is now a wrapper which simply casts
the offset to a long value.  It provides backward compatibility
with bytecodes compiled against 1.4.

Deprecated:As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset.
/**
     * This method, like all others with 32-bit offsets, was native
     * in a previous release but is now a wrapper which simply casts
     * the offset to a long value.  It provides backward compatibility
     * with bytecodes compiled against 1.4.
     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
     * See {@link #staticFieldOffset}.
     */
    @Deprecated
    public int getInt(Object o, int offset) {
        return getInt(o, (long)offset);
    }

    
Deprecated:As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset.
/**
     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
     * See {@link #staticFieldOffset}.
     */
    @Deprecated
    public void putInt(Object o, int offset, int x) {
        putInt(o, (long)offset, x);
    }

    
Deprecated:As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset.
/**
     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
     * See {@link #staticFieldOffset}.
     */
    @Deprecated
    public Object getObject(Object o, int offset) {
        return getObject(o, (long)offset);
    }

    
Deprecated:As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset.
/**
     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
     * See {@link #staticFieldOffset}.
     */
    @Deprecated
    public void putObject(Object o, int offset, Object x) {
        putObject(o, (long)offset, x);
    }

    
Deprecated:As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset.
/**
     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
     * See {@link #staticFieldOffset}.
     */
    @Deprecated
    public boolean getBoolean(Object o, int offset) {
        return getBoolean(o, (long)offset);
    }

    
Deprecated:As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset.
/**
     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
     * See {@link #staticFieldOffset}.
     */
    @Deprecated
    public void putBoolean(Object o, int offset, boolean x) {
        putBoolean(o, (long)offset, x);
    }

    
Deprecated:As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset.
/**
     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
     * See {@link #staticFieldOffset}.
     */
    @Deprecated
    public byte getByte(Object o, int offset) {
        return getByte(o, (long)offset);
    }

    
Deprecated:As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset.
/**
     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
     * See {@link #staticFieldOffset}.
     */
    @Deprecated
    public void putByte(Object o, int offset, byte x) {
        putByte(o, (long)offset, x);
    }

    
Deprecated:As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset.
/**
     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
     * See {@link #staticFieldOffset}.
     */
    @Deprecated
    public short getShort(Object o, int offset) {
        return getShort(o, (long)offset);
    }

    
Deprecated:As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset.
/**
     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
     * See {@link #staticFieldOffset}.
     */
    @Deprecated
    public void putShort(Object o, int offset, short x) {
        putShort(o, (long)offset, x);
    }

    
Deprecated:As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset.
/**
     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
     * See {@link #staticFieldOffset}.
     */
    @Deprecated
    public char getChar(Object o, int offset) {
        return getChar(o, (long)offset);
    }

    
Deprecated:As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset.
/**
     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
     * See {@link #staticFieldOffset}.
     */
    @Deprecated
    public void putChar(Object o, int offset, char x) {
        putChar(o, (long)offset, x);
    }

    
Deprecated:As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset.
/**
     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
     * See {@link #staticFieldOffset}.
     */
    @Deprecated
    public long getLong(Object o, int offset) {
        return getLong(o, (long)offset);
    }

    
Deprecated:As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset.
/**
     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
     * See {@link #staticFieldOffset}.
     */
    @Deprecated
    public void putLong(Object o, int offset, long x) {
        putLong(o, (long)offset, x);
    }

    
Deprecated:As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset.
/**
     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
     * See {@link #staticFieldOffset}.
     */
    @Deprecated
    public float getFloat(Object o, int offset) {
        return getFloat(o, (long)offset);
    }

    
Deprecated:As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset.
/**
     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
     * See {@link #staticFieldOffset}.
     */
    @Deprecated
    public void putFloat(Object o, int offset, float x) {
        putFloat(o, (long)offset, x);
    }

    
Deprecated:As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset.
/**
     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
     * See {@link #staticFieldOffset}.
     */
    @Deprecated
    public double getDouble(Object o, int offset) {
        return getDouble(o, (long)offset);
    }

    
Deprecated:As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset.
/**
     * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
     * See {@link #staticFieldOffset}.
     */
    @Deprecated
    public void putDouble(Object o, int offset, double x) {
        putDouble(o, (long)offset, x);
    }

    // These work on values in the C heap.

    
Fetches a value from a given memory address. If the address is zero, or does not point into a block obtained from allocateMemory, the results are undefined. 
See Also:
/**
     * Fetches a value from a given memory address.  If the address is zero, or
     * does not point into a block obtained from {@link #allocateMemory}, the
     * results are undefined.
     *
     * @see #allocateMemory
     */
    public native byte    getByte(long address);

    
Stores a value into a given memory address. If the address is zero, or does not point into a block obtained from allocateMemory, the results are undefined. 
See Also:
/**
     * Stores a value into a given memory address.  If the address is zero, or
     * does not point into a block obtained from {@link #allocateMemory}, the
     * results are undefined.
     *
     * @see #getByte(long)
     */
    public native void    putByte(long address, byte x);

    
See Also:
/** @see #getByte(long) */
    public native short   getShort(long address);
    
See Also:
/** @see #putByte(long, byte) */
    public native void    putShort(long address, short x);
    
See Also:
/** @see #getByte(long) */
    public native char    getChar(long address);
    
See Also:
/** @see #putByte(long, byte) */
    public native void    putChar(long address, char x);
    
See Also:
/** @see #getByte(long) */
    public native int     getInt(long address);
    
See Also:
/** @see #putByte(long, byte) */
    public native void    putInt(long address, int x);
    
See Also:
/** @see #getByte(long) */
    public native long    getLong(long address);
    
See Also:
/** @see #putByte(long, byte) */
    public native void    putLong(long address, long x);
    
See Also:
/** @see #getByte(long) */
    public native float   getFloat(long address);
    
See Also:
/** @see #putByte(long, byte) */
    public native void    putFloat(long address, float x);
    
See Also:
/** @see #getByte(long) */
    public native double  getDouble(long address);
    
See Also:
/** @see #putByte(long, byte) */
    public native void    putDouble(long address, double x);

    
Fetches a native pointer from a given memory address. If the address is zero, or does not point into a block obtained from allocateMemory, the results are undefined. 
 If the native pointer is less than 64 bits wide, it is extended as an unsigned number to a Java long. The pointer may be indexed by any given byte offset, simply by adding that offset (as a simple integer) to the long representing the pointer. The number of bytes actually read from the target address maybe determined by consulting addressSize. 
See Also:
/**
     * Fetches a native pointer from a given memory address.  If the address is
     * zero, or does not point into a block obtained from {@link
     * #allocateMemory}, the results are undefined.
     *
     * <p> If the native pointer is less than 64 bits wide, it is extended as
     * an unsigned number to a Java long.  The pointer may be indexed by any
     * given byte offset, simply by adding that offset (as a simple integer) to
     * the long representing the pointer.  The number of bytes actually read
     * from the target address maybe determined by consulting {@link
     * #addressSize}.
     *
     * @see #allocateMemory
     */
    public native long getAddress(long address);

    
Stores a native pointer into a given memory address. If the address is zero, or does not point into a block obtained from allocateMemory, the results are undefined. 
 The number of bytes actually written at the target address maybe determined by consulting addressSize. 
See Also:
/**
     * Stores a native pointer into a given memory address.  If the address is
     * zero, or does not point into a block obtained from {@link
     * #allocateMemory}, the results are undefined.
     *
     * <p> The number of bytes actually written at the target address maybe
     * determined by consulting {@link #addressSize}.
     *
     * @see #getAddress(long)
     */
    public native void putAddress(long address, long x);

    /// wrappers for malloc, realloc, free:

    
Allocates a new block of native memory, of the given size in bytes. The contents of the memory are uninitialized; they will generally be garbage. The resulting native pointer will never be zero, and will be aligned for all value types. Dispose of this memory by calling freeMemory, or resize it with reallocateMemory. 
Throws:
See Also:
/**
     * Allocates a new block of native memory, of the given size in bytes.  The
     * contents of the memory are uninitialized; they will generally be
     * garbage.  The resulting native pointer will never be zero, and will be
     * aligned for all value types.  Dispose of this memory by calling {@link
     * #freeMemory}, or resize it with {@link #reallocateMemory}.
     *
     * @throws IllegalArgumentException if the size is negative or too large
     *         for the native size_t type
     *
     * @throws OutOfMemoryError if the allocation is refused by the system
     *
     * @see #getByte(long)
     * @see #putByte(long, byte)
     */
    public native long allocateMemory(long bytes);

    
Resizes a new block of native memory, to the given size in bytes. The contents of the new block past the size of the old block are uninitialized; they will generally be garbage. The resulting native pointer will be zero if and only if the requested size is zero. The resulting native pointer will be aligned for all value types. Dispose of this memory by calling freeMemory, or resize it with reallocateMemory. The address passed to this method may be null, in which case an allocation will be performed. 
Throws:
See Also:
/**
     * Resizes a new block of native memory, to the given size in bytes.  The
     * contents of the new block past the size of the old block are
     * uninitialized; they will generally be garbage.  The resulting native
     * pointer will be zero if and only if the requested size is zero.  The
     * resulting native pointer will be aligned for all value types.  Dispose
     * of this memory by calling {@link #freeMemory}, or resize it with {@link
     * #reallocateMemory}.  The address passed to this method may be null, in
     * which case an allocation will be performed.
     *
     * @throws IllegalArgumentException if the size is negative or too large
     *         for the native size_t type
     *
     * @throws OutOfMemoryError if the allocation is refused by the system
     *
     * @see #allocateMemory
     */
    public native long reallocateMemory(long address, long bytes);

    
Sets all bytes in a given block of memory to a fixed value
(usually zero).

/**
     * Sets all bytes in a given block of memory to a fixed value
     * (usually zero).
     */
    public native void setMemory(long address, long bytes, byte value);

    
Sets all bytes in a given block of memory to a copy of another
block.

This method determines each block's base address by means of two parameters,
and so it provides (in effect) a double-register addressing mode, as discussed in getInt(Object, long). When the object reference is null, the offset supplies an absolute base address. 
The transfers are in coherent (atomic) units of a size determined
by the address and length parameters.  If the effective addresses and
length are all even modulo 8, the transfer takes place in 'long' units.
If the effective addresses and length are (resp.) even modulo 4 or 2,
the transfer takes place in units of 'int' or 'short'.

/**
     * Sets all bytes in a given block of memory to a copy of another
     * block.
     *
     * <p>This method determines each block's base address by means of two parameters,
     * and so it provides (in effect) a <em>double-register</em> addressing mode,
     * as discussed in {@link #getInt(Object,long)}.  When the object reference is null,
     * the offset supplies an absolute base address.
     *
     * <p>The transfers are in coherent (atomic) units of a size determined
     * by the address and length parameters.  If the effective addresses and
     * length are all even modulo 8, the transfer takes place in 'long' units.
     * If the effective addresses and length are (resp.) even modulo 4 or 2,
     * the transfer takes place in units of 'int' or 'short'.
     */
    public native void copyMemory(Object srcBase, long srcOffset,
                                  Object destBase, long destOffset,
                                  long bytes);
    
Sets all bytes in a given block of memory to a copy of another
block.  This provides a single-register addressing mode, as discussed in getInt(Object, long). Equivalent to copyMemory(null, srcAddress, null, destAddress, bytes).

/**
     * Sets all bytes in a given block of memory to a copy of another
     * block.  This provides a <em>single-register</em> addressing mode,
     * as discussed in {@link #getInt(Object,long)}.
     *
     * Equivalent to <code>copyMemory(null, srcAddress, null, destAddress, bytes)</code>.
     */
    public void copyMemory(long srcAddress, long destAddress, long bytes) {
        copyMemory(null, srcAddress, null, destAddress, bytes);
    }

    
Disposes of a block of native memory, as obtained from allocateMemory or reallocateMemory. The address passed to this method may be null, in which case no action is taken. 
See Also:
/**
     * Disposes of a block of native memory, as obtained from {@link
     * #allocateMemory} or {@link #reallocateMemory}.  The address passed to
     * this method may be null, in which case no action is taken.
     *
     * @see #allocateMemory
     */
    public native void freeMemory(long address);

    /// random queries

    
This constant differs from all results that will ever be returned from staticFieldOffset, objectFieldOffset, or arrayBaseOffset. 
/**
     * This constant differs from all results that will ever be returned from
     * {@link #staticFieldOffset}, {@link #objectFieldOffset},
     * or {@link #arrayBaseOffset}.
     */
    public static final int INVALID_FIELD_OFFSET   = -1;

    
Returns the offset of a field, truncated to 32 bits.
This method is implemented as follows:

public int fieldOffset(Field f) {
    if (Modifier.isStatic(f.getModifiers()))
        return (int) staticFieldOffset(f);
    else
        return (int) objectFieldOffset(f);
}



Deprecated:As of 1.4.1, use staticFieldOffset for static fields and objectFieldOffset for non-static fields.
/**
     * Returns the offset of a field, truncated to 32 bits.
     * This method is implemented as follows:
     * <blockquote><pre>
     * public int fieldOffset(Field f) {
     *     if (Modifier.isStatic(f.getModifiers()))
     *         return (int) staticFieldOffset(f);
     *     else
     *         return (int) objectFieldOffset(f);
     * }
     * </pre></blockquote>
     * @deprecated As of 1.4.1, use {@link #staticFieldOffset} for static
     * fields and {@link #objectFieldOffset} for non-static fields.
     */
    @Deprecated
    public int fieldOffset(Field f) {
        if (Modifier.isStatic(f.getModifiers()))
            return (int) staticFieldOffset(f);
        else
            return (int) objectFieldOffset(f);
    }

    
Returns the base address for accessing some static field
in the given class.  This method is implemented as follows:

public Object staticFieldBase(Class c) {
    Field[] fields = c.getDeclaredFields();
    for (int i = 0; i < fields.length; i++) {
        if (Modifier.isStatic(fields[i].getModifiers())) {
            return staticFieldBase(fields[i]);
        }
    }
    return null;
}



Deprecated:As of 1.4.1, use staticFieldBase(Field) to obtain the base pertaining to a specific Field. This method works only for JVMs which store all statics for a given class in one place.
/**
     * Returns the base address for accessing some static field
     * in the given class.  This method is implemented as follows:
     * <blockquote><pre>
     * public Object staticFieldBase(Class c) {
     *     Field[] fields = c.getDeclaredFields();
     *     for (int i = 0; i < fields.length; i++) {
     *         if (Modifier.isStatic(fields[i].getModifiers())) {
     *             return staticFieldBase(fields[i]);
     *         }
     *     }
     *     return null;
     * }
     * </pre></blockquote>
     * @deprecated As of 1.4.1, use {@link #staticFieldBase(Field)}
     * to obtain the base pertaining to a specific {@link Field}.
     * This method works only for JVMs which store all statics
     * for a given class in one place.
     */
    @Deprecated
    public Object staticFieldBase(Class c) {
        Field[] fields = c.getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            if (Modifier.isStatic(fields[i].getModifiers())) {
                return staticFieldBase(fields[i]);
            }
        }
        return null;
    }

    
Report the location of a given field in the storage allocation of its
class.  Do not expect to perform any sort of arithmetic on this offset;
it is just a cookie which is passed to the unsafe heap memory accessors.

Any given field will always have the same offset and base, and no
two distinct fields of the same class will ever have the same offset
and base.

As of 1.4.1, offsets for fields are represented as long values, although the Sun JVM does not use the most significant 32 bits. However, JVM implementations which store static fields at absolute addresses can use long offsets and null base pointers to express the field locations in a form usable by getInt(Object, long). Therefore, code which will be ported to such JVMs on 64-bit platforms must preserve all bits of static field offsets. 
See Also:
/**
     * Report the location of a given field in the storage allocation of its
     * class.  Do not expect to perform any sort of arithmetic on this offset;
     * it is just a cookie which is passed to the unsafe heap memory accessors.
     *
     * <p>Any given field will always have the same offset and base, and no
     * two distinct fields of the same class will ever have the same offset
     * and base.
     *
     * <p>As of 1.4.1, offsets for fields are represented as long values,
     * although the Sun JVM does not use the most significant 32 bits.
     * However, JVM implementations which store static fields at absolute
     * addresses can use long offsets and null base pointers to express
     * the field locations in a form usable by {@link #getInt(Object,long)}.
     * Therefore, code which will be ported to such JVMs on 64-bit platforms
     * must preserve all bits of static field offsets.
     * @see #getInt(Object, long)
     */
    public native long staticFieldOffset(Field f);

    
Report the location of a given static field, in conjunction with staticFieldBase. 
Do not expect to perform any sort of arithmetic on this offset;
it is just a cookie which is passed to the unsafe heap memory accessors.

Any given field will always have the same offset, and no two distinct
fields of the same class will ever have the same offset.

As of 1.4.1, offsets for fields are represented as long values,
although the Sun JVM does not use the most significant 32 bits.
It is hard to imagine a JVM technology which needs more than
a few bits to encode an offset within a non-array object,
However, for consistency with other methods in this class,
this method reports its result as a long value.

See Also:
/**
     * Report the location of a given static field, in conjunction with {@link
     * #staticFieldBase}.
     * <p>Do not expect to perform any sort of arithmetic on this offset;
     * it is just a cookie which is passed to the unsafe heap memory accessors.
     *
     * <p>Any given field will always have the same offset, and no two distinct
     * fields of the same class will ever have the same offset.
     *
     * <p>As of 1.4.1, offsets for fields are represented as long values,
     * although the Sun JVM does not use the most significant 32 bits.
     * It is hard to imagine a JVM technology which needs more than
     * a few bits to encode an offset within a non-array object,
     * However, for consistency with other methods in this class,
     * this method reports its result as a long value.
     * @see #getInt(Object, long)
     */
    public native long objectFieldOffset(Field f);

    
Report the location of a given static field, in conjunction with staticFieldOffset. 
Fetch the base "Object", if any, with which static fields of the given class can be accessed via methods like getInt(Object, long). This value may be null. This value may refer to an object which is a "cookie", not guaranteed to be a real Object, and it should not be used in any way except as argument to the get and put routines in this class. 
/**
     * Report the location of a given static field, in conjunction with {@link
     * #staticFieldOffset}.
     * <p>Fetch the base "Object", if any, with which static fields of the
     * given class can be accessed via methods like {@link #getInt(Object,
     * long)}.  This value may be null.  This value may refer to an object
     * which is a "cookie", not guaranteed to be a real Object, and it should
     * not be used in any way except as argument to the get and put routines in
     * this class.
     */
    public native Object staticFieldBase(Field f);

    
Ensure the given class has been initialized. This is often
needed in conjunction with obtaining the static field base of a
class.

/**
     * Ensure the given class has been initialized. This is often
     * needed in conjunction with obtaining the static field base of a
     * class.
     */
    public native void ensureClassInitialized(Class c);

    
Report the offset of the first element in the storage allocation of a given array class. If arrayIndexScale returns a non-zero value for the same class, you may use that scale factor, together with this base offset, to form new offsets to access elements of arrays of the given class. 
See Also:
/**
     * Report the offset of the first element in the storage allocation of a
     * given array class.  If {@link #arrayIndexScale} returns a non-zero value
     * for the same class, you may use that scale factor, together with this
     * base offset, to form new offsets to access elements of arrays of the
     * given class.
     *
     * @see #getInt(Object, long)
     * @see #putInt(Object, long, int)
     */
    public native int arrayBaseOffset(Class arrayClass);

    
Report the scale factor for addressing elements in the storage allocation of a given array class. However, arrays of "narrow" types will generally not work properly with accessors like getByte(Object, int), so the scale factor for such classes is reported as zero. 
See Also:
/**
     * Report the scale factor for addressing elements in the storage
     * allocation of a given array class.  However, arrays of "narrow" types
     * will generally not work properly with accessors like {@link
     * #getByte(Object, int)}, so the scale factor for such classes is reported
     * as zero.
     *
     * @see #arrayBaseOffset
     * @see #getInt(Object, long)
     * @see #putInt(Object, long, int)
     */
    public native int arrayIndexScale(Class arrayClass);

    
Report the size in bytes of a native pointer, as stored via putAddress. This value will be either 4 or 8. Note that the sizes of other primitive types (as stored in native memory blocks) is determined fully by their information content. 
/**
     * Report the size in bytes of a native pointer, as stored via {@link
     * #putAddress}.  This value will be either 4 or 8.  Note that the sizes of
     * other primitive types (as stored in native memory blocks) is determined
     * fully by their information content.
     */
    public native int addressSize();

    
Report the size in bytes of a native memory page (whatever that is).
This value will always be a power of two.

/**
     * Report the size in bytes of a native memory page (whatever that is).
     * This value will always be a power of two.
     */
    public native int pageSize();


    /// random trusted operations from JNI:

    
Tell the VM to define a class, without security checks.  By default, the
class loader and protection domain come from the caller's class.

/**
     * Tell the VM to define a class, without security checks.  By default, the
     * class loader and protection domain come from the caller's class.
     */
    public native Class defineClass(String name, byte[] b, int off, int len,
                                    ClassLoader loader,
                                    ProtectionDomain protectionDomain);

    
Deprecated:Use defineClass(String, byte[], int, int, ClassLoader, ProtectionDomain)
            instead. This method will be removed in JDK 8.
/**
     * @deprecated Use defineClass(String, byte[], int, int, ClassLoader, ProtectionDomain)
     *             instead. This method will be removed in JDK 8.
     */
    @Deprecated
    @CallerSensitive
    public native Class defineClass(String name, byte[] b, int off, int len);

    
Allocate an instance but do not run any constructor.
Initializes the class if it has not yet been. 
/** Allocate an instance but do not run any constructor.
        Initializes the class if it has not yet been. */
    public native Object allocateInstance(Class cls)
        throws InstantiationException;

    
Lock the object. It must get unlocked via monitorExit. 
/** Lock the object.  It must get unlocked via {@link #monitorExit}. */
    public native void monitorEnter(Object o);

    
Unlock the object. It must have been locked via monitorEnter. 
/**
     * Unlock the object.  It must have been locked via {@link
     * #monitorEnter}.
     */
    public native void monitorExit(Object o);

    
Tries to lock the object. Returns true or false to indicate whether the lock succeeded. If it did, the object must be unlocked via monitorExit. 
/**
     * Tries to lock the object.  Returns true or false to indicate
     * whether the lock succeeded.  If it did, the object must be
     * unlocked via {@link #monitorExit}.
     */
    public native boolean tryMonitorEnter(Object o);

    
Throw the exception without telling the verifier. 
/** Throw the exception without telling the verifier. */
    public native void throwException(Throwable ee);


    
Atomically update Java variable to x if it is currently
holding expected.

Returns:true if successful
/**
     * Atomically update Java variable to <tt>x</tt> if it is currently
     * holding <tt>expected</tt>.
     * @return <tt>true</tt> if successful
     */
    public final native boolean compareAndSwapObject(Object o, long offset,
                                                     Object expected,
                                                     Object x);

    
Atomically update Java variable to x if it is currently
holding expected.

Returns:true if successful
/**
     * Atomically update Java variable to <tt>x</tt> if it is currently
     * holding <tt>expected</tt>.
     * @return <tt>true</tt> if successful
     */
    public final native boolean compareAndSwapInt(Object o, long offset,
                                                  int expected,
                                                  int x);

    
Atomically update Java variable to x if it is currently
holding expected.

Returns:true if successful
/**
     * Atomically update Java variable to <tt>x</tt> if it is currently
     * holding <tt>expected</tt>.
     * @return <tt>true</tt> if successful
     */
    public final native boolean compareAndSwapLong(Object o, long offset,
                                                   long expected,
                                                   long x);

    
Fetches a reference value from a given Java variable, with volatile load semantics. Otherwise identical to getObject(Object, long) 
/**
     * Fetches a reference value from a given Java variable, with volatile
     * load semantics. Otherwise identical to {@link #getObject(Object, long)}
     */
    public native Object getObjectVolatile(Object o, long offset);

    
Stores a reference value into a given Java variable, with volatile store semantics. Otherwise identical to putObject(Object, long, Object) 
/**
     * Stores a reference value into a given Java variable, with
     * volatile store semantics. Otherwise identical to {@link #putObject(Object, long, Object)}
     */
    public native void    putObjectVolatile(Object o, long offset, Object x);

    
Volatile version of getInt(Object, long) 
/** Volatile version of {@link #getInt(Object, long)}  */
    public native int     getIntVolatile(Object o, long offset);

    
Volatile version of putInt(Object, long, int) 
/** Volatile version of {@link #putInt(Object, long, int)}  */
    public native void    putIntVolatile(Object o, long offset, int x);

    
Volatile version of getBoolean(Object, long) 
/** Volatile version of {@link #getBoolean(Object, long)}  */
    public native boolean getBooleanVolatile(Object o, long offset);

    /** Volatile version of {@link #putBoolean(Object, long, boolean)}  */
    public native void    putBooleanVolatile(Object o, long offset, boolean x);

    
Volatile version of getByte(Object, long) 
/** Volatile version of {@link #getByte(Object, long)}  */
    public native byte    getByteVolatile(Object o, long offset);

    
Volatile version of putByte(Object, long, byte) 
/** Volatile version of {@link #putByte(Object, long, byte)}  */
    public native void    putByteVolatile(Object o, long offset, byte x);

    
Volatile version of getShort(Object, long) 
/** Volatile version of {@link #getShort(Object, long)}  */
    public native short   getShortVolatile(Object o, long offset);

    
Volatile version of putShort(Object, long, short) 
/** Volatile version of {@link #putShort(Object, long, short)}  */
    public native void    putShortVolatile(Object o, long offset, short x);

    
Volatile version of getChar(Object, long) 
/** Volatile version of {@link #getChar(Object, long)}  */
    public native char    getCharVolatile(Object o, long offset);

    
Volatile version of putChar(Object, long, char) 
/** Volatile version of {@link #putChar(Object, long, char)}  */
    public native void    putCharVolatile(Object o, long offset, char x);

    
Volatile version of getLong(Object, long) 
/** Volatile version of {@link #getLong(Object, long)}  */
    public native long    getLongVolatile(Object o, long offset);

    
Volatile version of putLong(Object, long, long) 
/** Volatile version of {@link #putLong(Object, long, long)}  */
    public native void    putLongVolatile(Object o, long offset, long x);

    
Volatile version of getFloat(Object, long) 
/** Volatile version of {@link #getFloat(Object, long)}  */
    public native float   getFloatVolatile(Object o, long offset);

    
Volatile version of putFloat(Object, long, float) 
/** Volatile version of {@link #putFloat(Object, long, float)}  */
    public native void    putFloatVolatile(Object o, long offset, float x);

    
Volatile version of getDouble(Object, long) 
/** Volatile version of {@link #getDouble(Object, long)}  */
    public native double  getDoubleVolatile(Object o, long offset);

    
Volatile version of putDouble(Object, long, double) 
/** Volatile version of {@link #putDouble(Object, long, double)}  */
    public native void    putDoubleVolatile(Object o, long offset, double x);

    
Version of putObjectVolatile(Object, long, Object) that does not guarantee immediate visibility of the store to other threads. This method is generally only useful if the underlying field is a Java volatile (or if an array cell, one that is otherwise only accessed using volatile accesses). 
/**
     * Version of {@link #putObjectVolatile(Object, long, Object)}
     * that does not guarantee immediate visibility of the store to
     * other threads. This method is generally only useful if the
     * underlying field is a Java volatile (or if an array cell, one
     * that is otherwise only accessed using volatile accesses).
     */
    public native void    putOrderedObject(Object o, long offset, Object x);

    
Ordered/Lazy version of putIntVolatile(Object, long, int) 
/** Ordered/Lazy version of {@link #putIntVolatile(Object, long, int)}  */
    public native void    putOrderedInt(Object o, long offset, int x);

    
Ordered/Lazy version of putLongVolatile(Object, long, long) 
/** Ordered/Lazy version of {@link #putLongVolatile(Object, long, long)} */
    public native void    putOrderedLong(Object o, long offset, long x);

    
Unblock the given thread blocked on park, or, if it is
not blocked, cause the subsequent call to park not to
block.  Note: this operation is "unsafe" solely because the
caller must somehow ensure that the thread has not been
destroyed. Nothing special is usually required to ensure this
when called from Java (in which there will ordinarily be a live
reference to the thread) but this is not nearly-automatically
so when calling from native code.

Params:
  • thread – the thread to unpark.
/**
     * Unblock the given thread blocked on <tt>park</tt>, or, if it is
     * not blocked, cause the subsequent call to <tt>park</tt> not to
     * block.  Note: this operation is "unsafe" solely because the
     * caller must somehow ensure that the thread has not been
     * destroyed. Nothing special is usually required to ensure this
     * when called from Java (in which there will ordinarily be a live
     * reference to the thread) but this is not nearly-automatically
     * so when calling from native code.
     * @param thread the thread to unpark.
     *
     */
    public native void unpark(Object thread);

    
Block current thread, returning when a balancing
unpark occurs, or a balancing unpark has
already occurred, or the thread is interrupted, or, if not
absolute and time is not zero, the given time nanoseconds have
elapsed, or if absolute, the given deadline in milliseconds
since Epoch has passed, or spuriously (i.e., returning for no
"reason"). Note: This operation is in the Unsafe class only
because unpark is, so it would be strange to place it
elsewhere.

/**
     * Block current thread, returning when a balancing
     * <tt>unpark</tt> occurs, or a balancing <tt>unpark</tt> has
     * already occurred, or the thread is interrupted, or, if not
     * absolute and time is not zero, the given time nanoseconds have
     * elapsed, or if absolute, the given deadline in milliseconds
     * since Epoch has passed, or spuriously (i.e., returning for no
     * "reason"). Note: This operation is in the Unsafe class only
     * because <tt>unpark</tt> is, so it would be strange to place it
     * elsewhere.
     */
    public native void park(boolean isAbsolute, long time);

    
Gets the load average in the system run queue assigned
to the available processors averaged over various periods of time.
This method retrieves the given nelem samples and
assigns to the elements of the given loadavg array.
The system imposes a maximum of 3 samples, representing
averages over the last 1,  5,  and  15 minutes, respectively.

@paramsloadavg an array of double of size nelems
@paramsnelems the number of samples to be retrieved and
        must be 1 to 3.
Returns:the number of samples actually retrieved; or -1
        if the load average is unobtainable.
/**
     * Gets the load average in the system run queue assigned
     * to the available processors averaged over various periods of time.
     * This method retrieves the given <tt>nelem</tt> samples and
     * assigns to the elements of the given <tt>loadavg</tt> array.
     * The system imposes a maximum of 3 samples, representing
     * averages over the last 1,  5,  and  15 minutes, respectively.
     *
     * @params loadavg an array of double of size nelems
     * @params nelems the number of samples to be retrieved and
     *         must be 1 to 3.
     *
     * @return the number of samples actually retrieved; or -1
     *         if the load average is unobtainable.
     */
    public native int getLoadAverage(double[] loadavg, int nelems);
}