wie funktioniert overlay ing ?

[Jens Kallup]

Hallo Assemblerfreunde !

ich komme gerade von einen kleinen Testprojekt, das ich mittels
Turbo-Pascal 6 und 7 erstellt habe.
Dieses Programm läuft unter der Console in 16-Bit Modus.
Dort kann man aber nur Programme, die 64 KB schreiben - also am
Stück jetzt gesehen - nicht das gesamte Programm.

In der dazu gehörigen Hilfe habe ich etwas interessantes gefunden.
Und zwar bietet TurboPascal das verwenden von Overlays an.
Das hört sich nach Überlappung an...

Ich habe bemerkt, das Overlays teilweise das doppelte so Groß
sein können, die zum Programm gehören.

kann da einer mal was schreiben - wie das funktioniert ?
Ist das schwer nachzubauen?

Jens

[Heinz Schmitz]

Jens Kallup wrote:

>In der dazu gehörigen Hilfe habe ich etwas interessantes gefunden.
>Und zwar bietet TurboPascal das verwenden von Overlays an.
>Das hört sich nach Überlappung an...
>
>Ich habe bemerkt, das Overlays teilweise das doppelte so Groß
>sein können, die zum Programm gehören.
>
>kann da einer mal was schreiben - wie das funktioniert ?
>Ist das schwer nachzubauen?

https://de.wikipedia.org/wiki/Overlay_(Programmierung)

Grüße,
H.

[Stefan Reuther]

Am 15.08.2021 um 17:19 schrieb Jens Kallup:
> Ich habe bemerkt, das Overlays teilweise das doppelte so Groß
> sein können, die zum Programm gehören.
>
> kann da einer mal was schreiben - wie das funktioniert ?

Gut.

> Ist das schwer nachzubauen?

Wenn du fragen musst, dann ja.

Das braucht eine Menge Konventionen, die zu jedem Zeitpunkt eingehalten
werden müssen. In Turbo Pascal konnte Borland das deswegen so gut
umsetzen, weil sie dort alle Stufen von Code-Erzeugung und Linken in der
Hand hatten, und zu nix kompatibel sein mussten.

Mal grob skizziert:

Du brauchst einen eigenen Linker, der nicht nur eine .exe, sondern auch
eine oder mehrere .ovr schreiben kann, und Sprünge in eine Overlay-Datei
durch Sprünge an entsprechende Stubs ersetzen kann (ähnlich der
Procedure Linkage Table bei ELF). Die .ovr ist auch nicht nur ein
nackter Codeblock, die enthält eine Struktur für mehrere Segmente
jeweils mit Fixups.

Dein Code muss durchgängig saubere Stackframes nutzen (also immer schön
'push bp; mov bp,sp', auch, wenn das gar nicht nötig zu sein scheint),
damit der Overlay-Manager feststellen kann, ob ein Overlay auf dem Stack
referenziert wird (wenn Overlay A Overlay B aufruft, und dann B
zurückkehrt, muss A wieder geladen werden, möglicherweise an eine andere
Adresse; dazu muss der Stack umgeschrieben werden). 'near' Aufrufe und
sowas wie C-longjmp oder C++-Exception Handling musst du dir verkneifen.
Turbo Pascal hat noch extra Logik drin, dass eine Stringkonstante, die
normalerweise im Codesegment liegt, vor Benutzung auf den Stack kopiert
wird, weil das Codesegment jederzeit verschwinden kann.

Der Overlay-Manager muss den ganzen Kram parsen können, dabei korrekt
die oben erwähnten Stubs auf geladene Overlays umschreiben bzw. beim
Entladen der Overlays wieder zurück, das gleiche mit dem Stack.

Das baust du nicht mal eben in Assembler nach. Wenn du eh schon einen
halbfertigen Linker hast, da würde ich Chancen sehen...

Für 16-Bit-Windows mit DLLs hat Microsoft was ähnliches gemacht (die
DLLs konnten auch dynamisch raus und rein geladen werden, wie die
Segmente eines Overlays). Auch da musste sich der Code an Konventionen
halten, was neue Compiler erforderte.


Stefan