Assembler-Programmierung für x86-Prozessoren/ Befehlsreferenz

Aus Wikibooks
Zur Navigation springen Zur Suche springen


Nuvola apps bookcase.svg Assembler-Programmierung für x86-Prozessoren


Dieses Kapitel beschreibt die Assembler-Syntax in der Intelschreibweise.

Die Syntaxbeschreibungen bestehen jeweils aus drei Teilen: Dem Opcode in hexadezimal, der eigentlichen Syntax und dem Prozessor, seit dem der Befehl existiert. Der Opcode-Aufbau soll in Zukunft in einem eigenen Kapitel beschrieben werden. Die Syntax hat die folgenden Bedeutungen:

  • r8: Eines der folgenden 8-Bit-Register kann verwendet werden: AH, AL, BH, BL, CH, CL, DH oder DL
  • r16: Eines der folgenden 16-Bit-Register kann verwendet werden: AX, BX, CX oder DX; BP, SP, DI oder SI
  • r32: Eines der folgenden 32-Bit-Register kann verwendet werden: EAX, EBX, ECX oder EDX; EBP, ESP, EDI oder ESI
  • imm8: Ein Bytewert zwischen –128 bis +127
  • imm16: Ein Wortwert zwischen –32.768 bis +32.767
  • r/m8: Der Wert kann entweder ein allgemeines 8-Bit-Register (AH, AL, BH, BL, CH, CL, DH oder DL) oder ein Bytewert aus dem Arbeitsspeicher sein
  • r/m16: Der Wert kann entweder ein allgemeines 16-Bit-Register (AX, BX, CX oder DX; BP, SP, DI oder SI) oder ein Bytewert aus dem Arbeitsspeicher sein
  • SReg: Segmentregister


Der Aufbau des Opcodes hat die folgende Bedeutung:

  • ib: Operation bezieht sich auf 8 Bit Daten. (byte)
  • iw: Operation bezieht sich auf 16 Bit Daten. (word)
  • id: Operation bezieht sich auf 32 Bit Daten. (double word)
  • /0 bis /7, /r, r+b, r+w, r+d: Interne Information zum Aufbau des Maschinenbefehls


Wenn nicht explizit etwas anderes angegeben ist, haben die Flags die folgende Bedeutung:

  • OF – Overflow Flag / Überlauf
  • SF – Sign Flag / Vorzeichen
  • ZF – Zero Flag / Ist 1 falls das Resultat 0 ist, sonst 0
  • AF – Auxiliary Flag / Hilfs-Übertragsflag bei Übertrag von Bit 3 auf 4. Dies macht nur Sinn bei BCD-Zahlen
  • PF – Parity Flag / Paritätsflag
  • CF – Carry Flag / Übertrag


ADD (Add)[Bearbeiten]

ADD addiert zu einem Speicherbereich oder einem Register einen festen Wert oder den Wert eines Registers.

04 ib       add AL, imm8       8086+
05 iw       add AX, imm16      8086+
80 /0 ib    add r/m8, imm8     8086+
81 /0 iw    add r/m16, imm16   8086+
83 /0 ib    add r/m16, imm8    8086+
00 /r       add r/m8, r8       8086+
01 /r       add r/m16, r16     8086+
02 /r       add r8, r/m8       8086+
03 /r       add r16, r/m16     8086+
05 id       add eax,imm32      80386+
81 /0 id    add r/m32, imm32   80386+
83 /0 ib    add r/m32, imm8    80386+
01 /r       add r/m32, r32     80386+
03 /r       add r32, r/m32     80386+

Flags:

  • OF, SF, ZF, AF, CF, PF

Beispiel:

ADD eax,10
ADD eax,ebx

ADC (Add with carry)[Bearbeiten]

ADC addiert zu einem Speicherbereich oder einem Register einen festen Wert sowie das Carry-Flag oder den Wert eines Registers.

14 ib       adc AL, imm8       8086+
15 iw       adc AX, imm16      8086+
80 /2 ib    adc r/m8, imm8     8086+
81 /2 iw    adc r/m16, imm16   8086+
83 /2 ib    adc r/m16, imm8    8086+
10 /r       adc r/m8, r8       8086+
11 /r       adc r/m16, r16     8086+
12 /r       adc r8, r/m8       8086+
13 /r       adc r16, r/m16     8086+
15 id       adc EAX,imm32      80386+
83 /2 ib    adc r/m32, imm8    80386+
11 /r       add r/m32, r32     80386+
13 /r       add r32, r/m32     80386+

Flags:

  • OF, SF, ZF, AF, CF, PF

AND[Bearbeiten]

Verknüpft die Operanden durch ein logisches AND.

24 ib       and AL, imm8       8086+
25 iw       and AX, imm16      8086+
80 /4 ib    and r/m8, imm8     8086+
81 /4 iw    and r/m16, imm16   8086+
83 /4 ib    and r/m16, imm8    8086+
20 /r       and r/m8, r8       8086+
21 /r       and r/m16, r16     8086+
22 /r       and r8, r/m8       8086+
23 /r       and r16, r/m16     8086+
25 id       and EAX, imm32     80386+
81 /4 id    and r/m32, imm32   80386+
21 /r       and r/m32, r32     80386+
83 /4 ib    and r/m32, imm8    80386+
23 /r       add r32, r/m32     80386+

Flags:

  • OF und CF werden gelöscht
  • SF, ZF und PF
  • AF ist undefiniert

CLC (Clear Carry Flag)[Bearbeiten]

Löscht das Carry-Flag.

F8          clc                 8086+

Flags:

  • CF wird gelöscht

CLI (Clear Interrupt Flag)[Bearbeiten]

Löscht das Interrupt-Flag. Die CPU bearbeitet keine Interrupt-Requests (Hardware-Interrupts) mehr.

FA          cli                 8086+

Flags:

  • IF wird gelöscht

CMC (Complement Carry Flag)[Bearbeiten]

Dreht den Wahrheitswert des Carry-Flags um.

F4          cmc                 8086+

Flags:

  • CF -Wert wird invertiert; [ 0==>1 | 1==>0 ]

DEC (Decrement)[Bearbeiten]

Subtrahiert 1 vom Zieloperanden.

FE /1       dec r/m8            8086+
FF /1       dec r/m16           8086+
48 r+w      dec r16             8086+
FF /1       dec r/m32           80386+
48 r+w      dec r32             80386+

Flags:

  • OF, SF, ZF, AF, PF
  • Das Carry-Flag wird nicht beeinflust

Beispiel:

DEC eax
DEC [eax]

DIV (Unsigned Divide)[Bearbeiten]

Dividiert das AX-, DX:AX- oder EDX:EAX-Register durch den Quelloperanden und speichert das Ergebnis im AX-, DX:AX- oder EDX:EAX-Register.

F6 /6       div r/m8           8086+
F7 /6       div r/m16          8086+
F7 /6       div r/m32          80386+

Flags:

  • CF, OF, SF, ZF, AF und PF sind undefiniert

IMUL (Signed Multiply)[Bearbeiten]

Multipliziert eine vorzeichenbehaftete Zahl.

F6 /5      imul r/m8               8086+
F7 /5      imul r/m16              8086+
F7 /5      imul r/m32              80386+
0F AF /r   imul r16, r/m16         80386+
0F AF /r   imul r32, r/m32         80386+
6B /r ib   imul r16, r/m16, imm8   80186+
6B /r ib   imul r32, r/m32, imm8   80386+
6B /r ib   imul r16, imm8          80186+
6B /r ib   imul r32, imm8          80386+
69 /r iw   imul r16, r/m16, imm16  80186+
69 /r id   imul r32, r/m32, imm32  80386+
69 /r iw   imul r16, imm16         80186+
69 /r id   imul r32, imm32         80386+

Flags:

  • Wenn imul nur einen Operanden hat, ist das Carry-Flag und das Overflow-Flag gesetzt, wenn ein Übertrag in die höherwertige Hälfte des Ergebnisses stattfindet. Passt das Ergebnis exakt in die untere Hälfte des Ergebnisses werden Carry- und Overflow-Flag gelöscht. Hat imul zwei oder drei Operanden, wird das Carry- und Overflow-Flag zu groß für den Zieloperanden, andernfalls wird es gelöscht
  • SF, ZF, AF und PF sind undefiniert

INC (Increment)[Bearbeiten]

Addiert 1 zum Zieloperanden.

FE /0        inc r/m8        8086+
FF /0        inc r/m16       8086+
40 r+w       inc r16         8086+
FF /6        inc r/m32       80386+
40 r+d       inc r32         80386+

Flags:

  • OF, SF, ZF, AF, PF
  • Das Carry-Flag wird nicht beeinflusst

Beispiel:

INC eax
INC [eax]

INT (Interrupt)[Bearbeiten]

INT löst einen Software-Interrupt aus. Dies ist vergleichbar mit dem Aufruf eines Unterprogramms (hier ein Interrupt-Handler). Über die allgemeinen CPU-Register können dem Interrupt-Handler Werte übergeben werden. Der Interrupt-Handler kann über diese Register auch Werte zurückliefern. Nach INT steht eine Interrupt-Nummer, die zwischen 00h und FFh liegt. Über diese kann man die Lage der Einsprungadresse für den entsprechenden Interrupt-Handler in der Interrupt-Vektor-Tabelle ermitteln. Der Interrupt-Befehl 3 dient beispielsweise als Haltepunkt beim Debuggen eines Programms. Dieser ist daher auch als Ein-Byte-Befehl zusätzlich vorhanden.

CC           int3            8086+
CD           int imm8        8086+

Flags:
(keine)

Beispiel:

MOV ah,4Ch;  Der Wert 4Ch (= Beenden des Programms) wird dem Interrupt-Handler übergeben  
INT 21h;     Der Interrupt-Handler wird aufgerufen. Die Interrupt-Nummer ist 21h (MS-DOS).

IRET (Interrupt Return)[Bearbeiten]

Rückkehr aus dem Interrupt-Handler, welcher mit INT aufgerufen wurde. Dieser Befehl ist vergleichbar mit RET, jedoch werden hier die Flags restauriert.

CF           iret            8086+

Flags:
Alle Flag-Werte werden auf den Zustand vor dem Interrupt zurückgesetzt.

MOV (Move)[Bearbeiten]

Mit dem MOV Befehl wird der zweite Operand in den ersten Operanden kopiert.

88 /r       mov r/m8, r8       8086+
89 /r       mov r/m16, r16     8086+
8A /r       mov r8, r/m8       8086+
8B /r       mov r16, r/m16     8086+
C6 /0       mov r/m8, imm8     8086+
C7 /0       mov r/m16, imm16   8086+
8C /r       mov r/m16, SReg    8086+
8E /r       mov SReg, r/m16    8086+
A0          mov al, moffs8     8086+
A1          mov ax, moffs16    8086+
A2          mov moffs8, al     8086+
A3          mov moffs16, ax    8086+

Flags:
(keine)

Beispiel:

mov eax,10
mov eax,ebx

MUL (unsigned Multiplication)[Bearbeiten]

Multipliziert den Zieloperanden mit dem AL-, AX- oder EAX-Register. Das Ergebnis wird im AX-, DX:AX- oder EDX:EAX-Register abgelegt (abhängig von der Größe des Zieloperanden). Der höherwertige Anteil des Ergebnisses befindet sich im AH-, DX- bzw. EDX-Register.

F6 /4       mul r/m8           8086+
F7 /4       mul r/m16          8086+
F7 /4       mul r/m32          80386+

Flags:

  • OF und CF werden auf 0 gesetzt wenn der höherwertige Anteil des Ergebnisses 0 ist

NEG (Two’s Complement Negation)[Bearbeiten]

Bildet das Zweierkomplement indem der Operand von 0 abgezogen wird.

F6/3        neg r/m8            8086+
F7/3        neg r/m16           8086+
F7/3        neg r/m32           80386+

Flags:

  • OF, SF, ZF, AF und PF
  • Setzt das Carry-Flag auf 0, wenn das Ergebnis 0 ist, andernfalls wird es auf 1 gesetzt.

NOP (No Operation)[Bearbeiten]

Führt keine Aktion aus.

90         nop                 8086+

(Der Opcode entspricht xchg ax,ax bzw. xchg eax,eax.)

Flags:
(keine)

NOT[Bearbeiten]

Dreht den Wahrheitswert der Bits um. Entspricht dem Einerkomplement.

F6 /2       not r/m8          8086+
F7 /2       not r/m16         8086+
F7 /2       not r/m32         80386+

Flags:
(keine)

OR[Bearbeiten]

Verknüpft die Operanden durch ein logisches ODER.

0C ib       or AL, imm8       8086+
0D iw       or AX, imm16      8086+
80 /1 ib    or r/m8, imm8     8086+
81 /1 iw    or r/m16, imm16   8086+
83 /1 ib    or r/m16, imm8    8086+
08 /r       or r/m8, r8       8086+
09 /r       or r/m16, r16     8086+
0A /r       or r8, r/m8       8086+
0B /r       or r16, r/m16     8086+
0D id       or EAX, imm32     80386+
81 /1 id    or r/m32, imm32   80386+
09 /r       or r/m32, r32     80386+
83 /1 ib    or r/m32, imm8    80386+
0B /r       or r32, r/m32     80386+

Flags:

  • OF und CF werden gelöscht
  • SF, ZF und PF
  • AF ist undefiniert

SBB (Subtraction with Borrow)[Bearbeiten]

SBB subtrahiert von einem Speicherbereich oder einem Register den Wert eines Speicherbereichs oder eines Registers und berücksichtigt dabei das Carry-Flag.

1C ib       sbb AL, imm8       8086+
1D iw       sbb AX, imm16      8086+
80 /3 ib    sbb r/m8, imm8     8086+
81 /3 iw    sbb r/m16, imm16   8086+
83 /3 ib    sbb r/m16, imm8    8086+
18 /r       sbb r/m8, r8       8086+
19 /r       sbb r/m16, r16     8086+
1A /r       sbb r8, r/m8       8086+
1B /r       sbb r16, r/m16     8086+
1D id       sbb EAX, imm32     80386+
81 /3 id    sbb r/m32, imm32   80386+
83 /3 ib    sbb r/m32, imm8    80386+
19 /r       sbb r/m32, r32     80386+
1B /r       sbb r32, r/m32     80386+

Flags:

  • OF, SF, ZF, AF, PF, CF

SHL (Shift Left)[Bearbeiten]

Verschiebt alle Bits im Register um x Stellen nach links. Mathematisch wird der Wert im Register zum Beispiel beim Verschieben um eine Stelle mit 2 multipliziert. Beim Multiplizieren mit 2, 4 und so weiter sollte statt MUL besser dieser Befehl eingesetzt werden, da er von der CPU schneller abgearbeitet wird.

shl r8,x                    8086+
shl r16,x                   8086+
shl r32,x                  80386+

Flags:

  • CF

Beispiel:

 mov al,00000001b (al = 00000001b)
 shl al,1         (al = 00000010b)

SHR (Shift Right)[Bearbeiten]

Verschiebt alle Bits im Register um x Stellen nach rechts. Mathematisch wird der Wert im Register zum Beispiel beim Verschieben um eine Stelle durch 2 dividiert.

shr r8,x                    8086+
shr r16,x                   8086+
shr r32,x                  80386+

Flags:

  • ZF?

Beispiel:

 mov al,00000010b (al = 00000010b)
 shr al,1         (al = 00000001b)

STC (Set Carry Flag)[Bearbeiten]

Setzt das Carry-Flag.

F9          stc                8086+

Flags:

  • CF

STI (Set Interrupt Flag)[Bearbeiten]

Setzt das Interrupt-Flag.

FB          sti                8086+

Flags:

  • IF

SUB (Subtract)[Bearbeiten]

SUB subtrahiert von einem Speicherbereich oder einem Register den Wert eines Speicherbereichs oder eines Registers.

2C ib       sub AL, imm8       8086+
2D iw       sub AX, imm16      8086+
80 /5 ib    sub r/m8, imm8     8086+
81 /5 iw    sub r/m16, imm16   8086+
83 /5 ib    sub r/m16, imm8    8086+
28 /r       sub r/m8, r8       8086+
29 /r       sub r/m16, r16     8086+
2A /r       sub r8, r/m8       8086+
2B /r       sub r16, r/m16     8086+
2D id       sub EAX, imm32     80386+
81 /5 id    sub r/m32, imm32   80386+
83 /5 ib    sub r/m32, imm8    80386+
29 /r       sub r/m32, r32     80386+
2B /r       sub r32, r/m32     80386+

Flags:

  • OF, SF, ZF, AF, PF, CF

Beispiel:

SUB eax,10
SUB eax,ebx

XCHG (Exchange)[Bearbeiten]

Der erste und zweite Operand wird vertauscht.

90+rw       xchg ax, r16       8086+
90+rw       xchg r16, ax       8086+
86 /r       xchg r/m8, r8      8086+
86 /r       xchg r8, r/m8      8086+
87 /r       xchg r/m16, r16    8086+
87 /r       xchg r16, r/m16    8086+

Flags:
(keine)

XOR[Bearbeiten]

Verknüpft die Operanden durch ein logisches exklusives Oder (Antivalenz).

34 ib       xor AL, imm8       8086+
35 iw       xor AX, imm16      8086+
80 /6 ib    xor r/m8, imm8     8086+
81 /6 iw    xor r/m16, imm16   8086+
83 /6 ib    xor r/m16, imm8    8086+
30 /r       xor r/m8, r8       8086+
31 /r       xor r/m16, r16     8086+
32 /r       xor r8, r/m8       8086+
33 /r       xor r16, r/m16     8086+
35 id       xor EAX, imm32     80386+
81 /6 id    xor r/m32, imm32   80386+
31 /r       xor r/m32, r32     80386+
83 /6 ib    xor r/m32, imm8    80386+
33 /r       xor r32, r/m32     80386+

Flags:

  • OF und CF werden gelöscht
  • SF, ZF und PF
  • AF ist undefiniert


| One wikibook.svg Hoch zu Assembler-Programmierung für x86-Prozessoren |