Computer Architektur

Transkript

1 Fakultativfach Informatik 2001/ Die Sache mit den Bit und Byte Man weiss es längst: Im Computer drin gibt's nur 1 und 0: Entweder hat es an einer bestimmten Stelle eine Spannung oder eben nicht! Also gibt es immer eine von zwei Möglichkeiten (mit Ausnahme von "Tri-State"): Spannung keine Spannung 1 0 Schalter ein Schalter aus Lampe leuchtet Lampe leuchtet nicht wahr falsch ja nein Elektronik, welche nur mit zwei Zuständen arbeitet wird Digitaltechnik genannt. Im Gegensatz dazu gibt es die Analogtechnik. Bei den Rechnern (und in vielen andern Bereichen der Elektronik) hat sich klar die Digitaltechnik durchgesetzt. Beispiele: 1. Die Piratenkiste: Auf dem Piratenschiff befindet sich die Schatzkiste. Sie ist mit fünf Schlössern abgeschlossen, zu denen vier verschiedene Schlüssel A bis D passen (siehe Figur). Der Piraten Kapitän hat einen speziellen Schlüssel, seine zwei Stellvertreter haben ebenfalls je einen unterschiedlichen Schlüssel. Die Matrosen haben alle den selben Schlüssel. Wir können die Zustände auch hier mit 0 und 1 bezeichnen: Kiste ist offen = 1, Kiste ist abgeschlossen = 0, Schloss ist offen = 1, Schloss ist zu = 0. Preisfrage: Wem gehören die Schlüssel? Kapitän hat Schlüssel Vize haben Schlüssel und Schlüssel Matrosen haben Schlüssel

2 2. Ein Stromkreis mit Batterie (V1), Schalter (S1) und Lampe (L1). Ist der Schalter in der oberen Position, so fliesst ein Strom und die Lampe leuchtet, andernfalls nicht. Die Schaltung hat also genau zwei Zustände. Die Auflistung aller Zustände nennen wir Wahrheitstabelle. Nach der Figur ist die Wahrheitstabelle für diese Schaltung gezeigt. S1 + V1 10V L1 Wahrheitstabelle Schalter S1 Lampe L Logik Logik mit 0 und 1 bezeichnet man als Bool'sche Algebra. Es gibt drei grundlegende logische Zusammenhänge in der Bool'schen Algebra: Seite 2

3 Symbole für logische Verknüpfungen: Beispiel: UND Verknüpfung mit zwei Schaltern realisiert: Seite 3

4 S1 S2 + V1 10V L1 Aufgabe: Realisieren Sie eine ODER Schaltung mit zwei Schaltern und zeichnen Sie das Schaltschema: Aufgabe: Formulieren Sie die Funktionsweise der Schlösser mit Hilfe der Verknüpfungen UND, ODER und NICHT: Die Kiste ist offen, wenn Schloss.. offen ist. Seite 4

5 Takt Eine einfache Taktschaltung: Über einen Widerstand wird ein Kondensator geladen. Ist er geladen, wird er wieder entladen und der andere Kondensator wird geladen, usw. Die Dauer eines Taktes wird bestimmt durch das Produkt von Kapazität des Kondensators mal Widerstand. Im Experiment ist das ca. 1 Sekunde: 1000 µf. 1 kω = 1 s. Einmal pro Sekunde ist also unsere Takt - Frequenz. Das nennen wir ein Hertz. Tausend Hertz (Hz) ist ein Kilohertz (khz), eine Million Hertz ist ein Megahertz (MHz) und eine Milliare Hertz ist ein Gigahertz (GHz). Bei gegenwärtigen Prozessoren ist die Taktfrequenz bei ca. 100 MHz. Ein einzelner Takt dauert demnach ca.. Speicher Ein einfacher Speicher: Unsere Speicherschaltung kann genau einen von zwei Zuständen einnehmen. Ist der Zustand so, dass am Ausgang Q eine Eins ist, so sagen wir, in unserem Speicher sei eine Eins gespeichert, andernfalls eine Null. Eine von zwei Möglichkeiten ist die kleinste Informationsmenge, die es gibt. Wir nennen sie bit. Wenn wir zwei solche Speicher kombinieren, so kann jeder eine 1 oder 0 speichern: Insgesamt gibt es 4 mögliche Zustände: 2 bit Information ist also eine von 4 Möglichkeiten: Anzahl bit Anzahl Möglichkeiten Seite 5

6 Zahlensysteme Unser Zahlensystem funktioniert nicht in der Digitaltechnik, weil es mit 10 Ziffern (eine von 10 Möglichkeiten) arbeitet. Wir müssen umrechnen in ein System mit nur 2 Ziffern (0 und 1): Dezimal Dual Hexadezimal Der ASCII Code Bisher haben wir gesehen, wie Zahlen mit lauter 0 und 1 dargestellt werden können mit Hilfe des dualen Zahlensystems. Ein Computer muss aber auch mit Zeichen umgehen können. Für jedes Zeichen braucht unser PC acht bit. Er kann also verschiedene Zeichen voneinander unterscheiden. Die Zuordnung zwischen den acht bit und einem Zeichen heisst Code. Sehr verbreitet ist der American Standard Code for Information Interchange (ASCII): (Bit Nummer 7 ist beim Standard Code null. Ist bit Nummer 7 eins, können noch einmal 128 Zeichen verschlüsselt werden. Diese Verschlüsselung ist aber nicht einheitlich. Das liefert all die Probleme mit äöü, etc.!) Seite 6

7 Aufgabe: Entschlüsseln Sie folgende ASCII Codes: F 65 Seite 7

8 2. Der Hauptspeicher So ähnlich sieht es im Hauptspeicher (RAM) eines PC aus. Lauter Nullen oder Einsen! Beim 1 - bit - Speicher haben wir gesehen, wie eine Speicherstelle elektronisch realisiert wird. Die Frage ist nur, welche Ordnung im Hauptspeicher herrscht. Dabei gibt es zwei wichtige Dinge: Die bits haben nur für ein Programm, das im Hauptspeicher abläuft eine Bedeutung. Und: Ein Programm muss eine bestimmte Position im Speicher durch Adressierung bezeichnen können. Bedeutung: Die Bitkombinationen bedeuten für ein Computerprogramm eines der folgenden drei Dinge: Zahlen (dual) Zeichen (ASCII) Befehle (Maschinensprache). Die ersten beiden Bedeutungen kennen wir bereits, die dritte wird später erklärt. Adressierung: Im Hauptspeicher werden immer 8 bit (= 1 Byte) zusammengefasst. Jedes solche "Päckli" von bits hat eine Adresse. Man könnte also den Hauptspeicher etwa folgendermassen schematisch darstellen: Adresse: Speicherstelle mit Inhalt: A B F FFFFE FFFFF Aus wievielen bit besteht die grösste Adresse, also FFFFF? Länge der Adressen in bit:. Seite 8

9 Die Prozessoren 8088 / 8086 / konnten nur 16 bit adressieren. Das ergibt eine Speichergrösse von Byte. Für grössere RAM müssen die restlichen bit mit Hilfe eines Tricks angesprochen werden: Die effektive (physikalische) Adresse besteht aus der Summe zweier logischer 16 bit Adressen: Segment- und Offset - Adresse: Wenn wir eine physikalische Adresse angeben, geben wir Segment- und Offsetadresse an, getrennt durch einen Doppelpunkt: 0012:000F Dies ergibt die physikalische Adresse. Die Physikalische Adresse hat 20 bit. Dies bedeutet, dass ein 16 bit Prozessor direkt bis zu 1 Mega Byte RAM adressieren kann. So, jetzt ist es an der Zeit, dass Sie sich im Hauptspeicher etwas umsehen und prüfen ob Sie das, was Sie sehen mit dem bisher gesagten in Einklang bringen können: Sitzen Sie an einen PC und starten Sie ihn. Wählen Sie im Startmenü Programme und MS-DOS-Eingabeaufforderung. Sie haben ein schwarzes Fenster geöffnet, in welchem Sie Befehle für das Betriebssystem MS-DOS eingeben können. In neueren Windows Versionen ist dieses Betriebssystem nicht mehr vorhanden und wird dort nur noch simuliert. Sie können Ihren PC auch ohne Windows, nur mit dem Betriebssystem MS- DOS laufen lassen, indem Sie Start, Beenden, Im MS-DOS Modus neu starten wählen. Geben Sie folgenden Befehl ein: debug (am Schluss Eingabetaste drücken!) Seite 9

10 Damit ist das Programm namens DEBUG gestartet. DEBUG ist Bestandteil des Betriebssystems MS-DOS und ist gedacht als Hilfe bei der Fehlersuche (debug heisst "entkäfern!). Geben Sie hinter dem Bindestrich ein: -d500:0 d steht für DUMP. Die Zahlen stehen für eine Speicherstelle (Segmentadresse : Offsetadresse). Versuchen Sie die Bildschirmausgabe zu interpretieren. Geben Sie DUMP auch mit andern Adressen ein. Gelingt es Ihnen, den selben Speicherbereich auf zwei verschiedene Arten zu adressieren? Notieren Sie sich auftauchende Fragen: Haben Sie bemerkt, dass die Bildschirmausgabe von DUMP folgendermassen zu interpretieren ist?: Adresse der ersten Speicherinhalt hexadezimal, Speicherinhalt w. Speicherstelle in 16 Byte pro Zeile, Bindestrich m. interpretiert der Zeile: nach 8 Byte: als ASCII: 0000:0000 9E 0F C EC e.p...e.p. 0000: FF 00 F0-80 B5 00 F0 6F EF 00 F0 e.p.t...o : C8 D2 08 CA 0A-6F EF 00 F0 6F EF 00 F0...o...o :0030 6F EF 00 F0 6F EF 00 F0-9A 00 EC o...o...e.p. 0000: C8 4D F8 00 F0-41 F8 00 F F FD..u.M...A...'%_. 0000: E7 00 F B4 06-2D A B @...-.p.( :0060 A4 E7 00 F0 2F 00 AF 0A-6E FE 00 F B /...n :0070 1D C8 A4 F0 00 F "..."Q. Sehen Sie sich z.b. die letzten 16 Byte des Hauptspeichers an. Haben Sie das Datum im ASCII - Teil des Bildschirms gesehen? An diesem Datum wurde das sogenannte BIOS Ihres Computers "gemacht". Das BIOS ist ein Programm, welches permanent im Hauptspeicher vorhanden ist. Das scheint ein Widerspruch zu sein, denn sobald Sie den Computer ausschalten, geht sämtliche Information des RAM verloren! Der Hauptspeicher besteht aber eben nicht nur aus RAM ( = Random Access Memory = Speicher so, wie wir ihn auf Seite 6 kennengelernt haben), sondern auch aus ROM ( = Read Only Memory = Speicher nur zum lesen, dafür Information aber auch ohne Strom gespeichert ). Und wie Sie in der Tabelle unten sehen, ist das BIOS ROM bei den höchsten Adressen: Aufteilung des RAM Speichers für DOS: Blöcke Adresse Inhalt 15 F000:0000 F000:FFFF BIOS PROM D000:0000 E000:FFFF frei 12 C000:0000 C000:FFFF BIOS 11 B000:0000 B000:FFFF Video RAM 10 A000:0000 A000:FFFF zusätzliches Video RAM : :FFFF RAM Seite 10

11 Sehen Sie sich im BIOS etwas um! Um jeweils "weiterzublättern" zu den nächsten Adressen können Sie d ohne Adresse eingeben - das geht schneller. Seite 11

12 DEBUG Anweisungen: Nebst dem Anzeigen von Speicherinhalt kann der Debuger noch mehr. Z.B.: DEBUG Anweisungen: Eingabe: Befehlsname: Beispiel: -d DUMP -df000:fff0 -h HEX -hf7b A4E -e ENTER -B000:80A8 -q QUIT -q -r REGISTER -rcs -t TRACE -t -n NAME -nzeichen -w WRITE -w -u UNASSEMBLE -u100 -g GO -g HEX addiert und Subtrahiert zwei Hexadezimalzahlen - versuchen Sie's! ENTER ermöglicht das Eingeben von Werten an bestimmten Speicherstellen. Zuerst wird der bisherige Inhalt angezeigt. Dahinter können Sie den neuen Inhalt eintippen. Betätigen Sie nach dem Tippen die Leertaste, so können Sie die nächste Speicherstelle verändern, betätigen Sie die Eingabetaste, so wird ENTER abgeschlossen. Verändern Sie ruhig irgendwelche Speicherstellen, seien Sie aber nicht erstaunt, wenn der Rechner dabei abstürzt! Versuchen Sie auch, den ROM - Bereich zu verändern! QUIT: Mit diesem Befehl verlassen Sie DEBUG. ( Die weiteren Befehle werden im Zusammenhang mit Maschinenprogrammen erläutert. ) Das Video RAM Sie erkunden nachfolgend das Vidoe RAM von DOS, obschon die Ansteuerung des Bildschirmes unter einem grafischen System wie Windows anders vor sich geht. Ich denke aber, dass Sie bei dieser Erkundung Grunzätze erleben, die Ihnen in anderen Zusammenhängen sehr hilfreich sind. Für diese Übung müssen Sie Windows verlassen und den PC im MS-DOS Modus starten wie oben beschrieben. Falls auf dem Bildschirm schon einiges steht, geben Sie den MS - DOS Befehl CLS ( = Clear Screen = lösche Bildschirm ) ein. Damit haben Sie "tabula rasa" auf dem Bildschirm und sind bereit, diesen zu erkunden. Für diese Erkundung starten Sie wieder DEBUG und speichern mit ENTER an der Adresse B000:809E den Wert 2A. Sehen Sie den Stern oben rechts am schwarzen Himmel Ihres Bildschirmes? Wenn nein, dann rufen Sie mich bitte. Wenn ja, dann überprüfen Sie, was das 2A bedeutet, das Sie eingegeben haben und die 20, die vorher abgespeichert war mit Hilfe der ASCII - Tabelle Seite 5. Seite 12

13 Geben Sie an der Adresse B000:809E den Wert 2B ein. Haben Sie das Pluszeichen? Sie sehen, dass Sie jedes ASCII Zeichen darstellen können, indem Sie es an diese Speicheradresse schreiben. Geben Sie an der Adresse B000:809C den Wert 2A ein. Vor dem Pluszeichen ein Stern? Sie sehen, dass jede zweite Speicheradresse einer Stelle auf dem Bildschirm entspricht. Spielen Sie mit andern Adressen und andern Zeichen! Wie wär's z.b., wenn Ihre Initialen mitten auf dem Bildschirm zu sehen wären? Das Video RAM beginnt bei B000:8000 und endet bei B000:8F9F, wobei die Zeichen in den geraden Speicherplätzen sind und die Zeilen von links nach rechts und von oben nach unten der Reihe nach im Speicher sind. Das ergibt den Standart Textschirm von DOS mit 25 Zeilen mal 80 Zeichen, also insgesamt 2000 Zeichen. Was ist aber mit den ungeraden Speicherstellen. Das sollen Sie testen. Stellen Sie sicher, dass Sie oben rechts auf dem Schirm zwei Zeichen haben, *+ zum Beispiel. Geben Sie dann an der Adresse B000:809D den Wert 87 ein: Das zweithinterste Zeichen sollte blinken. Oder dann an der Adresse B000:809F den Wert 01: Das hinterste Zeichen sollte blau sein. Des Rätsels Lösung: Die ungeraden Bytes enthalten das Attribut des Zeichens davor! In der Hexziffer rechts steht die Vordergrundfarbe, in der links die Hintergrundfarbe. Mit einer Ausnahme: Das höchstwertige bit im Byte schaltet das Blinken ein und aus. Für die Hintergrundfarbe stehen also nur 3 bit zur Verfügung. Ihrem Spieltrieb sollten jetzt keine Grenzen gesetzt sein! (Noch ein Tip: Die Taste <F3> holt Ihre letzte Eingabe erneut auf den Schirm, was die Arbeit sehr erleichtert. Sie können diese Taste übrigens auch beim Eingeben von MS - DOS - Befehlen verwenden. Seite 13

14 Der Zugriff auf das RAM in Digitaltechnik: Digitaltechnik im Internet: Wählen Sie: Repetieren Sie im Bereich Digitaltechnik, Logische Grundverknüpfungen. Arbeiten Sie sich im Bereich Digitaltechnik, Rechenschaltungen in das Thema Arithmetik mit Digitalstechnik ein. Wenn Sie Lust haben, können Sie sich auch im Bereich Speicher... etwas genauer die FlipFlops ansehen. Die verschiedenen Typen von Halbleiterspeichern finden Sie unter Computertechnik, Grundlagen. Zwei bit Addierer: Bauen Sie mit dem Elektronikkasten einen zwei - bit Addierer auf. Testen Sie den Addierer und damit Ihre Kenntnisse des dualen Zahlensystems. Infos über Hardware: Seite 14

15 Seite 15

16 Computer Architektur 3. CPU Eine Zentraleinheit (CPU) sieht schematisch folgendermassen aus: Als konkrete Hardware, der Athlon von AMD: Seite 16

17 Computer Architektur Die 16 Bit Register der 80X86 Prozessorfamilie: Ab sind die Register (ausser Segmentregister) 32 bit breit, können aber weiter als 16 bit Register verwendet werden. Der Speicherzugriff über die Register: Seite 17

18 Computer Architektur Die Verbindungen eines Prozessors nach aussen: Aktuelle Informationen über aktuelle Prozessoren: Intel Pentium: Das Datenblatt zum Pentium 4: (.pdf Datei mit 25 Mbyte!) AMD, die Konkurrenz: Der Athlon Prozessor: Seite 18

19 4. Maschinensprache In diesem Kapitel lernen Sie die Maschinensprache der 80x86 Prozessorfamilie kennen. Ziel ist, zu erkennen, was eine Maschinensprache ist und die Grundlage für die anschliessende Assembler - Programmierung zu legen. Das Maschinensprachprogramm, das aus einem einzigen Befehl besteht: Öffnen Sie wieder ein DOS - Fenster und geben Sie den Befehl DEBUG ein. Sehen Sie sich den Anfang des Segmentes 5000 an mit -d5000:0 Sind alle Speicherinhalte null? Wenn nicht, dann rufen Sie mich! Andernfalls tippen Sie jetzt das Programm in Maschinensprache ein: -e5000:0<eingabetaste> a3<leertaste> 50<Leertaste> 05<Eingabetaste> Und jetzt schauen Sie sich Ihr erstes Maschinensprachprogramm gemütlich nochmals an: -d5000:0 Die ersten drei Bytes sollten Ihr Programm (A ) enthalten! Bevor Sie Ihr umwerfendes Programm starten können, müssen Sie den Inhalt einiger Register verändern. Den Inhalt aller Prozessorregister zeigt Ihnen DEBUG, wenn Sie eingeben: Den Inhalt einzelner Register ändern Sie auch mit dem Befehl -r ( = REGISTER), gefolgt vom Registernamen. Ändern Sie den Inhalt des Code - Segment - Registers, indem Sie tippen -r -rcs<eingabe> 5000<Eingabe> Überprüfen Sie mit dem Befehl R, ob das CS - Register wirklich 5000 enthält. Jetzt setzen Sie den Instruction Pointer auf null: -rip<eingabe> 0<Eingabe> IP und CS zeigen nun zusammen auf Ihren Maschinensprachbefehl! Jetzt verändern Sie den Inhalt des Daten - Segment - Registers: -rds<eingabe> b800 Damit zeigt das Daten - Segment auf den Anhang des Video - RAM! Zuletzt muß noch das AX - Register geladen werden: -rax<eingabe> 742a<Eingabe> Der Inhalt dieses Registers ist der ASCII - Code des Zeichens, das wir auf den Bildschirm schreiben wollen und sein Attribut. Mit dem Befehl t (TRACE) können Sie ein Programm Befehl um Befehl laufen lassen. Da Ihr Programm nur aus einem Befehl besteht, ist nur ein TRACE - Befehl möglich. Geben Sie also ein Seite 19

20 -t Ist der rote Stern auf weissem Grund irgendwo auf dem Schirm zu sehen? Herzliche Gratulation: Sie haben Ihr erstes Programm in Maschinensprache geschrieben und erfolgreich getestet! Wir wollen den Befehl dieses ersten Programmes analysieren. Vergleichen Sie mit der nachfolgenden Tabelle "Maschinencode": In der Tabelle, in der Kolonne "1. Byte" steht der Befehl hexadezimal. In unserem Falle ist es der Befehl A3. Was der tut, ersieht man aus der Kolonne "Mnemonik": Hier steht der Name des Befehls in einigermassen menschlicher Sprache. In unserem Falle steht MOV, Abkürzung für "move", zu deutsch "verschiebe". Der Maschinenbefehl MOV verschiebt also den Inhalt einer Speicherstelle an eine andere. Von wo wohin verschoben wird, das steht hinter dem Befehl. In unserem Falle "addr,ax". Das bedeutet: Aus dem Register AX in den RAM Speicher an die Adresse "addr". Verschiebungen etc. verlaufen immer von rechts nach links! Wo aber ist "addr" angegeben? Diese Adresse steht im 2. und 3. Byte, also direkt hinter dem Befehl. In der Tabelle ist das mit "pp" und "qq" symbolisch dargestellt, indem jeder Buchstabe für eine hexadezimale Ziffer steht. "pp" ist dabei das höherwertige Byte als "qq", wir würden also schreiben "ppqq", in unserem Falle 0550! Wohin im physikalischen RAM wird nun also der Inhalt des Registers AX verschoben? Sie haben mit rds in das Daten Segment Register den Wert b800 geladen, die Physikalische Adresse ist also b800:0550, irgendwo im Video RAM, wie Sie sehen, wenn Sie mit dem Kapitel über das RAM vergleichen. Und was wird verschoben? Eben der Inhalt des Registers AX, das Sie mit 742a geladen haben. Genau an die Adresse kommt das rechte Byte (2a), also der ASCII Code für *, an die nächste Stelle, in das Attribut - Byte, kommt das linke Byte (07), also die Bitkombination für rotes Zeichen (4) auf weissem Hintergrund (7). Ab jetzt ist pröbeln erwünscht. Dazu einige Hinweise: Der Befehl TRACE führt genau einen Maschinenbefehl aus und erhöht dabei den IP so, dass dieser auf den nächsten Befehl zeigt. Setzen Sie daher den IP immer wieder auf null, wenn Sie Ihr Programm erneut laufen lassen wollen. Variieren Sie das Zeichen, sein Attribut und seine Position Wichtige Befehle in Maschinensprache: MOV Move Verschiebe ADD Add Addiere SUB Subtract Subtrahiere MUL Multiply Multipliziere DIV Divide Dividiere INC Increment Erhöhe um eins DEC Decrement Erniedrige um eins OR Or Logisches Oder AND And Logisches Und XOR Excl. Or Exklusives Oder CMP Compare Vergleiche R.. Rotate Rotiere um 1 bit S.. Shift Verschiebe um 1 bit JMP Jump Springe nach Seite 20

21 J.. Jump bedingter Sprung Maschinensprache der 80x86 Prozessorfamilie: Seite 21

22 Seite 22

23 Seite 23

24 Seite 24

25 Seite 25

26 Aufgaben: 1. Verändern Sie das Programm von vorher so, dass der Stern eine Stelle weiter rechts blinkt. 2. Jetzt soll der Stern am Anfang einer Zeile blinken. Hinweis: Die erste Zeile ist natürlich am einfachsten. Aber da müssen Sie mit -q aus Debug aussteigen, mit CLS den Bildschirm löschen und mit DEBUG wieder einsteigen. Dabei bleibt das Programm erhalten, nicht aber die Registerinhalte! Für einen andern Zeilenanfang sehen Sie bitte nach wie viele Byte einer Zeile entsprechen. Ein Beispiel: Die Hex. - Zahl 500 entspricht dezimal Und das dividiert durch dezimal 160 gibt 8! 3. Anstatt des Sterns soll der Anfangsbuchstabe Ihres Vornamens grün blinken. 4. Das Zeichen und das Attribut könnte eigentlich auch das Programm ins AX - Register schreiben. Also ein Programm mit zwei Maschinenbefehlen: Zuerst Zeichen und Zahl ins AX (ich empfehle den Befehl b8, auch ein MOV - Befehl!) und dann wie vorher. Denken Sie daran, -t zweimal auszuführen! 5. Und nun noch Ihre Initialen! Also zwei Zeichen schreiben: Nach dem Schreiben des ersten Zeichens das zweite mit b8 ins AX verschieben und dann mit a3 an die übernächste Stelle im Bildschirmspeicher verschieben. Probieren Sie's aus, es geht, aber wegen dem Scrollen ist das erste Zeichen schon verschoben, wenn das zweite erscheint. Dem helfen wir ab, indem wir das Programm als ganzes laufen lassen: Merken Sie sich, welche Zahl am Ende des Programms (nach dem letzten Trace) im IP Register ist (bei mir ist das 000C). Stellen Sie den IP auf null und starten Sie das Programm mit dem Debug - Befehl GO. Hinter dem Befehl müssen Sie angeben, wo Ihr Programm zu Ende ist, sonst wird der ganze restliche Speicherinhalt als Programm ausgeführt - und das gibt wohl sicher einen Crash! Sie geben also die Zahl, die Sie sich soeben gemerkt haben hinter -g ein. Ich z.b. starte mein Programm mit -g00c oder auch einfacher mit -gc. Sie können GO auch sagen, wo Ihr Programm beginnt, dann ist die Sache mir -rip nicht mehr nötig: -g=0 c 6. Jetzt können Sie Ihr Programm weiter ändern (einen ganzen Text schreiben lassen z.b.) oder sich auch was ganz anderes ausdenken (z.b. zwei Zahlen subtrahieren; Achtung: Unsere Programme können noch nichts mit einer Tastatur anfangen. Also müssten die zu berechnenden Zahlen entweder im Programm oder in Registern sein). Viel Spass beim Pröbeln! Und: Falls dabei etwas interessantes herausgekommen ist, bringen Sie es mit -d auf den Bildschirm und drucken Sie es (falls Sie Windows verlassen haben, indem Sie die Taste "Printscreen" drücken, fall Sie ein DOS Fenster haben mit Copy und Paste in den Windows Editor). 7. Und noch ein Programm zum Studieren und Ausprobieren: -d1000:0 1000:0000 B8 00 B8 8E D8 B9 FF 00-B8 00 5A BB Z : FF C0 FF C3 FF C3-E2 F : : : : : : Wenn Sie das Programm eingetippt haben, können Sie es starten, indem Sie das CS (falls nötig) auf 1000 setzen und -g=0 1a eingeben. Es lebe der ASCII - Code! Seite 26

27 Falls Sie das Programm behalten wollen, gehen Sie folgendermassen vor: Setzen Sie BX auf null und CX auf 1a, denn BX:CX gibt an, wieviele Byte aus dem RAM in eine Datei geschrieben werden. Jetzt bestimmen Sie den Namen der Datei mit dem Debug - Befehl Name, z.b. -nzeichen (die Datei heisst dann ZEICHEN). Anschliessend geben Sie den Debug - Befehl Write ein: -wcs:0. Es werden auf dem Code - Segment ab Adresse 0 1a Byte in die Datei ZEICHEN geschrieben! Verlassen Sie jetzt Debug und geben Sie auf der DOS - Ebene den DOS - Befehl DIR ein. Er zeigt Ihnen alle Dateien des aktuellen Verzeichnisses - ZEICHEN sollte dabei sein! Falls das aktuelle Verzeichnis nicht Ihr privates ist, nämlich L:, dann kopieren Sie ZEICHEN dorthin mit dem DOS - Befehl COPY: COPY ZEICHEN L: Sie können jetzt ausprobieren, ob alles geklappt hat: Starten Sie Debug. Suchen Sie mit -d (Dump) einen Speicherbereich, der leer ist, z.b. -d6000:0. Setzen Sie CS auf diesen Bereich, legen Sie den Namen fest mit -nzeichen und laden Sie die Datei mit dem Load - Befehl: -lcs:0. Kontrollieren Sie mit -d! Starten Sie das Programm mit -g=cs:0 1a. Voilá, Sie besitzen ein Programm, das direkt in Maschinensprache geschrieben wurde und das alle ASCII - Zeichen auf den Bildschirm bringt. Das war der schwierigste Teil unseres Kurses. Programmieren in Maschinensprache heisst, sich ganz auf die "Denkweise" des Computers einzustellen und nur hexadezimal mit dem Computer zu kommunizieren. Leider war das nicht ganz in "Reinkultur" möglich, denn um unsere Programme ins RAM zu bringen und sie zu starten hatten wir bereits ein "Hilfsprogramm", den Debuger, nötig (und da gab's ja neben den Hexzahlen schon Buchstaben wie -d, -e, -g, etc. Ich wollte Ihnen damit einmal mehr die Grundstrukturen des Computers zeigen. Jede höhere Programmiersprache bzw. -umgebung ist ein Hilfsmittel, welches die Arbeit des Programmierers vereinfacht. Das Endprodukt wird aber immer ein Programm in Maschinensprache sein. Sie erkennen Dateien, die Programme in Maschinensprache enthalten an der Endung.COM oder.exe unter DOS. Unter Windows können Dateien, die Teile eines Maschinensprachprogramms enthalten auch andere Endungen haben (.DLL, etc.). Übrigens habe ich für unser Programm absichtlich keine Endung vorgesehen, weil es zwar ein vollständiges Maschinensprachprogramm ist, sich aber nur mit Hilfe des Debugers starten lässt. Programme mit den Endungen.COM oder.exe kann man direkt von der DOS Ebene aus starten, indem man einfach ihren Namen eingibt. Sie haben das gemacht mit dem Programm namens DEBUG.COM. Es befindet sich im Verzeichnis C:\Windows\Command. Dort sind alle Programme, die zum Betriebssystem gehören ausser denjenigen, die schon im RAM sind. Sie können sich das folgendermassen ansehen: Schalten Sie wenn nötig auf die lokale Festplatte um: C: Wechseln Sie ins Hauptverzeichnis mit Change Directory: CD \ Wechseln Sie ins Verzeichnis Command: CD WINDOWS\COMMAND Zeigen Sie sich die Namen der Dateien an: DIR Zeigen Sie sich die Dateien seitenweise an: DIR /P Haben Sie DEBUG gefunden? Nein? Dann: DIR DEBUG.* Sie wollen wissen, was diese Programme machen?: HELP Das war noch so ein kleiner DOS - Kurs. Wenn Sie mehr wissen möchten, dann sagen Sie es mir! Seite 27

28 Der Einplatinencomputer CT-65 Was eine Sprache ist, merkt man erst, wenn man deren zwei gelernt hat. Das ist bei Maschinensprachen nicht anders. Deshalb sollen Sie mit einer andern Maschinensprache ebenfalls etwas herumpröbeln. Es handelt sich um diejenige des Prozessors 6502, eines Vorläufers derjenigen Prozessoren, die heutzutage im Mac zu finden sind.gleichzeitig sollen Sie Ihre Hardwarekenntnisse etwas repetieren und den Aufbau eines Computers auf einen Blick erfassen. Prinzipaufbau des Computers: Die Tastenbefehle des Monitors (=Betriebssystem): A Adress Inhalt einer Speicheradresse anzeigen E Enter Inhalt einer Speicheradresse ändern und Adresse inkrementieren B Backspace Speicheradresse dekrementieren G Go Programm starten an angezeigter Adresse R Reset S,L Save, Load Programm speichern, laden I Index Neubelegung der Hex Tasten: I B Umrechnung in relative Adressen I C Blockverschieben I D Systemuhr anzeigen I E Programmstart bei E000 I F Systemuhr setzen Speicherbelegung: Seite 28

29 Die Sprache des 6502 Die wichtigsten Maschinenbefehle: Seite 29

30 5. Assembler Der Assembler ist ein Übersetzungsprogramm. Er übersetzt ein Programm, das wir Programmierer nicht in Machinensprache schreiben wollen in die Maschinensprache. Die Sprache, in der wir das Programm schreiben heisst ebenfalls Assembler. Assembler ist für den Computer die zweiteinfachste Sprache, die einfachste ist natürlich die Maschinensprache, also seine eigene. Sprachen, die noch näher an unserem menschlichen Denken sind als der Assembler nennt man häufig höhere Programmiersprachen (Basic, Pascal, C, Fortran, Forth, Modula, Java und wie sie alle heissen). Soll ein Programm auf einem Computer ausgeführt werden, muss es immer in Maschinensprache vorhanden sein. Ausser einem Programm in Maschinensprache muss also jedes Programm zuerst übersetzt werden. Bei einem Assemblerprogramm heisst dieser Vorgang assemblieren, bei allen andern entweder kompilieren (ganzes Programm übersetzen) oder interpretieren (Übersetzung einer Zeile und dann gleich Ausführung). Sie haben eigentlich die Assemblersprache schon etwas kennengelernt: Die Kürzel für die Maschinenbefehle in den Tabellen (MOV, ADD, etc.) sind Assemblerbefehle. Die einfachsten Assembler machen also nichts anderes als wir, wenn wir in den Tabellen nachsehen: MOV durch B8 ersetzen, etc. Wie wir gleich sehen werden, kann ein ausgewachsener Assembler aber noch wesentlich mehr. Ein wichtiger Punkt ist der, dass die Beziehung zwischen Assembler und Maschinensprache eineindeutig ist: Ein Assemblerprogramm kann man eindeutig in Maschinensprache übersetzen und dann eindeutig wieder zurück in Assembler. Dieser letzte Vorgang heisst unassemble. Das ist etwas, was sogar unser gutes Debug kann. Der entsprechende Debug Befehl heisst -u. Sehen Sie sich das folgende Listing dazu an: -u0 5000:0000 A35005 MOV [0550],AX 5000: EB ADD BL,CH 5000: ADC AX, : ADD [BX+SI],AL 5000:000A 0000 ADD [BX+SI],AL 5000:000C 0000 ADD [BX+SI],AL 5000:000E 0000 ADD [BX+SI],AL 5000:0010 4D DEC BP 5000: DAA 5000: JBE : ADD [BX+SI],AL 5000: ADD [BX+SI],AL 5000: ADD [BX+SI],AL 5000:001A 0000 ADD [BX+SI],AL 5000:001C 0000 ADD [BX+SI],AL 5000:001E 0000 ADD [BX+SI],AL - Wieder unser Programm, das aus einem Befehl besteht und ein Zeichen auf den Bildschirm schreibt! Es steht in der ersten Zeile. Der Rest ist natürlich Chabis. Da war irgendwas im Hauptspreicher und das hat der Unassembler als Maschinensprache interpretiert. Sie sehen eine Darstellung, wie sie auch meist von den Assemblern geliefert wird: Links die Speicheradresse, dann der Maschinencode und rechts davon dasselbe in Assembler. Seite 30

31 Erstes Assemblerprogramm für den PC: Damit es nicht allzu langweilig wird, soll Ihr erstes Assemblerprogramm nicht dasselbe machen wie das Maschinensprachprogramm. Der Assembler - Code ist nachfolgend abgedruckt. Sie geben das Programm nicht direkt ins RAM mit Debug, sondern schreiben es mit einer Textverarbeitung. Wir könnten z.b. Word brauchen. Das wäre aber mit Kanonen aus Spatzen geschossen! Wir verwenden das ganz einfache Textverarbeitungsprogramm Editor aus dem Zubehör im Menü "Start": - Starten Sie den Editor und geben Sie das nachfolgende Assemblerprogramm ein (die Kommentare nach den Strichpunkten können Sie auch weglassen, einrücken mit dem Tabulator). ; test.asm ; ********************************************************************** ; Zähler: Liest Ziffer und gibt entsprechende Anzahl Zeilen aus ; Übersetzen mit NASM: nasm -f bin test.asm -o test.com ; / Sö ; ********************************************************************** org 100h ; Code beginnt bei 100h im Code Segment section.text ; Codebereich: start: mov dx,text1 ; Adresse des Textes 1 nach dx mov ah,09 ; Funktion des DOS Interrupt 21 nach ah ; (Textausgabe) int 21h ; Interrupt 21 ausführen mov ah,01 ; Funktion des DOS Interrupt 21 nach ah int 21h ; Interrupt 21 ausführen ; (Taste lesen) sub al,48 ; ASCII Ziffer -> Zahl xor cx,cx ; cx löschen mov cl,al ; al (Zahl) nach cl (Zählerregister) mov dx,text2 ; Adresse des Textes 2 nach dx mov ah,09 ; IFunktion des DOS Interrupt 21 nach ah schleife: int 21h ; Interrupt 21 ausführen ; (Textausgabe) loop schleife ; Sprung nach schleife solange cx <> 0 ; und cx dekrementieren ret ; zurück ins DOS section.data ; Datenbereich: text1: db 10,13,'Anzahl Zeilen (1-9):','$' text2: db 10,13,'Computer sind auch nur Menschen!',10,13,'$' - Wenn Sie fertig sind, speichern Sie die Datei unter dem Namen test.asm in einem Ordner, in welchem sich sonst nichtt befindet (ev. neuen Ordner erstellen mit der entsprechenden Taste im Dateidialog!). - Öffnen Sie ein DOS Fenster und wechseln Sie mit CD in den Ordner, in welchem Sie die Datei gespeichert haben. Sehen Sie sich den Ordner mit DIR an. - Jetzt brauchen Sie den Assembler um Ihr Assemblerprogramm in Maschinencode zu übersetzen. Öffnen Sie dazu z.b. den Windows Explorer und kopieren Sie die Datei nasm.exe vom Server aus dem Ordner "Fächer", "Informatik", "Assembler", "nasm" in den Ordner, in welchem sich Ihr Assemblerprogramm befindet. Seite 31

32 - Im DOS Fenster übersetzen Sie jetzt Ihr Programm mit nasm -f bin test.asm -o test.com (-f bin besagt, dass es sich um ein einfaches DOS Programm handelt und -o gibt den Namen des zu erstellenden Maschinensprach - Programms an). - Wenn Sie keinen Fehler gemacht haben, schreibt Ihnen der nasm nichts, sonst gibt er Ihnen Fehlermeldungen aus. - Geben Sie DIR ein um zu kontrollieren, ob die Datei test.com wirklich erstellt wurde. - Führen Sie das Maschinensprache - Programm in der Datei test.com aus, indem Sie eingeben test - Hat's geklappt? Ob Sie mit dem dummen Spruch einverstanden sind oder nicht: Damit haben Sie die Programmentwicklung mit dem Assembler erlebt: Quelltext editieren -> assemblieren -> ausführen (wenn's komplexer wird, ist zwischen assemblieren und ausführen noch das Linken durchzuführen). - Und dieser Zyklus wird sich natürlich im Normalfall x mal wiederholen. Damit das nicht zu aufwendig ist geben Sie bitte den DOS Befehl doskey ein. Alle Befehle, die Sie anschliessend eingeben, können Sie mit der Cursor - Taste nach oben wieder hervorholen! - Ändern Sie den blöden Spruch ab, übersetzen Sie und führen Sie aus. Lassen Sie auch mal,10,13 am Ende des zweiten Textes weg. Weitere Änderungen auf eigene Gefahr! - Geben Sie auch mal die Ziffer 0 ein. Hoppla! Aber keine Angst: mit der Tastenkombination <Ctrl>+<C> können Sie das Programm wieder stoppen. Warum der unendliche Loop? - A propos Verständinis des Programms: Das mit den Interrupts ist noch zu klären, der Rest ist ev. jetzt schon verständlich. Denken Sie das Programm Schritt für Schritt durch und bereiten Sie Fragen für die Besprechung vor. Hier die Schlüsselwörter: start: mov dx,text1 mov ah,09 sub al,48 xor cx,cx mov cl,al loop schleife ret section.data oder: mov ah,4ch int 21h text1: db Seite 32

33 10,13,'Anzahl Zeilen (1-9):','$' Seite 33

34 Der Assembler, den ich Ihnen da zur Verfügung gestellt habe, ist übrigens Freeware. Wenn Sie ihn zu Hause haben wollen, kopieren Sie ihn vom Server oder laden Sie ihn von der Homepage von nasm herunter (ist recht klein!): Auch bei der Assemblerprogrammierung ist in der x86er Welt Microsoft am meisten am Ball. Der am meisten verwendete Assembler ist masm. Er ist auf dem Server ebenfalls vorhanden. Er ist aber nicht Freeware. Und passen Sie auf: Die Maschinenbefehle sind in allen Assemblern die selben, die Anweisungen an den Assembler selber unterscheiden sich aber. Viel Info zur Assembler - Programmierung (englisch) finden Sie unter: Und Assembler - Links sind zu finden unter: Maschinensprache der x86 Prozessoren: Intel 80x06 processor opcodes from the A86 assembler package compiled by Eric Isaacson This op-code list is extracted from the A86 assembler package V3.22, January 25, Copyright Eric Isaacson. All rights reserved. Opcodes Instruction Description 37 AAA ASCII adjust AL (carry into AH) after addition D5 0A AAD ASCII adjust before division (AX = 10*AH + AL) D4 0A AAM ASCII adjust after multiply (AL/10: AH=Quo AL=Rem) 3F AAS ASCII adjust AL (borrow from AH) after subtraction 14 ib ADC AL,ib Add with carry immediate byte into AL 15 iw ADC AX,iw Add with carry immediate word into AX 80 /2 ib ADC eb,ib Add with carry immediate byte into EA byte 10 /r ADC eb,rb Add with carry byte register into EA byte 83 /2 ib ADC ew,ib Add with carry immediate byte into EA word 81 /2 iw ADC ew,iw Add with carry immediate word into EA word 11 /r ADC ew,rw Add with carry word register into EA word 12 /r ADC rb,eb Add with carry EA byte into byte register 13 /r ADC rw,ew Add with carry EA word into word register 04 ib ADD AL,ib Add immediate byte into AL 05 iw ADD AX,iw Add immediate word into AX 80 /0 ib ADD eb,ib Add immediate byte into EA byte Seite 34

35 00 /r ADD eb,rb Add byte register into EA byte 83 /0 ib ADD ew,ib Add immediate byte into EA word 81 /0 iw ADD ew,iw Add immediate word into EA word 01 /r ADD ew,rw Add word register into EA word 02 /r ADD rb,eb Add EA byte into byte register 03 /r ADD rw,ew Add EA word into word register 0F 20 #ADD4S Add CL nibbles BCD from DS:SI into ES:DI (CL even,nz) 24 ib AND AL,ib Logical-AND immediate byte into AL 25 iw AND AX,iw Logical-AND immediate word into AX 80 /4 ib AND eb,ib Logical-AND immediate byte into EA byte 20 /r AND eb,rb Logical-AND byte register into EA byte 83 /4 ib AND ew,ib Logical-AND immediate byte into EA word 81 /4 iw AND ew,iw Logical-AND immediate word into EA word 21 /r AND ew,rw Logical-AND word register into EA word 22 /r AND rb,eb Logical-AND EA byte into byte register 23 /r AND rw,ew Logical-AND EA word into word register 63 /r *ARPL ew,rw Adjust RPL of EA word not smaller than RPL of rw 62 /r *BOUND rw,md INT 5 if rw not between [md] and [md+2] inclusive 9A cd CALL cd Call far segment, immediate 4-byte address E8 cw CALL cw Call near, offset relative to next instruction FF /3 CALL ed Call far segment, address at EA doubleword FF /2 CALL ew Call near, offset absolute at EA word 0F FF ib #CALL80 ib Call 8080-emulation code at INT number ib 98 CBW Convert byte into word (AH = top bit of AL) F8 CLC Clear carry flag FC CLD Clear direction flag so SI and DI will increment FA CLI Clear interrupt enable flag; interrupts disabled 0F 12/0 #CLRBIT eb,cl Clear bit CL of eb 0F 13/0 #CLRBIT ew,cl Clear bit CL of ew 0F 1A/0 ib #CLRBIT eb,ib Clear bit ib of eb 0F 1B/0 ib #CLRBIT ew,ib Clear bit ib of ew 0F 06 *CLTS Clear task switched flag F5 CMC Complement carry flag 3C ib CMP AL,ib Subtract immediate byte from AL for flags only 3D iw CMP AX,iw Subtract immediate word from AX for flags only 80 /7 ib CMP eb,ib Subtract immediate byte from EA byte for flags only 38 /r CMP eb,rb Subtract byte register from EA byte for flags only 83 /7 ib CMP ew,ib Subtract immediate byte from EA word for flags only 81 /7 iw CMP ew,iw Subtract immediate word from EA word for flags only 39 /r CMP ew,rw Subtract word register from EA word for flags only 3A /r CMP rb,eb Subtract EA byte from byte register for flags only 3B /r CMP rw,ew Subtract EA word from word register for flags only 0F 26 #CMP4S Compare CL nibbles CD at DS:SI from ES:DI (CL even,nz) A6 CMPS mb,mb Compare bytes ES:[DI] from [SI], advance SI and DI A7 CMPS mw,mw Compare words ES:[DI] from [SI], advance SI and DI A6 CMPSB Compare bytes ES:[DI] from DS:[SI], advance SI and DI A7 CMPSW Compare words ES:[DI] from DS:[SI], advance SI and DI 99 CWD Convert word to doubleword (DX = top bit of AX) 27 DAA Decimal adjust AL after addition 2F DAS Decimal adjust AL after subtraction FE /1 DEC eb Decrement EA byte by 1 FF /1 DEC ew Decrement EA word by 1 48+rw DEC rw Decrement word register by 1 F6 /6 DIV eb Unsigned divide AX by EA byte (AL=Quo AH=Rem) F7 /6 DIV ew Unsigned divide DXAX by EA word (AX=Quo DX=Rem) C8 iw 00 *ENTER iw,0 Make stack frame, iw bytes local storage, 0 levels C8 iw 01 *ENTER iw,1 Make stack frame, iw bytes local storage, 1 level C8 iw ib *ENTER iw,ib Make stack frame, iw bytes local storage, ib levels Fany Floating point set is in Chapter 7 F4 HLT Halt F6 /7 IDIV eb Signed divide AX by EA byte (AL=Quo AH=Rem) Seite 35

36 F7 /7 IDIV ew Signed divide DXAX by EA word (AX=Quo DX=Rem) F6 /5 IMUL eb Signed multiply (AX = AL * EA byte) F7 /5 IMUL ew Signed multiply (DXAX = AX * EA word) 6B /r ib *IMUL rw,ib Signed multiply immediate byte into word register 69 /r iw *IMUL rw,iw Signed multiply immediate word into word register 69 /r iw *IMUL rw,ew,iw Signed multiply (rw = EA word * immediate word) 6B /r ib *IMUL rw,ew,ib Signed multiply (rw = EA word * immediate byte) E4 ib IN AL,ib Input byte from immediate port into AL EC IN AL,DX Input byte from port DX into AL E5 ib IN AX,ib Input word from immediate port into AX ED IN AX,DX Input word from port DX into AX FE /0 INC eb Increment EA byte by 1 FF /0 INC ew Increment EA word by 1 40+rw INC rw Increment word register by 1 6C *INS eb,dx Input byte from port DX into [DI] 6D *INS ew,dx Input word from port DX into [DI] 6C *INSB Input byte from port DX into ES:[DI] 6D *INSW Input word from port DX into ES:[DI] CC INT 3 Interrupt 3 (trap to debugger) (far call, with flags CD ib INT ib Interrupt numbered by immediate byte pushed first) CE INTO Interrupt 4 if overflow flag is 1 CF IRET Interrupt return (far return and pop flags) 77 cb JA cb Jump short if above (CF=0 and ZF=0) above=unsigned 73 cb JAE cb Jump short if above or equal (CF=0) 72 cb JB cb Jump short if below (CF=1) below=unsigned 76 cb JBE cb Jump short if below or equal (CF=1 or ZF=1) 72 cb JC cb Jump short if carry (CF=1) E3 cb JCXZ cb Jump short if CX register is zero 74 cb JE cb Jump short if equal (ZF=1) 7F cb JG cb Jump short if greater (ZF=0 and SF=OF) greater=signed 7D cb JGE cb Jump short if greater or equal (SF=OF) 7C cb JL cb Jump short if less (SF/=OF) less=signed 7E cb JLE cb Jump short if less or equal (ZF=1 or SF/=OF) EB cb JMP cb Jump short (signed byte relative to next instruction) EA cd JMP cd Jump far (4-byte immediate address) E9 cw JMP cw Jump near (word offset relative to next instruction) FF /4 JMP ew Jump near to EA word (absolute offset) FF /5 JMP md Jump far (4-byte address in memory doubleword) 76 cb JNA cb Jump short if not above (CF=1 or ZF=1) 72 cb JNAE cb Jump short if not above or equal (CF=1) 73 cb JNB cb Jump short if not below (CF=0) 77 cb JNBE cb Jump short if not below or equal (CF=0 and ZF=0) 73 cb JNC cb Jump short if not carry (CF=0) 75 cb JNE cb Jump short if not equal (ZF=0) 7E cb JNG cb Jump short if not greater (ZF=1 or SF/=OF) 7C cb JNGE cb Jump short if not greater or equal (SF/=OF) 7D cb JNL cb Jump short if not less (SF=OF) 7F cb JNLE cb Jump short if not less or equal (ZF=0 and SF=OF) 71 cb JNO cb Jump short if not overflow (OF=0) 7B cb JNP cb Jump short if not parity (PF=0) 79 cb JNS cb Jump short if not sign (SF=0) 75 cb JNZ cb Jump short if not zero (ZF=0) 70 cb JO cb Jump short if overflow (OF=1) 7A cb JP cb Jump short if parity (PF=1) 7A cb JPE cb Jump short if parity even (PF=1) 7B cb JPO cb Jump short if parity odd (PF=0) 78 cb JS cb Jump short if sign (SF=1) 74 cb JZ cb Jump short if zero (ZF=1) 9F LAHF Load: AH = flags SF ZF xx AF xx PF xx CF Seite 36

37 0F 02 /r *LAR rw,ew Load: high(rw) = Access Rights byte, selector ew C5 /r LDS rw,ed Load EA doubleword into DS and word register 8D /r LEA rw,m Calculate EA offset given by m, place in rw C9 *LEAVE Set SP to BP, then POP BP (reverses previous ENTER) C4 /r LES rw,ed Load EA doubleword into ES and word register 0F 01 /2 *LGDT m Load 6 bytes at m into Global Descriptor Table reg 0F 01 /3 *LIDT m Load 6 bytes at m into Interrupt Descriptor Table reg 0F 00 /2 *LLDT ew Load selector ew into Local Descriptor Table reg 0F 01 /6 *LMSW ew Load EA word into Machine Status Word F0 LOCK (prefix) Assert BUSLOCK signal for the next instruction 0F 33/r #LODBITS rb,rb Load AX with DS:SI,bit rb (incr. SI,rb), rb+1 bits 0F 3B/0 ib #LODBITS rb,ib Load AX with DS:SI,bit rb (incr. SI,rb), ib+1 bits AC LODS mb Load byte [SI] into AL, advance SI AD LODS mw Load word [SI] into AX, advance SI AC LODSB Load byte [SI] into AL, advance SI AD LODSW Load word [SI] into AX, advance SI E2 cb LOOP cb noflags DEC CX; jump short if CX/=0 E1 cb LOOPE cb noflags DEC CX; jump short if CX/=0 and equal (ZF=1) E0 cb LOOPNE cb noflags DEC CX; jump short if CX/=0 and not equal E0 cb LOOPNZ cb noflags DEC CX; jump short if CX/=0 and ZF=0 E1 cb LOOPZ cb noflags DEC CX; jump short if CX/=0 and zero (ZF=1) 0F 03 /r *LSL rw,ew Load: rw = Segment Limit, selector ew 0F 00 /3 *LTR ew Load EA word into Task Register A0 iw MOV AL,xb Move byte variable (offset iw) into AL A1 iw MOV AX,xw Move word variable (offset iw) into AX 8E /3 MOV DS,mw Move memory word into DS 8E /3 MOV DS,rw Move word register into DS C6 /0 ib MOV eb,ib Move immediate byte into EA byte 88 /r MOV eb,rb Move byte register into EA byte 8E /0 MOV ES,mw Move memory word into ES 8E /0 MOV ES,rw Move word register into ES 8C /1 MOV ew,cs Move CS into EA word 8C /3 MOV ew,ds Move DS into EA word C7 /0 iw MOV ew,iw Move immediate word into EA word 8C /0 MOV ew,es Move ES into EA word 89 /r MOV ew,rw Move word register into EA word 8C /2 MOV ew,ss Move SS into EA word B0+rb ib MOV rb,ib Move immediate byte into byte register 8A /r MOV rb,eb Move EA byte into byte register B8+rw iw MOV rw,iw Move immediate word into word register 8B /r MOV rw,ew Move EA word into word register 8E /2 MOV SS,mw Move memory word into SS 8E /2 MOV SS,rw Move word register into SS A2 iw MOV xb,al Move AL into byte variable (offset iw) A3 iw MOV xw,ax Move AX into word register (offset iw) A4 MOVS mb,mb Move byte [SI] to ES:[DI], advance SI and DI A5 MOVS mw,mw Move word [SI] to ES:[DI], advance SI and DI A4 MOVSB Move byte DS:[SI] to ES:[DI], advance SI and DI A5 MOVSW Move word DS:[SI] to ES:[DI], advance SI and DI F6 /4 MUL eb Unsigned multiply (AX = AL * EA byte) F7 /4 MUL ew Unsigned multiply (DXAX = AX * EA word) F6 /3 NEG eb Two's complement negate EA byte F7 /3 NEG ew Two's complement negate EA word NIL (prefix) Special "do-nothing" opcode assembles no code 90 NOP No Operation F6 /2 NOT eb Reverse each bit of EA byte F7 /2 NOT ew Reverse each bit of EA word 0F 16/0 #NOTBIT eb,cl Complement bit CL of eb 0F 17/0 #NOTBIT ew,cl Complement bit CL of ew 0F 1E/0 ib #NOTBIT eb,ib Complement bit ib of eb Seite 37

38 0F 1F/0 ib #NOTBIT ew,ib Complement bit ib of ew 0C ib OR AL,ib Logical-OR immediate byte into AL 0D iw OR AX,iw Logical-OR immediate word into AX 80 /1 ib OR eb,ib Logical-OR immediate byte into EA byte 08 /r OR eb,rb Logical-OR byte register into EA byte 83 /1 ib OR ew,ib Logical-OR immediate byte into EA word 81 /1 iw OR ew,iw Logical-OR immediate word into EA word 09 /r OR ew,rw Logical-OR word register into EA word 0A /r OR rb,eb Logical-OR EA byte into byte register 0B /r OR rw,ew Logical-OR EA word into word register E6 ib OUT ib,al Output byte AL to immediate port number ib E7 ib OUT ib,ax Output word AX to immediate port number ib EE OUT DX,AL Output byte AL to port number DX EF OUT DX,AX Output word AX to port number DX 6E *OUTS DX,eb Output byte [SI] to port number DX, advance SI 6F *OUTS DX,ew Output word [SI] to port number DX, advance SI 6E *OUTSB Output byte DS:[SI] to port number DX, advance SI 6F *OUTSW Output word DS:[SI] to port number DX, advance SI 1F POP DS Set DS to top of stack, increment SP by 2 07 POP ES Set ES to top of stack, increment SP by 2 8F /0 POP mw Set memory word to top of stack, increment SP by 2 58+rw POP rw Set word register to top of stack, increment SP by 2 17 POP SS Set SS to top of stack, increment SP by 2 61 *POPA Pop DI,SI,BP,SP,BX,DX,CX,AX (SP value is ignored) 9D POPF Set flags register to top of stack, increment SP by 2 0E PUSH CS Set [SP-2] to CS, then decrement SP by 2 1E PUSH DS Set [SP-2] to DS, then decrement SP by 2 06 PUSH ES Set [SP-2] to ES, then decrement SP by 2 6A ib *PUSH ib Push sign-extended immediate byte 68 iw *PUSH iw Set [SP-2] to immediate word, then decrement SP by 2 FF /6 PUSH mw Set [SP-2] to memory word, then decrement SP by 2 50+rw PUSH rw Set [SP-2] to word register, then decrement SP by 2 16 PUSH SS Set [SP-2] to SS, then decrement SP by 2 60 *PUSHA Push AX,CX,DX,BX,original SP,BP,SI,DI 9C PUSHF Set [SP-2] to flags register, then decrement SP by 2 D0 /2 RCL eb,1 Rotate 9-bit quantity (CF, EA byte) left once D2 /2 RCL eb,cl Rotate 9-bit quantity (CF, EA byte) left CL times C0 /2 ib *RCL eb,ib Rotate 9-bit quantity (CF, EA byte) left ib times D1 /2 RCL ew,1 Rotate 17-bit quantity (CF, EA word) left once D3 /2 RCL ew,cl Rotate 17-bit quantity (CF, EA word) left CL times C1 /2 ib *RCL ew,ib Rotate 17-bit quantity (CF, EA word) left ib times D0 /3 RCR eb,1 Rotate 9-bit quantity (CF, EA byte) right once D2 /3 RCR eb,cl Rotate 9-bit quantity (CF, EA byte) right CL times C0 /3 ib *RCR eb,ib Rotate 9-bit quantity (CF, EA byte) right ib times D1 /3 RCR ew,1 Rotate 17-bit quantity (CF, EA word) right once D3 /3 RCR ew,cl Rotate 17-bit quantity (CF, EA word) right CL times C1 /3 ib *RCR ew,ib Rotate 17-bit quantity (CF, EA word) right ib times F3 REP (prefix) Repeat following MOVS,LODS,STOS,INS, or OUTS CX times 65 #REPC (prefix) Repeat following CMPS or SCAS CX times or until CF=0 F3 REPE (prefix) Repeat following CMPS or SCAS CX times or until ZF=0 64 #REPNC (prfix) Repeat following CMPS or SCAS CX times or until CF=1 F2 REPNE (prfix) Repeat following CMPS or SCAS CX times or until ZF=1 F2 REPNZ (prfix) Repeat following CMPS or SCAS CX times or until ZF=1 F3 REPZ (prefix) Repeat following CMPS or SCAS CX times or until ZF=0 CB RETF Return to far caller (pop offset, then seg) C3 RET Return to near caller (pop offset only) CA iw RETF iw RET (far), pop offset, seg, iw bytes C2 iw RET iw RET (near), pop offset, iw bytes pushed before Call Seite 38

39 D0 /0 ROL eb,1 Rotate 8-bit EA byte left once D2 /0 ROL eb,cl Rotate 8-bit EA byte left CL times C0 /0 ib *ROL eb,ib Rotate 8-bit EA byte left ib times D1 /0 ROL ew,1 Rotate 16-bit EA word left once D3 /0 ROL ew,cl Rotate 16-bit EA word left CL times C1 /0 ib *ROL ew,ib Rotate 16-bit EA word left ib times 0F 28/0 #ROL4 eb Rotate nibbles: Heb=Leb HAL,Leb=LAL LAL=Heb D0 /1 ROR eb,1 Rotate 8-bit EA byte right once D2 /1 ROR eb,cl Rotate 8-bit EA byte right CL times C0 /1 ib *ROR eb,ib Rotate 8-bit EA byte right ib times D1 /1 ROR ew,1 Rotate 16-bit EA word right once D3 /1 ROR ew,cl Rotate 16-bit EA word right CL times C1 /1 ib *ROR ew,ib Rotate 16-bit EA word right ib times 0F 2A/0 #ROR4 eb Rotate nibbles: Leb=Heb Heb=LAL AL=eb 9E SAHF Store AH into flags SF ZF xx AF xx PF xx CF D0 /4 SAL eb,1 Multiply EA byte by 2, once D2 /4 SAL eb,cl Multiply EA byte by 2, CL times C0 /4 ib *SAL eb,ib Multiply EA byte by 2, ib times D1 /4 SAL ew,1 Multiply EA word by 2, once D3 /4 SAL ew,cl Multiply EA word by 2, CL times C1 /4 ib *SAL ew,ib Multiply EA word by 2, ib times D0 /7 SAR eb,1 Signed divide EA byte by 2, once D2 /7 SAR eb,cl Signed divide EA byte by 2, CL times C0 /7 ib *SAR eb,ib Signed divide EA byte by 2, ib times D1 /7 SAR ew,1 Signed divide EA word by 2, once D3 /7 SAR ew,cl Signed divide EA word by 2, CL times C1 /7 ib *SAR ew,ib Signed divide EA word by 2, ib times 1C ib SBB AL,ib Subtract with borrow immediate byte from AL 1D iw SBB AX,iw Subtract with borrow immediate word from AX 80 /3 ib SBB eb,ib Subtract with borrow immediate byte from EA byte 18 /r SBB eb,rb Subtract with borrow byte register from EA byte 83 /3 ib SBB ew,ib Subtract with borrow immediate byte from EA word 81 /3 iw SBB ew,iw Subtract with borrow immediate word from EA word 19 /r SBB ew,rw Subtract with borrow word register from EA word 1A /r SBB rb,eb Subtract with borrow EA byte from byte register 1B /r SBB rw,ew Subtract with borrow EA word from word register AE SCAS mb Compare bytes AL - ES:[DI], advance DI AF SCAS mw Compare words AL - ES:[DI], advance DI AE SCASB Compare bytes AX - ES:[DI], advance DI AF SCASW Compare words AX - ES:[DI], advance DI 0F 14/0 #SETBIT eb,cl Set bit CL of eb 0F 15/0 #SETBIT ew,cl Set bit CL of ew 0F 1C/0 ib #SETBIT eb,ib Set bit ib of eb 0F 1D/0 ib #SETBIT ew,ib Set bit ib of ew 0F 01 /0 *SGDT m Store 6-byte Global Descriptor Table register to M D0 /4 SHL eb,1 Multiply EA byte by 2, once D2 /4 SHL eb,cl Multiply EA byte by 2, CL times C0 /4 ib *SHL eb,ib Multiply EA byte by 2, ib times D1 /4 SHL ew,1 Multiply EA word by 2, once D3 /4 SHL ew,cl Multiply EA word by 2, CL times C1 /4 ib *SHL ew,ib Multiply EA word by 2, ib times D0 /5 SHR eb,1 Unsigned divide EA byte by 2, once D2 /5 SHR eb,cl Unsigned divide EA byte by 2, CL times C0 /5 ib *SHR eb,ib Unsigned divide EA byte by 2, ib times D1 /5 SHR ew,1 Unsigned divide EA word by 2, once D3 /5 SHR ew,cl Unsigned divide EA word by 2, CL times C1 /5 ib *SHR ew,ib Unsigned divide EA word by 2, ib times 0F 01 /1 *SIDT m 0F 00 /0 *SLDT ew Store 6-byte Interrupt Descriptor Table register to M Store Local Descriptor Table register to EA word Seite 39