eine Referenz von einer lokalen Variablen auf den Stack laden #Index
aload_0
2a
0010 1010
→ Objektref
Laden Sie eine Referenz auf den Stack von der lokalen Variablen 0
aload_1
2b
0010 1011
→ Objektref
Laden Sie eine Referenz auf den Stack von lokaler Variable 1
aload_2
2c
0010 1100
→ Objektref
Laden Sie eine Referenz auf den Stack von lokaler Variable 2
aload_3
2d
0010 1101
→ Objektref
Laden Sie eine Referenz auf den Stack von der lokalen Variablen 3
anewarray
bd
1011 1101
2: Indexbyte1, Indexbyte2
count → arrayref
Erstellen Sie ein neues Array von Referenzen der Länge zählen und Komponententyp identifiziert durch die Klassenreferenz Index (Indexbyte1 << 8 | Indexbyte2) im Dauerpool
eine Rückgabe
b0
1011 0000
Objektref → [empty]
eine Referenz von einer Methode zurückgeben
Arraylänge
Sein
1011 1110
Arrayref → Länge
Holen Sie sich die Länge eines Arrays
ein Laden
3a
0011 1010
1: Index
Objektref →
eine Referenz in eine lokale Variable speichern #Index
astore_0
4b
0100 1011
Objektref →
speichere eine Referenz in die lokale Variable 0
astore_1
4c
0100 1100
Objektref →
speichere eine Referenz in lokale Variable 1
astore_2
4d
0100 1101
Objektref →
speichere eine Referenz in lokale Variable 2
astore_3
4e
0100 1110
Objektref →
speichere eine Referenz in lokale Variable 3
werfen
bf
1011 1111
Objektref → [empty], Objektref
wirft einen Fehler oder eine Ausnahme aus (beachten Sie, dass der Rest des Stapels gelöscht wird und nur ein Verweis auf das Throwable übrig bleibt)
balladen
33
0011 0011
Arrayref, Index → Wert
Laden Sie einen Byte- oder Booleschen Wert aus einem Array
bastore
54
0101 0100
Arrayref, Index, Wert →
einen Byte- oder Booleschen Wert in einem Array speichern
bipush
10
0001 0000
1: Byte
→ Wert
drücke ein Byte auf den Stack als ganze Zahl Wert
Haltepunkt
ca
1100 1010
reserviert für Breakpoints in Java-Debuggern; sollte in keiner Klassendatei erscheinen
lade
34
0011 0100
Arrayref, Index → Wert
lade ein Zeichen aus einem Array
castore
55
0101 0101
Arrayref, Index, Wert →
speichere ein Zeichen in einem Array
Checkcast
c0
1100 0000
2: Indexbyte1, Indexbyte2
Objektref → Objektref
prüft, ob ein Objektref von einem bestimmten Typ ist, dessen Klassenreferenz im konstanten Pool at . liegt Index (Indexbyte1 << 8 | Indexbyte2)
d2f
90
1001 0000
Wert → Ergebnis
Wandeln Sie ein Double in einen Float um
d2i
8e
1000 1110
Wert → Ergebnis
Konvertieren Sie ein Double in ein Int
d2l
8f
1000 1111
Wert → Ergebnis
Konvertieren Sie ein Double in ein Long
Papa
63
0110 0011
Wert1, Wert2 → Ergebnis
füge zwei Doppel hinzu
daload
31
0011 0001
Arrayref, Index → Wert
lade ein Double aus einem Array
dastore
52
0101 0010
Arrayref, Index, Wert →
speichere ein Double in einem Array
dcmpg
98
1001 1000
Wert1, Wert2 → Ergebnis
vergleiche zwei Doppel, 1 auf NaN
dcmpl
97
1001 0111
Wert1, Wert2 → Ergebnis
vergleiche zwei Doppel, -1 auf NaN
dconst_0
0e
0000 1110
→ 0.0
drücke die Konstante 0.0 (ein doppelt) auf den Stapel
dconst_1
0f
0000 1111
→ 1.0
drücke die Konstante 1.0 (ein doppelt) auf den Stapel
div
6f
0110 1111
Wert1, Wert2 → Ergebnis
zwei Doppel teilen
laden
18
0001 1000
1: Index
→ Wert
ein Doppel laden Wert aus einer lokalen Variablen #Index
dload_0
26
0010 0110
→ Wert
lade ein Double aus der lokalen Variablen 0
dload_1
27
0010 0111
→ Wert
lade ein Double aus lokaler Variable 1
dload_2
28
0010 1000
→ Wert
lade ein Double aus der lokalen Variablen 2
dload_3
29
0010 1001
→ Wert
lade ein Double aus der lokalen Variablen 3
dmul
6b
0110 1011
Wert1, Wert2 → Ergebnis
multipliziere zwei Doppel
dneg
77
0111 0111
Wert → Ergebnis
ein Doppel negieren
drem
73
0111 0011
Wert1, Wert2 → Ergebnis
erhalte den Rest aus einer Division zwischen zwei Doppeln
zurück
af
1010 1111
Wert → [empty]
Rückgabe eines Doubles von einer Methode
dstore
39
0011 1001
1: Index
Wert →
ein Doppel speichern Wert in eine lokale Variable #Index
dstore_0
47
0100 0111
Wert →
speichere ein Double in die lokale Variable 0
dstore_1
48
0100 1000
Wert →
speichere ein Double in lokale Variable 1
dstore_2
49
0100 1001
Wert →
speichere ein Double in die lokale Variable 2
dstore_3
4a
0100 1010
Wert →
speichere ein Double in lokale Variable 3
dsub
67
0110 0111
Wert1, Wert2 → Ergebnis
subtrahiere ein Doppeltes von einem anderen
betrügen
59
0101 1001
Wert → Wert, Wert
Dupliziere den Wert oben auf dem Stapel
dup_x1
5a
0101 1010
Wert2, Wert1 → Wert1, Wert2, Wert1
Fügen Sie eine Kopie des obersten Wertes in den Stapel zwei Werte von oben ein. value1 und value2 dürfen nicht vom Typ double oder long sein.
dup_x2
5b
0101 1011
Wert3, Wert2, Wert1 → Wert1, Wert3, Wert2, Wert1
füge eine Kopie des obersten Wertes in den Stack ein zwei (wenn wert2 doppelt oder lang ist, nimmt es auch den Eintrag von wert3 auf) oder drei Werte (wenn wert2 weder doppelt noch lang ist) von oben
dup2
5c
0101 1100
{Wert2, Wert1} → {Wert2, Wert1}, {Wert2, Wert1}
Duplizieren der obersten beiden Stapelwörter (zwei Werte, wenn Wert1 weder doppelt noch lang ist; ein einzelner Wert, wenn Wert1 doppelt oder lang ist)
zwei Wörter duplizieren und unter dem vierten Wort einfügen
f2d
8d
1000 1101
Wert → Ergebnis
einen Float in einen Double umwandeln
f2i
8b
1000 1011
Wert → Ergebnis
einen Float in einen int umwandeln
f2l
8c
1000 1100
Wert → Ergebnis
einen Float in einen Long umwandeln
Mode
62
0110 0010
Wert1, Wert2 → Ergebnis
füge zwei Schwimmer hinzu
faload
30
0011 0000
Arrayref, Index → Wert
einen Float aus einem Array laden
schnell
51
0101 0001
Arrayref, Index, Wert →
speichere einen Float in einem Array
fcmpg
96
1001 0110
Wert1, Wert2 → Ergebnis
vergleiche zwei Schwimmer, 1 auf NaN
fcmpl
95
1001 0101
Wert1, Wert2 → Ergebnis
vergleiche zwei Floats, -1 auf NaN
fconst_0
0b
0000 1011
→ 0.0f
drücken 0.0f auf dem Stapel
fconst_1
0c
0000 1100
→ 1.0f
drücken 1.0f auf dem Stapel
fconst_2
0d
0000 1101
→ 2.0f
drücken 2.0f auf dem Stapel
fdiv
6e
0110 1110
Wert1, Wert2 → Ergebnis
zwei Schwimmer teilen
fladen
17
0001 0111
1: Index
→ Wert
einen Schwimmer laden Wert aus einer lokalen Variablen #Index
fload_0
22
0010 0010
→ Wert
einen Schwimmer laden Wert von lokaler Variable 0
fload_1
23
0010 0011
→ Wert
einen Schwimmer laden Wert von lokaler Variable 1
fload_2
24
0010 0100
→ Wert
einen Schwimmer laden Wert von lokaler Variable 2
fload_3
25
0010 0101
→ Wert
einen Schwimmer laden Wert von lokaler Variable 3
fmul
6a
0110 1010
Wert1, Wert2 → Ergebnis
multiplizieren Sie zwei Schwimmer
fneg
76
0111 0110
Wert → Ergebnis
einen Schwimmer negieren
frem
72
0111 0010
Wert1, Wert2 → Ergebnis
erhalte den Rest aus einer Division zwischen zwei Floats
freturn
ae
1010 1110
Wert → [empty]
einen Schwimmer zurückgeben
fstore
38
0011 1000
1: Index
Wert →
einen Schwimmer aufbewahren Wert in eine lokale Variable #Index
fstore_0
43
0100 0011
Wert →
einen Schwimmer aufbewahren Wert in lokale Variable 0
fstore_1
44
0100 0100
Wert →
einen Schwimmer aufbewahren Wert in lokale Variable 1
fstore_2
45
0100 0101
Wert →
einen Schwimmer aufbewahren Wert in lokale Variable 2
fstore_3
46
0100 0110
Wert →
einen Schwimmer aufbewahren Wert in lokale Variable 3
fsub
66
0110 0110
Wert1, Wert2 → Ergebnis
zwei Floats abziehen
getfield
b4
1011 0100
2: Indexbyte1, Indexbyte2
Objektref → Wert
Holen Sie sich ein Feld Wert eines Objekts Objektref, wobei das Feld durch die Feldreferenz im Konstantenpool identifiziert wird Index (Indexbyte1 << 8 | Indexbyte2)
getstatic
b2
1011 0010
2: Indexbyte1, Indexbyte2
→ Wert
Bekomme ein statisches Feld Wert einer Klasse, wobei das Feld durch die Feldreferenz im Konstantenpool identifiziert wird Index (Indexbyte1 << 8 | Indexbyte2)
gehe zu
a7
1010 0111
2: Branchbyte1, Branchbyte2
[no change]
geht zu einer anderen Anweisung bei Verzweigungssatz (Signed Short aus vorzeichenlosen Bytes aufgebaut Branchbyte1 << 8 | Zweigbyte2)
geht zu einer anderen Anweisung bei Verzweigungssatz (signed int aus unsignierten Bytes aufgebaut Branchbyte1 << 24 | Branchbyte2 << 16 | Branchbyte3 << 8 | Branchbyte4)
i2b
91
1001 0001
Wert → Ergebnis
ein int in ein Byte umwandeln
i2c
92
1001 0010
Wert → Ergebnis
Konvertieren Sie ein Int in ein Zeichen
i2d
87
1000 0111
Wert → Ergebnis
wandle ein int in ein double um
i2f
86
1000 0110
Wert → Ergebnis
wandle einen int in einen float um
i2l
85
1000 0101
Wert → Ergebnis
Konvertieren Sie ein Int in ein Long
i2s
93
1001 0011
Wert → Ergebnis
wandle einen Int in einen Short um
ich füge hinzu
60
0110 0000
Wert1, Wert2 → Ergebnis
füge zwei ints hinzu
iaload
2e
0010 1110
Arrayref, Index → Wert
lade ein int aus einem Array
Ich und
7e
0111 1110
Wert1, Wert2 → Ergebnis
Führe ein bitweises UND auf zwei Ganzzahlen durch
iastore
4f
0100 1111
Arrayref, Index, Wert →
speichere ein int in einem Array
iconst_m1
02
0000 0010
→ -1
lade den int-Wert −1 auf den Stack
iconst_0
03
0000 0011
→ 0
lade den int-Wert 0 auf den Stack
iconst_1
04
0000 0100
→ 1
lade den int-Wert 1 auf den Stack
iconst_2
05
0000 0101
→ 2
lade den int-Wert 2 auf den Stack
iconst_3
06
0000 0110
→ 3
lade den int-Wert 3 auf den Stack
iconst_4
07
0000 0111
→ 4
lade den int-Wert 4 auf den Stack
iconst_5
08
0000 1000
→ 5
lade den int-Wert 5 auf den Stack
idiv
6c
0110 1100
Wert1, Wert2 → Ergebnis
dividiere zwei ganze Zahlen
if_acmpeq
a5
1010 0101
2: Branchbyte1, Branchbyte2
Wert1, Wert2 →
wenn Referenzen gleich sind, verzweigen Sie zur Anweisung at Verzweigungssatz (Signed Short aus vorzeichenlosen Bytes aufgebaut Branchbyte1 << 8 | Zweigbyte2)
if_acmpne
a6
1010 0110
2: Branchbyte1, Branchbyte2
Wert1, Wert2 →
wenn Referenzen nicht gleich sind, verzweigen Sie zur Anweisung at Verzweigungssatz (Signed Short aus vorzeichenlosen Bytes aufgebaut Branchbyte1 << 8 | Zweigbyte2)
if_icmpeq
9f
1001 1111
2: Branchbyte1, Branchbyte2
Wert1, Wert2 →
wenn ints gleich sind, verzweigen Sie zur Anweisung at Verzweigungssatz (Signed Short aus vorzeichenlosen Bytes aufgebaut Branchbyte1 << 8 | Zweigbyte2)
if_icmpge
a2
1010 0010
2: Branchbyte1, Branchbyte2
Wert1, Wert2 →
wenn Wert1 ist größer oder gleich Wert2, Verzweigung zur Anweisung bei Verzweigungssatz (Signed Short aus vorzeichenlosen Bytes aufgebaut Branchbyte1 << 8 | Zweigbyte2)
if_icmpgt
a3
1010 0011
2: Branchbyte1, Branchbyte2
Wert1, Wert2 →
wenn Wert1 ist größer als Wert2, Verzweigung zur Anweisung bei Verzweigungssatz (Signed Short aus vorzeichenlosen Bytes aufgebaut Branchbyte1 << 8 | Zweigbyte2)
if_icmple
a4
1010 0100
2: Branchbyte1, Branchbyte2
Wert1, Wert2 →
wenn Wert1 ist kleiner oder gleich Wert2, Verzweigung zur Anweisung bei Verzweigungssatz (Signed Short aus vorzeichenlosen Bytes aufgebaut Branchbyte1 << 8 | Zweigbyte2)
if_icmplt
a1
1010 0001
2: Branchbyte1, Branchbyte2
Wert1, Wert2 →
wenn Wert1 ist weniger als Wert2, Verzweigung zur Anweisung bei Verzweigungssatz (Signed Short aus vorzeichenlosen Bytes aufgebaut Branchbyte1 << 8 | Zweigbyte2)
if_icmpne
a0
1010 0000
2: Branchbyte1, Branchbyte2
Wert1, Wert2 →
wenn ints ungleich sind, verzweigen Sie zur Anweisung at Verzweigungssatz (Signed Short aus vorzeichenlosen Bytes aufgebaut Branchbyte1 << 8 | Zweigbyte2)
ifeq
99
1001 1001
2: Branchbyte1, Branchbyte2
Wert →
wenn Wert ist 0, Verzweigung zur Anweisung at Verzweigungssatz (Signed Short aus vorzeichenlosen Bytes aufgebaut Branchbyte1 << 8 | Zweigbyte2)
wennge
9c
1001 1100
2: Branchbyte1, Branchbyte2
Wert →
wenn Wert größer oder gleich 0 ist, zur Anweisung verzweigen bei Verzweigungssatz (Signed Short aus vorzeichenlosen Bytes aufgebaut Branchbyte1 << 8 | Zweigbyte2)
wenngt
9d
1001 1101
2: Branchbyte1, Branchbyte2
Wert →
wenn Wert größer als 0 ist, Verzweigung zum Befehl at Verzweigungssatz (Signed Short aus vorzeichenlosen Bytes aufgebaut Branchbyte1 << 8 | Zweigbyte2)
ifle
9e
1001 1110
2: Branchbyte1, Branchbyte2
Wert →
wenn Wert kleiner oder gleich 0 ist, verzweige zur Anweisung at Verzweigungssatz (Signed Short aus vorzeichenlosen Bytes aufgebaut Branchbyte1 << 8 | Zweigbyte2)
iflt
9b
1001 1011
2: Branchbyte1, Branchbyte2
Wert →
wenn Wert kleiner als 0 ist, verzweige zur Anweisung at Verzweigungssatz (Signed Short aus vorzeichenlosen Bytes aufgebaut Branchbyte1 << 8 | Zweigbyte2)
wennne
9a
1001 1010
2: Branchbyte1, Branchbyte2
Wert →
wenn Wert ist nicht 0, Verzweigung zur Anweisung at Verzweigungssatz (Signed Short aus vorzeichenlosen Bytes aufgebaut Branchbyte1 << 8 | Zweigbyte2)
ifnonnull
c7
1100 0111
2: Branchbyte1, Branchbyte2
Wert →
wenn Wert ist nicht null, verzweige zur Anweisung at Verzweigungssatz (Signed Short aus vorzeichenlosen Bytes aufgebaut Branchbyte1 << 8 | Zweigbyte2)
wennnull
c6
1100 0110
2: Branchbyte1, Branchbyte2
Wert →
wenn Wert ist null, verzweige zur Anweisung at Verzweigungssatz (Signed Short aus vorzeichenlosen Bytes aufgebaut Branchbyte1 << 8 | Zweigbyte2)
iinc
84
1000 0100
2: index, const
[No change]
lokale Variable inkrementieren #Index durch signiertes Byte const
iload
fünfzehn
0001 0101
1: Index
→ Wert
ein int laden Wert aus einer lokalen Variablen #Index
iload_0
1a
0001 1010
→ Wert
ein int laden Wert von lokaler Variable 0
iload_1
1b
0001 1011
→ Wert
ein int laden Wert von lokaler Variable 1
iload_2
1c
0001 1100
→ Wert
ein int laden Wert von lokaler Variable 2
iload_3
1d
0001 1101
→ Wert
ein int laden Wert von lokaler Variable 3
impdep1
fe
1111 1110
reserviert für implementierungsabhängige Operationen innerhalb von Debuggern; sollte in keiner Klassendatei erscheinen
impdep2
ff
1111 1111
reserviert für implementierungsabhängige Operationen innerhalb von Debuggern; sollte in keiner Klassendatei erscheinen
imul
68
0110 1000
Wert1, Wert2 → Ergebnis
zwei ganze Zahlen multiplizieren
ineg
74
0111 0100
Wert → Ergebnis
negieren int
Instanz von
c1
1100 0001
2: Indexbyte1, Indexbyte2
Objektref → Ergebnis
bestimmt, ob ein Objekt Objektref ist von einem bestimmten Typ, identifiziert durch Klassenreferenz Index im ständigen Pool (Indexbyte1 << 8 | Indexbyte2)
invokedynamic
ba
1011 1010
4: Indexbyte1, Indexbyte2, 0, 0
[arg1, arg2, …] → Ergebnis
ruft eine dynamische Methode auf und legt das Ergebnis auf den Stack (möglicherweise void); die Methode wird durch Methodenreferenz identifiziert Index im ständigen Pool (Indexbyte1 << 8 | Indexbyte2)
invokeinterface
b9
1011 1001
4: Indexbyte1, Indexbyte2, Anzahl, 0
Objektref, [arg1, arg2, …] → Ergebnis
ruft eine Schnittstellenmethode für das Objekt auf Objektref und legt das Ergebnis auf den Stack (kann ungültig sein); die Schnittstellenmethode wird durch die Methodenreferenz identifiziert Index im ständigen Pool (Indexbyte1 << 8 | Indexbyte2)
invokespecial
b7
1011 0111
2: Indexbyte1, Indexbyte2
Objektref, [arg1, arg2, …] → Ergebnis
Instanzmethode für Objekt aufrufen Objektref und legt das Ergebnis auf den Stack (kann ungültig sein); die Methode wird durch Methodenreferenz identifiziert Index im ständigen Pool (Indexbyte1 << 8 | Indexbyte2)
invokestatisch
b8
1011 1000
2: Indexbyte1, Indexbyte2
[arg1, arg2, …] → Ergebnis
ruft eine statische Methode auf und legt das Ergebnis auf den Stack (möglicherweise void); die Methode wird durch Methodenreferenz identifiziert Index im ständigen Pool (Indexbyte1 << 8 | Indexbyte2)
invokevirtual
b6
1011 0110
2: Indexbyte1, Indexbyte2
Objektref, [arg1, arg2, …] → Ergebnis
Virtuelle Methode für Objekt aufrufen Objektref und legt das Ergebnis auf den Stack (kann ungültig sein); die Methode wird durch Methodenreferenz identifiziert Index im ständigen Pool (Indexbyte1 << 8 | Indexbyte2)
ior
80
1000 0000
Wert1, Wert2 → Ergebnis
bitweise int ODER
irem
70
0111 0000
Wert1, Wert2 → Ergebnis
logischer int Rest
Ich kehre zurück
ac
1010 1100
Wert → [empty]
eine ganze Zahl von einer Methode zurückgeben
ishl
78
0111 1000
Wert1, Wert2 → Ergebnis
int nach links verschieben
ishr
7a
0111 1010
Wert1, Wert2 → Ergebnis
int arithmetische Verschiebung nach rechts
speicher
36
0011 0110
1: Index
Wert →
int speichern Wert in variabel #Index
istore_0
3b
0011 1011
Wert →
int speichern Wert in Variable 0
istore_1
3c
0011 1100
Wert →
int speichern Wert in Variable 1
istore_2
3d
0011 1101
Wert →
int speichern Wert in Variable 2
istore_3
3e
0011 1110
Wert →
int speichern Wert in Variable 3
isub
64
0110 0100
Wert1, Wert2 → Ergebnis
int subtrahieren
iushr
7c
0111 1100
Wert1, Wert2 → Ergebnis
int logische Verschiebung nach rechts
ixor
82
1000 0010
Wert1, Wert2 → Ergebnis
int xor
jsrIch
a8
1010 1000
2: Branchbyte1, Branchbyte2
→ Adresse
zum Unterprogramm springen um Verzweigungssatz (Signed Short aus vorzeichenlosen Bytes aufgebaut Branchbyte1 << 8 | Zweigbyte2) und lege die Rücksendeadresse auf den Stapel
zum Unterprogramm springen um Verzweigungssatz (signed int aus unsignierten Bytes aufgebaut Branchbyte1 << 24 | Branchbyte2 << 16 | Branchbyte3 << 8 | Branchbyte4) und lege die Rücksendeadresse auf den Stapel
l2d
8a
1000 1010
Wert → Ergebnis
Wandeln Sie ein Long in ein Double um
l2f
89
1000 1001
Wert → Ergebnis
Wandeln Sie einen Long in einen Float um
l2i
88
1000 1000
Wert → Ergebnis
Wandeln Sie ein langes in ein int um
Junge
61
0110 0001
Wert1, Wert2 → Ergebnis
füge zwei Longs hinzu
laload
2f
0010 1111
Arrayref, Index → Wert
lade ein langes aus einem Array
Land
7f
0111 1111
Wert1, Wert2 → Ergebnis
bitweise UND von zwei Longs
lastore
50
0101 0000
Arrayref, Index, Wert →
speichere ein langes in einem Array
lcmp
94
1001 0100
Wert1, Wert2 → Ergebnis
0 drücken, wenn die beiden Longs gleich sind, 1, wenn Wert1 größer als Wert2 ist, sonst -1
lconst_0
09
0000 1001
→ 0L
drücken 0L (die Zahl Null mit Typ lang) auf den Stapel
lconst_1
0a
0000 1010
→ 1L
drücken 1L (die Nummer eins mit Typ lang) auf den Stapel
ldc
12
0001 0010
1: Index
→ Wert
eine Konstante drücken #Index aus einem Konstantenpool (String, int, float, Class, java.lang.invoke.MethodType, java.lang.invoke.MethodHandle oder eine dynamisch berechnete Konstante) auf den Stack
ldc_w
13
0001 0011
2: Indexbyte1, Indexbyte2
→ Wert
eine Konstante drücken #Index aus einem Konstantenpool (String, int, float, Class, java.lang.invoke.MethodType, java.lang.invoke.MethodHandle oder eine dynamisch berechnete Konstante) auf den Stack (wide Index ist konstruiert als Indexbyte1 << 8 | Indexbyte2)
ldc2_w
14
0001 0100
2: Indexbyte1, Indexbyte2
→ Wert
eine Konstante drücken #Index aus einem konstanten Pool (double, long oder eine dynamisch berechnete Konstante) auf den Stack (wide Index ist konstruiert als Indexbyte1 << 8 | Indexbyte2)
ldiv
6d
0110 1101
Wert1, Wert2 → Ergebnis
zwei Longs teilen
lladen
16
0001 0110
1: Index
→ Wert
einen langen Wert aus einer lokalen Variablen laden #Index
lload_0
1e
0001 1110
→ Wert
einen langen Wert aus einer lokalen Variablen laden 0
lload_1
1f
0001 1111
→ Wert
einen langen Wert aus einer lokalen Variablen laden 1
lload_2
20
0010 0000
→ Wert
einen langen Wert aus einer lokalen Variablen laden 2
lload_3
21
0010 0001
→ Wert
einen langen Wert aus einer lokalen Variablen laden 3
eine Zieladresse wird mithilfe eines Schlüssels aus einer Tabelle nachgeschlagen und die Ausführung wird ab dem Befehl an dieser Adresse fortgesetzt
lor
81
1000 0001
Wert1, Wert2 → Ergebnis
bitweise ODER von zwei Longs
lrem
71
0111 0001
Wert1, Wert2 → Ergebnis
Rest der Teilung von zwei Longs
lrückkehr
Anzeige
1010 1101
Wert → [empty]
einen langen Wert zurückgeben
lshl
79
0111 1001
Wert1, Wert2 → Ergebnis
bitweise Verschiebung nach links von einem langen Wert1 von int Wert2 Positionen
lshr
7b
0111 1011
Wert1, Wert2 → Ergebnis
bitweise Verschiebung nach rechts von einem langen Wert1 von int Wert2 Positionen
lstore
37
0011 0111
1: Index
Wert →
lange aufbewahren Wert in einer lokalen Variablen #Index
lstore_0
3f
0011 1111
Wert →
lange aufbewahren Wert in einer lokalen Variablen 0
lstore_1
40
0100 0000
Wert →
lange aufbewahren Wert in einer lokalen Variablen 1
lstore_2
41
0100 0001
Wert →
lange aufbewahren Wert in einer lokalen Variablen 2
lstore_3
42
0100 0010
Wert →
lange aufbewahren Wert in einer lokalen Variablen 3
lsub
65
0110 0101
Wert1, Wert2 → Ergebnis
zwei Longs abziehen
lushr
7d
0111 1101
Wert1, Wert2 → Ergebnis
bitweise Verschiebung nach rechts von einem langen Wert1 von int Wert2 Positionen, unsigniert
lxor
83
1000 0011
Wert1, Wert2 → Ergebnis
bitweises XOR von zwei Longs
monitorenter
c2
1100 0010
Objektref →
Enter-Monitor für Objekt (“grab the lock” – Start des Abschnitts synchronisiert())
Monitorausgang
c3
1100 0011
Objektref →
Exit-Monitor für Objekt (“lock the lock” – Ende des Abschnitts synchronisiert())
multianewarray
c5
1100 0101
3: Indexbyte1, Indexbyte2, Dimensionen
zählen1, [count2,…] → Arrayref
erstelle ein neues Array von Maße Abmessungen des Typs identifiziert durch Klassenreferenz im konstanten Pool Index (Indexbyte1 << 8 | Indexbyte2); die Größen jeder Dimension sind gekennzeichnet durch count1, [count2, etc.]
Neu
bb
1011 1011
2: Indexbyte1, Indexbyte2
→ Objektref
Erstellen Sie ein neues Objekt des Typs, der durch eine Klassenreferenz im Konstantenpool identifiziert wird Index (Indexbyte1 << 8 | Indexbyte2)
neues Array
bc
1011 1100
1: atyp
count → arrayref
Neues Array erstellen mit zählen Elemente des primitiven Typs identifiziert durch eine Art
nein
00
0000 0000
[No change]
keine Operation durchführen
Pop
57
0101 0111
Wert →
lege den obersten Wert auf den Stapel
pop2
58
0101 1000
{Wert2, Wert1} →
verwerfen Sie die beiden obersten Werte auf dem Stapel (oder einen Wert, wenn es ein Double oder Long ist)
putfield
b5
1011 0101
2: Indexbyte1, Indexbyte2
Objektref, Wert →
Feld auf setzen Wert in einem Objekt Objektref, wobei das Feld durch eine Feldreferenz identifiziert wird Index im ständigen Pool (Indexbyte1 << 8 | Indexbyte2)
putstatisch
b3
1011 0011
2: Indexbyte1, Indexbyte2
Wert →
setze statisches Feld auf Wert in einer Klasse, wobei das Feld durch eine Feldreferenz identifiziert wird Index im ständigen Pool (Indexbyte1 << 8 | Indexbyte2)
retIch
a9
1010 1001
1: Index
[No change]
Fortsetzen der Ausführung von einer Adresse aus einer lokalen Variablen #Index (die Asymmetrie mit jsr ist beabsichtigt)
Rückkehr
b1
1011 0001
→ [empty]
Rückgabe von void von Methode
saload
35
0011 0101
Arrayref, Index → Wert
lade kurz aus dem Array
sastore
56
0101 0110
Arrayref, Index, Wert →
Speichern Sie kurz zu Array
sipush
11
0001 0001
2: Byte1, Byte2
→ Wert
lege einen Short als Integer auf den Stack Wert
Tauschen
5f
0101 1111
Wert2, Wert1 → Wert1, Wert2
vertauscht zwei oberste Wörter auf dem Stack (beachten Sie, dass value1 und value2 nicht doppelt oder lang sein dürfen)
Fortsetzen der Ausführung von einer Adresse in der Tabelle bei Offset Index
weit
c4
1100 0100
3/5: Opcode, Indexbyte1, Indexbyte2 oder iinc, indexbyte1, indexbyte2, countbyte1, countbyte2
[same as for corresponding instructions]
ausführen Opcode, wo Opcode ist entweder iload, fload, aload, lload, dload, istore, fstore, astore, lstore, dstore oder ret, aber nehmen Sie an, dass Index ist 16 Bit; oder führe iinc aus, wobei die Index ist 16 Bit und die Konstante, um die erhöht werden soll, ist eine 16-Bit-Kurzzeit mit Vorzeichen
(kein Name)
cb-fd
Diese Werte sind derzeit nicht für Opcodes zugewiesen und für die zukünftige Verwendung reserviert
Recent Comments