Hier sind ausführlichere Funktionsbeschreibungen der Assembler Funktionen zu finden. Als Ergänzung zu diesen Informationen können die Listen verwendet werden die Beschreibungen Opcode und Flags aller Funktionen enthalten.
Das Format einer Assembler Codezeile:
[Label] Funktion/Anweisung [Operanden] [; Kommentar]
Label: Sprungmarke
Funktion: Assembler Mnemonic
Parameter: Parameter und Operanden der Funktion, optionale Parameter sind in eckige Klammern [ ] gesetzt.
Kommentar: Beschreibender Kommentar der bei Compilierung nicht Berücksichtigt wird, alles nach dem Strichpunkt ;
Weitere Dokumente:
Beschreibung-Kurz-CPU
Flag, Flags-CPU
OpCode, OpCodes-CPU
Schnell-Kurs
(Die Basis für diese Texte stammen aus dieser Quelle AS.pdf, mit freundlicher Genehmigung von Klaus Wüst)
English: Move
Deutsch: Bewegen, Daten kopieren
Funktion Ziel , Quelle
Ziel: reg8/16/32 | mem8/16/32
Quelle: reg8/16/32 | mem8/16/32 | Konstante
Allgemeiner und häufig verwendeter Transportfunktion, kopiert den Quelloperanden in den Zieloperanden, der Quelloperand bleibt unverändert.
Einschränkungen:
* Beide Operanden müssen gleiche Bitbreite haben
* Es können nicht beide Operanden Speicheroperanden sein.
* Es können nicht beide Operanden Segmentregister sein.
* Konstanten können nicht in Segmentregister geschrieben werden
Für wiederholten Datentransport von | zu Speicherplätzen kommen auch die Funktionen MOVS, LODS und STOS in Frage.
;--------
MOV AX, 16
;--------
MOV AX, DS ; Umweg über AX notwendig
MOV ES, AX ; um DS nach ES zu kopieren
;--------
MOV CH, CL ; Anwendung auf 8 Bit-Register
;--------
MOV BX, [BP+4] ; mit SpeicheroperandEnglish: Exchange
Deutsch: Austauschen
Funktion Operand1 , Operand2
Operand1: reg8/16/32 | mem8/16/32
Operand2: reg8/16/32 | mem8/16/32
Datenaustausch zwischen zwei Registern oder Register und Speicher. Beide Operanden müssen gleiche Bitbreite haben und wenigstens einer von beiden muß ein Registeroperand sein.
;--------
XCHG CH, CL
;--------
XCHG AX, [BX+DI+1]English: Move with Zero- | Sign Extension
Deutsch: Bewegen mit Null- | Vorzeichenerweiterung
Funktion Operand1 , Operand2
Operand1: reg16/32 | mem16/32
Operand2: reg8/16 | mem8/16
Datentransport von kleineren in größere Register. Die Daten werden immer auf die niederwertigen Bits geschrieben. MOVZX füllt dabei die frei bleibenden höherwertigen Bits mit Nullen auf. MOVSX füllt die frei bleibenden höherwertigen Bits vorzeichenrichtig auf, d.h. je nach Vorzeichen mit 0 oder 1.
;--------
MOVZX EAX, DL
;--------
MOVSX DX, CLEnglish: SET if cc
Deutsch: Bedingtes Setzen
Funktion Operand
Operand: reg8 | mem8
Schreibt in den Operanden (=Ziel) eine 1 als 8-Bit-Wert, wenn die mit cc beschriebene Bedingung erfüllt ist und schreibt eine 0 wenn nicht. Die durch cc (Conditions) angedeuteteten möglichen Bedingungen sind die gleichen wie beim bedingte Sprung-Funktion Jcc.
cc-Code
SETZ CL ; 01h in cl, wenn Zeroflag gesetzt, sonst 00h in cl
SETGE var8 ; 01h in var8, wenn Größer/gleich-Bedingungerfüllt, sonst eine 00hEnglish: Negation
Deutsch: Negation
Funktion Operand
Operand: reg8/16/32 | mem8/16/32
Negiert den Operanden im Zweierkomplement, d.h. wechselt dessen Vorzeichen.
MOV AX, 5000
NEG AX ; Inhalt von AX ist jetzt -5000English: Increment | Decrement
Deutsch: Inkrement | Dekrement
Funktion Operand
Operand: reg8/16/32 | mem8/16/32
MOV CX, 80
L1:
CALL Unterprog
DEC CX ; Schleifenzählvariable herabzählen
JNZ L1 ; bedingter SprungEnglish: Addition | Addition with Carry
Deutsch: Addition | Addition mit übertrag
Funktion Operand1 , Operand2
Operand1: reg8/16/32 | mem8/16/32
Operand2: reg8/16/32 | mem8/16/32 | Konstante
ADD: Operand1 wird zu Operand2 addiert, das Ergebnis wird in Operand1 abgelegt.
ADC: Operand1 und der Inhalt des Carryflags werden zu Operand2 addiert, das Ergebnis wird in Operand1 abgelegt.
Die Funktionen arbeiten für vorzeichenbehaftete und vorzeichenlose Zahlen korrekt. Es können nicht beide Operanden Speicheroperanden sein. Die Kombination aus ADD und ADC ermöglicht die Addition beliebig großer Zahlen.
Siehe: SUB, SBB
;-------- Es soll a = b + c mit 16 Bit-Zahlen berechnet werden
MOV AX, [b] ; AX = b
ADD AX, [c] ; AX = b+c
MOV [a],AX ; a = b+c
;--------
.DATA
dvar1 DD ; doubleword (32 Bit)
dvar2 DD ; ''
.CODE
MOV AX, word ptr [dvar1] ; low word von dvar1 nach AX
ADD word ptr [dvar2],AX ; zu low word von dvar2 addieren
MOV AX, word ptr [dvar1+2] ; high word von dvar1 nach AX
ADC word ptr [dvar2+2],AX ; zu high word von dvar2 addieren
; dabei übertrag (Carry) addierenEnglish: Subtraction | Subtraction with Borrow
Deutsch: Subtraktion | Subtraktion mit Borgen
Funktion Operand1 , Operand2
Operand1: reg8/16/32 | mem8/16/32
Operand2: reg8/16/32 | mem8/16/32 | Konstante
SUB: Operand2 wird von Operand1 subtrahiert, das Ergebnis wird in Operand1 abgelegt.
SBB: Operand2 und der Inhalt des Carryflags werden von Operand1 subtrahiert, das Ergebnis wird in Operand1 abgelegt.
Die Funktionen arbeiten für vorzeichenbehaftete und vorzeichenlose Zahlen korrekt. Es können nicht beide Operanden Speicheroperanden sein. Die Kombination aus SUB und SBB ermöglicht die Subtraktion beliebig großer Zahlen.
Siehe: ADD, ADC
;-------- Es soll a = b - c mit 16 Bit-Zahlen berechnet werden
MOV AX, [b] ; AX = b
SUB AX, [c] ; AX = b-c
MOV [a],AX ; a = b-c
;--------
.DATA
dvar1 DD ; doubleword (32 Bit)
dvar2 DD ; ''
.CODE
; 32 Bit Subtraktion
MOV AX, word ptr [dvar1] ; low Word von dvar1 nach AX
SUB word ptr [dvar2],AX ; von low Word von dvar2 subtrahieren
MOV AX, word ptr [dvar1+2] ; high Word von dvar1 nach AX
SBB word ptr [dvar2+2],AX ; von high Word von dvar2 subtrahieren
; dabei übertrag (Carry) subtrahierenEnglish: Multiplication
Deutsch: Multiplikation
Funktion Multiplikator
Multiplikator: reg8/16/32 | mem8/16/32
MUL führt eine Multiplikation vorzeichenloser Zahlen durch. In der Funktion ist als Operand explizit nur der Multiplikator genannt, der Multiplikand ist immer AL bzw. AX. Je nach Bitbreite des Multiplikators wird eine Byte-, Wort- oder Doppelwort-Multiplikation durchgeführt. Bei der Byte-Multiplikation ist der Multiplikand AL und das Ergebnis wird in AX abgelegt. Bei der Wort-Multiplikation ist AX der Operand und das Ergebnis wird in DX-AX abgelegt, wobei AX das niederwertige Wort enthält. Bei der Doppelwort-Multiplikation ist EAX der Multiplikand und das Ergebnis wird in EDX-EAX abgelegt. Da ein Overflow nicht möglich ist, werden die Flags CF und OF dann gesetzt, wenn das Ergebnis die Bitbreite der Quelloperanden überschreitet.
Siehe: IMUL, DIV, IDIV
;-------- Multiplikation zweier 8 Bit-Speicheroperanden
.DATA
Multiplikand DB 50
Multiplikator DB 12
.CODE
MOV AL, [Multiplikand] ; AL = 50
MUL [Multiplikator] ; Byte-Multiplikation mit 12
; -> AX=600, CF=1, OF=1 da Ergebnis>255English: Integer Multiplication
Deutsch: vorzeichenrichtige Multiplikation
IMUL existiert (ab dem 386) in drei Varianten: Mit einem, zwei oder drei Operanden. Die erste Variante stellt für das Multiplikationsergebnis doppelt so viele Bit zur Verfügung wie die Operanden haben, die beiden letzten nur gleich viele! In den beiden letzten Varianten sind also ernste Fehler möglich! In allen Fällen werden die Flags CF und OF dann gesetzt, wenn das Ergebnis die Bitbreite der Quelloperanden überschreitet. Für die Varianten mit zwei oder drei Operanden bedeutet dies einen echten Fehler.
Siehe: MUL, DIV, IDIV
Funktion Multiplikator
Multiplikator: reg8/16/32 | mem8/16/32
IMUL mit einem Operanden führt eine Multiplikation vorzeichenbehafteter Zahlen durch und arbeitet ansonsten wie MUL.
Funktion Operand1 , Operand2
Operand1: reg16/32
Operand2: reg16/32 | mem16/32 | Konstante
IMUL mit zwei Operanden führt eine vorzeichenrichtige Multiplikation der beiden Operanden durch und legt das Ergebnis im ersten Operanden ab.
Funktion Operand1 , Operand2 , Operand3
Operand1: reg16/32
Operand2: reg16/32 | mem16/32
Operand3: Konstante
IMUL mit drei Operanden führt eine vorzeichenrichtige Multiplikation des zweiten und dritten Operanden durch und legt das Ergebnis im ersten Operanden ab.
;-------- Multiplikation zweier 8 Bit-Speicheroperanden
.DATA
zahl1 DW 1200
zahl2 DD 3000
.CODE
IMUL ECX ; multipliziert EAX mit ECX, Ergebnis in EDX-EAX
IMUL DI, zahl1 ; DI =English: Unsigned divide | signed Integer divide
Deutsch: vorzeichenlose Division | vorzeichenbehaftete Division
Funktion Divisor
Divisor: reg8/16/32 | mem8/16/32
In der Funktion wird nur der Divisor explizit als Operand aufgeführt, der Dividend ist immer AX bzw. DX:AX Je nach Bitbreite des Divisors wird eine Byte- oder eine Wort-Division durchgeführt. Dabei wird jeweils der ganzzahlige Quotient und der Rest separat abgelegt.
Bei der Byte-Division ist der Dividend AX. Der ganzzahlige Teil des Divisionsergebnis wird in AL und der Rest in AH abgelegt. Bei der Wort-Division ist der Dividend DX:AX. Der ganzzahlige Teil des Divisionsergebnis wird in AX und der Rest in DX abgelegt. Wenn das | die Zielregister nicht ausreicht um das Ergebnis aufzunehmen (bei kleinen Divisoren) tritt der sog. Divisionsfehler ein. In diesem Fall wird "INT 0" ausgelöst. Ein Spezialfall des Divisionsfehler ist die Division durch Null.
Siehe: MUL, IMUL
;-------- Bsp.1: Division eines Doppelwortes
.DATA
Dividend DD 010017h ; 65559d
Divisor DW 10h ; 16d
.CODE
MOV AX, [word ptr Dividend] ; niederwertiger Teil in AX
MOV DX, [word ptr Dividend+2] ; höherwertiger Teil in DX
DIV [word ptr Divisor] ; Division durch 10h
; -> ganzzahliger Teil des Quotienten: AX=1001h (4097d)
; -> Divisionsrest: DX=7
;--------
; Bsp.2: Division durch eine negative Zahl mov ax, 50
mov bl, -3
idiv bl
; -> Divisonsergebnis in AL: AL=F0h (-16 im Zweierkomplement)
; -> Divisionsrest in AH: AH=2English: NOT Negation
Deutsch: Negation, Invertierung
Funktion Operand
Operand: reg8/16/32 | mem8/16/32
Führt eine bitweise Negation des Operanden aus, d.h. 0 --> 1 und 1 --> 0.
MOV [mask],11110011b
NOT [mask] ; mask hat jetzt den Wert 00001100b d.h.12English: logical AND | OR | exclusive OR
Deutsch: logisches UND | ODER | exklusives ODER
Funktion Zieloperand , Operand2
Zieloperand: reg8/16/32 | mem8/16/32
Operand2: reg8/16/32 | mem8/16/32 | Konstante
O S Z P C
Hiervon werden OF und CF immer gelöscht!
Diese Funktionen führen bitweise logische Operationen zwischen Zieloperand und Operand2 aus, das Ergebnis wird im Zieloperand abgelegt. Die Bitoperationen sind
* AND: logisches UND, Ergebnisbit=1 wenn beide Operandenbits=1, sonst Ergebnisbit=0
* OR: logisches ODER, Ergebnisbit=1 wenn mindestens eines der beiden Operandenbits=1, sonst Ergebnisbit=0
* XOR: logisches exklusives ODER, Ergebnisbit=1 wenn die Summe der beiden Operandenbits=1 ist, sonst Ergebnisbit=0
;--------
AND AL, 01111111b ; Im Register AL Bit 7 löschen
;--------
OR [Maske],00000100b ; In Variable ''Maske'' Bit2 = 1 setzen
;--------
XOR [Maske],0F0h ; high nibble invertieren, low nibble bleibt
;--------
XOR AX, AX ; XOR wird auch häufig, wie in diesem Fall zum schnellen Löschen eines Registers verwendetEnglish: Shift right | Shift left
Deutsch: Schieben nach rechts | Schieben nach links
Funktion Operand , Anzahl
Operand: reg8/16/32 | mem8/16/32
Anzahl: 1 | CL
Schiebt ("Shiftet´') den Operanden um eine oder mehrere Stellen bitweise nach rechts | links.
Siehe: SAR, SAL
English: Shift arithmetic right | left
Deutsch: Arithmetisches Schieben nach rechts | links
Funktion Operand , Anzahl
Operand: reg8/16/32 | mem8/16/32
Anzahl: 1 | CL
SAL ist identisch mit SHL. Die Funktion überträgt das MSB ins CF, das freiwerdende LSB wird mit 0 besetzt.
SAR unterscheidet sich von SHR. Bei SHR wird das LSB ins CF übertragen und MSB wird mit 0 besetzt. Bei SAR wird MSB unverändert belassen und auf die benachbarte Stelle kopiert. LSB wird ins CF übertragen. Als Anzahl kann entweder 1 oder CL angegeben werden. Im ersten Fall wird einmal um ein Bit geschoben, im zweiten Fall so oft wie der Inhalt von CL vorgibt. OF ist im zweiten Fall undefiniert. SHR und SHL können verwendet werden um an einer vorzeichenlosen Zahl eine Multiplikation bzw. Division mit | durch 2, 4, 8 . . . durchzuführen. SAR und SAL können verwendet werden um an einer vorzeichenbehafteten Zahl eine Multiplikation bzw. Division mit | durch 2, 4, 8 . . . durchzuführen.
Siehe: ROR, ROL, RCR, RCL
;--------
SHL BX, 1 ; BX wird mit 2 multipliziert,
; gleichwertig: SAL BX, 1
;--------
MOV CL, 4
SHR [spalte],CL ; ''spalte'' vorzeichenlos durch 16 teilen
; Divisionsrest ist unbehandelt
;--------
SAR [differenz],1
; ''differenz'' wird durch 2 geteilt, Vorzeichen wird
; korrekt behandelt, Divisionsrest ist im CFEnglish: Rotate right | Rotate left
Deutsch: Rotieren nach rechts | Rotieren nach links
Funktion Operand , Anzahl
Operand: reg8/16/32 | mem8/16/32
Anzahl: 1 | CL
Das herausfallende Bit wird ins CF und auf den freiwerdenden Platz übertragen. Durch ROR wird also LSB nach MSB und (ins CF) übertragen, bei ROL ist es umgekehrt.
Als Anzahl kann entweder 1 oder CL angegeben werden. Im ersten Fall wird einmal um ein Bit rotiert, im zweiten Fall so oft wie der Inhalt von CL vorgibt. OF ist im zweiten Fall undefiniert.
Siehe: SHR, SHL, SAR, SAL, RCR, RCL
MOV CL, 8
ROL AX, CL ; Gleichwertig mit XCHG AH, ALEnglish: Rotate through Carry right | left
Deutsch: Rotieren durch Carry rechts | links
Funktion Operand , Anzahl
Operand: reg8/16/32 | mem8/16/32
Anzahl: 1 | CL
RCR Rotiert den Operanden um eine oder mehrere Stellen bitweise nach rechts und bezieht das Carry-
Flag mit ein.
RCL Rotiert den Operanden um eine oder mehrere Stellen bitweise nach links und bezieht das Carry-
Flag mit ein.
Schiebt ("Shiftet") den Operanden um eine oder mehrere Stellen bitweise nach rechts | links. Durch RCR wird das CF auf das MSB und das LSB ins CF übertragen. Im Unterschied zu ROR | ROL wird also das CF als Teil der rotierenden Einheit betrachtet. Durch RCL wird das MSB ins CF und das CF ins LSB übertragen.
Als Anzahl kann entweder 1 oder CL angegeben werden. Im ersten Fall wird einmal um ein Bit rotiert, im zweiten Fall so oft wie der Inhalt von CL vorgibt. OF ist im zweiten Fall undefiniert.
Siehe: ROR, ROL, SHR, SHL, SAR, SAL
MOV CL, 5
ROL [var1],CL ; rotiert ''var1'' um 5 BitEnglish: Test
Deutsch: Testen
Funktion Operand1 , Operand2
Operand1: reg8/16/32 | mem8/16/32
Operand2: reg8/16/32 | mem8/16/32 | Konstante
O S Z P C
OF und CF werden immer gelöscht!
Diese Funktion unterscheidet sich von AND nur dadurch, daß Operand1 nicht verändert wird.
TEST AL, 00000010b ; feststellen, ob im Register AL
; das Bit 1 gesetzt ist, dann ist ZF=0English: Compare
Deutsch: Vergleichen
Funktion Operand1 , Operand2
Operand1: reg8/16/32 | mem8/16/32
Operand2: reg8/16/32 | mem8/16/32 | Konstante
Operand2 wird von Operand1 subtrahiert, die Flags werden wie bei SUB gesetzt aber Operand 1 bleibt unverändert, d.h. das Ergebnis wird "weggeworfen". Die Auswertung der gesetzten Flags erfolgt meist durch einen direkt nachfolgenden bedingte Sprung-Funktion. CMP arbeitet für vorzeichenbehaftete und vorzeichenlose Zahlen korrekt. Es können nicht beide Operanden Speicheroperanden sein.
Siehe: SUB
;-------- Abbruch einer Zählschleife mit CMP
MOV CX, 0 ; AX = b
L1:
CALL Unterprog ; Schleifenrumpf
INC CX
CMP CX, 10 ; CX <?> 10
JNE L1 ; Wenn nicht, Schleife fortsetzenEnglish: Bit Search Forward | Bit Search Reverse
Deutsch: Bitsuche vorwärts | Bitsuche rückwärts
Funktion Operand1 , Operand2
Operand1: reg16/32
Operand2: reg16/32 | mem16/32
Durchsucht den ersten Operanden nach dem ersten auftretenden 1-Bit. BSF durchsucht vom niedrigstwertigen Bit (LSB) an, BSR beginnt beim höchstwertigen Bit (MSB). Die gefundene Bitposition wird im zweiten Operanden abgelegt.
English: Bit Test | Bit Test and Set | Bit Test and Reset | Bit Test and Complement
Deutsch: Bit Testen | Bit Testen und Setzen | Bit Testen und Löschen | Bit Testen und Invertieren
Funktion Operand1 , Operand2
Operand1: reg16/32 | mem16/32
Operand2: reg16/32 | Konstante
English: Push
Deutsch: Schieben
Funktion Quelle
Quelle: reg16/32 | mem16/32
Kopiert den Quelloperanden an die Spitze des Stack. Dazu wird zunächst SP um 2 bzw. 4 dekrementiert und dann der Kopiervorgang nach SS:SP ausgeführt. Weitere Erläuterungen.
Siehe: POP
English: Pop
Deutsch: Ziehen
Funktion Ziel
Ziel: reg16/32 | mem16/32
Kopiert den Wert an der Spitze des Stack in den Zieloperanden. Anschließend wird SP um 2 bzw. 4 erhöht. POP wird benutzt, um Werte vom Stack zurückzuholen, die mit PUSH dort abgelegt wurden. Die Hauptanwendung ist das Zwischenspeichern (Retten) von Registerinhalten. Die Funktionen PUSH und POP treten daher in der Regel paarweise auf, es wird dann SP automatisch korrekt verwaltet. Auf Speicheroperanden werden PUSH und POP seltener angewandt.
;--------
PUSH AX ; AX retten
PUSH BX ; BX retten
;
; arbeiten mit AX und BX
;
POP BX ; BX restaurieren
POP AX ; AX restaurieren
;--------
PUSH DS ; Datentransport mit PUSH und POP
POP ESEnglish: Jump
Deutsch: Springen
Funktion Ziel
Ziel: Sprunglabel | reg16 | mem16
Führt einen unbedingten Sprung zum angegebenen Sprunglabel (Marke) durch.
JMP Label1 ; unbedingter Sprung
...
... ; wird übersprungen
....
Label1:
MOV AX, 0FFhEnglish: Jump conditional
Deutsch: Springen wenn
Funktion Ziel
Ziel: label(short) Label im Bereich -128 bis +127 Byte
Führt einen bedingten Sprung zum angegebenen Sprunglabel (Marke) durch, die Sprungweite ist abhängig von den Segmentattributen und kann zB. auf -128 bis +127 Byte begrenzt (Short-Jump) sein. Für die Bedingung cc gibt es zahlreiche Möglichkeiten, die in der nachfolgenden Tabelle aufgeführt sind. Bsp.: cc=NGE ergibt die Sprung-Funktion JNGE d.h. "Jump if not greater or equal". Viele bedingte Sprung-Funktionen sind unter mehreren Mnemonics verfügbar, zB. ist JNGE identisch mit JL, "Jump if less". Durch entsprechende Interpretation der Flags wird zwischen Arithmetik mit und ohne Vorzeichen unterschieden. Die arithmetischen bedingten Sprung-Funktionen werden typischerweise nach einem CMP angeordnet. In diesem Fall ist das Sprungverhalten genau so, wie die Namen vermuten lassen.
Kürzel Erweiterung für cc, zB. in Jcc oder SETcc.
| Kürzel | Bit | Flag | Beschreibung |
|---|
| O | 0 | OF=1 | Overflow |
|---|
| NO | 1 | OF=0 | Not Overflow |
|---|
| C, B, NAE | 2 | CF=1 | Carry, Below, Not Above or Equal |
|---|
| NC, NB, AE | 3 | CF=0 | Not Carry, Not Below, Above or Equal |
|---|
| E, Z | 4 | ZF=1 | Equal, Zero |
|---|
| NE, NZ | 5 | ZF=0 | Not Equal, Not Zero |
|---|
| BE, NA | 6 | CF=1 or ZF=1 | Below or Equal, Not Above |
|---|
| NBE, A | 7 | CF=0 and ZF=0 | Not Below or Equal, Above |
|---|
| S | 8 | SF=1 | Signed |
|---|
| NS | 9 | SF=0 | Not Signed |
|---|
| P, PE | A | PF=1 | Parity, Parity Even |
|---|
| NP, PO | B | PF=0 | Not Parity, Parity Odd |
|---|
| L, NGE | C | SF <> OF | Less, Not Greater or Equal |
|---|
| GE, NL | D | SF = OF | Not Less, Greater or Equal |
|---|
| LE, NG | E | ZF=1 or (SF <> OF) | Less or Equal, Not Greater |
|---|
| G, NLE | F | ZF=0 and (SF = OF) | Not Less or Equal, Greater |
|---|
CMP AX, BX ; Vgl AX und BX
JG Label1 ; Sprung wenn AX>BX
...
... ; wird übersprungen
...
Label1:
MOV AX, 0FFhEnglish: Jump if CX Zero
Deutsch: Springen wenn CX=0
Funktion Ziel
Ziel: label (short)
Führt einen Sprung zum angegebenen Sprunglabel (Short-Jump) durch, wenn CX=0 ist. Diese Funktion ist in Verbindung mit den LOOPxx-Funktionen nützlich. Er kann benutzt werden, um zu erreichen, dass eine LOOPxx- Schleife übersprungen wird, wenn CX=0.
English: CALL
Deutsch: Aufrufen
Funktion Ziel
Ziel: Unterprogrammadresse
Legt zunächst die Adresse der nächstfolgenden Funktion auf den Stack (PUSH) und springt dann zu der angebenen Startadresse des gerufenen Unterprogramms. Das Programm wird also dort fortgesetzt. Wenn im Unterprogramm ein RET ausgeführt wird, wird die Rücksprungadresse vom Stack geholt und das Programm mit dem nächsten Funktion nach CALL fortgesetzt.
Siehe: RET
English: Return | Return NEAR | Return FAR
Deutsch: Zurückkehren | nah | fern
Funktion [Zahl]
[Zahl]: vorzeichenlose Konstante
Holt zunächst eine Adresse vom Stack (POP) und setzt die Programmausführung dort fort. Verwendung: Rückkehr aus einem Unterprogramm.
RETN holt ein Wort vom Stack und führt einen Near-Sprung aus, RETF holt zwei Worte vom Stack und führt einen Far-Sprung aus. Bei RET entscheidet der Assembler über die Art des Rücksprungs. Optional kann jede der drei Funktionsformen mit einer vorzeichenlosen Zahl als Argument versehen werden. Diese Zahl wird zu SP addiert, nachdem die Rücksprungadresse vom Stack geholt wurde.
Siehe: CALL
Kopfzeile DB 'Programm XY Version 0.9',13, 10,'$'
.CODE
CALL Printkopfzeile ; Unterprogrammaufruf
MOV AH, 22
;
Proc Printkopfzeile
MOV ah, 9 ; DOS Funktion ''print string''
MOV dx, OFFSET Kopfzeile ; Adresse von ''Kopfzeile''
INT 21h ; Zeile ausgeben
RET ; Rücksprung, Fortsetz. bei ''MOV AH, 22''
ENDP ; Ende des Codes der ProzedurEnglish: Interrupt
Deutsch: Systemaufruf
Funktion [N]
[N]: Nummer des Aufgerufenen Interrupthandlers
Ruft die zugehörige BIOS-Funktion auf und stellt so die Schnittstelle zum Betriebssystem dar. Erlaubte Nummern sind 0 . . . 255. Die weitere Spezifikation der gewünschten Funktion wird durch übergabe von Parametern in den Registern AH, AL etc. vorgenommen. Die größte Gruppe ist INT 21h (DOS-Funktionsaufruf).
Kopfzeile DB 'Hallo Assemblerwelt!',13, 10,'$'
MOV AH, 9 ; DOS Funktion ''print string''
MOV DX, OFFSET Kopfzeile ; Adresse von ''Kopfzeile''
INT 21h ; Zeile ausgebenAlle StringFunktionen (MOVS, LODS, STOS, CMPS, SCAS) haben folgende Gemeinsamkeiten:
* Die Adressierung erfolgt immer über die Registerpaare DS:SI und | oder ES:DI.
* Die beteiligten Indexregister DI und | oder SI werden nach der Ausführung der Funktion automatisch verändert. Diese Veränderung hängt von der Bitbreite der Funktion und der Stellung von DF ab:
DF=0 DF=1
Byteoperation +1 -1
Wortoperation +2 -2
Doppelwortoperation +4 -4
* Für die String-Funktionen gibt es eine Funktionsform, aus der nicht ersichtlich ist, ob ein Byte- oder Wort-Funktion ausgeführt werden soll, zB. MOVS statt MOVSB, MOVSW oder MOVSD . In dieser Form müssen Operanden angegeben werden, die aber nicht adressiert werden, sondern nur die Bitbreite anzeigen.
* Die StringFunktionen können mit den Wiederholungspräfixen REP, REPE, REPNE versehen werden, so daß Schleifen in einer Codezeile programmiert werden können.
English: Move String Byte | Word | Doubleword
Deutsch: Stringtransport Byte | Wort | Doppelwort
Kopiert ein Byte | Wort | Doppelwort von DS:SI nach ES:DI.
.DATA
titel DB 'Beispiele zum Assemblerskript',0dh, 0ah,'$'
string DB 50 DUP(?)
bvar1 DB 0
bvar2 DB 0FFh
.CODE
MOV AX, DS ; Quelle und Ziel liegen
MOV ES, AX ; im gleichen Segment
MOV SI, offset titel ; Source index = Quellzeiger
MOV DI, offset string ; Destination index = Zielzeiger
MOV CL, 32 ; Anzahl
CLD ; DF = 0, -> Inkrement
L1:
MOVSB ; move string byte
DEC CL ; Dekrement Zaehler
JNZ L1 ; Schleife wenn cl != 0
MOV AH, 9 ; DOS print string function
MOV DX, OFFSET string ; Adresse von ''string''
INT 21h ; Ueberschrift ausgeben
;--------
MOVS bvar1, bvar2 ; irrefuehrend, BVAR1 und BVAR2
; sind nicht Ziel und Quelle!!English: Load String Byte | Word | Doubleword
Deutsch: Laden String Byte | Wort | Doppelwort
LODSB Kopiert ein
Byte DS:SI nach AL.
LODSW Kopiert ein Wort
DS:SI nach AX .
LODSD Kopiert ein Doppelwort
DS:SI nach
EAX.
.DATA
titel DB 'Beispiele zum Assemblerskript',0dh, 0ah,'$'
.CODE
MOV SI, offset titel ; Source index = Quellzeiger
; ''titel'' liegt im Datensegment,
; DS:SI zeigt jetzt auf ''titel''
CLD ; DF = 0, -> Inkrement
LODSB ; load string byte
; -> AL='B'English: Store String Byte | Word | Doubleword
Deutsch: Speichern String Byte | Wort | Doppelwort
STOSB Speichert das
Byte in AL nach
ES:DI.
STOSW Speichert das Wort in AX nach
ES:DI.
STOSD Speichert das Doppelwort in
EAX nach
ES:DI.
.DATA
Spruch DB 'Dreizeitbeschäftigung',0dh, 0ah,'$'
.CODE
MOV AX, DS ; ES:DI muß auf Ziel zeigen
MOV ES, AX
MOV DI, offset Spruch ; Source index = Quellzeiger
CLD ; DF = 0, -> Inkrement
MOV AL,'F'
STOSB ; store string byte
; -> 'Freizeit'English: Compare String Byte | Word | Doubleword
Deutsch: Vergleichen String Byte | Wort | Doppelwort
CMPSB Vergleicht das
Byte an
DS:SI mit dem an
ES:DI und setzt die
Flags wie bei CMP.
CMPSB Vergleicht das Wort an
DS:SI mit dem an
ES:DI und setzt die
Flags wie bei CMP.
CMPSB Vergleicht das Doppelwort an
DS:SI mit dem an
ES:DI und setzt die
Flags wie bei CMP.
English: Scan String Byte | Word | Doubleword
Deutsch: Suchen String Byte | Wort | Doppelwort
Vergleicht das Byte | Wort | Doppelwort in AL | AX | EAX mit dem an ES:DI und setzt die Flags wie bei CMP.
English: Repeat
Deutsch: Wiederholen
Funktion Stringfunktion
Stringfunktion: MOVS | STOS
REP ist keine eigenständige Funktion sondern ein Wiederholungspräfix und muß vor einer Stringfunktion stehen. Sinnvoll sind nur MOVS und STOS. REP bewirkt, daß nach jeder Ausführung der nachstehenden Stringfunktion CX dekrementiert und, falls CX=0, die Stringfunktion erneut ausgeführt wird. Auf diese Art läßt sich in einer Zeile eine bis zu 0FFFFh mal ausgeführte Zählschleife programmieren.
Siehe: REPNE, SCAS, CMPS.
;-------- direktes Schreiben in den Bildschirmspeicher
MOV AX, 0B800h ; Segmentadresse des
MOV ES, AX ; Bildschirmspeichers nach ES
MOV DI, 0 ; DI=0 -> linke obere Ecke
MOV AL,'O' ; Zeichen
MOV AH, 49h ; Attribut
MOV CX, 80 ; Anzahl 80
CLD ; DF=0, steigende Adressen
REP STOSW ; repeat store string word (Schleife)English: Repeat while equal | not equal
Deutsch: Wiederholen solange gleich | ungleich
Funktion Stringfunktion
Stringfunktion: SCAS | CMPS
REPE | REPNE(identisch sind REPZ | REPNZ) sind keine eigenständige Funktionen sondern Wiederholungspräfixe und müssen vor einem der StringFunktionen SCAS oder CMPS stehen. REPE | REPNE bewirkt, daß nach jeder Ausführung der nachstehenden Stringfunktion CX dekrementiert und, falls CX=0, die Stringfunktion erneut ausgeführt wird. Man hat also eine Zählschleife, wie bei REP. Hier existiert aber ein zweites Abbruchkriterium, nämlich die Gleichheit/Ungleichheit der Operanden:
* REPE-Schleifen werden bei Ungleichheit der Operanden abgebrochen, d.h. wenn ZF=0.
* REPNE-Schleifen werden bei Gleichheit der Operanden abgebrochen, d.h. wenn ZF=1.
Siehe: REP, SCAS, CMPS.
;-------- Aufsuchen eines Zeichens 'A' mit Attribut 07h im Bildschirmspeicher
MOV AX, 0B800h ; Segmentadresse des
MOV ES, AX ; Bildschirmspeichers nach ES
MOV DI, 0 ; DI=0 -> linke obere Ecke
MOV AL,'A' ; Zeichen
MOV AH, 07h ; Attribut
MOV CX, 2000 ; 25*80 = 2000 Worte
CLD ; DF=0, steigende Adressen
REPNE SCASW ; repeat scan string word (Schleife)English: Input from Port
Deutsch: Eingabe von Port
Funktion Ziel , I/O-Adresse
Ziel: AL | AX | EAX
I/O-Adresse: Konstante | DX
Diese Funktion dient zur Eingabe von Daten über I/O-Ports. Eine unmittelbare Adressierung des Ports ist möglich, wenn die Adresse kleiner als 100H ist.
Siehe: OUT
;--------
IN al, 20h ; ISR des 8259A auslesen
;--------
MOV DX, 3F8h
IN AL, DX ; Empfängerpufferregister von COM1 lesenEnglish: Output from Port
Deutsch: Ausgabe von Port
Funktion I/O-Adresse , Quelle
I/O-Adresse: Konstante | DX
Quelle: AL | AX | EAX
Diese Funktion dient zur Ausgabe von Daten über I/O-Ports. Eine unmittelbare Adressierung des Ports ist möglich, wenn die Adresse kleiner als 100H ist.
Siehe: IN
;--------
OUT 20h, 66h ; OCW über Port 20h
; an Interruptcontroller senden
;--------
MOV DX, 3F9h ; Interrupt Enable Register
IN AL, DX ; von COM1 lesen
OR AL, 03h ; Bits zur Interruptaktivierung setzen
OUT DX, AL ; zurückschreiben ins RegisterEnglish: Loop
Deutsch: Schleife
Funktion label (short)
label (short): Label im Bereich -128 bis +127 Byte
Dekrementiert ECX/CX und springt zur angegebenen Marke, falls ECX/CX=0. Die Funktion dient der einfachen Konstruktion von Schleifen und ersetzt die Funktionsfolge DEC ECX ; JNZ Sprungmarke LOOPE, LOOPNE, LOOPZ, LOOPNZ, JCXZ
;-------- Warteschleife mit NOP-Funktionen (=No Operation) Procedure Warten
; Parameter: ECX = Anzahl der Warteschleifen
; Rückgabe: keine
JCXZ L2 ; Prozedur verlassen wenn CX=0
L1:
NOP
LOOP L1 ; Warteschleife
L2:
returnEnglish: Loope while equal Zero ECX | Zero Flag
Deutsch: Schleife solange gleich Null ECX | Null Flag
Funktion label (short)
label (short): Label im Bereich -128 bis +127 Byte
Dekrementiert ECX und springt zur angegebenen Marke, falls...
Die Funktion dient der einfachen Konstruktion von Schleifen mit zwei Abbruchkriterien.
Siehe: LOOP, LOOPNE, LOOPNZ
English: Loope while equal not Zero ECX | not Zero Flag
Deutsch: Schleife solange gleich nicht Null ECX | nicht Null Flag
Funktion label (short)
label (short): Label im Bereich -128 bis +127 Byte
Dekrementiert ECX und springt zur angegebenen Marke, falls...
Die Funktion dient der einfachen Konstruktion von Schleifen mit zwei Abbruchkriterien.
Siehe: LOOP, LOOPNE, LOOPNZ
;-------- Suche nach einem Punkt in einem Dateinamen
; Abbruch wenn Punkt gefunden oder 8 Zeichen untersucht
; DI zeigt auf Dateinamen
MOV CX, 8
L1:
CMP [DI],'.' ; Zeichen <?> '.'
INC DI ; Zeiger weiterruecken
LOOPNE L1 ; Schleife
L2:
returnEnglish: Clear | Set Directionflag
Deutsch: Löschen | Setzen Richtungsflag
Diese Funktionen dienen zur direkten Manipulation des Directionflags (Richtungsflag), und werden benutzt um Stringoperationen vorzubereiten.
* CLD : löscht das Directionflag, DF=0 --> Autoinkrement bei Stringoperationen
* STD : setzt das Directionflag, DF=1 --> Autodekrement bei Stringoperationen
English: Clear | Set Interruptflag
Deutsch: Löschen | Setzen Unterbrechungsflag
Diese Funktionen dienen zur direkten Manipulation des Interruptflags (Unterbrechungsflag). Bei gesetztem Interruptflag sind externe Interrupts zugelassen, sonst nur NMI.
* CLI : löscht das Interruptflag, IF=0
* STI : setzt das Interruptflag, IF=1
;-------- Interruptvektor Timerinterrupt neu setzen
CLI ; Interrupts während Manipulation an
; Interrupt Vektoren Tabelle sperren
; Besser: DOS-Funktion 25h benutzen!
MOV [32],DX
MOV AX, CS
MOV [34],AX
STI ; Interrupts wieder zulassenEnglish: Clear | Set | Complement Carry
Deutsch: Löschen | Setzen | Komplementieren des Carryflags
Diese Funktionen dienen zur direkten Manipulation des Carryflags.
* CLC : löscht das Carryflag, CF=0
* STC : setzt das Carryflag, CF=1
* CMC : komplementiert das Carryflag, CF=1-CF
fehler:
STC ; Fehlerfall, Rückgabe der Information im Carry
RET
ok:
CLC ; kein Fehler
RET
