Diesehen

So, eigentlich wärs Zeit!

Meine colleg- gn, stecken alle im Schnee!

Ich bin euch trotzdem nicht bestrafen, wenn ihr rechtzeitig da seid.

Fangen wir trotzdem an.

Worum geht es?

Letzte Woche, Freitag haben wir angefangen mit Just-in-Time-Compiler 2.

Wir hatten uns grob überlegt, was war jetzt das Problem von unserem ersten Versuch, einen

Just-in-Time-Compiler zu basteln.

Wir haben gemerkt, dass das, was wir emulieren wollen, nicht darauf zugeschnitten war, emuliert

zu werden, sondern in Hardware gebaut zu werden.

Typische Fall, diese Condition Codes in Hardware kostet das nichts.

Das ist ein Carry-Fleck, das fällt einfach ab bei der Addition.

Und wie sie alle heißen, genauso.

In der Emulation muss man sie natürlich alle noch mal mühsam berechnen.

Da war die Idee, jetzt bauen wir uns da umgekehrt eine Hardware, die all den Quatsch wegglässt,

den man nicht leicht emulieren kann.

Oder nicht leicht kompilieren kann.

Da haben wir uns noch mal genauer angeguckt, was waren jetzt die eigentlichen Probleme.

Exceptions, Interrupts, Condition Codes, MMU-Segmentierungsgeschichten, berechnete Sprünge und nicht zuletzt selbstmodifizierender

Code.

Exceptions hatten wir uns schon angeguckt.

Just-in-time-Compiler freundliche Condition Codes hatten wir uns überlegt.

Was haben wir überlegt?

Wir haben überlegt, die brauchen wir eigentlich in 99,9% der Fälle schlicht nicht.

Eigentlich brauchen wir die Condition Codes aus heutiger Sicht nur noch bei Compare-Befehlen,

Addition, Subtraction und wie sie alle heißen, bräuchten die gar nicht berechnen.

Nächste Schritt, wir wollen die MMU loswerden.

Wie werden wir die MMU los?

Einmal kann man sagen, dass ein normales Wald- und Wiesen-Benutzerprogramm, ein C-Programm,

C++-Programm, was auch immer mit MMUs eigentlich nichts zu tun hat.

Auf Hochsprache interessiert mich der MMU eigentlich nicht.

Ich will, dass mein Programm läuft und dass mein Programm sicher läuft, sicher im Sinne

von es wird nicht gestört von anderen Programmen und sicher vielleicht auch im Sinne, es kann

andere nicht stören.

Das ja, aber wie das unter der Haube abgehandelt wird, wo welche Page liegt, das ist mir auf

anderen Sicht eigentlich völlig egal.

Dann könnte man sagen, man soll sich doch nicht um die Anwendung der MMU kümmern,

sondern man macht die virtuelle Maschine, die ganzen MMU-Kram und lässt einfach die Anwendung

in einem flachen Adressraum laufen und fertig.

Gut, was man dann eventuell gerne hätte, wäre, wenn man dann in dem Sinne keinen Schutz

mehr hat, dass man dann sichere Pointer verwenden möchte.

Sicher im Sinne von, ja die Dinger zeigen mit Sicherheit entweder auf nichts, null,

oder sie zeigen wirklich auf ein Objekt von dem entsprechenden Typ.

Das ist so die Definition, sichere Pointer.

Die Frage ist natürlich, wie kriegen wir jetzt sichere Pointer hin?

Gut, auf Hochsprache, Java oder so, der Compiler passt auf, dass da nichts schief geht.

Kein Problem, wir müssen uns jetzt natürlich vorstellen, wir sind jetzt nicht auf Compiler-Ebene,

sondern wir haben ja jetzt schon irgendeine Art von Bytecode.

Von dem müssen wir jetzt sicherstellen, dass der keinen Quatsch macht, also nicht beispielsweise