Maksymalna liczba punktów: 50

Rozkład punktów:

• Obecność: 10 punktów (2 punkty za każde zajęcia)
• Realizacja zadań/projektu: 40 punktów

Nowy Rok Akademicki 2025/2026

Zgodnie z obowiązkami określonymi przez Pana Dziekana Jerzego Choroszczaka:

Podczas zajęć ćwiczeniowych/laboratoryjnych studenci mają obowiązek uczestniczenia w nich z włączonymi kamerkami. Brak włączonej kamerki jest równoznaczny z brakiem obecności na zajęciach.

Wybór ścieżki realizacji

Na pierwszych zajęciach (Lab 01) należy wybrać jedną z dwóch ścieżek:

• Ścieżka A: Projekt zespołowy (2 osoby)
• Ścieżka B: Zadania indywidualne

Brak wyboru na Lab 01 oznacza automatyczne przypisanie do Ścieżki B.

Zmiana ścieżki jest możliwa w trakcie semestru (A - B), jednak wiąże się ze wszystkimi konsekwencjami dotyczącymi punktacji i terminów (zadania/projekt muszą być uzupełnione zgodnie z zasadami opóźnień).

Ścieżka A (Projekt zespołowy)

Punktacja

• Prezentacja postępów (5 spotkań po 5 pkt): 25 punktów
• Jakość kodu i dokumentacji: 10 punktów (finalnie)
• Finalna funkcjonalność projektu: 5 punktów (finalnie)

Ważne: Oceniane jest zaangażowanie i proces pracy, nie tylko końcowy efekt. Program nie musi działać w 100%, aby otrzymać punkty. Liczy się systematyczna praca, dokumentowanie problemów i prób ich rozwiązania.

Wymagania

• Zespoły: 2 osoby
• Podział pracy: równy, bez oceniania indywidualnego wkładu
• Minimalne wymagania:
  • Projekt musi przypominać wybrany temat
  • Musi posiadać dokumentację
  • Należy być przygotowanym na pytania: “Dlaczego tak, a nie inaczej?”
• Środowisko: Projekt musi działać w 16-bit DOS, uruchamiany w DOSBox
• Środowisko na ostatnie zajęcia (nr 5): Dowolne środowisko z kompilatorem C++

Tematy projektów

Każdy projekt może być realizowany w trybie tekstowym lub graficznym (assembler):

1. Snake - Sterowanie klawiszami, zjadanie punktów
2. Pong - Dwie paletki, piłka, kolizje, przeciwnik
3. Animacja sprite-ów w mode 13h - Sprite poruszający się po ekranie, kolizje ze ścianami, kilka klatek animacji (jak wygaszacz DVD)
4. Kalkulator RPN - Stos, operacje + - * /, wejście z klawiatury, liczby zmiennoprzecinkowe
5. Gra Labirynt - Generowanie labiryntu i poruszanie się w nim (marker pozycji)
6. Arkanoid / Breakout - Sterowanie paletką, odbijanie piłki, kasowanie klocków
7. Tetris - Spadające klocki, obracanie, kasowanie linii, przyśpieszanie, punktacja
8. Edytor tekstu - Wpisywanie tekstu, obsługa kursorem, zapisywanie/wczytywanie plików
9. Kompresor plików - Algorytm kompresji (np. RLE), kompresja i dekompresja
10. Gra w życie Conway’a - Automat komórkowy, wizualizacja, edycja stanu, animacja
11. Symulator dowolnej wybranej architektury - symulator procesora i ew. peryferiów (to rozwiązanie może być realizowane w C++, Python, C# lub inny popularny język)
    1. Przykładowo - podzbiór instrukcji procesora 6502 i tryb tekstowy. Prosty parser do asemblera i uruchamianie testowych programów.
    2. Ważne aby implementacja miała instrukcje dostępu do rejestrów, pamięci, można było wykonywać pętle i pisać po ekranie.

Zasada takiego projektu - na tyle powinien być rozbudowany, aby na każdych zajęciach można było prezentować postęp pracy. Należy również uwzględnić odpowiedni zakres w przypadku grupy (2 osoby).

Prezentacja

Każda grupa przedstawia na zajęciach numer 2, 3, 4

• Pokaz działania - uruchomienie programu w DOSBox, demonstracja funkcjonalności
• Omówienie zastosowanych rozwiązań - architektura kodu, kluczowe procedury
• Napotkane problemy - trudności techniczne, błędy, sposób ich rozwiązania
• Liczy się systematyczna praca, dokumentowanie problemów i prób ich rozwiązania
• Odpowiedzi na pytania prowadzącego o ile będą
• Czas prezentacji: maksymalnie kilka minut

Forma oddawania zadań

Paczka ZIP przesłana do CloudA zawierająca:

• Kod źródłowy (.asm)
• Skompilowany program (.exe lub .com)
• Dokumentacja/sprawozdanie (PDF/MD)
• Dodatkowo mile widziany link do publicznego repozytorium jeśli tam znajduje się kod

Ścieżka B (zadania indywidualne)

Punktacja

• Blok 1 (zadania 1-5): 7 punktów (do 12.12.2025)
• Blok 2 (zadania 6-10): 8 punktów (do 02.01.2026)
• Blok 3 (zadania 11-15): 12 punktów (do 09.01.2026)
• Blok 4 (zadania 16-20): 13 punktów (do 23.01.2026)

Wymagania

• Praca indywidualna
• Środowisko: 16-bit DOS (DOSBox)
• Środowisko na ostatnie zajęcia (nr 5): Dowolne środowisko z kompilatorem C++

Omawianie rozwiązań

Na zajęciach numer 2,3,4 rozwiązania zadań wybranych osób

• Pokaz działania - uruchomienie programu w DOSBox
• Napotkane problemy - trudności techniczne, błędy, sposób ich rozwiązania
• Odpowiedzi na pytania prowadzącego o ile będą

Tematy

BLOK 1: Podstawy I/O i operacje na danych (Zadania 1-5)

• Zadanie 1: Hello World Wyświetl na ekranie swoje imię i nazwisko, zakończ program.
• Zadanie 2: Wczytaj i wyświetl znak Wczytaj wyłącznie cyfry z klawiatury i wyświetl je na ekranie. Znaki pomijaj.
• Zadanie 3: Suma dwóch liczb jednocyfrowych Wczytaj dwie cyfry (znaki ‘0’-‘9’), oblicz ich sumę i wyświetl wynik jako znak (od A do Z). - tablica kodów ASCII (ASCII – Wikipedia, wolna encyklopedia)
• Zadanie 4: Konwersja małe/wielkie litery Wczytaj znak. Jeśli to mała litera, zamień na wielką. Jeśli wielka, zamień na małą. Wyświetl wynik.
• Zadanie 5: Wyświetlanie ciągu znaków w pętli Wyświetl 10 razy znak ‘*’ w jednej linii, używając pętli z rejestrem CX.

BLOK 2: Tablice i łańcuchy (Zadania 6-10)

zostaną podane na zajęciach numer 2

BLOK 3: Procedury, arytmetyka i logika (Zadania 11-15)

zostaną podane na zajęciach numer 3

BLOK 4: Wielowątkowość (Zadania 16-20)

zostaną podane na zajęciach numer 3

Zasady wspólne

• Współpraca jest wskazana - konsultacje, wymiana pomysłów, dyskusje techniczne
• Niedozwolone: oddawanie identycznych rozwiązań
• Dozwolone: wspólne procedury pomocnicze (np. wyświetlanie, konwersje)
• Wymagane: główna logika programu musi być własna
• Na każdych zajęciach:
  • prezentuję przykładowy kod,
  • omawiam go,
  • mamy czas na pytania
  • następnie pozostawiam czas na realizację zadań z bloku, lub pracę na projektem.

Terminy

• Lab 01: Wybór ścieżki realizacji, utworzenie repozytoriów/setup środowiska
• Lab 02-04: Systematyczna praca nad projektem/zadaniami,
  • postępy prac zespołów ze ścieżki A
  • omówienie zadań ze ścieżki B
• Lab 05: Finalne prezentacje projektów i oddanie ostatnich zadań

• Zadania należy oddać do piątku przed zajęciami.
• Każdy tydzień opóźnienia obniża punktację o 3

Przykładowo

Nieobecności

• W przypadku nieobecności należy skontaktować się z prowadzącym
• Oddanie zadań nadal obowiązuje, należy uzupełnić braki

Forma oddawania zadań

Paczka ZIP przesłana do CloudA zawierająca:

• Kod źródłowy (.asm)
• Skompilowany program (.exe lub .com)
• Dokumentacja/sprawozdanie (PDF/MD)
• Dodatkowo mile widziany link do publicznego repozytorium jeśli tam znajduje się kod

Kontakt z prowadzącym

Wszelkie pytania, sprawy organizacyjne i oddawanie prac poprzez system CloudA

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

Informacje organizacyjne

Termin oddania: do 12.12.2025
Punktacja: 7 punktów
Opóźnienie: -3 punkty za każdy tydzień

1. Środowisko pracy

Kompilacja w DOSBox-X

1
2

D:\> cd project
D:\PROJECT> cl program

Skrypt cl automatycznie wykonuje:

1. tasm program.asm - kompilacja do .OBJ
2. tlink program.obj - linkowanie do .EXE
3. Wyświetla ewentualne błędy

Debugowanie - TurboDebugger

1

D:\PROJECT> td program.exe

Podstawowe komendy:

• F7 - Step Into (krok do instrukcji)
• F8 - Step Over (pomiń CALL)
• F9 - Run to cursor
• Ctrl+F2 - Reset programu
• Alt+V - View menu (rejestry, pamięć, stos)

Porównanie z Visual Studio

Na zajęciach pokażę jak ten sam kod C wygląda w asemblerze pod Windows (x64).
To pomoże zrozumieć koncepcje uniwersalne dla każdej architektury.

2. Instrukcje asemblera - podstawy

2.1. Struktura programu .EXE

Każdy program w asemblerze dla DOS musi mieć określoną strukturę:

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

.model small          ; Model pamięci
.stack 512           ; Rozmiar stosu

.data
    ; Tutaj deklarujemy zmienne
    
.code
main proc
    ; Inicjalizacja segmentu danych
    mov ax, @data
    mov ds, ax
    
    ; Właściwy kod programu
    
    ; Zakończenie programu
    mov ax, 4C00h
    int 21h
main endp
end main

Wyjaśnienie:

• .model small - określa, że kod i dane mieszczą się w 64KB każdy
• .stack 512 - rezerwuje 512 bajtów na stos
• .data - sekcja dla zmiennych zainicjalizowanych
• .code - sekcja z instrukcjami programu
• @data - adres segmentu danych (generowany przez assembler)
• mov ax, 4C00h; int 21h - standardowe zakończenie programu DOS

2.2. Rejestry procesora - przypomnienie

Procesor 8086 ma następujące rejestry 16-bitowe, z których każdy można podzielić na dwie części 8-bitowe:

Rejestry wskaźnikowe:

• SI - Source Index (indeks źródłowy)
• DI - Destination Index (indeks docelowy)
• BP - Base Pointer (wskaźnik bazy stosu)
• SP - Stack Pointer (wskaźnik stosu)

Rejestry segmentowe:

• CS - Code Segment (segment kodu)
• DS - Data Segment (segment danych)
• SS - Stack Segment (segment stosu)
• ES - Extra Segment (dodatkowy segment)

2.3. Przerwania DOS (INT 21h)

INT 21h to główne przerwanie DOS-u do obsługi wejścia/wyjścia.

Najważniejsze funkcje dla BLOKU 1:

Przykład użycia funkcji 02h:

1
2
3

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

Przykład użycia funkcji 01h:

1
2
3

mov ah, 01h      ; Funkcja 01h - czytaj znak
int 21h          ; Wywołaj DOS
; Teraz AL zawiera wczytany znak

Przykład użycia funkcji 09h:

1
2
3
4
5
6
7

.data
    tekst db 'Hello World!$'    ; String musi kończyć się $
    
.code
    lea dx, tekst    ; DX = adres stringa
    mov ah, 09h      ; Funkcja 09h
    int 21h          ; Wyświetl string

2.4. Podstawowe operacje arytmetyczne

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

; Dodawanie
mov al, 5
add al, 3        ; AL = 8

; Odejmowanie
mov al, 10
sub al, 4        ; AL = 6

; Inkrementacja / Dekrementacja
mov cx, 5
inc cx           ; CX = 6
dec cx           ; CX = 5

2.5. Porównania i skoki warunkowe

1
2
3
4
5
6

; Porównanie
cmp al, 5        ; Porównuje AL z 5 (AL - 5)
je rowne         ; Jump if Equal (jeśli AL = 5)
jne nierowne     ; Jump if Not Equal (jeśli AL ≠ 5)
jg wieksze       ; Jump if Greater (jeśli AL > 5, signed)
jl mniejsze      ; Jump if Less (jeśli AL < 5, signed)

2.6. Pętle

1
2
3
4

mov cx, 10       ; Licznik
petla:
    ; Kod do powtórzenia
    loop petla   ; CX--, jeśli CX ≠ 0 skocz do 'petla'

2.7. Konwersja cyfr ASCII

Bardzo ważne dla zadań:

Gdy wczytujemy cyfrę z klawiatury (funkcja 01h), dostajemy jej kod ASCII, nie wartość liczbową!

Konwersja cyfra ASCII → wartość liczbowa:

1
2
3
4
5

mov ah, 01h      ; Wczytaj cyfrę
int 21h          ; AL = '5' = 35h
sub al, '0'      ; AL = 5 = 05h (wartość liczbowa)
; lub równoważnie:
sub al, 30h

Konwersja wartość liczbowa → cyfra ASCII:

1
2
3
4

mov al, 5        ; Wartość liczbowa
add al, '0'      ; AL = '5' = 35h (kod ASCII)
; lub równoważnie:
add al, 30h

Konwersja małe/wielkie litery:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

; Wielka → mała
mov al, 'A'      ; AL = 41h
add al, 20h      ; AL = 61h = 'a'
; lub:
or al, 20h       ; Ustaw bit 5

; Mała → wielka
mov al, 'a'      ; AL = 61h
sub al, 20h      ; AL = 41h = 'A'
; lub:
and al, 0DFh     ; Wyzeruj bit 5

3. Przykłady: C vs Asembler

Przykład 1: Hello World

Kod C:

1
2
3
4
5
6

#include <stdio.h>

int main() {
    printf("Hello World!\n");
    return 0;
}

Asembler x86-16 (TASM):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

.model small
.stack 256
.data
    tekst db 'Hello World!', 0Dh, 0Ah, '$'
    ; 0Dh = Carriage Return, 0Ah = Line Feed, '$' = koniec

.code
main proc
    mov ax, @data
    mov ds, ax
    
    ; Wyświetl string
    lea dx, tekst        ; DX = adres stringa
    mov ah, 09h          ; Funkcja 09h - wypisz string
    int 21h              ; Wywołaj DOS
    
    ; Zakończ program
    mov ax, 4C00h
    int 21h
main endp
end main

Visual Studio (x64 - do demonstracji):

1
2
3

; Visual Studio - Disassembly view
    lea rcx, [format_string]    ; Pierwszy parametr (64-bit)
    call printf                 ; Wywołanie funkcji C

Analiza różnic:

• DOS: Używamy przerwania INT 21h do komunikacji z systemem
• x64: Używamy wywołań funkcji biblioteki C (printf)
• DOS: String kończy się znakiem ‘$’
• C: String kończy się znakiem ‘\0’ (null terminator)
• DOS: Bezpośrednia komunikacja ze sprzętem przez BIOS/DOS
• Modern: Abstrakcja przez system operacyjny

Przykład 2: Wczytanie i wyświetlenie znaku

Kod C:

1
2
3
4
5
6
7
8
9

#include <stdio.h>

int main() {
    char znak;
    printf("Wpisz znak: ");
    scanf("%c", &znak);
    printf("Wpisales: %c\n", znak);
    return 0;
}

Asembler (TASM):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

.model small
.stack 256
.data
    prompt db 'Wpisz znak: $'
    wynik db 0Dh, 0Ah, 'Wpisales: $'

.code
main proc
    mov ax, @data
    mov ds, ax
    
    ; Wyświetl prompt
    lea dx, prompt
    mov ah, 09h
    int 21h
    
    ; Wczytaj znak
    mov ah, 01h          ; Funkcja 01h - czytaj znak z echo
    int 21h              ; AL = wczytany znak
    
    mov bl, al           ; Zapisz znak w BL
    
    ; Wyświetl komunikat
    lea dx, wynik
    mov ah, 09h
    int 21h
    
    ; Wyświetl znak
    mov dl, bl           ; Znak do wyświetlenia
    mov ah, 02h          ; Funkcja 02h - wypisz znak
    int 21h
    
    mov ax, 4C00h
    int 21h
main endp
end main

Analiza:

• W C używamy funkcji scanf i printf - wysokopoziomowa abstrakcja
• W asemblerze bezpośrednio wywołujemy funkcje DOS przez INT 21h
• Musimy ręcznie zarządzać rejestrami (AL, BL, DL)
• Każda operacja I/O wymaga ustawienia odpowiedniej funkcji w AH

Przykład 3: Prosta arytmetyka

Kod C:

1
2
3
4
5
6
7
8
9

#include <stdio.h>

int main() {
    int a = 5;
    int b = 3;
    int suma = a + b;
    printf("Suma: %d\n", suma);
    return 0;
}

Asembler (TASM) - wersja uproszczona:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

.model small
.stack 256
.data
    a db 5
    b db 3
    suma db 0

.code
main proc
    mov ax, @data
    mov ds, ax
    
    ; Oblicz sumę
    mov al, a            ; AL = 5
    add al, b            ; AL = AL + 3 = 8
    mov suma, al         ; Zapisz wynik
    
    ; Wyświetl wynik (zakładając jednocyfrowy)
    add al, '0'          ; Konwersja na ASCII
    mov dl, al
    mov ah, 02h
    int 21h
    
    mov ax, 4C00h
    int 21h
main endp
end main

Analiza:

• C: Kompilator automatycznie przydziela zmienne
• Asembler: Musimy jawnie zadeklarować zmienne w sekcji .data
• C: Operacje arytmetyczne są abstrakcyjne
• Asembler: Bezpośrednie operacje na rejestrach procesora
• C: printf obsługuje formatowanie
• Asembler: Ręczna konwersja liczby na znak ASCII

Przykład 4: Pętla i wyświetlanie

Kod C:

1
2
3
4
5
6
7
8
9

#include <stdio.h>

int main() {
    for (int i = 0; i < 10; i++) {
        printf("*");
    }
    printf("\n");
    return 0;
}

Asembler (TASM):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

.model small
.stack 256

.code
main proc
    mov ax, @data
    mov ds, ax
    
    mov cx, 10           ; Licznik pętli
    
petla:
    mov dl, '*'          ; Znak do wyświetlenia
    mov ah, 02h          ; Funkcja 02h
    int 21h
    loop petla           ; CX--, jeśli CX ≠ 0 goto petla
    
    ; Nowa linia
    mov dl, 0Dh          ; Carriage Return
    mov ah, 02h
    int 21h
    mov dl, 0Ah          ; Line Feed
    mov ah, 02h
    int 21h
    
    mov ax, 4C00h
    int 21h
main endp
end main

Analiza:

• C: Pętla for z jawnym licznikiem i warunkiem
• Asembler: Instrukcja LOOP używa rejestru CX
• Procesor automatycznie dekrementuje CX i sprawdza warunek
• W C nowa linia to \n, w DOS to dwa znaki: CR (0Dh) + LF (0Ah)

4. Zadania do wykonania

Forma oddawania

Każde zadanie oddajemy jako:

1. Kod źródłowy (.asm)
2. Skompilowany program (.exe)
3. Sprawozdanie (PDF lub MD) zawierające:
   • Opis rozwiązania
   • Wyjaśnienie kluczowych fragmentów kodu
   • Zrzuty ekranu z działania programu
   • Napotkane problemy i ich rozwiązania

Zadanie 1: Hello World

Treść zadania: Napisz program, który wyświetla na ekranie Twoje imię i nazwisko, a następnie kończy działanie.

Wymagania:

• Użyj funkcji DOS 09h (wyświetlanie stringa)
• String musi kończyć się znakiem ‘$’
• Program musi poprawnie zakończyć działanie (INT 21h, AH=4Ch)

Wskazówki:

1
2

.data
    tekst db 'Twoje Imie Nazwisko$'

W sprawozdaniu opisz:

• Dlaczego string musi kończyć się znakiem ‘$’?
• Jaka jest rola instrukcji lea dx, tekst?
• Co oznacza kod mov ax, 4C00h; int 21h?

Zadanie 2: Wczytaj i wyświetl znak

Treść zadania: Napisz program, który w pętli wczytuje znaki z klawiatury i wyświetla je na ekranie.
Program ma pomijać wszystkie znaki oprócz cyfr (‘0’-‘9’).
Pętla kończy się po naciśnięciu klawisza ESC (kod 1Bh).

Wymagania:

• Użyj funkcji 01h (wczytaj znak z echo) lub 08h (bez echo)
• Sprawdź czy znak jest cyfrą (zakres ‘0’-‘9’)
• Jeśli tak - wyświetl go funkcją 02h
• Jeśli nie - pomiń i czytaj następny
• Zakończ po naciśnięciu ESC

Wskazówki:

1
2
3
4
5
6

; Sprawdzenie czy cyfra:
cmp al, '0'      ; Czy >= '0'?
jb nie_cyfra     ; Jump if Below (mniejsze)
cmp al, '9'      ; Czy <= '9'?
ja nie_cyfra     ; Jump if Above (większe)
; Tutaj jest cyfra

W sprawozdaniu wyjaśnij:

• Jaka jest różnica między funkcją 01h a 08h?
• Dlaczego używamy instrukcji jb i ja zamiast jl i jg?
• Jaki kod ASCII ma klawisz ESC i dlaczego taki?

Zadanie 3: Suma dwóch liczb jednocyfrowych

Treść zadania: Napisz program, który:

1. Wczytuje dwie cyfry z klawiatury (znaki ‘0’-‘9’)
2. Oblicza ich sumę jako wartości liczbowe
3. Wyświetla wynik jako literę (od A do R)

Przykład:

• Wejście: ‘3’ i ‘5’
• Suma wartości: 3 + 5 = 8
• Wynik: ‘H’ (ósma litera alfabetu)

Wymagania:

• Konwersja cyfr ASCII na wartości liczbowe
• Dodawanie wartości
• Konwersja wyniku na literę (0→‘A’, 1→‘B’, …, 8→‘I’)
• Zakładamy, że suma < 18 (wynik < ‘S’)

Wskazówki:

1
2
3
4
5

; Konwersja cyfra ASCII → wartość:
sub al, '0'      ; lub sub al, 30h

; Konwersja liczba → litera:
add al, 'A'      ; lub add al, 41h

W sprawozdaniu wyjaśnij:

• Dlaczego odejmujemy 30h od cyfry ASCII?
• Jaki kod ASCII ma litera ‘A’ i dlaczego to ważne?
• Co się stanie jeśli suma będzie >= 26? (opcjonalnie: jak obsłużyć?)

Zadanie 4: Konwersja małe/wielkie litery

Treść zadania: Napisz program, który:

1. Wczytuje jeden znak z klawiatury
2. Sprawdza czy to litera (mała lub wielka)
3. Jeśli mała litera → zamienia na wielką
4. Jeśli wielka litera → zamienia na małą
5. Wyświetla przekonwertowany znak

Wymagania:

• Sprawdzenie zakresu ‘a’-‘z’ i ‘A’-‘Z’
• Konwersja przez dodanie/odjęcie 20h
• Wyświetlenie wyniku

Wskazówki:

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

; Sprawdzenie czy wielka litera:
cmp al, 'A'
jb nie_wielka
cmp al, 'Z'
ja nie_wielka
; Tutaj jest wielka litera

; Konwersja wielka → mała:
add al, 20h      ; lub or al, 20h

; Konwersja mała → wielka:
sub al, 20h      ; lub and al, 0DFh

W sprawozdaniu wyjaśnij:

• Dlaczego różnica między małą a wielką literą to dokładnie 20h?
• Jaki bit jest odpowiedzialny za wielkość litery?
• Dlaczego or al, 20h zamienia na małą, a and al, 0DFh na wielką?
• Co program powinien zrobić jeśli wejście nie jest literą?

Zadanie 5: Wyświetlanie ciągu znaków w pętli

Treść zadania: Napisz program, który wyświetla 10 razy znak ‘*’ w jednej linii,
używając pętli z rejestrem CX.

Wymagania:

• Użycie instrukcji LOOP
• Rejestr CX jako licznik
• Funkcja 02h do wyświetlania pojedynczego znaku

Wskazówki:

1
2
3
4
5
6

mov cx, 10       ; Licznik
petla:
    mov dl, '*'
    mov ah, 02h
    int 21h
    loop petla   ; CX--, if CX ≠ 0 goto petla

W sprawozdaniu wyjaśnij:

• Jak działa instrukcja LOOP krok po kroku?
• Co się stanie jeśli CX będzie miało wartość 0 przed pętlą?
• Dlaczego używamy CX, a nie innego rejestru?
• Jak wyświetlić 100 razy znak ‘*’ używając tylko 16-bitowego CX?

5. Wskazówki ogólne

Dobre praktyki

1. Zawsze inicjalizuj segment danych

   1 2	mov ax, @data mov ds, ax

2. Zawsze poprawnie kończ program

   1 2	mov ax, 4C00h ; Kod zakończenia 0 w AL int 21h

3. Używaj znaczących nazw etykiet

   1 2 3 4 5 6 7

   ; DOBRZE: wczytaj_znak: koniec_petli: ; ŹŹLE: etykieta1: x:

4. Dodawaj komentarze

   1 2	mov ah, 01h ; Funkcja 01h - czytaj znak int 21h ; Wywołaj DOS, wynik w AL

Częste błędy

1. Zapomnienie o inicjalizacji DS

   1 2 3 4 5 6 7 8 9 10 11

   ; ŹŹLE: .code main proc lea dx, tekst ; DS nie wskazuje na @data! ; DOBRZE: .code main proc mov ax, @data mov ds, ax lea dx, tekst

2. Brak znaku ‘$’ w stringu

   1 2 3 4 5

   ; ŹŹLE: tekst db 'Hello' ; Funkcja 09h nie wie gdzie koniec! ; DOBRZE: tekst db 'Hello$'

3. Niepoprawne zakończenie programu

   1 2 3 4 5 6

   ; ŹŹLE: ret ; To nie jest DOS! ; DOBRZE: mov ax, 4C00h int 21h

4. Mylenie kodów ASCII z wartościami

   1 2 3 4 5 6 7 8 9 10 11

   ; ŹŹLE: mov ah, 01h int 21h ; AL = '5' = 35h add al, 3 ; AL = 38h = '8' (NIEPOPRAWNE!) ; DOBRZE: mov ah, 01h int 21h ; AL = '5' = 35h sub al, '0' ; AL = 5 (wartość liczbowa) add al, 3 ; AL = 8 add al, '0' ; AL = '8' = 38h (ASCII)

5. Zapomnienie o destrukcyjnym charakterze instrukcji

   1 2 3 4 5 6 7 8 9

   ; ŹŹLE: mov al, znak1 add al, znak2 ; AL zawiera sumę mov dl, al ; ...ale AL już straciliśmy znak1! ; DOBRZE: mov al, znak1 mov bl, al ; Kopia na później add al, znak2

Przydatne kody ASCII

Debugowanie w TurboDebugger

Co warto sprawdzić:

1. View → Registers - obserwuj zmiany rejestrów

   • Czy AL zawiera poprawny kod ASCII?
   • Czy CX się prawidłowo zmniejsza w pętli?

2. View → Dump - pamięć programu

   • Czy twoje stringi są poprawnie zakończone ‘$’?
   • Jak wyglądają dane w pamięci?

3. F7 (Step Into) - wykonuj program instrukcja po instrukcji

   • Śledź jak zmieniają się rejestry
   • Sprawdź czy skoki warunkowe działają jak należy

4. Breakpointy (F2) - zatrzymaj program w konkretnym miejscu

   • Postaw breakpoint przed i po krytycznej operacji
   • Sprawdź stan rejestrów

6. Kryteria oceny

Każde zadanie oceniane jest według:

Uwaga: Nawet jeśli program nie działa w 100%, możesz otrzymać punkty za:

• Prawidłowe podejście do problemu
• Poprawną strukturę programu
• Merytoryczne wyjaśnienia w sprawozdaniu
• Próby rozwiązania i dokumentację problemów

Liczy się proces uczenia się i zrozumienie architektury!

Co powinno być w sprawozdaniu:

1. Opis problemu - co program ma robić
2. Analiza techniczna:
   • Jakie funkcje DOS użyłeś i dlaczego?
   • Jakie rejestry są wykorzystywane?
   • Jak działają kluczowe fragmenty kodu?
3. Fragmenty kodu z komentarzami - najważniejsze sekcje
4. Zrzuty ekranu - działający program
5. Napotkane problemy - błędy i ich rozwiązania
6. Wnioski - co się nauczyłeś?

7. Podsumowanie: Co powinniśmy wynieść z BLOKU 1

Po tym bloku powinieneś rozumieć:

1. Strukturę programu w asemblerze

   • Dyrektywy .model, .stack, .data, .code
   • Procedura główna main proc…endp
   • Inicjalizacja segmentu danych
   • Zakończenie programu

2. Podstawy komunikacji z systemem DOS

   • Przerwanie INT 21h i jego funkcje
   • Funkcja 01h - wczytaj znak
   • Funkcja 02h - wypisz znak
   • Funkcja 09h - wypisz string
   • Funkcja 4Ch - zakończ program

3. Rejestry procesora i ich role

   • AX jako akumulator
   • DX do przekazywania adresów i znaków
   • CX jako licznik pętli
   • Różnica między częściami 8-bit (AH, AL) a całym 16-bit (AX)

4. Kody ASCII i konwersje

   • Różnica między kodem ASCII a wartością liczbową
   • Konwersja cyfra ASCII ↔ wartość (±30h)
   • Konwersja małe ↔ wielkie litery (±20h)
   • Znaczenie bitów w reprezentacji znaków

5. Podstawowe konstrukcje programistyczne

   • Pętle z instrukcją LOOP
   • Porównania z CMP
   • Skoki warunkowe (JE, JNE, JB, JA)
   • Proste operacje arytmetyczne (ADD, SUB, INC, DEC)

6. Myślenie “blisko sprzętu”

   • Każda operacja to bezpośrednia instrukcja procesora
   • Ręczne zarządzanie rejestrami
   • Brak automatycznych konwersji typów
   • Kontrola nad każdym bajtem i bitem

Pamiętaj: To nie jest tylko nauka składni - to zrozumienie jak komputer rzeczywiście działa!

Po opanowaniu BLOKU 1 będziesz gotowy na bardziej zaawansowane tematy:

• Tablice i łańcuchy (BLOK 2)
• Procedury i funkcje (BLOK 3)
• Operacje na plikach (BLOK 4)

8. Zasoby dodatkowe

Kody ASCII - kompletna tabela

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

Dec  Hex  Znak | Dec  Hex  Znak | Dec  Hex  Znak | Dec  Hex  Znak
  0  00h  NUL  |  32  20h  SPC  |  64  40h  @    |  96  60h  `
  7  07h  BEL  |  33  21h  !    |  65  41h  A    |  97  61h  a
  8  08h  BS   |  34  22h  "    |  66  42h  B    |  98  62h  b
  9  09h  TAB  |  35  23h  #    |  67  43h  C    |  99  63h  c
 10  0Ah  LF   |  36  24h  $    |  68  44h  D    | 100  64h  d
 13  0Dh  CR   |  37  25h  %    |  69  45h  E    | 101  65h  e
 27  1Bh  ESC  |  48  30h  0    |  70  46h  F    | 102  66h  f
                |  49  31h  1    |  71  47h  G    | 103  67h  g
                |  50  32h  2    |  72  48h  H    | 104  68h  h
                |  57  39h  9    |  90  5Ah  Z    | 122  7Ah  z

Przydatne wzory

Sprawdzenie czy cyfra:

1
2
3
4
5

cmp al, '0'
jb nie_cyfra
cmp al, '9'
ja nie_cyfra
; tutaj jest cyfra

Sprawdzenie czy wielka litera:

1
2
3
4
5

cmp al, 'A'
jb nie_wielka
cmp al, 'Z'
ja nie_wielka
; tutaj jest wielka litera

Sprawdzenie czy mała litera:

1
2
3
4
5

cmp al, 'a'
jb nie_mala
cmp al, 'z'
ja nie_mala
; tutaj jest mała litera

Powodzenia!

Marcin Klimek
Architektura i Organizacja Systemów Komputerowych
WSB Nowy Sącz, 2025/2026

Informacje organizacyjne

Termin oddania: do 02.01.2026
Punktacja: 8 punktów
Opóźnienie: -3 punkty za każdy tydzień

1. Środowisko pracy

Kompilacja w DOSBox-X

1
2

D:\> cd project
D:\PROJECT> cl program

Skrypt cl automatycznie wykonuje:

1. tasm program.asm - kompilacja do .OBJ
2. tlink program.obj - linkowanie do .EXE
3. Wyświetla ewentualne błędy

Debugowanie - TurboDebugger

1

D:\PROJECT> td program.exe

Podstawowe komendy:

• F7 - Step Into (krok do instrukcji)
• F8 - Step Over (pomiń CALL)
• F9 - Run to cursor
• Ctrl+F2 - Reset programu
• Alt+V - View menu (rejestry, pamięć, stos)

Porównanie z Visual Studio

Na zajęciach pokażę jak ten sam kod C wygląda w asemblerze pod Windows (x64).
To pomoże zrozumieć koncepcje uniwersalne dla każdej architektury.

2. Instrukcje asemblera - rozszerzenie wiedzy

2.1. Pętle w asemblerze

Instrukcja LOOP

1
2
3
4

mov cx, 10        ; Ustaw licznik na 10
petla:
    ; Kod do powtórzenia
    loop petla    ; CX--, jeśli CX ≠ 0 skocz do 'petla'

Jak działa LOOP:

1. Dekrementuje CX (CX = CX - 1)
2. Sprawdza czy CX ≠ 0
3. Jeśli tak - skacze do etykiety
4. Jeśli CX = 0 - kontynuuje dalej

UWAGA: LOOP zawsze dekrementuje CX, nawet jeśli CX=0!
Wtedy CX staje się FFFFh (65535) → pętla wykona się 65535 razy!

Alternatywa: pętle z porównaniem

1
2
3
4
5
6

mov cx, 0         ; Licznik od 0
petla:
    ; Kod
    inc cx
    cmp cx, 10
    jl petla      ; Jump if Less (cx < 10)

Porównanie:

2.2. Operacje na stringach (łańcuchach)

Procesor ma specjalne instrukcje do pracy ze stringami. Używają rejestrów SI (source index) i DI (destination index).

Flaga kierunku (DF)

1
2

cld    ; Clear Direction Flag - SI/DI rosną (w górę pamięci)
std    ; Set Direction Flag - SI/DI maleją (w dół pamięci)

ZAWSZE ustawiaj cld na początku operacji stringowych!

LODSB/LODSW - Load String

1
2
3
4
5

; LODSB - Load String Byte
lodsb    ; AL = [DS:SI], następnie SI++

; LODSW - Load String Word
lodsw    ; AX = [DS:SI], następnie SI+=2

STOSB/STOSW - Store String

1
2
3
4
5

; STOSB - Store String Byte
stosb    ; [ES:DI] = AL, następnie DI++

; STOSW - Store String Word
stosw    ; [ES:DI] = AX, następnie DI+=2

MOVSB/MOVSW - Move String

1
2
3
4
5

; MOVSB - Move String Byte
movsb    ; [ES:DI] = [DS:SI], SI++, DI++

; MOVSW - Move String Word
movsw    ; [ES:DI] = [DS:SI], SI+=2, DI+=2

CMPSB/CMPSW - Compare String

1
2
3
4
5

; CMPSB - Compare String Byte
cmpsb    ; Porównuje [DS:SI] z [ES:DI], SI++, DI++, ustawia flagi

; CMPSW - Compare String Word
cmpsw    ; Porównuje słowa, SI+=2, DI+=2

SCASB/SCASW - Scan String

1
2
3
4
5

; SCASB - Scan String Byte
scasb    ; Porównuje AL z [ES:DI], DI++, ustawia flagi

; SCASW - Scan String Word
scasw    ; Porównuje AX z [ES:DI], DI+=2

Prefiksy powtarzania

1
2
3

rep movsb      ; Powtarzaj MOVSB dopóki CX ≠ 0 (CX razy)
repz cmpsb     ; Powtarzaj dopóki ZF=1 i CX≠0 (dopóki równe)
repnz scasb    ; Powtarzaj dopóki ZF=0 i CX≠0 (dopóki różne)

2.3. Adresowanie tablic

Podstawowe tryby

1
2
3

mov al, [bx]       ; AL = bajt pod adresem DS:BX
mov ax, [si]       ; AX = słowo pod adresem DS:SI
mov bl, [di]       ; BL = bajt pod adresem DS:DI (lub ES:DI dla stringów)

Displacement (przesunięcie)

1
2

mov al, [bx+5]     ; AL = bajt pod adresem DS:BX+5
mov ax, [si+10]    ; AX = słowo pod adresem DS:SI+10

Indeksowanie złożone

1
2

mov al, [bx+si]    ; AL = bajt pod adresem DS:BX+SI
mov ax, [bp+di]    ; AX = słowo pod adresem SS:BP+DI

Przesunięcie + indeks

1

mov al, [bx+si+5]  ; AL = bajt pod adresem DS:BX+SI+5

2.4. Różnica: bajt vs słowo w tablicach

KRYTYCZNE DO ZROZUMIENIA:

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

.data
    tablica_b db 10, 20, 30, 40, 50    ; Tablica bajtów
    tablica_w dw 10, 20, 30, 40, 50    ; Tablica słów (dwa bajty)

.code
    ; Dostęp do tablicy bajtów
    mov si, 0
    mov al, tablica_b[si]    ; AL = 10
    inc si                   ; SI = 1
    mov al, tablica_b[si]    ; AL = 20
    
    ; Dostęp do tablicy słów
    mov si, 0
    mov ax, tablica_w[si]    ; AX = 10
    add si, 2                ; SI = 2 (słowo = 2 bajty!)
    mov ax, tablica_w[si]    ; AX = 20

Częsty błąd: Inkrementacja inc si dla tablicy słów - to da dostęp do środka słowa!

1
2
3
4
5

; BŁĄD:
mov si, 0
mov ax, tablica_w[si]    ; AX = 10 (00 0A w pamięci little-endian)
inc si                   ; SI = 1 - wskazuje ŚRODEK słowa!
mov ax, tablica_w[si]    ; AX = nieprawidłowa wartość

3. Przykłady: C vs Asembler

Przykład 1: Pętla for - zliczanie

Kod C:

1
2
3
4
5

int count = 0;
for (int i = 0; i < 10; i++) {
    count++;
}
printf("Count: %d\n", count);

Asembler x86-16 (TASM):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

.model small
.stack 256
.data
    wynik dw 0

.code
main proc
    mov ax, @data
    mov ds, ax
    
    mov cx, 10        ; i = 10 (liczymy w dół)
    mov ax, 0         ; count = 0
    
petla:
    inc ax            ; count++
    loop petla        ; i--, if i != 0 goto petla
    
    mov wynik, ax     ; Zapisz wynik
    
    ; Zakończenie
    mov ax, 4C00h
    int 21h
main endp
end main

Visual Studio (x64 - do demonstracji):

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

; Visual Studio - Disassembly view
    mov dword ptr [count], 0
    mov dword ptr [i], 0
    jmp short check_loop
loop_body:
    mov eax, dword ptr [count]
    inc eax
    mov dword ptr [count], eax
    mov eax, dword ptr [i]
    inc eax
    mov dword ptr [i], eax
check_loop:
    cmp dword ptr [i], 10
    jl short loop_body

Analiza różnic:

• DOS: Używamy CX i instrukcji LOOP - procesor to rozumie natywnie
• x64: Kompilator używa jawnych porównań CMP i skoków JL
• DOS: 16-bit rejestry (AX, CX)
• x64: 32/64-bit rejestry (EAX, RAX)

Przykład 2: Tablica - suma elementów

Kod C:

1
2
3
4
5
6
7
8

int tablica[5] = {10, 20, 30, 40, 50};
int suma = 0;

for (int i = 0; i < 5; i++) {
    suma += tablica[i];
}

printf("Suma: %d\n", suma);

Asembler (TASM) - wersja 1 z LOOP:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

.model small
.stack 256
.data
    tablica dw 10, 20, 30, 40, 50    ; 5 słów
    suma dw 0

.code
main proc
    mov ax, @data
    mov ds, ax
    
    mov cx, 5              ; Licznik elementów
    mov si, 0              ; Indeks (w bajtach)
    mov ax, 0              ; Akumulator sumy
    
petla:
    add ax, tablica[si]    ; suma += tablica[i]
    add si, 2              ; Następny element (słowo = 2 bajty)
    loop petla
    
    mov suma, ax           ; Zapisz wynik
    
    mov ax, 4C00h
    int 21h
main endp
end main

Asembler (TASM) - wersja 2 z LODSW:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

.model small
.stack 256
.data
    tablica dw 10, 20, 30, 40, 50
    suma dw 0

.code
main proc
    mov ax, @data
    mov ds, ax
    
    cld                    ; Kierunek w górę
    lea si, tablica        ; SI wskazuje na tablicę
    mov cx, 5              ; 5 elementów
    mov bx, 0              ; Akumulator sumy
    
petla:
    lodsw                  ; AX = [DS:SI], SI += 2
    add bx, ax             ; suma += AX
    loop petla
    
    mov suma, bx
    
    mov ax, 4C00h
    int 21h
main endp
end main

Analiza:

• Wersja 1: Jawne indeksowanie tablica[si]
• Wersja 2: Użycie instrukcji stringowej LODSW - procesor automatycznie przesuwa SI
• Oba podejścia są poprawne, LODSW jest bardziej “idiomatic” dla x86

Przykład 3: String - długość łańcucha

Kod C:

1
2
3
4
5
6
7
8

char tekst[] = "Hello";
int dlugosc = 0;

while (tekst[dlugosc] != '\0') {
    dlugosc++;
}

printf("Długość: %d\n", dlugosc);

Asembler (TASM) - wersja 1 ręczna:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

.model small
.stack 256
.data
    tekst db 'Hello', 0    ; String zakończony zerem
    dlugosc dw 0

.code
main proc
    mov ax, @data
    mov ds, ax
    
    mov si, 0              ; Indeks
    
petla:
    mov al, tekst[si]      ; Pobierz bajt
    cmp al, 0              ; Czy koniec?
    je koniec              ; Jeśli tak - zakończ
    inc si                 ; dlugosc++
    jmp petla
    
koniec:
    mov dlugosc, si        ; Zapisz długość
    
    mov ax, 4C00h
    int 21h
main endp
end main

Asembler (TASM) - wersja 2 z SCASB:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

.model small
.stack 256
.data
    tekst db 'Hello', 0
    dlugosc dw 0

.code
main proc
    mov ax, @data
    mov ds, ax
    mov es, ax             ; ES = DS (SCASB używa ES:DI)
    
    cld                    ; Kierunek w górę
    lea di, tekst          ; DI wskazuje na tekst
    mov al, 0              ; Szukamy zera
    mov cx, 0FFFFh         ; Maksymalna długość
    
    repnz scasb            ; Szukaj AL w [ES:DI], aż znajdziesz (ZF=1)
    
    ; CX teraz zawiera: FFFFh - długość - 1
    ; Dlatego długość = FFFFh - CX
    neg cx                 ; CX = -CX
    dec cx                 ; CX = -(FFFFh - długość - 1) - 1 = długość
    
    mov dlugosc, cx
    
    mov ax, 4C00h
    int 21h
main endp
end main

Analiza:

• Wersja 1: Prosta, zrozumiała, jawna logika
• Wersja 2: Używa specjalizowanej instrukcji SCASB z prefiksem REPNZ
  • REPNZ = Repeat while Not Zero (dopóki nie znajdzie)
  • Po zakończeniu CX zawiera liczbę pozostałych iteracji
  • Matematyka: długość = max_cx - pozostałe_cx - 1

Przykład 4: Debugowanie w TurboDebugger

Program do zademonstrowania:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24