Kompilacja: tasm p1 powstaje p1.obj
Linkowanie: tlink p1.obj powstaje p1.exe
Deklaracja segment:
segmencik SEGMENT ; Deklaracja początku segmentu
; W tym miejscu OFFSET = 0
; Tutaj piszemy zawartość segmentu
; maksymalny OFFSET = FFFF h stąd maksymalny rozmiar segmentu to 64k
; w trybie DOS programy zwykle składają się z 3 segmentów:
; DANYCH
; STOSU
; PROGRAMU
; mają wówczas rozszerzenie EXE
;mogą również składać się z jednego segmentu wówczas mają rozszerzenie COM
segmencik ENDS ; Deklaracja końca segmentu
Segment Dane:
dane SEGMENT
; sposób deklaracji:
; nazwa_zmiennej typ wartość (wartości)
; rodzaje `zmiennych' :
; db bajt
; dw słowo
; dd podwójne słowo
zmienna1 db 0 ;deklaracja 1 bajtu i zainicjalizowanie jego wartoscią 1
zmienna2 db ? ;deklaracja bajtu bez inicjalizowania wartości
zmienna3 db ?,?,3 ;deklaracja 3 komórek pamięci przy czym wartość
;pierwszej i drugiej jest niezainicjaliwoana a trzeciej ; zainicjalizowana wartością 3 adresy to kolejno:
zmienna3, zmienna3+1, zmienna3+2
zmienna4 db `A' ;deklaracja 1 bajtu zainicjalizowanego wartością 41 hex ; (znak ascii A)
zmienna4 db `A' ;deklaracja 1 bajtu zainicjalizowanego wartością ; 41 hex (znak ascii A)
zmienna5 db `A','B','C' ; 3 komórki o wartościach ascii A,B i C, ale również ; można to zadeklarować tak:
zmienna6 db `ABC' ; ale to się nie nadaje do wyświetlania na ekranie !!!
zmienna7 db `ABC$' ; Teraz to się nadaje do wyświetlania jako ciąg ; znaków - $ informuje funkcje wyświetlające że jest ; to konieć stringa. Jak by to było napisane tak:
zmienna8 db `ABC' ; jak by było tak to następna zmienna:
zmienna9 db `DEF$' ; wyświetliła by się również czyli się wys: ABCDEF
zmienna 10 db 10,13,'$' ; zmiana linii
zmienna 11 dw 0 ; zmienna 16-bit
zmienna 12 dd 0 ; zmienna 32-bit
; na początek wystarczy
dane ENDS
Segment Stosu:
stosik SEGMENT stack ;stack od razu informuje kompilator że to jest segment stosu
db 256 dup(?) ;rozmiar stosu
stosik ENDS ;Aha nazwa nie może być stos bo jest taka instrukcja
Segment Programu:
program SEGMENT
ASSUME CS:program, DS:dane, SS:stosik ; przyporządkowanie nazw poszczególnych ; segmentów do rejestrów
start: ; przesunięcie adresowe w tym segmencie
MOV ax, SEG dane ; mov to instrukcja przesłania do AX zwartości adresu segmentu ; danych
MOV ds., ax ; który następnie ładowany jest do DS-a. Wydaje się oczywiste
MOV ah,4Ch ; Tu musimy zatrzymać się dłużej
INT 21h
program ENDS
END start ; Koniec programu
Instruckje Skoków warunkowych:
opis słówny |
liczby bez znaku |
liczby ze znakiem |
gdy X1 większy |
ja (jnbe) |
jg (jnle) |
gdy X1 mniejszy |
jb (jnae, jc) |
jl (jnge) |
gdy równe |
je (jz) |
je (jz) |
gdy nierówne |
jne (jnz) |
jne (jnz) |
gdy większy lub równy |
jae (jnb, jnc) |
jge (jnl) |
gdy mniejszy lub równy |
jbe (jna) |
jle (jng) |
Pętla LOOP:
mov cx,10 ; cx jest licznikiem petli
petla:
.
.
.
loop petla ; cx = cx -1, jesli cx nie jest 0, nastepuje skok do petla
mnożenie:
mul cl ; AX := AL*CL
mul bx ; DX:AX := AX*BX
dzielenie:
div cl ; AL := (AX div CL), AH := (AX mod CL)
div bx ; AX := (DX:AX div BX), DX := (DX:AX mod BX)
dodawanie:
Bez przeniesienia:
add al, bl ; AL=AL+BL
add dx, bx ; DX=BX+DX
z przeniesieniem:
adc al, bl ; AL=AL+BL+C
adc dx, bx ; DX=BX+DX+C
Zastosowanie przy długich dodawaniach:
add al, bl ; AL=AL+BL
adc ah, bh ; AH=AH+BH+C ; add ax, bx
odejmowanie:
Bez pożyczki:
sub al, bl ; AL=AL-BL
sub dx, bx ; DX=BX-DX
z pożyczką:
sbb al, bl ; AL=AL-BL-C
sbb dx, bx ; DX=BX-DX-C
Zastosowanie przy długich odejmowaniach:
sub al, bl ; AL=AL-BL
sbb ah, bh ; AH=AH-BH-C ; sub ax, bx
Inkrementacja:
inc al ; AL=AL + 1
inc dx ; DX=DX + 1
Dekrementacja:
dec al ; AL=AL - 1
dec dx ; DX=DX - 1
Przesunięcia:
Wywołanie:
SHR AX, 1 ; przesunięcie rejestru AX o ; jeden w prawo
SHL AX, 1 ; przesunięcie rejestru AX o ; jeden w lewo
RCR AX, 1 ; przesunięcie rejestru AX o ; jeden w prawo
RCL AX, 1 ; przesunięcie rejestru AX o ; jeden w lewo
ROR AX, 1 ; przesunięcie rejestru AX o ; jeden w prawo
ROL AX, 1 ; przesunięcie rejestru AX o ; jeden w lewo
Operatory logiczne:
NOT al ; 8 bit
NOT ax ; 16 bit
NOT 0 = 1
NOT 1 = 0
AND al, 0000 0001 b ; 8 bit
AND ax, 00FFh ; 16 bit
AND 0,0 = 0
AND 0,1 = 0
AND 1,0 = 0
AND 1,1 = 1
OR al, 0000 0001 b ; 8 bit
OR ax, 00FFh ; 16 bit
OR 0,0 = 0
OR 0,1 = 1
OR 1,0 = 1
OR 1,1 = 1
XOR al, 0000 0001 b ; 8 bit
XOR ax, ax ; 16 bit
XOR 0,0 = 0
XOR 0,1 = 1
XOR 1,0 = 1
XOR 1,1 = 0
Operacje ladowania i wyciagania danych:
FLD/FILD [mem] - załaduj liczbę rzeczywistą/całkowitą z pamięci. Dla liczby rzeczywistej 32, 64 lub 80 bitów. Dla całkowitej - 16, 32 lub 64 bity
FST [mem] - do pamięci idzie liczba ze st(0).
FSTP [mem] - "store & pop" - zapisz st(0) w pamięci i zdejmij je ze stosu. Znaczy to tyle, że st(1) o ile istnieje, staje się st(0) itd. każdy rejestr cofa się o 1.
FIST [mem] - ewentualnie obciętą do całkowitej liczbę z st(0) zapisz do pamięci.
FISTP [mem] - FIST ze zdjęciem ze stosu.
FXCH st(i) - zamień st(0) z st(i).
Operacja pobierania stalych:
FLDZ - załaduj zero. st(0) = 0.0
FLD1 - załaduj 1. st(0) = 1.0
FLDPI - załaduj pi
FLDL2T - załaduj log2(10)
FLDL2E - załaduj log2(e)
FLDLG2 - załaduj log(2)=log10(2)
FLDLN2 - załaduj ln(2)
Operacje arytmetyczne:
Dodawania:
FADD [mem] st = st + [mem]
FADD st(0), st(i) st = st + st(i)
FADD st(i),st(0) st(i) = st(i) + st(0)
FADDP st(i), st(0) st(i) = st(i) + st(0) & pop
FADDP FADDP st(1),st(0)
FIADD [mem] st = st + [mem]
Odejmowanie:
FSUB [mem] st = st - [mem]
FSUB st(0), st(i) st = st - st(i)
FSUB st(i), st st(i) = st(i) - st
FSUBP st(i), st st(i) = st(i) - st(0) & pop
FSUBP FSUBP st(1), st(0)
FISUB [mem] st = st - [mem]
FSUBR [mem] st = [mem] - st(0)
Inne operacje odejmowania: FSUBRP st(i)_st , FSUBRP, FISUBRP [mem]
Mnozenie:
FMUL [mem] st = st * [mem]
FMUL st(0), st(i) st = st * st(i)
FMUL st(i), st(0) st(i) = st(i) * st(0)
FMULP st(i), st(0) st(i) = st(i) * st(0) & pop
FMULP FMULP st(1),st(0)
FIMUL [mem] st = st * [mem]
Dzielenie:
FDIV [mem] st = st / [mem]
FDIV st, st(i) st = st / st(i)
FDIV st(i), st st(i) = st(i) / st
FDIVP st(i), st st(i) = st(i) / st & pop
FDIVP FDIVP st(1), st
FIDIV [mem] st = st / [mem]
FDIVR [mem] st = [mem] / st
Inne operacje dzielenia: FDIVRP st(i)_st , FDIVRP, FIDIVRP [mem]
Inne operacje arytmetyczne:
FABS st = abs(st)
FCHS st = -st
FSQRT st = SQRT(st)
FPREM st = st mod st(1)
FRNDINT st = (int) st
FSIN, FCOS, FPTAN, FPATAN podstawowe instrukcje trygonometryczne
Operacje porownan:
FCOM st(n) - porównaj st(0) z st(n) (lub zmienną w pamięci) bez zdejmowania st(0) ze stosu FPU
FCOMP st(n) -porównaj st(0) z st(n) (lub zmienną w pamięci) i zdejmij st(0)
FCOMPP - porównaj st(0) z st(1) i zdejmij oba ze stosu
FICOM [mem] - porównaj st(0) ze zmienną całkowitą 16- lub 32-bitową w pamięci
FICOMP [mem] - porównaj st(0) ze zmienną całkowitą 16- lub 32-bitową w pamięci, zdejmij st(0)
FCOMI st(0), st(n) - porównaj st(0) z st(n) i ustaw flagi procesora
FCOMIP st(0), st(n) - porównaj st(0) z st(n) i ustaw flagi procesora, zdejmij st(0)
Operacje sterujace:
FINIT/FNINIT - inicjalizacja FPU. Litera "N" oznacza, aby nie brać pod uwagę ew. niezałatwionych wyjątków.
FLDCW, FSTCW/FNSTCW - Load/Store control word - zapisuje 16 kontrolnych bitów do pamięci, gdzie można je zmieniać np. aby zmienić sposób zaokrąglania liczb.
FSTSW/FNSTSW - zapisz do pamięci / rejestru AX słowo statusu (FPU)
FCLEX/FNCLEX - wyczyść wyjątki
FLDENV, FSTENV/FNSTENV - wczytaj / zapisz środowisko (rejestry stanu, kontroly i kilka innych, bez rejestrów danych). Wymaga 14 albo 28 bajtów pamięci, w zależności od trybu pracy procesora (rzeczywisty/DOS lub chroniony - Windows/Linux).
FRSTOR, FSAVE/FNSAVE - jw., tylko że z rejestrami danych. Wymaga 94 lub 108 bajtów w pamięci, zależnie od trybu procesora.
FINCSTP, FDECSTP - zwiększ/zmniejsz wskaźnik stosu - przesuń st(0) na st(7), st(1) na st(0) itd. oraz w drugą stronę, odpowiednio.
FFREE - zwolnij podany rejestr danych
FNOP - no operation. Nic nie robi, ale zabiera czas.
WAIT/FWAIT - czekaj, aż FPU skończy pracę. Używane do synchronizacji z CPU.