Výpisy instrukcí Java bytecode - Java bytecode instruction listings

Hlavní článek: Bajtový kód Java

Toto je seznam pokynů, které tvoří Bajtový kód Java, abstraktní strojový jazyk, který nakonec provede Virtuální stroj Java. Bajtový kód Java je generován z jazyků běžících na serveru Platforma Java, nejvíce pozoruhodně Programovací jazyk Java.

Všimněte si, že jakákoli odkazovaná „hodnota“ odkazuje na 32bitový int podle sady instrukcí Java.

Mnemotechnická pomůckaOperační kód
(v hex )		Opcode (v binární podobě)Ostatní bajty
[count]: [štítky operandů]		Zásobník
[před] → [po]		Popis
aaload320011 0010arrayref, index → ​​hodnotanačíst do zásobníku odkaz z pole
aastore530101 0011arrayref, index, hodnota →uložit odkaz do pole
aconst_null010000 0001→ nulltlačit a nula odkaz na zásobník
aload190001 10011: index→ reference objektunačíst odkaz do zásobníku z místní proměnné #index
aload_02a0010 1010→ reference objektunačíst odkaz do zásobníku z lokální proměnné 0
aload_12b0010 1011→ reference objektunačíst odkaz do zásobníku z lokální proměnné 1
aload_22c0010 1100→ reference objektunačíst odkaz do zásobníku z lokální proměnné 2
aload_32d0010 1101→ reference objektunačíst odkaz do zásobníku z lokální proměnné 3
znovubd1011 11012: indexbyte1, indexbyte2count → arrayrefvytvořit nové pole odkazů délky počet a typ komponenty identifikovaný odkazem na třídu index (indexbyte1 << 8 | indexbyte2) ve stálém bazénu
zpětb01011 0000objectref → [prázdný]vrátit odkaz z metody
délka polebýt1011 1110arrayref → délkazískejte délku pole
obchod3a0011 10101: indexobjectref →uložit odkaz do místní proměnné #index
astore_04b0100 1011objectref →uložit odkaz do lokální proměnné 0
astore_14c0100 1100objectref →uložit odkaz do lokální proměnné 1
astore_24d0100 1101objectref →uložit odkaz do lokální proměnné 2
astore_34e0100 1110objectref →uložit odkaz do lokální proměnné 3
házetbf1011 1111objectref → [prázdný], objectrefvyvolá chybu nebo výjimku (všimněte si, že zbytek zásobníku je vymazán, takže zbývá jen odkaz na Throwable)
Baload330011 0011arrayref, index → ​​hodnotanačíst bajt nebo booleovskou hodnotu z pole
bastore540101 0100arrayref, index, hodnota →uložit bajt nebo booleovskou hodnotu do pole
bipush100001 00001: bajt→ hodnotatlačit a byte do zásobníku jako celé číslo hodnota
bod zlomuca.1100 1010vyhrazeno pro zarážky v debuggerech Java; by se neměl objevit v žádném souboru třídy
náklad340011 0100arrayref, index → ​​hodnotanačíst znak z pole
Castore550101 0101arrayref, index, hodnota →uložit znak do pole
checkcastc01100 00002: indexbyte1, indexbyte2objectref → objectrefzkontroluje, zda objectref je určitého typu, jehož odkaz na třídu je v konstantním fondu na index (indexbyte1 << 8 | indexbyte2)
d2f901001 0000hodnota → výsledekpřevést a dvojnásobek do a plovák
d2i8e1000 1110hodnota → výsledekpřevést dvojitý na int
d2l8f1000 1111hodnota → výsledekpřevést dvojitý na dlouhý
táta630110 0011hodnota1, hodnota2 → výsledekpřidat dvě zdvojnásobí
daload310011 0001arrayref, index → ​​hodnotanačíst dvojníka z pole
dastore520101 0010arrayref, index, hodnota →uložit dvojník do pole
dcmpg981001 1000hodnota1, hodnota2 → výsledekporovnat dvě zdvojnásobí, 1 na NaN
dcmpl971001 0111hodnota1, hodnota2 → výsledekporovnat dvě zdvojnásobí, -1 na NaN
dconst_00e0000 1110→ 0.0tlačit na konstantu 0.0 (A dvojnásobek) do zásobníku
dconst_10f0000 1111→ 1.0tlačit na konstantu 1.0 (A dvojnásobek) do zásobníku
ddiv6f0110 1111hodnota1, hodnota2 → výsledekrozdělit dvě čtyřhry
dload180001 10001: index→ hodnotanačíst dvojitý hodnota z lokální proměnné #index
dload_0260010 0110→ hodnotanačíst dvojnásobek z místní proměnné 0
dload_1270010 0111→ hodnotanačíst dvojnásobek z lokální proměnné 1
dload_2280010 1000→ hodnotanačíst dvojnásobek z místní proměnné 2
dload_3290010 1001→ hodnotanačíst dvojnásobek z místní proměnné 3
dmul6b0110 1011hodnota1, hodnota2 → výsledekvynásobte dvě zdvojnásobení
dneg770111 0111hodnota → výsledeknegovat dvojníka
drem730111 0011hodnota1, hodnota2 → výsledekzískejte zbytek z rozdělení mezi dvě čtyřhry
dreturnaf1010 1111hodnota → [prázdný]vrátit dvojitý z metody
obchod390011 10011: indexhodnota →uložit dvojitý hodnota do lokální proměnné #index
dstore_0470100 0111hodnota →uložit double do lokální proměnné 0
dstore_1480100 1000hodnota →uložit double do lokální proměnné 1
dstore_2490100 1001hodnota →uložit double do místní proměnné 2
dstore_34a0100 1010hodnota →uložit double do lokální proměnné 3
dsub670110 0111hodnota1, hodnota2 → výsledekodečíst dvojnásobek od druhého
dup590101 1001hodnota → hodnota, hodnotaduplikujte hodnotu v horní části zásobníku
dup_x15a0101 1010hodnota2, hodnota1 → hodnota1, hodnota2, hodnota1vložte kopii nejvyšší hodnoty do stohu dvou hodnot shora. value1 a value2 nesmí být typu double nebo long.
dup_x25b0101 1011hodnota3, hodnota2, hodnota1 → hodnota1, hodnota3, hodnota2, hodnota1vložte kopii nejvyšší hodnoty do stohu dvě (pokud je hodnota2 dvojitá nebo dlouhá, zabírá také hodnotu value3) nebo tři hodnoty (pokud hodnota2 není ani zdvojnásobená, ani dlouhá) shora
dup25c0101 1100{hodnota2, hodnota1} → {hodnota2, hodnota1}, {hodnota2, hodnota1}duplikovat horní dvě slova v zásobníku (dvě hodnoty, pokud hodnota1 není dvojitá ani dlouhá; jedna hodnota, pokud je hodnota1 dvojitá nebo dlouhá)
dup2_x15 d0101 1101hodnota3, {hodnota2, hodnota1} → {hodnota2, hodnota1}, hodnota3, {hodnota2, hodnota1}duplikovat dvě slova a vložit pod třetí slovo (viz vysvětlení výše)
dup2_x25e0101 1110{hodnota4, hodnota3}, {hodnota2, hodnota1} → {hodnota2, hodnota1}, {hodnota4, hodnota3}, {hodnota2, hodnota1}duplikujte dvě slova a vložte pod čtvrté slovo
f2d8d1000 1101hodnota → výsledekpřevést plovák na dvojitý
f2i8b1000 1011hodnota → výsledekpřevést float na int
f2l8c1000 1100hodnota → výsledekpřevést plovák na dlouhý
fadd620110 0010hodnota1, hodnota2 → výsledekpřidat dva plováky
faload300011 0000arrayref, index → ​​hodnotanačíst float z pole
rychle510101 0001arrayref, index, hodnota →uložit plovák do pole
fcmpg961001 0110hodnota1, hodnota2 → výsledekporovnat dva plováky, 1 na NaN
fcmpl951001 0101hodnota1, hodnota2 → výsledekporovnat dva plováky, -1 na NaN
fconst_00b0000 1011→ 0,0ftlačit 0,0f na zásobníku
fconst_10c0000 1100→ 1.0ftlačit 1,0f na zásobníku
fconst_20 d0000 1101→ 2.0ftlačit 2,0f na zásobníku
fdiv6e0110 1110hodnota1, hodnota2 → výsledekrozdělit dva plováky
načíst170001 01111: index→ hodnotavložte plovák hodnota z lokální proměnné #index
fload_0220010 0010→ hodnotavložte plovák hodnota z lokální proměnné 0
fload_1230010 0011→ hodnotavložte plovák hodnota z lokální proměnné 1
fload_2240010 0100→ hodnotavložte plovák hodnota z lokální proměnné 2
fload_3250010 0101→ hodnotavložte plovák hodnota z lokální proměnné 3
fmul6a0110 1010hodnota1, hodnota2 → výsledekvynásobte dva plováky
fneg760111 0110hodnota → výsledekvyvrátit plovák
frem720111 0010hodnota1, hodnota2 → výsledekzískejte zbytek z rozdělení mezi dva plováky
freturnae1010 1110hodnota → [prázdný]vrátit plovák
fstore380011 10001: indexhodnota →uložit plovák hodnota do lokální proměnné #index
fstore_0430100 0011hodnota →uložit plovák hodnota do lokální proměnné 0
fstore_1440100 0100hodnota →uložit plovák hodnota do lokální proměnné 1
fstore_2450100 0101hodnota →uložit plovák hodnota do lokální proměnné 2
fstore_3460100 0110hodnota →uložit plovák hodnota do lokální proměnné 3
fsub660110 0110hodnota1, hodnota2 → výsledekodečíst dva plováky
getfieldb41011 01002: indexbyte1, indexbyte2objectref → hodnotazískat pole hodnota objektu objektová reference, kde je pole identifikováno odkazem na pole v konstantním fondu index (indexbyte1 << 8 | indexbyte2)
getstatickýb21011 00102: indexbyte1, indexbyte2→ hodnotazískat statické pole hodnota třídy, kde je pole identifikováno odkazem na pole v konstantním fondu index (indexbyte1 << 8 | indexbyte2)
jít doa71010 01112: branchbyte1, branchbyte2[žádná změna]přejde na jinou instrukci v odbočka (podepsané krátké zkonstruované z nepodepsaných bajtů branchbyte1 << 8 | branchbyte2)
goto_wc81100 10004: branchbyte1, branchbyte2, branchbyte3, branchbyte4[žádná změna]přejde na jinou instrukci v odbočka (signed int konstruováno z nepodepsaných bajtů branchbyte1 << 24 | branchbyte2 << 16 | branchbyte3 << 8 | branchbyte4)
i2b911001 0001hodnota → výsledekpřevést int na bajt
i2c921001 0010hodnota → výsledekpřevést int na znak
i2d871000 0111hodnota → výsledekpřevést int na dvojitý
i2f861000 0110hodnota → výsledekpřevést int na plovák
i2l851000 0101hodnota → výsledekpřevést int na dlouhý
i2s931001 0011hodnota → výsledekpřevést int na krátký
přidávám600110 0000hodnota1, hodnota2 → výsledekpřidat dva ints
iaload2e0010 1110arrayref, index → ​​hodnotanačíst int z pole
iand7e0111 1110hodnota1, hodnota2 → výsledekproveďte bitové AND na dvou celých číslech
iastore4f0100 1111arrayref, index, hodnota →uložit int do pole
iconst_m1020000 0010→ -1načíst hodnotu int -1 do zásobníku
iconst_0030000 0011→ 0načíst hodnotu int 0 do zásobníku
iconst_1040000 0100→ 1načíst hodnotu int 1 do zásobníku
iconst_2050000 0101→ 2načíst hodnotu int 2 do zásobníku
iconst_3060000 0110→ 3načtěte hodnotu int 3 do zásobníku
iconst_4070000 0111→ 4načíst hodnotu int 4 do zásobníku
iconst_5080000 1000→ 5načtěte hodnotu int 5 do zásobníku
idiv6c0110 1100hodnota1, hodnota2 → výsledekrozdělit dvě celá čísla
if_acmpeqa51010 01012: branchbyte1, branchbyte2hodnota1, hodnota2 →pokud jsou odkazy stejné, odbočte na instrukci na odbočka (podepsané krátké zkonstruované z nepodepsaných bajtů branchbyte1 << 8 | branchbyte2)
if_acmpnea61010 01102: branchbyte1, branchbyte2hodnota1, hodnota2 →pokud odkazy nejsou stejné, odbočte na instrukci na odbočka (podepsané krátké zkonstruované z nepodepsaných bajtů branchbyte1 << 8 | branchbyte2)
if_icmpeq9f1001 11112: branchbyte1, branchbyte2hodnota1, hodnota2 →pokud jsou ints rovné, odbočte na instrukci na odbočka (podepsané krátké zkonstruované z nepodepsaných bajtů branchbyte1 << 8 | branchbyte2)
if_icmpgea21010 00102: branchbyte1, branchbyte2hodnota1, hodnota2 →-li hodnota1 je větší nebo rovno hodnota2, pobočka k výuce na odbočka (podepsané krátké zkonstruované z nepodepsaných bajtů branchbyte1 << 8 | branchbyte2)
if_icmpgta31010 00112: branchbyte1, branchbyte2hodnota1, hodnota2 →-li hodnota1 je větší než hodnota2, pobočka k výuce na odbočka (podepsané krátké zkonstruované z nepodepsaných bajtů branchbyte1 << 8 | branchbyte2)
if_icmplea41010 01002: branchbyte1, branchbyte2hodnota1, hodnota2 →-li hodnota1 je menší nebo rovno hodnota2, pobočka k výuce na odbočka (podepsané krátké zkonstruované z nepodepsaných bajtů branchbyte1 << 8 | branchbyte2)
if_icmplta11010 00012: branchbyte1, branchbyte2hodnota1, hodnota2 →-li hodnota1 je méně než hodnota2, pobočka k výuce na odbočka (podepsané krátké zkonstruované z nepodepsaných bajtů branchbyte1 << 8 | branchbyte2)
if_icmpnea01010 00002: branchbyte1, branchbyte2hodnota1, hodnota2 →pokud nejsou ints stejné, odbočíme na instrukci v odbočka (podepsané krátké zkonstruované z nepodepsaných bajtů branchbyte1 << 8 | branchbyte2)
ifeq991001 10012: branchbyte1, branchbyte2hodnota →-li hodnota je 0, větev k výuce na odbočka (podepsané krátké zkonstruované z nepodepsaných bajtů branchbyte1 << 8 | branchbyte2)
ifge9c1001 11002: branchbyte1, branchbyte2hodnota →-li hodnota je větší než nebo rovno 0, větev na instrukci v odbočka (podepsané krátké zkonstruované z nepodepsaných bajtů branchbyte1 << 8 | branchbyte2)
ifgt9d1001 11012: branchbyte1, branchbyte2hodnota →-li hodnota je větší než 0, větev na instrukci na odbočka (podepsané krátké zkonstruované z nepodepsaných bajtů branchbyte1 << 8 | branchbyte2)
ifle9e1001 11102: branchbyte1, branchbyte2hodnota →-li hodnota je menší než nebo rovno 0, větev na instrukci v odbočka (podepsané krátké zkonstruované z nepodepsaných bajtů branchbyte1 << 8 | branchbyte2)
iflt9b1001 10112: branchbyte1, branchbyte2hodnota →-li hodnota je menší než 0, větev k výuce na odbočka (podepsané krátké zkonstruované z nepodepsaných bajtů branchbyte1 << 8 | branchbyte2)
ifne9a1001 10102: branchbyte1, branchbyte2hodnota →-li hodnota není 0, větev k instrukci na odbočka (podepsané krátké zkonstruované z nepodepsaných bajtů branchbyte1 << 8 | branchbyte2)
ifnonnullc71100 01112: branchbyte1, branchbyte2hodnota →-li hodnota není null, větev instrukce na odbočka (podepsané krátké zkonstruované z nepodepsaných bajtů branchbyte1 << 8 | branchbyte2)
ifnullc61100 01102: branchbyte1, branchbyte2hodnota →-li hodnota je null, větev instrukce na odbočka (podepsané krátké zkonstruované z nepodepsaných bajtů branchbyte1 << 8 | branchbyte2)
iinc841000 01002: index, konst[Žádná změna]přírůstek místní proměnné #index podepsaným bajtem konst
iload150001 01011: index→ hodnotanačíst int hodnota z lokální proměnné #index
iload_01a0001 1010→ hodnotanačíst int hodnota z lokální proměnné 0
iload_11b0001 1011→ hodnotanačíst int hodnota z lokální proměnné 1
iload_21c0001 1100→ hodnotanačíst int hodnota z lokální proměnné 2
iload_31d0001 1101→ hodnotanačíst int hodnota z lokální proměnné 3
impdep1fe1111 1110vyhrazeno pro operace závislé na implementaci v debuggerech; by se neměl objevit v žádném souboru třídy
impdep2ff1111 1111vyhrazeno pro operace závislé na implementaci v debuggerech; by se neměl objevit v žádném souboru třídy
imul680110 1000hodnota1, hodnota2 → výsledekvynásobte dvě celá čísla
ineg740111 0100hodnota → výsledeknegovat int
instanceofc11100 00012: indexbyte1, indexbyte2objectref → výsledekurčuje, zda je objekt objectref je daného typu identifikovaného odkazem na třídu index ve stálém bazénu (indexbyte1 << 8 | indexbyte2)
invokedynamicba1011 10104: indexbyte1, indexbyte2, 0, 0[arg1, [arg2 ...]] → výsledekvyvolá dynamickou metodu a umístí výsledek do zásobníku (může být neplatný); metoda je identifikována odkazem na metodu index ve stálém bazénu (indexbyte1 << 8 | indexbyte2)
vyvolatrozhraníb91011 10014: indexbyte1, indexbyte2, count, 0objectref, [arg1, arg2, ...] → výsledekvyvolá metodu rozhraní na objektu objectref a umístí výsledek do zásobníku (může být neplatný); metoda rozhraní je identifikována odkazem na metodu index ve stálém bazénu (indexbyte1 << 8 | indexbyte2)
speciálníb71011 01112: indexbyte1, indexbyte2objectref, [arg1, arg2, ...] → výsledekvyvolat instanci metody na objektu objectref a umístí výsledek do zásobníku (může být neplatný); metoda je identifikována odkazem na metodu index ve stálém bazénu (indexbyte1 << 8 | indexbyte2)
invokestatickýb81011 10002: indexbyte1, indexbyte2[arg1, arg2, ...] → výsledekvyvolat statickou metodu a umístit výsledek do zásobníku (může být neplatný); metoda je identifikována odkazem na metodu index ve stálém bazénu (indexbyte1 << 8 | indexbyte2)
invokevirtualb61011 01102: indexbyte1, indexbyte2objectref, [arg1, arg2, ...] → výsledekvyvolat virtuální metodu na objektu objectref a umístí výsledek do zásobníku (může být neplatný); metoda je identifikována odkazem na metodu index ve stálém bazénu (indexbyte1 << 8 | indexbyte2)
ior801000 0000hodnota1, hodnota2 → výsledekbitový int NEBO
irem700111 0000hodnota1, hodnota2 → výsledekzbytek logického int
zpětac1010 1100hodnota → [prázdný]vrátit celé číslo z metody
ishl780111 1000hodnota1, hodnota2 → výsledekint posun doleva
ishr7a0111 1010hodnota1, hodnota2 → výsledekint aritmetický posun doprava
Istore360011 01101: indexhodnota →obchod int hodnota do proměnné #index
istore_03b0011 1011hodnota →obchod int hodnota do proměnné 0
istore_13c0011 1100hodnota →obchod int hodnota do proměnné 1
istore_23d0011 1101hodnota →obchod int hodnota do proměnné 2
istore_33e0011 1110hodnota →obchod int hodnota do proměnné 3
isub640110 0100hodnota1, hodnota2 → výsledekint odečíst
iushr7c0111 1100hodnota1, hodnota2 → výsledekint logický posun doprava
ixor821000 0010hodnota1, hodnota2 → výsledekint xor
jsra81010 10002: branchbyte1, branchbyte2→ adresaskočit na podprogram v odbočka (podepsané krátké zkonstruované z nepodepsaných bajtů branchbyte1 << 8 | branchbyte2) a vložte zpáteční adresu do zásobníku
jsr_wc91100 10014: branchbyte1, branchbyte2, branchbyte3, branchbyte4→ adresaskočit na podprogram v odbočka (signed int konstruováno z nepodepsaných bajtů branchbyte1 << 24 | branchbyte2 << 16 | branchbyte3 << 8 | branchbyte4) a vložte zpáteční adresu do zásobníku
l2d8a1000 1010hodnota → výsledekpřevést dlouhý na dvojitý
l2f891000 1001hodnota → výsledekpřevést dlouhý na plovák
l2i881000 1000hodnota → výsledekpřevést dlouhý na int
ladd610110 0001hodnota1, hodnota2 → výsledekpřidat dvě dlouhé
zátěž2f0010 1111arrayref, index → ​​hodnotanačíst dlouhý z pole
přistát7f0111 1111hodnota1, hodnota2 → výsledekbitový A ze dvou dlouhých
vydržet500101 0000arrayref, index, hodnota →uložit dlouhý do pole
lcmp941001 0100hodnota1, hodnota2 → výsledekstiskněte 0, pokud jsou dvě délky stejné, 1, pokud je hodnota1 větší než hodnota2, -1 jinak
lconst_0090000 1001→ 0Ltlačit 0L (číslo nula s typem dlouho) do zásobníku
lconst_10a0000 1010→ 1Ltlačit 1L (číslo jeden s typem dlouho) do zásobníku
ldc120001 00101: index→ hodnotatlačit konstantu #index z konstantního fondu (String, int, float, Class, java.lang.invoke.MethodType, java.lang.invoke.MethodHandle nebo dynamicky vypočítaná konstanta) do zásobníku
ldc_w130001 00112: indexbyte1, indexbyte2→ hodnotatlačit konstantu #index z konstantního fondu (String, int, float, Class, java.lang.invoke.MethodType, java.lang.invoke.MethodHandle nebo dynamicky vypočítaná konstanta) do zásobníku (široký index je konstruován jako indexbyte1 << 8 | indexbyte2)
ldc2_w140001 01002: indexbyte1, indexbyte2→ hodnotatlačit konstantu #index z konstantního fondu (dvojitá, dlouhá nebo dynamicky vypočítaná konstanta) do zásobníku (široký index je konstruován jako indexbyte1 << 8 | indexbyte2)
ldiv6d0110 1101hodnota1, hodnota2 → výsledekrozdělit dvě dlouhé
Načíst160001 01101: index→ hodnotanačíst dlouhou hodnotu z místní proměnné #index
lload_01e0001 1110→ hodnotanačíst dlouhou hodnotu z lokální proměnné 0
lload_11f0001 1111→ hodnotanačíst dlouhou hodnotu z lokální proměnné 1
lload_2200010 0000→ hodnotanačíst dlouhou hodnotu z lokální proměnné 2
lload_3210010 0001→ hodnotanačíst dlouhou hodnotu z lokální proměnné 3
lmul690110 1001hodnota1, hodnota2 → výsledekznásobte dvě délky
lneg750111 0101hodnota → výsledeknegovat dlouho
vyhledávací spínačab1010 10118+: <0–3 bajty odsazení>, defaultbyte1, defaultbyte2, defaultbyte3, defaultbyte4, npairs1, npairs2, npairs3, npair4, páry párování-offset ...klíč →cílová adresa je vyhledána z tabulky pomocí klíče a provádění pokračuje z instrukce na této adrese
lor811000 0001hodnota1, hodnota2 → výsledekbitové NEBO dvou délek
lrem710111 0001hodnota1, hodnota2 → výsledekzbytek rozdělení na dvě délky
pozdní návratinzerát1010 1101hodnota → [prázdný]vrátit dlouhou hodnotu
lshl790111 1001hodnota1, hodnota2 → výsledekbitový posun vlevo od dlouhého hodnota1 podle int hodnota2 pozic
lshr7b0111 1011hodnota1, hodnota2 → výsledekbitový posun vpravo o dlouhý hodnota1 podle int hodnota2 pozic
obchod370011 01111: indexhodnota →uložit dlouho hodnota v lokální proměnné #index
lstore_03f0011 1111hodnota →uložit dlouho hodnota v lokální proměnné 0
lstore_1400100 0000hodnota →uložit dlouho hodnota v lokální proměnné 1
lstore_2410100 0001hodnota →uložit dlouho hodnota v lokální proměnné 2
lstore_3420100 0010hodnota →uložit dlouho hodnota v lokální proměnné 3
lsub650110 0101hodnota1, hodnota2 → výsledekodečíst dvě délky
lushr7d0111 1101hodnota1, hodnota2 → výsledekbitový posun vpravo o dlouhý hodnota1 podle int hodnota2 pozice, nepodepsané
lxor831000 0011hodnota1, hodnota2 → výsledekbitový XOR dvou délek
monitorovací centrumc21100 0010objectref →zadejte monitor objektu ("chytit zámek" - začátek synchronizované () sekce)
monitorexitc31100 0011objectref →výstupní monitor objektu ("uvolnit zámek" - konec synchronizované () sekce)
multianewarrayc51100 01013: indexbyte1, indexbyte2, rozměrycount1, [count2, ...] → arrayrefvytvořit nové pole rozměry rozměry typu identifikované odkazem na třídu v konstantním fondu index (indexbyte1 << 8 | indexbyte2); velikosti každé dimenze jsou označeny count1, [count2, atd.]
Novýbb1011 10112: indexbyte1, indexbyte2→ reference objektuvytvořit nový objekt typu identifikovaného odkazem na třídu v konstantním fondu index (indexbyte1 << 8 | indexbyte2)
newarraypřed naším letopočtem1011 11001: atypecount → arrayrefvytvořit nové pole s počet prvky primitivního typu identifikované pomocí typ
nop000000 0000[Žádná změna]neprovádějte žádnou operaci
pop570101 0111hodnota →zahoďte nejvyšší hodnotu v zásobníku
pop2580101 1000{hodnota2, hodnota1} →zahoďte první dvě hodnoty v zásobníku (nebo jednu hodnotu, pokud je dvojitá nebo dlouhá)
Putfieldb51011 01012: indexbyte1, indexbyte2objectref, value →nastavit pole na hodnota v objektu objektová reference, kde je pole identifikováno odkazem na pole index ve stálém bazénu (indexbyte1 << 8 | indexbyte2)
putstatickýb31011 00112: indexbyte1, indexbyte2hodnota →nastavit statické pole na hodnota ve třídě, kde je pole identifikováno odkazem na pole index ve stálém bazénu (indexbyte1 << 8 | indexbyte2)
reta91010 10011: index[Žádná změna]pokračovat v provádění z adresy převzaté z místní proměnné #index (asymetrie s jsr je úmyslná)
vrátit seb11011 0001→ [prázdné]return void z metody
pytel350011 0101arrayref, index → ​​hodnotanačíst z pole
sastore560101 0110arrayref, index, hodnota →uložit short to array
sipush110001 00012: byte1, byte2→ hodnotavložit zkratku do zásobníku jako celé číslo hodnota
vyměnit5f0101 1111hodnota2, hodnota1 → hodnota1, hodnota2zamění dvě hlavní slova v zásobníku (všimněte si, že hodnota1 a hodnota2 nesmí být dvojité nebo dlouhé)
stolní čarodějniceaa1010 101016+: [0–3 bajty odsazení], defaultbyte1, defaultbyte2, defaultbyte3, defaultbyte4, lowbyte1, lowbyte2, lowbyte3, lowbyte4, highbyte1, highbyte2, highbyte3, highbyte4, skokové posuny ...index →pokračovat v provádění z adresy v tabulce na offsetu index
širokýc41100 01003/5: operační kód, indexbyte1, indexbyte2
nebo
iinc, indexbyte1, indexbyte2, countbyte1, countbyte2		[stejné jako u příslušných pokynů]vykonat operační kód, kde operační kód je buď iload, fload, aload, lload, dload, istore, fstore, astore, lstore, dstore nebo ret, ale předpokládejme index je 16 bitů; nebo provést iinc, kde index je 16 bitů a konstanta, o kterou se zvyšuje, je o 16 bitů krátká
(beze jména)cb-fdtyto hodnoty nejsou aktuálně přiřazeny pro operační kódy a jsou vyhrazeny pro budoucí použití

Viz také

externí odkazy