Praktikumsanleitung...3 Vorbemerkungen In Vorbereitung auf das Praktikum können Sie eine...

Praktikumsanleitung

Rechnerorganisation

Versuch 2: Informationskodierung

(Emulator 8086)

(Studiengange Informatik und Basic Engineering School)

Christian VollmerDr.-Ing. Karsten HenkeDr.-Ing. Klaus Debes

Technische Universitat Ilmenau

Fakultat fur Informatik und AutomatisierungInstitut Technische Informatik und IngenieurinformatikFachgebiet Integrierte Kommunikationssysteme

Inhaltsverzeichnis1 Einleitung 2

2 Ablauf 2

3 Vorbemerkungen 3

4 Aufgaben 34.1 Aufgabe 1.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

4.1.1 Vorbereitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34.1.2 Aufgabenstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

4.2 Aufgabe 1.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44.2.1 Vorbereitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44.2.2 Aufgabenstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4











1

5 Anhang A - Emu8086 Kurzhandbuch 135.1 Inhalt dieses Dokuments . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135.2 Editorfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135.3 Programm emulieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145.4 Typischer Ablauf der Emulation eines Programmes . . . . . . . . . . . . . 18

6 Anhang B - Erklärung des Inhaltes der Datei Template.asm 206.1 Inhalt dieses Dokuments . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206.2 Quellcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206.3 Erläuterung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206.4 Ein einfaches Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216.5 Erläuterung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

1 EinleitungDieser Versuch im Rahmen des Praktikums "Technische Informatik" soll die Kenntnisseder systemnahen Programmierung und zum Zusammenspiel wichtiger Prozessorkompo-nenten vertiefen. Dazu sind mehrere Aufgaben zu bearbeiten, in denen jeweils anhandeiner vorgegebenen Aufgabenstellung ein Programm in einer Assembler-Sprache zu im-plementieren ist. Anschließend soll das erstellte Programm in einer Simulationsumgebung,die die systemnahe Sicht eines 8086-kompatiblen PC emuliert, getestet werden. Dabei solldas Programmverhalten bezüglich der Aufgabenstellung untersucht und interpretiert wer-den.

2 AblaufZu Beginn des Praktikums bekommen Sie vom Betreuer eine Quellcodedatei "student-Template.asm", die als Basis für ihre Quelltextentwürfe dient. Des weiteren bekommenSie für jede zu lösende Aufgabe je eine vom Betreuer erstellte, zur jeweiligen Aufgabepassende Datei, welche per "include"-Direktive automatisch (diese Direktive ist schon inder vorgegebenen Quellcodedatei enthalten) in ihr Programm eingebunden wird und einevom Betreuer definierte Speicherbelegung zum Beginn der Laufzeit ihres Programmes her-stellt. Der Betreuer teilt ihnen nun mit, welche Aufgabe Sie zuerst lösen sollen. Sollten Siein Vorbereitung auf das Praktikum diese Aufgabe bereits gelöst haben und den fertigenQuelltext in ausgedruckter Form zum Praktikum mitgebracht haben, so können Sie nunihren Quelltext abtippen. Mit Hilfe der Emulationsfunktionen des emu8086 simulieren Sieanschließend Ihr erstelltes Programm und machen sich gegebenenfalls Notizen, sofern inder Aufgabe eine Aussage zum Programmverlauf gefordert ist. Nachdem Sie die Lösung,einschließlich der Beobachtungen des Programmverlaufes, fertig gestellt haben, melden Siesich beim Betreuer. Der Betreuer beurteilt nun die Korrektheit ihrer Ergebnisse und stelltgegebenenfalls vertiefende Fragen. Nachdem Sie ein zufriedenstellendes Ergebnis erzielthaben, teilt der Betreuer Ihnen mit, welche Aufgabe Sie als nächstes lösen sollen.

2

3 VorbemerkungenIn Vorbereitung auf das Praktikum können Sie eine Demoversion der Simulationsum-gebung emu8086 von der Website www.emu8086.com downloaden und mit deren Hilfebereits Lösungen für die gegebenen Aufgaben anfertigen. Diese Lösungen können Sie inausgedruckter Form zum Praktikumstermin mitbringen. Des Weiteren finden Sie auf denPraktikumsseiten die Quellcodedatei, welche Ihnen auch vom Betreuer während des Prak-tikums vorgegeben wird. Diese können Sie als Basis für eigene Experimente und zur An-fertigung Ihrer Lösungen in Vorbereitung auf das Praktikum verwenden. Anhang A diesesDokumentes enthält eine kurze Einführung in die Bedienung der Emulationsumgebung,welche die im Rahmen des Praktikums nötigen Funktionen des Programmes darstellt underläutert. Anhang B enthält eine Erläuterung der vorgegebenen Quellcodedatei. Um einenumfassenden Überblick über den Ablauf des Praktikums zu bekommen, sollten Sie diesesDokument vollständig lesen, bevor Sie mit der weiteren Arbeit beginnen!

4 AufgabenIm Folgenden sind die während des Praktikums zu lösenden Aufgaben dargestellt.

4.1 Aufgabe 1.1

4.1.1 Vorbereitung

Informieren Sie sich zur Vorbereitung über die Syntax und Semantik der Befehle MOV,MUL, DEC und JNZ.

4.1.2 Aufgabenstellung

Übernehmen Sie folgende Assember-Befehlsfolge in Ihr Assembler-Template template.asm:

Listing 1: Vorgegebener Assembler-CodeMOV AL, 1

m1: MUL BLDEC CXJNZ m1

Emulieren Sie den Programmlauf mit dem Assembler-Emulator emu8086. Starten Sie dieEmulation. 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än-derungen der Register und der Prozessor-Status-Flags nach jedem Befehl. Leiten Sie ausIhren Beobachtungen Vermutungen über die Funktion der Befehlsfolge ab.

Ändern Sie nun die Befehlsfolge folgendermaßen:

Listing 2: Abgeänderter Assembler-CodeMOV AL, 1

m1: MUL DL

3

DEC CXJNZ 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 wie-der die Veränderungen der Register und der Prozessor-Status-Flags nach jedem Befehl.Welche Unterschiede beobachten Sie im Vergleich zur Abarbeitung der vorhergehendenBefehlsfolge. Was bedeuten diese Veränderungen und wo liegen ihre Ursachen?

4.2 Aufgabe 1.2

4.2.1 Vorbereitung

Informieren Sie sich zur Vorbereitung über die Syntax und Semantik der Befehle MOV,ADD, CMP, JNE, INC und JNZ.



Listing 3: Vorgegebener Assembler-CodeMOV SI , 0MOV BX, BPADD BX, DX

m1: MOV CL , [BP+SI ]MOV [BX+SI ] , CLINC SICMP SI , DXJNE m1

Emulieren Sie den Programmlauf mit dem Assembler-Emulator emu8086. Starten Siedie Emulation. Führen Sie nun die Anweisungen sequenziell schrittweise mit Hilfe derStep-Funktion bis zum Erreichen der Anweisung HLT aus. Beobachten Sie dabei die Ver-änderungen der Register und der Prozessor-Status-Flags, sowie die Speicherinhalte anden im Programm adressierten Speicherstellen nach jedem Befehl. Leiten Sie aus IhrenBeobachtungen Vermutungen über die Funktion der Befehlsfolge ab.

Ändern Sie nun die Befehlsfolge folgendermaßen:

Listing 4: Abgeänderter Assembler-CodeMOV SI , 0MOV DI , DXMOV BX, BPADD BX, DX

m1: MOV CL , [BP+DI−1]DEC DIMOV [BX+SI ] , CL

4

INC SICMP SI , DXJNE 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 wiederdie Veränderungen der Register und der Prozessor-Status-Flags, sowie die Speicherinhaltean den im Programm adressierten Speicherstellen nach jedem Befehl. Welche Unterschie-de beobachten Sie im Vergleich zur Abarbeitung der vorhergehenden Befehlsfolge. Wasbedeuten diese Veränderungen und wo liegen ihre Ursachen?

4.3 Aufgabe 1.3

4.3.1 Vorbereitung

Informieren Sie sich zur Vorbereitung über die Syntax und Semantik der Befehle MUL,ADD und MOV.


Die nachfolgende Assembler-Routine soll den Zugriff auf ein Element eines zweidimen-sionalen Byte-Arrays demonstrieren. Dabei wird ein bestimmtes Array-Element in einRegister eingelesen. Übernehmen Sie folgende Assember-Befehlsfolge in Ihr Assembler-Template template.asm:

Listing 5: Vorgegebener Assembler-CodeMOV AX, DIMUL BXMOV DI , AXADD DI , SIMOV CL , [BP+DI ]MOV AL, 0MOV [BP+DI ] , AL

Die Inhalte der verwendeten Register haben die folgende Bedeutung:BP = Anfangsadresse des zweidimensionalen ArraysCX = ZeilenanzahlDX = SpaltenanzahlDI = Selektierte ZeileSI = Selektierte SpalteCL = Zielregister

Emulieren Sie den Programmlauf mit dem Assembler-Emulator emu8086. Starten Sie dieEmulation. 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ände-rungen der Register und der Prozessor-Status-Flags, sowie die Speicherinhalte an den im

5

Programm adressierten Speicherstellen nach jedem Befehl. Erklären Sie die Bedeutungder einzelnen Befehle im Kontext der Array-Adressierung.

4.4 Aufgabe 1.4

4.4.1 Vorbereitung

Informieren Sie sich zur Vorbereitung über die Syntax und Semantik der Befehle CMP,JMP, JE, JNE, ROL, ROR, SHL, DEC.



Listing 6: Vorgegebener Assembler-Codem1: CMP CX, 0 ; Beginn von Block1

JNE m2ROL BP, 1JMP m3

m2: ROR BP, 1m3: ; Ende von Block1

m4: CMP AX, 0 ; Beginn von Block2JE m5SHL BP, 1DEC AXJMP m4

m5: ; Ende von Block2

CMP BX, 0 ; Beginn von Block3JE m7

m6: ROR BP, 1DEC BXJNZ m6

m7: ; Ende von Block3

m8: CMP DX, 0 ; Beginn von Block4JNE m9ROL BP, 1JMP m11

m9: CMP DX, 1JNE m10ROR BP, 1JMP m11

m10 : CMP DX, 2JNE m11SHL BP, 1

6

m11 : ; Ende von Block4

Emulieren Sie den Programmlauf mit dem Assembler-Emulator emu8086. Starten Siedie Emulation. Führen Sie nun die Anweisungen sequenziell schrittweise mit Hilfe derStep-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 An-weisungsblöcke Block1, . . . , Block4 realisieren je eine typische Kontrollstruktur der struk-turierten Programmierung. Ordnen Sie jedem Block jeweils einen der folgenden Begriffezu:

• Schleife mit Eintrittsbedingung

• Schleife mit Austrittsbedingung

• bedingte Verzweigung

• Fallauswahl

4.5 Aufgabe 2.1

4.5.1 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 desOverflow-Flags klar.



Listing 7: Vorgegebener Assembler-CodeADD AL, AHSUB BL , BHADC CL , CHSBB DL, DH

Emulieren Sie den Programmlauf mit dem Assembler-Emulator emu8086. Starten Siedie Emulation. Führen Sie nun die Anweisungen sequenziell schrittweise mit Hilfe derStep-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 Siedabei besonders auf die Veränderungen im Carry- und im Overflow-Flag. Erklären Sie dasVerhalten der Flags. Beziehen Sie die Werte der verwendeten Register in Ihre Überlegun-gen 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 imRegister AX gespeichert. Analog dazu seien die oberen 16 Bits der zweiten Zahl im Re-gister CX, ihre unteren 16 Bits im Register BX gespeichert. Das Ergebnis soll am Ende

7

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 vonCarrys.

4.6 Aufgabe 2.2

4.6.1 Vorbereitung

Informieren Sie sich zur Vorbereitung über die maschineninterne Darstellung einer (IEEE754-) Float-Zahl.


Lesen Sie aus dem Speicher die (IEEE 754-) Float-Zahl, deren Adresse im Register BXspezifiziert ist, mit Hilfe des Memory-Fensters des emu8086 aus. Beachten Sie dabei, wiedieser Datentyp im Speicher abgelegt wird (Bytereihenfolge). Wandeln Sie diese Zahl vonihrer maschinenlesbaren Form "per Hand" in die übliche für Menschen lesbare Darstellungum.

4.7 Aufgabe 2.3

4.7.1 Vorbereitung

Informieren Sie sich zur Vorbereitung über die Syntax und Semantik der Befehle MOV,CMP, JB, JBE, SUB.



Listing 8: Vorgegebener Assembler-CodeBLANK EQU 20h ; Lee r z e i chenNULL EQU 30h ; Nu l lMOV AL, [BP ] ; l e s e ASCII−Z i f f e rCMP AL, 61h ; Z i f f e r a − f ?JB L1 ; k e ine K le inbuchs tabenSUB AL, BLANK ; in Grossbuchs taben

L1 : SUB AL, NULL ; in Hexzah l wandelnCMP AL, 9 ; Z i f f e r > 9 ?JBE Ok ; JMP OKSUB AL, 07 ; k o r r i g i e r e Z i f f e r n A..F

Ok: ; Ex 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 numerischenWert um und schreibt das Ergebnis der Umwandlung in das Register AL.

Emulieren Sie den Programmlauf mit dem Assembler-Emulator emu8086. Starten Sie

8

die Emulation. Führen Sie nun die Anweisungen sequenziell schrittweise mit Hilfe derStep-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 Siedabei Besonders auf die Belegung des Registers AL.

Erweitern Sie nun die Routine so, dass sie einen ganzen ASCII-String, welcher eine He-xadezimalzahl darstellt, in seinen numerischen Wert umwandelt. Der String beginnt ander in BP spezifizierten Speicherstelle. Dabei steht die höchstwertige Hexadezimalzifferan 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 Zeichenumwandeln kann (Zur Umwandlung längerer Strings benötigt man 32-Bit-Arithmetik!).

Hinweis: Überlegen Sie sich zuerst, wie man eine solche Umwandlung "per Hand" vor-nimmt und versuchen Sie, dieses Vorgehen mit Hilfe einer Schleife zu realisieren.

4.8 Aufgabe 2.4

4.8.1 Vorbereitung

Informieren Sie sich zur Vorbereitung über die Syntax und Semantik der Befehle MOV,CMP, JB, JBE, SUB.



Listing 9: Vorgegebener Assembler-CodeADD 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 Ergebnisin BCD-Form steht.

4.9 Aufgabe 3.1

4.9.1 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 verwen-deten Interrupts.



9

Listing 10: Vorgegebener Assembler-Codem1: MOV AH, 01h ; Beginn von Block1

INT 16hJZ m1MOV AH, 00hINT 16h ; Ende von Block1

MOV AH, 01h ; Beginn von Block2INT 21h ; Ende von Block2

Das Programm demonstriert zwei verschiedene Möglichkeiten zum Einlesen eines Zeichensvon 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 da-zu 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. GebenSie nun ein Zeichen in die emulierte Konsole ein (Das Konsolenfenster muss dazu aktiviertsein) und beobachten Sie dabei die Veränderungen der Register. Nachdem Sie das Zeicheneingegeben 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 Konso-lenfenster muss dazu aktiviert sein) und beobachten Sie dabei die Veränderungen derRegister. Danach kommt das Programm bei HLT durch den darauf gesetzten Breakpointzum Stillstand.

4.10 Aufgabe 3.2

4.10.1 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 ver-wendeten Interrupts.



Listing 11: Vorgegebener Assembler-Codem1: MOV [BX] , AL ; Die Grösse des Pu f f e r s muss _

; im e r s t en Byte des Pu f f e r s s t ehenMOV DX, BX ; Adresse des Pu f f e r s _

; ( i n k l . Grösse , . . . ) muss in DX s t ehenMOV AH, 0Ah ; S t r i n g e i n l e s e n und _

; in Pu f f e r s c h r e i b en

10

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 e in Do l l a r z e i c h en _

AND DI , 00FFh ; g e s c h r i e b en werden , damit DOS b e i _; der Ausgabe das Ende _

MOV BP, BX ; des S t r i n g s erkenntMOV [BP+DI+2] , 24hMOV DX, BXADD DX, 2MOV AH, 09h ; S t r i n g von S t e l l e DX auf _

; Konsole ausgebenINT 21h

Die Routine demonstriert, wie man einen String von der Konsole einliest und diesen an-schließend wieder auf der Konsole ausgibt.

Die beiden Register BX und AL enthalten vor dem Programmstart bereits vorgegebe-ne Werte:BX = Zieladresse des einzulesenden StringsAL = Puffergröße

Um die Dos-Interrupt-Routine 21h/0Ah zum Einlesen einer Zeichenkette von der Tas-tatur verwenden zu können, muss man ihr zuvor mitteilen, welchen Speicherbereich siezur Ablage des eingelesenen Strings verwenden soll. Zur Spezifizierung dieses sogenanntenPuffers muss man seine Anfangsadresse und seine Größe angeben. Um der Routine denOrt des Puffers mitzuteilen, wird seine Adresse vor dem Interrupt-Aufruf in das RegisterDX 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-Aufrufsteht im ersten Byte des Puffers immernoch die Größe des Puffers. In das zweite Bytedes Puffers hat die Routine die Länge der eingelesenen Zeichenkette geschrieben. Ab demdritten 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 Siedie Emulation. Führen Sie nun die Anweisungen sequenziell schrittweise mit Hilfe derStep-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 derKonsole einliest, diese direkt aneinander hängt und den entstandenen String wieder aufder Konsole ausgibt.

11

4.11 Aufgabe 4.1

4.11.1 Vorbereitung

Informieren Sie sich zur Vorbereitung über die nötigen Speicherzugriffsmechanismen undDOS-Interrupts mit deren Hilfe Sie die Aufgabenstellung bewältigen können.


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.

4.12 Aufgabe 4.2

4.12.1 Vorbereitung

Informieren Sie sich zur Vorbereitung über die verschiedenen Speicherzugriffsmechanis-men.


Schreiben Sie ein Programm, welches einen Ringtausch von drei Speicherinhalten (jeweilszwei Bytes) vornimmt. Die Speicheradressen der drei zu tauschenden Speicherzellen stehenebenfalls im Speicher, aufeinander folgend in Form eines Arrays(drei Einträge von je zweiBytes). Die Anfangsadresse dieser Tabelle steht im Register BP.

12

5 Anhang A - Emu8086 Kurzhandbuch

5.1 Inhalt dieses Dokuments

Dieses Dokument dient als kurze Einführung in die Bedienungsweise des ProgrammesEmu8086.

5.2 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 demButton "recent files" öffnet man bereits vorhandene Quellcodedateien. Da im Rahmendes Praktikums eigene Programme immer ausgehend von dem vorgegebenen Templateerstellt werden sollten, muss man zu Beginn das Template mit Hilfe des Buttons "recentfiles" öffnen. Klickt man auf diesen Button, so öffnet sich eine Pull-Down-Liste, in dersich die zuletzt bearbeiteten Dateien befinden (wenn man das Programm zum ersten malnach der Neuinstallation startet, ist die Liste natürlich leer). Außerdem befindet sich amEnde 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 zubearbeitende Datei ausgewählt werden kann

(per Mausklick) aus, so öffnet sich ein Dialogfenster, in dem man die zu bearbeitende

13

Datei auswählen kann. Wenn Sie mit der Bearbeitung einer Aufgabe beginnen, solltenSie mit Hilfe dieses Dialoges das vorgegebene Template suchen und öffnen. Nachdem Siedas 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 Quellcodeeinfügen. Mit Hilfe des "save"-Symbols kann man die Datei unter ihrem aktuellen Namenspeichern, durch einen Klick auf den kleinen Pfeil rechts neben dem "save"-Symbol kannman die Datei unter einem anderen Namen speichern. Um das leere Template, welches Sieauch noch als Vorlage für weitere Programme benötigen, nicht zu überschreiben, solltenSie Ihren Quellcode unter einem anderen Dateinamen speichern.

5.3 Programm emulieren

Nachdem Sie Ihren Quellcode fertig gestellt (oder zumindest der Meinung sind, er sei fer-tig gestellt) und gespeichert haben, können Sie die Emulatorfunktionen des Programmesdazu nutzen, Ihr Programm zu emulieren. Durch einen Klick auf das "emulate"-Symbol,führt das Programm einen Syntaxcheck durch und startet, insofern der Syntaxcheck er-folgreich war, den Emulator. Schlägt der Syntaxcheck fehl, so erscheint ein Dialog, demSie entnehmen können, welche Stellen Ihres Quellcodes Fehler enthalten (siehe Abb. 4).Die Zahl innerhalb der Klammern gibt die fehlerhafte Quellcodezeile an. Danach folgteine kurze Beschreibung des Fehlers. Nachdem Sie alle Fehler beseitigt haben, und wie-derum das "emulate"-Symbol betätigen, beginnt der Emulator mit der Emulation IhresProgrammes. Es erscheinen nun zwei neue Fenster: zum einen das Hauptfenster des Emu-lators (siehe Abb. 5), erkennbar am Fenstertitel "emulator: ...", zum anderen ein Fenster,welches Ihren Quellcode anzeigt, erkennbar am Fenstertitel "original source code". ImHauptfenster kann man den Emulationsvorgang steuern. In dem anderen Fenster wirdparallel zur Emulation der gerade aktive Befehl markiert. Am linken Rand des Haupt-fensters sind die aktuellen Inhalte der Register dargestellt. Diese ändern sich entsprechenddes 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

Abbildung 4: Meldung bei Fehlerhafter Syntax

Abbildung 5: Das Hauptfenster des Emulators

15

fünfstellige hexadezimale Zahl gefolgt von einem Doppelpunkt, welche die Speicheradres-se (nicht in der Schreibweise "segment:offset", sondern als physische Speicheradresse) derentsprechenden Zeile darstellt. Nach dem Doppelpunkt folgt der Inhalt der Speicherzelle,welche durch die entsprechende Adresse in der ersten Spalte adressiert wird, als zweistel-lige hexadezimale Zahl. In der dritten und vierten Spalte wird ebenfalls der Inhalt derSpeicherzelle dargestellt, hier aber in dezimaler Schreibweise (in der dritten Spalte) bzw.in Form von ASCII-Zeichen (in der vierten Spalte). Am rechten Rand des Hauptfens-ters befindet sich eine weitere Darstellung des Speichers. Hier werden alle Speicherinhalteals Maschinenbefehle interpretiert. Dabei ist zu beachten, dass es sich nicht tatsächlichauch um Maschinenbefehle handeln muss. Es wird hier einfach "blind" eine Reihe auf-einanderfolgender Bytes als Befehl interpretiert (auch, wenn Sie vom Programmierer ei-gentlich als Daten interpretiert werden würden), so wie es auch die CPU eines realenRechners tun würde, falls der Befehlszeiger auf diese Speicherstelle zeigen würde. Überden beiden Tabellen befindet sich jeweils eine Box, in der jeweils die Anfangsadresse desgerade betrachteten Speicherbereichs steht. Es gibt zwei Modi, um nun das Programmablaufen zu lassen. Mit Hilfe des Buttons "single step" kann man das Programm im Ein-zelschrittmodus ausführen. Dabei wird bei Betätigung des Buttons immer der sowohl inden beiden Tabellen des Hauptfensters, als auch im "original source code"-Fenster mar-kierte Befehl ausgeführt. Nach dessen Ausführung wird der Programmlauf gestoppt undder nächste Befehl markiert. Im zweiten Modus wird das Programm vom Anfang biszum 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 Programmlaufeseinstellen kann. Der nächste Befehl wird immer mit der dort eingestellten Verzögerungausgeführt. Auch im "run"-Modus wird der aktuell ausgeführte Befehl im Hauptfensterund 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 las-sen, kann man einen sogenannten Breakpoint setzen. Im Menü des Haupfensters findetman unter "debug"->"set breakpoint" die entsprechende Funktion. Um den Programm-

16

lauf nun vor der Ausführung eines bestimmten Befehls zu stoppen, markiert man denBefehl im Hauptfenster oder im "original source code"-Fenster durch einen Klick mit derlinken Maustaste auf den Befehl und wählt dann "debug"->"set breakpoint" im Menüdes Hauptfensters aus. Nachdem man den Breakpoint wie beschrieben gesetzt hat, startetman den Programmlauf mit Hilfe des "run"-Buttons. Das Programm wird nun emuliertund 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 ei-ner Schleife setzt, so wird der Programmlauf jedesmal, wenn er den entsprechenden Befehlpassiert, angehalten. Um das Programmverhalten während der Emulation genauer unter-suchen zu können, stellt der Emulator weitere Werkzeuge zu Verfügung. Die wichtigstensind das Memory-Fenster, des Flag-Fenster und das Stack-Fenster. Diese Fenster lassensich ü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 zeigteinen 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 beobachtetwerden. Im oberen Teil des Fensters befindet sich eine Box, in der die Anfangsadressedes anzuzeigenden Speicherbereiches steht. Trägt man hier eine andere Adresse ein, sowird der entsprechende Speicherbereich angezeigt. Werden nun während des Programm-laufes Speicheroperationen auf dem aktuell angezeigten Speicherbereich ausgeführt, sokann man deren Auswirkungen hier beobachten. Der Speicherbereich wird in Form einerTabelle angezeigt. Die erste Zahl in jeder Spalte gibt dabei jeweils die Anfangsadresse derin der Zeile dargestellten Byte-Folge an. Rechts davon folgen 16 Bytes, von denen jedesjeweils als zweistellige hexadezimale Zahl codiert ist. Dabei hat das erste Byte die amAnfang der Zeile angegebene Adresse, das zweite Byte die am Zeilenanfang angegebeneAdresse plus eins, das dritte Byte plus zwei, ..., das letzte Byte plus 15. Am rechten Randder Tabelle wird der Speicherinhalt der entsprechenden Zeile in ASCII-codierter Formdargestellt. Mit Hilfe des Stack-Fensters (siehe Abb. 8), welches sich über den Menüein-trag "view"->"stack" öffnen lässt, kann man den als Stack verwendeten Speicherbereichinspizieren. Natürlich ist dies auch mit dem Memory-Fenster möglich (siehe Abb. 9), daes sich ja auch nur um einen Speicherbereich handelt, allerdings stellt das Stack-Fenstereine "stack-gerechtere" Ansicht zur Verfügung. Nachdem die erste Stack-Operation (üb-licherweise 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 (al-so der Eintrag, der als letztes auf den Stapel gelegt wurde). Der Pfeil wird bei einemPUSH-Befehl um eine Zeile nach unten versetzt, bei einem POP-Befehl um eine Zeile

17

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 beginntim 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 umeins verringert.). Mit Hilfe des Flags-Fensters (siehe Abb. 10) kann man den aktuellenZustand der Prozessor-Status-Flags nach jedem Befehl inspizieren. Nach der Ausführungeines Befehls werden die Inhalte der einzelnen Flags hier angezeigt. Die Flags, die sichmit 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. Nach-dem man den Quellcode fertig gestellt und alle Fehler beseitigt hat, startet man dieEmulation mit Hilfe des "emulate"-Buttons. Im Emulator öffnet man nun mindestens dasMemory-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 startetden Programmlauf im "run"-Modus. Nachdem der Breakpoint erreicht wurde, führt manden zu untersuchenden Code-Bereich im Einzelschrittmodus aus und beobachtet dabeiden Zustand des Programmes mit Hilfe der zuvor geöffneten Fenster (Memory-Fenster,

18

Abbildung 10: Das Flag-Fenster

Stack-Fenster, ...).

Abbildung 11: Die typische Arbeitsumgebung während der Emulation

19

6 Anhang B - Erklärung des Inhaltes der Datei Tem-plate.asm

6.1 Inhalt dieses Dokuments

Dieses Dokument beschreibt den Inhalt der Datei Template.asm. Diese Datei dient demPraktikanten als Vorlage für seine eigenen Programmtexte.

6.2 Quellcode

01: name "Template"02:03: include "data.inc"04:05: org 0100H06:07: .MODEL TINY ;Das Speichermodell08:09:10: .DATA ;Beginndes Datensegments11:12: #hier werden eigene Daten eingefügt13:14: .CODE15: start:16:17: #hier wird eigener Quellcode eingefügt18:19: ende: HLT

6.3 Erläuterung

Zeile 01: Hier wird der Name der Datei angegeben, welche entstehen würde, wenn manden Quellcode compilieren würde. Im Rahmen des Praktikums werden die Quelldateiennicht compiliert, sondern lediglich emuliert. Daher ist diese Zeile unwichtig und kann weggelassen werden.Zeile 03: Hier wird der Quellcode der Datei "data.inc" eingebunden. Diese Direktive be-wirkt, dass der Quelltext der Datei "data.inc" vor dem compilieren bzw. emulieren direktan diese Stelle kopiert wird. Der Inhalt der Datei "data.inc" realisiert eine Speichervor-belegung.Zeile 05: Hier teilt man dem Compiler bzw. Emulator mit, dass er den Maschinencodean 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

Speicher geladen wird. Wählt man das Speichermodell TINY, so werden Daten und Codein ein einziges Segment geladen, welches auf eine Größe von 64KB begrenzt ist. Der Com-piler 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 64KBgeladen und der Compiler würde eine EXE-Datei erzeugen. Aufgrund diverser Beschrän-kungen, 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. Da-ten, Variablen und Puffer definiert.Zeile 14: .CODE definiert den Anfang des Codesegments. Nach .CODE folgen die Be-fehle.Zeile 19: HLT teilt dem Compiler mit, dass hier das Programm zu Ende ist. Währendder Emulation wird der Programmlauf hier beendet.

6.4 Ein einfaches Programm

Das folgende Programm wurde unter Verwendung des Templates erstellt. Es demonstrierteine einfache Konsolenaussgabe mit Hilfe von DOS-Interrupts.

01: name "Template"02:03: include "data.inc"04:05: org 0100H06:07: .MODEL TINY ;Das Speichermodell08:09:10: .DATA ;Beginn des Datensegments11:12: Meld DB "Hallo Welt!$" ;Die Meldung13:14: .CODE15: start:mov ax,@data ;Adresse des Datensegments (@data) nach ax16: mov ds,ax ;Datensegmentadr. in Segmentregister17: mov dx,OFFSET Meld ;Die Offsetadresse von Meldung nach dx18: mov ah,09h ;Den Wert neun nach ah schieben19: int 21h ;Interrupt 21h Funktion 09h aufrufen20: ;= Write String. Geschrieben wird bis zum $21: mov ah,4Ch ;DOS Funktion Programm beenden22: int 21h ;Programm beenden19: ende: HLT

21

6.5 Erläuterung

Das Grundgerüst der Quellcodedatei wurde bereits weiter oben erläutert. Im Folgendenwird der Inhalt des Beispielprogramms näher erläutert.

Zeile 12: Hier wird die Variable Meld angelegt. Über diese Variable kann später einSpeicherbereich angesprochen werden, der an dieser Stelle mit einer Zeichenkette vor-belegt wird. Dafür muss zuerst der Variablenname angegeben werden, dann folgt derDatentyp, in diesem Fall DB (Das B in DB steht für Byte. Es zeigt an, dass es sich beidem Speicherbereich um eine Sequenz von Bytes handelt. Eine Alternative wäre DW, wasden Speicherbereich zu einer Sequenz von Words macht – hier nicht von Belang). Zuletztfolgt die Belegung des Speicherbereichs. Soll der Speicher mit einer Zeichenkette belegtwerden, so muss diese in Anführungszeichen angegeben werden.Zeile 15: Hier wird die Anfangsadresse des für die Variable Meld reservierten Speicher-bereiches in das Register DX geladen um den Text in Meld mit Hilfe der folgenden In-terruptroutine ausgeben zu können. Mit Hilfe des Vorsatzes OFFSET kann man die An-fangsadresse einer beliebigen Variablen abrufen.Zeile 16/17: Hier wird die Dos-Interruptroutine zur Ausgabe eines Textes auf der Kon-sole aufgerufen um den in Meld enthaltenen Text auszugeben.Zeile 19/20: Hier wird eine Dos-Interruptroutine zum Beenden des Programmes aufgeru-fen. Damit wird das Programm explizit durch das simulierte Betriebssystem des emu8086-Emulators beendet. Diesen Aufruf kann man auch weg lassen, da das Programm beimErreichen des HLT-Befehls implizit beendet wird.

22

Praktikumsanleitung...3 Vorbemerkungen In Vorbereitung auf das Praktikum können Sie eine...

Documents

Transcript of Praktikumsanleitung...3 Vorbemerkungen In Vorbereitung auf das Praktikum können Sie eine...