Wstęp do Asemblera x86 16-bit

1. Czym jest asembler i architektura x86?

Asembler to język programowania niskiego poziomu, w którym każda instrukcja odpowiada niemal bezpośrednio jednej operacji procesora. Programujemy “blisko sprzętu”.

Architektura x86 to rodzina procesorów zapoczątkowana przez Intel 8086 (1978). Procesor 16-bitowy oznacza, że podstawowa jednostka danych to 16 bitów (2 bajty).

2. Tryby pracy procesora x86

Procesor x86 może działać w różnych trybach:

Real Mode (Tryb rzeczywisty)

• Oryginalny tryb procesora 8086
• Dostęp do maksymalnie 1 MB pamięci (20-bitowy adres)
• Brak ochrony pamięci

Protected Mode (Tryb chroniony)

• Wprowadzony w 80286
• Pełna ochrona pamięci, wielozadaniowość
• 32-bitowe adresy (dostęp do 4 GB RAM)

3. Segmentacja pamięci

Problem adresowania

Procesor 16-bitowy może operować na liczbach 0-65535 (FFFFh). Jak więc dostać się do 1 MB pamięci (adresy 0-1048575)?

Rozwiązanie: adresowanie segment:offset

Adres fizyczny = Segment × 16 + Offset

1
2
3
4

Segment:  1234h
Offset:   5678h
──────────────────
Fizyczny: 1234h × 10h + 5678h = 12340h + 5678h = 179B8h

Segmenty w procesorze

Procesor ma specjalne rejestry segmentowe:

• CS (Code Segment) - kod programu
• DS (Data Segment) - dane
• SS (Stack Segment) - stos
• ES (Extra Segment) - dodatkowy segment danych

Przykład dostępu do pamięci:

1
2

mov ax, ds:[0100h]  ; czytaj z DS:0100h
mov ax, es:[bx]     ; czytaj z ES:BX

4. Jak DOS uruchamia program?

Krok po kroku:

1. Załadowanie do pamięci

   • DOS rezerwuje blok pamięci
   • Ładuje plik .EXE lub .COM

2. Tworzenie PSP (Program Segment Prefix)

   • 256-bajtowy obszar przed programem
   • Zawiera informacje środowiskowe, linię komend (80h, 81h-FFh)

3. Ustawienie rejestrów segmentowych

   • CS:IP wskazuje na punkt wejścia
   • DS i ES wskazują na PSP
   • SS:SP wskazuje na stos

4. Przekazanie sterowania

   • Skok do programu (CS:IP)

5. Po zakończeniu

   • Program wywołuje INT 21h, funkcja 4Ch
   • DOS zwalnia pamięć i przywraca kontrolę

5. Różnica między plikami COM i EXE

EXE

• Nagłówek EXE (MZ header) - 28 bajtów minimalnie:
  • Sygnatura “MZ” (4Dh 5Ah)
  • Rozmiar ostatniej strony
  • Liczba stron ( 512-bajtowych)
  • Liczba wpisów relokacyjnych
  • Rozmiar nagłówka w paragrafach
  • Minimalna/maksymalna pamięć dodatkowa
  • Początkowe wartości SS:SP i CS:IP
  • Offset tabeli relokacji
• Tablica relokacji - lista adresów wymagających modyfikacji
• Kod programu - segment CODE z instrukcjami
• Dane programu - segment DATA z zainicjalizowanymi danymi
• Segment stosu - STACK (jeśli zdefiniowany dyrektywą .stack)

Relokacja w EXE

Program EXE jest relokowalny, ponieważ:

• Może być ładowany pod dowolny adres w pamięci
• Zawiera tabelę relokacji z adresami, które trzeba poprawić
• Przy ładowaniu, DOS:
  1. Wczytuje program do pamięci
  2. Odczytuje tabelę relokacji
  3. Dla każdego wpisu dodaje adres segmentu ładowania do wartości pod wskazanym adresem
  4. Ustawia CS:IP i SS:SP zgodnie z nagłówkiem

Jeśli kod zawiera MOV AX, SEG dane i program załadowano pod segment 1000h, DOS doda 1000h do wartości segmentu zapisanej w kodzie.

Brak relokacji w COM

Program COM jest nierelokowalny:

• Jest zawsze ładowany pod stały adres 100h (w segmencie PSP)
• Wszystkie adresy są obliczone na etapie kompilacji dla tego konkretnego offsetu
• Nie ma nagłówka ani tabeli relokacji
• Cały segment (CS=DS=ES=SS) wskazuje na ten sam obszar pamięci
• Program jest po prostu “zrzutem pamięci” gotowym do wykonania

6. Dyrektywy asemblera MASM

Dyrektywy to instrukcje dla asemblera, nie dla procesora. Nie generują kodu maszynowego, tylko organizują program.

.model small

Określa model pamięci programu. Wpływa bezpośrednio na generowany kod maszynowy.

Rozmiar wskaźników i tryb adresowania

Model TINY/SMALL/COMPACT (near code):

1

CALL procedura

Generuje: E8 xx xx (3 bajty - relative near call)

• Offset względny 16-bit
• Zakłada, że procedura jest w tym samym segmencie kodu

Model MEDIUM/LARGE/HUGE (far code):

1

CALL procedura

Generuje: 9A xx xx yy yy (5 bajtów - absolute far call)

• Pełny adres: offset (2 bajty) + segment (2 bajty)
• Może wywołać procedurę w innym segmencie

.stack 512

Rezerwuje 512 bajtów na stos programu. Stos służy do:

• Przechowywania adresów powrotu z funkcji
• Zmiennych lokalnych
• Tymczasowego przechowywania rejestrów

Można zmienić rozmiar, np. .stack 1024.

COM:

• Dyrektywa jest IGNOROWANA
• Program COM ma z góry ustalony stos na końcu dostępnej pamięci
• Rejestr SP wskazuje na koniec segmentu (offset FFFEh lub FFFFh)
• Stos “rośnie w dół” od końca dostępnych 64KB
• Nie ma kontroli nad wielkością stosu w pliku COM

EXE:

• Dyrektywa tworzy osobny segment stosu o wielkości XXX bajtów
• Linker umieszcza ten segment w pliku wykonywalnym
• Rejestry SS:SP są inicjalizowane przez loader systemu operacyjnego
• SP wskazuje na koniec zaalokowanego obszaru stosu (offset XXX)
• Rozmiar stosu można precyzyjnie kontrolować

.data

Początek sekcji zainicjalizowanych danych. Tu deklarujemy zmienne z wartościami początkowymi.

Deklaracja zmiennych

Przykłady:

1
2

Liczba  dw ?             ; 1 słowo, niezaincjalizowane
Liczby  dw 1, 2, 3, 2000

1
2
3
4

.data
    liczba dw 100
    tekst db "Hello$"
    tablica db 1, 2, 3, 4, 5

.data?

Sekcja niezainicjalizowanych danych (opcjonalna). Zmienne bez wartości początkowej.

1
2

.data?
    bufor db 100 dup(?)  ; 100 bajtów nieokreślonych

.code

Początek sekcji kodu programu.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

.code
start:
    mov ax, @data    ; inicjalizacja DS
    mov ds, ax
    
    ; właściwy kod...
    
    mov ax, 4C00h    ; zakończenie
    int 21h
end start

end start - wskazuje punkt wejścia programu (etykietę start).

Szablon

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

.model small  
.stack 1024

.data
    ; {dane}

.code

main endp

    ; {kod}

main endp
end main

7. Rejestry procesora

Rejestry ogólnego przeznaczenia (General Purpose Registers)

Procesory x86 w trybie 16-bitowym dysponują czterema głównymi rejestrami ogólnego przeznaczenia, z których każdy może być używany jako jeden rejestr 16-bitowy lub dwa oddzielne rejestry 8-bitowe.

Uwagi:

• Rejestry te można używać wymiennie w większości operacji arytmetycznych i logicznych
• Podział na części wysoką (H - high) i niską (L - low) pozwala na efektywną pracę z danymi 8-bitowymi
• Niektóre instrukcje wymagają konkretnego rejestru (np. mul używa AX, loop sprawdza CX)

Rejestry wskaźnikowe i indeksowe (Pointer and Index Registers)

Uwagi:

• SP automatycznie modyfikowany przez push, pop, call, ret
• BP typowo używany do budowania ramek stosu w procedurach
• SI i DI pracują razem w instrukcjach stringowych (movsb, cmpsb, etc.)
• Rejestry te nie mają podziału na części 8-bitowe

Rejestry segmentowe (Segment Registers)

W architekturze x86 adres fizyczny jest tworzony z pary: rejestr segmentowy + offset. Każdy segment może mieć maksymalnie 64KB (0000h-FFFFh).

Uwagi:

• Adres fizyczny = Segment × 16 + Offset (np. CS:IP, DS:BX, SS:SP)
• Rejestry segmentowe nie mogą być używane bezpośrednio w operacjach arytmetycznych
• Zmiana CS możliwa tylko przez instrukcje skoku dalekiego (jmp far, call far, retf)
• W małych modelach pamięci (.model small) często wszystkie segmenty wskazują na ten sam obszar

Rejestr wskaźnika instrukcji (Instruction Pointer)

Uwagi:

• Nie można bezpośrednio odczytać ani zapisać wartości IP
• IP jest modyfikowany automatycznie przez procesor oraz instrukcje skoku i wywołań
• Adres fizyczny następnej instrukcji: CS:IP
• Do pośredniego dostępu można użyć call z natychmiastowym pop

Rejestr flag procesora (Flags Register)

Rejestr flag to specjalny 16-bitowy rejestr zawierający bity informacyjne o wyniku ostatniej operacji oraz kontrolujące tryb pracy procesora.

Uwagi:

• Flagi CF, PF, AF, ZF, SF, OF – flagi stanu (modyfikowane przez operacje arytmetyczne/logiczne)
• Flagi TF, IF, DF – flagi kontrolne (kontrolują tryb pracy procesora)
• Dostęp do rejestru flag: pushf (odłóż na stos), popf (zdejmij ze stosu)
• Instrukcje warunkowe (jz, jc, jg, etc.) sprawdzają kombinacje flag
• Bity 1, 3, 5, 12-15 są zarezerwowane (zawsze = 0 w 8086/80286)

8. Podstawowe instrukcje asemblera

Przesyłanie danych

Uwaga: Nie można wykonać mov mem, mem - tylko przez rejestr!

Ustawianie rejestrów:

1
2

mov ah, 02h    ; do AH ładowana jest liczba 02h
mov dl, 07h    ; do DL ładowana jest liczba 07h

Arytmetyka

Przykład:

1
2

mov al, 255
inc al        ; AL = 0, ZF = 1, CF = 1

Logika

Przesunięcia

Przykład:

1
2

mov cl, 3
shl ax, cl    ; AX = AX × 8

Porównania i skoki

Etykieta:

1

start:

Skok bezwarunkowy:

1

jmp etykieta

Instrukcje porównania

Instrukcje skoku (warunkowe)

BEZ ZNAKU (unsigned)

ZE ZNAKIEM (signed)

Pętle

1
2
3
4

mov cx, 10
petla:
    ; kod powtarzany 10 razy
    loop petla

Stos

Procedury

9. Czym jest przerwanie (interrupt)?

Przerwanie to mechanizm komunikacji między programem a systemem operacyjnym lub BIOS-em.

Jak to działa?

1. Program umieszcza parametry w rejestrach
2. Wywołuje instrukcję INT <numer>
3. Procesor:
   • Zapisuje aktualny stan na stosie
   • Skacze do procedury obsługi przerwania
   • Po zakończeniu wraca do programu

Przykład: wyświetlenie znaku

1
2
3

mov ah, 02h      ; funkcja 02h - wypisz znak
mov dl, 'A'      ; znak do wyświetlenia
int 21h          ; wywołaj DOS

Tabela przykładowych funkcji przerwania DOS (INT 21h)

INT 21h to główne przerwanie DOS-u do obsługi I/O, plików i systemu.

Tryb otwarcia pliku (funkcja 3Dh, rejestr AL):

• 00h = tylko odczyt
• 01h = tylko zapis
• 02h = odczyt/zapis

1
2
3

mov ah, 02h
mov dl, 07h
int 21h

wywołuje funkcję 02h przerwania 21h, która wysyła znak 07h (BEL / dzwonek).

Tabela funkcji INT 10h dla trybu tekstowego

Kody atrybutów kolorów (dla BH/BL)

Format bajtu atrybutu: KBBBTTTT

• K - miganie (1 bit)
• BBB - kolor tła (3 bity)
• TTTT - kolor tekstu (4 bity)

Kolory (0-15):

Przykłady użycia:

Przykład 1: Czyszczenie ekranu

1
2
3
4
5
6

mov ah, 06h      ; Scroll up
mov al, 0        ; Cały ekran
mov bh, 07h      ; Atrybut: białe na czarnym
mov cx, 0        ; Lewy górny (0,0)
mov dx, 184Fh    ; Prawy dolny (24,79)
int 10h

Przykład 2: Wyświetlanie kolorowego tekstu

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

mov ah, 02h      ; Ustaw kursor
mov bh, 0
mov dh, 10       ; Wiersz
mov dl, 20       ; Kolumna
int 10h

mov ah, 09h      ; Wyświetl znak z atrybutem
mov al, 'A'      ; Znak
mov bh, 0        ; Strona
mov bl, 1Eh      ; Żółty na niebieskim (tło=1, tekst=E)
mov cx, 5        ; Powtórz 5 razy
int 10h

Przykład 3: Wyświetlanie tekstu funkcją teletype

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

mov ah, 0Eh      ; Teletype
mov al, 'H'      ; Znak
mov bh, 0        ; Strona
int 10h          ; Wyświetl 'H'

mov al, 'i'
int 10h          ; Wyświetl 'i'

mov al, '!'
int 10h          ; Wyświetl '!'

Przykład 4: Ukrywanie kursora

1
2
3
4

mov ah, 01h      ; Set cursor shape
mov ch, 20h      ; Bit 5 = 1 ukrywa kursor
mov cl, 0
int 10h

Przykład 5: Wyświetlanie całego ciągu

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

.DATA
    tekst DB 'Hello World!'
    dlugosc EQU $-tekst

.CODE
    mov ah, 13h      ; Write string
    mov al, 1        ; Tryb 1: przesuwaj kursor, użyj BL
    mov bh, 0        ; Strona
    mov bl, 0Eh      ; Żółty na czarnym
    mov cx, dlugosc  ; Długość
    mov dh, 12       ; Wiersz
    mov dl, 35       ; Kolumna
    push ds
    pop es
    lea bp, tekst    ; ES:BP wskazuje na tekst
    int 10h

11. Wskazówki

1. Zawsze inicjalizuj DS na początku programu:

   1 2	mov ax, @data mov ds, ax

2. Zawsze kończ programem prawidłowo:

   1 2	mov ax, 4C00h int 21h

3. Nie można kopiować pamięć-pamięć bezpośrednio:

   1 2 3 4 5 6

   ; ŹLE: mov [zmienna1], [zmienna2] ; DOBRZE: mov ax, [zmienna2] mov [zmienna1], ax

4. Rozmiary muszą się zgadzać:

   1 2 3 4 5

   ; ŹLE: mov al, word ptr [zmienna] ; AL to 8-bit, word to 16-bit ; DOBRZE: mov ax, word ptr [zmienna]

5. String musi kończyć się znakiem $ dla funkcji 09h:

   1	tekst db "String musi kończyć się znakiem $"

Materiały dodatkowe - sporo staroci

Dokumentacja techniczna

• Intel 8086 Family User’s Manual - oficjalna dokumentacja procesora 9800722-03_The_8086_Family_Users_Manual_Oct79.pdf
• MASM 6.1 Programmer’s Guide - dokumentacja asemblera Microsoft Microsoft_Macro_Assembler_6.0_Programmers_Guide_1991.pdf
• Art of Assembly Language (16-bit) - Randall Hyde: https://www.plantation-productions.com/Webster/www.artofasm.com/DOS/index.html
• PC Assembly Language - Paul A. Carter (darmowy PDF) pcasm-book.pdf
• x86 Opcode and Instruction Reference - http://ref.x86asm.net/

Tutoriale i kursy online

• Tutorials Point - Assembly Programming: https://www.tutorialspoint.com/assembly_programming/
• x86 Assembly Guide (University of Virginia): https://www.cs.virginia.edu/~evans/cs216/guides/x86.html
• Assembly Language Tutorial (Derek Banas): seria video na YouTube (ARM) Assembly Language Tutorial - YouTube

Narzędzia i środowiska

• DOSBox - emulator DOS: https://www.dosbox.com/
• MASM/TASM - asemblery dla DOS
• Turbo Debugger - debugger dla programów DOS
• NASM - alternatywny assembler: https://www.nasm.us/
• WinASM - IDE dla programowania w assemblerze

Referencje online

• OSDev Wiki - niskopoziomowe programowanie: https://wiki.osdev.org/
• Felix Cloutier’s x86 Reference: https://www.felixcloutier.com/x86/
• Sandpile.org - szczegółowe informacje o architekturach x86

Tryb graficzny (Mode 13h)

• Michael Abrash’s Graphics Programming Black Book - klasyka grafiki VGA
• VGA Hardware Programming: http://www.osdever.net/FreeVGA/home.htm
• Mode 13h Tutorial - liczne tutoriale na YouTube i blogach

Przerwania DOS i BIOS

• DOS API Reference - lista funkcji int 21h
• BIOS Services Reference - funkcje int 10h, 16h, 13h
• IBM PC BIOS Source Code - historyczny kod źródłowy

Społeczności i fora

• gynvael.coldwind//vx + youtube: GynvaelColdwind - YouTube
• flat assembler Board: https://board.flatassembler.net/
• Vogons Programming Forum - retro programowanie

Emulatowy i debugowanie

• DOSBox-X - rozszerzona wersja DOSBox z lepszym debuggerem
• QEMU - emulator z możliwością debugowania
• Bochs - emulator x86 z wbudowanym debuggerem

Historie i ciekawostki

• “Masters of Doom” - historia id Software (programowanie DOS)
• Demoscene archives - pouët.net :: your online demoscene resource, SCENE.ORG
• “Tricks of the Game Programming Gurus” - André LaMothe