Dies ist eine Liste der Anweisungen, aus denen der JVM-Bytecode besteht, die abstrakte Maschinensprache, die von der Java Virtual Machine ausgeführt wird . [ 1 ] JVM-Bytecode wird von Compilern erzeugt, die für Sprachen entwickelt wurden, die auf der Java-Plattform laufen , insbesondere für Java .

Der Bytecode der JVM bildet den Befehlsinhalt von Methoden. Bei der Ausführung erhält jede Methode einen eigenen Frame mit einem Stack, lokalen Variablenregistern und weiteren Daten. Die meisten Befehle operieren mit einem oder mehreren Stack-Werten und legen ihre Ausgabe auf dem Stack ab.

Beachten Sie, dass sich jeder erwähnte „Wert“ auf einen 32-Bit-Integer gemäß dem Java-Befehlssatz bezieht.

Mnemotechnik Opcode (in Hexadezimaldarstellung ) Opcode (binär) Andere Bytes [Anzahl]: [Operandenbezeichnungen] Stapel [vorher]→[nachher] Beschreibung
aaload 32 0011 0010 arrayref, index → ​​value Eine Referenz aus einem Array auf den Stack laden.
aastore 53 0101 0011 arrayref, index, value → eine Referenz in einem Array speichern
const_null 01 0000 0001 → null Eine Nullreferenz auf den Stack legen.
aload 19 0001 1001 1: Index → Objektreferenz Eine Referenz von einer lokalen Variable #index auf den Stack laden.
aload_0 2a 0010 1010 → Objektreferenz Lade eine Referenz von der lokalen Variable 0 auf den Stack.
aload_1 2b 0010 1011 → Objektreferenz Lade eine Referenz von der lokalen Variable 1 auf den Stack.
aload_2 2c 0010 1100 → Objektreferenz Lade eine Referenz von der lokalen Variable 2 auf den Stack.
aload_3 2d 0010 1101 → Objektreferenz Lade eine Referenz von der lokalen Variable 3 auf den Stack.
anewarray bd 1011 1101 2: Indexbyte1, Indexbyte2 Anzahl → Array-Referenz Erstelle ein neues Array von Referenzen der Länge Anzahl und des Komponententyps, der durch den Klassenreferenzindex ( indexbyte1 << 8 | indexbyte2 ) im Konstantenpool identifiziert wird.
Rückkehr b 1011 0000 Objektreferenz → [leer] Eine Referenz von einer Methode zurückgeben
Arraylänge Sei 1011 1110 arrayref → Länge Die Länge eines Arrays ermitteln
astore 3a 0011 1010 1: Index Objektreferenz → Speichere eine Referenz in der lokalen Variable #index
astore_0 4b 0100 1011 Objektreferenz → Speichere eine Referenz in der lokalen Variable 0
astore_1 4c 0100 1100 Objektreferenz → Speichere eine Referenz in der lokalen Variable 1
astore_2 4d 0100 1101 Objektreferenz → Speichere eine Referenz in der lokalen Variable 2
astore_3 4e 0100 1110 Objektreferenz → Speichere eine Referenz in der lokalen Variable 3
werfen bf 1011 1111 objectref → [leer], objectref löst einen Fehler oder eine Ausnahme aus (beachten Sie, dass der Rest des Stacks gelöscht wird, sodass nur noch eine Referenz auf das Throwable verbleibt).
baload 33 0011 0011 arrayref, index → ​​value Einen Byte- oder Booleschen Wert aus einem Array laden
Bastore 54 0101 0100 arrayref, index, value → einen Byte- oder Boolean-Wert in einem Array speichern
bipush 10 0001 0000 1: Byte → Wert Lege ein Byte als ganzzahligen Wert auf den Stack.
Haltepunkt ca 1100 1010 Für Haltepunkte in Java-Debuggern reserviert; sollte in keiner Klassendatei vorkommen.
caload 34 0011 0100 arrayref, index → ​​value Ein Zeichen aus einem Array laden
Castore 55 0101 0101 arrayref, index, value → Speichere ein Zeichen in einem Array
Checkcast c0 1100 0000 2: Indexbyte1, Indexbyte2 Objektreferenz → Objektreferenz prüft, ob eine Objektreferenz von einem bestimmten Typ ist, dessen Klassenreferenz sich im Konstantenpool an Index ( indexbyte1 << 8 | indexbyte2 ) befindet.
d2f 90 1001 0000 Wert → Ergebnis Konvertiere einen Double-Wert in einen Float-Wert.
d2i 8e 1000 1110 Wert → Ergebnis Konvertiere einen Double-Wert in einen Integer-Wert.
d2l 8f 1000 1111 Wert → Ergebnis Konvertiere eine Double-Zahl in eine Long-Zahl.
Papa 63 0110 0011 Wert1, Wert2 → Ergebnis Zwei Doppel hinzufügen
daload 31 0011 0001 arrayref, index → ​​value Einen Double-Wert aus einem Array laden
dastore 52 0101 0010 arrayref, index, value → Speichere einen Double-Wert in einem Array
dcmpg 98 1001 1000 Wert1, Wert2 → Ergebnis Vergleiche zwei Doubles, 1 bei NaN
dcmpl 97 1001 0111 Wert1, Wert2 → Ergebnis Vergleiche zwei Doubles, -1 bei NaN
dconst_0 0e 0000 1110 → 0,0 Lege die Konstante 0.0 (ein Double ) auf den Stack.
dconst_1 0f 0000 1111 → 1,0 Lege die Konstante 1.0 (ein Double ) auf den Stack.
ddiv 6f 0110 1111 Wert1, Wert2 → Ergebnis zwei Doppel teilen
dload 18 0001 1000 1: Index → Wert Einen Double- Wert aus der lokalen Variable #index laden
dload_0 26 0010 0110 → Wert Lade einen Double-Wert aus der lokalen Variable 0
dload_1 27 0010 0111 → Wert Lade einen Double-Wert aus der lokalen Variable 1
dload_2 28 0010 1000 → Wert Lade einen Double-Wert aus der lokalen Variable 2
dload_3 29 0010 1001 → Wert Lade einen Double-Wert aus der lokalen Variable 3
dmul 6b 0110 1011 Wert1, Wert2 → Ergebnis Multipliziere zwei Verdoppelungen
dneg 77 0111 0111 Wert → Ergebnis negieren Sie ein Doppel
Traum 73 0111 0011 Wert1, Wert2 → Ergebnis Den Rest aus der Division zweier Doppel ermitteln
Rückkehr af 1010 1111 Wert → [leer] gibt einen Double-Wert von einer Methode zurück
dstore 39 0011 1001 1: Index Wert → Speichere einen Double- Wert in der lokalen Variable #index
dstore_0 47 0100 0111 Wert → Speichere einen Double-Wert in der lokalen Variable 0
dstore_1 48 0100 1000 Wert → Speichere einen Double-Wert in der lokalen Variable 1
dstore_2 49 0100 1001 Wert → Speichere einen Double-Wert in der lokalen Variable 2.
dstore_3 4a 0100 1010 Wert → Speichere einen Double-Wert in der lokalen Variable 3
dsub 67 0110 0111 Wert1, Wert2 → Ergebnis Subtrahiere ein Double von einem anderen
Duplikat 59 0101 1001 Wert → Wert, Wert Dupliziere den Wert oben im Stapel.
dup_x1 5a 0101 1010 Wert2, Wert1 → Wert1, Wert2, Wert1 Füge eine Kopie des obersten Werts zwei Werte von oben in den Stapel ein. Wert1 und Wert2 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 Werts zwei (wenn Wert2 vom Typ Double oder Long ist, belegt er auch den Eintrag von Wert3) oder drei Werte (wenn Wert2 weder Double noch Long ist) vom obersten Element des Stacks ein.
dup2 5 Cent 0101 1100 {value2, value1} → {value2, value1}, {value2, value1} Dupliziere die obersten zwei Wörter des Stapels (zwei Werte, falls Wert1 weder Double noch Long ist; ein einzelner Wert, falls Wert1 Double oder Long ist).
dup2_x1 5d 0101 1101 Wert3, {Wert2, Wert1} → {Wert2, Wert1}, Wert3, {Wert2, Wert1} Dupliziere zwei Wörter und füge sie unter dem dritten Wort ein (siehe Erklärung oben).
dup2_x2 5e 0101 1110 {value4, value3}, {value2, value1} → {value2, value1}, {value4, value3}, {value2, value1} Duplizieren Sie zwei Wörter und fügen Sie sie unter dem vierten Wort ein.
f2d 8d 1000 1101 Wert → Ergebnis Konvertiere einen Float-Wert in einen Double-Wert.
f2i 8b 1000 1011 Wert → Ergebnis Konvertiere einen Float-Wert in einen Integer-Wert.
f2l 8c 1000 1100 Wert → Ergebnis Konvertiere einen Float-Wert in einen Long-Wert
Mode 62 0110 0010 Wert1, Wert2 → Ergebnis Zwei Gleitkommazahlen addieren
faload 30 0011 0000 arrayref, index → ​​value Einen Float-Wert aus einem Array laden
Fastore 51 0101 0001 arrayref, index, value → einen Float-Wert in einem Array speichern
fcmpg 96 1001 0110 Wert1, Wert2 → Ergebnis Vergleiche zwei Gleitkommazahlen, 1 auf NaN
fcmpl 95 1001 0101 Wert1, Wert2 → Ergebnis Vergleiche zwei Gleitkommazahlen, -1 bei NaN
fconst_0 0b 0000 1011 → 0,0f Füge 0.0f dem Stack hinzu
fconst_1 0c 0000 1100 → 1,0f Füge 1.0f dem Stack hinzu
fconst_2 0d 0000 1101 → 2,0f Füge 2.0f auf dem Stack hinzu.
fdiv 6e 0110 1110 Wert1, Wert2 → Ergebnis zwei Gleitkommazahlen teilen
fload 17 0001 0111 1: Index → Wert Einen Gleitkommawert aus der lokalen Variable #index laden
fload_0 22 0010 0010 → Wert Lade einen Gleitkommawert aus der lokalen Variable 0
fload_1 23 0010 0011 → Wert Lade einen Gleitkommawert aus der lokalen Variable 1
fload_2 24 0010 0100 → Wert Lade einen Gleitkommawert aus der lokalen Variable 2
fload_3 25 0010 0101 → Wert Lade einen Gleitkommawert aus der lokalen Variable 3
fmul 6a 0110 1010 Wert1, Wert2 → Ergebnis Multiplikation zweier Gleitkommazahlen
fneg 76 0111 0110 Wert → Ergebnis einen Gleitkommawert negieren
frem 72 0111 0010 Wert1, Wert2 → Ergebnis Den Rest einer Division zweier Gleitkommazahlen ermitteln
freturn ae 1010 1110 Wert → [leer] Gibt einen Gleitkommawert zurück
fstore 38 0011 1000 1: Index Wert → Speichere einen Gleitkommawert in der lokalen Variable #index
fstore_0 43 0100 0011 Wert → Speichere einen Gleitkommawert in der lokalen Variable 0
fstore_1 44 0100 0100 Wert → Speichere einen Gleitkommawert in der lokalen Variable 1
fstore_2 45 0100 0101 Wert → Speichere einen Gleitkommawert in der lokalen Variable 2.
fstore_3 46 0100 0110 Wert → Speichere einen Gleitkommawert in der lokalen Variable 3
fsub 66 0110 0110 Wert1, Wert2 → Ergebnis Zwei Gleitkommazahlen subtrahieren
Getfield b4 1011 0100 2: Indexbyte1, Indexbyte2 Objektreferenz → Wert Rufe einen Feldwert eines Objekts objectref ab , wobei das Feld durch die Feldreferenz im Konstantenpool index identifiziert wird ( indexbyte1 << 8 | indexbyte2 )
getstatic b2 1011 0010 2: Indexbyte1, Indexbyte2 → Wert Rufe den Wert eines statischen Feldes einer Klasse ab, wobei das Feld durch eine Feldreferenz im Konstantenpool index identifiziert wird ( indexbyte1 << 8 | indexbyte2 )
gehe zu a7 1010 0111 2: branchbyte1, branchbyte2 [keine Änderung] geht zu einer anderen Anweisung an der Verzweigungsposition (signed short, konstruiert aus unsigned bytes branchbyte1 << 8 | branchbyte2 )
goto_w c8 1100 1000 4: branchbyte1, branchbyte2, branchbyte3, branchbyte4 [keine Änderung] geht zu einer anderen Anweisung an der Verzweigungsposition (signed int, konstruiert aus unsigned bytes branchbyte1 << 24 | branchbyte2 << 16 | branchbyte3 << 8 | branchbyte4 )
i2b 91 1001 0001 Wert → Ergebnis einen Integer in ein Byte umwandeln
i2c 92 1001 0010 Wert → Ergebnis einen Integer in ein Zeichen umwandeln
i2d 87 1000 0111 Wert → Ergebnis Konvertiere einen Integer in einen Double.
i2f 86 1000 0110 Wert → Ergebnis Konvertiere einen Integer in einen Float.
i2l 85 1000 0101 Wert → Ergebnis einen int-Wert in einen long-Wert umwandeln
i2s 93 1001 0011 Wert → Ergebnis Konvertiere einen int in einen short
iadd 60 0110 0000 Wert1, Wert2 → Ergebnis zwei ganze Zahlen addieren
iaload 2e 0010 1110 arrayref, index → ​​value Einen Integer aus einem Array laden
iand 7e 0111 1110 Wert1, Wert2 → Ergebnis Führe eine bitweise UND-Verknüpfung zweier Ganzzahlen durch.
iastore 4f 0100 1111 arrayref, index, value → einen Integer in einem Array speichern
iconst_m1 02 0000 0010 → -1 Lade den Integer-Wert −1 auf den Stack.
iconst_0 03 0000 0011 → 0 Lade den Integer-Wert 0 auf den Stack.
iconst_1 04 0000 0100 → 1 Lade den Integer-Wert 1 auf den Stack.
iconst_2 05 0000 0101 → 2 Lade den Integer-Wert 2 auf den Stack.
iconst_3 06 0000 0110 → 3 Lade den Integer-Wert 3 auf den Stack.
iconst_4 07 0000 0111 → 4 Lade den Integer-Wert 4 auf den Stack.
iconst_5 08 0000 1000 → 5 Lade den Integer-Wert 5 auf den Stack.
idiv 6c 0110 1100 Wert1, Wert2 → Ergebnis zwei ganze Zahlen teilen
if_acmpeq a5 1010 0101 2: branchbyte1, branchbyte2 Wert1, Wert2 → Wenn die Referenzen gleich sind, verzweige zur Anweisung an der Verzweigungsposition (signed short, konstruiert aus unsigned bytes branchbyte1 << 8 | branchbyte2 )
if_acmpne a6 1010 0110 2: branchbyte1, branchbyte2 Wert1, Wert2 → Wenn die Referenzen nicht gleich sind, verzweige zur Anweisung an der Verzweigungsposition (signed short, konstruiert aus unsigned bytes branchbyte1 << 8 | branchbyte2 )
if_icmpeq 9f 1001 1111 2: branchbyte1, branchbyte2 Wert1, Wert2 → Wenn die Integerwerte gleich sind, verzweige zur Anweisung an der Verzweigungsposition (signed short, konstruiert aus unsigned bytes branchbyte1 << 8 | branchbyte2 )
if_icmpge a2 1010 0010 2: branchbyte1, branchbyte2 Wert1, Wert2 → Wenn Wert1 größer oder gleich Wert2 ist , verzweige zur Anweisung an der Verzweigungsposition (signed short, konstruiert aus unsigned bytes branchbyte1 << 8 | branchbyte2 )
if_icmpgt a3 1010 0011 2: branchbyte1, branchbyte2 Wert1, Wert2 → Wenn Wert1 größer als Wert2 ist , verzweige zur Anweisung an der Verzweigungsposition (signed short, konstruiert aus unsigned bytes branchbyte1 << 8 | branchbyte2 )
if_icmple A4 1010 0100 2: branchbyte1, branchbyte2 Wert1, Wert2 → Wenn Wert1 kleiner oder gleich Wert2 ist , verzweige zur Anweisung an der Verzweigungsposition (signed short, konstruiert aus unsigned bytes branchbyte1 << 8 | branchbyte2 )
if_icmplt a1 1010 0001 2: branchbyte1, branchbyte2 Wert1, Wert2 → Wenn Wert1 kleiner als Wert2 ist , verzweige zur Anweisung an der Verzweigungsposition (signed short, konstruiert aus unsigned bytes branchbyte1 << 8 | branchbyte2 )
if_icmpne a0 1010 0000 2: branchbyte1, branchbyte2 Wert1, Wert2 → Wenn die Integerwerte ungleich sind, verzweige zur Anweisung an der Verzweigungsposition (signed short, konstruiert aus unsigned bytes branchbyte1 << 8 | branchbyte2 )
ifeq 99 1001 1001 2: branchbyte1, branchbyte2 Wert → Wenn der Wert 0 ist, springe zur Anweisung an der Position branchoffset (signed short, konstruiert aus unsigned bytes branchbyte1 << 8 | branchbyte2 )
ifge 9c 1001 1100 2: branchbyte1, branchbyte2 Wert → Wenn der Wert größer oder gleich 0 ist, verzweige zur Anweisung an der Position branchoffset (signed short, konstruiert aus unsigned bytes branchbyte1 << 8 | branchbyte2 )
ifgt 9d 1001 1101 2: branchbyte1, branchbyte2 Wert → Wenn der Wert größer als 0 ist, verzweige zur Anweisung an der Position branchoffset (signed short, konstruiert aus unsigned bytes branchbyte1 << 8 | branchbyte2 )
ifle 9e 1001 1110 2: branchbyte1, branchbyte2 Wert → Wenn der Wert kleiner oder gleich 0 ist, verzweige zur Anweisung an der Verzweigungsposition (signed short, konstruiert aus unsigned bytes branchbyte1 << 8 | branchbyte2 )
iflt 9b 1001 1011 2: branchbyte1, branchbyte2 Wert → Wenn der Wert kleiner als 0 ist, verzweige zur Anweisung an der Verzweigungsposition (signed short, konstruiert aus unsigned bytes branchbyte1 << 8 | branchbyte2 )
ifne 9a 1001 1010 2: branchbyte1, branchbyte2 Wert → Wenn der Wert nicht 0 ist, verzweige zur Anweisung an der Position branchoffset (signed short, konstruiert aus unsigned bytes branchbyte1 << 8 | branchbyte2 )
ifnonnull c7 1100 0111 2: branchbyte1, branchbyte2 Wert → Wenn der Wert nicht null ist, verzweige zur Anweisung an der Verzweigungsposition (signed short, konstruiert aus unsigned bytes branchbyte1 << 8 | branchbyte2 )
ifnull c6 1100 0110 2: branchbyte1, branchbyte2 Wert → Wenn der Wert null ist, verzweige zur Anweisung an der Verzweigungsposition (signed short, konstruiert aus unsigned bytes branchbyte1 << 8 | branchbyte2 )
iinc 84 1000 0100 2: Index, Konstante [Keine Änderung] lokale Variable #index um signiertes Byte erhöhen
iload 15 0001 0101 1: Index → Wert Einen Integer- Wert aus einer lokalen Variable #index laden
iload_0 1a 0001 1010 → Wert Lade einen Integer- Wert aus der lokalen Variable 0
iload_1 1b 0001 1011 → Wert Lade einen Integer- Wert aus der lokalen Variable 1
iload_2 1c 0001 1100 → Wert Lade einen Integer- Wert aus der lokalen Variable 2
iload_3 1d 0001 1101 → Wert Lade einen Integer- Wert aus der lokalen Variable 3
impdep1 fe 1111 1110 Reserviert für implementierungsabhängige Operationen innerhalb von Debuggern; sollte in keiner Klassendatei vorkommen.
impdep2 ff 1111 1111 Reserviert für implementierungsabhängige Operationen innerhalb von Debuggern; sollte in keiner Klassendatei vorkommen.
imul 68 0110 1000 Wert1, Wert2 → Ergebnis Multiplikation zweier ganzer Zahlen
ineg 74 0111 0100 Wert → Ergebnis negate int
instanceof c1 1100 0001 2: Indexbyte1, Indexbyte2 Objektreferenz → Ergebnis ermittelt, ob ein Objekt objectref von einem bestimmten Typ ist, der durch den Klassenreferenzindex im Konstantenpool identifiziert wird ( 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 (kann void sein); die Methode wird durch ihren Methodenreferenzindex im Konstantenpool identifiziert ( indexbyte1 << 8 | indexbyte2 )
invokeinterface b9 1011 1001 4: indexbyte1, indexbyte2, count, 0 objectref, [arg1, arg2, ...] → result Ruft eine Schnittstellenmethode des Objekts objectref auf und legt das Ergebnis auf den Stack (kann void sein); die Schnittstellenmethode wird durch den Methodenreferenzindex im Konstantenpool identifiziert ( indexbyte1 << 8 | indexbyte2 )
invokespecial b7 1011 0111 2: Indexbyte1, Indexbyte2 objectref, [arg1, arg2, ...] → result Die Instanzmethode des Objekts objectref wird aufgerufen und das Ergebnis auf den Stack gelegt (kann void sein); die Methode wird durch ihren Methodenreferenzindex im Konstantenpool identifiziert ( indexbyte1 << 8 | indexbyte2 ).
invokestatic b8 1011 1000 2: Indexbyte1, Indexbyte2 [arg1, arg2, ...] → Ergebnis Eine statische Methode aufrufen und das Ergebnis auf den Stack legen (kann void sein); die Methode wird durch ihren Methodenreferenzindex im Konstantenpool identifiziert ( indexbyte1 << 8 | indexbyte2 )
invokevirtual b6 1011 0110 2: Indexbyte1, Indexbyte2 objectref, [arg1, arg2, ...] → result Ruft eine virtuelle Methode des Objekts objectref auf und legt das Ergebnis auf den Stack (kann void sein); die Methode wird durch ihren Methodenreferenzindex im Konstantenpool identifiziert ( indexbyte1 << 8 | indexbyte2 )
Eisen 80 1.000.000 Wert1, Wert2 → Ergebnis bitweises int ODER
irem 70 0111 0000 Wert1, Wert2 → Ergebnis logischer int-Rest
iReturn Klimaanlage 1010 1100 Wert → [leer] gibt eine Ganzzahl von einer Methode zurück
ishl 78 0111 1000 Wert1, Wert2 → Ergebnis int verschiebt nach links
ishr 7a 0111 1010 Wert1, Wert2 → Ergebnis int arithmetische Verschiebung nach rechts
iStore 36 0011 0110 1: Index Wert → Speichere den Integer- Wert in der Variablen #index
iStore_0 3b 0011 1011 Wert → Speichere den Integer- Wert in der Variablen 0
iStore_1 3c 0011 1100 Wert → Speichere den Integer- Wert in Variable 1
iStore_2 3D 0011 1101 Wert → Speichere den Integer- Wert in Variable 2
iStore_3 3e 0011 1110 Wert → Speichere den Integer- Wert in der Variablen 3
isub 64 0110 0100 Wert1, Wert2 → Ergebnis int subtract
iushr 7c 0111 1100 Wert1, Wert2 → Ergebnis int logische Verschiebung nach rechts
ixor 82 1000 0010 Wert1, Wert2 → Ergebnis int xor
jsr †a8 1010 1000 2: branchbyte1, branchbyte2 → Adresse Springe zur Unterroutine an der Verzweigungsposition (signierter Short-Wert, erstellt aus unsigned Bytes branchbyte1 << 8 | branchbyte2 ) und lege die Rücksprungadresse auf den Stack.
jsr_w †c9 1100 1001 4: branchbyte1, branchbyte2, branchbyte3, branchbyte4 → Adresse Springe zur Unterroutine an der Verzweigungsposition (signed int, zusammengesetzt aus unsigned bytes branchbyte1 << 24 | branchbyte2 << 16 | branchbyte3 << 8 | branchbyte4 ) und lege die Rücksprungadresse auf den Stack.
l2d 8a 1000 1010 Wert → Ergebnis Konvertiere einen Long-Wert in einen Double-Wert.
l2f 89 1000 1001 Wert → Ergebnis Konvertiere einen Long-Wert in einen Float-Wert.
l2i 88 1000 1000 Wert → Ergebnis Konvertiere einen Long-Wert in einen Integer-Wert.
ladd 61 0110 0001 Wert1, Wert2 → Ergebnis zwei lange hinzufügen
laload 2f 0010 1111 arrayref, index → ​​value einen Long-Wert aus einem Array laden
Land 7f 0111 1111 Wert1, Wert2 → Ergebnis Bitweises UND zweier Long-Werte
Lastore 50 0101 0000 arrayref, index, value → einen Long-Wert in einem Array speichern
lcmp 94 1001 0100 Wert1, Wert2 → Ergebnis Gib 0 ein, wenn die beiden Long-Werte gleich sind, 1, wenn Wert1 größer als Wert2 ist, und -1 andernfalls.
lconst_0 09 0000 1001 → 0L Füge 0L (die Zahl Null vom Typ long ) auf den Stack hinzu.
lconst_1 0a 0000 1010 → 1L Füge 1L (die Nummer eins vom Typ long ) auf den Stapel hinzu.
ldc 12 0001 0010 1: Index → Wert Eine Konstante vom Typ #index aus einem Konstantenpool (String, int, float, Class, java.lang.invoke.MethodType, java.lang.invoke.MethodHandle oder eine dynamisch berechnete Konstante) auf den Stack legen.
ldc_w 13 0001 0011 2: Indexbyte1, Indexbyte2 → Wert Eine Konstante vom Typ #index aus einem Konstantenpool (String, int, float, Class, java.lang.invoke.MethodType, java.lang.invoke.MethodHandle oder eine dynamisch berechnete Konstante) wird auf den Stack gelegt (der breite Index wird als indexbyte1 << 8 | indexbyte2 konstruiert ).
ldc2_w 14 0001 0100 2: Indexbyte1, Indexbyte2 → Wert Eine Konstante mit der Nummer #index aus einem Konstantenpool (double, long oder eine dynamisch berechnete Konstante) wird auf den Stack gelegt (der breite Index wird als indexbyte1 << 8 | indexbyte2 konstruiert ).
ldiv 6d 0110 1101 Wert1, Wert2 → Ergebnis zwei lange Teile
lload 16 0001 0110 1: Index → Wert Einen Long-Wert aus der lokalen Variable #index laden
lload_0 1e 0001 1110 → Wert Einen Long-Wert aus einer lokalen Variable laden 0
lload_1 1f 0001 1111 → Wert Einen Long-Wert aus einer lokalen Variable laden 1
lload_2 20 0010 0000 → Wert Einen Long-Wert aus einer lokalen Variable laden 2
lload_3 21 0010 0001 → Wert Einen Long-Wert aus einer lokalen Variable laden 3
lmul 69 0110 1001 Wert1, Wert2 → Ergebnis Multipliziere zwei lange Zahlen
lneg 75 0111 0101 Wert → Ergebnis eine lange
Lookup-Schalter ab 1010 1011 8+: <0–3 Bytes Padding>, Standardbyte1, Standardbyte2, Standardbyte3, Standardbyte4, npairs1, npairs2, npairs3, npairs4, Match-Offset-Paare... Schlüssel → Anhand eines Schlüssels wird die Zieladresse in einer Tabelle nachgeschlagen, und die Ausführung wird ab der Anweisung an dieser Adresse fortgesetzt.
lor 81 1000 0001 Wert1, Wert2 → Ergebnis Bitweises ODER zweier Long-Werte
lrem 71 0111 0001 Wert1, Wert2 → Ergebnis Rest der Division zweier langer Zahlen
lreturn Anzeige 1010 1101 Wert → [leer] Gibt einen Long-Wert zurück
lshl 79 0111 1001 Wert1, Wert2 → Ergebnis Bitweise Linksverschiebung eines Long- Wertes1 um einen Integer- Wert2 Positionen
lshr 7b 0111 1011 Wert1, Wert2 → Ergebnis Bitweise Rechtsverschiebung eines long- Wertes1 um einen int- Wert2 Positionen
lstore 37 0011 0111 1: Index Wert → Speichere einen Long- Wert in der lokalen Variable #index
lstore_0 3f 0011 1111 Wert → Speichere einen Long- Wert in einer lokalen Variable 0
lstore_1 40 0100 0000 Wert → Speichere einen Long- Wert in einer lokalen Variable 1
lstore_2 41 0100 0001 Wert → Speichere einen Long- Wert in einer lokalen Variable 2
lstore_3 42 0100 0010 Wert → Speichere einen Long- Wert in einer lokalen Variable 3
lsub 65 0110 0101 Wert1, Wert2 → Ergebnis Zwei lange Teile abziehen
üppig 7d 0111 1101 Wert1, Wert2 → Ergebnis Bitweise Rechtsverschiebung eines long- Wertes1 um den int- Wert2 Positionen, vorzeichenlos
LXOR 83 1000 0011 Wert1, Wert2 → Ergebnis Bitweises XOR von zwei Long-Werten
Monitorenter c2 1100 0010 Objektreferenz → Monitor für Objekt aufrufen ("Sperre erzwingen" – Beginn des Abschnitts synchronized())
Monitorexit c3 1100 0011 Objektreferenz → Monitor für Objekt verlassen ("Sperre freigeben" – Ende des synchronisierten()-Abschnitts)
Multianewarray c5 1100 0101 3: Indexbyte1, Indexbyte2, Dimensionen count1, [count2,...] → arrayref Erstelle ein neues Array von Dimensionen vom Typ, der durch eine Klassenreferenz im Konstantenpool index identifiziert wird ( indexbyte1 << 8 | indexbyte2 ); die Größen der einzelnen Dimensionen werden durch count1 , [ count2 , etc.] identifiziert.
neu bb 1011 1011 2: Indexbyte1, Indexbyte2 → Objektreferenz Erstelle ein neues Objekt des durch die Klassenreferenz im Konstantenpool index ( indexbyte1 << 8 | indexbyte2 ) identifizierten Typs.
neues Array bc 1011 1100 1: Typ Anzahl → Array-Referenz Erstelle ein neues Array mit der Anzahl Elemente des primitiven Typs, der durch atype identifiziert wird.
nein 00 0000 0000 [Keine Änderung] Es wird keine Operation durchgeführt
Pop 57 0101 0111 Wert → Verwerfe den obersten Wert des Stapels.
Pop2 58 0101 1000 {Wert2, Wert1} → Verwerfe die beiden obersten Werte auf dem Stapel (oder einen Wert, falls es sich um einen Double- oder Long-Wert handelt).
Putfield b5 1011 0101 2: Indexbyte1, Indexbyte2 Objektreferenz, Wert → setze Feld auf Wert in einem Objekt objectref , wobei das Feld durch einen Feldreferenzindex im Konstantenpool identifiziert wird ( indexbyte1 << 8 | indexbyte2 )
putstatic b3 1011 0011 2: Indexbyte1, Indexbyte2 Wert → Ein statisches Feld in einer Klasse wird auf einen Wert gesetzt, wobei das Feld durch einen Feldreferenzindex im Konstantenpool identifiziert wird ( indexbyte1 << 8 | indexbyte2 )
ret †a9 1010 1001 1: Index [Keine Änderung] Die Ausführung wird ab der Adresse fortgesetzt, die aus der lokalen Variable #index entnommen wurde (die Asymmetrie mit jsr ist beabsichtigt).
zurückkehren b1 1011 0001 → [leer] Rückgabewert einer void-Methode
saload 35 0011 0101 arrayref, index → ​​value Laden Sie einen kurzen Text aus dem Array
sastore 56 0101 0110 arrayref, index, value → Speichere Short in Array
Sipush 11 0001 0001 2: Byte 1, Byte 2 → Wert Ich lege einen Short-Wert als Integer- Wert auf den Stack.
tauschen 5f 0101 1111 Wert2, Wert1 → Wert1, Wert2 Vertauscht die beiden obersten Wörter auf dem Stapel (beachte, dass Wert1 und Wert2 nicht vom Typ Double oder Long sein dürfen).
Tischschalter aa 1010 1010 16+: [0–3 Bytes Padding], Standardbyte1, Standardbyte2, Standardbyte3, Standardbyte4, niedrigstes Byte1, niedrigstes Byte2, niedrigstes Byte3, niedrigstes Byte4, höchstes Byte1, höchstes Byte2, höchstes Byte3, höchstes Byte4, Sprungoffsets... Index → Die Ausführung wird von einer Adresse in der Tabelle am Offset -Index fortgesetzt.
breit c4 1100 0100 3/5: Opcode, Indexbyte1, Indexbyte2 oder iinc, Indexbyte1, Indexbyte2, Countbyte1, Countbyte2 [gleich wie bei den entsprechenden Anweisungen] Führe den Befehl `opcode` aus , wobei ` opcode` entweder `iload`, `fload`, `aload`, `lload`, `dload`, `istore`, `fstore`, `astore`, `lstore`, `dstore` oder `ret` ist. Gehe davon aus, dass der Index 16 Bit groß ist. Alternativ kannst du `iinc` ausführen, wobei der Index 16 Bit groß ist und die zu inkrementierende Konstante ein vorzeichenbehafteter 16-Bit-Short ist.
(kein Name)cb-fd Diese Werte sind derzeit für Opcodes nicht zugewiesen und für die zukünftige Verwendung reserviert.

† In Java 7 (Hauptklassenversion 51) veraltet. [ 2 ] Sie erscheinen nicht in Klassendateien, die von einem neueren Compiler generiert wurden.

Siehe auch

  • Jazelle DBX (Direct Bytecode eXecution), eine Funktion, die bestimmte Java-Bytecodes in Hardware auf einigen ARM9-CPUs ausführt.
  • Common Intermediate Language (CIL), eine ähnliche Bytecode-Spezifikation, die auf der CLR des .NET Frameworks ausgeführt wird.

Referenzen