Praktikumsanleitung Technische Informatik - tu-ilmenau.de · In Vorbereitung auf das Praktikum können Sie eine Demoversion der Simulationsum- gebung emu8086 von der Website downloaden

+LA

TEX

+KD

+Em

u80

86-A

nle

itung.

tex

+26

.M

ärz

2013

+

Praktikumsanleitung

"Technische Informatik"

Studiengang: WIW

Christian VollmerStudent M 2004Dr. K. Debes

FG Neuroinformatik & Kognitive RobotikDr. K. Henke

FG Integrierte Hard- und Softwaresysteme

Versuch Emulator 8086Version 1.6 vom 27.3.2013

TU Ilmenau, Fakultät Informatik und AutomatisierungInstitut für Technische Informatik und Ingenieurinformatik

FG Neuroinformatik und Kognitive Robotik

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 145.1 Inhalt dieses Dokuments . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145.2 Editorfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145.3 Programm emulieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155.4 Typischer Ablauf der Emulation eines Programmes . . . . . . . . . . . . . 19

6 Anhang B - Erklärung des Inhaltes der Datei Template.asm 216.1 Inhalt dieses Dokuments . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216.2 Quellcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216.3 Erläuterung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216.4 Ein einfaches Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226.5 Erläuterung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

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 analysiert und interpretiert wer-den.

2 AblaufNach Anmeldung mit dem für das Praktikum erforderlichen Login (ap6rzwdxxx \ emumit xxx = Arbeitsplatznummer) und Passwort (emu80861) bekommen Sie vom Betreuereine Quellcodedatei "template.asm", die als Basis für ihre Quelltextentwürfe dient (liegtim Arbeitsverzeichnis). Des weiteren bekommen Sie für jede zu lösende Aufgabe je einevom Betreuer erstellte, zur jeweiligen Aufgabe passende inc-Datei, welche per "include"-Direktive automatisch (diese Direktive ist schon in der vorgegebenen Quellcodedatei ent-halten) in ihr Programm eingebunden wird und eine vom Betreuer definierte Speicher-belegung zum Beginn der Laufzeit ihres Programmes herstellt. Sie müssen nur noch denNamen der include-Datei aufgabenspezifisch ergänzen (z.B. data1_1.inc). Der Betreuerteilt ihnen nun mit, welche Aufgabe Sie zuerst lösen sollen. Sollten Sie in Vorbereitungauf das Praktikum diese Aufgabe bereits gelöst haben und den fertigen Quelltext in aus-gedruckter Form zum Praktikum mitgebracht haben, so können Sie nun ihren Quelltextabtippen. Mit Hilfe der Emulationsfunktionen des emu8086 simulieren Sie anschließendIhr erstelltes Programm und machen sich gegebenenfalls Notizen, sofern in der Aufgabeeine Aussage zum Programmverlauf gefordert ist. Nachdem Sie die Lösung, einschließlichder Beobachtungen des Programmverlaufes, fertig gestellt haben, melden Sie sich beimBetreuer. Der Betreuer beurteilt nun die Korrektheit ihrer Ergebnisse und stellt gegebe-nenfalls vertiefende Fragen. Nachdem Sie ein zufriedenstellendes Ergebnis erzielt haben,

2

teilt der Betreuer Ihnen mit, welche Aufgabe Sie als nächstes lösen sollen. Alle Ergeb-nisse zusammen mit Ihrer Vorbereitung werden als Protokoll eingesammelt!

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 template.asm, welche Ihnen auch vom Betreuer wäh-rend des Praktikums vorgegeben wird. Diese können Sie als Basis für eigene Experimen-te 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 Emu-lationsumgebung, welche die im Rahmen des Praktikums nötigen Funktionen des Pro-grammes darstellt und erläutert. Anhang B enthält eine Erläuterung der vorgegebenenQuellcodedatei template.asm. Das (normalerweise voreingestellte) Arbeitsverzeichnis fürden Emulator auf Ihrem Arbeitsplatz lautet:c : \Benutzer \ emu \ software \ tempDort werden auch Ihre Programme gespeichert, die Sie unter einem sinnvollen Namenabspeichern sollten.Um einen umfassenden Überblick über den Ablauf des Praktikums zu bekommen, solltenSie dieses Dokument vollständig lesen, bevor Sie mit der weiteren Arbeit beginnen!

4 AufgabenIm Folgenden sind die während des Praktikums zu lösenden Aufgaben dargestellt. Fürden Studiengang WIW sind von den Studierenden die folgenden Aufgaben verbindlich fürdas Praktikum Emulator 8086 vorzubereiten:

1.1 / 1.2 / 1.3 / 1.4 / 2.1 / 2.2 / 2.4 / 3.1

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.und analysieren Sie die Funktionsweise des Programmes. Welche Funktionalität realisiertdas Programmstück?

Listing 1: Vorgegebener Assembler-CodeMOV AL, 1

3

m1: MUL BLDEC CXJNZ m1

Emulieren Sie den Programmlauf mit dem Assembler-Emulator emu8086. Starten Sie dieEmulation. Führen sie nun die Anweisungen schrittweise mit Hilfe der Step-Funktion biszum Erreichen der Anweisung HLT aus. Beobachten Sie dabei die Veränderungen derRegister und der Prozessor-Status-Flags nach jedem Befehl. Leiten Sie aus Ihren Beob-achtungen Vermutungen über die Funktion der Befehlsfolge ab.

Ändern Sie nun die Befehlsfolge folgendermaßen:

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

m1: MUL DLDEC CXJNZ m1

Führen Sie nun wiederum die Anweisungen schrittweise mit Hilfe der "Step"-Funktionbis 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 Un-terschiede beobachten Sie im Vergleich zur Abarbeitung der vorhergehenden Befehlsfolge.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.


Übernehmen Sie folgende Assember-Befehlsfolge in Ihr Assembler-Template template.asmund analysieren Sie die Funktionsweise des Programmes. Welche Funktionalität realisiertdas Programmstück?

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

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

4

Emulieren Sie den Programmlauf mit dem Assembler-Emulator emu8086. Starten Sie dieEmulation. Führen Sie nun die Anweisungen schrittweise mit Hilfe der Step-Funktion biszum Erreichen der Anweisung HLT aus. Beobachten Sie dabei die Veränderungen derRegister und der Prozessor-Status-Flags, sowie die Speicherinhalte an den im Programmadressierten Speicherstellen nach jedem Befehl. Leiten Sie aus Ihren Beobachtungen Ver-mutungen ü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 ] , CLINC SICMP SI , DXJNE m1

Führen Sie nun wiederum die Anweisungen schrittweise mit Hilfe der Step-Funktion biszum Erreichen der Anweisung HLT aus. Beobachten Sie auch hierbei wieder die Verän-derungen der Register und der Prozessor-Status-Flags, sowie die Speicherinhalte an denim Programm adressierten Speicherstellen nach jedem Befehl. Welche Unterschiede beob-achten Sie im Vergleich zur Abarbeitung der vorhergehenden Befehlsfolge. Was bedeutendiese 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 zwei dimen-sionalen Byte-Arrays demonstrieren. Dabei wird ein bestimmtes Array-Element in einRegister eingelesen. Übernehmen Sie folgende Assember-Befehlsfolge in Ihr Assembler-Template template.asm und analysieren Sie die Funktionsweise des Programmes. GebenSie sich ein Matrix-Element vor und aktualisieren Sie den Registerinhalt DI und SI ent-sprechend. Worin liegt die Schwierigkeit bei der unterschiedlichen Vorgehensweise in dermathematischen Notation und in der programmtechnischen Realisierung?Im Datenfile wird BP mit 200H gefüllt, CX und BX jeweils mit 3.

Listing 5: Vorgegebener Assembler-Code

5

MOV 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 = ZeilenanzahlBX = SpaltenanzahlDI = Selektierte Zeile (bei 0 beginnend)SI = Selektierte Spalte (bei 0 beginnend)CL = Zielregister

Emulieren Sie den Programmlauf mit dem Assembler-Emulator emu8086. Starten Sie dieEmulation. Führen sie nun die Anweisungen schrittweise mit Hilfe der Step-Funktion biszum Erreichen der Anweisung HLT aus. Beobachten Sie dabei die Veränderungen derRegister und der Prozessor-Status-Flags, sowie die Speicherinhalte an den im Programmadressierten Speicherstellen nach jedem Befehl. Erklären Sie die Bedeutung der einzelnenBefehle 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. Wiederholen Sie die Arten von Programmver-zweigungen aus den Vorlesungen des 1. Semesters!


Übernehmen Sie folgende Assember-Befehlsfolge in Ihr Assembler-Template template.asmund analysieren Sie die Funktionsweise des Programmes. Welche Funktionalität realisierendie 4 Programmblöcke?

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 m5

6

SHL 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

m11 : ; Ende von Block4

Emulieren Sie den Programmlauf mit dem Assembler-Emulator emu8086. Starten Sie dieEmulation. Führen Sie nun die Anweisungen schrittweise mit Hilfe der Step-Funktion biszum Erreichen der Anweisung HLT aus. Beobachten Sie dabei die Veränderungen derRegister und der Prozessor-Status-Flags nach jedem Befehl. Die vier AnweisungsblöckeBlock1, . . . , Block4 realisieren je eine typische Kontrollstruktur der strukturierten Pro-grammierung. Ordnen Sie jedem Block jeweils einen der folgenden Begriffe zu:

• 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. Wiederholen Sie Ursachen und Lösungen für die Korrektur von Be-rechnungen mit BCD-Zahlen.

7


Übernehmen Sie folgende Assember-Befehlsfolge in Ihr Assembler-Template template.asmund analysieren Sie die Funktionsweise des Programmes. Welche Funktionalität realisiertdas Programmstück?

Listing 7: Vorgegebener Assembler-CodeADD AL, AHADC CL , CHSUB BL , BHSBB DL, DH

Emulieren Sie den Programmlauf mit dem Assembler-Emulator emu8086. Starten Sie dieEmulation. Führen Sie nun die Anweisungen schrittweise mit Hilfe der Step-Funktion biszum Erreichen der Anweisung HLT aus. Beobachten Sie dabei die Veränderungen derRegister und der Prozessor-Status-Flags nach jedem Befehl. Achten Sie dabei besondersauf die Veränderungen im Carry- und im Overflow-Flag. Erklären Sie das Verhalten derFlags. 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 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 Endein 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.

8

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.


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

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 Siedie Emulation. Führen Sie nun die Anweisungen schrittweise mit Hilfe der Step-Funktionbis zum Erreichen der Anweisung HLT aus. Beobachten Sie dabei die Veränderungen derRegister und der Prozessor-Status-Flags nach jedem Befehl. Achten Sie dabei Besondersauf 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.

9

4.8 Aufgabe 2.4

4.8.1 Vorbereitung

Informieren Sie sich zur Vorbereitung über die Syntax und Semantik der Befehle ADD,ADC, DAA, SBB, SUB.


Übernehmen Sie folgenden Assember-Befehl in Ihr Assembler-Template template.asm undanalysieren Sie die Funktionsweise des Programmes.

Listing 9: Vorgegebener Assembler-CodeADD AL, BL

Der Assemblerbefehl führt eine Addition zweier BCD-Zahlen, gegeben in AL und BL, aus,macht dabei aber einen gravierenden Fehler. Erläutern Sie das Problem.

Ergänzen Sie die Routine so, dass nach deren Abarbeitung in AL das korrekte Ergeb-nis in 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. Eine include-Datei ist für dieses Beispiel nicht erforderlich (die entspre-chende Zeile im template.asm ist mit # auszukommentieren.



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.

10

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 enINT 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

11

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.

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.

12

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.

13

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

14

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

15

Abbildung 4: Meldung bei Fehlerhafter Syntax

Abbildung 5: Das Hauptfenster des Emulators

16

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-

17

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

18

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,

19

Abbildung 10: Das Flag-Fenster

Stack-Fenster, ...).

Abbildung 11: Die typische Arbeitsumgebung während der Emulation

20

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.(Muss für jede Aufgabe angepasst werden: z.B. data1_1.inc für Aufgabe 1.1).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

21

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

22

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.

23

Documents

Praktikumsanleitung Technische Informatik - tu-ilmenau.de · In Vorbereitung auf das Praktikum können Sie eine Demoversion der Simulationsum- gebung emu8086 von der Website downloaden