Die Architektur der Java VM

Seminarthemen→ Die Architektur der Java VM→ I.• II.• III.• IV.• V. Befehlssatz • VI.• VII.

V. Befehlssatz

V. 1 Zusammenfassung

Die JVM ist intern insofern streng getypt, dass jeweils nur genau bestimmte JVM-Typen von einem Befehl verarbeitet werden. Daher existieren für mathematische, logische und load & store Operationen seperate typspeziefische Befehle. D.h. es gibt z.B. je einen Befehl um zwei int's float's oder double's zu addieren, suptrahieren usw. . Welche Typen ein Befehl erwartet wird meist durch einen Prefix im Namen des Befehls angedeutet. Etwa addiert iadd int's und fadd float's. Nicht alle Typen der JVM werden so äquivalent unterstützt. Insbesondere für int gibt es noch einige zusätzliche Befehle, die auch für long, float und double nicht vorhanden sind. Ansonsten sind diese 4 jedoch ähnlich gut unterstützt. Die primitiven Typen byte, short und char werden hingegen nicht besonders vielseitig durch eigene Befehle unterstützt. Sie werden für die meisten Operationen von der JVM automatisch zu int erweitert, als solche verarbeitet, und per Typkonvertierung wieder auf ihre ausgangslänge abgeschnitten.

Volle Unterstützung durch Befehlssatz

Kategorie Prefix JVM-Typ

1 i int

2 l long

1 f float

2 d double

1 a reference

Volle Unterstützung durch Befehlssatz
Kategorie	Prefix	JVM-Typ
1	`i`	`int`
2	`l`	`long`
1	`f`	`float`
2	`d`	`double`
1	`a`	`reference`
Geringe Unterstützung durch Befehlssatz (sonst als `int` behandelt)
1	`c`	`char`
1	`s`	`short`
1	`b`	`byte`

Geringe Unterstützung durch Befehlssatz (sonst als int behandelt)

1 c char

1 s short

1 b byte

Die JVM unterteilt ihre Typen zudem in Kategorie 1 und Kategorie 2 Typen. Alle Typen, die durch einen 32-Bit-Wert dargestellt werden konnen gehören zur Kategorie 1 (belegen 1 Element des OS oder LV):

Kategorie 1 = ( int, float, returnAddress, reference, [ byte, short, char ] )

Die wenig unterstützten Typen sind nur impliziet Teil dieser Menge, da sie auf dem Operand-Stack oder in den lokalen Variablen als int abgelegt werden. Zur Kategorie 2 gehören die verbleibenden 64-Bit breiten Typen:

Kategorie 2 = ( long, double )

Diese belegen immer 2 aufeinander folgende Elemente des Operand-Stack oder der lokalen Variablen. Diese gehören untrennbar zusammen, und dürfen von Befehlen entwerder garnicht oder nur als Einheit (Paar) manipuliert werden. Daher existieren von einigen Befehlen zwei Varianten: Je eine für Kategorie 1 und eine für Kategorie 2 Typen. Zum Beispiel entnimmt pop das oberste Kat1-Element vom Operand-Stack, pop2 die obersten 2 Kat1-Elemente oder das oberste Kat2-Element.

Der Befehlssatz der JVM ist so gestalltet, dass direktes Manipulieren eines Programm-Counters nicht möglich ist. Dieser kann mit Sprunganweisungen lediglich inkrementiert oder dekrementiert werden. Die Länge, um welche gesprungen wird, ist dabei bereits im Bytecode festgesetzt. Dadurch kann sichergestellt werden, dass ein Sprung die aktuelle Methoden-Implementierung nicht verlässt und zu einem gültigen Opcode eines Befehls führt.

↑ oben

V. 2 Index

Gruppiert

List der JVM-Befehle gruppiert nach ihrem Verwendungszweck
(Nicht verwendete aber reservierte Opcodes sind nicht enthalten)
Verwendung		Opcode Mnemonics
Daten-OPs "Load & Store"	Stack ⇔ Stack	nop, pop, pop2, dup, dup_x1, dup_x2, dup2, dup2_x1, dup2_x2, swap
	Konstante ⇒ Stack	aconst_null, iconst_<n> (iconst_m1, iconst_0, iconst_1, iconst_2, iconst_3, iconst_4, iconst_5), lconst_<n> (lconst_0, lconst_1), fconst_<n> (fconst_0, fconst_1, fconst_2), dconst_<n> (dconst_0, dconst_1) bipush, sipush, ldc, ldc_w, ldc2_w,
	Variable ⇒ Stack	iload, iload_<n> (iload_0, iload_1, iload_2, iload_3) lload, lload_<n> (lload_0, lload_1, lload_2, lload_3) fload, fload_<n> (fload_0, fload_1, fload_2, fload_3) dload, dload_<n> (dload_0, dload_1, dload_2, dload_3) aload, aload_<n> (aload_0, aload_1, aload_2, aload_3)
	Stack ⇒ Variable	istore, istore_<n> (istore_0, istore_1, istore_2, istore_3) lstore, lstore_<n> (lstore_0, lstore_1, lstore_2, lstore_3) fstore, fstore_<n> (fstore_0, fstore_1, fstore_2, fstore_3) dstore, dstore_<n> (dstore_0, dstore_1, dstore_2, dstore_3) astore, astore_<n> (astore_0, astore_1, astore_2, astore_3)
	Arraywert ⇒ Stack	iaload, laload, faload, daload, aaload, baload, caload, saload
	Stack ⇒ Arraywert	iastore, lastore, fastore, dastore, aastore, bastore, castore, sastore
	Variablen	iinc, wide
	Arrays	newarray, anewarray, arraylength, multianewarray
	Objekte	getstatic, putstatic, getfield, putfield, new, checkcast, instanceof
Arithmetik "ALU"	Ganzzahlen	iadd, isub, imul, idiv, irem, ineg, ladd, lsub, lmul, ldiv, lrem, lneg
	Gleitkomma	fadd, fsub, fmul, fdiv, frem, fneg, dadd, dsub, dmul, ddiv, drem, dneg
	Bitweise	ishl, ishr, iushr, iand, ior, ixor, lshl, lshr, lushr, land, lor, lxor
	Typumwandlung	i2l, i2f, i2d, i2b, i2c, i2s, l2i, l2f, l2d, f2i, f2l, f2d, d2i, d2l, d2f
Flusskontrolle	Sprünge	lcmp, fcmpl, fcmpg, dcmpl, dcmpg, ifeq, ifne, iflt, ifge, ifgt, ifle, if_icmpeq, if_icmpne, if_icmplt, if_icmpge, if_icmpgt, if_icmple, if_acmpeq, if_acmpne, ifnull, ifnonnull, goto, goto_w
	Unterprogramme	jsr, ret, jsr_w
	Tabellen	tableswitch, lookupswitch
	Methoden	invokevirtual, invokespecial, invokestatic, invokeinterface, ireturn, lreturn, freturn, dreturn, areturn, return
	Exceptions	athrow
	Threads	monitorenter, monitorexit

↑ oben

Alphabet

List der JVM-Befehle alphabetisch sortiert
(Nicht verwendete aber reservierte Opcodes sind nicht enthalten)
Opcode	Mnemonic	Opcode	Mnemonic	Opcode	Mnemonic	Opcode	Mnemonic
50 (x32)	aaload	92 (x5c)	dup2	7 (x07)	iconst_4	136 (x88)	l2i
83 (x53)	aastore	93 (x5d)	dup2_x1	8 (x08)	iconst_5	97 (x61)	ladd
1 (x01)	aconst_null	94 (x5e)	dup2_x2	2 (x02)	iconst_m1	47 (x2f)	laload
25 (x19)	aload	90 (x5a)	dup_x1	108 (x6c)	idiv	127 (x7f)	land
42 (x2a)	aload_0	91 (x5b)	dup_x2	153 (x99)	ifeq	80 (x50)	lastore
43 (x2b)	aload_1	141 (x8d)	f2d	156 (x9c)	ifge	148 (x94)	lcmp
44 (x2c)	aload_2	139 (x8b)	f2i	157 (x9d)	ifgt	9 (x09)	lconst_0
45 (x2d)	aload_3	140 (x8c)	f2l	158 (x9e)	ifle	10 (x0a)	lconst_1
189 (xbd)	anewarray	98 (x62)	fadd	155 (x9b)	iflt	18 (x12)	ldc
176 (xb0)	areturn	48 (x30)	faload	154 (x9a)	ifne	20 (x14)	ldc2_w
190 (xbe)	arraylenght	81 (x51)	fastore	199 (xc7)	ifnonnull	19 (x13)	ldc_w
58 (x3a)	astore	150 (x96)	fcmpg	198 (xc6)	ifnull	109 (x6d)	ldiv
75 (x4b)	astore_0	149 (x95)	fcmpl	165 (xa5)	if_acmpeq	22 (x16)	lload
76 (x4c)	astore_1	11 (x0b)	fconst_0	166 (xa6)	if_acmpne	30 (x1e)	lload_0
77 (x4d)	astore_2	12 (x0c)	fconst_1	159 (x9f)	if_icmpeq	31 (x1f)	lload_1
78 (x4e)	astore_3	13 (x0d)	fconst_2	162 (xa2)	if_icmpge	32 (x20)	lload_2
191 (xbf)	athrow	110 (x6e)	fdiv	163 (xa3)	if_icmpgt	33 (x21)	lload_3
51 (x33)	baload	23 (x17)	fload	164 (xa4)	if_icmple	105 (x69)	lmul
84 (x54)	bastore	34 (x22)	fload_0	161 (xa1)	if_icmplt	117 (x75)	lneg
16 (x10)	bipush	35 (x23)	fload_1	160 (xa0)	if_icmpne	171 (xab)	lookupswitch
52 (x34)	caload	36 (x24)	fload_2	132 (x84)	iinc	129 (x81)	lor
85 (x55)	castore	37 (x25)	fload_3	21 (x15)	iload	113 (x71)	lrem
192 (xc0)	checkcast	106 (x6a)	fmul	26 (x1a)	iload_0	173 (xad)	lreturn
144 (x90)	d2f	118 (x76)	fneg	27 (x1b)	iload_1	121 (x79)	lshl
142 (x8e)	d2i	114 (x72)	frem	28 (x1c)	iload_2	123 (x7b)	lshr
143 (x8f)	d2l	174 (xae)	freturn	29 (x1d)	iload_3	55 (x37)	lstore
99 (x63)	dadd	56 (x38)	fstore	104 (x68)	imul	63 (x3f)	lstore_0
49 (x31)	daload	67 (x43)	fstore_0	116 (x74)	ineg	64 (x40)	lstore_1
82 (x52)	dastore	68 (x44)	fstore_1	193 (xc1)	instanceof	65 (x41)	lstore_2
152 (x98)	dcmpg	69 (x45)	fstore_2	185 (xb9)	invokeinterface	66 (x42)	lstore_3
151 (x97)	dcmpl	70 (x46)	fstore_3	183 (xb7)	invokespecial	101 (x65)	lsub
14 (x0e)	dconst_0	102 (x66)	fsub	184 (xb8)	invokestatic	125 (x7d)	lushr
15 (x0f)	dconst_1	180 (xb4)	getfield	182 (xb6)	invokevirtual	131 (x83)	lxor
111 (x6f)	ddiv	178 (xb2)	getstatic	128 (x80)	ior	194 (xc2)	monitorenter
24 (x18)	dload	167 (xa7)	goto	112 (x70)	irem	195 (xc3)	monitorexit
38 (x26)	dload_0	200 (xc8)	goto_w	172 (xac)	ireturn	197 (xc5)	multianewarray
39 (x27)	dload_1	145 (x91)	i2b	120 (x78)	ishl	187 (xbb)	new
40 (x28)	dload_2	146 (x92)	i2c	122 (x7a)	ishr	188 (xbc)	newarray
41 (x29)	dload_3	135 (x87)	i2d	54 (x36)	istore	0 (x00)	nop
107 (x6b)	dmul	134 (x86)	i2f	59 (x3b)	istore_0	87 (x57)	pop
119 (x77)	dneg	133 (x85)	i2l	60 (x3c)	istore_1	88 (x58)	pop2
115 (x73)	drem	147 (x93)	i2s	61 (x3d)	istore_2	181 (xb5)	putfield
175 (xaf)	dreturn	96 (x60)	iadd	62 (x3e)	istore_3	179 (xb3)	putstatic
57 (x39)	dstore	46 (x2e)	iaload	100 (x64)	isub	169 (xa9)	ret
71 (x47)	dstore_0	126 (x7e)	iand	124 (x7c)	iushr	177 (xb1)	return
72 (x48)	dstore_1	79 (x4f)	iastore	130 (x82)	ixor	53 (x35)	saload
73 (x49)	dstore_2	3 (x03)	iconst_0	168 (xa8)	jsr	86 (x56)	sastore
74 (x4a)	dstore_3	4 (x04)	iconst_1	201 (xc9)	jsr_w	17 (x11)	sipush
103 (x67)	dsub	5 (x05)	iconst_2	138 (x8a)	l2d	95 (x5f)	swap
89 (x59)	dup	6 (x06)	iconst_3	137 (x89)	l2f	170 (xaa)	tableswitch

↑ oben

Opcode

List der JVM-Befehle sortiert nach ihrem Opcode
(Opcode 186 ist aus historischen Gründen nicht belegt)
Opcode	Mnemonic	Opcode	Mnemonic	Opcode	Mnemonic	Opcode	Mnemonic
0 (x00)	nop	64 (x40)	lstore_1	128 (x80)	ior	192 (xc0)	checkcast
1 (x01)	aconst_null	65 (x41)	lstore_2	129 (x81)	lor	193 (xc1)	instanceof
2 (x02)	iconst_m1	66 (x42)	lstore_3	130 (x82)	ixor	194 (xc2)	monitorenter
3 (x03)	iconst_0	67 (x43)	fstore_0	131 (x83)	lxor	195 (xc3)	monitorexit
4 (x04)	iconst_1	68 (x44)	fstore_1	132 (x84)	iinc	196 (xc4)	wide
5 (x05)	iconst_2	69 (x45)	fstore_2	133 (x85)	i2l	197 (xc5)	multianewarray
6 (x06)	iconst_3	70 (x46)	fstore_3	134 (x86)	i2f	198 (xc6)	ifnull
7 (x07)	iconst_4	71 (x47)	dstore_0	135 (x87)	i2d	199 (xc7)	ifnonnull
8 (x08)	iconst_5	72 (x48)	dstore_1	136 (x88)	l2i	200 (xc8)	goto_w
9 (x09)	lconst_0	73 (x49)	dstore_2	137 (x89)	l2f	201 (xc9)	jsr_w
10 (x0a)	lconst_1	74 (x4a)	dstore_3	138 (x8a)	l2d
11 (x0b)	fconst_0	75 (x4b)	astore_0	139 (x8b)	f2i
12 (x0c)	fconst_1	76 (x4c)	astore_1	140 (x8c)	f2l
13 (x0d)	fconst_2	77 (x4d)	astore_2	141 (x8d)	f2d
14 (x0e)	dconst_0	78 (x4e)	astore_3	142 (x8e)	d2i
15 (x0f)	dconst_1	79 (x4f)	iastore	143 (x8f)	d2l
16 (x10)	bipush	80 (x50)	lastore	144 (x90)	d2f
17 (x11)	sipush	81 (x51)	fastore	145 (x91)	i2b
18 (x12)	ldc	82 (x52)	dastore	146 (x92)	i2c
19 (x13)	ldc_w	83 (x53)	aastore	147 (x93)	i2s
20 (x14)	ldc2_w	84 (x54)	bastore	148 (x94)	lcmp
21 (x15)	iload	85 (x55)	castore	149 (x95)	fcmpl
22 (x16)	lload	86 (x56)	sastore	150 (x96)	fcmpg
23 (x17)	fload	87 (x57)	pop	151 (x97)	dcmpl
24 (x18)	dload	88 (x58)	pop2	152 (x98)	dcmpg
25 (x19)	aload	89 (x59)	dup	153 (x99)	ifeq
26 (x1a)	iload_0	90 (x5a)	dup_x1	154 (x9a)	ifne
27 (x1b)	iload_1	91 (x5b)	dup_x2	155 (x9b)	iflt
28 (x1c)	iload_2	92 (x5c)	dup2	156 (x9c)	ifge
29 (x1d)	iload_3	93 (x5d)	dup2_x1	157 (x9d)	ifgt
30 (x1e)	lload_0	94 (x5e)	dup2_x2	158 (x9e)	ifle
31 (x1f)	lload_1	95 (x5f)	swap	159 (x9f)	if_icmpeq
32 (x20)	lload_2	96 (x60)	iadd	160 (xa0)	if_icmpne
33 (x21)	lload_3	97 (x61)	ladd	161 (xa1)	if_icmplt
34 (x22)	fload_0	98 (x62)	fadd	162 (xa2)	if_icmpge
35 (x23)	fload_1	99 (x63)	dadd	163 (xa3)	if_icmpgt
36 (x24)	fload_2	100 (x64)	isub	164 (xa4)	if_icmple
37 (x25)	fload_3	101 (x65)	lsub	165 (xa5)	if_acmpeq
38 (x26)	dload_0	102 (x66)	fsub	166 (xa6)	if_acmpne
39 (x27)	dload_1	103 (x67)	dsub	167 (xa7)	goto
40 (x28)	dload_2	104 (x68)	imul	168 (xa8)	jsr
41 (x29)	dload_3	105 (x69)	lmul	169 (xa9)	ret
42 (x2a)	aload_0	106 (x6a)	fmul	170 (xaa)	tableswitch
43 (x2b)	aload_1	107 (x6b)	dmul	171 (xab)	lookupswitch
44 (x2c)	aload_2	108 (x6c)	idiv	172 (xac)	ireturn
45 (x2d)	aload_3	109 (x6d)	ldiv	173 (xad)	lreturn
46 (x2e)	iaload	110 (x6e)	fdiv	174 (xae)	freturn
47 (x2f)	laload	111 (x6f)	ddiv	175 (xaf)	dreturn
48 (x30)	faload	112 (x70)	irem	176 (xb0)	areturn
49 (x31)	daload	113 (x71)	lrem	177 (xb1)	return
50 (x32)	aaload	114 (x72)	frem	178 (xb2)	getstatic
51 (x33)	baload	115 (x73)	drem	179 (xb3)	putstatic
52 (x34)	caload	116 (x74)	ineg	180 (xb4)	getfield
53 (x35)	saload	117 (x75)	lneg	181 (xb5)	putfield
54 (x36)	istore	118 (x76)	fneg	182 (xb6)	invokevirtual
55 (x37)	lstore	119 (x77)	dneg	183 (xb7)	invokespecial
56 (x38)	fstore	120 (x78)	ishl	184 (xb8)	invokestatic
57 (x39)	dstore	121 (x79)	lshl	185 (xb9)	invokeinterface
58 (x3a)	astore	122 (x7a)	ishr	186 (xba)	u_n_u_s_e_d
59 (x3b)	istore_0	123 (x7b)	lshr	187 (xbb)	new
60 (x3c)	istore_1	124 (x7c)	iushr	188 (xbc)	newarray	Reserviert
61 (x3d)	istore_2	125 (x7d)	lushr	189 (xbd)	anewarray	202 (xca)	breakpoint
62 (x3e)	istore_3	126 (x7e)	iand	190 (xbe)	arraylenght	254 (xfe)	impdep1
63 (x3f)	lstore_0	127 (x7f)	land	191 (xbf)	athrow	255 (xff)	impdep2

↑ oben

V.3 Beschreibungsformat der Befehle

Jeder Befehl wird entsprechend dem untenstehenden Beispiel genau beschrieben. Einige Befehle gehören zu Befehlsfamilien. Alle Befehle einer Familie sind prinzipiel funktional identisch. Jeder benennt jedoch impliziet ein anderen konstanten Wert. Hierbei handelt es sich um eine numerische Konstante, oder den Index einer lokalen Variablen des aktuellen Frames. Für eine Befehlsfamilie existiert jeweils nur eine Beschreibung unter der Titel familie_<n>. Je nach Familie kann n verschiedene Werte annehmen. Diese sind unter Formen aufgeführt.

mnemonic

Beispiel:
Befehl	Kurzbeschreibung des Befehls
Format	mnemonic operant1 operant2 ...
Formen	mnemonic = opcode
Operanden-Stack	... wert1`type` wert2`type` ⇓ ... wert3`type`
Beschreibung	Eine ausführlichere Beschreibung, welche die Abläufe auf dem Operanden-Stack, Zugriffe auf den Konstanten-Pool oder die durchgeführte Operation und deren Ergebnisse beschreibt.
Exceptions	LinkingException Beschreibung möglicher Ursachen RuntimeException Beschreibung möglicher Ursachen
Hinweise	Zusätzliche Hinweise, die nicht direkt mit der Operation zusammenhängen, aber in deren Kontext evt. hilfreich sein könnten.

Das Format des Befehls stellt die einzelnen Bytes des Befehls dar, so wie dieser im Bytecode der class-Dateien steht. Teilweise wird dabei eine numerische Konstante oder ein Index in den Laufzeit-Konstanten-Pool aus 2 Operanden-Bytes zusammengesetzt, die dann etwa mit operand1 und operand2 benannt sind. Die meisten Befehle bestehen jedoch ausschließlich aus dem 1. Byte (8 Bit) für den opcode / mnemonic.

In der Zeile Operanden-Stack werden die Auswirkungen des Befehls auf den Operanden-Stack gezeigt. Der Stack baut sich von oben nach unten auf. Der meist als erstes angeführte ...-Eintrag deutet an, dass vor den verwendteten Befehlen beliebige (auch keine) Befehle auf dem Stack vorhanden sein können, die, von der Operation unangetastet, auf dem Stack verbleiben. Die breite eines Stack-Eintrags ist hier proportional richtig zur Breite eines Bytes in der Formatangabe dargestellt. Alle Einträge auf dem Stack sind also 4 Byte = 32 Bit breit. Operanden vom Typ long oder double die 64 Bit breit sind, und daher eigentlich auch 2 Einträge auf dem Stack entsprechen, werden als 1 voller Eintrag gefolgt von einem verkleinerten dargestellt (wie bei wert2), da die 2 Einträge ohnehin untrennbar sind, und nur von entsprechenden Befehlen als ein ganzes behandelt werden können. Durch die hier gewählte logisch Darstellung verdeutlicht sich die Arbeitsweise des Befehls besser. Die Analogie zu gleichen Befehlen für andere Datentypen zeigt sich sofoert.

Der Typ jedes Operanden auf dem Stack ist (sofern dieser von einem bestimmten Typ sein muss) in Klammern hinter dem Operanden angegeben. Unterschieden wird zwischen den einfachen Datentypen int, long, float, double und dem Referenztypen reference. Die Typen byte, short und char werden von der JVM als int auf dem OS verarbeitet. Dazu werden diese automatisch richtig auf eine 32-Bit Integer-Darstellung erweitert. wert3 deutet etwa eine Erweiterung von short zu int an.

Befehl	Läd Objekt-`reference` value aus Zelle index des Arrays arrayref
Format	aaload
Formen	aaload = 50 (x32)
Operand-Stack	... arrayref `reference` index `int` ... value `reference`
Beschreibung	Die Referenz arrayref muss auf ein Array verweisen, dessen Komponenten ebenfalls vom Typ `reference` sind. Aus arrayref und index, die vom Stack entnommen werden, wird die `reference` value an der Position index des Arrays bestimmt, und auf den Stack gebracht.
Exceptions	NullPointerException arrayref ist `null` ArrayIndexOutOfBoundsException index ist nicht innerhalb der Grenzen des durch arrayref bestimmten Arrays

Befehl	Speichert `reference` value in Zelle index des Arrays arrayref
Format	aastore
Formen	aastore = 83 (x53)
Operand-Stack	... arrayref `reference` index `int` value `reference` ...
Beschreibung	Die Operanden arrayref, index und value werden vom Operad-Stack entnommen. Die `reference` value wird im Array arrayref in Zelle index abgelegt. Dessen Elementtyp muss zuweisungskompatibel mit der Klasse von value sein.
Exceptions	NullPointerException arrayref ist `null`. ArrayIndexOutOfBoundsException index liegt nicht in den Grenzen des druch arrayref referenzierten Arrays. ArrayStoreException value ist nicht zuweisungskompatibel mit dem Elementtyp des durch arrayref referenzierten Arrays.

Befehl	`null` auf OS
Format	aconst_null
Formen	aconst_null = 1 (x01)
Operand-Stack	... ... `null`
Beschreibung	Bringt die `null` Objekt-`reference` auf den Operand-Stack.
Hinweis	Die JVM schreibt keinen bestimmten Wert für `null` vor.

Befehl	Läd `reference` objectref aus lokaler Variable index
Format	aload index
Formen	aload = 25 (x19)
Operand-Stack	... ... objectref `reference`
Beschreibung	Der index ist ein vorzeichenloser `byte`-Wert, der einen Index in das Array der lokalen Variablen des aktuellen Frames angibt. Dies muss dort eine objectref `reference` enthalten, die auf den Operand-Stack gebracht wird.
Hinweis	Der `aload` Befehl kann nicht verwendet werden, um einen Wert vom Typ `returnAddress` auf den OS zu bringen. Diese Asymetrie zum `astore` Befehl ist beabsichtigt, um direkte Manipulationen des PCs durch den Programmierer zu verhindern. Der `aload` Befehl kann zusammen mit dem `wide` Befehl verwendet werden, um einen höheren Index über eine vorzeichenlose 2-`byte`-Wert anzugeben.

Befehl	Neues 1-dimensionales Array mit `reference` Elementtyp anlegen
Format	anewarray indexbyte1 indexbyte2
Formen	anewarray = 189 (xbd)
Operand-Stack	... count `int` ... arrayref `reference`

Befehl	Rückgabewert `reference` objectref einer Methode
Format	areturn
Formen	areturn = 176 (xb0)
Operand-Stack	... objectref `reference` [empty]

Befehl	Länge eines Arrays lesen
Format	arraylenght
Formen	arraylenght = 190 (xbe)
Operand-Stack	... arrayref `reference` ... length `int`

Befehl	Speichert `returnAddress` oder `reference` objectref in lokaler Variable index
Format	astore index
Formen	astore = 58 (x3a)
Operand-Stack	... objectref `reference\|returnAddress` ...
Beschreibung	Der index ist ein vorzeichenloser `byte`-Wert, der einen Index in das Array der lokalen Variablen des aktuellen Frames angibt. Die `reference` bzw. `returnAddress` objectref wird vom Operand-Stack entnommen und in der lokalen Variable index gespeichert.
Hinweis	Der `astore` Befehl kann zusammen mit dem `wide` Befehl verwendet werden, um einen höheren Index über eine vorzeichenlose 2-`byte`-Wert anzugeben.

Befehl	Speichert refernce oder `returnAddress` objectref in lokaler Variable a
Format	astore_<a>
Formen	astore_0 = 75 (x4b) astore_1 = 76 (x4c) astore_2 = 77 (x4d) astore_3 = 78 (x4e)
Operand-Stack	... objectref `reference\|returnAddress` ...
Beschreibung	Die `reference` bzw. `returnAddress` objectref wird vom Operand-Stack entnommen und in der lokalen Variable a (0, 1 , 2, 3) gespeichert.
Hinweis	Jeder Befehl der Familie ist äquivalent zum `astore` `<a>` Befehl, nur dass der Index a der lokalen Variable hier im Befehl selbst enthalten ist.

Befehl	Exception oder Error auslösen
Format	athrow
Formen	athrow = 191 (xbf)
Operand-Stack	... objectref `reference` objectref `reference`

Befehl	Addition (`double`): value1 + value2 = result
Format	dadd
Formen	dadd = 99 (x63)
Operand-Stack	... value1 `double` value2 `double` ... result `double`
Beschreibung	Entnimmt die `double`-Werte value1 und value2 vom Operand-Stack und legt die Summe value1 + value2 als Ergebnis result wieder auf diesem ab. Es gelten die Regeln der IEEE Arithmetik: x ∈ ℜ + `NaN` = `NaN` +∞ + -∞ = `NaN` +∞ + +∞ = +∞, -∞ + -∞ = -∞ ±∞ + x ∈ ℜ = ±∞ +0 + -0 = +0, ±0 + ±0 = ±0 ±0 + x ∈ ℜ = x +x ∈ ℜ + -x ∈ ℜ = +0 Ansonsten wird auf den nächsten `double`-Wert gerundet (Round to nearest-Modus). Dadurch kann es zu einem Über- oder Unterlauf kommen. Auch dann wird keine Exception ausgelöst.

Befehl	Läd `byte` oder `boolean` value aus Zelle index des Arrays arrayref
Format	baload
Formen	baload = 51 (x33)
Operand-Stack	... arrayref `reference` index `int` ... value `int`
Beschreibung	Die Referenz arrayref muss auf ein Array verweisen, dessen Komponenten vom Typ `byte` oder `boolean` sind. Aus arrayref und index, die vom Stack entnommen werden, wird der `byte`- oder `boolean`-Wert an der Position index des Arrays bestimmt, auf den `int`-Wert value erweiteret, und dieser auf den Stack gebracht. Für `byte` wird das Vorzeichen berücksichtigt. Bei `boolean` findet eine vorzeichenlose Erweiterung statt.
Exceptions	NullPointerException arrayref ist `null` ArrayIndexOutOfBoundsException index ist nicht innerhalb der Grenzen des durch arrayref bestimmten Arrays
Hinweis	Die baload-Anweisung wird sowohl für `byte`- als auch `boolean`-Arrays verwendet. Suns Implementierung verwendet etwa 8 Bit Werte um ein `boolean` abzubilden. Diese können aber ebenso als Bitfeld implementiert werden.

Befehl	Speichert `byte` oder `boolean` value in Zelle index des Arrays arrayref
Format	bastore
Formen	bastore = 84 (x54)
Operand-Stack	... arrayref `reference` index `int` value `int` ...
Beschreibung	Die Operanden arrayref, index und value werden vom Operad-Stack entnommen. Der `int` Wert value wird auf `byte` gekürzt, und im Array arrayref in Zelle index abgelegt.
Exceptions	NullPointerException arrayref ist `null`. ArrayIndexOutOfBoundsException index liegt nicht in den Grenzen des druch arrayref referenzierten Arrays.
Hinweis	Der `bastore` Befehl wird für `byte`- und `boolean`-Arrays verwendet, um einen Wert darin zu setzen. Ein `boolean`-Array kann dabei als `byte`-Array oder auch als Bitfeld implementiert sein.

Befehl	`byte` Konstante bvalue zu `int` ivalue erweitern und auf OS
Format	bipush bvalue
Formen	bipush = 16 (x10)
Operand-Stack	... ... ivalue `int`
Beschreibung	Erweitert die `byte` Konstante bvalue vorzeichenbehaftet zum `int`-Wert ivalue und legt diesen auf dem Operand-Stack ab.

Befehl	Läd `char` value aus Zelle index des Arrays arrayref
Format	caload
Formen	caload = 52 (x34)
Operand-Stack	... arrayref `reference` index `int` ... value `int`
Beschreibung	Die Referenz arrayref muss auf ein Array verweisen, dessen Komponenten vom Typ `char` sind. Aus arrayref und index, die vom Stack entnommen werden, wird der `char`-Wert an der Position index des Arrays bestimmt, vorzeichenlos auf den `int`-Wert value erweitert, und dieser auf den Stack gebracht.
Exceptions	NullPointerException arrayref ist `null` ArrayIndexOutOfBoundsException index ist nicht innerhalb der Grenzen des durch arrayref bestimmten Arrays

Befehl	Speichert `char` value in Zelle index des Arrays arrayref
Format	castore
Formen	castore = 85 (x55)
Operand-Stack	... arrayref `reference` index `int` value `int` ...
Beschreibung	Die Operanden arrayref, index und value werden vom Operad-Stack entnommen. Der `int` Wert value wird auf `char` gekürzt, und im Array arrayref in Zelle index abgelegt.
Exceptions	NullPointerException arrayref ist `null`. ArrayIndexOutOfBoundsException index liegt nicht in den Grenzen des druch arrayref referenzierten Arrays.

Befehl	Prüfen, ob `reference` objectref zu einer bestimmten Klasse zuweisungsungskompatiebel ist
Format	checkcast indexbyte1 indexbyte2
Formen	checkcast = 192 (xc0)
Operand-Stack	... objectref `reference` ... objectref `reference`

Befehl	Typkonvertierung: `double` value zu `float` result
Format	d2f
Formen	d2f = 144 (x90)
Operand-Stack	... value `double` ... result `float`

Befehl	Typkonvertierung: `double` value zu `int` result
Format	d2i
Formen	d2i = 142 (x8e)
Operand-Stack	... value `double` ... result `int`

Befehl	Typkonvertierung: `double` value zu `long` result
Format	d2l
Formen	d2l = 143 (x8f)
Operand-Stack	... value `double` ... result `long`

Befehl	Läd `double` value aus Zelle index des Arrays arrayref
Format	daload
Formen	daload = 49 (x31)
Operand-Stack	... arrayref `reference` index `int` ... value `double`
Beschreibung	Die Referenz arrayref muss auf ein Array verweisen, dessen Komponenten vom Typ `double` sind. Aus arrayref und index, die vom Stack entnommen werden, wird der `double`-Wert value an der Position index des Arrays bestimmt, und auf den Stack gebracht.
Exceptions	NullPointerException arrayref ist `null` ArrayIndexOutOfBoundsException index ist nicht innerhalb der Grenzen des durch arrayref bestimmten Arrays

V. Befehlssatz

V. 1 Zusammenfassung

V. 2 Index

V.3 Beschreibungsformat der Befehle

V.4 Befehle A-Z

Befehl	Speichert `double` value in Zelle index des Arrays arrayref
Format	dastore
Formen	dastore = 82 (x52)
Operand-Stack	... arrayref `reference` index `int` value `double` ...
Beschreibung	Die Operanden arrayref, index und value werden vom Operad-Stack entnommen. Der `double` Wert value wird im Array arrayref in Zelle index abgelegt.
Exceptions	NullPointerException arrayref ist `null`. ArrayIndexOutOfBoundsException index liegt nicht in den Grenzen des druch arrayref referenzierten Arrays.

Befehl	Vergeich (`double`): value1 == value2 ?
Format	dcmp<d>
Formen	dcmpl = 151 (x97) dcmpg = 152 (x98)
Operand-Stack	... value1 `double` value2 `double` ... result `int`

Befehl	`double`-Konstante const_value auf OS
Format	dconst_<d>
Formen	dconst_0 = 14 (x0e) dconst_1 = 15 (x0f)
Operand-Stack	... ... const_value `double`
Beschreibung	Bringt die `double` Konstante const_value (0.0d, 1.0d) auf den Operand-Stack.

Befehl	Division (`double`): value1 / value2 = result
Format	ddiv
Formen	ddiv = 111 (x6f)
Operand-Stack	... value1 `double` value2 `double` ... result `double`

Befehl	Läd `double` value aus lokaler Variable index und index + 1
Format	dload index
Formen	dload = 24 (x18)
Operand-Stack	... ... value `double`
Beschreibung	Der index ist ein vorzeichenloser `byte`-Wert, der einen Index in das Array der lokalen Variablen des aktuellen Frames angibt. Der an index und index + 1 enthaltene `double`-Wert value wird auf den Operand-Stack gebracht.
Hinweis	Der `dload` Befehl kann zusammen mit dem `wide` Befehl verwendet werden, um einen höheren Index über eine vorzeichenlose 2-`byte`-Wert anzugeben.

Befehl	Multiplikation (`double`): value1 * value2 = result
Format	dmul
Formen	dmul = 107 (x6b)
Operand-Stack	... value1 `double` value2 `double` ... result `double`

Befehl	Negation (`double`): -value = result
Format	dneg
Formen	dneg = 119 (x77)
Operand-Stack	... value `double` ... result `double`

Befehl	Divisionsrest (`double`): value1 % value2 = result
Format	drem
Formen	drem = 115 (x73)
Operand-Stack	... value1 `double` value2 `double` ... result `double`

Befehl	Rückgabewert `double` value einer Methode
Format	dreturn
Formen	dreturn = 175 (xaf)
Operand-Stack	... value `double` [empty]

Befehl	Speichert `double` value in lokalen Variablen index und index + 1
Format	dstore index
Formen	dstore = 57 (x39)
Operand-Stack	... value `double` ...
Beschreibung	Der index ist ein vorzeichenloser `byte`-Wert, der einen Index in das Array der lokalen Variablen des aktuellen Frames angibt. Der `double` Wert value wird vom Operand-Stack entnommen und in den lokalen Variablen index und index + 1 gespeichert.
Hinweis	Der `dstore` Befehl kann zusammen mit dem `wide` Befehl verwendet werden, um einen höheren Index über eine vorzeichenlose 2-`byte`-Wert anzugeben.