Praktikumsanleitung. Rechnerorganisation. Versuch 1: Informationskodierung. (Emulator 8086)

Transkript

1 Technische Universität Ilmenau Fakultät für Informatik und Automatisierung Institut für Technische Informatik und Ingenieurinformatik Fachgebiet Integrierte Hard- und Softwaresysteme Praktikumsanleitung Rechnerorganisation Versuch 1: Informationskodierung (Emulator 8086) (Studiengänge IN, MA) Christian Vollmer Dr.-Ing. Karsten Henke Dr.-Ing. Klaus Debes Version 1.2 vom April 2007

2 Inhaltsverzeichnis 1 Einleitung 2 2 Ablauf 2 3 Vorbemerkungen 3 4 Aufgaben Aufgabe Vorbereitung Aufgabenstellung Aufgabe Vorbereitung Aufgabenstellung Aufgabe Vorbereitung Aufgabenstellung Aufgabe Vorbereitung Aufgabenstellung Aufgabe Vorbereitung Aufgabenstellung Aufgabe Vorbereitung Aufgabenstellung Aufgabe Vorbereitung Aufgabenstellung Aufgabe Vorbereitung Aufgabenstellung Aufgabe Vorbereitung Aufgabenstellung Aufgabe Vorbereitung Aufgabenstellung Aufgabe Vorbereitung Aufgabenstellung Aufgabe Vorbereitung Aufgabenstellung

3 5 Anhang A - Emu8086 Kurzhandbuch Inhalt dieses Dokuments Editorfunktionen Programm emulieren Typischer Ablauf der Emulation eines Programmes Anhang B - Erklärung des Inhaltes der Datei Template.asm Inhalt dieses Dokuments Quellcode Erläuterung Ein einfaches Programm Erläuterung Einleitung Dieser Versuch im Rahmen des Praktikums "Technische Informatik" soll die Kenntnisse der systemnahen Programmierung und zum Zusammenspiel wichtiger Prozessorkomponenten vertiefen. Dazu sind mehrere Aufgaben zu bearbeiten, in denen jeweils anhand einer vorgegebenen Aufgabenstellung ein Programm in einer Assembler-Sprache zu implementieren ist. Anschließend soll das erstellte Programm in einer Simulationsumgebung, die die systemnahe Sicht eines 8086-kompatiblen PC emuliert, getestet werden. Dabei soll das Programmverhalten bezüglich der Aufgabenstellung untersucht und interpretiert werden. 2 Ablauf Zu Beginn des Praktikums bekommen Sie vom Betreuer eine Quellcodedatei "student- Template.asm", die als Basis für ihre Quelltextentwürfe dient. Des weiteren bekommen Sie für jede zu lösende Aufgabe je eine vom Betreuer erstellte, zur jeweiligen Aufgabe passende Datei, welche per "include"-direktive automatisch (diese Direktive ist schon in der vorgegebenen Quellcodedatei enthalten) in ihr Programm eingebunden wird und eine vom Betreuer definierte Speicherbelegung zum Beginn der Laufzeit ihres Programmes herstellt. Der Betreuer teilt ihnen nun mit, welche Aufgabe Sie zuerst lösen sollen. Sollten Sie in Vorbereitung auf das Praktikum diese Aufgabe bereits gelöst haben und den fertigen Quelltext in ausgedruckter Form zum Praktikum mitgebracht haben, so können Sie nun ihren Quelltext abtippen. Mit Hilfe der Emulationsfunktionen des emu8086 simulieren Sie anschließend Ihr erstelltes Programm und machen sich gegebenenfalls Notizen, sofern in der Aufgabe eine Aussage zum Programmverlauf gefordert ist. Nachdem Sie die Lösung, einschließlich der Beobachtungen des Programmverlaufes, fertig gestellt haben, melden Sie sich beim Betreuer. Der Betreuer beurteilt nun die Korrektheit ihrer Ergebnisse und stellt gegebenenfalls vertiefende Fragen. Nachdem Sie ein zufriedenstellendes Ergebnis erzielt haben, teilt der Betreuer Ihnen mit, welche Aufgabe Sie als nächstes lösen sollen. 2

4 3 Vorbemerkungen In Vorbereitung auf das Praktikum können Sie eine Demoversion der Simulationsumgebung emu8086 von der Website downloaden und mit deren Hilfe bereits Lösungen für die gegebenen Aufgaben anfertigen. Diese Lösungen können Sie in ausgedruckter Form zum Praktikumstermin mitbringen. Des Weiteren finden Sie auf den Praktikumsseiten die Quellcodedatei, welche Ihnen auch vom Betreuer während des Praktikums vorgegeben wird. Diese können Sie als Basis für eigene Experimente und zur Anfertigung Ihrer Lösungen in Vorbereitung auf das Praktikum verwenden. Anhang A dieses Dokumentes enthält eine kurze Einführung in die Bedienung der Emulationsumgebung, welche die im Rahmen des Praktikums nötigen Funktionen des Programmes darstellt und erläutert. Anhang B enthält eine Erläuterung der vorgegebenen Quellcodedatei. Um einen umfassenden Überblick über den Ablauf des Praktikums zu bekommen, sollten Sie dieses Dokument vollständig lesen, bevor Sie mit der weiteren Arbeit beginnen! 4 Aufgaben Im Folgenden sind die während des Praktikums zu lösenden Aufgaben dargestellt. 4.1 Aufgabe Vorbereitung Informieren Sie sich zur Vorbereitung über die Syntax und Semantik der Befehle MOV, MUL, DEC und JNZ Aufgabenstellung Übernehmen Sie folgende Assember-Befehlsfolge in Ihr Assembler-Template template.asm: MOV AL, 1 m1: MUL BL DEC CX JNZ m1 Listing 1: Vorgegebener Assembler-Code Emulieren Sie den Programmlauf mit dem Assembler-Emulator emu8086. Starten Sie die Emulation. Führen sie nun die Anweisungen sequenziell schrittweise mit Hilfe der Step- Funktion bis zum Erreichen der Anweisung HLT aus. Beobachten Sie dabei die Veränderungen der Register und der Prozessor-Status-Flags nach jedem Befehl. Leiten Sie aus Ihren Beobachtungen Vermutungen über die Funktion der Befehlsfolge ab. Ändern Sie nun die Befehlsfolge folgendermaßen: MOV AL, 1 m1: MUL DL Listing 2: Abgeänderter Assembler-Code 3

5 DEC CX JNZ m1 Führen Sie nun wiederum die Anweisungen sequenziell schrittweise mit Hilfe der "Step"- Funktion bis zum Erreichen der Anweisung HLT aus. Beobachten Sie auch hierbei wieder die Veränderungen der Register und der Prozessor-Status-Flags nach jedem Befehl. Welche Unterschiede beobachten Sie im Vergleich zur Abarbeitung der vorhergehenden Befehlsfolge. Was bedeuten diese Veränderungen und wo liegen ihre Ursachen? 4.2 Aufgabe Vorbereitung Informieren Sie sich zur Vorbereitung über die Syntax und Semantik der Befehle MOV, ADD, CMP, JNE, INC und JNZ Aufgabenstellung Übernehmen Sie folgende Assember-Befehlsfolge in Ihr Assembler-Template template.asm: MOV SI, 0 MOV BX, BP ADD BX, DX m1: MOV CL, [BP+S I ] MOV [BX+SI ], CL INC SI CMP SI, DX JNE m1 Listing 3: Vorgegebener Assembler-Code Emulieren Sie den Programmlauf mit dem Assembler-Emulator emu8086. Starten Sie die Emulation. Führen Sie nun die Anweisungen sequenziell schrittweise mit Hilfe der Step-Funktion bis zum Erreichen der Anweisung HLT aus. Beobachten Sie dabei die Veränderungen der Register und der Prozessor-Status-Flags, sowie die Speicherinhalte an den im Programm adressierten Speicherstellen nach jedem Befehl. Leiten Sie aus Ihren Beobachtungen Vermutungen über die Funktion der Befehlsfolge ab. Ändern Sie nun die Befehlsfolge folgendermaßen: MOV SI, 0 MOV DI, DX MOV BX, BP ADD BX, DX m1: MOV CL, [BP+DI 1] DEC DI MOV [BX+SI ], CL Listing 4: Abgeänderter Assembler-Code 4

6 INC SI CMP SI, DX JNE m1 Führen Sie nun wiederum die Anweisungen sequenziell schrittweise mit Hilfe der Step- Funktion bis zum Erreichen der Anweisung HLT aus. Beobachten Sie auch hierbei wieder die Veränderungen der Register und der Prozessor-Status-Flags, sowie die Speicherinhalte an den im Programm adressierten Speicherstellen nach jedem Befehl. Welche Unterschiede beobachten Sie im Vergleich zur Abarbeitung der vorhergehenden Befehlsfolge. Was bedeuten diese Veränderungen und wo liegen ihre Ursachen? 4.3 Aufgabe Vorbereitung Informieren Sie sich zur Vorbereitung über die Syntax und Semantik der Befehle MUL, ADD und MOV Aufgabenstellung Die nachfolgende Assembler-Routine soll den Zugriff auf ein Element eines zweidimensionalen Byte-Arrays demonstrieren. Dabei wird ein bestimmtes Array-Element in ein Register eingelesen. Übernehmen Sie folgende Assember-Befehlsfolge in Ihr Assembler- Template template.asm: MOV AX, DI MUL BX MOV DI, AX ADD DI, SI MOV CL, [BP+DI ] MOV AL, 0 MOV [BP+DI ], AL Listing 5: Vorgegebener Assembler-Code Die Inhalte der verwendeten Register haben die folgende Bedeutung: BP = Anfangsadresse des zweidimensionalen Arrays CX = Zeilenanzahl DX = Spaltenanzahl DI = Selektierte Zeile SI = Selektierte Spalte CL = Zielregister Emulieren Sie den Programmlauf mit dem Assembler-Emulator emu8086. Starten Sie die Emulation. Führen sie nun die Anweisungen sequenziell schrittweise mit Hilfe der Step- Funktion bis zum Erreichen der Anweisung HLT aus. Beobachten Sie dabei die Veränderungen der Register und der Prozessor-Status-Flags, sowie die Speicherinhalte an den im 5

7 Programm adressierten Speicherstellen nach jedem Befehl. Erklären Sie die Bedeutung der einzelnen Befehle im Kontext der Array-Adressierung. 4.4 Aufgabe Vorbereitung Informieren Sie sich zur Vorbereitung über die Syntax und Semantik der Befehle CMP, JMP, JE, JNE, ROL, ROR, SHL, DEC Aufgabenstellung Übernehmen Sie folgende Assember-Befehlsfolge in Ihr Assembler-Template template.asm: Listing 6: Vorgegebener Assembler-Code m1: CMP CX, 0 ; Beginn von Block1 JNE m2 ROL BP, 1 JMP m3 m2: ROR BP, 1 m3: ; Ende von Block1 m4: CMP AX, 0 ; Beginn von Block2 JE m5 SHL BP, 1 DEC AX JMP m4 m5: ; Ende von Block2 CMP BX, 0 ; Beginn von Block3 JE m7 m6: ROR BP, 1 DEC BX JNZ m6 m7: ; Ende von Block3 m8: CMP DX, 0 ; Beginn von Block4 JNE m9 ROL BP, 1 JMP m11 m9: CMP DX, 1 JNE m10 ROR BP, 1 JMP m11 m10 : CMP DX, 2 JNE m11 SHL BP, 1 6

8 m11 : ; Ende von Block4 Emulieren Sie den Programmlauf mit dem Assembler-Emulator emu8086. Starten Sie die Emulation. Führen Sie nun die Anweisungen sequenziell schrittweise mit Hilfe der Step-Funktion bis zum Erreichen der Anweisung HLT aus. Beobachten Sie dabei die Veränderungen der Register und der Prozessor-Status-Flags nach jedem Befehl. Die vier Anweisungsblöcke Block1,..., Block4 realisieren je eine typische Kontrollstruktur der strukturierten Programmierung. Ordnen Sie jedem Block jeweils einen der folgenden Begriffe zu: Schleife mit Eintrittsbedingung Schleife mit Austrittsbedingung bedingte Verzweigung Fallauswahl 4.5 Aufgabe Vorbereitung Informieren Sie sich zur Vorbereitung über die Syntax und Semantik der Befehle ADD, SUB, ADC und SBB. Machen Sie sich außerdem die Bedeutung des Carry- und des Overflow-Flags klar Aufgabenstellung Übernehmen Sie folgende Assember-Befehlsfolge in Ihr Assembler-Template template.asm: ADD AL, AH SUB BL, BH ADC CL, CH SBB DL, DH Listing 7: Vorgegebener Assembler-Code Emulieren Sie den Programmlauf mit dem Assembler-Emulator emu8086. Starten Sie die Emulation. Führen Sie nun die Anweisungen sequenziell schrittweise mit Hilfe der Step-Funktion bis zum Erreichen der Anweisung HLT aus. Beobachten Sie dabei die Veränderungen der Register und der Prozessor-Status-Flags nach jedem Befehl. Achten Sie dabei besonders auf die Veränderungen im Carry- und im Overflow-Flag. Erklären Sie das Verhalten der Flags. Beziehen Sie die Werte der verwendeten Register in Ihre Überlegungen mit ein. Finden Sie eine Möglichkeit, zwei 32-bit-Zahlen mit Hilfe der 16-Bit-Register zu addieren. Dabei seien die oberen 16 Bits der ersten Zahl im Register DX, ihre unteren 16 Bits im Register AX gespeichert. Analog dazu seien die oberen 16 Bits der zweiten Zahl im Register CX, ihre unteren 16 Bits im Register BX gespeichert. Das Ergebnis soll am Ende 7

9 in analoger Weise in den Registern DX (die oberen 16 Bits) und AX (die unteren 16 Bits) stehen. Ignorieren Sie dabei Overflows, achten Sie aber auf die korrekte Behandlung von Carrys. 4.6 Aufgabe Vorbereitung Informieren Sie sich zur Vorbereitung über die maschineninterne Darstellung einer (IEEE 754-) Float-Zahl Aufgabenstellung Lesen Sie aus dem Speicher die (IEEE 754-) Float-Zahl, deren Adresse im Register BX spezifiziert ist, mit Hilfe des Memory-Fensters des emu8086 aus. Beachten Sie dabei, wie dieser Datentyp im Speicher abgelegt wird (Bytereihenfolge). Wandeln Sie diese Zahl von ihrer maschinenlesbaren Form "per Hand" in die übliche für Menschen lesbare Darstellung um. 4.7 Aufgabe Vorbereitung Informieren Sie sich zur Vorbereitung über die Syntax und Semantik der Befehle MOV, CMP, JB, JBE, SUB Aufgabenstellung Übernehmen Sie folgende Assember-Befehlsfolge in Ihr Assembler-Template template.asm: Listing 8: Vorgegebener Assembler-Code BLANK EQU 20h ; L e e r z e i c h e n NULL EQU 30h ; N u l l MOV AL, [BP] ; l e s e ASCII Z i f f e r CMP AL, 61h ; Z i f f e r a f? JB L1 ; k e i n e K l e i n b u c h s t a b e n SUB AL, BLANK ; in Grossbuchstaben L1 : SUB AL, NULL ; in Hexzahl wandeln CMP AL, 9 ; Z i f f e r > 9? JBE Ok ; JMP OK SUB AL, 07 ; k o r r i g i e r e Z i f f e r n A..F Ok: ; E x i t Die gegebene Assembler-Routine wandelt eine hexadezimale Ziffer, welche als ASCII- Zeichen im Speicher an der im Register BP gegebenen Adresse steht, in ihren numerischen Wert um und schreibt das Ergebnis der Umwandlung in das Register AL. Emulieren Sie den Programmlauf mit dem Assembler-Emulator emu8086. Starten Sie 8

10 die Emulation. Führen Sie nun die Anweisungen sequenziell schrittweise mit Hilfe der Step-Funktion bis zum Erreichen der Anweisung HLT aus. Beobachten Sie dabei die Veränderungen der Register und der Prozessor-Status-Flags nach jedem Befehl. Achten Sie dabei Besonders auf die Belegung des Registers AL. Erweitern Sie nun die Routine so, dass sie einen ganzen ASCII-String, welcher eine Hexadezimalzahl darstellt, in seinen numerischen Wert umwandelt. Der String beginnt an der in BP spezifizierten Speicherstelle. Dabei steht die höchstwertige Hexadezimalziffer an der niedrigsten Speicherstelle. Die Länge des Strings ist im Register SI vorgegeben. Am Ende soll der Wert, den dieser String kodiert, in einem beliebigen Register stehen. Es reicht aus, wenn Ihre Routine Strings mit einer maximalen Länge von vier Zeichen umwandeln kann (Zur Umwandlung längerer Strings benötigt man 32-Bit-Arithmetik!). Hinweis: Überlegen Sie sich zuerst, wie man eine solche Umwandlung "per Hand" vornimmt und versuchen Sie, dieses Vorgehen mit Hilfe einer Schleife zu realisieren. 4.8 Aufgabe Vorbereitung Informieren Sie sich zur Vorbereitung über die Syntax und Semantik der Befehle MOV, CMP, JB, JBE, SUB Aufgabenstellung Übernehmen Sie folgende Assember-Befehlsfolge in Ihr Assembler-Template template.asm: ADD Listing 9: Vorgegebener Assembler-Code AL, BL Die gegebene Routine führt eine Addition zweier BCD-Zahlen, gegeben in AL und BL, durch, macht dabei aber einen gravierenden Fehler. Erläutern Sie das Problem. Korrigieren Sie die Routine so, dass nach deren Abarbeitung in AL das korrekte Ergebnis in BCD-Form steht. 4.9 Aufgabe Vorbereitung Informieren Sie sich zur Vorbereitung über die Syntax und Semantik der Befehle MOV, JNZ und INT im Zusammenhang mit dem DOS-Interrupt-Mechanismus und den verwendeten Interrupts Aufgabenstellung Übernehmen Sie folgende Assember-Befehlsfolge in Ihr Assembler-Template template.asm: 9

11 Listing 10: Vorgegebener Assembler-Code m1: MOV AH, 01h ; Beginn von Block1 INT 16h JZ m1 MOV AH, 00h INT 16h ; Ende von Block1 MOV AH, 01h ; Beginn von Block2 INT 21h ; Ende von Block2 Das Programm demonstriert zwei verschiedene Möglichkeiten zum Einlesen eines Zeichens von der Tastatur. Dabei werden zwei grundlegend unterschiedliche Verfahren verwendet. Erläutern Sie diese Verfahren und heben Sie dabei deren Unterschiede hervor. Emulieren Sie den Programmlauf mit dem Assembler-Emulator emu8086. Setzen Sie dazu einen Breakpoint auf Anweisung HLT. Starten Sie die Emulation mit Hilfe der Run- Funktion. Damit der Programmlauf Block1 verlassen kann, müssen Sie auf der emulierten Konsole (ähnlich der DOS-Eingabeaufforderung) ein Zeichen über die Tastatur eingeben. Geben Sie nun ein Zeichen in die emulierte Konsole ein (Das Konsolenfenster muss dazu aktiviert sein) und beobachten Sie dabei die Veränderungen der Register. Nachdem Sie das Zeichen eingegeben haben wird Block1 verlassen und Block2 betreten. Auch hier müssen Sie ein Zeichen eingeben, damit das Programm den Block verlässt. Geben Sie also auch hier wieder ein Zeichen in die emulierte Konsole ein (Das Konsolenfenster muss dazu aktiviert sein) und beobachten Sie dabei die Veränderungen der Register. Danach kommt das Programm bei HLT durch den darauf gesetzten Breakpoint zum Stillstand Aufgabe Vorbereitung Informieren Sie sich zur Vorbereitung über die Syntax und Semantik der Befehle MOV, ADD und INT im Zusammenhang mit dem DOS-Interrupt-Mechanismus und den verwendeten Interrupts Aufgabenstellung Übernehmen Sie folgende Assember-Befehlsfolge in Ihr Assembler-Template template.asm: Listing 11: Vorgegebener Assembler-Code m1: MOV [BX], AL ; Die Grösse des P u f f e r s muss _ ; im e r s t e n Byte des P u f f e r s s t e h e n MOV DX, BX ; Adresse des P u f f e r s _ ; ( i n k l. Grösse,... ) muss in DX s t e h e n MOV AH, 0Ah ; S t r i n g e i n l e s e n und _ ; in P u f f e r s c h r e i b e n 10

12 INT 21h MOV DI, [BX+1] ; h i n t e r das l e t z t e Zeichen des _ ; S t r i n g s muss ein D o l l a r z e i c h e n _ AND DI, 00FFh ; g e s c h r i e b e n werden, damit DOS b e i _ ; d e r Ausgabe das Ende _ MOV BP, BX ; des S t r i n g s e r k e n n t MOV [BP+DI +2], 24h MOV DX, BX ADD DX, 2 MOV AH, 09h ; S t r i n g von S t e l l e DX auf _ ; Konsole ausgeben INT 21h Die Routine demonstriert, wie man einen String von der Konsole einliest und diesen anschließend wieder auf der Konsole ausgibt. Die beiden Register BX und AL enthalten vor dem Programmstart bereits vorgegebene Werte: BX = Zieladresse des einzulesenden Strings AL = Puffergröße Um die Dos-Interrupt-Routine 21h/0Ah zum Einlesen einer Zeichenkette von der Tastatur verwenden zu können, muss man ihr zuvor mitteilen, welchen Speicherbereich sie zur Ablage des eingelesenen Strings verwenden soll. Zur Spezifizierung dieses sogenannten Puffers muss man seine Anfangsadresse und seine Größe angeben. Um der Routine den Ort des Puffers mitzuteilen, wird seine Adresse vor dem Interrupt-Aufruf in das Register DX geschrieben. Die Größe des Puffers wird der Routine etwas "indirekter" mitgeteilt. Sie muss in das erste Byte des Puffers geschrieben werden. Nach dem Interrupt-Aufruf steht im ersten Byte des Puffers immernoch die Größe des Puffers. In das zweite Byte des Puffers hat die Routine die Länge der eingelesenen Zeichenkette geschrieben. Ab dem dritten Byte hat die Routine die eingelesene Zeichenkette abgelegt. Der Puffer hat also am Ende folgenden Inhalt: <1 Byte Puffergröße N><1 Byte Stringlänge M> <Zeichen1><Zeichen2>... <ZeichenM> <Leeres Byte1><Leeres Byte2>... <Leeres Byte(N-M-2)> Emulieren Sie den Programmlauf mit dem Assembler-Emulator emu8086. Starten Sie die Emulation. Führen Sie nun die Anweisungen sequenziell schrittweise mit Hilfe der Step-Funktion bis zum Erreichen der Anweisung HLT aus. Beobachten Sie dabei die Veränderungen der Register und der Prozessor-Status-Flags nach jedem Befehl. Leiten Sie nun aus der gegebenen Routine ein Programm ab, welches zwei Strings von der Konsole einliest, diese direkt aneinander hängt und den entstandenen String wieder auf der Konsole ausgibt. 11

13 4.11 Aufgabe Vorbereitung Informieren Sie sich zur Vorbereitung über die nötigen Speicherzugriffsmechanismen und DOS-Interrupts mit deren Hilfe Sie die Aufgabenstellung bewältigen können Aufgabenstellung Schreiben Sie eine Assembler-Routine, die einen Text von der Tastatur einliest, anschließend alle Zeichen in Großbuchstaben wandelt und den resultierenden Text wieder ausgibt Aufgabe Vorbereitung Informieren Sie sich zur Vorbereitung über die verschiedenen Speicherzugriffsmechanismen Aufgabenstellung Schreiben Sie ein Programm, welches einen Ringtausch von drei Speicherinhalten (jeweils zwei Bytes) vornimmt. Die Speicheradressen der drei zu tauschenden Speicherzellen stehen ebenfalls im Speicher, aufeinander folgend in Form eines Arrays(drei Einträge von je zwei Bytes). Die Anfangsadresse dieser Tabelle steht im Register BP. 12

14 5 Anhang A - Emu8086 Kurzhandbuch 5.1 Inhalt dieses Dokuments Dieses Dokument dient als kurze Einführung in die Bedienungsweise des Programmes Emu Editorfunktionen Startet man das Programm emu8086, so erscheint ein Fenster mit vier Buttons (siehe Abb. 1). Im Rahmen des Praktikums sind nur die beiden Buttons "new" und "recent files" von Abbildung 1: Dialog nach dem Start des Programms emu8086 Interesse. Mit dem Button "new" erzeugt man eine neue, leere Quellcodedatei. Mit dem Button "recent files" öffnet man bereits vorhandene Quellcodedateien. Da im Rahmen des Praktikums eigene Programme immer ausgehend von dem vorgegebenen Template erstellt werden sollten, muss man zu Beginn das Template mit Hilfe des Buttons "recent files" öffnen. Klickt man auf diesen Button, so öffnet sich eine Pull-Down-Liste, in der sich die zuletzt bearbeiteten Dateien befinden (wenn man das Programm zum ersten mal nach der Neuinstallation startet, ist die Liste natürlich leer). Außerdem befindet sich am Ende der Liste der Eintrag "other files..." (siehe Abb. 2). Wählt man diesen Eintrag Abbildung 2: Ein Klick auf den markierten Eintrag öffnet einen Dialog, in dem die zu bearbeitende Datei ausgewählt werden kann (per Mausklick) aus, so öffnet sich ein Dialogfenster, in dem man die zu bearbeitende 13

15 Datei auswählen kann. Wenn Sie mit der Bearbeitung einer Aufgabe beginnen, sollten Sie mit Hilfe dieses Dialoges das vorgegebene Template suchen und öffnen. Nachdem Sie das Template geöffnet haben, befinden Sie sich im Editormodus (siehe Abb. 3). In diesem Abbildung 3: Das vorgebene Template im Editormodus Modus können Sie den Quellcode des Templates bearbeiten und so Ihren eigenen Quellcode einfügen. Mit Hilfe des "save"-symbols kann man die Datei unter ihrem aktuellen Namen speichern, durch einen Klick auf den kleinen Pfeil rechts neben dem "save"-symbol kann man die Datei unter einem anderen Namen speichern. Um das leere Template, welches Sie auch noch als Vorlage für weitere Programme benötigen, nicht zu überschreiben, sollten Sie Ihren Quellcode unter einem anderen Dateinamen speichern. 5.3 Programm emulieren Nachdem Sie Ihren Quellcode fertig gestellt (oder zumindest der Meinung sind, er sei fertig gestellt) und gespeichert haben, können Sie die Emulatorfunktionen des Programmes dazu nutzen, Ihr Programm zu emulieren. Durch einen Klick auf das "emulate"-symbol, führt das Programm einen Syntaxcheck durch und startet, insofern der Syntaxcheck erfolgreich war, den Emulator. Schlägt der Syntaxcheck fehl, so erscheint ein Dialog, dem Sie entnehmen können, welche Stellen Ihres Quellcodes Fehler enthalten (siehe Abb. 4). Die Zahl innerhalb der Klammern gibt die fehlerhafte Quellcodezeile an. Danach folgt eine kurze Beschreibung des Fehlers. Nachdem Sie alle Fehler beseitigt haben, und wiederum das "emulate"-symbol betätigen, beginnt der Emulator mit der Emulation Ihres Programmes. Es erscheinen nun zwei neue Fenster: zum einen das Hauptfenster des Emulators (siehe Abb. 5), erkennbar am Fenstertitel "emulator:...", zum anderen ein Fenster, welches Ihren Quellcode anzeigt, erkennbar am Fenstertitel "original source code". Im Hauptfenster kann man den Emulationsvorgang steuern. In dem anderen Fenster wird parallel zur Emulation der gerade aktive Befehl markiert. Am linken Rand des Hauptfensters sind die aktuellen Inhalte der Register dargestellt. Diese ändern sich entsprechend des zuletzt ausgeführten Befehls. Im mittleren Teil des Fensters befindet sich eine Tabelle. Diese Tabelle illustriert den Inhalt des Speichers. In der linken Spalte befindet sich eine 14

16 Abbildung 4: Meldung bei Fehlerhafter Syntax Abbildung 5: Das Hauptfenster des Emulators 15

17 fünfstellige hexadezimale Zahl gefolgt von einem Doppelpunkt, welche die Speicheradresse (nicht in der Schreibweise "segment:offset", sondern als physische Speicheradresse) der entsprechenden Zeile darstellt. Nach dem Doppelpunkt folgt der Inhalt der Speicherzelle, welche durch die entsprechende Adresse in der ersten Spalte adressiert wird, als zweistellige hexadezimale Zahl. In der dritten und vierten Spalte wird ebenfalls der Inhalt der Speicherzelle dargestellt, hier aber in dezimaler Schreibweise (in der dritten Spalte) bzw. in Form von ASCII-Zeichen (in der vierten Spalte). Am rechten Rand des Hauptfensters befindet sich eine weitere Darstellung des Speichers. Hier werden alle Speicherinhalte als Maschinenbefehle interpretiert. Dabei ist zu beachten, dass es sich nicht tatsächlich auch um Maschinenbefehle handeln muss. Es wird hier einfach "blind" eine Reihe aufeinanderfolgender Bytes als Befehl interpretiert (auch, wenn Sie vom Programmierer eigentlich als Daten interpretiert werden würden), so wie es auch die CPU eines realen Rechners tun würde, falls der Befehlszeiger auf diese Speicherstelle zeigen würde. Über den beiden Tabellen befindet sich jeweils eine Box, in der jeweils die Anfangsadresse des gerade betrachteten Speicherbereichs steht. Es gibt zwei Modi, um nun das Programm ablaufen zu lassen. Mit Hilfe des Buttons "single step" kann man das Programm im Einzelschrittmodus ausführen. Dabei wird bei Betätigung des Buttons immer der sowohl in den beiden Tabellen des Hauptfensters, als auch im "original source code"-fenster markierte Befehl ausgeführt. Nach dessen Ausführung wird der Programmlauf gestoppt und der nächste Befehl markiert. Im zweiten Modus wird das Programm vom Anfang bis zum Programmende durchlaufen, so wie es auch auf einer realen CPU ablaufen würde. Dieser Modus wird mit Hilfe des Buttons "run" gestartet. Rechts neben dem "run"- Button befindet sich ein Slider, mit dem man die Geschwindigkeit des Programmlaufes einstellen kann. Der nächste Befehl wird immer mit der dort eingestellten Verzögerung ausgeführt. Auch im "run"-modus wird der aktuell ausgeführte Befehl im Hauptfenster und im "original source code"-fenster markiert (siehe Abb. 6). Um im "run"-modus den Abbildung 6: "original source code"-fenster mit aktuellem, markiertem Befehl Programmlauf an einer bestimmten Stelle des Programmes automatisch stoppen zu lassen, kann man einen sogenannten Breakpoint setzen. Im Menü des Haupfensters findet man unter "debug"->"set breakpoint" die entsprechende Funktion. Um den Programm- 16

18 lauf nun vor der Ausführung eines bestimmten Befehls zu stoppen, markiert man den Befehl im Hauptfenster oder im "original source code"-fenster durch einen Klick mit der linken Maustaste auf den Befehl und wählt dann "debug"->"set breakpoint" im Menü des Hauptfensters aus. Nachdem man den Breakpoint wie beschrieben gesetzt hat, startet man den Programmlauf mit Hilfe des "run"-buttons. Das Programm wird nun emuliert und hält vor der Ausführung des entsprechenden Befehls an. Mit Hilfe des "single step"- Buttons kann man nun den nun markierten Befehl ausführen. Betätigt man wieder den "run"-button, so wird die Emulation fortgeführt. Falls man den Breakpoint innerhalb einer Schleife setzt, so wird der Programmlauf jedesmal, wenn er den entsprechenden Befehl passiert, angehalten. Um das Programmverhalten während der Emulation genauer untersuchen zu können, stellt der Emulator weitere Werkzeuge zu Verfügung. Die wichtigsten sind das Memory-Fenster, des Flag-Fenster und das Stack-Fenster. Diese Fenster lassen sich über das "view"-menü des Hauptfensters öffnen. Das Memory-Fenster (siehe Abb. 7) kann mit Hilfe des Eintrages "view"->"memory" geöffnet werden. Dieses Fenster zeigt einen Ausschnitt des dem Programm zur Verfügung stehenden Hauptspeichers. Hier kön- Abbildung 7: Das Memory-Fenster nen die Auswirkungen von Speicheroperationen während des Programmlaufes beobachtet werden. Im oberen Teil des Fensters befindet sich eine Box, in der die Anfangsadresse des anzuzeigenden Speicherbereiches steht. Trägt man hier eine andere Adresse ein, so wird der entsprechende Speicherbereich angezeigt. Werden nun während des Programmlaufes Speicheroperationen auf dem aktuell angezeigten Speicherbereich ausgeführt, so kann man deren Auswirkungen hier beobachten. Der Speicherbereich wird in Form einer Tabelle angezeigt. Die erste Zahl in jeder Spalte gibt dabei jeweils die Anfangsadresse der in der Zeile dargestellten Byte-Folge an. Rechts davon folgen 16 Bytes, von denen jedes jeweils als zweistellige hexadezimale Zahl codiert ist. Dabei hat das erste Byte die am Anfang der Zeile angegebene Adresse, das zweite Byte die am Zeilenanfang angegebene Adresse plus eins, das dritte Byte plus zwei,..., das letzte Byte plus 15. Am rechten Rand der Tabelle wird der Speicherinhalt der entsprechenden Zeile in ASCII-codierter Form dargestellt. Mit Hilfe des Stack-Fensters (siehe Abb. 8), welches sich über den Menüeintrag "view"->"stack" öffnen lässt, kann man den als Stack verwendeten Speicherbereich inspizieren. Natürlich ist dies auch mit dem Memory-Fenster möglich (siehe Abb. 9), da es sich ja auch nur um einen Speicherbereich handelt, allerdings stellt das Stack-Fenster eine "stack-gerechtere" Ansicht zur Verfügung. Nachdem die erste Stack-Operation (üblicherweise der Befehl PUSH, da der Stack zu Beginn noch leer ist) ausgeführt wurde, springt der Pfeil im rechten Teil des Stack-Fensters auf den "obersten" Stackeintrag (also der Eintrag, der als letztes auf den Stapel gelegt wurde). Der Pfeil wird bei einem PUSH-Befehl um eine Zeile nach unten versetzt, bei einem POP-Befehl um eine Zeile 17

19 Abbildung 8: Das Stack-Fenster Abbildung 9: Der Speicherbereich des Stacks im Memory-Fenster betrachtet nach oben (Man beachte hier, wie der Stack im Speicherbereich organisiert ist. Er beginnt im hier gezeigten Beispiel am Ende des Segments, welches die Segmentadresse 0100 trägt. Mit einem PUSH-Befehl wird der Wert auf den Stack gelegt und der Stack-Zeiger um eins verringert.). Mit Hilfe des Flags-Fensters (siehe Abb. 10) kann man den aktuellen Zustand der Prozessor-Status-Flags nach jedem Befehl inspizieren. Nach der Ausführung eines Befehls werden die Inhalte der einzelnen Flags hier angezeigt. Die Flags, die sich mit der Ausführung des Befehls geändert haben, werden rot markiert, alle anderen blau. Neben den hier aufgezählten Fenstern, kann man im "view"-menü noch weitere finden, die aber weniger häufig benötigt werden. 5.4 Typischer Ablauf der Emulation eines Programmes Im Folgenden soll exemplarisch der typische Ablauf einer Emulation dargestellt werden. Typischerweise beginnt man mit der Erstellung des Quellcodes im Editor-Fenster. Nachdem man den Quellcode fertig gestellt und alle Fehler beseitigt hat, startet man die Emulation mit Hilfe des "emulate"-buttons. Im Emulator öffnet man nun mindestens das Memory-Fenster, falls nötig auch weitere, wie das Stack-Fenster und das Flags-Fenster. Will man nun die Wirkung eines bestimmten Teils des Quellcodes genauer untersuchen, setzt man den Breakpoint auf den Anfang des zu untersuchenden Bereiches und startet den Programmlauf im "run"-modus. Nachdem der Breakpoint erreicht wurde, führt man den zu untersuchenden Code-Bereich im Einzelschrittmodus aus und beobachtet dabei den Zustand des Programmes mit Hilfe der zuvor geöffneten Fenster (Memory-Fenster, 18

20 Abbildung 10: Das Flag-Fenster Stack-Fenster,...). Abbildung 11: Die typische Arbeitsumgebung während der Emulation 19

21 6 Anhang B - Erklärung des Inhaltes der Datei Template.asm 6.1 Inhalt dieses Dokuments Dieses Dokument beschreibt den Inhalt der Datei Template.asm. Diese Datei dient dem Praktikanten als Vorlage für seine eigenen Programmtexte. 6.2 Quellcode 01: name "Template" 02: 03: include "data.inc" 04: 05: org 0100H 06: 07:.MODEL TINY ;Das Speichermodell 08: 09: 10:.DATA ;Beginndes Datensegments 11: 12: #hier werden eigene Daten eingefügt 13: 14:.CODE 15: start: 16: 17: #hier wird eigener Quellcode eingefügt 18: 19: ende: HLT 6.3 Erläuterung Zeile 01: Hier wird der Name der Datei angegeben, welche entstehen würde, wenn man den Quellcode compilieren würde. Im Rahmen des Praktikums werden die Quelldateien nicht compiliert, sondern lediglich emuliert. Daher ist diese Zeile unwichtig und kann weg gelassen werden. Zeile 03: Hier wird der Quellcode der Datei "data.inc" eingebunden. Diese Direktive bewirkt, dass der Quelltext der Datei "data.inc" vor dem compilieren bzw. emulieren direkt an diese Stelle kopiert wird. Der Inhalt der Datei "data.inc" realisiert eine Speichervorbelegung. Zeile 05: Hier teilt man dem Compiler bzw. Emulator mit, dass er den Maschinencode an die Adresse 0100H im Adressraum des Programmes schreiben soll. Zeile 07: Hier teilt man dem Compiler mit, welches Speichermodell er verwenden soll. Das Speichermodell legt fest, in welcher Weise das Programm zur Ausführungszeit in den 20

22 Speicher geladen wird. Wählt man das Speichermodell TINY, so werden Daten und Code in ein einziges Segment geladen, welches auf eine Größe von 64KB begrenzt ist. Der Compiler würde in diesem Fall eine COM-Datei erzeugen. Ein anderes Speichermodell ist z. B. SMALL. Hierbei werden Daten und Code jeweils in ein eigenes Segment der Größe 64KB geladen und der Compiler würde eine EXE-Datei erzeugen. Aufgrund diverser Beschränkungen, die mit der Einbindung der Include-Datei zu Speichervorbelegung einhergehen, kann im Rahmen des Praktikums nur das Speichermodell tiny verwendet werden. Zeile 10:.DATA definiert den Anfang des Datensegments. Nach.Data werden z.b. Daten, Variablen und Puffer definiert. Zeile 14:.CODE definiert den Anfang des Codesegments. Nach.CODE folgen die Befehle. Zeile 19: HLT teilt dem Compiler mit, dass hier das Programm zu Ende ist. Während der Emulation wird der Programmlauf hier beendet. 6.4 Ein einfaches Programm Das folgende Programm wurde unter Verwendung des Templates erstellt. Es demonstriert eine einfache Konsolenaussgabe mit Hilfe von DOS-Interrupts. 01: name "Template" 02: 03: include "data.inc" 04: 05: org 0100H 06: 07:.MODEL TINY ;Das Speichermodell 08: 09: 10:.DATA ;Beginn des Datensegments 11: 12: Meld DB "Hallo Welt!$" ;Die Meldung 13: 14:.CODE 15: start:mov ;Adresse des Datensegments nach ax 16: mov ds,ax ;Datensegmentadr. in Segmentregister 17: mov dx,offset Meld ;Die Offsetadresse von Meldung nach dx 18: mov ah,09h ;Den Wert neun nach ah schieben 19: int 21h ;Interrupt 21h Funktion 09h aufrufen 20: ;= Write String. Geschrieben wird bis zum $ 21: mov ah,4ch ;DOS Funktion Programm beenden 22: int 21h ;Programm beenden 19: ende: HLT 21

23 6.5 Erläuterung Das Grundgerüst der Quellcodedatei wurde bereits weiter oben erläutert. Im Folgenden wird der Inhalt des Beispielprogramms näher erläutert. Zeile 12: Hier wird die Variable Meld angelegt. Über diese Variable kann später ein Speicherbereich angesprochen werden, der an dieser Stelle mit einer Zeichenkette vorbelegt wird. Dafür muss zuerst der Variablenname angegeben werden, dann folgt der Datentyp, in diesem Fall DB (Das B in DB steht für Byte. Es zeigt an, dass es sich bei dem Speicherbereich um eine Sequenz von Bytes handelt. Eine Alternative wäre DW, was den Speicherbereich zu einer Sequenz von Words macht hier nicht von Belang). Zuletzt folgt die Belegung des Speicherbereichs. Soll der Speicher mit einer Zeichenkette belegt werden, so muss diese in Anführungszeichen angegeben werden. Zeile 15: Hier wird die Anfangsadresse des für die Variable Meld reservierten Speicherbereiches in das Register DX geladen um den Text in Meld mit Hilfe der folgenden Interruptroutine ausgeben zu können. Mit Hilfe des Vorsatzes OFFSET kann man die Anfangsadresse einer beliebigen Variablen abrufen. Zeile 16/17: Hier wird die Dos-Interruptroutine zur Ausgabe eines Textes auf der Konsole aufgerufen um den in Meld enthaltenen Text auszugeben. Zeile 19/20: Hier wird eine Dos-Interruptroutine zum Beenden des Programmes aufgerufen. Damit wird das Programm explizit durch das simulierte Betriebssystem des emu8086- Emulators beendet. Diesen Aufruf kann man auch weg lassen, da das Programm beim Erreichen des HLT-Befehls implizit beendet wird. 22