

                Schlu mit der Theorie
                

habe ich mir gesagt, als ich mir berlegt habe, wie der nchste
Assembler Kurs aussehen soll.
Also steigen wir heute direkt mit einem kleinen Programm ein:

schanipp
-----------------------------------------------------------------

        Mnemonics                       Opcodes

        .MODEL SMALL
        .STACK 100h
        .DATA
                Zahl1   DW      ?
                Zahl2   DW      ?
                Min     DW      ?
                Max     DW      ?
        .CODE
                MOV DX,@DATA            BA 52 0F
                MOV DS,DX               8E DA

                MOV Zahl1,10d           C7 06 00 00 0A 00
                MOV Zahl2,20d           C7 06 02 00 14 00

                MOV AX,Zahl1            A1 00 00
                MOV BX,Zahl2            8B 1E 02 00

                CMP AX,BX               3B C3
                JG  Ziel1               7F 0A
                MOV Min,AX              A3 04 00
                MOV Max,BX              89 1E 06 00
                JMP Ziel2               EB 08
        Ziel1:  MOV Min,BX              89 1E 04 00
                MOV Max,AX              A3 06 00
        Ziel2:  MOV AH,4Ch              B4 4C
                INT 21h                 CD 21
        END

-----------------------------------------------------------------
schanapp

Als erstes sei erwhnt, da dieses Programm sicherlich nicht als
Vorbild fr einen guten Programmierstil dienen soll, aber man
kann an ihm recht gut den grundlegenden Aufbau eines Assembler-
programms deutlich machen.


Der Rahmen eines Maschinenspracheprogramms


Die Anweisung

                        .MODEL SMALL

                        legt das Speichermodell fest. Durch das
Speichermodell wird festgelegt, wie gro das Befehls- und Daten-
segment des Programms werden darf. Diese Segmente sind einfach
ausgedrckt ein bestimmter Speicherbereich, der den Rahmen fr
die Befehle und Daten des Programmes bildet. Die Gre dieses
Rahmens wird durch die MODEL Anweisung festgelegt. Die folgen-
den Speichermodelle werden von den gngigen Assemblern unter-
sttzt:

        Speichermodell      Beschreibung
        
        TINY                Befehls- + Datensegment <= 64kbyte
                            (nur fr COM-Dateien)

        SMALL               Befehls- + Datensegment <= 64kbyte

        MEDIUM              Befehls- + Datensegment <= 64kbyte
                            (Befehlssegment kann jedoch grer
                            als 64kbyte werden)

        COMPACT             Befehlssegment <= 64kbyte
                            (die Summe aller Datensegmente kann
                            64kbyte bersteigen, jedoch darf ein
                            einzelnes Datenfeld nicht grer als
                            64kbyte werden)

        LARGE               Summe aller Befehls- und Datensegmen-
                            te > 64kbyte
                            (jedoch darf ein einzelnes Befehls-,
                            Datenfeld nicht grer als 64kbyte
                            werden)

        HUGE                Befehls- + Datensegment > 64kbyte
                            keine Einschrnkungen

Die drei Anweisungen STACK, DATA und CODE sind Segmentanweisun-
gen, die ein bestimmtes Speichersegment des Programms definie-
ren: In diesem Fall das Stapelspeicher-, Daten- und Befehls-
segment.

Die Anweisung

                .STACK 100h

definiert ein Stapelspeichersegment mit der Gre von 100 Byte.
Der Stack wird fr die Rettung, oder Zwischenspeicherung, von
besonders wichtigen Daten verwendet.

Die Anweisung

                .DATA

                leitet das Datensegment ein. Im Datensegment
werden die Variablen, Konstanten und Felder definiert mit denen
das Programm arbeitet. In unserem Fall werden vier Variablen vom
Typ 'WORD' definiert; die entsprechende Anweisung lautet hier
DW = 'Define Word'. Es gibt allerdings noch andere mgliche
Variablentypen.

                DB      Byte
                DW      Word    =  2 Byte
                DD      DWord   =  4 Byte
                DF      FWord   =  6 Byte
                DQ      QWord   =  8 Byte
                DT      TByte   = 10 Byte

Das '?' bedeutet, da es sich um Variablen handelt, da kein di-
rekter Wert zugewiesen wird.

Die Anweisung

                .CODE

                deutet auf den Anfang des Befehlssegmentes an,
mit dem wir uns auch nher beschftigen werden. Im Befehlsseg-
ment ist das eigentliche Programm untergebracht.

Die
                END

                Anweisung beendet schlielich das Programm und
stellt somit den Abschlu des Rahmens fr ein Assemblerprogramm
dar.


Das Maschinenspracheprogramm


Jetzt wollen wir uns mit dem eigentlichen Assemblerprogramm be-
schftigen, also mit dem CODE-Segment des Beispielprogramms.

Der wohl auffallendste Befehl, drfte der MOV-Befehl sein,
dessen Funktion auch recht einfach zu erklren ist.


                        Der MOV-Befehl
                        

Bei dem MOV-Befehl handelt es sich um den wohl grundlegendsten
Assemblerbefehl. Man wrde den MOV-Befehl in die Kategorie Daten-
transportbefehle stecken, weil er nichts anderes macht, als Daten
von einer Quelle zu einem Ziel zu kopieren.
Die Annahme der MOV-Befehl wrde Daten verschieben, wie man dem
Namen nach ja leicht annehmen knnte (MOVe), ist falsch, denn der
MOV-Befehl lt die Quelle nach der Operation unverndert.
Man kann jedoch Quelle und Ziel beim MOV-Befehl nicht beliebig
whlen, es gelten nmlich besondere Syntax-Regeln bei der Anwen-
dung des MOV-Befehls.

Die grundlegende Syntax lautet:

                        MOV Ziel,Quelle

Der MOV-Befehl darf aber nur in den folgenden Variationen ange-
wendet werden (8086/88):

        Syntax                  Beispiel

        MOV Var,Wert            MOV Zahl1,10
        MOV Reg,Wert            MOV AX,10
        MOV Reg,Var             MOV AX,Zahl1
        MOV Reg,Reg             MOV AX,BX
        MOV SegReg,Reg          MOV DS,DX
        MOV Reg,SegReg          MOV DX,DS
        MOV SegReg,Var          MOV DS,Seg1
        MOV Var,SegReg          MOV Seg2,ES

Hierbei mu Var eine gltige Variable, Wert eine Konstante, Reg
ein gltiges CPU-Register und SegReg ein gltiges CPU-Segment-
register sein.


Das Kernstck des Programms allerdings bildet der CMP-Befehl mit
den beiden Jxx-Befehlen.

Der CMP-Befehl fhrt einen Vergleich durch (Compare Integers), um
in einem Programm eine mgliche Verzweigung vorzubereiten.

In unserem Beispielprogramm wird in den ersten beiden Zeilen das
Datensegment initialisiert, d.h. die Variablen werden in das
Datensegment integriert, es wird Speicher fr sie reserviert.
In den nchsten zwei Zeilen wird in die Variablen jeweils ein
Wert eingelesen. Diese Werte werden in den nchsten zwei Zeilen
in die zwei CPU-Register geladen, so da jetzt AX den Wert von
Zahl1 und BX den Wert von Zahl2 enthlt. Das Programm soll jetzt
die kleinere der beiden Zahlen in der Variablen Min und die
grere der beiden in der Variablen Max speichern.

Genau dazu dient der CMP-Befehl.


                        Der CMP-Befehl
                        

Wie schon gesagt, fhrt der CMP-Befehl einen Vergleich durch,
aber wie?
Ganz einfach, er subtrahiert intern die beiden angegebenen
Operanden und setzt, je nach Ergebnis, die Statusflags der CPU.

Dem CMP-Befehl liegt folgende Syntax zugrunde:

                        CMP Ziel,Quelle

Um einen Vergleich durchzufhren, rechnet die CPU intern:

                         Ziel - Quelle

Jetzt kommt es auf das Ergebnis an, wie die Statusflags der CPU
gesetzt werden, aber das interessiert uns erst einmal nicht.

Wichtig ist fr uns jetzt, was diese Vernderung der Statusflags
fr eine Auswirkung auf den weiteren Verlauf des Programms hat.

Auf den CMP-Befehl folgt ein Sprungbefehl, in unserem Fall ein
JG-Befehl. Die Funktionsweise dieses Befehls kann man jetzt sehr
gut in Zusammenhang mit dem vorangegangenen CMP-Befehl erklren.

Das JG steht fr 'jump if greater' und bezieht sich auf den
vorangegangenen CMP-Befehl.
Anschaulich ausgedrckt bedeutet die Befehlsfolge:

                        CMP AX,BX
                        JG Ziel1

         Springe nach Ziel1, wenn AX grer BX ist

In unserem Beispiel ist die Bedingung nicht erfllt, da AX
gleich Zahl1 gleich 10 und BX gleich Zahl2 gleich 20 und somit
also AX < BX ist.
Das Programm luft also ohne den bedingen Sprung auszufhren
weiter und ldt AX in Min und BX in Max.
Der nchste Befehl fhrt einen unbedingten Sprung aus, also
einen Sprung der nicht von einer Bedingung abhngig ist (auer
von der Bedingung, da das Programm berhaupt diese Stelle er-
reicht).
In den letzten beiden Zeilen wird die Funktion 4Ch des Inter-
rupts 21h ausgefhrt, die das Programm beendet und in die DOS-
Ebene zurckfhrt.

Es ist noch anzumerken, da unser Beispielprogramm nie nach dem
CMP-Befehl verzweigt, da Zahl1 und Zahl2 konstant sind.
Whlt man Zahl1 und Zahl2 allerdings variabel, so kann es durch-
aus vorkommen, da der Befehlsteil ab der Sprungmarke Ziel1 aus-
gefhrt wird, d.h. wenn AX > BX ist wird Min=BX und Max=AX.

Sind Zahl1 und Zahl2 also variabel, dann ermittelt das Programm
die grere bzw. kleinere Zahl von beiden.

So, ich hoffe das war nicht zuviel fr das erste Assemblerpro-
gramm, wenn doch dann beschwert Euch ruhig. Ansonsten sage ich
einfach einmal schne Gre und bis bald!

                                                GABRIEL

