Jo, letzte Woche haben wir uns angeschaut, haben überlegt, wie muss eine echte Hardware

aussehen, dass man sich gut virtuell nahe machen kann.

Dann haben wir ja so gesagt, Interrupt soll man weglassen, Exception müssen wir irgendwie

auf ein Minimum beschränken. Das mit dem Flex, wie immer zu berechnen, ist doof. Dann haben

wir ja so alles Mögliche an Infos zusammengesammelt. Bis wir drauf gekommen sind, dann ist das

doch genau das, was Java macht. Das wollte ich euch heute nochmal genauer erzählen, wie

Java unter der Haube eigentlich aussieht. Also nicht Java-Programmiersprache, sondern

die Java Virtual Machine, was die unter der Haube macht.

Jo, wir haben uns das schon im Wesentlichen angeguckt. Wir brauchen einfache Instruktionen,

die man gut nachmachen kann. Wir brauchen, wenn es irgendwie geht, was, dass wir keine

Exceptions haben wollen. Gut, Divisionen durch Null, die werden wir nicht los. Bisher haben

wir immer gesagt, wenn irgendetwas Exceptions produzieren kann, dann lassen wir es weg.

Also beispielsweise Pointer-Rechnerei kann ja irgendwelche schlechten Speicherzellen

erwischen oder so. Dann haben wir das weggelassen. Aber Divisionen weggelassen, das ist jetzt

keine gute Idee. Also diese Exceptions, die kriegen wir noch. Und ihr wisst alle aus Java,

letztendlich Null Pointer muss es irgendwie geben können. Die müssen wir auch irgendwie

zulassen. Interrupts haben wir nicht, stattdessen Multiswetting, Condition Codes haben wir gesagt,

weglassen, MMU wollen wir nicht, keine Segmentierung, stattdessen sichere Pointer, nichts springen

wir berechnen, nichts selbst modifizierender Code. Genau das, was wir an letzter Woche

uns überlegt haben.

Jo, und wie schaut denn der Code aus? Es gibt beispielsweise, da kommen jetzt ein paar

Folien der Reihe nach, die Befehle, also die Assembler-Befehle sozusagen. Also jetzt nicht

I386, sondern Java Virtual Machine Code Befehle. Ja, und es gibt immer letztendlich hier für

Referenzen, die Dinge kennt ihr, Character, Double Load Long Int und so weiter, gibt es

die entsprechenden Befehle, also beispielsweise gibt es ein Befehl, um eine Integer-Konstante

auf den Stack zu holen. Es gibt das gleiche für Long, das gleiche für Fließkomma, das

gleiche für Double. Statt eine Konstante auf den Stack zu pushen, kann ich auch eine

lokale Variable mir holen von dem entsprechenden Typ. Ich kann eine, was auf dem Stack liegt,

mit einer Art Push, wieder herunterschreiben in eine lokale Variable und das ganze gibt

es auch noch, auch nochmal Load und Store, jetzt aber nicht lokale Variable, sondern

ARIE. Ich kann aus einem ARIE einen Doppelwert holen und auf den Stack legen oder umgekehrt

auf dem ARIE wieder abspeichern. Ja, und jetzt sieht man hier, da sind schon so einige Plätze

frei, es geht nicht alles mit allem. Zum Beispiel kann ich keine Short-Konstante pushen. In

sofern nicht so schlimm, ich pushe eine Integer-Konstante. Ich kann keine Short-Variable auf den Stack

legen. Gut, das ist dann stattdessen die hier oben, das sind nämlich die, die aus dem Short

erstmal einen Integer machen und den dann auf den Stack legen bzw. hier entsprechend.

Also im Prinzip gerecht oder auf den Stack pushen kann ich immer nur diese vier hier

bzw. Referenzen. Die anderen Typen, Character, Short, Wide, die muss ich immer erstmal in

ein Integer umwandeln. Ihr wisst sowieso, intern arbeitet Java sowieso mit dieser Hierarchie-Kette

sozusagen, Wide ist das kleinste, Short, Integer, Long. Und wie man hier sieht, Rechnen tut er

immer nur mit Intern-Schan. Man kann eventuell dann das, was auf dem Stack liegt, eine Integer-Zahl,

die kann ich als Short in ein ARIE speichern oder als Wide in ein ARIE. Aber ansonsten,

es gibt keine Short-Lokale-Variable. Gerechnet sieht man jetzt auch hier, wird mit Wide, Short,

Character, Referenz überhaupt nicht. Das sind jetzt nämlich die ganzen Rechenbefehle. Ganz

einfach, ich muss immer erst mein Wide in ein Integer umwandeln, dann kann ich damit

rechnen und dann kann ich ihn eventuell wieder zurückkonvertieren. Auch hier interessant sind

Referenzen und bleiben Referenzen, die werden nicht geändert. Sichere Point an. Das, was ich

mit einem New mir geholt habe, da kriege ich eine Zahl und die Zahl habe ich und bleibt dabei.

Klar, hier für die Fließkommas, da können wir rechnen mit Fließkommas, Shiften und XOR und

und und so. Das gibt es halt auch nicht, also ist hier alles frei. Das hier ist, denke ich,