alom!

Halb so schlimm. Denkt nur was neues aus. Haben genügend Themen.

Ja.

Technik läuft? Technik läuft. Okay, dann begrüße ich euch alle ganz offiziell, virtueller Maschinen.

Ja, eigentlich wollte ich weitermachen mit den Just-in-Time-Compilern.

Wenn die Technik jetzt nicht läuft, machen wir was anderes und zwar, wie funktioniert denn VM mehr?

Da habe ich keine Folien, weil ich weiß es nicht. Warum weiß ich es nicht?

Kommerzielles Produkt, man kann es sich kaufen, reingucken kann man nicht.

Aber es gibt die Patentschrift von der Firma VM da.

Da habe ich mal reingeguckt, was sie dann so patentiert haben und da schimmert so dunkel durch,

wie das unter der Haube vielleicht funktionieren könnte.

Das will ich versuchen mit euch mal heute ein bisschen raus zu kitzeln, wie das funktionieren könnte.

Also fangen wir mal an mit der Idee.

Also VMBer stammt aus einer Zeit, da gab es noch keine der heute besseren CPUs.

Also Nix64bit, Nix-Hardware-Virtualisierung, irgendwas.

Sondern das waren Wald und Wiesen, sage ich mal, PCs.

Irgendwie kam ja jetzt in der letzten Woche, vorletzte Woche auch immer schon von euch die Idee,

warum so ein Intel-PC, wenn ich ihn nachmache mit diesen blöden Flex-Berechnungen und so,

warum nehme ich nicht einfach die Addition vom PC selber, der berechnet doch die Flex.

Da haben wir immer gesagt, naja, das kann ich zwar so kompilieren,

aber dann muss ich irgendeinen Präfixcode davor schreiben,

um aus meinen Variablen die Flex irgendwie reinzufummeln in das iFlex-Register.

Dann kann ich die Addition zum Beispiel machen,

und danach muss ich die Flex aus dem iFlex-Register wieder rausfummeln in meine Simulationsvariable.

Man könnte es auch anders sagen, man könnte doch eigentlich eins zu eins den Originalcode abarbeiten.

Bis auf wenige Stellen.

Ach na, eine Stelle hatte ich nly schon gesagt. Solchen Kli sollte man vielleicht nicht unbedingt direkt houseführen,

weil dann ist die Maschine gegebenenfalls komplett tot für alle laufenden Betriebssysteme.

Was könnte man denn tun, um beispielsweise einen Kli rauszusortieren,

man das mitkriegen, dass da so eine blöde Instruktion steht, die man nicht simulieren will.

Das ist schon mal ein Teil davon. Es ist eine sehr gute Idee.

Das heißt, alles wo ich der Meinung bin, weiß ich nicht so genau ob ich das wirklich so machen will,

das patche ich im Original raus durch, ich sag mal ein Breakpoint.

Im Intel Fall nennt sich das dann irgendwie Interrupt.

Also typischer Fall.

Im Intel Fall gibt es eine Instruktion, die heißt, dass es in 3 nichts anderes tut, als einen Breakpoint zu generieren.

Und die Instruktion ist 1 Byte groß. Das heißt, die kann ich auch überall reinpatchen.

Also von der Idee her, ich habe meinen Code.

Und da steht ein Kli und dann geht es hinterher weiter.

Das bauen wir oder versuchen wir mal umzubauen in ein 3.

Und dann lassen wir es laufen.

Und wenn wir es dann laufen lassen, dann kriegen wir an der Stelle eine Exception.

Und im Prinzip läuft dann der Debugger.

Und der Debugger könnte sich jetzt ja überlegen, naja, vorher stand da das.

Da kann man sich ja merken, was da vorher stand, ne.

Und dann das Kli entsprechend simulieren.

So tun, als wenn die Interact aus wären.

Und dann kehrt er einfach, der Debugger lässt dann sozusagen das normale Programm einfach weiterlaufen.

Ja.

Okay.