Dnes se společně již potřetí vrátíme ke struktuře bajtkódu, tj. k souborům s koncovkou .class. Řekneme si, jakým způsobem jsou v bajtkódu uloženy další důležité informace: příznaky třídy či rozhraní, jméno implementované třídy, jméno nadtřídy a konečně i seznam všech implementovaných rozhraní.
1. Pohled pod kapotu JVM (3.část – pokračování popisu struktury souborů .class)
2. Definice příznaků třídy či rozhraní
4. Jméno třídy/rozhraní/výčtu/anotace a jméno nadřazené třídy
5. Jména tříd a nadřazených tříd u vybraných souborů .class pocházejících z balíčku java.lang
6. Seznam implementovaných rozhraní
V předchozích dvou částech seriálu o programovacím jazyce Java i o vlastnostech virtuálního stroje tohoto jazyka jsme si podrobně popsali strukturu constant poolu, jenž tvoří nedílnou součást každého bajtkódu, tj. každého souboru s koncovkou .class generovaného překladačem Javy (většinou programem javac). Pro výpis obsahu constant poolu byl použit relativně jednoduchý nástroj naprogramovaný v céčku, který budeme v dnešním článku postupně rozšiřovat. Připomeňme si, že v constant poolu jsou umístěny všechny řetězcové konstanty (literály), celočíselné i reálné konstanty, jména tříd, signatury metod a konečně i signatury atributů. Signatura metody se skládá z jejího jména, zakódovaného návratového typu i zakódovaných typů všech argumentů metody. U signatury atributu je vedle jeho jména uložen (opět v zakódované podobě) i jeho datový typ. V dnešním článku si alespoň zhruba popíšeme další údaje, které je možné v souborech .class nalézt.
Celkovou strukturu bajtkódu jsme si již popsali. Z minula již víme, co obsahuje hlavička souborů .class a známe i způsob uložení informací v constant poolu. Další údaje v bajtkódu jsou však neméně důležité. Jedná se především o příznaky třídy či rozhraní, informace o jméně třídy i nadtřídy, seznam implementovaných rozhraní, atributy třídy a konečně i o nejdůležitější typ údajů – instrukce tvořící těla jednotlivých metod:
+-----------------------------------+ | Hlavička | +-----------------------------------+ | Constant pool | | ..... | | ..... | | ..... | +-----------------------------------+ | Definice příznaků třídy/rozhraní | +-----------------------------------+ | Jméno třídy a nadtřídy | +-----------------------------------+ | Implementovaná rozhraní | | ..... | +-----------------------------------+ | Atributy třídy | | ..... | +-----------------------------------+ | Kódy jednotlivých metod | | ..... | | ..... | | ..... | +-----------------------------------+ | Další metadata třídy | +-----------------------------------+
Pojďme si tedy podrobněji popsat další údaje, z nichž je sestaven každý javovský bajtkód. Ihned za posledním záznamem uloženým v constant poolu se nachází další důležitá informace. Jedná se o příznaky přiřazené ke třídě, k výčtovému typu, k rozhraní či k anotaci, z níž soubor .class vznikl. Všechny tyto příznaky jsou společně zakódované ve dvojici bajtů, jejichž pořadí opět (stejně jako u jiných typů záznamů v bajtkódu) odpovídá pořadí big endian. V následující tabulce jsou vypsány všechny příznaky, s nimiž se můžeme setkat v různých verzích bajtkódu. Prvních pět příznaků se používá již od prvních verzí JVM, další příznaky byly postupně přidávány s tím, jak se rozšiřovala syntaxe a samozřejmě i sémantika programovacího jazyka Java. Jedná se především o příznak ACC_ANNOTATION, který se objevil společně s anotacemi (Java 5) a taktéž o příznak ACC_ENUM označující výčtový typ (enumeration):
| # | Jméno příznaku | Bitová maska | Význam příznaku |
|---|---|---|---|
| 1 | ACC_PUBLIC | 0×0001 | veřejná třída či rozhraní |
| 2 | ACC_FINAL | 0×0010 | finální třída (nelze z ní vytvářet další odvozené třídy) |
| 3 | ACC_SUPER | 0×0020 | mění význam volání metod nadtřídy pomocí instrukce invokespecial |
| 4 | ACC_INTERFACE | 0×0200 | příznak označující, že se jedná o rozhraní |
| 5 | ACC_ABSTRACT | 0×0400 | abstraktní třída (nelze vytvořit její přímou instanci) |
| 6 | ACC_SYNTHETIC | 0×1000 | obvykle se jedná o třídu generovanou přímo překladačem (neexistuje k ní zdrojový kód) |
| 7 | ACC_ANNOTATION | 0×2000 | jedná se o anotaci |
| 8 | ACC_ENUM | 0×4000 | jedná se o výčet |
Vzhledem ke vztahu mezi výše popsanými příznaky a sémantikou programovacího jazyka Java je zřejmé, že zdaleka ne všechny kombinace příznaků jsou korektní. Například platí, že příznak ACC_INTERFACE by měl být použit společně s příznakem ACC_ABSTRACT. Podobně platí, že pokud se jedná o anotaci, tj. je nastaven příznak ACC_ANNOTATION, měl by být společně nastaven příznak ACC_INTERFACE. Taktéž je pochopitelné, že příznaky ACC_FINAL a ACC_ABSTRACT nesmí být nastaveny společně – nelze totiž vytvořit finální a současně i abstraktní třídu. Speciální význam má příznak ACC_SUPER, který mění význam instrukce invokespecial. O významu této instrukce se zmíníme v následující části tohoto seriálu.
Přidání výpisu příznaků třídy, rozhraní, anotace či výčtu do pomocného nástroje popsaného v předchozí části tohoto seriálu je velmi snadné, protože postačuje ihned po zpracování constant poolu přečíst z bajtkódu dvojici bajtů nacházejících se za posledním záznamem uloženým v constant poolu a následně správně interpretovat jednotlivé bity uložené v této dvojici bajtů. Do programu tedy stačí doplnit jeden výčet (skupinu celočíselných konstant) a jednu novou funkci:
/*
* Priznaky tridy ci rozhrani.
*/
enum
{
ACC_PUBLIC = 0x0001, /* verejna trida/rozhrani */
ACC_FINAL = 0x0010, /* finalni trida */
ACC_SUPER = 0x0020, /* semantika instrukce invokespecial */
ACC_INTERFACE = 0x0200, /* rozliseni trida/rozhrani */
ACC_ABSTRACT = 0x0400, /* abstraktni trida */
ACC_SYNTHETIC = 0x1000, /* synteticka trida */
ACC_ANNOTATION = 0x2000, /* anotace */
ACC_ENUM = 0x4000, /* vycet */
};
Tyto konstanty jsou použity v nové funkci process_class_flags:
/*
* Nacteni a vypis atributu tridy ci rozhrani.
*/
void process_class_flags(FILE *fin)
{
uint16_t flags;
flags = read_two_bytes(fin);
printf("\nClass/interface attributes: 0x%04x\n", flags);
if (flags & ACC_PUBLIC) puts(" ACC_PUBLIC");
if (flags & ACC_FINAL) puts(" ACC_FINAL");
if (flags & ACC_SUPER) puts(" ACC_SUPER");
if (flags & ACC_INTERFACE) puts(" ACC_INTERFACE");
if (flags & ACC_ABSTRACT) puts(" ACC_ABSTRACT");
if (flags & ACC_SYNTHETIC) puts(" ACC_SYNTHETIC");
if (flags & ACC_ANNOTATION) puts(" ACC_ANNOTATION");
if (flags & ACC_ENUM) puts(" ACC_ENUM");
}
Zdrojový text tímto způsobem upraveného dekompileru souborů .class můžete nalézt zde, popř. si můžete prohlédnout i zdrojový kód se zvýrazněnou syntaxí.
Ukažme si nyní výpis příznaků pro standardní .class soubory získané z archivu rt.jar, který většinou můžete nalézt v adresáři /usr/lib/jvm/java***/jre/lib. Připomeňme si, že v archivu rt.jar se nachází všechny třídy tvořící standardní API Javy:
java.lang.Object:
Class/interface attributes: 0x0021
ACC_PUBLIC
ACC_SUPER
java.lang.String:
Class/interface attributes: 0x0031
ACC_PUBLIC
ACC_FINAL
ACC_SUPER
java.lang.Number:
Class/interface attributes: 0x0421
ACC_PUBLIC
ACC_SUPER
ACC_ABSTRACT
java.lang.Integer:
Class/interface attributes: 0x0031
ACC_PUBLIC
ACC_FINAL
ACC_SUPER
java.lang.Comparable:
Class/interface attributes: 0x0601
ACC_PUBLIC
ACC_INTERFACE
ACC_ABSTRACT
java.lang.Override:
Class/interface attributes: 0x2601
ACC_PUBLIC
ACC_INTERFACE
ACC_ABSTRACT
ACC_ANNOTATION
java.lang.Exception:
Class/interface attributes: 0x0021
ACC_PUBLIC
ACC_SUPER
java.lang.NullPointerException:
Class/interface attributes: 0x0021
ACC_PUBLIC
ACC_SUPER
java.lang.Class:
Class/interface attributes: 0x0031
ACC_PUBLIC
ACC_FINAL
ACC_SUPER
Ihned za dvojicí bajtů, v nichž jsou uloženy příznaky třídy, výčtu, rozhraní či anotace, se nachází další důležitý údaj. Tento údaj reprezentuje jméno třídy, rozhraní, anotace či výčtu, ke které přísluší daný soubor .class. Ve skutečnosti však na tomto místě bajtkódu není uložen přímo řetězec s názvem příslušného jazykového prvku, ale pouze dvoubajtový odkaz na záznam umístěný v constant poolu. Musí se přitom vždy jednat o odkaz na záznam typu CONSTANT_Class, což je samozřejmě náležitě kontrolováno již při načítání bajtkódu do virtuálního stroje Javy. Připomeňme si, že záznam typu CONSTANT_Class obsahuje odkaz (index) na záznam typu CONSTANT_Utf8, který již obsahuje kýženou řetězcovou konstantu (literál) se jménem třídy. Poznamenejme, že jméno třídy je uvedeno v plné podobě, tj. i se jménem balíčku, v němž se třída nachází. Pro oddělení jednotlivých částí „cesty“ ke třídě je použit znak lomítka, který lze pro účely tisku změnit na znak tečky.
Velmi podobný význam má i další dvojice bajtů uložená v bajtkódu. Tento údaj obsahuje informaci o jménu nadřazené třídy (super class) a opět se musí jednat o index do constant poolu, jenž odkazuje na záznam typu CONSTANT_Class (není snad nutné připomínat, že při načítání bajtkódu je jeho korektnost opět kontrolována). Mezi oběma zmíněnými názvy je však jeden rozdíl – zatímco název třídy musí být vždy korektně vyplněn, v případě názvu nadřazené třídy je možné, aby tento údaj obsahoval nulu, ovšem pouze v tom speciálním případě, že bajtkód byl získán překladem třídy Object, která nemá žádnou nadtřídu, což vyplývá ze samotné specifikace programovacího jazyka Java. Ostatní třídy, včetně tříd bez explicitně specifikované nadtřídy, mají tento údaj vyplněn.
Úprava našeho demonstračního dekompileru bajtkódu takovým způsobem, aby dokázal zobrazit jméno třídy (atributu, výčtu…) a jméno příslušné nadtřídy, není vůbec složitá, neboť postačuje načíst obě dvojice bajtů a následně je použít jako indexy do constant poolu, jehož obsah je uložen v poli pool_entries. Funkce pro výpis jména třídy (či jiného jazykového prvku) vypadá následovně:
/*
* Nacteni a vypis jmena tridy.
*/
void process_class_name(FILE *fin)
{
/* nacist index z bajtkodu */
uint16_t index = read_two_bytes(fin);
/* v cecku se indexuje od 0, v constant poolu od 1 */
index--;
printf("\nClass name is stored in constant pool #%d\n", index);
PoolEntry pool_entry = pool_entries[index];
print_class_info(&pool_entry);
}
Výpis jména nadřazené třídy je nepatrně složitější, neboť je zapotřebí detekovat speciální případ třídy Object:
/*
* Nacteni a vypis jmena nadrazene tridy.
*/
void process_superclass_name(FILE *fin)
{
/* nacist index z bajtkodu */
uint16_t index = read_two_bytes(fin);
/* test na specialni pripad */
if (index == 0)
{
printf("\nIt's a class without super class!\n");
}
else
{
/* v cecku se indexuje od 0, v constant poolu od 1 */
index--;
printf("\nSuper class name is stored in constant pool #%d\n", index);
PoolEntry pool_entry = pool_entries[index];
print_class_info(&pool_entry);
}
}
Zdrojový text třetí verze demonstračního dekompileru souborů .class můžete nalézt zde, popř. si můžete prohlédnout i zdrojový kód se zvýrazněnou syntaxí.
Opět si můžeme vyzkoušet, jaké údaje získáme analýzou .class souborů ze standardního balíčku java.lang:
java.lang.Object:
Class name is stored in constant pool #17 Class 74 java/lang/Object It's a class without super class!
java.lang.String:
Class name is stored in constant pool #39 Class 414 java/lang/String Super class name is stored in constant pool #116 Class 493 java/lang/Object
java.lang.Number:
Class name is stored in constant pool #2 Class 34 java/lang/Number Super class name is stored in constant pool #3 Class 35 java/lang/Object
java.lang.Integer:
Class name is stored in constant pool #32 Class 231 java/lang/Integer Super class name is stored in constant pool #69 Class 258 java/lang/Number
java.lang.Comparable:
Class name is stored in constant pool #0 Class 10 java/lang/Comparable Super class name is stored in constant pool #1 Class 11 java/lang/Object
java.lang.Override:
Class name is stored in constant pool #0 Class 14 java/lang/Override Super class name is stored in constant pool #1 Class 15 java/lang/Object
java.lang.Exception:
Class name is stored in constant pool #4 Class 32 java/lang/Exception Super class name is stored in constant pool #5 Class 33 java/lang/Throwable
java.lang.NullPointerException:
Class name is stored in constant pool #2 Class 19 java/lang/NullPointerException Super class name is stored in constant pool #3 Class 20 java/lang/RuntimeException
java.lang.Class:
Class name is stored in constant pool #26 Class 681 java/lang/Class Super class name is stored in constant pool #237 Class 882 java/lang/Object
Pokud pro jednoduchost nebudeme brát do úvahy implementovaná rozhraní, lze celou objektovou hierarchii všech tříd zrekonstruovat pomocí dvojice údajů popsaných v předchozích odstavcích.
Z informací, které jsme až doposud z bajtkódu získali, je již možné částečně zrekonstruovat hlavičku libovolné třídy, protože již známe její příznaky (public, abstract, final atd.) a samozřejmě i její plné jméno i jméno nadřazené třídy (včetně uvedení balíčku). Ovšem ve skutečnosti může třída implementovat i libovolný počet rozhraní, což je další informace, kterou je nutné nějakým způsobem přečíst z bajtkódu. To je ve skutečnosti velmi jednoduché, neboť ihned za dvojicí indexů odkazujících na jméno třídy a nadřazené třídy se v bajtkódu nachází šestnáctibitové slovo s počtem všech implementovaných rozhraní (čistě teoreticky jich tedy může být až 65535) a ihned za tímto údajem se nachází n šestnáctibitových indexů do constant poolu, kde n odpovídá počtu implementovaných rozhraní (toto pole indexů může samozřejmě být i prázdné, pokud třída žádné rozhraní neimplementuje, tj. n==0). Podobně jako u jména třídy i jména nadtřídy, musí každý index v poli s rozhraními odkazovat na záznam typu CONSTANT_Class, který sám obsahuje odkaz na záznam typu CONSTANT_Utf8, tj. na vlastní řetězec se jménem rozhraní.
Doplnění našeho demonstračního dekompileru bajtkódu o výpis všech implementovaných rozhraní je obstaráno funkcí process_all_implemented_interfaces(), kterou je nutné zavolat ihned po funkci process_superclass_name() (přesněji řečeno se nemusí tyto funkce volat ihned po sobě, mezi voláním těchto funkcí však nesmí dojít ke čtení údajů z bajtkódu, protože by došlo k posunu interně udržovaného offsetu posledně načteného bajtu). Funkce process_all_implemented_interfaces je velmi jednoduchá – pouze přečte počet indexů v tabulce implementovaných rozhraní a posléze celou tabulku zpracuje a vytiskne příslušné referencované hodnoty získané z constant poolu:
/*
* Nacteni a vypis vsech implementovanych rozhrani
*/
void process_all_implemented_interfaces(FILE *fin)
{
int i;
/* nacist pocet implementovanych rozhrani */
uint16_t interfaces = read_two_bytes(fin);
/* zakladni informace pro uzivatele */
printf("\nNumber of implemented interfaces: %d\n", interfaces);
/* vypis vsech rozhrani */
for (i = 0; i < interfaces; i++)
{
/* nacist index do constant poolu */
int index = read_two_bytes(fin);
/* v cecku se indexuje od 0, v constant poolu od 1 */
index--;
/* ziskat a vypsat pozadovanou informaci */
PoolEntry pool_entry = pool_entries[index];
print_class_info(&pool_entry);
putchar('\n');
}
}
Zdrojový text již čtvrté varianty dekompileru souborů .class můžete nalézt zde, popř. si můžete prohlédnout i zdrojový kód se zvýrazněnou syntaxí.
S využitím prozatím finální verze demonstračního dekompileru bajtkódu je možné snadno zjistit seznam všech rozhraní implementovaných vybranými třídami ze standardního balíčku java.lang:
java.lang.Object:
Number of implemented interfaces: 0
java.lang.String:
Number of implemented interfaces: 3 Class 494 java/io/Serializable Class 495 java/lang/Comparable Class 496 java/lang/CharSequence
java.lang.Number:
Number of implemented interfaces: 1 Class 36 java/io/Serializable
java.lang.Integer:
Number of implemented interfaces: 1 Class 259 java/lang/Comparable
java.lang.Comparable:
Number of implemented interfaces: 0
java.lang.Override:
Number of implemented interfaces: 1 Class 16 java/lang/annotation/Annotation
java.lang.Exception:
Number of implemented interfaces: 0
java.lang.NullPointerException:
Number of implemented interfaces: 0
java.lang.Class:
Number of implemented interfaces: 4 Class 923 java/io/Serializable Class 924 java/lang/reflect/GenericDeclaration Class 925 java/lang/reflect/Type Class 926 java/lang/reflect/AnnotatedElement
