Die Architektur der Java VM

Jan Bernitt

Virtualisierungsziele

Portabilität
Bytecode plattform- / betriebssystemunabhängig
Flexibilität
Metaprogrammiertechniken möglich
Effizienz
Optimale Nutzung der Ressourcen (CPU/ASP)
Kompaktheit
Kompakter Bytecode
Sicherheit
Validierung des Bytecode möglich
Interoperabilität
"Verbindung" von/zu vielen Programmiersprachen möglich

Java Laufzeit-System
Java Runtime Environment (JRE)

Java Virtual Maschine (JVM)

Application and Programming Interface (API)

java.lang
Object, Class, String, System, Thread

Selbstreflexion: java.lang.reflect

Soft-, Weak-Referenzen: java.lang.ref

Wrapperklassen: Byte, Short, Integer, Long, Float, Double, Character
java.util
Datenstrukturen, Zeitangaben und Internationalisierung
java.io
Ein- Ausgabe von Daten(-stömen) - "Streams"

Die Java VM

Stack-Maschine
Kompakter Bytecode
Primitive Typen:
int, long, float, double

boolean, byte, short, char (werden als int verarbeitet)

returnAddress für Unterprogramme
Referenz-Typ:
reference für Klassen, Interfaces, Aufzählungen, Arrays
Schnittstelle zu nativen Bibliotheken
Java Native Interface (JNI)
Felder und Methoden
Konstruktoren ?

Java `ClassLoader`

JVM (Execution Engine)

erfragt unbekannte Klasse

SystemClassLoader

nicht gefunden: delegiert an

ExtendsionClassLoader

nicht gefunden: delegiert an

BootStrapClassLoader

löst aus: ClassNotFoundException

1 Namensraum / ClassLoader
UserClassLoader möglich

Ziel:

Sicherheit
Performance
Flexibilität

Automatische Speicherverwaltung
Garbage Collection

Strategien:

Reference Counting
Mark and Sweep

GC aus Sicht des Programmierers

GC unvorhersehbar
Echtzeit daher schwierig
Nicht mehr benötigte Referenzen null setzen!
Soft- Weak-Referenzen einsetzen

Execution-Engine
"virtueller Prozessor"

Funktionsweise: ...später im Detail

Optimierungen:

Just-In-Time Compiler (JIT)
Einmaliges Übersetzen in nativen Code

Erzeugt besseren nativen Code als AOT
Bytecode-Compiler (HotSpot)
Optimierung nach und nach

Erreicht native Ausführungsgeschwindigkeit

Das `.class`-Dateiformat
`ClassFile`-Tabelle

magic = 0xCAFEBABE

minor_version

major_version

constant_pool_count

ConstantPool[]

access_flags

this_class

super_class

interface_count

interface_index[]

field_count

Field[]

method_count

Method[]

attribute_count

Attribute[]

2.1: Zugriffs- und Eigenschafts-Flags von Klassen
Name	Wert	Beschreibung
`ACC_PUBLIC`	`0x0001`	Klasse ist als `public` deklariert, daher Zugriff auch von außerhalb ihres Pakets erlaubt.
`ACC_FINAL`	`0x0010`	Klasse ist als `final` deklariert, keine Unterklassen erlaubt.
`ACC_SUPER`	`0x0020`	Besondere Behandlung für Methoden der Superklasse beim Aufruf über `invokespecial`.
`ACC_INTERFACE`	`0x0200`	`class`-File beschreibt ein Interface, keine Klasse. `ACC_ABSTRACT` erforderlich.
`ACC_ABSTRACT`	`0x0400`	Klasse ist als `abstract` deklariert, daher keine Instanziierung erlaubt.
`ACC_SYNTHETIC`	`0x1000`	Klasse ist vom Compiler generiert, im Quellcode nicht vorhanden.
`ACC_ANNOTATION`	`0x2000`	`class`-File beschreibt eine Annotation, keine Klasse. `ACC_INTERFACE` erforderlich.
`ACC_ENUM`	`0x4000`	Diese Klasse (oder ihre Superklasse) ist als Aufzählungstyp `enum` definiert.

Das `.class`-Dateiformat
`ConstantPool`-Tabelle

CONSTANT_Utf8: tag = 1

length

bytes[]
CONSTANT_Integer: tag = 3

bytes
CONSTANT_Float: tag = 4

bytes
CONSTANT_Long: tag = 5

high_bytes

low_bytes
CONSTANT_Double: tag = 6

high_bytes

low_bytes
CONSTANT_Class: tag = 7

name_index→1
CONSTANT_String: tag = 8

string_index→1
CONSTANT_Fieldref: tag = 9

class_index→7

name_type_index→12
CONSTANT_Methodref: tag = 10

class_index→7

name_type_index→12
CONSTANT_InterfaceMethodref: tag = 11

class_index→7

name_type_index→12
CONSTANT_NameAndType: tag = 12

name_index→1

descriptor_index→1

Namen und Typen innerhalb der JVM

Voll qualifizierte Klassennamen
java/lang/String

Array-Namen von JVM erzeugt, z.B: [I
Einfache Feld- und Methodennamen
exampleMethode

FINAL_STATIC_FIELD

Initialisierungsmethoden: <init>, <clinit>

Das `.class`-Dateiformat
`Field` und `Method`-Tabelle

access_flags

name_index→1

descriptor_index→1

attributes_count

Attribute[]

7.1: Zugriffs- und Eigenschafts-Flags von Feldern
Name	Wert	Beschreibung
`ACC_PUBLIC`	`0x0001`	Feld ist als `public` deklariert, daher Zugriff auch von außerhalb des Pakets erlaubt.
`ACC_PRIVATE`	`0x0002`	Feld ist als `private` deklariert, daher Zugriff nur in der definierenden Klasse.
`ACC_PROTECTED`	`0x0004`	Feld ist als `protected` deklariert, daher Zugriff auch in Unterklassen der definierenden Klasse.
`ACC_STATIC`	`0x0008`	Feld ist als `static` deklariert, also eine Klassenvariable (ohne) oder Konstante (mit) `ACC_FINAL`.
`ACC_FINAL`	`0x0010`	Feld ist als `final` deklariert, daher keine weitere Zuweisung nach Initalisierung möglich.
`ACC_VOLATILE`	`0x0040`	Feld ist als `volatile` deklariert, daher kein cachen des Werts möglich.
`ACC_TRANSIENT`	`0x0080`	Feld ist als `transient` deklariert, daher kein lesender oder schreibender Zugriff vom `PersistentObjectManager`.
`ACC_SYNTHETIC`	`0x1000`	Feld ist vom Compiler generiert, im Quellcode nicht vorhanden.
`ACC_ENUM`	`0x4000`	Feld wird verwendet, um einen Wert eines Aufzählungstyp zu speichern.

7.2: Zugriffs- und Eigenschafts-Flags von Methoden
Name	Wert	Beschreibung
`ACC_PUBLIC`	`0x0001`	Methode ist als `public` deklariert, daher Aufruf auch von außerhalb des Pakets erlaubt.
`ACC_PRIVATE`	`0x0002`	Methode ist als `private` deklariert, daher Aufruf nur in der definierenden Klasse möglich.
`ACC_PROTECTED`	`0x0004`	Methode ist als `protected` deklariert, daher Aufruf auch in Unterklassen der definierenden Klasse erlaubt.
`ACC_STATIC`	`0x0008`	Methode ist als `static` deklariert, also eine Klassenmethode.
`ACC_FINAL`	`0x0010`	Methode ist als `final` deklariert, kann nicht überschrieben werden.
`ACC_SYNCHRONIZED`	`0x0020`	Methode ist als `synchronized` deklariert, daher Aufruf über einen Monitor.
`ACC_BRIDGE`	`0x0040`	Methode wurde als Bridge-Methode (Type Erasure) vom Compiler erzeugt.
`ACC_VARARGS`	`0x0080`	Methode wurde im Quellcode mit variabler Parameteranzahl deklariert.
`ACC_NATIVE`	`0x0100`	Methode ist als `native` deklariert, wird daher in einer anderen Sprache als Java-`Bytecode` implementiert.
`ACC_ABSTRACT`	`0x0400`	Methode ist als `abstract` deklariert, besitzt daher keine Implementierung.
`ACC_STRICT`	`0x0800`	Methode ist als `strictfp` deklariert, verwendet daher den Gleitkomma-Modus FP-strict.
`ACC_SYNTHETIC`	`0x1000`	Methode ist vom Compiler generiert, im Quellcode nicht vorhanden.

Descriptoren und Signaturen

Descriptoren:

Typbeschreibung nach Type Erasure
Methoden / Felder
Immer schon ein essentieller Teil der VM
Als Feld descriptor in Method- und Field-Tabelle

Dynamisches Linken

Signaturen:

Typbeschreibung vor Type Erasure
Klassen / Methoden / Felder
Indirekt durch Generics zum Teil der VM geworden
Als Attribut Signature in ClassFile-, Method- und Field-Tabelle

Reflexion

5.1: Bedeutung der `BaseType`-Zeichen
`BaseType`-Zeichen	Typ	Bedeutung
`B`	`byte`	vorzeichenbehafteter Bytewert
`C`	`char`	Unicode-Zeichen
`D`	`double`	Fließkommawert mit doppelter Genaigkeit
`F`	`float`	Fließkommawert mit einfacher Genauigkeit
`I`	`int`	vorzeichenbehafteter Integerwert
`J`	`long`	vorzeichenbehafteter Longwert
`LClassname;`	`reference`	Eine Instanz der Klasse Classname
`S`	`short`	vorzeichenbehafteter Shortwert
`V`	`void`	entspricht dem Rückgabewert `void`
`Z`	`boolean`	`true` oder `false`
`[`	`reference`	Eine Array-Dimension

Attribute und Annotations

Attribute:

"Zusatzinformation" im Bytecode
für Klassen / Felder / Methoden / Attribute
Unverzichtbarer Bestandteil von .class-Dateien
Aufbau:
Name → Wert - Paare

name_index→1

length

info[]

Annotations:

"Zusatzinformation" in der Java-Sprache (.java)
für Klassen / Felder / Methoden / Parameter / lokale Variablen
Optionaler Bestandteil der Sprache Java
mehr Möglichkeiten für den Programmierer

Aufbau:

Interface mit Methoden als konstantes Feld

@Retention(RetentionPolicy.RUNTIME) 
@Target(ElementType.METHOD)               
public @interface RuntimeComplexity {
	enum Complexity { On, On2, O1 };
	Complexity complexity();          
	String     hint() default "";
}

Das `.class`-Dateiformat
Das `Code`-Attribut

name_index→1

length

max_stack

max_locals

code_length

code

exceptions_count

Exception[]

attributes_count

Attribute[]

Die `Exception-Tabelle`

start_pc

end_pc

handler_pc

catch_type→7

Das `.class`-Dateiformat
Einfache Attribute

Synthetic: name_index→1

length = 0
Deprecated: name_index→1

length = 0
Signature: name_index→1

length = 2

signature_index→1
SourceFile: name_index→1

length = 2

sourcefile_index→1
ConstantValue: name_index→1

length = 2

constant_value_index

9.1: Attribut `ConstantValue` Typen-Index
attributierter Feld-Typ	`constant_value_index`→RCP-Eintrag
`long`	`CONSTANT_Long →5`
`float`	`CONSTANT_Float →4`
`double`	`CONSTANT_Double →6`
`int,short,char,byte,boolean`	`CONSTANT_Integer →3`
`String`	`CONSTANT_String →8`

Befehlssatz des `Bytecode`s (1)

Load & Store

Stack-Maipulation:
pop, dup, swap
Lokale Variablen → Stack / Stack → lokale Variable
Array-Element → Stack / Stack → Array-Element
und Array-Länge → Stack
Feld → Stack / Stack → Feld
Konstante (CP) → Stack
auch hoher Index mit wide
Objekt-und Array Instanziierung

Arithmetik

Grundrechenarten:
Negation, Addition, Subtraktion, Multiplikation, Division, Rest
Bitmnipulationen:
AND, OR, XOR, Shift
Vergleich:
long, float, double gegen 0

Kontrolltransfer:

Typkonversion, Typüberprüfung (Casts, instanceof)
Bedingte Sprunganweisungen:
int auf <, <=, =, >, >= sowie switches

reference auf = null, != null, =
Unbedingte Sprunganweisungen, Unterprogramme
Methodenaufruf und Rückgabewerte
Exceptions auslösen

Befehlssatz des `Bytecode`s (2)

Verwendung	Opcode Mnemonics
Daten-OPs "Load & Store"	Stack ⇔ Stack	nop, pop, pop2, dup, dup_x1, dup_x2, dup2, dup2_x1, dup2_x2, swap
Konstante ⇒ Stack	aconst_null, iconst_<n> (iconst_m1, iconst_0, iconst_1, iconst_2, iconst_3, iconst_4, iconst_5), lconst_<n> (lconst_0, lconst_1), fconst_<n> (fconst_0, fconst_1, fconst_2), dconst_<n> (dconst_0, dconst_1) bipush, sipush, ldc, ldc_w, ldc2_w,
Variable ⇒ Stack	iload, iload_<n> (iload_0, iload_1, iload_2, iload_3) lload, lload_<n> (lload_0, lload_1, lload_2, lload_3) fload, fload_<n> (fload_0, fload_1, fload_2, fload_3) dload, dload_<n> (dload_0, dload_1, dload_2, dload_3) aload, aload_<n> (aload_0, aload_1, aload_2, aload_3)
Stack ⇒ Variable	istore, istore_<n> (istore_0, istore_1, istore_2, istore_3) lstore, lstore_<n> (lstore_0, lstore_1, lstore_2, lstore_3) fstore, fstore_<n> (fstore_0, fstore_1, fstore_2, fstore_3) dstore, dstore_<n> (dstore_0, dstore_1, dstore_2, dstore_3) astore, astore_<n> (astore_0, astore_1, astore_2, astore_3)
Arraywert ⇒ Stack	iaload, laload, faload, daload, aaload, baload, caload, saload
Stack ⇒ Arraywert	iastore, lastore, fastore, dastore, aastore, bastore, castore, sastore
Variablen	iinc, wide
Arrays	newarray, anewarray, arraylength, multianewarray
Objekte	getstatic, putstatic, getfield, putfield, new, checkcast, instanceof

Verwendung

Opcode Mnemonics

Daten-OPs
"Load & Store"

Stack ⇔ Stack

nop, pop, pop2, dup, dup_x1, dup_x2, dup2, dup2_x1, dup2_x2, swap

Konstante ⇒ Stack

aconst_null,
iconst_<n> (iconst_m1, iconst_0, iconst_1, iconst_2, iconst_3, iconst_4, iconst_5),
lconst_<n> (lconst_0, lconst_1),
fconst_<n> (fconst_0, fconst_1, fconst_2),
dconst_<n> (dconst_0, dconst_1)
bipush, sipush, ldc, ldc_w, ldc2_w,

Variable ⇒ Stack

iload, iload_<n> (iload_0, iload_1, iload_2, iload_3)
lload, lload_<n> (lload_0, lload_1, lload_2, lload_3)
fload, fload_<n> (fload_0, fload_1, fload_2, fload_3)
dload, dload_<n> (dload_0, dload_1, dload_2, dload_3)
aload, aload_<n> (aload_0, aload_1, aload_2, aload_3)

Stack ⇒ Variable

istore, istore_<n> (istore_0, istore_1, istore_2, istore_3)
lstore, lstore_<n> (lstore_0, lstore_1, lstore_2, lstore_3)
fstore, fstore_<n> (fstore_0, fstore_1, fstore_2, fstore_3)
dstore, dstore_<n> (dstore_0, dstore_1, dstore_2, dstore_3)
astore, astore_<n> (astore_0, astore_1, astore_2, astore_3)

Arraywert ⇒ Stack

iaload, laload, faload, daload, aaload, baload, caload, saload

Stack ⇒ Arraywert

iastore, lastore, fastore, dastore, aastore, bastore, castore, sastore

Variablen

iinc, wide

Arrays

newarray, anewarray, arraylength, multianewarray

Objekte

getstatic, putstatic, getfield, putfield, new, checkcast, instanceof

Befehlssatz des `Bytecode`s (3)

Arithmetik "ALU"	Ganzzahlen	iadd, isub, imul, idiv, irem, ineg, ladd, lsub, lmul, ldiv, lrem, lneg
Gleitkomma	fadd, fsub, fmul, fdiv, frem, fneg, dadd, dsub, dmul, ddiv, drem, dneg
Bitweise	ishl, ishr, iushr, iand, ior, ixor, lshl, lshr, lushr, land, lor, lxor
Typumwandlung	i2l, i2f, i2d, i2b, i2c, i2s, l2i, l2f, l2d, f2i, f2l, f2d, d2i, d2l, d2f
Flusskontrolle	Sprünge	lcmp, fcmpl, fcmpg, dcmpl, dcmpg, ifeq, ifne, iflt, ifge, ifgt, ifle, if_icmpeq, if_icmpne, if_icmplt, if_icmpge, if_icmpgt, if_icmple, if_acmpeq, if_acmpne, ifnull, ifnonnull, goto, goto_w
Unterprogramme	jsr, ret, jsr_w
Tabellen	tableswitch, lookupswitch
Methoden	invokevirtual, invokespecial, invokestatic, invokeinterface, ireturn, lreturn, freturn, dreturn, areturn, return
Exceptions	athrow
Threads	monitorenter, monitorexit

Arithmetik
"ALU"

Ganzzahlen

iadd, isub, imul, idiv, irem, ineg,
ladd, lsub, lmul, ldiv, lrem, lneg

Gleitkomma

fadd, fsub, fmul, fdiv, frem, fneg,
dadd, dsub, dmul, ddiv, drem, dneg

Bitweise

ishl, ishr, iushr, iand, ior, ixor,
lshl, lshr, lushr, land, lor, lxor

Typumwandlung

i2l, i2f, i2d, i2b, i2c, i2s,
l2i, l2f, l2d,
f2i, f2l, f2d,
d2i, d2l, d2f

Flusskontrolle

Sprünge

lcmp, fcmpl, fcmpg, dcmpl, dcmpg,
ifeq, ifne, iflt, ifge, ifgt, ifle,
if_icmpeq, if_icmpne, if_icmplt, if_icmpge, if_icmpgt, if_icmple,
if_acmpeq, if_acmpne, ifnull, ifnonnull,
goto, goto_w

Unterprogramme

jsr, ret, jsr_w

Tabellen

tableswitch, lookupswitch

Methoden

invokevirtual, invokespecial, invokestatic, invokeinterface,
ireturn, lreturn, freturn, dreturn, areturn, return

Exceptions

athrow

Threads

monitorenter, monitorexit

JVM zur Laufzeit
Objekterzeugung - `new`

Java
```
...
new myClass(int i, Object o);
...
```

Bytecode

...
new #1            // uninitialisierten Speicher für myClass allozieren
dup               // Objekt-Referenz auf Stack verdoppeln
iload_1           // i auf Stack bringen
aload_2           // o auf Stack bringen
invokespecial #7  // myClass.<init> aufrufen
...

JVM zur Laufzeit
Feldzugriff

Java
```
...
this.value = this.otherValue;
...
```

Bytecode

...
aload_0           // Referenz this auf Stack
dup               // x 2
getfield #13      // Wert von otherValue auf Stack
putfield #6       // Wert vom Stack in value
...

JVM zur Laufzeit
Konstanten

Java

...
int x = 10000 + 1;
x += (int)200.5d;
...

Bytecode

...
aload_0           // Referenz this auf Stack
ldc #5            // 10000 aus CP laden und auf Stack
iconst_1          // 1 auf Stack
iadd              // 10000 + 1
putfield #7       // Wert vom Stack in x
aload_0           // wieder this auf Stack
ldc2_w #140       // 200.5 aus CP laden und auf Stack
d2i
putfield #7       // wieder Wert vom Stack in x
...

JVM zur Laufzeit
Klassen-Methoden (1)

Java (Klasse Example)

...
mulBy5(2);
...
int mulBy5(int v) { return Example.mul(v,5); }
static int mul(int l, inr r) { return l * r;  }

Bytecode

...
aload_0           // this auf Stack
iconst_2          // 2 auf Stack
invokevirtual #3  // Methode this.mulBy5(I)I aufrufen
...
iload_1           // v aus LV 1 auf Stack
iconst_5          // 5 auf Stack
invokestatic #9   // Methode Example.mul(II)I aufrufen
ireturn           // Ergebnis zurückgeben

iload_0           // l aus LV 0 auf Stack
iload_1           // r aus LV 1 auf Stack
imul
ireturn           // Ergebnis zurückgeben

JVM zur Laufzeit
Klassen-Methoden (2)

Java

class Near {
	Near(float value) { this.value = value; }
	float value;
	private float getValue() { return value }
	public float getValueNear() { return getValue() }
}
class Far {
	float getValueFar() { return super.getValueNear(); }
	Near getNear(float v) { return new Near(v); }
}

Bytecode

// Implementierung von getValueNear()F
aload_0
invokespecial #6  // Near.getValue()F aufrufen
freturn
// Implementierung von getValueFar()F
aload_0
invokespecial #5  // Near.getValueNear()F aufrufen
freturn
// Implementierung von Far.getNear(F)V
new #1            // neue Instanz von Near allozieren
dup
fload_1           // v auf Stack
invokespecial #4  // Methode Near.<init>(F)V
areturn           // neue Instanz zurückgeben

JVM zur Laufzeit
Interface-Methoden

Java

class MyList<E extends Comparable<E>> {
	E first;
	boolean isFirstElement(E e) {
		return this.first.compareTo(e) == 0;
	}
	...
}

Bytecode (isFirstElement)

 0:  aload_0
 1:  getfield        #23;    // Field first:Ljava/lang/Comparable;
 4:  aload_1
 5:  invokeinterface #25, 2; // InterfaceMethod java/lang/Comparable.
                             // compareTo:(Ljava/lang/Object;)I
10:  ifne    15              // bei != 0 zu Offest 15
13:  iconst_1
14:  ireturn
15:  iconst_0
16:  ireturn

JVM zur Laufzeit
Dynamisches Binden von Methoden

Vorbedingung:

Die durch den Befehl im CP referenzierte Methode M_CP kann aufgelöst werden.

Initalisierung:

invokespecial
- wird direkt ausgefüht, wenn:
  M_CP ist eine Initialisierungsmethode <init>(...).
  
  M_CP ist private.
- sonst gilt als Ausgangspunkt:
  C = direkte Superklasse der aktuellen Klasse (Frame).
invokevirtual, invokeinterface
- Ausgangspunkt:
  C = Klasse der Objekt-Instanz

Suche (Lookup-Algorithmus):

Enthält C Instanz-Methode M ≡ M_CP, wird M aufgerufen, sonst 2.
(nur invokevirtual: M muss für C zugreifbar sein)
Hat C eine Superklasse S, wird das Lookup rekursive für S ausgeführt, sonst AbstractMethodError.

JVM zur Laufzeit
Exception-Kontrolltransfer

Java

void nestedCatch() {
	try {
		try {
			tryThis();
		} catch (Exc1 e) {
			handle1();
		}
	} catch (Exc2 e) {
		handle2();
	}
}

Bytecode

void nestedCatch();
  Code:
   0:   aload_0
   1:   invokevirtual   #15; //Method tryThis:()V
   4:   goto    20
   7:   astore_1
   8:   aload_0
   9:   invokevirtual   #18; //Method handle1:()V
   12:  goto    20
   15:  astore_1
   16:  aload_0
   17:  invokevirtual   #21; //Method handle2:()V
   20:  return
  Exception table:
   from   to  target type
     0     4     7   Class Exc1
     0    12    15   Class Exc2

JVM zur Laufzeit
Unterprogramme

Befehle:

Aufruf: jsr, jsr_w
Rücksprung: ret

Ablauf:

Ausführen von jsr(_w):
Offest der nachfolgenden Anweisung wird als returnAddress auf OS gebracht

fortsetzen bei relativem Offest des jsr(_w)-Befehls (Unterprogramm)
Ausführen des Unterprogramms:
sichern der returnAddress in LV i

...Unterprogrammanweisungen...
Ausführen von ret:
schreiben der returnAddress aus LV i in PC des Threads

fortsetzen mit Befehl bei PC

Der `Bytecode`-Verifier

Aufgabe

Statische Validierung des Bytecodes

Erreicht:

Typsicherheit
nur gültige Sprünge und Speicherzugriffe

Bedingungen:

Sprüngen nur innerhalb des code-Arrays einer Methode
Sprungziel ist ein Opcode
Nur Zugriff auf lokale Variablen die auch existieren.
Im (R)CP referenzierte Elementen haben passende Typ
ldc → int, float, String

ldc2 → long, double

getfield, getstatic → Fieldref/Field
Das code-Array endet nicht mitten in einer Instruktion.
Ausführung kann nicht aus der Methode laufen.
return? vorhanden
Exception-Handler sind gültig:
start_pc, end_pc liegen innerhalb des code-Arrays

start_pc < end_pc

handler_index verweist auf Exception-Klasse
...

Bewertung

Portabilität ?
Flexibilität ?
Effizienz ?
Kompaktheit ?
Sicherheit ?
Interoperabilität ?

Die Architektur der Java VM

Jan Bernitt

Virtualisierungsziele

Java Laufzeit-SystemJava Runtime Environment (JRE)

Java Virtual Maschine (JVM)

Application and Programming Interface (API)

Die Java VM

Java ClassLoader

Ziel:

Automatische Speicherverwaltung Garbage Collection

Strategien:

GC aus Sicht des Programmierers

Execution-Engine "virtueller Prozessor"

Funktionsweise: ...später im Detail

Optimierungen:

Das .class-Dateiformat ClassFile-Tabelle

Das .class-Dateiformat ConstantPool-Tabelle

Namen und Typen innerhalb der JVM

Das .class-Dateiformat Field und Method-Tabelle

Descriptoren und Signaturen

Descriptoren:

Signaturen:

Attribute und Annotations

Attribute:

Annotations:

Das .class-Dateiformat Das Code-Attribut

Die Exception-Tabelle

Das .class-Dateiformat Einfache Attribute

Befehlssatz des Bytecodes (1)

Load & Store

Arithmetik

Kontrolltransfer:

Befehlssatz des Bytecodes (2)

Befehlssatz des Bytecodes (3)

JVM zur Laufzeit Objekterzeugung - new

JVM zur Laufzeit Feldzugriff

JVM zur Laufzeit Konstanten

JVM zur Laufzeit Klassen-Methoden (1)

JVM zur Laufzeit Klassen-Methoden (2)

JVM zur Laufzeit Interface-Methoden

JVM zur Laufzeit Dynamisches Binden von Methoden

Vorbedingung:

Initalisierung:

Suche (Lookup-Algorithmus):

JVM zur Laufzeit Exception-Kontrolltransfer

JVM zur Laufzeit Unterprogramme

Befehle:

Ablauf:

Der Bytecode-Verifier

Aufgabe

Erreicht:

Bedingungen:

Bewertung

Java Laufzeit-System
Java Runtime Environment (JRE)

Java `ClassLoader`

Automatische Speicherverwaltung
Garbage Collection

Execution-Engine
"virtueller Prozessor"

Das `.class`-Dateiformat
`ClassFile`-Tabelle

Das `.class`-Dateiformat
`ConstantPool`-Tabelle

Das `.class`-Dateiformat
`Field` und `Method`-Tabelle

Das `.class`-Dateiformat
Das `Code`-Attribut

Die `Exception-Tabelle`

Das `.class`-Dateiformat
Einfache Attribute

Befehlssatz des `Bytecode`s (1)

Befehlssatz des `Bytecode`s (2)

Befehlssatz des `Bytecode`s (3)

JVM zur Laufzeit
Objekterzeugung - `new`

JVM zur Laufzeit
Feldzugriff

JVM zur Laufzeit
Konstanten

JVM zur Laufzeit
Klassen-Methoden (1)

JVM zur Laufzeit
Klassen-Methoden (2)

JVM zur Laufzeit
Interface-Methoden

JVM zur Laufzeit
Dynamisches Binden von Methoden

JVM zur Laufzeit
Exception-Kontrolltransfer

JVM zur Laufzeit
Unterprogramme

Der `Bytecode`-Verifier