| Enum | Description |
|---|---|
| Inline.When |
Enumeration defining when to inline
|
| RuntimePure.ReturnValue |
Enumeration of the special boot image return values
|
| Annotation Type | Description |
|---|---|
| BaselineNoRegisters |
Some methods shouldn't use registers for locals and stack values.
|
| BaselineSaveLSRegisters |
Methods with this pragma that are BaselineCompiled should save in its prologue, ALL registers that
can be used to store local and stack registers in any BaselineCompiled method.
|
| DynamicBridge |
Methods of a class that implements this interface are treated specially
by the compilers.
|
| Entrypoint |
The entrypoint annotation indicates that the method or field is
directly accessed by the compiler.
|
| Inline |
This pragma indicates that a particular method should always be inlined
by the optimizing compiler.
|
| Interruptible |
By default all Java code is interruptible, that is scheduling or garbage
collection may occur at points within the code.
|
| LogicallyUninterruptible | Deprecated |
| NativeBridge |
Methods of a class that implements this interface are treated specially
by the compilers:
They are only called from C or C++ program
The compiler will generate the necessary prolog to insert a glue stack
frame to map from the native stack/register convention to RVM's convention
It is an error to call these methods from Java
|
| NoBoundsCheck |
This pragma indicates that a particular method should never have bounds
checks generated.
|
| NoCheckStore |
Methods with this annotation do not perform a checkstore on stores
into object arrays.
|
| NoEscapes |
Use this annotation to mark methods that won't cause their reference arguments
to escape.
|
| NoInline |
This pragma indicates that a particular method should never be inlined
by the optimizing compiler.
|
| NonMoving |
Use this annotation to mark types that must never move.
|
| NonMovingAllocation |
Use this annotation to mark methods for which all allocation must never
move.
|
| NoNullCheck |
This pragma indicates that a particular method should never have null checks
generated.
|
| NoOptCompile |
This pragma indicates that a particular method should never be
compiled by the optimizing compiler.
|
| Preemptible |
By default all Java code is interruptible, that is scheduling or garbage
collection may occur at points within the code.
|
| Pure |
This pragma is used to indicate a method has no side effects.
|
| RawStorage |
When applied to class this annotation indicates that the data component
of this field consists of an intrinsically managed chunk of raw memory of
the specified size.
|
| ReferenceFieldsVary |
This annotation marks types which have fields that can be marked
as either traced or untraced by the VM.
|
| RuntimeFinal |
This pragma is used to indicate a field will be final in the running VM.
|
| RuntimePure |
This pragma is a variant of Pure that is used to mark methods that have a
special behaviour at boot image writing time and are Pure at runtime
|
| SaveVolatile |
Methods of a class that implements this interface
are treated specially by the machine code compiler:
the method prologue saves all the volatile registers
and the method epilogue restores all the volatile registers
|
| SpecializedMethodInvoke |
This pragma indicates that a particular method is a specialized
method invocation point, and could be optimized as such.
|
| SysCallNative |
An annotation for static native methods to show that they should be
compiled as system calls.
|
| Uninterruptible |
By default all Java code is interruptible, that is scheduling or garbage
collection may occur at points within the code.
|
| UninterruptibleNoWarn |
A pragma that has the same direct effect as
Uninterruptible
but also suppresses checking of uninterruptibility violations for
the method. |
| Unpreemptible |
By default all Java code is interruptible, that is scheduling or garbage
collection may occur at points within the code.
|
| UnpreemptibleNoWarn |
A special case of
Unpreemptible where the code may call out to other
interruptible routines. |
| Untraced |
Use this annotation to mark fields that are read without the knowledge of the
memory management system.
|