ARCHITEKTURA KOMPUTERÓW – proste algorytmy (x86/Pentium

ARCHITEKTURA KOMPUTERÓW – proste algorytmy (x86/Pentium – składnia Intel/Borland)
Spis programów
1. Obliczenie warto ci bezwzgldnej 64-bitowej liczby całkowitej spod adresu ZMIENNA (dwie wersje). ...................... 2
2. (2A) Obliczanie NWP 32-b liczb naturalnych ZA i ZB wg wzoru Euklidesa (NWP(a,b)=NWP(b, a mod b))............ 2
3. Szacowanie √ z 64-b liczby naturalnej spod adresu ZMIENNA wg.zaleno ci 1+3+5+…+(2n–1) = n2 .................... 2
4. Obliczenie wariacji V(n,k)=n!/(n–k)! (silnia , gdy k=1), n – w ecx, k – w esi, V(n,k) w eax ........................................ 2
5. Obliczenie kombinacji C(n,k) = n!/[k!(n–k)!], : n – liczba z rejestru ecx, k – liczba z rejestru esi, wynik w eax
algorytm: C(n,k) = {[...{[(n*(n–1)/2]*(n–2)/3}*(n–3)/4 .... ]*(n–k+1)/(k–1)}*(n–k+1)/k ......................................... 3
6. Wyszukiwanie najwikszej całkowitej z liczb 64-bitowych umieszczonych w tablicy LICZBY (big endian): ........... 3
7. Obliczenie N-tej liczby Fibonacciego........................................................................................................................... 3
8. Szyfr Cezara: tekst w buforze TEKST, ostatni znak NULL (kod 0), klucz w cl, szyfrogram w buforze CEZAR ............... 4
9. Obliczenie warto ci liczby wprowadzanej jako sekwencja cyfr ASCII (z bufora LICZBA)........................................... 4
10. Mnoenie 64-b liczb naturalnych (opcja: całkowitych w U2) danych pod adresami MNONA i MNONIK.......... 4
11. Generowanie liczb pierwszych <232 wg.algorytmu „sito Eratostenesa” (usuwanie z listy wielokrotno ci liczby p). . 5
12. Mnoenie 64-b liczb naturalnych (opcja: całkowitych w U2) danych pod adresami MNONA i MNONIK.......... 5
IA-32 – główne rónice składni asemblera Intel / Borland [MS DOS / Windows] oraz AT&T [UNIX / Linux]
(UWAGA: jeden operand musi by rejestrem, chyba e src jest stał)
IA-32
Intel/Borland [Windows]
AT&T [UNIX / Linux]
lista argumentów w zapisie działania "op"
dst:= dst (op) src
op dst, src
opl src, dst
opb src(b), dst(b)
nazwa rejestru
(32b) eax, ebx, …
(16b) ax, bx, …
( 8b) al, ah, bl, bh
(32b) %eax, %ebx, …
(16b) ––– (brak)
( 8b) %al, %ah, %bl, %bh,…
stałe: dziesitne
szesnastkowe
binarne
symboliczne (CONST, STALA, )
1654, –27531, 1011d
1234h, 0ABCh, 101h
0100b, 101111b
SCONST, STALA
1654, –27531, 1011, 0d–1012
0x1234, 0xABC, 0x101, 0x–ABC
0b0100, 0b101111
$CONST, $STALA
atrybuty zmiennej:
seg ZMIENNA
offset ZMIENNA
(brak, model liniowy pamici)
$ZMIENNA
ZMIENNA
ZMIENNA
warto
nr segmentu
offset (adres)
warto typ (jedn. liczba bajtów)
rozmiar
elementu zmiennej ideksowanej
spod wskazanego adresu
(zapis trybu adresowania)
programiki.doc
(w deklaracji: DB, DW, DD,…) (w deklaracji: .byte, .long, .ascii)
size ZMIENNA
(SIZE_ZM =. – ZMIENNA)
(w jednostkach rozmiaru)
(w bajtach, . – wskanik lokacji,
wyraenie musi by tu po deklaracji
ZMIENNA[ebx,
edx*4]
[ebx, edx*4]
[edx*4],
ZMIENNA[edx*4]
[ebx],
ZMIENNA[ebx],
ZMIENNA+5
13 czerwca 2009
ZMIENNA(%ebx,%edi,4)
(%ebx,%edi,4)
(,%edi,4),
ZMIENNA(,%edi,4)
(%edi),
ZMIENNA
ZMIENNA+5
©Janusz Biernat
ARCHITEKTURA KOMPUTERÓW – proste algorytmy (x86/Pentium – składnia Intel/Borland)
1. Obliczenie warto ci bezwzgldnej 64-bitowej liczby całkowitej spod adresu ZMIENNA (dwie wersje).
(etykieta)
rozkaz
komentarz
(copy:)
mov eax, ZMIENNA
mov ABS-ZM, eax
mov eax, ZMIENNA+4
mov ABS-ZM+4, eax
or eax, eax
jns wynik
xor eax, eax
sub eax, ABS-ZM
mov ABS-ZM, eax
mov eax, 0
sbb eax, ABS-ZM +4
mov ABS-ZM+4, eax
not ABS-ZM
not ABS-ZM +4
mov eax, 1
add ABS-ZM, eax
adc ABS-ZM+4, eax
(into)
; przekopiowanie, je li wynik ma by w innej zmiennej
a)
albo
b)
wynik:
; poniej dwa warianty algorytmu
; czy ZMIENNA jest dodatnia?
; zero (przygotowanie działania 0 – ZMIENNA)
; odejmowanie i zapis ABS-ZM = 0 – ZMIENNA
; wynik w ABS-ZM
; negowanie niszych bitów
; negowanie wyszych bitów
;
; dodanie “1”
; wynik w ABS-ZM
; niewykonalne je li ZMIENNA = 8000 0000 0000 0000
2. (2A) Obliczanie NWP 32-b liczb naturalnych ZA i ZB wg wzoru Euklidesa (NWP(a,b)=NWP(b, a mod b)).
(etykieta)
licz:
rozkaz
komentarz
mov ebx, ZB
mov eax, ZA
mov edx, 0
div ebx
xchg ebx, eax
xchg ebx, edx
and ebx, ebx
jnz licz
; ecx:ebx= mniejsza =ZBB (je li nie, bd przestawione)
; edx:eax= wiksza =ZAA
; dzielna (a) w eax, dzielnik (b) w ebx
; reszta (a mod b) w edx, zbdny iloraz w eax
; teraz dzielnik (b) bdzie dzieln w eax
; reszta (a mod b) bdzie dzielnikiem w ebx, … zbdny iloraz w edx
; czy reszta=0, je li tak, to NWP jest w eax, reszta jest teraz w ebx
; licz dopóki reszta ≠0, je li =0, to wynik: NWP(a,b) jest w eax
3. Szacowanie √ z 64-b liczby naturalnej spod adresu ZMIENNA wg.zaleno ci 1+3+5+…+(2n–1) = n2
(etykieta)
cykl:
9
rozkaz
komentarz
mov eax, –1
mov edx, –1
mov ecx, –1
add eax, 2
adc edx, 0
inc ecx
sub ZMIENNA, eax
sbb ZMIENNA+4, edx
jge cykl
(...(((ZMIENNA–1)|[?<0] –3) |[?<0] –5)|[?<0] –...) – (2ND–1)|[!<0]
; ND = (edx:eax=) –1 – kolejna nieparzysta
; SQRT = –1 (ZMIENNA<264→ SQRT<232)
; ND = ND+2 (nastpna nieparzysta)
; SQRT = SQRT+1 (liczba składników sumy nieparzystych)
; wynik SQRT (ZMIENNA) w ecx, korekta zbdna
4. Obliczenie wariacji V(n,k)=n!/(n–k)! (silnia , gdy k=1), n – w ecx, k – w esi, V(n,k) w eax
(etykieta)
licz:
(check:)
rozkaz
komentarz
mov eax, ecx
and eax, eax
jz end
sub esi, ecx
neg esi
mov eax, 1
mul ecx
dec ecx
cmp ecx, esi
jgt licz
and edx, edx
jnz error
; n w ecx, k w esi, kopia ecx do eax
;
; sprawdzenie, czy n=0, wtedy V(0,k) = df 0
; (k–n) do esi
; n–k w esi [–(k–n)]
; pocztkowy iloczyn (i=n)
; mnoenie przez biecy czynnik i
; kolejny czynnik (i–1)
; czy ostatni mnonik
; je li i>n–k licz dalej, je li i=n–k zako cz liczenie
; sprawd, czy iloczyn jest 32-b (w eax – edx:eax = 0:eax)
; przekroczony zakres, wynik >232
;
end:
programiki.doc
13 czerwca 2009
©Janusz Biernat
ARCHITEKTURA KOMPUTERÓW – proste algorytmy (x86/Pentium – składnia Intel/Borland)
5. Obliczenie kombinacji C(n,k) = n!/[k!(n–k)!], : n – liczba z rejestru ecx, k – liczba z rejestru esi, wynik w eax
algorytm: C(n,k) = {[...{[(n*(n–1)/2]*(n–2)/3}*(n–3)/4 .... ]*(n–k+1)/(k–1)}*(n–k+1)/k
(etykieta)
rozkaz
komentarz
(prep:)
mov ebx, esi
add ebx, ebx
sub ebx, ecx
jle hop
sub esi, ebx
mov eax, 0
jlt end
mov eax, 1
and esi, esi
jz end
mov edx, 0
mov ebx, 1
mov eax, ecx
dec ecx
mul ecx
inc ebx
div ebx
and edx, edx
jnz error
cmp ebx, esi
jlt comb
; argument k do ebx
; oblicz 2k
; oblicz 2k–n
; je li k≤n/2 przeskocz
; zastp k przez k–(2k–n) = n–k
; C(n,k) = 0 gdy k>n
; koniec gdy k>n
; C(n,k) = 1 gdy k=0 lub n–k=0
hop:
comb:
(check:)
end:
; n jest w ecx, k lub n–k jest w esi
;
; n do eax
; kolejny czynnik (n–i) iloczynu
;
; kolejny dzielnik i+1
; C(n,i+1) = C(n,i)*(n–i))/(i+1)
; sprawd, czy iloczyn jest w eax (edx:eax = 0:eax)
; przekroczony zakres, wynik >232
; je li i+1<k, kontynuuj
; wynik w eax
6. Wyszukiwanie najwikszej całkowitej z liczb 64-bitowych umieszczonych w tablicy LICZBY (big endian):
(etykieta)
pocz:
dalej:
cykl:
rozkaz
komentarz
mov edx, [LICZBY]
mov eax, [LICZBY+4]
mov esi, 2
mov ecx, ILE–1
jcxz koniec
inc esi
mov ebx, [LICZBY+4*esi]
mov ebp, [LICZBY+4+4*esi]
cmp edx,ebx
jgt cykl
jne dalej
cmp eax,ebp
jge cykl
mov edx, ebx
mov eax, ebp
inc esi
loop pocz
; edx = max-liczbaH
; eax = max-liczbaL
; ebx = kolejnaH
; ecx = kolejnaL
; powtórz gdy max-liczba > kolejna
; czy kolejna jest wieksza?
; kolejna nie wiksza od max-liczby
; kolejna jest wieksza od max-liczby, wic przestaw
;
; powtórz je li nie przeszukano całego zbioru, max w edx:eax
7. Obliczenie N-tej liczby Fibonacciego
(etykieta)
fibonac:
rozkaz
komentarz
mov ecx, N
mov eax, 0
mov ebx, 1
cmp ebx, N
je out
add eax, ebx
xchg ebx, eax
loop fibonac
; N – liczba naturalna (>0)
; warto pocztkowa F(0)=0
; F(1)=1
; czy N=1
out:
programiki.doc
; akumulacja: F(i–1) w eax, F(i) w ebx, F(i+1) do eax
; zamie F(i+1) z F(i)
; zmniejsz licznik i sprawd, czy ostatnia
; F(N) w ebx za F(N–1) w eax
13 czerwca 2009
©Janusz Biernat
ARCHITEKTURA KOMPUTERÓW – proste algorytmy (x86/Pentium – składnia Intel/Borland)
8. Szyfr Cezara: tekst w buforze TEKST, ostatni znak NULL (kod 0), klucz w cl, szyfrogram w buforze CEZAR
(etykieta)
pocz:
omijaj:
end:
rozkaz
komentarz
mov esi, offset TEKST
mov edi, offset CEZAR
mov al, [esi]
inc esi
cmp al, 0
jeq end
or al, 20h
cmp al, ‘ ’
jeq pocz
add al, cl
cmp al, ‘z’
jle omijaj
sub al, 1Ah
mov [edi], al
inc edi
jmp pocz
mov [edi], al
; usuwanie spacji (0x20 = ‘ ‘ = SP)
;
;
;
;
;
; wszystkie cyfry małe (maska 0010 0000)
; usuwanie spacji
;
;
;
;
; (1Ah=26 liter w alfabecie)
;
;
;
; znak ko ca (NULL) do bufora szyfrogramu
9. Obliczenie warto ci liczby wprowadzanej jako sekwencja cyfr ASCII (z bufora LICZBA)
(etykieta)
pocz:
rozkaz
komentarz
mov ebx, 10
mov eax, 0
mov esi, 0
mov cl, LICZBA [esi]
and ecx, 0Fh
add eax, ecx
mul ebx
inc esi
cmp esi, SIZE
jlt pocz
; max 9 cyfr, SIZE – rozmiar liczby, max. 9 cyfr
;
;
;
;
;
;
;
;
;
10. Mnoenie 64-b liczb naturalnych (opcja: całkowitych w U2) danych pod adresami MNONA i MNONIK.
(etykieta)
23
rozkaz
mov eax, MNO NA
mul MNO NIK
mov ILOCZYN, eax
mov ebx, edx
mov eax, MNO NA+4
mul MNO NIK
add ebx, eax
adc edx, 0
mov ecx, edx
mov eax, MNO NA
mul MNO NIK+4
add ebx, eax
adc ecx, edx
mov ILOCZYN+4, ebx
mov ebx, 0
adc ebx, 0
mov eax, MNO NA+4
mul MNO NIK+4
add eax, ecx
adc adx, ebx
mov ILOCZYN+8, eax
mov ILOCZYN+12, edx
programiki.doc
komentarz
; całkowite: A⋅M=(A+–263)⋅(M+–263)= A+⋅M+ – 263 (A++M+) –2126
; A⋅M = AL⋅ML+232(AH⋅ML+AL⋅MH)+ 264(AH⋅MH)
; edx:eax =(AL⋅ML)H:(AL⋅ML)L
; ILOCZYNLL = eax = (AL⋅ML)L (gotowe (A⋅M)LL)
; ebx: = (AL⋅ML)H (do dalszego przetwarzania)
; edx:eax =(AH⋅ML)H:(AH⋅ML)L
; ebx: = [(AL⋅ML)H+(AH⋅ML)L] mod 232
; (bez przekroczenia zakresu, bo iloczyn ≤(232–1)2=264–233+1)
; ecx = skorygowany (AH⋅ML)H
; edx:eax =(AL⋅MH)H:(AL⋅MH)L
; ebx: = [[(AL⋅ML)H+(AH⋅ML)L] mod 232 +(AL⋅MH)L] mod 232
; ecx = [skorygowany (AH⋅ML)H + (AL⋅MH)H+ CY] mod 232
; ILOCZYNLH=ebx=(AL⋅ML)H+(AH⋅ML)L+(AL⋅MH)L (gotowe (A⋅M)LH)
; przeniesienie na ILOCZYNHL
; edx:eax =(Ah⋅MH)H:(AH⋅MH)L
; ILOCZYNHL
; ILOCZYNHH
13 czerwca 2009
©Janusz Biernat
ARCHITEKTURA KOMPUTERÓW – proste algorytmy (x86/Pentium – składnia Intel/Borland)
11. Generowanie liczb pierwszych <232 wg.algorytmu „sito Eratostenesa” (usuwanie z listy wielokrotno ci liczby p).
(etykieta)
pocz:
pet:
hop:
cykl:
25
rozkaz
komentarz
cld
mov eax, –1
mov edi, offset ERAT
mov ecx, HK
rep stosd
mov esi, 0
mov edx, 1
mov ebx, edx
add ebx, ebx
add ebx, 1
cmp edx, SQK
jgt hop
mov eax, edx
add eax, ebx
mov [ERAT +4*eax], 0
cmp eax, HK
jlt pet
inc esi
mov [ERAT +4*esi], ebx
inc edx
cmp [ERAT +4*edx], 0
jz cykl
cmp edx, HK
jlt pocz:
mov ERAT, 2
; k–zakres, HK=k/2, SQK=sqrt(k), ERAT– tablica
; edx – indeks wyszukiwania, eax – indeks biecy, esi – nr liczby
; wypełnienie tablicy ERAT stał „–1” (stała moe by dowolna)
; esi – indeks liczby pierwszej
; edx – indeks biecy
; ebx = 2*edx+1
; indeksy komórek z wielokrotno ciami l.p.
; zerowanie
; kolejna liczba pierwsza do kolejnej komórki ERAT (lub innej tab)
12. Mnoenie 64-b liczb naturalnych (opcja: całkowitych w U2) danych pod adresami MNONA i MNONIK.
(etykieta)
23
rozkaz
mov eax, MNO NA
mul MNO NIK
mov ILOCZYN, eax
mov ebx, edx
mov eax, MNO NA+4
mul MNO NIK
add ebx, eax
adc edx, 0
mov ecx, edx
mov eax, MNO NA
mul MNO NIK+4
add ebx, eax
adc ecx, edx
mov ILOCZYN+4, ebx
mov ebx, 0
adc ebx, 0
mov eax, MNO NA+4
mul MNO NIK+4
add eax, ecx
adc adx, ebx
mov ILOCZYN+8, eax
mov ILOCZYN+12, edx
programiki.doc
komentarz
; całkowite: A⋅M=(A+–263)⋅(M+–263)= A+⋅M+ – 263 (A++M+) –2126
; A⋅M = AL⋅ML+232(AH⋅ML+AL⋅MH)+ 264(AH⋅MH)
; edx:eax =(AL⋅ML)H:(AL⋅ML)L
; ILOCZYNLL = eax = (AL⋅ML)L (gotowe (A⋅M)LL)
; ebx: = (AL⋅ML)H (do dalszego przetwarzania)
; edx:eax =(AH⋅ML)H:(AH⋅ML)L
; ebx: = [(AL⋅ML)H+(AH⋅ML)L] mod 232
; (bez przekroczenia zakresu, bo iloczyn ≤(232–1)2=264–233+1)
; ecx = skorygowany (AH⋅ML)H
; edx:eax =(AL⋅MH)H:(AL⋅MH)L
; ebx: = [[(AL⋅ML)H+(AH⋅ML)L] mod 232 +(AL⋅MH)L] mod 232
; ecx = [skorygowany (AH⋅ML)H + (AL⋅MH)H+ CY] mod 232
; ILOCZYNLH=ebx=(AL⋅ML)H+(AH⋅ML)L+(AL⋅MH)L (gotowe (A⋅M)LH)
; przeniesienie na ILOCZYNHL
; edx:eax =(Ah⋅MH)H:(AH⋅MH)L
; ILOCZYNHL
; ILOCZYNHH
13 czerwca 2009
©Janusz Biernat