Liste der Java-Bytecode-Anweisungen

Gedächtnisstütze Opcode
(im Sechseck) Opcode (in binär) Andere Bytes
[count]: [operand labels] Stapel
[before]→[after] Beschreibung aaload 32 0011 0010 Arrayref, Index → ​​Wert eine Referenz aus einem Array auf den Stack laden aastore 53 0101 0011 Arrayref, Index, Wert → speichere eine Referenz in einem Array aconst_null 01 0000 0001 → null drücke ein Null Referenz auf den Stack eine Ladung 19 0001 1001 1: Index → Objektref 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) dup2_x1 5d 0101 1101 value3, {value2, value1} → {value2, value1}, value3, {value2, value1} zwei Wörter duplizieren und unter dem dritten Wort einfügen (siehe Erklärung oben) dup2_x2 5e 0101 1110 {Wert4, Wert3}, {Wert2, Wert1} → {Wert2, Wert1}, {Wert4, Wert3}, {Wert2, Wert1} 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) goto_w c8 1100 1000 4: Branchbyte1, Branchbyte2, Branchbyte3, Branchbyte4 [no change] 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 jsr^Ich 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 jsr_w^Ich c9 1100 1001 4: Branchbyte1, Branchbyte2, Branchbyte3, Branchbyte4 → Adresse 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 lmul 69 0110 1001 Wert1, Wert2 → Ergebnis multipliziere zwei Longs lneg 75 0111 0101 Wert → Ergebnis eine lange negieren Nachschlageschalter ab 1010 1011 8+: <0–3 bytes padding>, defaultbyte1, defaultbyte2, defaultbyte3, defaultbyte4, npairs1, npairs2, npairs3, npairs4, Match-Offset-Paare… Taste → 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) ret^Ich 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) Tischschalter aa 1010 1010 16+: [0–3 bytes padding], defaultbyte1, defaultbyte2, defaultbyte3, defaultbyte4, lowbyte1, lowbyte2, lowbyte3, lowbyte4, highbyte1, highbyte2, highbyte3, highbyte4, Sprungoffsets… Index → 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