Pohled pod kapotu JVM (6.část - instrukční soubor virtuálního stroje Javy)

Obsah

1. Pohled pod kapotu JVM (6.část – instrukční soubor virtuálního stroje Javy)

2. Instrukce sloužící pro uložení konstanty zvoleného typu na zásobník operandů

3. Demonstrační příklad: využití instrukcí pro uložení konstanty na zásobník

4. Instrukce sloužící pro přesuny dat mezi lokálními proměnnými a zásobníkem operandů

5. Demonstrační příklad: přesun dat mezi parametry metody a zásobníkem

6. Instrukce pro přímou manipulaci s prvky uloženými na zásobníku operandů

7. Instrukce pro konverzi mezi různými datovými typy

8. Demonstrační příklad: konverze mezi různými datovými typy

9. Odkazy na Internetu

1. Pohled pod kapotu JVM (6.část – instrukční soubor virtuálního stroje Javy)

V dnešní části seriálu o programovacím jazyku Java i o vlastnostech JVM (Java Virtual Machine) budeme pokračovat v popisu instrukčního souboru zpracovávaného buď přímo virtuálním strojem Javy (interpretace bajtkódu), nebo překládaného s využitím JIT (Just In Time) překladače do nativního strojového kódu konkrétního mikroprocesoru, na němž virtuální stroj Javy běží. Připomeňme si, že instrukce použité v instrukční sadě JVM pracují s operandy uloženými na takzvaném zásobníku operandů, který současně slouží i pro předávání parametrů volaným metodám a následně pro získání návratové hodnoty těchto metod. Některé instrukce taktéž pracují s operandy uloženými v zásobníkovém rámci (stack frame), v němž se nachází jak parametry předané volané metodě, tak i oblast vyhrazená pro lokální proměnné této metody. Velikost této paměťové oblasti, na níž se můžeme dívat jako na pole s možností indexace jednotlivých prvků, je zjištěna již při překladu zdrojových kódů a virtuální stroj Javy automaticky provádí kontrolu, zda nedochází k překročení indexu, tj. ke čtení či zápisu mimo vyhrazenou oblast (jedná se ovšem o pole nehomogenní, protože jeho prvky mohou mít různý typ).

Logická struktura paměti spravované virtuálním strojem Javy, která nás nyní bude zajímat, je zobrazena pod tímto odstavcem:

+============================================+
|              Zásobník (stack)              |
+============================================+
|                                            |
|   +------------------------------------+   |
|   | Zásobníkový rámec #1 (stack frame) |   |
|   +------------------------------------+   |
|   |                                    |   |
|   |      +---------------------+       |   |
|   |      |  Zásobník operandů  |       |   |
|   |      +---------------------+       |   |
|   |                                    |   |
|   |      +---------------------+       |   |
|   |      |  Parametry metody   |       |   |
|   |      |.....................|       |   |
|   |      |  Lokální proměnné   |       |   |
|   |      +---------------------+       |   |
|   |                                    |   |
|   +------------------------------------+   |
|                                            |
|   +------------------------------------+   |
|   | Zásobníkový rámec #2 (stack frame) |   |
|   +------------------------------------+   |
|   |                                    |   |
|   |      +---------------------+       |   |
|   |      |  Zásobník operandů  |       |   |
|   |      +---------------------+       |   |
|   |                                    |   |
|   |      +---------------------+       |   |
|   |      |  Parametry metody   |       |   |
|   |      |.....................|       |   |
|   |      |  Lokální proměnné   |       |   |
|   |      +---------------------+       |   |
|   |                                    |   |
|   +------------------------------------+   |
|                                            |
|   +------------------------------------+   |
|   | Zásobníkový rámec #3 (stack frame) |   |
|   +------------------------------------+   |
|   |                                    |   |
|   |      +---------------------+       |   |
|   |      |  Zásobník operandů  |       |   |
|   |      +---------------------+       |   |
|   |                                    |   |
|   |      +---------------------+       |   |
|   |      |  Parametry metody   |       |   |
|   |      |.....................|       |   |
|   |      |  Lokální proměnné   |       |   |
|   |      +---------------------+       |   |
|   |                                    |   |
|   +------------------------------------+   |
|                                            |
|  ::::::::::::::::::::::::::::::::::::::::  |
|  :: Další zásobníkové rámce vytvářené  ::  |
|  :: v čase běhu aplikace při volání    ::  |
|  :: metod.                             ::  |
|  ::::::::::::::::::::::::::::::::::::::::  |
+============================================+

2. Instrukce sloužící pro uložení konstanty zvoleného typu na zásobník operandů

První skupinou instrukcí, o nichž se dnes zmíníme, jsou instrukce sloužící pro uložení konstanty na zásobník operandů. Ovšem ještě před uvedením seznamu jednotlivých instrukcí si musíme říci dva důležité fakty o celém instrukčním souboru JVM. Prvním faktem je, že všechny dále popsané instrukce mají operační kód o délce pouhého jednoho bajtu, přičemž se za operačním kódem u některých instrukcí nachází jeden či více dalších bajtů představujících buď přímo celočíselnou konstantu nebo index do constant poolu. Druhým faktem, který možná „assemblerovským puristům“ (mezi které jsem také ještě nedávno patřil :-) může vadit, je to, že instrukční sada JVM není v žádném případě ortogonální, tj. mnohé instrukce pracují pouze s omezeným počtem datových typů a pro ostatní datové typy neexistuje ekvivalentní instrukce. To například znamená, že existuje jen velmi málo instrukcí pro operace nad datovými typy byte, short a char a prakticky žádná instrukce pro datový typ boolean.

Naproti tomu však některé další instrukce obsahují přímo ve svém operačním kódu (tj. v onom jednom bajtu) krátkou celočíselnou konstantu, která se využívá buď jako index do oblasti lokálních proměnných nebo jako skutečná číselná konstanta. Tato technika je použita z toho důvodu, aby byl bajtkód co možná nejkratší, proto se také nejvíce místa v instrukční sadě „obětovalo“ na instrukce sloužící pro uložení konstanty typu int. V následující tabulce jsou vypsány všechny instrukce sloužící pro uložení číselné konstanty na zásobník. Ve sloupci „Instrukce“ se nachází symbolické jméno instrukce, sloupec „Opkód“ obsahuje bajtovou hodnotu uloženou přímo v bajtkódu (tedy operační kód instrukce), ve sloupcích „Data 1“ a „Data 2“ jsou vypsány bajty, které jsou případně uloženy ihned za operačním kódem a ve sloupci „Typ“ je uveden datový typ skutečně uložený na zásobník operandů:

3. Demonstrační příklad: využití instrukcí pro uložení konstanty na zásobník

Při pohledu na tabulku uvedenou v předchozí kapitole se může zdát, že některé instrukce jsou zdánlivě shodné. Například se jedná o pár instrukcí iconst₁ a lconst₁. Ve skutečnosti však tyto instrukce pracují s rozdílnými datovými typy, což je kontrolováno za běhu JVM. Totéž platí i u trojice instrukcí ldc* u nichž je typ zjištěn přímo z typu konstanty uložené na constant poolu (typicky se jedná o reference na objekty či o reálné konstanty). Všimněte si také, že práce s typy long a double téměř vždy vede k vygenerování delšího bajtkódu, protože konstanty tohoto typu uložené na constant poolu lze adresovat jen s využitím šestnáctibitového indexu (popravdě řečeno je v tomto případě jak struktura constant poolu, tak i struktura bajtkódu navržena dosti nešťastně a nelogicky; jen těžko lze odhadnout, kolik kilobajtů paměťového prostoru je kvůli této nelogičnosti zbytečně alokováno pro každou běžící JVM).

Pojďme se podívat ještě na další vlastnosti instrukcí vypsaných v předchozí tabulce. Zajímavé například je, že některé příkazy lze provést více způsoby, protože například instrukce iconst₁, bipush 1 a sipush 1 jsou funkčně ekvivalentní – všechny totiž slouží pro uložení konstanty 1 typu int na zásobník operandů. Ve skutečnosti ale překladač v tomto případě vždy vybere nejkratší instrukci, tj. iconst₁ (ta má délku jen jeden bajt, zatímco bipush 1 má dva bajty a sipush 1 dokonce bajty tři). Totéž platí například pro instrukce bipush 100, sipush 100 a ldc (index na konstantu 100 uloženou na constant poolu). I v tomto případě překladač vybere první instrukci, protože ne nejkratší (už jen z toho důvodu, že se ušetří jeden záznam na constant poolu). Vše si ukážeme na následujícím demonstračním příkladu, jehož zdrojový kód má tvar:

class Test1 {
 
    static void method1() {
        nop(0, 1, 2);
    }
 
    static void method2() {
        nop(3, 4, 5);
    }
 
    static void method3() {
        nop(6, 7, 8);
    }
 
    static void method4() {
        nop(32, 127, -128);
    }
 
    static void method5() {
        nop(128, 32767, -32768);
    }
 
    static void method6() {
        nop(0x12345678, 0x00aabbcc, 789789);
    }
 
    static void method7() {
        nop(0.0f, 1.0f);
    }
 
    static void method8() {
        nop(2.0f, 3.0f);
    }
 
    static void method9() {
        nop(0.0, 1.0);
    }
 
    static void method10() {
        nop(2.0, 3.0);
    }
 
    static void method11() {
        nop(null);
    }
 
    static void method12() {
        nop("pokus");
    }
 
    static void nop(int a, int b, int c) {
        // nic ;-)
    }
 
    static void nop(float a, float b) {
        // opět nic ;-)
    }
 
    static void nop(double a, double b) {
        // opět nic ;-)
    }
 
    static void nop(Object o) {
        // opět nic ;-)
    }
 
}

Jak je ze zdrojového kódu třídy Test1 patrné, je v něm z několika testovacích metod volána přetížená statická metoda nop(int, int, int), nop(float, float), nop(double, double) či nop(Object), která ve skutečnosti nic neprovádí a taktéž nic nevrací (její návratový typ je ve všech případech void). My budeme sledovat, jakým způsobem se přeloží zbylé metody method*, které musí před zavoláním nop() umístit všechny parametry na zásobník, tj. použít instrukce z tabulky uvedené ve druhé kapitole. Následuje výpis disassemlovaného bajtkódu s ručně dopsanými poznámkami:

static void method1();
  Code:
   Stack=3, Locals=0, Args_size=0
   0:   iconst_0            // konstanta 1 je přímo součástí operačního kódu instrukce
   1:   iconst_1            // konstanta 2 je přímo součástí operačního kódu instrukce
   2:   iconst_2            // konstanta 3 je přímo součástí operačního kódu instrukce
   3:   invokestatic    #2; // volání metody void nop(int, int, int)
   6:   return              // návrat do volající metody

static void method2();
  Code:
   Stack=3, Locals=0, Args_size=0
   0:   iconst_3            // konstanta 4 je přímo součástí operačního kódu instrukce
   1:   iconst_4            // konstanta 5 je přímo součástí operačního kódu instrukce
   2:   iconst_5            // konstanta 6 je přímo součástí operačního kódu instrukce
   3:   invokestatic    #2; // volání metody void nop(int, int, int)
   6:   return              // návrat do volající metody

static void method3();
  Code:
   Stack=3, Locals=0, Args_size=0
   0:   bipush  6           // konstanta o rozsahu (signed) byte uložená ihned za operačním kódem
   2:   bipush  7           // konstanta o rozsahu (signed) byte uložená ihned za operačním kódem
   4:   bipush  8           // konstanta o rozsahu (signed) byte uložená ihned za operačním kódem
   6:   invokestatic    #2; // volání metody void nop(int, int, int)
   9:   return              // návrat do volající metody

static void method4();
  Code:
   Stack=3, Locals=0, Args_size=0
   0:   bipush  32          // konstanta o rozsahu (signed) byte uložená ihned za operačním kódem
   2:   bipush  127         // konstanta o rozsahu (signed) byte uložená ihned za operačním kódem
   4:   bipush  -128        // konstanta o rozsahu (signed) byte uložená ihned za operačním kódem
   6:   invokestatic    #2; // volání metody void nop(int, int, int)
   9:   return              // návrat do volající metody

static void method5();
  Code:
   Stack=3, Locals=0, Args_size=0
   0:   sipush  128         // konstanta o rozsahu (signed) short uložená ihned za operačním kódem
   3:   sipush  32767       // konstanta o rozsahu (signed) short uložená ihned za operačním kódem
   6:   sipush  -32768      // konstanta o rozsahu (signed) short uložená ihned za operačním kódem
   9:   invokestatic    #2; // volání metody void nop(int, int, int)
   12:  return              // návrat do volající metody

static void method6();
  Code:
   Stack=3, Locals=0, Args_size=0
   0:   ldc #3;             // celočíselná konstanta typu int 305419896 načtená z constant poolu
   2:   ldc #4;             // celočíselná konstanta typu int 11189196 načtená z constant poolu
   4:   ldc #5;             // celočíselná konstanta typu int 789789 načtená z constant poolu
   6:   invokestatic    #2; // volání metody void nop(int, int, int)
   9:   return              // návrat do volající metody

static void method7();
  Code:
   Stack=2, Locals=0, Args_size=0
   0:   fconst_0            // konstanta 0.0f je přímo součástí operačního kódu instrukce
   1:   fconst_1            // konstanta 1.0f je přímo součástí operačního kódu instrukce
   2:   invokestatic    #6; // volání metody void nop(float, float)
   5:   return              // návrat do volající metody

static void method8();
  Code:
   Stack=2, Locals=0, Args_size=0
   0:   fconst_2            // konstanta 2.0f je přímo součástí operačního kódu instrukce
   1:   ldc #7;             // konstanta typu float 3.0f načtená z constant poolu
   3:   invokestatic    #6; // volání metody void nop(float, float)
   6:   return              // návrat do volající metody

static void method9();
  Code:
   Stack=4, Locals=0, Args_size=0
   0:   dconst_0            // konstanta 0.0 je přímo součástí operačního kódu instrukce
   1:   dconst_1            // konstanta 1.0 je přímo součástí operačního kódu instrukce
   2:   invokestatic    #8; // volání metody void nop(double, double)
   5:   return

static void method10();
  Code:
   Stack=4, Locals=0, Args_size=0
   0:   ldc2_w  #9;         // konstanta typu double 2.0d načtená z constant poolu
   3:   ldc2_w  #11;        // konstanta typu double 3.0d načtená z constant poolu
   6:   invokestatic    #8; // volání metody void nop(double, double)
   9:   return

static void method11();
  Code:
   Stack=1, Locals=0, Args_size=0
   0:   aconst_null         // konstanta null je součástí operačního kódu instrukce
   1:   invokestatic   #13; // volání metody void nop(Object)
   4:   return

static void method12();
  Code:
   Stack=1, Locals=0, Args_size=0
   0:   ldc #14;            // String "pokus" je uložen v constant poolu
   2:   invokestatic   #13; // volání metody void nop(Object)
   5:   return

4. Instrukce sloužící pro přesuny dat mezi lokálními proměnnými a zásobníkem operandů

Další poměrně velkou skupinu instrukcí tvoří instrukce sloužící pro přesuny dat mezi lokálními proměnnými a případnými parametry metody na jedné straně a zásobníkem operandů na straně druhé. Je pravděpodobně zřejmé, že způsob adresace dat bude odlišný na straně lokálních proměnných i na straně zásobníku operandů. V případě lokálních proměnných+pa­rametrů je totiž každý prvek určen svým indexem, který je nedílnou součástí instrukce (jak jsme si již řekli minule a ostatně i v první kapitole, lze na tuto oblast zásobníkového rámce pohlížet jako na pole, jehož prvky lze snadno indexovat). U zásobníku operandů se vždy pracuje s prvkem umístěným na vrcholu zásobníku (TOS=Top Of Stack); ostatní prvky umístěné pod TOS jsou nedostupné.

Všechny instrukce tohoto typu se jmenují *load# popř. *store#, přičemž za hvězdičku se doplňuje první písmeno datového typu a za křížek se v některých případech udává index do oblasti lokálních proměnných – to ovšem jen v případě těch instrukcí, u nichž je index součástí instrukčního slova. V opačném případě je index uložen ve formě jednoho bajtu ihned za instrukčním kódem. Pokud je nutné adresovat prvek s indexem větším než 255 (typicky u začátečnických programů v velkým množstvím lokálních proměnných v jediné metodě :-)), lze před instrukci typu load/store vložit prefix wide – poté lze použít šestnáctibitový index namísto indexu osmibitového. Tuto zajímavou instrukci (či spíše instrukční prefix) si podrobněji popíšeme příště:

5. Demonstrační příklad: přesun dat mezi parametry metody a zásobníkem

Podobně jako u předchozí skupiny instrukcí, i u instrukcí typu load a store je možné vidět snahu tvůrců specifikace JVM o optimalizaci bajtkódu na jeho celkovou velikost – týká se to především přístupu k prvním parametrům metody a/nebo lokálním proměnným s využitím konstantního indexu uloženého přímo v operačním kódu instrukce. I z tohoto důvodu je vhodné u všech metod nepracujících s atributy objektu používat modifikátor static, čímž se ušetří jedna pozice v oblasti lokálních proměnných, která by jinak byla rezervována pro předání hodnoty this. Podívejme se však opět na demonstrační příklad, který nám ukáže, jakým způsobem překladač generuje instrukce typu load a store v reálném bajtkódu. Zdrojový kód demonstračního příkladu je opět poměrně jednoduchý – jedná se o třídu obsahující metody, které pracují pouze se svými parametry (to abychom se vyhnuli práci s konstantami, protože to již známe z předchozích kapitol). Aby byl vidět rozdíl mezi přístupem k prvním čtyřem parametrům a zbylými parametry, má každá metoda navíc i dvojici „výplňových“ parametrů:

class Test2 {
 
    static void method1(int a, int b, boolean vypln1, boolean vypln2, int c) {
        a = b;
        b = c;
        c = a;
    }
 
    static void method2(long a, long b, boolean vypln1, boolean vypln2, long c) {
        a = b;
        b = c;
        c = a;
    }
 
    static void method3(float a, float b, boolean vypln1, boolean vypln2, float c) {
        a = b;
        b = c;
        c = a;
    }
 
    static void method4(double a, double b, boolean vypln1, boolean vypln2, double c) {
        a = b;
        b = c;
        c = a;
    }
 
    static void method5(String a, String b, boolean vypln1, boolean vypln2, String c) {
        a = b;
        b = c;
        c = a;
    }
 
}

Disassemlovaný bajtkód všech pěti testovacích metod s ručně dopsanými komentáři vypadá následovně:

static void method1(int, int, boolean, boolean, int);
  Code:
   Stack=1, Locals=5, Args_size=5
   0:   iload_1           // index je součástí operačního kódu instrukce
   1:   istore_0          // index je součástí operačního kódu instrukce
   2:   iload   4         // index je uveden v bajtu za operačním kódem
   4:   istore_1          // index je součástí operačního kódu instrukce
   5:   iload_0           // index je součástí operačního kódu instrukce
   6:   istore  4         // index je uveden v bajtu za operačním kódem
   8:   return            // návrat do volající metody

static void method2(long, long, boolean, boolean, long);
  Code:
   Stack=2, Locals=8, Args_size=5
   0:   lload_2           // index je součástí operačního kódu instrukce
   1:   lstore_0          // index je součástí operačního kódu instrukce
   2:   lload   6         // index je uveden v bajtu za operačním kódem
   4:   lstore_2          // index je součástí operačního kódu instrukce
   5:   lload_0           // index je součástí operačního kódu instrukce
   6:   lstore  6         // index je uveden v bajtu za operačním kódem
   8:   return            // návrat do volající metody

static void method3(float, float, boolean, boolean, float);
  Code:
   Stack=1, Locals=5, Args_size=5
   0:   fload_1           // index je součástí operačního kódu instrukce
   1:   fstore_0          // index je součástí operačního kódu instrukce
   2:   fload   4         // index je uveden v bajtu za operačním kódem
   4:   fstore_1          // index je součástí operačního kódu instrukce
   5:   fload_0           // index je součástí operačního kódu instrukce
   6:   fstore  4         // index je uveden v bajtu za operačním kódem
   8:   return            // návrat do volající metody

static void method4(double, double, boolean, boolean, double);
  Code:
   Stack=2, Locals=8, Args_size=5
   0:   dload_2           // index je součástí operačního kódu instrukce
   1:   dstore_0          // index je součástí operačního kódu instrukce
   2:   dload   6         // index je uveden v bajtu za operačním kódem
   4:   dstore_2          // index je součástí operačního kódu instrukce
   5:   dload_0           // index je součástí operačního kódu instrukce
   6:   dstore  6         // index je uveden v bajtu za operačním kódem
   8:   return            // návrat do volající metody

static void method5(java.lang.String, java.lang.String, boolean, boolean, java.lang.String);
  Code:
   Stack=1, Locals=5, Args_size=5
   0:   aload_1           // index je součástí operačního kódu instrukce
   1:   astore_0          // index je součástí operačního kódu instrukce
   2:   aload   4         // index je uveden v bajtu za operačním kódem
   4:   astore_1          // index je součástí operačního kódu instrukce
   5:   aload_0           // index je součástí operačního kódu instrukce
   6:   astore  4         // index je uveden v bajtu za operačním kódem
   8:   return            // návrat do volající metody

6. Instrukce pro přímou manipulaci s prvky uloženými na zásobníku operandů

Mohlo by se zdát, že pokud zásobník operandů slouží pouze k přípravě parametrů pro volanou metodu, popř. k jednoduchým výpočtům, nejsou potřeba žádné další instrukce, které by sloužily pro manipulaci s daty uloženými na zásobníku operandů. Ve skutečnosti to však není zcela pravda, protože se velmi často stane, že je zapotřebí odstranit nějaký prvek ze zásobníku a nikam ho přitom neukládat, popř. zduplikovat prvek, který se na zásobníku nachází. Pro tyto případy obsahuje instrukční sada virtuálního stroje Javy několik instrukcí, které se nápadně podobají slovům používaným v programovacím jazyku Forth (ono se ostatně není čemu divit, protože se jedná skutečně o základní instrukce). Důležité je, že tyto instrukce již nepotřebují být rozděleny podle toho s jakými daty pracují, protože každému prvku uloženém na zásobníku operandů je stejně přiřazen datový tag, který je těmito instrukcemi využíván. Zajímavé je, že podobný princip nebyl použit například u aritmetických instrukcí (bavil jsem se o tom s jedním vývojářem VM, kterému se to také příliš nelíbilo, ale už si nepamatoval, kdo vlastně s návrhem instrukční sady před více než patnácti lety u společnosti Sun přišel):

7. Instrukce pro konverzi mezi různými datovými typy

Čtvrtou skupinou instrukcí virtuálního stroje jazyka Java, s níž se dnes seznámíme, jsou instrukce sloužící pro konverzi dat. Programovací jazyk Java sice patří mezi jazyky silně typované, ale konverze mezi některými datovými typy jsou prováděny automaticky (byte-→int) a jiné lze explicitně zapsat. Navíc se konverzní instrukce objevují v bajtkódu například při vytváření návratové hodnoty metody v případě, že tato hodnota nemá typ int, long, float či double. Ovšem ne všechny kombinace konverzí datových typů jsou v instrukční sadě přítomny, takže některé konverze je ve skutečnosti nutné provádět pomocí dvojice instrukcí (například se může jednat o konverzi z float na short a podobně). Podívejme se ostatně na tabulku obsahující všechny konverzní instrukce. V prvním sloupci je uveden datový typ, z něhož je konverze prováděna a v prvním řádku naopak výsledný datový typ:

8. Demonstrační příklad: konverze mezi různými datovými typy

Opět se podívejme na jednoduchý demonstrační příklad, v němž budou použity některé výše uvedené konverzní funkce. Příklad se skládá z několika metod – první čtyři metody provádí konverzi svého parametru na výstupní hodnotu a pátá metoda obsahuje několik lokálních proměnných inicializovaných proměnnými jiného typu. V některých případech je možné využít implicitní konverze, ovšem v mnoha dalších případech se nevyhneme explicitnímu přetypování:

class Test3 {
 
    static byte toByte(int i) {
        return (byte)i;
    }
 
    static short toShort(int i) {
        return (short)i;
    }
 
    static short toShort(float f) {
        return (short)f;
    }
 
    static short toShort(double d) {
        return (short)d;
    }
 
    static void vypocet(int x, int y) {
        long   a = x;
        float  f = y;
        float  g = a;
        int    i = (int)f;
        double d = i;
        byte   b = (byte)d;
    }
 
}

Disassemlovaný bajtkód vypadá následovně:

static byte toByte(int);
  Code:
   Stack=1, Locals=1, Args_size=1
   0:   iload_0           // načtení prvního parametru metody
   1:   i2b               // převod na byte
   2:   ireturn           // návrat do volající metody s návratovou hodnotou na zásobníku

static short toShort(int);
  Code:
   Stack=1, Locals=1, Args_size=1
   0:   iload_0           // načtení prvního parametru metody
   1:   i2s               // převod na short
   2:   ireturn           // návrat do volající metody s návratovou hodnotou na zásobníku

static short toShort(float);
  Code:
   Stack=1, Locals=1, Args_size=1
   0:   fload_0           // načtení prvního parametru metody
   1:   f2i               // postupný převod z float
   2:   i2s               // ... na short přes typ int
   3:   ireturn           // návrat do volající metody s návratovou hodnotou na zásobníku

static short toShort(double);
  Code:
   Stack=2, Locals=2, Args_size=1
   0:   dload_0           // načtení prvního parametru metody
   1:   d2i               // postupný převod z double
   2:   i2s               // ... na short přes typ int
   3:   ireturn           // návrat do volající metody s návratovou hodnotou na zásobníku

static void vypocet(int, int);
  Code:
   Stack=2, Locals=10, Args_size=2
   0:   iload_0           //
   1:   i2l               // long a = x;
   2:   lstore_2          //
 
   3:   iload_1           //
   4:   i2f               // float f = y
   5:   fstore  4         //
 
   7:   lload_2           //
   8:   l2f               // float g = a
   9:   fstore  5         //
 
   11:  fload   4         //
   13:  f2i               // int i = (int)f;
   14:  istore  6         //
 
   16:  iload   6         //
   18:  i2d               // double d = i;
   19:  dstore  7         //
 
   21:  dload   7         //
   23:  d2i               // byte b = (byte)d;
   24:  i2b               // zde jde o postupný převod přes int
   25:  istore  9         //
 
   27:  return            // návrat do volající metody

9. Odkazy na Internetu

1. Java quick guide: JVM Instruction Set
   http://www.mo­bilefish.com/tu­torials/java/ja­va_quickguide_jvm_in­struction_set­.html
2. The JVM Instruction Set
   http://mpdebo­er.home.xs4all­.nl/scriptie/no­de14.html
3. Root.cz: Využití komprimovaných ukazatelů na objekty v JVM
   http://www.ro­ot.cz/clanky/vy­uziti-komprimovanych-ukazatelu-na-objekty-v-nbsp-jvm/
4. Root.cz: JamVM aneb alternativa k HotSpotu nejenom pro embedded zařízení a chytré telefony
   http://www.ro­ot.cz/clanky/jam­vm-aneb-alternativa-k-hotspotu-nejenom-pro-embedded-zarizeni-tablety-a-chytre-telefony/
5. The Java^TM Virtual Machine Specification, Second Edition
   http://java.sun­.com/docs/book­s/jvms/second_e­dition/html/VMSp­ecTOC.doc.html
6. The class File Format
   http://java.sun­.com/docs/book­s/jvms/second_e­dition/html/Clas­sFile.doc.html
7. javap – The Java Class File Disassembler
   http://docs.o­racle.com/java­se/1.4.2/docs/to­oldocs/window­s/javap.html
8. javap-java-1.6.0-openjdk(1) – Linux man page
   http://linux.di­e.net/man/1/j­avap-java-1.6.0-openjdk
9. Using javap
   http://www.ide­velopment.info/da­ta/Programmin­g/java/miscella­neous_java/Usin­g_javap.html
10. Examine class files with the javap command
    http://www.techre­public.com/ar­ticle/examine-class-files-with-the-javap-command/5815354
11. BCEL Home page
    http://common­s.apache.org/bcel/
12. BCEL Manual
    http://common­s.apache.org/bcel/ma­nual.html
13. Byte Code Engineering Library (Wikipedia)
    http://en.wiki­pedia.org/wiki/BCEL
14. Java programming dynamics, Part 7: Bytecode engineering with BCEL
    http://www.ib­m.com/developer­works/java/li­brary/j-dyn0414/
15. Bytecode Engineering
    http://book.chi­naunix.net/spe­cial/ebook/Co­re_Java2_Volu­me2AF/0131118269/ch13lev­1sec6.html
16. BCEL Tutorial
    http://www.smfsup­port.com/suppor­t/java/bcel-tutorial!/
17. ASM Home page
    http://asm.ow2­.org/
18. Seznam nástrojů využívajících projekt ASM
    http://asm.ow2­.org/users.html
19. ObjectWeb ASM (Wikipedia)
    http://en.wiki­pedia.org/wiki/Ob­jectWeb_ASM
20. Java Bytecode BCEL vs ASM
    http://james.o­negoodcookie.com/2005/10­/26/java-bytecode-bcel-vs-asm/
21. Bytecode Outline plugin for Eclipse (screenshoty + info)
    http://asm.ow2­.org/eclipse/in­dex.html
22. aspectj (Eclipse)
    http://www.eclip­se.org/aspectj/
23. Aspect-oriented programming (Wikipedia)
    http://en.wiki­pedia.org/wiki/As­pect_oriented_pro­gramming
24. AspectJ (Wikipedia)
    http://en.wiki­pedia.org/wiki/As­pectJ
25. EMMA: a free Java code coverage tool
    http://emma.sou­rceforge.net/
26. Cobertura
    http://cobertu­ra.sourceforge­.net/
27. FindBugs
    http://findbug­s.sourceforge­.net/
28. GNU Classpath
    www.gnu.org/s/clas­spath/
29. Java VMs Compared
    http://bugblog­ger.com/java-vms-compared-160/
30. JSRs: Java Specification Requests – JSR 223: Scripting for the Java Platform
    http://www.jcp­.org/en/jsr/de­tail?id=223
31. Scripting for the Java Platform
    http://java.sun­.com/developer/techni­calArticles/J2SE/Des­ktop/scriptin­g/
32. Scripting for the Java Platform (Wikipedia)
    http://en.wiki­pedia.org/wiki/Scrip­ting_for_the_Ja­va_Platform
33. Java Community Process
    http://en.wiki­pedia.org/wiki/Ja­va_Specificati­on_Request
34. Java HotSpot VM Options
    http://www.ora­cle.com/technet­work/java/java­se/tech/vmopti­ons-jsp-140102.html
35. Great Computer Language Shootout
    http://c2.com/cgi/wi­ki?GreatCompu­terLanguageSho­otout
36. Java performance
    http://en.wiki­pedia.org/wiki/Ja­va_performance
37. Trying the prototype
    http://mail.o­penjdk.java.net/pi­permail/lambda-dev/2010-August/002179.html
38. Better closures (for Java)
    http://blogs.sun­.com/jrose/en­try/better_clo­sures
39. Lambdas in Java: An In-Depth Analysis
    http://www.in­foq.com/articles/lam­bdas-java-analysis
40. Class ReflectiveOpe­rationExcepti­on
    http://downlo­ad.java.net/jdk7/doc­s/api/java/lan­g/ReflectiveO­perationExcep­tion.html
41. Proposal: Indexing access syntax for Lists and Maps
    http://mail.o­penjdk.java.net/pi­permail/coin-dev/2009-March/001108.html
42. Proposal: Elvis and Other Null-Safe Operators
    http://mail.o­penjdk.java.net/pi­permail/coin-dev/2009-March/000047.html
43. Java 7 : Oracle pushes a first version of closures
    http://www.bap­tiste-wicht.com/2010/05­/oracle-pushes-a-first-version-of-closures/
44. Groovy: An agile dynamic language for the Java Platform
    http://groovy­.codehaus.org/O­perators
45. Better Strategies for Null Handling in Java
    http://www.sli­deshare.net/Step­han.Schmidt/bet­ter-strategies-for-null-handling-in-java
46. Control Flow in the Java Virtual Machine
    http://www.ar­tima.com/under­thehood/flowP­.html
47. Java Virtual Machine
    http://en.wiki­pedia.org/wiki/Ja­va_virtual_machi­ne
48. ==, .equals(), compareTo(), and compare()
    http://leepoin­t.net/notes-java/data/expres­sions/22compa­reobjects.html
49. New JDK7 features
    http://openjdk­.java.net/pro­jects/jdk7/fe­atures/
50. Project Coin: Bringing it to a Close(able)
    http://blogs.sun­.com/darcy/en­try/project_co­in_bring_close
51. CloseableFinder source code
    http://blogs.sun­.com/darcy/re­source/Projec­tCoin/Closeable­Finder.java
52. Joe Darcy blog about JDK
    http://blogs.sun­.com/darcy
53. Java 7 – more dynamics
    http://www.bap­tiste-wicht.com/2010/04­/java-7-more-dynamics/
54. New JDK 7 Feature: Support for Dynamically Typed Languages in the Java Virtual Machine
    http://java.sun­.com/developer/techni­calArticles/Dyn­TypeLang/index­.html