-deklarowanie zmiennych:
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
-tworzenie segmentów
Kompilacja: tasm p1 powstaje p1.obj
Linkowanie: tlink p1.obj powstaje p1.exe
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
-jak działa stos
Na stosie mozemy przechowywać dzne znajdujace sie w rejestrze. Do wkładania na stos sluzy instrukcja push, a do sciagniecia pop. Istnieje rowniez push/pop-a wszystko, lub push/pop-f flagi.
-pętle
mov cx,10 ; cx jest licznikiem petli
petla:
.
.
.
loop petla ; cx = cx -1, jesli cx nie jest 0, nastepuje skok do petla
-konwersje (coś jak robiliśmy na którymś z wykładów ASCII na BCD itp.)
cmp ah,9
ja litera
add ah,30h
jmp cyfra
litera: add ah,37h
cyfra: mov t3,ah
mov ah,cl
and ah,0Fh
cmp ah,9
ja litera2
add ah,30h
jmp cyfra2
-procedury
mov ax,seg dane
mov ds,ax
mov ax,5
call procedurka
mov ah,4ch
int 21h
procedurka:
push ax
push dx
mov ah,9
mov dx, offset d1
int 21h
pop dx
pop ax
ret
-dodawanie, odejmowanie długich liczb (ADD, ADC)
add al, bl ; AL=AL+BL
adc al, bl ; AL=AL+BL+C
sub al, bl ; AL=AL-BL
sbb al, bl ; AL=AL-BL-C
-mnożenie, dzielenie
mul cl ; AX := AL*CL
div cl ; AL := (AX div CL), AH := (AX mod CL)
-koprocesor
mov ax,seg dane
mov ds,ax
mov dx, offset max
call pobierz_dane
finit
fld [m1]
fld [m2]
fmul
fst [m1]
mov ah,4ch
int 21h
pobierz_dane:
push ax
mov ah, 0ah
int 21h
pop ax
ret
-SHL, SHR
SHR AX, 1 ; przesunięcie rejestru AX o jeden w prawo
SHL AX, 1 ; przesunięcie rejestru AX o jeden w lewo
Koprocesor:
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.