[home] [<-back] [index] [next->]
____________________________________________________________________
[2:. - [ Maschinenbefehle des 8068 ] [ireg] :. ]
[ireg@luschen.at] :. ]
____________________________________________________________________
Der folgende Text ist nur für hartgesottene Masochisten.
Mit Assembler hab ich mich früher viel beschäftigt, als
ich noch meinen Sinclair Spectrum gehabt habe.
Heute programmiere ich nur noch in Visual Basic, PHP oder
arbeite an HTML. Das Hardcorezeug ist nichts mehr für mich.
Die Auflistung beinhaltet alle Befehle des 8086 mit einer
Beschreibung und Taktangaben für den benötigten Zeitbedarf.
Viel Spass beim lesen was es alles für Befehle gibt.
_______________________________________________________________________
Auflistung aller Befehle:
AAA AAD AAM AAS ADC ADD AND CALL CBW CLC CLD CLI CMC CMP
CMPS CWD DAA DAS DEC DIV ESC HLT IDIV IMUL IN INC INT INTO
IRET JMP LAHF LDS LEA LES LOCK LODS LOOP LOOPE/LOOPZ
LOOPNE/LOOPNZ MOV MOVS NEG NOP NOT OR OUT POP POPF PUSH
PUSHF RCL RCR REP RET ROL ROR SAHF SAL SAR SBB SCAS SHL
SHR STC STD STI STOS SUB TEST WAIT XCHG XLAT XOR
Legende Flags:
O - Overflow
D - Direction
I - Interupt
T - Trag
S - Sign
Z - Zero
A - Auxiliary
P - Parity
C - Cary
(!=Changed,?=Not Defined,*=Unchanged,0=0,1=1)
Befehl: ()
Flags: O,D,I,T,S,Z,A,P,C
Beschreibung:
Beispiel:
Zeitbedarf: Takte
----------------------------
Zurück zur Auflistung
Befehl: AAA (ASCII Adjust for Addition)
Korrektur nach einer ASCII-Addition (ungepackte BCD-Addition)
Flags: O?,D*,I*,T*,S?,Z?,A!,P?,C!
Beschreibung:
AAA wandelt das duale Additionsergebnis im AL-Register in eine
BCD-ZAhl im AH und AL Register.
Beispiel:
mov al,7 ;AL = 7
add al,8 ;AL = AL + 8 -> AL = 0Fh = 15d
aaa ;AH = 1 und AL = 5 -> BCD-Zahl 15
Zeitbedarf: 4 Takte
----------------------------
Zurück zur Auflistung
Befehl: AAD (ASCII Adjust for Division)
Koorektur vor einer ASCII-Division (ungepackte BCD-Division)
Flags: O?,D*,I*,T*,S!,Z!,A?,P!,C?
Beschreibung:
AAD wandelt die BCD-Zahl im AH- und AL-Register in eine Dualzahl
um, welche sich anschließend
im AL-Register befindet. Das AH-Register wird auf 0 gesetzt.
Beispiel:
mov ah,7 ;AH = 7
aov al,1 ;AL = 1 -> AX = 0701 -> BCD-Zahl 71
aad ;AX = 0047 -> 47h = 71d
Zeitbedarf: 60 Takte
----------------------------
Zurück zur Auflistung
Befehl: AAM (ASCII Adjust for Multiplication)
Kooerktur nach einer ASCII-Multiplikation
(ungepackte BCD-Multiplikation)
Flags: O?,D*,I*,T*,S!,Z!,A?,P!,C?
Beschreibung:
AAM wandelt das duale Multiplikationsergebnis
im AX-Register in eine BCD-Zahl
im AH- und AL-Register um.
Beispiel:
mov al,8 ;AL = 8
mov ah,2 ;AH = 2
mul ah ;AX = AL * AH = 0010h = 16d
aam ;AH = 01 und AL = 06 -> BCD-Zahl 16
Zeitbedarf: 83 Takte
----------------------------
Zurück zur Auflistung
Befehl: AAS (ASCII Adjust for Subtraction)
Korrektur nach einer ASCII-Subtraktion
(ungepackte BCD-Subtraktion)
Flags: O?,D*,I*,T*,S?,Z?,A!,P?,C!
Beschreibung:
AAS wandelt das Subtraktionsergebnis im
AX-Register in eine BCD-Zahl um.
Beispiel:
mov ah,8 ;AH = 8
mov al,4 ;AL = 4
sub al,8 ;AX = 08FCh
aas ;AX = 0406 -> BCD-Zahl 76
Zeitbedarf: 4 Takte
----------------------------
Zurück zur Auflistung
Befehl: ADC Ziel,Quelle (ADd with Carry)
Addiere mit Carry-übertrag
Flags: O!,D*,I*,T*,S!,Z!,A!,P!,C!
Beschreibung:
ADC addiert den Inhalt der beiden Operanden
Ziel und Quelle mit dem Carry Flag auf dem Ziel-Operanden.
ADC wird besonders bei der Addition von 32-Bit-Werten
benötigt.
Beispiel:
Auf einem 32-Bit-Wert, der im Registerpaar DX:AX
abgespeichert ist, soll ein Wert addiert werden.
Da wir das Registerpaar DX:AX nicht direkt ansprechen können,
müssen wir den Wert erst auf das AX-Register addieren.
War das Ergebnis im AX-Register grösser 65535, ensteht
ein übertrag aus dem AX-Register, welcher im Carry Flag abgelegt
wird. Dieser übertrag muß mit dem ADC-Befehl
auf das höherwertige Wort im DX-Register addiert werden.
add ax,1234 ;Addiere zu dem Wert in DX:AX 1234
;(dezimal)
jc Ueber ;Wertebereich des AX-Registers
;überschritten
.
Ueber: adc dx,0 ;übertrag auf das höherwertige Wort
;addieren
Zeitbedarf: 3 Takte bei ADC Reg,Reg
4 Takte bei ADC Reg,Wert
9 Takte bei ADC Reg,Mem
16 Takte bei ADC Mem,Reg
----------------------------
Zurück zur Auflistung
Befehl: ADD Ziel,Quelle (ADD Addiere)
Flags: O!,D*,I*,T*,S!,Z!,A!,P!,C!
Beschreibung:
ADD addiert die Inhalte des Ziel- und Quelloperanden und legt
das Ergebnis im Zieloperanden ab.
Beispiel: :
mov ah,5 ;AH = 5
add ah,5 ;AH = AH + 5 = 10
Zeitbedarf: 3 Takte bei ADD Reg,Reg
4 Takte bei ADD Reg,Wert
9 Takte bei ADD Reg,Mem
16 Takte bei ADD Mem,Reg
----------------------------
Zurück zur Auflistung
Befehl: AND Ziel,Quelle (AND Logisches Und)
Flags: O0,D*,I*,T*,S!,Z!,A?,P!,C0
Beschreibung:
AND verknüpft den Zieloperanden bitweise mit dem
Quelloperanden nach der logischen UND-Verknüpfung
und legt das Ergebnis im Zieloperanden ab.
op1 op2 op1 AND op2
0 0 0
0 1 0
1 0 0
1 1 1
Beispiel:
mov ah,5 ;AH = 5d = 0101b
mov al,3 ;AL = 3d = 0011b
and ah,al ;AH = 1d = 0001b
Zeitbedarf: 3 Takte bei AND Reg,Reg
4 Takte bei AND Reg,Wert
9 Takte bei AND Reg,Mem
16 Takte bei AND Mem,Reg
----------------------------
Zurück zur Auflistung
Befehl: CALL Adr (CALL Aufruf eines Unterprogramms)
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
Call bewirkt das Laden einer Adresse, die beim CALL-Befehl
angegeben ist, in den Instruction-Pointer. Dies bewirkt, daß
die Programmausführung an der durch Adr angegebenen Adresse
fortgeführt wird. Zuvor wird die aktuelle Adresse des IP auf
dem Stack gesichert. Dieser Wert wird bei der Beendigung des
Unterprogramms durch einen RET-Befehl wieder vom Stack genommen
und in den IP geladen. (Beim FAR-Call wird zusätzlich das
CS-Register auf dem Stack zwischengespeichert).
Beispiel:
.
<1> call UP ;Aufruf des Unterprogramms UP
<2> . ;
UP PROC ;Anfang des Unterprogramms UP
. ;
;
. ;
ret ;Zurück zum Aufrufer <2>
Zeitbedarf: 19 Takte bei einem NEAR Unterprogramm
28 Takte bei einem FAR Unterprogramm
----------------------------
Zurück zur Auflistung
Befehl: CBW (Convert Byte to Word)
Umwandlung eines Bytes im AL-Register in ein Wort im AX-Register
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
CBW wandelt einen Byte-Wert mit Vorzeichen im AL-Register
in einen vorzeichenbehafteten Wort-Wert im AX-Register um.
Ist das Vorzeichen-Bit in AL positiv (Bit 7 = 0), wird
der Wert 00h in das AH-Register transportiert.
Im umgekehrten Fall (Bit 7 = 1 -> Negativ) wird der Wert FFh
in das AH-Register gestellt. Der CBW wird immer dann benötigt, wenn
ein 8-Bit Operand in einer 16-Bit-Operation, die das Vorzeichen
berücksichtigt, verwendet werden soll
(beispielsweise IMUL oder IDIV).
Beispiel:
xor ax,ax ;AX = 0000 0000 0000 0000b
mov al,01101111b ;AX = 0000 0000 0110 1111b
cbw ;AX = 0000 0000 0110 1111b
xor ax,ax ;AX = 0000 0000 0000 0000b
mov al,11110000b ;AX = 0000 0000 1111 0000b
cbw ;AX = 1111 1111 1111 1111b
Zeitbedarf: 2 Takte
----------------------------
Zurück zur Auflistung
Befehl: CLC (CLear Cary flag)
Lösche das übertragungs-Flag (CF=0)
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C0
Beschreibung:
CLC setzt das Carry Flag (CF) auf 0. Oft wird das Carry Flag als
Schalter benutzt. Der Befehl STC setzt das Carry Flag auf 1.
Mit dem Befehl CLC kann das übertragsflag auf 0 gesetzt werden
und so beispielsweise eine erfolgreiche Ausführung signalisieren.
Auch muß bei Befehlen wie ADC, RCL und SBB das Cary Flag manchmal
gelöscht werden.
Beispiel: :
clc ;Setze das Carry-Flag auf 0
call Up ;Aufruf Unterprogramm - Schalter CF = 0
jc Fehler ;Wenn CF = 1 springe zu Fehler
Zeitbedarf: 2 Takte
----------------------------
Zurück zur Auflistung
Befehl: CLD (CLear Direction flag)
Lösche das Richtungs-Flag (DF = 0)
Flags: O*,D0,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
CLD setzt das Direction Flad (DF) auf 0. Dadurch arbeiten
alle Stringoperationen in Richtung der größer werdenden
Adressen, also von links nach rechts (default).
Beispiel:
.
std ;Alle Stringoperationen arbeiten von rechts
;nach links
stosb ;Stringoperation
.
cld ;Alle Stringoperationen arbeiten von links
;nach rechts
movsb
Zeitbedarf: 2 Takte
----------------------------
Zurück zur Auflistung
Befehl: CLI (CLear Interrupt flag)
Lösche das Interrupt (IF=0)
Flags: O*,D*,I0,T*,S*,Z*,A*,P*,C*
Beschreibung:
CLI setzt das Interrupt Flag auf 0. Damit werden keine
externen Interrupts mehr zugelassen.
Dieser Befehl wird besonders in Zeitkritischen Phasen
benötigt, wo jeder Interrupt stören würde.
Beispiel:
cli ;extern maskierbare Interrups sperren
;(erstmal Ruhe)
;
sti ;extern maskierbare Interrupts wieder
;zulassen
Zeitbedarf: 2 Takte
----------------------------
Zurück zur Auflistung
Befehl: CMC (CoMplement Cary flag)
Drehe den Zustand des Carry Flags um
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C!
Beschreibung:
CMC dreht den zustand des Carry-Flags um, das heißt,
wenn CF = 1 ist, wird es auf 0 gesetzt und umgekehrt.
Dies ist sinnvoll beim ADC- und beim SBB-Befehl.
Beispiel:
clc ;CF = 0
cmc ;cf = 1
Zeitbedarf: 2 Takte
----------------------------
Zurück zur Auflistung
Befehl: CMP Ziel,Quelle (CoMPare two operands)
Vergleiche zwei Operanden
Flags: O!,D*,I*,T*,S!,Z!,A!,P!,C!
Beschreibung:
Der CMP-Befehl vergleicht zwei Operanden miteinander.
Beide Operanden müssen gleich groß sein (Byte, Byte oder
Wort,Wort). Das Ergebnis wird im Statusregister angezeigt.
Beispiel:
mov ah,7 ;AH = 7
cmp ah,max ;vergleiche AH-Register mit der
;Variablen max
je Gleich ;wenn nicht - springe zum Label
;Gleich:
jg Groesser ;wenn größer - springe zum Label
;Groesser:
jl Kleiner ;wenn kleiner - springe zum Label
;Kleiner:
.
Gleich:
;
Groesser:
;
Kleiner:
;
Zeitbedarf: 3 Takte bei CMP Reg,Reg
4 Takte bei CMP Reg,Wert
9 Takte bei CMP Reg,Mem
16 Takte bei CMP Mem,Reg
----------------------------
Zurück zur Auflistung
Befehl: CMPS Ziel,Quelle
CMPSB(CoMPare Strings Bytes)
CMPSW(CoMParw String Words
Vergleiche zwei Zeichenketten byte- oder wortweise
Flags: O!,D*,I*,T*,S!,Z!,A!,P!,C!
Beschreibung:
CMPS vergleicht die Inhalte zweier Zeichenketten miteinander.
Der Zielstring wird durch das Registerpaar ES:DI adressiert,
der Quell-String durch das Registerpaar DS:SI.
Der CMPS-Befehl wird mit den Wiederholungs-Präfixen
REPE/REPNE eingesetzt. So können Texte auf übereinstimmung
miteinander verglichen werden. Nach einem Vergleich
werden die beiden Index-Register DI und SI, entsprechend
den gesetzten Direction-Flag,
automatisch erhöht oder gesenkt.
Beispiel:
lea di,Ziel ;Index-Register DI zeigt auf den Ziel-
;String
lea si,Quelle ;Index-Register SI zeigt auf den Quell-
;String
cmpsb ;vergleiche Ziel und Quelle byteweise
cmpsw ;vergleiche Ziel und Quelle wortweise
Zeitbedarf: 22 Takte (pro Vergleich)
----------------------------
Zurück zur Auflistung
Befehl: CWD (Convert Word to Dubleword)
Umwandlung Inhelt des AX-Registers in ein Doppel-Wort, welches
im Registerpaar DX:AX abgelegt wird
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
CWD setzt alle Bits im DX-Register auf den gleichen Wert
wie das Corzeichenbit (Bit 15) im AX-Register.
Das bedeutet, ist das Vorzeichenbit im AX positiv (Bit 15 = 0)
wird der Wert 0000h nach DX geschoben, ist AX negativ
(Bit 15 = 0) wird der wert FFFFhin das DX-Register transportiert.
Der CWD-Befehl wird immer dann benötigt, wenn
ein 16-Bit-Operand in einer 32-Bit-Operation, die
das Vorzeichen berücksichtigt
verwendet werden soll (beispielsweise IDIV).
Beispiel:
mov ax,1000
mov bx,330
cwd ;Vorzeichen AX nach DX verlängern
idiv bx ;Wort/Wort=Ergebnis in AX, Rest in DX
Zeitbedarf: 5 Takte
----------------------------
Zurück zur Auflistung
Befehl: DAA (Decimal Adjust for Addition)
Korrektur nach einer gepackten BCD-Addition
Flags: O?,D*,I*,T*,S!,Z!,A!,P!,C!
Beschreibung:
DAA ist dem Befehl AAA ähnlich, mit dem Unterschied,
daß bei der DAA gepackte BCD-Zahlen
korrigiert werden.
Beispiel:
mov al,8 ;AL = 08h
add al,3 ;Al = 0Bh
daa ;AL = 11 (BCD-Darstellung)
Zeitbedarf: 4 Takte
----------------------------
Zurück zur Auflistung
Befehl: DAS (Decimal Adjust for Subtraction)
Korrektur nach einer gepackten BCD-Subtraction
Flags: O!,D*,I*,T*,S!,Z!,A!,P!,C!
Beschreibung:
DAS wandelt das Subtraktionsergebnis im AL-Register in eine
gültige, gepackte BCD-Darstellung um.
Beispiel:
mov ah,17 ;gepackte BCD-Ziffer
sub ahh,6 ; " "
das ;gepackte Dezimaldifferenz
Zeitbedarf: 4 Takte
----------------------------
Zurück zur Auflistung
Befehl: DEC Quelle (DECrement)
Subtrahiere den Wert 1 vom Quelloperanden
Flags: O!,D*,I*,T*,S!,Z!,A!,P!,C*
Beschreibung:
Quelle = Quelle - 1
Beispiel:
mov ah,9 ;AH = 9
dec ah ;AH = 8
dec ah ;AH = 7
Zeitbedarf: 2 Takte bei DEC Reg
15 Takte bei DEC Mem
----------------------------
Zurück zur Auflistung
Befehl: DIV Quelle (DIVision)
Division ohne Vorzeichen
Flags: O?,D*,I*,T*,S?,Z?,A?,P?,C?
Beschreibung:
Der DIV-Befehl dividiert das AX-Register bzw. das
Registerpaar DX:AX durch den Quelloperanden
Divident / Divisor = Quotient Rest
AX (16 Bit) / Operand(8 Bit)= AL AH
DX:AX (32 Bit) / Operand(16Bit)= AX DX
Beispiel:
;Byte-Division
mov ax,330 ;AX = Divident
mov bh,12 ;BH = Divisor (Byte)
div bh ;AX / Byte = AL(Quotient) DX(Rest)
;Wort-Division
xor dx:dx ;High-Teil 32-Bit-Wert löschen
mov ax,30445 ;AX = Divident (Low-Teil 32-Bit-Wert)
mox dx,330 ;DX = Divisor (Wort)
div dx ;DX:AX / Wort = AX(Quotient) DX(Rest)
Zeitbedarf: 85 Takte bei DIV Reg (16-Bit)
150 Takte bei DIV Reg (32-Bit)
90 Takte bei DIV Mem (16-Bit)
155 Takte bei DIV Mem (32-Bit)
----------------------------
Zurück zur Auflistung
Befehl: ESC Koprozessorbefehl,Operand (ESCape)
Speicherzugriff
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
ESC sendet einen Befehl an den Koprozessor.
Der erste Operand ist eine Konstante,
die den Befehl an den Coporzessor enthält.
Der zweite Operand ist ein Register
oder ein Speicheroperand, der den Operanden zum
Coprozessorbefehl darstellt.
Beispiel:
ESC Opcode,al ;Opcode enthält einen Coprozessorbefehl
;AL wird als Parameter zum Opcode mit
;übergeben
Zeitbedarf: 10 Takte
----------------------------
Zurück zur Auflistung
Befehl: HLT (HaLT)
Prozessor anhalten
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
Der HLT-Befehl veranlaßt den Prozessor,
in einen Wartezustand
zu gehen. Dieser Zustand
kann durch den RESET-Befehl oder durch einen
Interrupt wieder aufgehoben werden.
Beispiel:
;Wir warten auf einen Tastendruck
hlt ;warte auf einen Interrupt
mov ah,1 ;Funktion zum Prüfen, ob Zeichen
int 16h ;im Tastaturpuffer vorhanden
Zeitbedarf: 2 Takte
----------------------------
Zurück zur Auflistung
Befehl: IDIV Quelle (Integer DIVision)
Division mit Vorzeichen
Flags: O?,D*,I*,T*,S?,Z?,A?,P?,C?
Beschreibung:
Der IDIV-Befehl dividiert das AX-Register bzw. das
Registerpaar DX:AX durch den Quelloperanden,
unter Berücksichtigung des Vorzeichens.
Divident / Divisor = Quotient Rest
AX (16 Bit) / Operand(8 Bit)= AL AH
AX:DX (32 Bit) / Operand(16Bit)= AX DX
Unter Berücksichtigung des Vorzeichens:
(+) / (+) = (+) (+)
(-) / (+) = (-) (-)
(+) / (-) = (-) (+)
(-) / (-) = (-) (-)
Beispiel:
;Byte-Division
mov ax,-330 ;AX = Divident (-)
mov bh,12 ;BH = Divisor (Byte) (+)
idiv bh ;AX(-) / Byte (+) = AL (Quotient) (+)
;AH (Rest) (-)
mov ax,-233 ;AX = Divident
mov bh,-14 ;BH = Divisor (Byte) (-)
;AX (-) / Byte (-) = AL (Quotient) (-)
;AH (Rest)
;Wort-Division
xor dx,dx ;High - Teil 32-Bit-Wert löschen (+)
mov ax,30445 ;AX = Dividend (Low-Teil 32-Bit-Wert) (+)
mov dx,300 ;DX = Divisor (Wort) (-)
;DX:AX / Wort = AX (Quotient) (-)
;DX(Rest) (+)
Zeitbedarf: 105 Takte bei IDIV Reg (16 Bit)
170 Takte bei IDIV Reg (32 Bit)
110 Takte bei IDIV Mem (16 Bit)
180 Takte bei IDIV Mem (32 Bit)
----------------------------
Zurück zur Auflistung
Befehl: IMUL Quelle (Integer MULtiply)
Multiplikation mir Vorzeichen
Flags: O!,D*,I*,T*,S?,Z?,A?,P?,C!
Beschreibung:
Der Befehl IMUL multipliziert den angegebenen
Quelloperanden mit dem AL-Register (Quelle = Byte)
oder mit dem AX-Register (Quelle = Wort).
Das Ergebnis wird bei einer Byte-Multiplikation
im AX-Register abgelegt, bei einer Wort-Multiplikation
wird das Registerpaar DX:AX verwendet.
Multiplikant * Multiplikator = Ergebnis
AL (8 Bit) * Operand(8 Bit) = AX (16 Bit)
AX(16 Bit) * Operand(16Bit) = DX:AX (32 Bit)
Unter Berücksichtigung des Vorzeichens:
(-) * (-) = (+)
(+) * (-) = (-)
(-) * (+) = (-)
(+) * (+) = (+)
Beispiel:
;Byte Multiplikation mit Vorzeichen
mov al,35 ;Multiplikand (Byte)
mov bl,-2 ;Multiplikator (Byte)
imul bl ;AX (Wort) = AL (Byte) * BL (Byte) = -70
;Wort Multiplikation mit Vorzeichen
mov ax,-360 ;Multiplikand (Wort)
mov bx,-45 ;Multiplikator (Wort)
imul bx ;DX:AX (Doppelwort) = AX (Wort) * BX
;(Wort) = +16200
Zeitbedarf: 90 Takte bei IMUL Reg (8 Bit)
135 Takte bei IMUL Reg (16 Bit)
100 Takte bei IMUL Mem (8 Bit)
145 Takte bei IMUL Mem (16 Bit)
----------------------------
Zurück zur Auflistung
Befehl: IN AX-/AL-Register,Quelle (INput byte and word)
Einlesen eines Bytes oder Wortes von einem Eingabeport
Flags: O!,D*,I*,T*,S?,Z?,A?,P?,C!
Beschreibung:
Der IN-Befehl transportiert ein Byte oder Wort vom
Quelloperanden, der den E/A-Port angibt,
in den Akkumulator, der das eingelesene Byte oder Wort aufnimmt.
Beispiel:
;Der Tastaturpuffer hat die Portadresse 60h
in al,60h ;lese ein Byte vom E/A-Port mit der Adresse
;60h
;(Tastaturpuffer) in das AL-Register
Zeitbedarf: 10 Takte
----------------------------
Zurück zur Auflistung
Befehl: INC Quelle (INCrement)
Addiere den Wert 1 zum Quelloperanden
Flags: O!,D*,I*,T*,S!,Z!,A!,P!,C*
Beschreibung:
Quelle = Quelle + 1
Beispiel:
mov ah,7 ;AH = 7
inc ah ;AH = 8
inc ah ;AH = 9
Zeitbedarf: 3 Takte bei INC Reg
15 Takte bei INC Mem
----------------------------
Zurück zur Auflistung
Befehl: INT Interrupt (INTerrupt)
Unterbreche durch einen Interrupt
Flags: O*,D*,I0,T0,S*,Z*,A*,P*,C*
Beschreibung:
Der INT-Befehl bewirkt die Ausführung eines Softwareinterrupts.
Beispiel:
;Freie Speicherkapazität der Festplatte ermitteln über
;INT 21h
;Eingabe: AH = 36h
; DL = LW = 0 = aktuelles Laufwerk
; 1 = Laufwerk A
; 2 = Laufwerk B usw.
;Ausgabe: AX = 0FFFFh = Fehler sonst
; AX = Anzahl der Sektoren pro Cluster
; BX = Anzahl der freien Cluster
; CX = Anzahl der Bytes pro Cluster
; DX = Anzahl der Cluster gesamt
xor dl,dl ;überprüfe die Speicherkapazität des
;aktuellen Lw
mov ah,36h ;Funktion Plattenkapazität ermitteln
int 21h ;Funktion (Intrerrupt) aufrufen
cmp ax,0FFFFh ;Fehler?
je Fehler ;ja - springe in zum Label Fehler:
;Freien Speicherplatz ermitteln
mul cx ;freier Speicher in Bytes = Anzahl
;Sektoren pro
mul bx ;Cluster * Anzahl Bytes pro Sektor * Anzahl
;freie Cluster -> AX = AX * CX * BX
Zeitbedarf: 51 Takte
----------------------------
Zurück zur Auflistung
Befehl: INTO (INTerrupt if Overflow)
Löse einen Interrupt aus, wenn das überlauf-Flag gesetzt ist)
Flags: O*,D*,I0,T0,S*,Z*,A*,P*,C*
Beschreibung:
INTO erzeugt den Softwareinterrupt INT 4 bei Auftreten eines
überlaufs (OF = 1).
Der Interrupt 4 ist unter DOS nicht belegt und muß vorher
durch den Programmierer
auf eine entsprechende Routine gesetzt werden.
Beispiel:
add ax,Wort_Var
into ;Wenn der Wertebereich im AX-Register
;überschritten wird
;(AX > 65535) löse den Softwareinterrupt INT 4 aus
Zeitbedarf: 53 Takte, falls der Interrupt ausgeführt wird
4 Takte, wenn der Interrupt nicht ausgeführt wird
----------------------------
Zurück zur Auflistung
Befehl: IRET (Interrupt RETurn)
Rückkehr aus einer Interruptroutine
Flags: O!,D!,I!,T!,S!,Z!,A!,P!,C!
Beschreibung:
IRET kehrt zu dem Befehl hinter einer selbstgeschriebenen Interrupt-Anweisung zurück.
Dazu werden das Codesegment, der IP und das Statusregister vom Stack genommen.
Beispiel:
INT_4 PROC FAR
;
iret ;Zurück zum Aufrufer
INT_4 ENDP
Zeitbedarf: 24 Takte
----------------------------
Zurück zur Auflistung
Befehl: JMP Ziel (JuMP)
Unbedingter Sprung zur Zieladresse
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
Der JMP-Befehl bewirkt einen Sprung auf eine Adresse
im Programm, die mit dem Zieloperanden
angegeben wird.
Beispiel:
; .
jmp Ziel ;springe zu dem Label Ziel:
; .
Ziel:
; .
Zeitbedarf: 15 Takte
----------------------------
Zurück zur Auflistung
Befehl: Jxxx Adr (Jump on Condition)
Bedingter Sprung zur Zieladresse
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Die bedingten Sprünge des 8086-Prozessors
Befehl: Sprung wenn... Jump if ... Geprüfte Statusflags:
JA/JNBE größer / nicht-kleiner-gleich CF = 0 und ZF = 0
above / not-below-equal
JAE/JNB größer-gleich / nicht-kleiner CF = 0
above-equal / not-below
JB/JNAE kleiner / nicht-größer-gleich CF = 1
below / not-above-equal
JBE/JNA kleiner-gleich / nicht-größer CF = 1 oder ZF = 1
below-equal / not-equal
JE/JZ gleich / null ZF = 1
equal / zero
JG/JNLE größer / nicht-kleiner-gleich ZF = 0
greater / not-less-equal
JGE/JNL größer-gleich / nicht-kleiner SF gleich OF
greater-equal / not-less
JL/JNGE kleiner / nicht-größer-gleich SF ungleich OF
less / not-greater-equal
JLE/JNG kleiner-gleich / nicht-größer ZF = 1
less-equal / not-greater
JNE/JNZ nicht-gleich / nicht-null ZF = 0
not-equal / not-zero
JC Carry Flag (CF) gesetzt CF = 1
Carry
JNC Carry Flag (CF) nicht gesetzt CF = 0
not-Carry
JNP/JPO keine-Parität / Parität ungerade PF = 0
not-Parity / Parity-odd
JNO kein überlauf OF = 0
not-Overflow
JNS kein Vorzeichen (positiv) SF = 0
not-Sign
JO überlauf OF = 1
Overflow
JP/JPE Parität / Parität-gerade PF = 1
Parity / Parity-even
Beschreibung:
Jede der Vorgestellten Sprunganweisungen testet die
Flags im Statusregister und führt
einen Sprung nach Ziel aus, wenn die angegebene
Bedingung erfüllt ist.
Beispiel:
cmp ax,bx ;vergleiche die Inhalte von AX und BX
je Gleich ;springe wenn AX = BX zu Gleich:
jg Groesser ;springe wenn AX > BX zu Groesser:
jl Kleiner ;springe wenn AX < BX zu Kleiner:
Zeitbedarf: 16 Takte, wenn der Sprung ausgeführt wird
4 Takte, wenn nicht
----------------------------
Zurück zur Auflistung
Befehl: LAHF (Load AH from Flags)
Lade das Low-Byte des Statusregisters in das AH-Register
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
LAHF transpoertiert die niederwertigen 8 Bits aus dem
Statusregister in das AH-Register.
Beispiel:
;Bit 7 6 5 4 3 2 1 0
lahf ;AH= SF ZF ? AF ? PF ? CF
Zeitbedarf: 4 Takte
----------------------------
Zurück zur Auflistung
Befehl: LDS Ziel,Quelle (Load Data Segment register)
Lade Datensegment und ein Register
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
Der Befehl LDS überträgt die Segmentadresse des Quelloperanden
in das Datensegment und die
Offsetadresse des Quelloperanden in den Zieloperanden.
Beispiel:
lds si,String ;Segment- und Offsetadresse gleichzeitig
;laden
;String wird jetzt durch das Registerpaar
;DS:SI adressiert
Zeitbedarf: 16 Takte
----------------------------
Zurück zur Auflistung
Befehl: LEA Ziel,Quelle (Load Effective Address)
Lade effektive Adresse
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
LEA berechnet und überträgt den Offset (effektife Adresse) des
Quelloperanden in den Zieloperanden.
Beispiel:
lea bx,Tabelle ;Der BX-Register zeigt auf den Anfang
;von Tabelle
Zeitbedarf: 2 Takte
----------------------------
Zurück zur Auflistung
Befehl: LES Ziel,Quelle (Load ES-register)
Lade Extrasegment und ein Register
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
Der Befehl LES überträgt die Segmentadresse des
Quelloperanden in das Extrasegment
und die Offsetadresse des Quelloperanden in den
Zieloperanden.
Beispiel:
les si,String ;Segment. und Offsetadresse
;gleichzeitig laden
;String wird jetzt durch das
;Registerpaar ES:SI adressiert
Zeitbedarf: 16 Takte
----------------------------
Zurück zur Auflistung
Befehl: LOCK (LOCK)
Bussperre
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
LOCK bewirkt, daß der Bus für die Dauer des nächsten
Befehls gesperrt bleibt.
Der Befehl dient in einer Multiprozessor-Umgebung
zur Synchronisation des Zugriffs
mehrerer Prozessoren auf den Systembus.
Beispiel:
lock and al,ah ;für diesen Befehl bleibt der Bus gesperrt
Zeitbedarf: 2 Takte
----------------------------
Zurück zur Auflistung
Befehl: LODS (LOaD String)
LOADSB (Byte)
LOADSW (Word)
Lade ein Byte oder ein Wort eines Stringelementd
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
Laden eines Stringelements in das AL- (Byte) oder AX-Register (Wort).
Der String wird über das Registerpaar DS:SI adressiert.
Beispiel:
lea si,String ;SI-Register zeigt auf den Anfang von
;String
lodsb ;hole ein Byte aus String in das
;AL-Register
lodsw ;hole ein Wort aus String in das
;AX-Register
Zeitbedarf: 12 Takte
----------------------------
Zurück zur Auflistung
Befehl: LOOP Adr (LOOP until count complete)
Springe zur Adresse, solange das CX-Register nicht null
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
Der LOOP-Befehl subtrahiert vom CX-Register den
Wert 1 und überprüft anschließend das CX-Register auf null.
Ist das CX-Register nicht null,
wird zu der angegebenen Adresse verzweigt, ist der
Wert null, wird mit dem nächsten
Befehl nach LOOP fortgeführt.
Beispiel:
; .
mov cx,10 ;CX ist der Schleifenzähler
Schleife:
;
loop Schleife ;Befehlssequenz 10 * ausführen
Zeitbedarf: 17 Takte, wenn die Verzweigung ausgeführt wird
5 Takte, wenn nicht
----------------------------
Zurück zur Auflistung
Befehl: LOOPE/LOOPZ Adr (LOOP if Equal/LOOP if Zero)
Springe zu der Adresse, solange das CX-Register nicht null ist und
solange das Zero-Flag gesetzt ist
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
LOOPE und LOOPZ arbeiten wie der LOOP-Befehl, mit dem Zusatz, daß zu der
angegebenen Adresse nur dann verzweigt wird, wenn das Zero-Flag gesetzt ist (ZF = 1).
Die Schleife wird also verlassen, wenn CX = 0 oder ZF = 0 ist.
Beispiel:
;Suche in einer Tabelle ein Zeichen ungleich "A".
;Beende die Suche, wenn ein Zeichen ungleich "A"
;gefunden wird oder das Ende der Tabelle erreicht wird.
mov cx,Laenge ;CX = Länge der Tabelle
mov bx,-1 ;BX = Index
Schleife:
inc bx ;ein Element der Tab weiter
cmp Tab[bx],"A" ;vergleiche auf "A"
loope Schleife ;wenn gleich - springe
;zu Schleife:
Zeitbedarf: 18 Takte, wenn Verzweigung ausgeführt wird
6 Takte, wenn nicht
----------------------------
Zurück zur Auflistung
Befehl: LOOPNE/LOOPNZ Adr (LOOP if Not Equal/LOOP if Not Zero)
Springe zu der Adresse, solange das CX-Register nicht null ist
und solange das Zero-Flag
nicht gesetzt ist
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
LOOPNE und LOOPNZ arbeiten wie der LOOP-Befehl, mit dem
Zusatz, daß zu der angegebenen
Adresse nur dann verzweigt wird, wenn das Zero-Flag nicht
gesetzt ist. Die Schleife wird
also verlassen, wenn CX = 0 oder ZF = 1 ist.
Beispiel:
;Suche in einer Tabelle das Zeichen "*".
;Beende die Suche, wenn das Zeichen gefunden wird oder
;das Ende der Tabelle erreicht wird.
mov cx,Laenge ;CX = Länge der Tabelle
mov bx,-1 ;BX = Index
Schleife:
inc bx ;ein Element der Tab weiter
cmp Tab[bx],"*" ;vergleiche auf "*"
loopne Schleife ;wenn nicht gleich -
;oder ein Ende
;der Tabelle - springe zu
;Schleife:
Zeitbedarf: 19 Takte, wenn Verzweigung ausgeführt wird
5 Takte, wenn nicht
----------------------------
Zurück zur Auflistung
Befehl: MOV Ziel,Quelle (MOVe)
übertrage/Kopiere
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
Der MOV-Befehl kopiert den Inhalt des Quelloperanden in den
Zieloperanden. Beide Operanden müssen vom gleichen Typ sein
(Byte,Byte / Word,Word). Als Zieloperand kann jedes Register
oder eine Speichervariable angegeben werden.
Der Quelloperand kann zusätzlich aus einem
Direktwert bestehen.
Beispiel:
mov ax,2000 ;AX = 2000
mov ch,250 ;CH = 250
mov ax,bx ;AX = BX
mov cx,Laenge ;CX = Laenge
Zeitbedarf: 2 Takte bei MOV Reg,Reg (8 Bit/16 Bit)
4 Takte bei MOV Reg,Wert (8 Bit/16 Bit)
8 Takte bei MOV Reg,Mem (8 Bit/16 Bit)
9 Takte bei MOV Mem,Reg (8 Bit/16 Bit)
10 Takte bei MOV Mem,Wert (8 Bit/16 Bit)
----------------------------
Zurück zur Auflistung
Befehl: MOVS Ziel,Quelle (MOVe String or Word)
MOVSB (Byte)
MOVSW (Word)
Stringelement übertragen
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
MOVS überträgt ein Element einer Zeichenkette, welches durch den
Quelloperanden (DS:SI) definiert ist, in der Zieloperanden (ES:DI).
MOVS faßt somit die beiden Befehle LODS und STOS zusammen.
Nach jeder übertragung werden die Segmentregister SI und DI,
je nach gesetztem Direction-Flag um den Wert der übertragenen
Größe erhöht oder gesenkt.
Beispiel:
;Kopieren einer Zeichenkette in eine andere.
.
cld ;Zeichenkette wird von links nach rechts
;verarbeitet
lea si,Quelle ;was kopiert wird
lds di,Ziel ;wohin wird kopiert
mov cx,Laenge ;Länge von Quelle
rep movsb ;Ziel (ES:DI) <-- 18="" 20="" 100="" byte-weise="" -="" quelle="" zeitbedarf:="" takte="" ----------------------------="" befehl:="" mul="" multiply="" vorzeichenlose="" multiplikation="" flags:="" beschreibung:="" multipliziert="" den="" quelloperanden="" mit="" dem="" oder="" ax-register="" bei="" einer="" wort-multiplikation.="" multplikant="" multiplikator="Ergebnis" al="100" ax="" beispiel:="" byte-multiplikation="" mov="" bh="Byte"> AX = AL * BH
sorry guys, this section was screwed up.... SYSTEM ERROR
;Byte-mit-Wort-Multiplikation
xor ah,ah ;AH = 0
mov al,Summe ;AL = Summe
mov bx,500 ;BX = 500
mul bx ;BX = Wort -> DX:AX = AX * BX
;DX = höherwertiger Teil des Ergebnisses
;AX = niederwertiger Teil des Ergebnisses
Zeitbedarf: 75 Takte bei MUL Reg (8 Bit)
125 Takte bei MUL Reg (16 Bit)
----------------------------
Zurück zur Auflistung
Befehl: NEG Operand (NEGate)
Negieren [2er-Komplement bilden]
Flags: O!,D*,I*,T*,S!,Z!,A!,P!,C!
Beschreibung:
NEG bildet das Zweierkomplement vom Operanden.
Beispiel:
mov ah,00001100b ;AH = 0000 1100 binär = 12 dezimal
neg ah ;AH = 1111 0100 binär = -12 dezimal
Zeitbedarf: 3 Takte bei NEG Reg
16 Takte bei NEG Mem
----------------------------
Zurück zur Auflistung
Befehl: NOP (No OPerantion)
Keine Operation
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
NOP führt keine Operation durch. Dieser Befehl
dient dem Assembler dazu, eine
Warteschleife aufzubauen.
Beispiel:
;Warte 6 Maschinentakte
nop
nop
Zeitbedarf: 3 Takte
----------------------------
Zurück zur Auflistung
Befehl: NOT Operand (NOT)
Logisches Nicht
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
NOT bildet von dem angegebenen Operanden
die logische Negation, das heißt, alle Bits
des Operanden gehen von Eins auf Null und umgekehrt.
op1 NOT op1
0 1
1 0
Beispiel:
mov al,00001111b ;AL = 0000 1111 binär
not al ;AL = 1111 0000 binär
Zeitbedarf: 3 Takte bei NOT Reg
16 Takte bei NOT Mem
----------------------------
Zurück zur Auflistung
Befehl: OR Ziel,Quelle (OR)
Logisches Oder
Flags: O0,D*,I*,T*,S!,Z!,A?,P!,C0
Beschreibung:
OR verknüpft den Quelloperanden bitweise mit mit
dem Zieloperanden nach der logischen Oder-Regel
op1 op2 op1 OR op2
0 0 0
0 1 1
1 0 1
1 1 1
Beispiel:
mov ah,10101101b ;AH = 1010 1101 binär
mov al,01100111b ;AL = 0110 0111 binär
or al,ah ;AL = 1110 1111 binär
Zeitbedarf: 3 Takte bei OR Reg,Reg
4 Takte bei OR Reg,Wert
9 Takte bei OR Reg,Mem
16 Takte bei OR Mem,Reg
----------------------------
Zurück zur Auflistung
Befehl: OUT Port-Adresse,AX-/AL-Register (OUTput)
Ausgabe eines Bytes oder Wortes an eine Portadresse
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
Der OUT-Befehl übergibt ein Byte im AL-Register oder
ein Wort im AX-Register an eine Portadresse.
Liegt die Portadresse im Bereich zwischen 0 und 255,
kann sie als Direktwert angegeben werden.
Ist die Portadresse größer 255, muß der Wert
im DX-Register angegeben werden.
Beispiel:
;Schreibe ein Byte in den Tastaturpuffer
;Portadresse der Tastatur ist 60h
mov al,"?" ;AL = "?"
out 60h,al ;schreibe das Zeichen "?" in den
;Tastaturpuffer
Zeitbedarf: 10 Takte
----------------------------
Zurück zur Auflistung
Befehl: POP Ziel (POP word off stack)
übertrage obersten Stack-Inhalt
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
Mit diesem Befehl werden zwei Bytes von der Spitze
des Stacks in den Zieloperanden übertragen .
Das Offsetregister des Stacks, der Stackpointer,
wird anschließend um den Wert 2 erhöht.
Beispiel:
push ax ;Inhalt des AX-Registers auf den Stack speichern
pop ax ;Inhalt des obersten Stack-EIntrags nach AX
;kopieren
Zeitbedarf: 8 Takte bei POP Reg
16 Takte bei POP Mem
----------------------------
Zurück zur Auflistung
Befehl: POPF (POP Flags off stack)
übertrage den obersten Stack-Inhalt in das Statusregister
Flags: O!,D!,I!,T!,S!,Z!,A!,P!,C!
Beschreibung:
Mit diesem Befehl werden zwei Bytes von der Spitze
des Stacks in das Statusregister übertragen.
Das Offsetregister des Stacks, der Stackpointer
wird um den Wert 2 erhöht.
Beispiel:
pushf ;Inhalt des Statusregisters auf den Stack
;speichern
;
popf ;alten Zustand des Statusregisters
;wiederherstellen
Zeitbedarf: 8 Takte
----------------------------
Zurück zur Auflistung
Befehl: PUSH Quelle (PUSH word to stack)
übertrage den Quelloperanden auf den Stack
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
PUSH subtrahiert vom Stackpointer den Wert 2 und
reserviert somit einen freien Platz(Wort)
auf dem Stack. Danach wird der Quelloperand,
der eine Wort-Größe darstellen muß, auf dem
Stack kopiert.
Beispiel:
push ax ;Inhalt AX-Register zwischenspeichern
push wort_var ;Variable wort_var zwischenspeichern
Zeitbedarf: 11 Takte bei PUSH Reg
16 Takte bei PUSH Mem
----------------------------
Zurück zur Auflistung
Befehl: PUSHF (PUSH Flags to stack)
übertrage das Statusregister auf den Stack
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
PUSHF überträgt das Statusregister auf den Stack.
Beispiel:
pushf ;rette den Inhalt des Statusregisters
popf ;alten Inhalt des Statusregisters
;wiederherstellen
Zeitbedarf: 10 Takte
----------------------------
Zurück zur Auflistung
Befehl: RCL Ziel,n (Rotate through Carry Left)
Rotiere nach links durch das Carry Flag
Flags: O!,D*,I*,T*,S*,Z*,A*,P*,C!
Beschreibung:
Der RCL-Befehl rotiert die einzelnen Bits des
Zieloperanden n-mal nach links.
Das höherwertige Bit des Zieloperanden wird im
Carry-Flag abgelegt. Vor dieser
Operation wird der aktuelle Inhalt des Carry-Flags in
das niederwertige Bit des
Zieloperanden geschoben. Soll mehr als ein Bit des
Zieloperanden verschoben werden,
muß der Wert über das CL-Register angegeben werden.
Beispiel:
clc ;CF = 0
mov al,01101001b ;AL = 0110 1001 binär
rcl al,1 ;AL = 1101 0010 binär CF = 0
mov cl,2 ;CL = 2
rcl al,cl ;AL = 0100 1001 binär CF = 1
Zeitbedarf: 2 Takte bei RCL Reg,1
8 + 4 * n Takte bei RCL Reg,CL
15 Takte bei RCL Mem,1
20 + 4 * n Takte bei RCL Mem,CL
----------------------------
Zurück zur Auflistung
Befehl: RCR Ziel,n (Rotate through Carry Right)
Rotiere nach rechts durch das Carry Flag
Flags: O!,D*,I*,T*,S*,Z*,A*,P*,C!
Beschreibung:
Der RCL-Befehl rotiert die einzelnen Bits des
Zieloperanden n-mal nach rechts.
Das höherwertige Bit des Zieloperanden wird im
Carry-Flag abgelegt.
Vor dieser Operation wird der aktuelle Inhalt des
Carry-Flags ín das höherwertige Bit des
Zieloperanden geschoben. Soll mehr als ein Bit des
Zieloperanden verschoben werden, muß der Wert über
das CL-Register angegeben werden.
clc ;CF = 0
mov al,01101001b ;AL = 0110 1001 binär
rcr al,1 ;AL = 0011 0100 binär CF = 1
mov cl,2 ;CL = 2
rcr al,cl ;AL = 0100 1101 binär CF = 0
Zeitbedarf: 2 Takte bei RCR Reg,1
8 + 4 * n Takte bei RCR Reg,CL
15 Takte bei RCR Mem,1
20 + 4 * n Takte bei RCR Mem,CL
----------------------------
Zurück zur Auflistung
Befehl: REP (REPeat string operation)
REPE/REPNE
REPZ/REPNZ
Wiederhole Stringoperation
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
REP ist ein Präfix vor einem Stringbefehl und
wiederholt diesen, solange das CX-Register nicht
null ist. Bei jedem Durchlauf wird das CX-Register
um den Wert 1 gesenkt.
Zusätzlich gibt es zum REP-Befehl verschiedene Varianten:
REPE/REPZ ;Wiederhole bis CX = 0 und ZF = 1
REPNE/REPNZ ;Wiederhole bis CX = 0 und ZF = 0
Beispiel:
;Füllen einer Tabelle mit Hilfe des Stringbefehls STOSB
;und der REP-Anweisung
cld ;Stringverarbeitung aufsteigend
les di,Zielstring ;STOSB überträgt den Inhalt des
;AL-Registers
mov al," " ;in die durch ES:DI adressierte
;Speicherstelle
mov cx,Laenge_Ziel ;Länge des Zleistrings nach CX
rep stosb ;Füllen des Zielstrings mit Blank
;Suche nach einem Zeichen mit SCASB ind der REPNE-Anweisung
cld ;Stringverarbeitung aufsteigend
les di,Zielstring ;SCASB vergleicht die durch ES:DI
;adressierte
mov al,"&" ;Speicherstelle mit dem
;AL-Register
mov cx,Laenge_Ziel ;Länge des Zielstrings nach CX
repne scasb ;vergleiche bis Ende Zielstring
;oder
je Gefunden ;Zeichen gefunden
Zeitbedarf: 2 Takte
----------------------------
Zurück zur Auflistung
Befehl: RET (RETurn)
Rücksprung aus einem Unterprogramm
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
Beim Aufruf eines Unterprogramms durch den CALL-Befehl
wird der auf den CALL-Befehl folgende Befehl auf dem
Stack zwischengespeichert. RET holt diese Adresse vom Stack
zurück und setzt dadurch die Programmausführung
nach dem CALL-Befehl fort.
Beispiel:
<1> .
<2> call UP ;Aufruf des Unterprogramms UP <4>
<3> .
<4> UP PROC ;Anfang des Unterprogramms UP
<5> .
<6>
<7> .
<8> RET ;zurück zum Aufrufer <3>
<9> UP ENDP
Zeitbedarf: 8 Takte bei einem NEAR Unterprogramm
18 Takte bei einem FAR Unterprogramm
----------------------------
Zurück zur Auflistung
Befehl: ROL Ziel,n (ROtate Left)
Rotiere nach links
Flags: O!,D*,I*,T*,S*,Z*,A*,P*,C!
Beschreibung:
ROL rotiert den Zieloperanden um n Bits nach links.
Das höherwertige Bit wird in das Carry Flag und in
das niederwertige Bit des Zieloperanden übertragen.
Soll mehr als ein Bit nach links verschoben werden,
muß der Wert im CL-Register angegeben werden.
Beispiel:
mov ah,01101101b ;AH = 0110 1101 binär
rol ah,1 ;AH = 1101 1010 binär CF = 0
mov cl,2 ;CL = 2
rol ah,cl ;AH = 0110 1011 binär CF = 1
Zeitbedarf: 2 Takte bei ROL Reg,1
8 + 4 * n Takte bei ROL Reg,CL
15 Takte bei ROL Mem,1
20 + 4 * n Takte bei ROL Mem,CL
----------------------------
Zurück zur Auflistung
Befehl: ROR Ziel,n (POtate Right)
Rotiere nach rechts
Flags: O,D,I,T,S,Z,A,P,C
Beschreibung:
ROL rotiert den Zieloperanden um n Bits nach rechts.
Das niederwertige Bit wird in das Carry Flag und in das
höherwertige Bit des Zieloperanden übertragen.
Soll mehr als ein Bit nach links verschoben werden, muß
der Wert im CL-Register angegeben werden.
Beispiel:
mov ah,01101101b ;AH = 0110 1101 binär
ror ah,1 ;AH = 1011 0110 binär CF = 1
mov cl,2 ;CL = 2
ror ah,cl ;AH = 1010 1101 binär CF = 1
Zeitbedarf: 2 Takte bei ROR Reg,1
8 + 4 * n Takte bei ROR Reg,CL
15 Takte bei ROR Mem,1
20 + 4 * n Takte bei ROR Mem,CL
----------------------------
Zurück zur Auflistung
Befehl: SAHF (Store AH into Flags)
Kopiere den Inhalt des AH-Registers in das untere
Byte des Statusregisters
Flags: O*,D*,I*,T*,S!,Z!,A!,P!,C!
Beschreibung:
überträgt den Inhalt des AH-Registers in das
niederwertige Byte des Statusregisters.
Aus diese Weise können sie Statusflags
SF, ZF, AF, PF,und CF nicht nur durch bedingte
Sprungbefehle abgetestet werden.
Beispiel:
;Löschen des SF,ZF,AF,PF und CF
xor ah,ah ;AH = 0
sahf ;SF=ZF=AF=PF=CF=0
Zeitbedarf: 4 Takte
----------------------------
Zurück zur Auflistung
Befehl: SAL Ziel,n (Shift Arithmetic Left)
Verschiebe arithmetisch nach links
Flags: O!,D*,I*,T*,S!,Z!,A?,P!,C!
Beschreibung:
SAL hat die gleiche Funktion wie SHL und bewirkt,
daß der Zieloperand um n Bits nach links
geschoben wird. Das höherwertige Bit des
Zieloperanden wird beim Shiften in das Carry Flag
übertragen. Das niederwertige Bit wird mit einer
Null gefüllt. Soll mehr als ein Bit
verschoben werden, muß der Wert im CL-Register
angegeben werden.
Beispiel:
;Das Verschieben des Zieloperanden um ein Bit nach links
;und das Auffüllen des niederwertigen Bits mit dem Wert
;Null bewirkt in der Dualarithmetik eine Multiplikation
;mit dem Wert 2
mov ah,20 ;AH = 20
sal ah,1 ;AH = 40
mov cl,2 ;CL = 2
sal ah,cl ;AH = 160
Zeitbedarf: 2 Takte bei SAL Reg,1
8 + 4 * n Takte bei SAL Reg,CL
15 Takte bei SAL Mem,1
20 + 4 * n Takte bei SAL Mem,CL
----------------------------
Zurück zur Auflistung
Befehl: SAR Ziel,n (Shift Arithmetic Rigtht)
Verschiebe arithmetisch nach rechts
Flags: O!,D*,I*,T*,S!,Z!,A?,P!,C!
Beschreibung:
SAR bewirkt, daß der Zieloperand um n Bits nach
rechts geschoben wird.
Das niederwertige Bit des Zieloperanden wird beim
Shiften in das Carry Flag übertragen.
Das höherwertige Bit (Vorzeichen) wird dabei nicht mit
Null aufgefüllt, sondern mit einer Kopie des Vorzeichens.
Soll mehr als ein Bit nach rechts geschoben werden, muß
der Wert im CL-Register angegeben werden.
Beispiel:
;Das Verschieben des Zieloperanden um ein Bit nach
;rechts bewirkt in der Dualarithmetik eine Division
;durch den Wert 2. Da SAR das Vorzeichenbit nicht
;verändert, können vorzeichenbehaftete Operanden
;vorzeichengerecht dividiert werden.
mov ah,-40 ;AH = -40
sar ah,1 ;AH = -20
mov cl,2 ;CL = 2
sar ah,cl ;AH = -5
Zeitbedarf: 2 Takte bei SAR Reg,1
8 + 4 * n Takte bei SAR Reg,CL
15 Takte bei SAR Mem,1
20 + 4 * n Takte bei SAR Mem,CL
----------------------------
Zurück zur Auflistung
Befehl: SBB Ziel,Quelle (SuBtract with Borrow)
Subtraktion mit übertrag
Flags: O!,D*,I*,T*,S!,Z!,A!,P!,C!
Beschreibung:
SBB subtrahiert den Inhalt des Quelloperanden vom
Inhalt des Zieloperanden unter Berücksichtigung
des Carry Flags. Ist das Carry Flag gesetzt (CF = 1),
wird dieses vom Zieloperanden subtrahiert.
SBB wird hauptsächlich bei der Subtraktion von
32-Bit-Werten benutzt.
Beispiel:
;Vom 32-Bit-Wert (DX:AX) einen 16-Bit-Wert (BX)
;subtrahieren
sub ax,bx ;32-Bit-Low-Wert - 16-Bit-Wert
sbb dx,0 ;übertrag berücksichtigen
Zeitbedarf: 3 Takte bei SBB Reg,Reg
9 Takte bei SBB Reg,Mem
16 takte bei SBB Mem,Reg
----------------------------
Zurück zur Auflistung
Befehl: SCAS (SCAn String)
SCASB
SCASW
Vergleiche String [ES:DI] mit dem Akkumulator
Flags: O!,D*,I*,T*,S!,Z!,A!,P!,C!
Beschreibung:
SCAS vergleicht einen String, der durch das
Registerpaar ES:DI adressiert ist, mit dem
Inhalt des AL-Registers (Byte) oder des
AX-Registers (Wort).
Beispiel:
;Suche in einer Zeichenkette das Zeichen "*"
mov cx,Laenge_String ;Wiederhole CX mal für REPNE
les di,Such_String ;dieser String wird durchsucht
mov al,"*" ;Zeichen, nach dem gesucht witrd
repne scasb ;suche bis Zeichen gefunden oder
;Ende String
je Gefunden ;wenn Zeichen gefunden - springe
;zu Gefunden:
Zeitbedarf: 15 Takte pro vergleich
----------------------------
Zurück zur Auflistung
Befehl: SHL Ziel,n (Shift Arithmetic Left)
Verschiebe arithmetisch nach links
Flags: O!,D*,I*,T*,S!,Z!,A?,P!,C!
Beschreibung:
SAL hat die gleiche Funktion wie SAL und bewirkt,
daß der Zieloperand um n Bits nach links geschoben
wird. Das höherwertige Bit des Zieloperanden wird
beim Shiften in das Carry Flag übertragen.
Das niederwertige Bit wird mit einer Null gefüllt.
Soll mehr als ein Bit verschoben werden,
muß der Wert im CL-Register angegeben werden.
Beispiel:
;Das Verschieben des Zieloperanden um ein Bit nach links
;und das Auffüllen des niederwertigen Bits mit dem Wert
;Null bewirkt in der Dualarithmetik eine Multiplikation
;mit dem Wert 2
mov ah,20 ;AH = 20
shl ah,1 ;AH = 40
mov cl,2 ;CL = 2
shl ah,cl ;AH = 160
Zeitbedarf: 2 Takte bei SHL Reg,1
8 + 4 * n Takte bei SHL Reg,CL
15 Takte bei SHL Mem,1
20 + 4 * n Takte bei SHL Mem,CL
----------------------------
Zurück zur Auflistung
Befehl: SHR Ziel,n (SHift logical Right)
Verschiebe logisch nach rechts
Flags: O!,D*,I*,T*,S!,Z!,A?,P!,C!
Beschreibung:
SHR bewirkt, daß der Zieloperand um n Bits nach
rechts geschoben wird. Das niederwertige Bit des
Zieloperanden wird beim Shiften in das Carry Flag
übertragen. Das höherwertige Bit wird mit einer
Null aufgefüllt. Soll mehr als ein Bit nach rechts
verschoben werden, muß der Wert im CL-Register
angegeben werden.
Beispiel:
;Das Verschieben des Zieloperanden um ein Bit nach
;rechts und das Auffüllen des höherwertigen Bits mit dem
;Wert Null bewirkt in der Dualarithmetik eine Division
;durch den Wert 2
mov ah,200 ;AH = 200
shr ah,1 ;AH = 100
mov cl,2 ;CL = 2
shr ah,cl ;AH = 25
Zeitbedarf: 2 Takte bei SHR Reg,1
8 + 4 * n Takte bei SHR Reg,CL
15 Takte bei SHR Mem,1
20 + 4 * n Takte bei SHR Mem,CL
----------------------------
Zurück zur Auflistung
Befehl: STC (SeT Carry flag)
Setze das Carry Flag auf Eins (CL = 1)
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C1
Beschreibung:
STC setzt das Carry Flag auf Eins.
Beispiel:
clc ;CF = 0
stc ;CF = 1
Zeitbedarf: 2 Takte
----------------------------
Zurück zur Auflistung
Befehl: STD (SeT Direction flag)
Setze das Direction Flag auf Eins (DF = 1)
Flags: O*,D1,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
STD setzt das Direction Flag auf Eins.
Dadurch arbeiten alle Stringoperationen in
Richtung absteigender Adressen, also von
rechts nach links.
Beispiel:
.
std ;Alle Stringoperationen arbeiten von rechts
;nach links
stosb ;Stringoperation
.
cld ;Alle Stringoperationen arbeiten von links
;nach rechts
movsb
Zeitbedarf: 2 Takte
----------------------------
Zurück zur Auflistung
Befehl: STI (SeT Interrupt flag)
Setze Interrupt Flag auf Eins (IF = 1)
Flags: O*,D*,I1,T*,S*,Z*,A*,P*,C*
Beschreibung:
STI setzt das Interrupt Flag aud Eins.
Damit werden externe Interrupts, die mit CLS
gesperrt wurde, wieder zugelassen.
Beispiel:
cli ;extern maskierbare Interrupts sperren
;(erst mal Ruhe)
;
sti ;extern maskierbare Interrupts wieder
;zulassen
Zeitbedarf: 2 Takte
----------------------------
Zurück zur Auflistung
Befehl: STOS (STOre String byte or Word)
STOSB
STOSW
übertrage den Inhalt des Akkumulators in einen
String [ES:DI]
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
STOS übertragt den Inhalt des AL-Registers bei
einer Byte-Verarbeitung bzw. den Inhalt des
AX-Registers bei einer Wort-Verarbeitung in
einen durch das Registerpaar ES:DI
adressierten Speicherbereich.
Beispiel:
;Füllen einer Tabelle mit Hilfe
;des Stringbefehls STOSB
;und REP
cld ;von links nach rechts
les di,ZielTab ;STOSB überträgt den Inhalt des
;AL-Registers
mov al,0 ;in die durch ES.DI adressierte
;Speicherstelle
mov cx,Laenge_Ziel ;Länge der Tabelle nach CX
rep stosb ;Füllen der Tabelle mit dem Wert
;Null
Zeitbedarf: 11 Takte
----------------------------
Zurück zur Auflistung
Befehl: SUB Ziel,Quelle (SUBtract)
Subtrahiere
Flags: O!,D*,I*,T*,S!,Z!,A!,P!,C!
Beschreibung:
Der Inhalt des Quelloperanden wird vom Inhalt
des Zieloperanden subtrahiert und das
Ergebnis im Zieloperanden abgespeichert.
Beispiel:
mov ax,2000 ;AX = 2000
sub ax,500 ;AX = 1500
mov ah,40 ;AH = 40
mov al,10 ;AL = 10
sub ah,al ;AH = 30
Zeitbedarf: 3 Takte bei SUB Reg,Reg
4 Takte bei SUB Reg,Wert
9 Takte bei SUB Reg,Mem
16 Takte bei SUB Mem,Reg
17 Takte bei SUB Mem,Wert
----------------------------
Zurück zur Auflistung
Befehl: TEST Ziel,Quelle (TEST)
Logischer Vergleich [Und-VErknüpfung]
Flags: O0,D*,I*,T*,S!,Z!,A?,P!,C0
Beschreibung:
TEST verknüpft den Zieloperanden bitweise mit
dem Quelloperanden nach der Und-Verküpfung.
Das Ergebnis des Vergleichs wird nicht
abgespeichert sondern verändern nur das
Statusregister.
Beispiel:
;Ein vorzeichenbehafteter Byte-Wert soll auf
:positiv oder negativ geprüft werden.
;
;Bit 7 6 5 4 3 2 1 0
; 0 Vorzeichenbit (Bit 7) = 0 -> Positiv
; 1 Vorzeichenbit (Bit 7) = 1 -> Negativ
;
TEST al,10000000b ;Bit 7 gesetzt
je Negativ ;Ja - negativer Wert
jmp positiv ;Nein - positiver Wert
Zeitbedarf:
----------------------------
Zurück zur Auflistung
Befehl: WAIT (Wait until not busy)
Warte
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
Der Prozessor wird in einen Wartezustand versetzt,
bis der Coprozessor einen ihm übertragenen Befehl
abgearbeitet hat. Dazu wird in einem Abstand von
5 Takten die Eingangsleitung TEST überprüft, welche
der Coprozessor nach der Ausführung des
Befehls aktiviert. Dieser Befehl wird immer dann
benötigt, wenn der Coprozessor langsamer
getaktet ist als der Hauptprozessor (Synchronisation).
Beispiel:
;
wait ;warte so lange, bis der Befehl abgearbeitet wird
Zeitbedarf: 3 + 5 * n Takte
----------------------------
Zurück zur Auflistung
Befehl: XCHG Operand1,Operand2 (eXCHanGe)
Vertausche Inhalt der Operanden
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
XCHG vertauscht den Inhalt der beiden Operanden.
Beide Operanden müssen gleich groß
sein, einer von ihnen muß ein Register sein.
Beispiel:
mov ah,40 ;AH = 40
mov dh,10 ;DH = 10
xchg ah,dh ;vertausche die Inhalte der beiden Operanden
;AH = 10 und DH = 40
Zeitbedarf: 4 Takte für XCHG Reg,Reg
17 Takte für XCHG Reg,Mem
----------------------------
Zurück zur Auflistung
Befehl: XLAT (transLATe)
XLATB
Tabellenelement umschlüsseln
Flags: O*,D*,I*,T*,S*,Z*,A*,P*,C*
Beschreibung:
XLAT transportiert ein Byte aus einer Tabelle, die über
das BX-Register adressiert wird, in das AL-Register.
Das AL-Register wird vor dem eigentlichen
Befehlsaufruf XLAT als Index verwendet.
Beispiel:
.
Tab db "ABCDEF"
.
lea bx,Tab ;BX = Offset von Tab
xor al,al ;AL = 0 -> Index = Erstes Element von Tab
xlatb ;AL = "A"
mov al,3 ;AL = 3 -> Index = viertes Element von Tab
xlat Tab ;AL = "D"
Zeitbedarf: 11 Takte
----------------------------
Zurück zur Auflistung
Befehl: XOR (eXclusive OR)
Exklusives Oder
Flags: O0,D*,I*,T*,S!,Z!,A?,P!,C0
Beschreibung:
XOR verknüpft den Zieloperanden bitweise mit dem
Quelloperanden nach der Exklusiv-Oder-Verknüpfung.
Das Ergebnis wird im Zieloperanden abgelegt.
op1 op2 XOR op2
0 0 0
0 1 1
1 0 1
1 1 0
Beispiel:
xor ax,ax ;AX = 0
Zeitbedarf: 3 Takte bei XOR Reg,Reg
4 Takte bei XOR Reg,Wert
9 Takte bei XOR Reg,Mem
16 Takte bei XOR Mem,Reg
17 Takte bei XOR Mem,Wert
______________________________________________________________