Tabele Kodowania Rozkazów x86 (16-bit AT&T)

Rozpoznawanie formatu rozkazu na podstawie pierwszych bitów bajtu 1

Analiza rozkazu x86 (16-bitowa składnia AT&T) rozpoczyna się od weryfikacji początkowych bitów pierwszego bajtu, co determinuje format rozkazu oraz jego długość:

• Rozkazy 1-bajtowe z rejestrem:
  • $01000xxx$: INC rejestr (np. $inc \, \%BX$), długość: $1$ bajt.
  • $01001xxx$: DEC rejestr (np. $dec \, \%CX$), długość: $1$ bajt.
  • $01010xxx$: PUSH rejestr (np. $push \, \%DX$), długość: $1$ bajt.
  • $01011xxx$: POP rejestr (np. $pop \, \%AX$), długość: $1$ bajt.
• Rozkazy 1-bajtowe bez operandu:
  • $10010000$: NOP (No Operation), długość: $1$ bajt.
  • $11000011$: RET (Return), długość: $1$ bajt.
  • $11111000$: CLC (Clear Carry Flag), długość: $1$ bajt.
• Rozkazy 2-bajtowe (typu rejestr-rejestr):
  • $000000 DW$: ADD (np. $add \, \%BX, \%CX$), długość: $2$ bajty.
  • $001010 DW$: SUB (np. $sub \, \%DX, \%BX$), długość: $2$ bajty.
  • $000010 DW$: OR (np. $or \, \%CX, \%DX$), długość: $2$ bajty.
  • $001000 DW$: AND (np. $and \, \%AX, \%BX$), długość: $2$ bajty.
  • $001100 DW$: XOR (np. $xor \, \%BX, \%CX$), długość: $2$ bajty.
  • $001110 DW$: CMP (np. $cmp \, \%AX, \%BX$), długość: $2$ bajty.
  • $100010 DW$: MOV (np. $mov \, \%CX, \%DX$), długość: $2$ bajty.
  • $100001 DW$: XCHG (np. $xchg \, \%BX, \%CX$), długość: $2$ bajty.
• Rozkazy rozszerzone:
  • $1111111 W$: Rozszerzony INC/DEC pamięci, długość: $2$ do $4$ bajtów (np. $inc \, 0x20(\%BX)$).
  • $1111011 W$: Rozszerzone operacje MUL, DIV, NEG, NOT, długość: $2$ lub więcej bajtów (np. $mul \, \%BX$).
  • $100000 SW$: Operacje z operandem natychmiastowym, długość: $3$ do $6$ bajtów (np. $add \, \$5, \%BX$).

Kody rejestrów w polach REG i R/M

Kodowanie rejestrów zależy od wartości bitu szerokości $W$ oraz kontekstu pola (REG lub R/M przy $mod=11$).

• Tabela kodowania rejestrów (8-bit i 16-bit):

  • $000$: $W=1 \rightarrow AX; W=0 \rightarrow AL$
  • $001$: $W=1 \rightarrow CX; W=0 \rightarrow CL$
  • $010$: $W=1 \rightarrow DX; W=0 \rightarrow DL$
  • $011$: $W=1 \rightarrow BX; W=0 \rightarrow BL$
  • $100$: $W=1 \rightarrow SP; W=0 \rightarrow AH$
  • $101$: $W=1 \rightarrow BP; W=0 \rightarrow CH$
  • $110$: $W=1 \rightarrow SI; W=0 \rightarrow DH$
  • $111$: $W=1 \rightarrow DI; W=0 \rightarrow BH$

• Kody rejestrów dla 1-bajtowych wersji INC/DEC/PUSH/POP (tylko 16-bit):

  • $000$: $AX$
  • $001$: $CX$
  • $010$: $DX$
  • $011$: $BX$
  • $100$: $SP$
  • $101$: $BP$
  • $110$: $SI$
  • $111$: $DI$

Tryby adresowania pamięci (Pole MOD i R/M)

Jeśli pole $MOD \neq 11$, połączenie $MOD$ oraz $R/M$ określa tryb adresowania pamięci zamiast bezpośredniego wyboru rejestru.

• Kombinacje pola R/M dla poszczególnych wartości MOD:
  • $000$:
    • $mod=00 \rightarrow [BX+SI]$
    • $mod=01 \rightarrow [BX+SI+disp8]$
    • $mod=10 \rightarrow [BX+SI+disp16]$
  • $001$:
    • $mod=00 \rightarrow [BX+DI]$
    • $mod=01 \rightarrow [BX+DI+disp8]$
    • $mod=10 \rightarrow [BX+DI+disp16]$
  • $010$:
    • $mod=00 \rightarrow [BP+SI]$
    • $mod=01 \rightarrow [BP+SI+disp8]$
    • $mod=10 \rightarrow [BP+SI+disp16]$
  • $011$:
    • $mod=00 \rightarrow [BP+DI]$
    • $mod=01 \rightarrow [BP+DI+disp8]$
    • $mod=10 \rightarrow [BP+DI+disp16]$
  • $100$:
    • $mod=00 \rightarrow [SI]$
    • $mod=01 \rightarrow [SI+disp8]$
    • $mod=10 \rightarrow [SI+disp16]$
  • $101$:
    • $mod=00 \rightarrow [DI]$
    • $mod=01 \rightarrow [DI+disp8]$
    • $mod=10 \rightarrow [DI+disp16]$
  • $110$:
    • $mod=00 \rightarrow disp16$ (Adres bezpośredni - przypadek specjalny, brak rejestru bazowego)
    • $mod=01 \rightarrow [BP+disp8]$
    • $mod=10 \rightarrow [BP+disp16]$
  • $111$:
    • $mod=00 \rightarrow [BX]$
    • $mod=01 \rightarrow [BX+disp8]$
    • $mod=10 \rightarrow [BX+disp16]$
  • Adresowanie rejestrowe ($mod=11$): Rejestr wskazany przez $R/M$ (według tabeli rejestrów dla $W=0$ lub $W=1$).

Rozszerzone kody operacji w bajcie 2 (Pole OP)

W niektórych formatach (np. gdy bajt 1 kończy się prefiksem rozszerzenia), 3-bitowe pole REG w drugim bajcie służy jako rozszerzenie kodu operacji (pole op).

• Dla bajtu 1 = $1111111x$ (INC/DEC/CALL/JMP/PUSH memoriałowe):

  • $000$: INC
  • $001$: DEC
  • $010$: CALL (pośredni)
  • $011$: CALL (daleki)
  • $100$: JMP (pośredni)
  • $101$: JMP (daleki)
  • $110$: PUSH
  • $111$: Rezerwacja

• Dla bajtu 1 = $1111011x$ (Operacje arytmetyczne i logiczne):

  • $000$: TEST (z operandem natychmiastowym)
  • $001$: Rezerwacja
  • $010$: NOT
  • $011$: NEG
  • $100$: MUL (bez znaku)
  • $101$: IMUL (ze znakiem)
  • $110$: DIV (bez znaku)
  • $111$: IDIV (ze znakiem)

• Dla bajtu 1 = $100000xx$ (Operacje z operandem natychmiastowym):

  • $000$: ADD
  • $001$: OR
  • $010$: ADC
  • $011$: SBB
  • $100$: AND
  • $101$: SUB
  • $110$: XOR
  • $111$: CMP

Znaczenie pól bitowych D, W oraz S

• Bit W (Width):
  • $W=0$: Operandy 8-bitowe (np. $AL, BL, CL, DL, AH, BH, CH, DH$).
  • $W=1$: Operandy 16-bitowe (np. $AX, BX, CX, DX, SP, BP, SI, DI$).
• Bit D (Direction):
  • $D=0$: Pole $REG$ określa źródło (SOURCE), a pole $R/M$ określa cel (DESTINATION).
  • $D=1$: Pole $R/M$ określa źródło (SOURCE), a pole $REG$ określa cel (DESTINATION).
• Bit S (Sign-extend):
  • $S=0$: Pełny operand natychmiastowy (8 bitów dla $W=0$, 16 bitów dla $W=1$).
  • $S=1$: 8-bitowy operand natychmiastowy z rozszerzeniem znaku do 16 bitów (stosowane przy $W=1$).

Szczegółowa budowa formatów rozkazów

• 1-bajtowy bez operandu:
  • Budowa: Kod operacji ($8$ bitów).
  • Przykład: $nop = 10010000$, $ret = 11000011$, $clc = 11111000$.
• 1-bajtowy z rejestrem (INC/DEC/PUSH/POP):
  • Budowa: Kod operacji ($5$ bitów) + reg ($3$ bity).
  • Przykład: $inc \, \%BX = 01000 \, 011$, $dec \, \%CX = 01001 \, 001$, $push \, \%DX = 01010 \, 010$, $pop \, \%AX = 01011 \, 000$.
• 2-bajtowy rejestr-rejestr:
  • Bajt 1: $op \, (6 \, bitów) \, D \, W$.
  • Bajt 2: $11 \, reg \, (3 \, bity) \, r/m \, (3 \, bity)$.
  • Przykład: $add \, \%BX, \%CX = 00000001 \, 11011001$, $sub \, \%DL, \%BL = 00101000 \, 11010011$.
• 2-bajtowy rejestr + pamięć (bez przemieszczenia):
  • Bajt 1: $op \, (6 \, bitów) \, D \, W$.
  • Bajt 2: $00 \, reg \, (3 \, bity) \, r/m \, (3 \, bity)$.
  • Przykład: $mov \, (\%BX), \%CL = 10001010 \, 00001111$.
• 3-bajtowy rejestr + pamięć (8-bit przemieszczenie):
  • Bajt 1: $op \, (6 \, bitów) \, D \, W$.
  • Bajt 2: $01 \, reg \, (3 \, bity) \, r/m \, (3 \, bity)$.
  • Bajt 3: $disp8$.
  • Przykład: $and \, 4(\%BP), \%CX = 00100011 \, 01001110 \, 00000100$.
• 4-bajtowy rejestr + pamięć (16-bit przemieszczenie):
  • Bajt 1: $op \, (6 \, bitów) \, D \, W$.
  • Bajt 2: $10 \, reg \, (3 \, bity) \, r/m \, (3 \, bity)$.
  • Bajty 3-4: $disp16$ (kolejność LSB, MSB).
  • Przykład: $or \, 0x5000(\%BX), \%CX = 00001011 \, 10001111 \, 00000000 \, 01010000$.
• 3-bajtowy rejestr + natychmiastowy (8-bit data):
  • Bajt 1: $100000 \, S \, W$.
  • Bajt 2: $11 \, op \, (3 \, bity) \, r/m \, (3 \, bity)$.
  • Bajt 3: $data8$.
  • Przykład: $add \, \$5, \%BX = 10000011 \, 11000011 \, 00000101$.
• 4-bajtowy rejestr + natychmiastowy (16-bit data):
  • Bajt 1: $100000 \, 0 \, 1$.
  • Bajt 2: $11 \, op \, (3 \, bity) \, r/m \, (3 \, bity)$.
  • Bajty 3-4: $data16$ (kolejność LSB, MSB).
  • Przykład: $add \, \$0x400, \%BX = 10000001 \, 11000011 \, 00000000 \, 00000100$.

Algorytm dekodowania rozkazów — krok po kroku

Procedura zamiany binarnego kodu na instrukcję w składni AT&T przebiega w następujący sposób:

1. KROK 1: Pobierz bajt 1 i zamień jego postać na binarną.
2. KROK 2: Zidentyfikuj format na podstawie pierwszych bitów bajtu 1.
   • $01000xxx \dots 01011xxx$: Instrukcje 1-bajtowe (INC, DEC, PUSH, POP), rejestr zakodowany w ostatnich 3 bitach.
   • $10010000$: NOP.
   • $11000011$: RET.
   • $1111111x$ lub $1111011x$: Przejdź do analizy bajtu 2 (rozszerzone operacje).
   • $100000xx$: Operacja natychmiastowa (czytaj bajt 2 oraz dane).
   • Pozostałe: Standardowy 2-bajtowy rozkaz ($bit7-2 = op$, $bit1 = D$, $bit0 = W$).
3. KROK 3: Pobierz bajt 2 i podziel go na pola: $mod \, (2 \, bity)$, $reg \, (3 \, bity)$, $r/m \, (3 \, bity)$.
4. KROK 4: Zinterpretuj pole $mod$:
   • $mod=11$: Pole $r/m$ wskazuje na rejestr.
   • $mod=00$: Pole $r/m$ wskazuje na adres bazowy w pamięci; jeśli $r/m=110$, czytaj 2 bajty przemieszczenia ($disp16$).
   • $mod=01$: Pole $r/m$ wskazuje na adres bazowy + czytaj 1 bajt przemieszczenia ($disp8$).
   • $mod=10$: Pole $r/m$ wskazuje na adres bazowy + czytaj 2 bajty przemieszczenia ($disp16$).
5. KROK 5: Ustal kierunek operacji na podstawie bitu $D$:
   • $D=0 \rightarrow$ rejestr ($reg$) to źródło, a $r/m$ (rejestr lub pamięć) to cel.
   • $D=1 \rightarrow r/m$ (rejestr lub pamięć) to źródło, a rejestr ($reg$) to cel.
6. KROK 6: Złóż końcową instrukcję w formacie AT&T: nazwa_instrukcji źródło, cel.

Opracowano na podstawie kursu Architektury Komputerów — Collegium Da Vinci, prowadzonego przez dr. D. Wawrzyniaka.