Moin.

Jo, okay, dann machen wir mal weiter.

Wo waren wir gestern?

Gestern waren wir, du hattest gerade das Stichwort Liste, da waren wir noch nicht ganz fertig

mit. Ich hatte links so zwei Stichpunkte noch hingeschrieben. Das eine war die Geschichte mit

den Flex. Da hatte ich jetzt mit ein paar Leuten nach der Vorlesung noch so eine kleine Gesprächsrunde.

Irgendwie haben wir ja während der Vorlesung noch darüber geredet, wie ist denn das mit den

Flex. Wir haben gesagt, die Idee war bei OVP, es gibt für die Addition ein kleines Unterprogrammchen,

was einem einen Schnipsel generiert. Und diesem Unterprogramm, das diesen Schnipsel generiert,

kann man noch Parameter mitgeben. Das soll 16-bit sein, er soll das Carry-Flex im positiven Sinne

mitberechnen, er soll usw. Und jetzt war ja die Frage, jetzt kann man ja vielleicht noch

was wegoptimieren. Zum Beispiel, was weiß ich, man kann sich die nächste Instruktion angucken und

wenn die natürlich wieder in die Flex berechnet, dann vergisst das mit dem Flex. Während der Vorlesung

die Frage, vielleicht berechnet die nächste aber gar nicht die Flex. Und dann müsste man sich die

nächste und nächste und nächste und nächste und man weiß eigentlich gar nicht, wie weit man

vorausblicken soll. Da hatte ich dann noch einigen erzählt, wollte ich allen nochmal kurz erzählen.

Also wenn wir dann sagen wir mal, das Beispiel von gestern hatten, wir haben so eine Addition,

1 zu eax dazu addieren. Dann bauen wir das um in Schnipsel und ich nenne die Schnipsel jetzt mal,

gestern hatten wir vier solche Schnipsel und danach kommt dann vielleicht ein Compar,

irgendwas, dann haben wir Schnipsel e f oder vielleicht auch ein Beispiel,

was weiß ich, der Schnipsel a kommt nochmal vor a e f. So haben wir das dann weiter. Und das was

man jetzt macht bei Qemu und Co., also alle die diese Art von Just-At-Nime-Kompilierungreihe

machen, die schreiben sich wirklich gar nicht die einzelnen Schnipsel erst hin, sondern Schnipselnummern

oder Schnipsel-IDs oder irgend sowas. Und dann gehe ich von hinten her nach vorne und gucke,

was brauche ich denn eigentlich alles. Am Ende weiß ich, ich brauche alle Register, ich brauche

zum Beispiel auch den EIP und am Ende brauche ich die Flex. Weil was danach kommt, weiß ich nicht.

Ja, dann gehe ich jetzt rückwärts. Hier werden die Flex nicht berechnet, aber ich brauche die Flex.

Also zurückrechnen, da werden die Flex als letztes berechnet. Den Schnipsel brauche ich.

Ich muss den EIP am Ende berechnet haben, also gehe ich von hinten her und gucke, wer als letztes

sozusagen den Instruction-Point berechnet. Davor brauche ich ihn eigentlich nicht mehr.

Beside, was weiß ich, hier ich sehe, der berechnet die Flex, aber der braucht

zwischenzeitlich nochmal die Flex, also muss ich von da aus wieder suchen, wer vorher produziert

sie mir dann. Und dann kann ich mir merken, ja den Schnipsel brauche ich, den Schnipsel brauche ich,

den brauchen wir nicht, den brauchen wir, den brauchen wir nicht, den brauchen wir nicht,

den brauchen wir. Das mache ich im Prinzip in einer Art Array. In dem Array stehen erstmal die

ID's drin. Ja, man merkt dann, ja A brauche ich nicht, dann ersetze ich A sozusagen durch NOB.

Und dann fliegen so ein paar Dinge hier raus, da steht dann überall noch ein NOB drin. Dann kann

ich hierher gehen, ich gehe sozusagen von oben durch. Ich weiß, dieser Schnipsel braucht 5 Byte,

dieser Schnipsel braucht 10 Byte, dieser Schnipsel braucht 8 Byte, dieser Schnipsel braucht so viel.

Dann kann ich, wenn ich das Array von oben bis unten durch gehe, den Platzbedarf ermitteln,

könnte dann so eine Art Malloc aufrufen. Wir hatten uns verschiedene Strategien angeguckt,

wie man sich dann Speicher für diesen Cache holt. Ja, und kann dann passend zur ID A,

kann ich dann den Schnipsel kopieren. Passend zum NOB kann ich den Schnipsel kopieren. Okay,

der Schnipsel ist Null Byte, da kopiere ich nichts. Den kopiere ich hinten dran, den kopiere ich,

den kopiere ich und dann klebe ich mir im zweiten Schritt letztendlich im Cache meinen Code zusammen.

Also da brauche ich dann gar nicht immer vorausblicken, was kommt dann als nächstes,

als nächstes, als nächstes. Da weiß ich auch gar nicht, wie weit ich vorausblicken müsste.

Nee, ich mache es eher von hinten, dann am Ende weiß ich, was ich brauche. Und von da aus rückwärts

gehen, viel einfacher.

Ich kenne den Bereich, den ich wieder ankoppe, das ist wieder, wie ich auswähle,