VM Spec

Contents | Prev | Next | Index | The JavaTM Virtual Machine Specification

A B C D F G I J L M N P R S T W

## aaload

Operation

> Load `reference` from array

Format

> aaload

Forms

> aaload = 50 (0x32)

Operand Stack

> ..., arrayref, index ..., value

Description

> The arrayref must be of type `reference` and must refer to an array whose components are of type `reference`. The index must be of type `int`. Both arrayref and index are popped from the operand stack. The `reference` value in the component of the array at index is retrieved and pushed onto the operand stack.

Runtime Exceptions

> If arrayref is `null`, aaload throws a `NullPointerException`.

> Otherwise, if index is not within the bounds of the array referenced by arrayref, the aaload instruction throws an `ArrayIndex` `OutOfBoundsException`.

## aastore

Operation

> Store into `reference` array

Format

> aastore

Forms

> aastore = 83 (0x53)

Operand Stack

> ..., arrayref, index, value ...

Description

> The arrayref must be of type `reference` and must refer to an array whose components are of type `reference`. The index must be of type `int` and value must be of type `reference`. The arrayref, index, and value are popped from the operand stack. The `reference` value is stored as the component of the array at index.

> The type of value must be assignment compatible (§2.6.7) with the type of the components of the array referenced by arrayref. Assignment of a value of reference type S (source) to a variable of reference type T (target) is allowed only when the type S supports all the operations defined on type T. The detailed rules follow:

- If S is a class type, then:

  - If T is a class type, then S must be the same class (§2.8.1) as T, or S must be a subclass of T;

  - If T is an interface type, S must implement (§2.13) interface T.

- If S is an interface type, then:

  - If T is a class type, then T must be `Object` (§2.4.7).

  - If T is an interface type, then T must be the same interface as S or a superinterface of S (§2.13.2).

- If S is an array type, namely, the type SC`[]`, that is, an array of components of type SC, then:

  - If T is a class type, then T must be `Object` (§2.4.7).

  - If T is an array type TC`[]`, that is, an array of components of type TC, then one of the following must be true:

    - TC and SC are the same primitive type (§2.4.1).

    - TC and SC are reference types (§2.4.6), and type SC is assignable to TC by these runtime rules.

  - If T is an interface type, T must be one of the interfaces implemented by arrays (§2.15).

Runtime Exceptions

> If arrayref is `null`, aastore throws a `NullPointerException`.

> Otherwise, if index is not within the bounds of the array referenced by arrayref, the aastore instruction throws an `ArrayIndexOutOfBoundsException`.

> Otherwise, if arrayref is not `null` and the actual type of value is not assignment compatible (§2.6.7) with the actual type of the components of the array, aastore throws an `ArrayStoreException`.

## aconst_null

Operation

> Push `null`

Format

> aconst_null

Forms

> aconst_null = 1 (0x1)

Operand Stack

> ... ..., null

Description

> Push the `null` object `reference` onto the operand stack.

Notes

> The Java virtual machine does not mandate a concrete value for `null`.

## aload

Operation

> Load `reference` from local variable

Format

> aload
> index

Forms

> aload = 25 (0x19)

Operand Stack

> ... ..., objectref

Description

> The index is an unsigned byte that must be an index into the local variable array of the current frame (§3.6). The local variable at index must contain a `reference`. The objectref in the local variable at index is pushed onto the operand stack.

Notes

> The aload instruction cannot be used to load a value of type `returnAddress` from a local variable onto the operand stack. This asymmetry with the astore instruction is intentional.

> The aload opcode can be used in conjunction with the wide instruction to access a local variable using a two-byte unsigned index.

## aload_<n>

Operation

> Load `reference` from local variable

Format

> aload_<n>

Forms

> aload_0 = 42 (0x2a) aload_1 = 43 (0x2b) aload_2 = 44 (0x2c) aload_3 = 45 (0x2d)

Operand Stack

> ... ..., objectref

Description

> The <n> must be an index into the local variable array of the current frame (§3.6). The local variable at <n> must contain a `reference`. The objectref in the local variable at index is pushed onto the operand stack.

Notes

> An aload_<n> instruction cannot be used to load a value of type `returnAddress` from a local variable onto the operand stack. This asymmetry with the corresponding astore_<n> instruction is intentional. Each of the aload_<n> instructions is the same as aload with an index of <n>, except that the operand <n> is implicit.

## anewarray

Operation

> Create new array of `reference`

Format

> anewarray
> indexbyte1
> indexbyte2

Forms

> anewarray = 189 (0xbd)

Operand Stack

> ..., count ..., arrayref

Description

> The count must be of type `int`. It is popped off the operand stack. The count represents the number of components of the array to be created. The unsigned indexbyte1 and indexbyte2 are used to construct an index into the runtime constant pool of the current class (§3.6), where the value of the index is (indexbyte1 << 8) | indexbyte2. The runtime constant pool item at that index must be a symbolic reference to a class, array, or interface type. The named class, array, or interface type is resolved (§5.4.3.1). A new array with components of that type, of length count, is allocated from the garbage-collected heap, and a `reference` arrayref to this new array object is pushed onto the operand stack. All components of the new array are initialized to `null`, the default value for `reference` types (§2.5.1).

Linking Exceptions

> During resolution of the symbolic reference to the class, array, or interface type, any of the exceptions documented in §5.4.3.1 can be thrown.

Runtime Exception

> Otherwise, if count is less than zero, the anewarray instruction throws a `NegativeArraySizeException`.

Notes

> The anewarray instruction is used to create a single dimension of an array of object references or part of a multidimensional array.

## areturn

Operation

> Return `reference` from method

Format

> areturn

Forms

> areturn = 176 (0xb0)

Operand Stack

> ..., objectref [empty]

Description

> The objectref must be of type `reference` and must refer to an object of a type that is assignment compatible (§2.6.7) with the type represented by the return descriptor (§4.3.3) of the current method. If the current method is a `synchronized` method, the monitor acquired or reentered on invocation of the method is released or exited (respectively) as if by execution of a monitorexit instruction. If no exception is thrown, objectref is popped from the operand stack of the current frame (§3.6) and pushed onto the operand stack of the frame of the invoker. Any other values on the operand stack of the current method are discarded.

> The interpreter then reinstates the frame of the invoker and returns control to the invoker.

Runtime Exceptions

> If the current method is a `synchronized` method and the current thread is not the owner of the monitor acquired or reentered on invocation of the method, areturn throws an `IllegalMonitorStateException`. This can happen, for example, if a `synchronized` method contains a monitorexit instruction, but no monitorenter instruction, on the object on which the method is synchronized.

> Otherwise, if the virtual machine implementation enforces the rules on structured use of locks described in §8.13 and if the first of those rules is violated during invocation of the current method, then areturn throws an `IllegalMonitorStateException`.

## arraylength

Operation

> Get length of array

Format

> arraylength

Forms

> arraylength = 190 (0xbe)

Operand Stack

> ..., arrayref ..., length

Description

> The arrayref must be of type `reference` and must refer to an array. It is popped from the operand stack. The length of the array it references is determined. That length is pushed onto the operand stack as an `int`.

Runtime Exception

> If the arrayref is `null`, the arraylength instruction throws a `NullPointerException`.

## astore

Operation

> Store `reference` into local variable

Format

> astore
> index

Forms

> astore = 58 (0x3a)

Operand Stack

> ..., objectref ...

Description

> The index is an unsigned byte that must be an index into the local variable array of the current frame (§3.6). The objectref on the top of the operand stack must be of type `returnAddress` or of type `reference`. It is popped from the operand stack, and the value of the local variable at index is set to objectref.

Notes

> The astore instruction is used with an objectref of type `return` `Address` when implementing the `finally` clauses of the Java programming language (see Section 7.13, "Compiling `finally`"). The aload instruction cannot be used to load a value of type `returnAddress` from a local variable onto the operand stack. This asymmetry with the astore instruction is intentional.

> The astore opcode can be used in conjunction with the wide instruction to access a local variable using a two-byte unsigned index.

## astore_<n>

Operation

> Store `reference` into local variable

Format

> astore_<n>

Forms

> astore_0 = 75 (0x4b) astore_1 = 76 (0x4c) astore_2 = 77 (0x4d) astore_3 = 78 (0x4e)

Operand Stack

> ..., objectref ...

Description

> The <n> must be an index into the local variable array of the current frame (§3.6). The objectref on the top of the operand stack must be of type `returnAddress` or of type `reference`. It is popped from the operand stack, and the value of the local variable at <n> is set to objectref.

Notes

> An astore_<n> instruction is used with an objectref of type `returnAddress` when implementing the `finally` clauses of the Java programming language (see Section 7.13, "Compiling `finally`"). An aload_<n> instruction cannot be used to load a value of type `returnAddress` from a local variable onto the operand stack. This asymmetry with the corresponding astore_<n> instruction is intentional.

> Each of the astore_<n> instructions is the same as astore with an index of <n>, except that the operand <n> is implicit.

## athrow

Operation

> Throw exception or error

Format

> athrow

Forms

> athrow = 191 (0xbf)

Operand Stack

> ..., objectref objectref

Description

> The objectref must be of type `reference` and must refer to an object that is an instance of class `Throwable` or of a subclass of `Throwable`. It is popped from the operand stack. The objectref is then thrown by searching the current method (§3.6) for the first exception handler that matches the class of objectref, as given by the algorithm in §3.10.

> If an exception handler that matches objectref is found, it contains the location of the code intended to handle this exception. The `pc` register is reset to that location, the operand stack of the current frame is cleared, objectref is pushed back onto the operand stack, and execution continues.

> If no matching exception handler is found in the current frame, that frame is popped. If the current frame represents an invocation of a `synchronized` method, the monitor acquired or reentered on invocation of the method is released or exited (respectively) as if by execution of a monitorexit instruction. Finally, the frame of its invoker is reinstated, if such a frame exists, and the objectref is rethrown. If no such frame exists, the current thread exits.

Runtime Exceptions

> If objectref is `null`, athrow throws a `NullPointerException` instead of objectref.

> Otherwise, if the method of the current frame is a `synchronized` method and the current thread is not the owner of the monitor acquired or reentered on invocation of the method, athrow throws an `IllegalMonitorStateException` instead of the object previously being thrown. This can happen, for example, if an abruptly completing `synchronized` method contains a monitorexit instruction, but no monitorenter instruction, on the object on which the method is synchronized.

> Otherwise, if the virtual machine implementation enforces the rules on structured use of locks described in §8.13 and if the first of those rules is violated during invocation of the current method, then athrow throws an `IllegalMonitorStateException` instead of the object previously being thrown.

Notes

> The operand stack diagram for the athrow instruction may be misleading: If a handler for this exception is matched in the current method, the athrow instruction discards all the values on the operand stack, then pushes the thrown object onto the operand stack. However, if no handler is matched in the current method and the exception is thrown farther up the method invocation chain, then the operand stack of the method (if any) that handles the exception is cleared and objectref is pushed onto that empty operand stack. All intervening frames from the method that threw the exception up to, but not including, the method that handles the exception are discarded.

Contents | Prev | Next | Index

The JavaTM Virtual Machine Specification
Copyright © 1999 Sun Microsystems, Inc. All rights reserved
Please send any comments or corrections to jvm@java.sun.com