Assembler-Programmierung für x86-Prozessoren/ Sprünge und Schleifen

Assembler-Programmierung für x86-Prozessoren

Unbedingte Sprünge

Unbedingte Sprünge entsprechen im Prinzip einem GOTO in höheren Programmiersprachen. Im Assembler heißt der Befehl allerdings jmp (Abkürzung für jump; dt. „springen“).

Das Prinzip des Sprungbefehls ist sehr einfach: Um die Bearbeitung des Programms an einer anderen Stelle fortzusetzen, wird das IP-Register mit der Adresse des Sprungziels geladen. Da die Adresse des IP-Registers zusammen mit dem CS-Register immer auf den nächsten Befehl zeigt, den der Prozessor bearbeiten wird, setzt er die Bearbeitung des Programms am Sprungziel fort.

Der Befehl hat die folgende Syntax:

  jmp Zieloperand

Je nach Sprungart kann der Zieloperand ein Wert und/oder ein Register bzw. eine Speicherstelle sein. Im Real Mode gibt es drei verschiedene Sprungarten:

• Short Jump: Der Sprung erfolgt innerhalb einer Grenze von -128 bis +127 Byte.
• Near Jump: Der Sprung erfolgt innerhalb der Grenzen des Code-Segments.
• Far Jump: Der Sprung erfolgt innerhalb des gesamten im Real Mode adressierbaren Speichers.

Bevor wir noch genauer auf die Syntax eingehen, sehen wir uns ein Beispiel an, das einen Short Jump benutzt. Bei einem Short Jump darf der Zieloperand nur als Wert angegeben werden. Ein Register oder eine Speicherstelle ist nicht erlaubt.

Der Wert wird als relative Adresse (bezogen auf die Adresse des nächsten Befehls) interpretiert. Das heißt, dem Inhalt des IP-Registers wird der Wert des Zieloperanden hinzuaddiert. Ist der Wert des Zieloperanden positiv, so liegt das Sprungziel hinter dem jmp-Befehl, ist der Wert negativ, so befindet sich das Sprungziel vor dem jmp-Befehl.

Das folgende Programm führt einen Short Jump aus:

  org 100h
  start:
         jmp short ziel
         ;ein paar unsinnige Befehle:
         mov ax, 05h
         inc ax
         mov bx, 07h
         xchg ax, bx
  ziel:  mov cx, 05h
         mov ah,4Ch
         int 21h

Das Sprungziel ist durch ein Label gekennzeichnet (hier: ziel). Damit kann der Assembler die (absolute oder relative) Adresse für das Sprungziel ermitteln und in den Opcode einsetzen.

Wenn Sie das Programm mit dem Debugger ausführen, bekommen Sie die folgende Ausgabe:

-r
AX=0000  BX=0000  CX=0011  DX=0000  SP=FFFE  BP=0000  SI=0000  DI=0000
DS=0D3E  ES=0D3E  SS=0D3E  CS=0D3E  IP=0100   NV UP EI PL NZ NA PO NC
0D3E:0100 EB08          JMP     010A
-t

Lassen Sie sich nicht von der Ausgabe JMP 010A irritieren. Wie Sie am Opcode EB08 sehen können, besitzt der Zieloperand tatsächlich den Wert 08h; EBh ist der Opcode des (short) jmp-Befehls.

Die nächste Adresse nach dem jmp-Befehle beginnt mit 0102h. Addiert man hierzu den Wert 08h, so erhält man die Adresse des Sprungziels: 010Ah. Mit dieser Adresse lädt der Prozessor das IP-Register:

AX=0000  BX=0000  CX=0011  DX=0000  SP=FFFE  BP=0000  SI=0000  DI=0000
DS=0D3E  ES=0D3E  SS=0D3E  CS=0D3E  IP=010A   NV UP EI PL NZ NA PO NC
0D3E:010A B90500        MOV     CX,0005
-t

Wie Sie nun sehen, zeigt nun die Registerkombination CS:IP auf den Befehl mov cx,0005h, wo der Prozessor mit der Bearbeitung fortfährt.

Beachten Sie, dass NASM nicht automatisch erkennt, ob es sich um einen Short oder Near Jump handelt (im Gegensatz zum Turbo Assembler und zum Macro Assembler ab Version 6.0). Fehlt das Schlüsselwort short, so übersetzt dies der Assembler in einen Near Jump (was zur Folge hat, dass der Opcode um ein Byte länger ist).

Beim Short Jump darf der Zieloperand nur eine relative Adresse besitzen, wohingegen beim Near Jump sowohl eine relative wie auch eine absolute Adresse möglich ist. Dies ist auch leicht einzusehen, wenn Sie sich nochmals den Opcode ansehen: Da nur ein Byte für die Adressinformation zu Verfügung steht, kann der Befehl keine 16bittige absolute Adresse erhalten.

Wenn der Near Jump-Befehl aber sowohl ein relative als auch eine absolute Adresse erhalten kann, wie kann der Assembler dann unterscheiden, in welchen Opcode er den Befehl übersetzen muss? Nun, wenn der Zieloperand ein Wert ist, handelt es sich um eine relative Adresse, ist der Zieloperand in einem Register oder einer Speicherstelle abgelegt, so handelt es sich um eine absolute Adresse.

Beim Far Jump wird sowohl das CS Register wie auch das IP Register neu geladen. Damit kann sich das Sprungziel auch in einem anderen Segment befinden. Die Adresse kann entweder ein Wert sein oder ein Registerpaar. In beiden Fällen handelt es sich um eine absolute Adresse. Eine relative Adresse existiert beim Far Jump nicht.

Das folgende Beispiel zeigt ein Programm mit zwei Codesegmenten, bei dem ein Far Jump in das zweite Segment erfolgt:

 segment code1 
   start:
         jmp word far ziel

  segment code2 
  ziel:  mov ah, 4Ch
         int 21h

Bitte vergessen Sie nicht, dass com-Dateien nur ein Codesegment besitzen dürfen und deshalb das Programm als exe-Datei übersetzt werden muss (siehe Kapitel Das erste Assemblerprogramm / EXE-Dateien).

Das Schlüsselwort word wird benutzt, da es sich um eine 16-Bit-Adresse handelt. Ab der 80386 CPU sind auch 32-Bit-Adressen möglich, da das IP Register 32 Bit breit ist (die Segmentregister sind auch bei der 80386 CPU nur 16 Bit groß).

Bedingte Sprünge

Mit bedingten Sprüngen lassen sich in Assembler Kontrollstrukturen vergleichbar mit IF … ELSE Anweisungen in Hochsprachen ausdrücken. Im Gegensatz zum unbedingten Sprung wird dazu nicht in jedem Fall ein Sprung durchgeführt, sondern in Abhängigkeit der Flags.

Natürlich müssen dazu erst die Flags gesetzt werden. Dies erfolgt mit dem cmp- oder test-Befehl.

Der cmp-Befehl hat die folgende Syntax:

 cmp operand1, operand2

Wie Sie sehen, existiert weder ein Quell- noch ein Zieloperand. Dies liegt daran, dass keiner der beiden Operanden verändert wird. Vielmehr entspricht der cmp- einem sub-Befehl, lediglich mit dem Unterschied, dass nur die Flags verändert werden.

Der test-Befehl führt im Gegensatz zum cmp-Befehl keine Subtraktion, sondern eine UND Verknüpfung durch. Der test-Befehl hat die folgende Syntax:

 test operand1, operand2

Mit dem test-Befehl kann der bedingte Sprung davon abhängig gemacht werden, ob ein bestimmtes Bit gesetzt ist oder nicht.

Für Vorzeichenbehaftete Zahlen müssen andere Sprungbefehle benutzt werden, da die Flags entsprechend anders gesetzt sind. Die folgende Tabelle zeigt sämtliche bedingte Sprünge für vorzeichenlose Zahlen:

Sprungbefehl	Abkürzung für	Zustand der Flags	Bedeutung
ja	jump if above	CF = 0 und ZF = 0	Operand1 > Operand2
jae	jump if above or equal	CF = 0	Operand1 >= Operand2
jb	jump if below	CF = 1	Operand1 < Operand2
jbe	jump if below or equal	CF = 1 oder ZF = 1	Operand1 <= Operand2
je	jump if equal	ZF = 1	Operand1 = Operand2
jne	jump if not equal	ZF = 0	Operand1 <> Operand2, also Operand1 != Operand2

Wie Sie an der Tabelle erkennen können, ist jeder Vergleich an eine charakteristische Kombination der Carry Flags und des Zero Flags geknüpft. Mit dem Zero Flag werden die Operanden auf Gleichheit überprüft. Sind beide Operanden gleich, so ergibt eine Subtraktion 0 und das Zero Flag ist gesetzt. Sind beide Operanden dagegen ungleich, so ist das Ergebnis einer Subtraktion bei vorzeichenlosen Zahlen einen Wert ungleich 0 und das Zero Flag ist nicht gesetzt.

Kleiner und größer werden durch das Carry Flag angezeigt: Wenn Zieloperand kleiner als der Quelloperand ist, so wird das Most Significant Bit „herausgeschoben“. Dieses Herausschieben wird durch das Carry Flag angezeigt. Das folgende Beispiel zeigt eine solche Subtraktion:

    0000 1101 (Operand1)
-   0001 1010 (Operand2)
Ü 1 111   1
-------------
    1111 0011

Der fett markierte Übertrag stellt den Übertrag dar, der das Carry Flag setzt. Wie Sie an diesem Beispiel sehen, lässt sich das Carryflag also auch dazu benutzen um festzustellen, ob der Zieloperand kleiner oder größer als der Quelloperand ist.

Mit diesem Wissen können wir uns nun herleiten, warum die Flags so gesetzt sein müssen und nicht anders:

• ja: Hier testen wir mit dem Carry Flag, ob die Bedingung Operand1 > Operand2 erfüllt ist. Da die beiden Operanden nicht gleich sein sollen, testen wir außerdem noch das Zero Flag.
• jae: Der Befehl entspricht dem ja-Befehl, mit dem Unterschied, dass wir nicht das Zero Flag testen, da beide Operanden gleich sein dürfen.
• jb : Hier testen wir mit dem Carry Flag, ob die Bedingung Operand1 < Operand2 erfüllt ist. Aber wieso testet jb nicht auch das Zero Flag? Sehen wir uns dies an einem Beispiel an: Angenommen der erste und zweite Operand haben jeweils den Wert 5. Wenn wir beide voneinander subtrahieren, so erhalten wir als Ergebnis 0. Damit ist das Zero Flag gesetzt und das Carry Flag ist 0. Folge: Es reicht aus zu prüfen, ob das Carry Flag gesetzt ist oder nicht. Die beiden Operanden müssen in diesem Fall ungleich sein.
• jbe: Mit dem Carry Flag testen wir wieder die Bedingung Operand1 < Operand2 und mit dem Zero Flag auf Gleichheit. Beachten Sie, dass entweder das Carry Flag oder das Zero Flag gesetzt werden müssen und nicht beide gleichzeitig gesetzt sein müssen.

Die Befehle je und jne dürften nun selbsterklärend sein.

Wie bereits erwähnt, unterscheiden sich die bedingten Sprünge mit vorzeichenbehafteten Zahlen von Sprüngen mit vorzeichenlosen Zahlen, da hier die Flags anders gesetzt werden:

Sprungbefehl	Abkürzung für	Zustand der Flags	Bedeutung
jg	jump if greater	ZF = 0 und SF = OF	Operand1 > Operand2
jge	jump if greater or equal	SF = OF	Operand1 >= Operand2
jl	jump if less	ZF = 0 und SF <> OF	Operand1 < Operand2
jle	jump if less or equal	ZF = 1 oder SF <> OF	Operand1 <= Operand2

Die Befehle je und jne sind bei vorzeichenlosen und vorzeichenbehafteten Operatoren identisch und tauchen deshalb in der Tabelle nicht noch einmal auf.

Darüber hinaus existieren noch Sprungbefehle, mit denen sich die einzelnen Flags abprüfen lassen:

Sprungbefehl	Abkürzung für	Zustand der Flags
jc	jump if carry	CF = 1
jnc	jump if not carry	CF = 0
jo	jump if overflow	OF = 1
jno	jump if not overflow	OF = 0
jp	jump if parity	PF = 1
jpe	jump if parity even	PF = 1
jpo	jump if parity odd	PF = 0

Es fällt auf, dass sowohl der jb und jae wie auch jc und jnc testen, ob das Carry Flag gesetzt bzw. gelöscht ist. Wie kann der Prozessor also beide Befehle unterscheiden? Die Antwort lautet: Beide Befehle sind Synonyme. Die Befehle jb und jc besitzen beide den Opcode 72h, jae und jnc den Opcode 73h. Das gleiche gilt auch für jp und jpe, die ebenfalls Synonyme sind.

Das folgende Beispiel zeigt eine einfache IF-THEN-Anweisung:

 org 100h
 start:
   mov dx,meldung1
   mov ah,9h
   int 021h
   mov ah, 01h    ;Wert über die Tastatur einlesen
   int 021h
   cmp al, '5'
   jne ende
   mov dx,meldung2
   mov ah,9h
   int 021h
 ende:
   mov ah,4Ch
   int 21h
 section .data
   meldung1: db 'Bitte geben Sie eine Zahl ein:', 13, 10, '$'
   meldung2: db 13, 10, 'Sie haben die Zahl 5 eingegeben.', 13, 10, '$'

Nachdem Sie das Programm gestartet haben, werden Sie aufgefordert, eine Zahl einzugeben. Wenn Sie die Zahl 5 eingeben, erscheint die Meldung Sie haben die Zahl 5 eingeben.

Wie Sie sehen, prüfen wir nicht Gleichheit, sondern auf Ungleichheit. Der Grund hierfür ist, dass wir die nachfolgende Codesequenz ausführen wollen, wenn der Inhalt des AL Registers 5 ist. Da wir aber nur die Möglichkeit eines bedingten Sprungs haben, müssen wir überprüfen ob AL ungleich 5 ist.

Das folgende Programm zeigt die Implementierung einer IF-THEN-ELSE-Anweisung im Assembler:

 org 100h
 start:
     mov dx,meldung1
     mov ah,9h
     int 021h
     mov ah, 01h    ;Wert über die Tastatur einlesen
     int 021h
     cmp al, '5'

     ja l1
     mov dx,meldung2
     mov ah,9h
     int 021h
     jmp ende

 l1: mov dx,meldung3
     mov ah,9h
     int 021h
 ende:
     mov ah,4Ch
     int 21h
 section .data
 meldung1: db 'Bitte geben Sie eine Zahl ein:', 13, 10, '$'
 meldung2: db 13, 10, 'Sie haben eine Zahl kleiner oder gleich 5 eingegeben', 13, 10, '$' 
 meldung3: db 13, 10, 'Sie haben eine Zahl groesser 5 eingegeben' , 13, 10, '$'

Auch hier besitzt der bedingte Sprung eine „umgekehrte Logik“. Beachten Sie den unbedingten Sprung. Er verhindert, dass auch der ELSE-Zweig des Programms ausgeführt wird und darf deshalb nicht weggelassen werden.

Schleifen

Wie in jeder anderen Sprache auch hat der Assembler Schleifenbefehle. Eine mit FOR vergleichbare Schleife lässt sich mit loop realisieren. Der loop-Befehl hat die folgende Syntax:

  loop adresse

Bei der Adresse handelt es sich um eine relative Adresse, die 8 Bit groß ist. Da das Offset deshalb nur einen Wert von –128 bis +127 einnehmen darf, kann eine Schleife maximal 128 Byte Code erhalten – dies gilt auch für eine 32-Bit-CPU wie beispielsweise den Pentium IV. Umgehen lässt sich diese Beschränkung, wenn man die Schleife mit den Befehlen der bedingten Sprünge konstruiert, beispielsweise mit einem Near Jump.

Die Anzahl der Schleifendurchgänge befindet sich immer im CX-Register (daher auch der Name „Counter Register“). Bei jedem Durchgang wird der Inhalt um 1 verringert. Ist der Inhalt des CX-Registers 0 wird die Schleife verlassen und der nächste Befehl bearbeitet. Der Befehl ließe sich also auch mit der folgenden Befehlsfolge nachbilden:

dec cx
jne adresse

Wenn der Schleifenzähler um mehr als 1 verringert werden soll, kann der sub-Befehl verwendet werden. Wenn der Schleifenzähler um 2 oder 3 verringert wird, werden die meisten Assemblerprogrammierer stattdessen auf den dec-Befehl zurückgreifen, da dieser schneller als der sub-Befehl ist.

Das nachfolgende Programm berechnet 7!, die Fakultät von 7:

 org 100h
 start:
   mov cx, 7
   mov ax, 1
   mov bx, 1
 schleife:
   mul bx
   inc bx
   loop schleife
   mov ah, 4Ch
   int 21h

Mit dem Befehl mov cx, 7 wird der Schleifenzähler initialisiert. Insgesammt wird die Schleife 7-mal durchlaufen, im ersten Durchlauf mit CX=7 und BX=1, im letzten mit CX=1 und BX=7.

Das Ergebnis kann mit jedem Debugger überprüft werden (AX=13B0).

Neben den Normalen FOR-Schleifen existieren in den meisten Hochsprachen auch noch WHILE- oder „REPEAT ... UNTIL“-Schleifen. Im Assembler kann dazu die loope (loop if equal) und loopne (loop if not equal) als Befehl benutzt werden. Beide Befehle prüfen nicht nur, ob das CX-Register den Wert 0 erreicht hat, sondern zusätzlich noch das Zeroflag: Der loope durchläuft die Schleife solange, wie der Zeroflag gesetzt ist, der loopne-Befehl dagegen, solange das Zeroflag ungleich 0 ist.

| Hoch zu Assembler-Programmierung für x86-Prozessoren |