MetaspacePointer

java.lang.Object
- org.graalvm.compiler.hotspot.word.MetaspacePointer

Direct Known Subclasses:

KlassPointer, MethodCountersPointer, MethodPointer
```
public abstract class MetaspacePointer
extends Object
```
Marker type for a metaspace pointer.

Constructor Summary

Constructors
Constructor and Description

MetaspacePointer()

Constructors
Constructor and Description
`MetaspacePointer()`

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`abstract Word`	`asWord()`
`abstract void`	`initializeLong(org.graalvm.word.WordBase offset, long val, org.graalvm.word.LocationIdentity locationIdentity)` Initializes the memory at address `(this + offset)`.
`abstract boolean`	`isNull()`
`abstract byte`	`readByte(int offset)` Reads the memory at address `(this + offset)`.
`abstract byte`	`readByte(int offset, org.graalvm.word.LocationIdentity locationIdentity)` Reads the memory at address `(this + offset)`.
`abstract byte`	`readByte(org.graalvm.word.WordBase offset)` Reads the memory at address `(this + offset)`.
`abstract byte`	`readByte(org.graalvm.word.WordBase offset, org.graalvm.word.LocationIdentity locationIdentity)` Reads the memory at address `(this + offset)`.
`abstract char`	`readChar(int offset)` Reads the memory at address `(this + offset)`.
`abstract char`	`readChar(int offset, org.graalvm.word.LocationIdentity locationIdentity)` Reads the memory at address `(this + offset)`.
`abstract char`	`readChar(org.graalvm.word.WordBase offset)` Reads the memory at address `(this + offset)`.
`abstract char`	`readChar(org.graalvm.word.WordBase offset, org.graalvm.word.LocationIdentity locationIdentity)` Reads the memory at address `(this + offset)`.
`abstract double`	`readDouble(int offset)` Reads the memory at address `(this + offset)`.
`abstract double`	`readDouble(int offset, org.graalvm.word.LocationIdentity locationIdentity)` Reads the memory at address `(this + offset)`.
`abstract double`	`readDouble(org.graalvm.word.WordBase offset)` Reads the memory at address `(this + offset)`.
`abstract double`	`readDouble(org.graalvm.word.WordBase offset, org.graalvm.word.LocationIdentity locationIdentity)` Reads the memory at address `(this + offset)`.
`abstract float`	`readFloat(int offset)` Reads the memory at address `(this + offset)`.
`abstract float`	`readFloat(int offset, org.graalvm.word.LocationIdentity locationIdentity)` Reads the memory at address `(this + offset)`.
`abstract float`	`readFloat(org.graalvm.word.WordBase offset)` Reads the memory at address `(this + offset)`.
`abstract float`	`readFloat(org.graalvm.word.WordBase offset, org.graalvm.word.LocationIdentity locationIdentity)` Reads the memory at address `(this + offset)`.
`abstract int`	`readInt(int offset)` Reads the memory at address `(this + offset)`.
`abstract int`	`readInt(int offset, org.graalvm.word.LocationIdentity locationIdentity)` Reads the memory at address `(this + offset)`.
`abstract int`	`readInt(org.graalvm.word.WordBase offset)` Reads the memory at address `(this + offset)`.
`abstract int`	`readInt(org.graalvm.word.WordBase offset, org.graalvm.word.LocationIdentity locationIdentity)` Reads the memory at address `(this + offset)`.
`abstract long`	`readLong(int offset)` Reads the memory at address `(this + offset)`.
`abstract long`	`readLong(int offset, org.graalvm.word.LocationIdentity locationIdentity)` Reads the memory at address `(this + offset)`.
`abstract long`	`readLong(org.graalvm.word.WordBase offset)` Reads the memory at address `(this + offset)`.
`abstract long`	`readLong(org.graalvm.word.WordBase offset, org.graalvm.word.LocationIdentity locationIdentity)` Reads the memory at address `(this + offset)`.
`abstract Object`	`readObject(int offset)` Reads the memory at address `(this + offset)`.
`abstract Object`	`readObject(int offset, org.graalvm.word.LocationIdentity locationIdentity)` Reads the memory at address `(this + offset)`.
`abstract Object`	`readObject(int offset, OnHeapMemoryAccess.BarrierType barrierType)` Reads the memory at address `(this + offset)`.
`abstract Object`	`readObject(org.graalvm.word.WordBase offset)` Reads the memory at address `(this + offset)`.
`abstract Object`	`readObject(org.graalvm.word.WordBase offset, org.graalvm.word.LocationIdentity locationIdentity)` Reads the memory at address `(this + offset)`.
`abstract Object`	`readObject(org.graalvm.word.WordBase offset, OnHeapMemoryAccess.BarrierType barrierType)` Reads the memory at address `(this + offset)`.
`abstract short`	`readShort(int offset)` Reads the memory at address `(this + offset)`.
`abstract short`	`readShort(int offset, org.graalvm.word.LocationIdentity locationIdentity)` Reads the memory at address `(this + offset)`.
`abstract short`	`readShort(org.graalvm.word.WordBase offset)` Reads the memory at address `(this + offset)`.
`abstract short`	`readShort(org.graalvm.word.WordBase offset, org.graalvm.word.LocationIdentity locationIdentity)` Reads the memory at address `(this + offset)`.
`abstract Word`	`readWord(int offset)` Reads the memory at address `(this + offset)`.
`abstract Word`	`readWord(int offset, org.graalvm.word.LocationIdentity locationIdentity)` Reads the memory at address `(this + offset)`.
`abstract Word`	`readWord(org.graalvm.word.WordBase offset)` Reads the memory at address `(this + offset)`.
`abstract Word`	`readWord(org.graalvm.word.WordBase offset, org.graalvm.word.LocationIdentity locationIdentity)` Reads the memory at address `(this + offset)`.
`abstract void`	`writeByte(int offset, byte val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeByte(int offset, byte val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeByte(org.graalvm.word.WordBase offset, byte val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeByte(org.graalvm.word.WordBase offset, byte val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeByteSideEffectFree(int offset, byte val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeByteSideEffectFree(int offset, byte val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeByteSideEffectFree(org.graalvm.word.WordBase offset, byte val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeByteSideEffectFree(org.graalvm.word.WordBase offset, byte val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeChar(int offset, char val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeChar(int offset, char val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeChar(org.graalvm.word.WordBase offset, char val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeChar(org.graalvm.word.WordBase offset, char val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeCharSideEffectFree(int offset, char val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeCharSideEffectFree(int offset, char val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeCharSideEffectFree(org.graalvm.word.WordBase offset, char val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeCharSideEffectFree(org.graalvm.word.WordBase offset, char val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeDouble(int offset, double val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeDouble(int offset, double val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeDouble(org.graalvm.word.WordBase offset, double val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeDouble(org.graalvm.word.WordBase offset, double val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeDoubleSideEffectFree(int offset, double val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeDoubleSideEffectFree(int offset, double val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeDoubleSideEffectFree(org.graalvm.word.WordBase offset, double val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeDoubleSideEffectFree(org.graalvm.word.WordBase offset, double val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeFloat(int offset, float val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeFloat(int offset, float val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeFloat(org.graalvm.word.WordBase offset, float val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeFloat(org.graalvm.word.WordBase offset, float val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeFloatSideEffectFree(int offset, float val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeFloatSideEffectFree(int offset, float val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeFloatSideEffectFree(org.graalvm.word.WordBase offset, float val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeFloatSideEffectFree(org.graalvm.word.WordBase offset, float val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeInt(int offset, int val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeInt(int offset, int val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeInt(org.graalvm.word.WordBase offset, int val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeInt(org.graalvm.word.WordBase offset, int val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeIntSideEffectFree(int offset, int val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeIntSideEffectFree(int offset, int val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeIntSideEffectFree(org.graalvm.word.WordBase offset, int val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeIntSideEffectFree(org.graalvm.word.WordBase offset, int val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeLong(int offset, long val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeLong(int offset, long val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeLong(org.graalvm.word.WordBase offset, long val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeLong(org.graalvm.word.WordBase offset, long val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeLongSideEffectFree(int offset, long val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeLongSideEffectFree(int offset, long val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeLongSideEffectFree(org.graalvm.word.WordBase offset, long val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeLongSideEffectFree(org.graalvm.word.WordBase offset, long val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeObject(int offset, Object val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeObject(int offset, Object val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeObject(org.graalvm.word.WordBase offset, Object val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeObject(org.graalvm.word.WordBase offset, Object val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeObjectSideEffectFree(int offset, Object val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeObjectSideEffectFree(int offset, Object val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeObjectSideEffectFree(org.graalvm.word.WordBase offset, Object val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeObjectSideEffectFree(org.graalvm.word.WordBase offset, Object val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeShort(int offset, short val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeShort(int offset, short val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeShort(org.graalvm.word.WordBase offset, short val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeShort(org.graalvm.word.WordBase offset, short val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeShortSideEffectFree(int offset, short val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeShortSideEffectFree(int offset, short val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeShortSideEffectFree(org.graalvm.word.WordBase offset, short val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeShortSideEffectFree(org.graalvm.word.WordBase offset, short val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeWord(int offset, org.graalvm.word.WordBase val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeWord(int offset, org.graalvm.word.WordBase val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeWord(org.graalvm.word.WordBase offset, org.graalvm.word.WordBase val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeWord(org.graalvm.word.WordBase offset, org.graalvm.word.WordBase val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeWordSideEffectFree(int offset, org.graalvm.word.WordBase val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeWordSideEffectFree(int offset, org.graalvm.word.WordBase val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeWordSideEffectFree(org.graalvm.word.WordBase offset, org.graalvm.word.WordBase val)` Writes the memory at address `(this + offset)`.
`abstract void`	`writeWordSideEffectFree(org.graalvm.word.WordBase offset, org.graalvm.word.WordBase val, org.graalvm.word.LocationIdentity locationIdentity)` Writes the memory at address `(this + offset)`.

Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - MetaspacePointer
```
public MetaspacePointer()
```
- Method Detail
  - isNull
```
public abstract boolean isNull()
```
  - asWord
```
public abstract Word asWord()
```
  - readByte
```
public abstract byte readByte(org.graalvm.word.WordBase offset,
                              org.graalvm.word.LocationIdentity locationIdentity)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the read
    
    Returns:
    
    the result of the memory access
  - readChar
```
public abstract char readChar(org.graalvm.word.WordBase offset,
                              org.graalvm.word.LocationIdentity locationIdentity)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the read
    
    Returns:
    
    the result of the memory access
  - readShort
```
public abstract short readShort(org.graalvm.word.WordBase offset,
                                org.graalvm.word.LocationIdentity locationIdentity)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the read
    
    Returns:
    
    the result of the memory access
  - readInt
```
public abstract int readInt(org.graalvm.word.WordBase offset,
                            org.graalvm.word.LocationIdentity locationIdentity)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the read
    
    Returns:
    
    the result of the memory access
  - readLong
```
public abstract long readLong(org.graalvm.word.WordBase offset,
                              org.graalvm.word.LocationIdentity locationIdentity)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the read
    
    Returns:
    
    the result of the memory access
  - readFloat
```
public abstract float readFloat(org.graalvm.word.WordBase offset,
                                org.graalvm.word.LocationIdentity locationIdentity)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the read
    
    Returns:
    
    the result of the memory access
  - readDouble
```
public abstract double readDouble(org.graalvm.word.WordBase offset,
                                  org.graalvm.word.LocationIdentity locationIdentity)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the read
    
    Returns:
    
    the result of the memory access
  - readWord
```
public abstract Word readWord(org.graalvm.word.WordBase offset,
                              org.graalvm.word.LocationIdentity locationIdentity)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the read
    
    Returns:
    
    the result of the memory access
  - readObject
```
public abstract Object readObject(org.graalvm.word.WordBase offset,
                                  org.graalvm.word.LocationIdentity locationIdentity)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the read
    
    Returns:
    
    the result of the memory access
  - readByte
```
public abstract byte readByte(int offset,
                              org.graalvm.word.LocationIdentity locationIdentity)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the read
    
    Returns:
    
    the result of the memory access
  - readChar
```
public abstract char readChar(int offset,
                              org.graalvm.word.LocationIdentity locationIdentity)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the read
    
    Returns:
    
    the result of the memory access
  - readShort
```
public abstract short readShort(int offset,
                                org.graalvm.word.LocationIdentity locationIdentity)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the read
    
    Returns:
    
    the result of the memory access
  - readInt
```
public abstract int readInt(int offset,
                            org.graalvm.word.LocationIdentity locationIdentity)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the read
    
    Returns:
    
    the result of the memory access
  - readLong
```
public abstract long readLong(int offset,
                              org.graalvm.word.LocationIdentity locationIdentity)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the read
    
    Returns:
    
    the result of the memory access
  - readFloat
```
public abstract float readFloat(int offset,
                                org.graalvm.word.LocationIdentity locationIdentity)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the read
    
    Returns:
    
    the result of the memory access
  - readDouble
```
public abstract double readDouble(int offset,
                                  org.graalvm.word.LocationIdentity locationIdentity)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the read
    
    Returns:
    
    the result of the memory access
  - readWord
```
public abstract Word readWord(int offset,
                              org.graalvm.word.LocationIdentity locationIdentity)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the read
    
    Returns:
    
    the result of the memory access
  - readObject
```
public abstract Object readObject(int offset,
                                  org.graalvm.word.LocationIdentity locationIdentity)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the read
    
    Returns:
    
    the result of the memory access
  - writeByte
```
public abstract void writeByte(org.graalvm.word.WordBase offset,
                               byte val,
                               org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeChar
```
public abstract void writeChar(org.graalvm.word.WordBase offset,
                               char val,
                               org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeShort
```
public abstract void writeShort(org.graalvm.word.WordBase offset,
                                short val,
                                org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeInt
```
public abstract void writeInt(org.graalvm.word.WordBase offset,
                              int val,
                              org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeLong
```
public abstract void writeLong(org.graalvm.word.WordBase offset,
                               long val,
                               org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeFloat
```
public abstract void writeFloat(org.graalvm.word.WordBase offset,
                                float val,
                                org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeDouble
```
public abstract void writeDouble(org.graalvm.word.WordBase offset,
                                 double val,
                                 org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeWord
```
public abstract void writeWord(org.graalvm.word.WordBase offset,
                               org.graalvm.word.WordBase val,
                               org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - initializeLong
```
public abstract void initializeLong(org.graalvm.word.WordBase offset,
                                    long val,
                                    org.graalvm.word.LocationIdentity locationIdentity)
```
    Initializes the memory at address (this + offset). Both the base address and offset are in bytes. The memory must be uninitialized or zero prior to this operation.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeObject
```
public abstract void writeObject(org.graalvm.word.WordBase offset,
                                 Object val,
                                 org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeByte
```
public abstract void writeByte(int offset,
                               byte val,
                               org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeChar
```
public abstract void writeChar(int offset,
                               char val,
                               org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeShort
```
public abstract void writeShort(int offset,
                                short val,
                                org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeInt
```
public abstract void writeInt(int offset,
                              int val,
                              org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeLong
```
public abstract void writeLong(int offset,
                               long val,
                               org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeFloat
```
public abstract void writeFloat(int offset,
                                float val,
                                org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeDouble
```
public abstract void writeDouble(int offset,
                                 double val,
                                 org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeWord
```
public abstract void writeWord(int offset,
                               org.graalvm.word.WordBase val,
                               org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeObject
```
public abstract void writeObject(int offset,
                                 Object val,
                                 org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - readByte
```
public abstract byte readByte(org.graalvm.word.WordBase offset)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    Returns:
    
    the result of the memory access
  - readChar
```
public abstract char readChar(org.graalvm.word.WordBase offset)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    Returns:
    
    the result of the memory access
  - readShort
```
public abstract short readShort(org.graalvm.word.WordBase offset)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    Returns:
    
    the result of the memory access
  - readInt
```
public abstract int readInt(org.graalvm.word.WordBase offset)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    Returns:
    
    the result of the memory access
  - readLong
```
public abstract long readLong(org.graalvm.word.WordBase offset)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    Returns:
    
    the result of the memory access
  - readFloat
```
public abstract float readFloat(org.graalvm.word.WordBase offset)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    Returns:
    
    the result of the memory access
  - readDouble
```
public abstract double readDouble(org.graalvm.word.WordBase offset)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    Returns:
    
    the result of the memory access
  - readWord
```
public abstract Word readWord(org.graalvm.word.WordBase offset)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    Returns:
    
    the result of the memory access
  - readObject
```
public abstract Object readObject(org.graalvm.word.WordBase offset)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    Returns:
    
    the result of the memory access
  - readObject
```
public abstract Object readObject(org.graalvm.word.WordBase offset,
                                  OnHeapMemoryAccess.BarrierType barrierType)
```
    Reads the memory at address (this + offset). This access will decompress the oop if the VM uses compressed oops, and it can be parameterized to allow read barriers (G1 referent field).
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    barrierType - the type of the read barrier to be added
    
    Returns:
    
    the result of the memory access
  - readByte
```
public abstract byte readByte(int offset)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    Returns:
    
    the result of the memory access
  - readChar
```
public abstract char readChar(int offset)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    Returns:
    
    the result of the memory access
  - readShort
```
public abstract short readShort(int offset)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    Returns:
    
    the result of the memory access
  - readInt
```
public abstract int readInt(int offset)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    Returns:
    
    the result of the memory access
  - readLong
```
public abstract long readLong(int offset)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    Returns:
    
    the result of the memory access
  - readFloat
```
public abstract float readFloat(int offset)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    Returns:
    
    the result of the memory access
  - readDouble
```
public abstract double readDouble(int offset)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    Returns:
    
    the result of the memory access
  - readWord
```
public abstract Word readWord(int offset)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    Returns:
    
    the result of the memory access
  - readObject
```
public abstract Object readObject(int offset)
```
    Reads the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    Returns:
    
    the result of the memory access
  - readObject
```
public abstract Object readObject(int offset,
                                  OnHeapMemoryAccess.BarrierType barrierType)
```
    Reads the memory at address (this + offset). This access will decompress the oop if the VM uses compressed oops, and it can be parameterized to allow read barriers (G1 referent field).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    barrierType - the type of the read barrier to be added
    
    Returns:
    
    the result of the memory access
  - writeByte
```
public abstract void writeByte(org.graalvm.word.WordBase offset,
                               byte val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeChar
```
public abstract void writeChar(org.graalvm.word.WordBase offset,
                               char val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeShort
```
public abstract void writeShort(org.graalvm.word.WordBase offset,
                                short val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeInt
```
public abstract void writeInt(org.graalvm.word.WordBase offset,
                              int val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeLong
```
public abstract void writeLong(org.graalvm.word.WordBase offset,
                               long val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeFloat
```
public abstract void writeFloat(org.graalvm.word.WordBase offset,
                                float val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeDouble
```
public abstract void writeDouble(org.graalvm.word.WordBase offset,
                                 double val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeWord
```
public abstract void writeWord(org.graalvm.word.WordBase offset,
                               org.graalvm.word.WordBase val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeObject
```
public abstract void writeObject(org.graalvm.word.WordBase offset,
                                 Object val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeByte
```
public abstract void writeByte(int offset,
                               byte val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeChar
```
public abstract void writeChar(int offset,
                               char val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeShort
```
public abstract void writeShort(int offset,
                                short val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeInt
```
public abstract void writeInt(int offset,
                              int val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeLong
```
public abstract void writeLong(int offset,
                               long val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeFloat
```
public abstract void writeFloat(int offset,
                                float val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeDouble
```
public abstract void writeDouble(int offset,
                                 double val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeWord
```
public abstract void writeWord(int offset,
                               org.graalvm.word.WordBase val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeObject
```
public abstract void writeObject(int offset,
                                 Object val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeByteSideEffectFree
```
public abstract void writeByteSideEffectFree(org.graalvm.word.WordBase offset,
                                             byte val,
                                             org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeCharSideEffectFree
```
public abstract void writeCharSideEffectFree(org.graalvm.word.WordBase offset,
                                             char val,
                                             org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeShortSideEffectFree
```
public abstract void writeShortSideEffectFree(org.graalvm.word.WordBase offset,
                                              short val,
                                              org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeIntSideEffectFree
```
public abstract void writeIntSideEffectFree(org.graalvm.word.WordBase offset,
                                            int val,
                                            org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeLongSideEffectFree
```
public abstract void writeLongSideEffectFree(org.graalvm.word.WordBase offset,
                                             long val,
                                             org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeFloatSideEffectFree
```
public abstract void writeFloatSideEffectFree(org.graalvm.word.WordBase offset,
                                              float val,
                                              org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeDoubleSideEffectFree
```
public abstract void writeDoubleSideEffectFree(org.graalvm.word.WordBase offset,
                                               double val,
                                               org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeWordSideEffectFree
```
public abstract void writeWordSideEffectFree(org.graalvm.word.WordBase offset,
                                             org.graalvm.word.WordBase val,
                                             org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeObjectSideEffectFree
```
public abstract void writeObjectSideEffectFree(org.graalvm.word.WordBase offset,
                                               Object val,
                                               org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeByteSideEffectFree
```
public abstract void writeByteSideEffectFree(int offset,
                                             byte val,
                                             org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeCharSideEffectFree
```
public abstract void writeCharSideEffectFree(int offset,
                                             char val,
                                             org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeShortSideEffectFree
```
public abstract void writeShortSideEffectFree(int offset,
                                              short val,
                                              org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeIntSideEffectFree
```
public abstract void writeIntSideEffectFree(int offset,
                                            int val,
                                            org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeLongSideEffectFree
```
public abstract void writeLongSideEffectFree(int offset,
                                             long val,
                                             org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeFloatSideEffectFree
```
public abstract void writeFloatSideEffectFree(int offset,
                                              float val,
                                              org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeDoubleSideEffectFree
```
public abstract void writeDoubleSideEffectFree(int offset,
                                               double val,
                                               org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeWordSideEffectFree
```
public abstract void writeWordSideEffectFree(int offset,
                                             org.graalvm.word.WordBase val,
                                             org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeObjectSideEffectFree
```
public abstract void writeObjectSideEffectFree(int offset,
                                               Object val,
                                               org.graalvm.word.LocationIdentity locationIdentity)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    locationIdentity - the identity of the write
    
    val - the value to be written to memory
  - writeByteSideEffectFree
```
public abstract void writeByteSideEffectFree(org.graalvm.word.WordBase offset,
                                             byte val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeCharSideEffectFree
```
public abstract void writeCharSideEffectFree(org.graalvm.word.WordBase offset,
                                             char val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeShortSideEffectFree
```
public abstract void writeShortSideEffectFree(org.graalvm.word.WordBase offset,
                                              short val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeIntSideEffectFree
```
public abstract void writeIntSideEffectFree(org.graalvm.word.WordBase offset,
                                            int val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeLongSideEffectFree
```
public abstract void writeLongSideEffectFree(org.graalvm.word.WordBase offset,
                                             long val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeFloatSideEffectFree
```
public abstract void writeFloatSideEffectFree(org.graalvm.word.WordBase offset,
                                              float val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeDoubleSideEffectFree
```
public abstract void writeDoubleSideEffectFree(org.graalvm.word.WordBase offset,
                                               double val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeWordSideEffectFree
```
public abstract void writeWordSideEffectFree(org.graalvm.word.WordBase offset,
                                             org.graalvm.word.WordBase val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeObjectSideEffectFree
```
public abstract void writeObjectSideEffectFree(org.graalvm.word.WordBase offset,
                                               Object val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    The offset is always treated as a SignedWord value. However, the static type is WordBase to avoid the frequent casts of UnsignedWord values (where the caller knows that the highest-order bit of the unsigned value is never used).
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeByteSideEffectFree
```
public abstract void writeByteSideEffectFree(int offset,
                                             byte val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeCharSideEffectFree
```
public abstract void writeCharSideEffectFree(int offset,
                                             char val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeShortSideEffectFree
```
public abstract void writeShortSideEffectFree(int offset,
                                              short val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeIntSideEffectFree
```
public abstract void writeIntSideEffectFree(int offset,
                                            int val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeLongSideEffectFree
```
public abstract void writeLongSideEffectFree(int offset,
                                             long val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeFloatSideEffectFree
```
public abstract void writeFloatSideEffectFree(int offset,
                                              float val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeDoubleSideEffectFree
```
public abstract void writeDoubleSideEffectFree(int offset,
                                               double val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeWordSideEffectFree
```
public abstract void writeWordSideEffectFree(int offset,
                                             org.graalvm.word.WordBase val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory
  - writeObjectSideEffectFree
```
public abstract void writeObjectSideEffectFree(int offset,
                                               Object val)
```
    Writes the memory at address (this + offset). Both the base address and offset are in bytes. The write is side-effect free, it is not a part of the JVM state and can be repeated after deoptimization.
    
    Parameters:
    
    offset - the signed offset for the memory access
    
    val - the value to be written to memory

Class MetaspacePointer

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

MetaspacePointer

Method Detail

isNull

asWord

readByte

readChar

readShort

readInt

readLong

readFloat

readDouble

readWord

readObject

readByte

readChar

readShort

readInt

readLong

readFloat

readDouble

readWord

readObject

writeByte

writeChar

writeShort

writeInt

writeLong

writeFloat

writeDouble

writeWord

initializeLong

writeObject

writeByte

writeChar

writeShort

writeInt

writeLong

writeFloat

writeDouble

writeWord

writeObject

readByte

readChar

readShort

readInt

readLong

readFloat

readDouble

readWord

readObject

readObject

readByte

readChar

readShort

readInt

readLong

readFloat

readDouble

readWord

readObject

readObject

writeByte

writeChar

writeShort

writeInt

writeLong

writeFloat

writeDouble

writeWord

writeObject

writeByte

writeChar

writeShort

writeInt

writeLong