jeszcze

INSTRUKCJE
Instrukcje przeniesienia: mov, lea, les , push, pop,
pushf, popf
Instrukcje konwersji: cbw, cwd, xlat
Arytmetyczne instrukcje: add, inc sub, dec, cmp,
neg, mul, imul, div, idiv
Logiczne instrukcje: and, or, xor, not, shl, shr, rcl, rcr
Instrukcje wejścia - wyjścia: in, out
Instrukcje łańcuchowe: movs, stos, lods
Instrukcje kontroli toku programu: jmp, call,
ret,conditional jumps
Operacje na bitach: clc, stc, cmc.
Instrukcje przeniesienia
Funkcja: kopiowanie dannych od jednego
miejsca do drugiego
Instrukcje:
Mov
Xchg
lds, les, lfs, lgs, lss
lea,
push, pusha, pushad, pushf, pushfd, pop,
popa, popad, popf, popfd
lahf, sahf
XCHG operand1, operand2
Działanie – zamienia wartości
dwóch operandów
Specyfikacje:
xchg reg, mem
xchg reg, reg
xchg ax, reg16
xchg eax, reg32 ;dla 80386 i
wyższej
LxS dest, source
Działanie: ładuje 32b operand (AL,np.) równocześnie
w reg.segmentowym i reg.przesun.
Specyfikacje:
lds reg16, mem32
les reg16, mem32
lfs reg16, mem32; dla 80386 i wyższej
lgs reg16, mem32; dla 80386 i wyższej
lss reg16, mem32; dla 80386 i wyższej
LEA (Load Effective
Address)
 Forma: lea dest, source
 Działanie: ładuje AE do rejestru docelowego
 Specyfikacja:
lea reg16, mem
 lea reg32, mem

 Przykłady:



lea ax, [bx] (=mov ax, bx) lea bx, 3[bx](=add bx,3)
lea ax, 3[bx](=mov ax, (bx+3) - nie dozwolone)
lea bx, 4[bp+si]
LAHF i SAHF
 lahf (load ah from flags) – ładuje do
AH zawart. rejestru znacznikowego
 sahf (store ah into flags) - ładuje do
rejestru znacznikowego zawart. AH
INSTRUKCJE KONWERSJI
CBW – convert byte to word (AL->AX)
CWD – convert word to double word (AX->DX:AX)
CWDE – convert word to double word (AX->EAX)
CDQ – convert 32b to 64b (eax->EDX:EAX)
XLAT – przetwarza zawart. AL wg. tablica w pam.
INSTRUKCJE ARYTMETYCZNE
 Dodawanie: ADD, ADC, INC, XADD, AAA DAA
 Odejmowanie: SUB, SBB, DEC, AAS, DAS
 NEG
 Mnożenie: MUL, IMUL, AAM
 Dzielenie: DIV, IDIV, AAD
 CMP
Dodawanie
 ADD (ADC):add dest, src dest := dest + src
adc dest, src dest := dest + src + CF






add reg, reg
add reg, mem
add mem, reg
add reg, immediate data
add mem, immediate data
add eax/ax/al, immediate data
 INC: inc mem inc reg8/16
Przykłady
 ; J:= K + M
mov ax, K
add ax, M
mov J, ax
 ; J := K + M + N + P
mov ax, K
add ax, M
add ax, N
add ax, P
mov J, ax
Odejmowanie
 SUB (SBB):SUB dest, src dest := dest - src
sbb dest, src dest := dest - src - C
sub reg, reg
 sub reg, mem
 sub mem, reg
 sub reg, immediate data
 sub mem, immediate data
 sub eax/ax/al, immediate data
 DEC: dec mem inc reg8/16

 ; J := K - J
mov ax, K
sub ax, J
mov J, ax
Przykłady
;
;? mov ax, J
sub ax, K
 ; J := J - (K + M) (lub J := J - K - M)
mov ax, K ; AX := K + M
add ax, M
sub J, ax ; J := J - (K + M)
;ALBO:
mov ax, J
sub ax, K
sub ax, M
mov J, ax
NEG
 NEG dest dest := 0 – dest
 Specyfikacja:
neg reg/mem
 Przykady:
; J := - J
neg J
; J := -K
mov ax, K
neg ax
mov J, ax
Mnożenie (MUL, IMUL)
mul src16/8
imul src16/8
imul dest, src1, imm_src
imul dest, imm_src
imul dest, src
acc32/16:= acc16/8 * src16/8
dest := src1 * imm_src
dest := dest * imm_src
dest := dest * src
 Speczfikacje:




mul reg/mem
imul reg/mem
imul reg, reg/mem, immediate
imul reg, immediate/reg/mem
Przykłady
;***********
mov ax, J
add ax, K
sub ax, M
mul L
(J+K-M)*L
*************
;********** ((J*7 + K) * 6 + M) * 2 ***********
imul bx, 7
add bx, K
imul bx, 6
add bx, M
add bx, bx ;BX := BX * 2
Dzielenie (DIV, IDIV)
div src; AX(AL):=DX:AX(AX)/src
idiv src; AX(AL):=DX:AX(AX)/src
 Specyfikacje:
 div reg/mem
 idiv reg/mem
16(8)
16(8)
!reszta: DX(AH)
!reszta: DX(AH)
; ********** J := (K *M )/P *********
mov ax, K
imul M ; 32 bit resultat - w DX:AX!!!
idiv P
mov J, ax
?
?
?
?
Porównanie
 CMP dest, src
(dest - src)
 Speczfiakcja:
cmp reg, reg
cmp reg, mem
cmp mem, reg
cmp reg, immediate data
cmp mem, immediate data
cmp eax/ax/al, immediate data
Ustawianie znaczników
Z (wynik zerowy):
Oprnd1 = Oprnd2
C (przeniesienie):
Oprnd1 < Oprnd2 (C=1)
Oprnd1 >= Oprnd2 (C=0)
INSTRUKCJE LOGICZNE
 AND, OR, XOR
instr dest, source
 NOT
 SHL/SAL, SHR, SAR, SHLD, and
SHRD
 RCL, RCR, ROL, ROR
 TEST
Specyfikacja dla AND, OR, XOR
and
and
and
and
and
and
reg, reg
mem, reg
reg, mem
reg, immediate data
mem, immediate data
eax/ax/al, immediate data
AND
Działanie:
0 and 0 = 0
0 and 1 = 0
1 and 0 = 0
1 and 1 = 1
 Zastosowanie – logiczne mnożenie,
zerowanie bitów, sprawdzenie bitów:
and al, 5
and Liczba,0f0h
and dx, maska
OR
 Działanie:
0 or 0 = 0
0 or 1 = 1
1 or 0 = 1
1 or 1 = 1
 Zastosowanie – logicznasuma, ustawianie
bitów, sprawdzenie bitów:
or dl, 7
or Liczba,01101000b
or dx, 80h
XOR (exclusive OR)
 Działanie:
0 xor
0 xor
1 xor
1 xor
0=0
1=1
0=1
1=0
 Zastosowanie – zerowanie, sprawdzenie
bitów:
xor al, al
xor Liczba,0f0h
xor dx, maska
NOT
 Działanie:
not 0 = 1
not 1 = 0
 Specyfikacja:
not reg
not mem
Test
Działa tak samo, jak AND, tylko
nie wpisuje wynik operacji do
pierwszego operanda
SHR/L, SAR/L, SHRD/L
SHL dest, count
shr dest, count
PRZYKŁADY
ZASTOSOWANIE
sal dest, count
sar dest, count
Specyfikacja
shl
shl
shl
shl
shl
shl
reg, 1
mem, 1
reg, imm
mem, imm
reg, cl
mem, cl
RCL/R, ROR/L
 ROL dest, count
RCL dest, count
ROR dest, count
RCR dest, count
SPECYFIKACJA:
rcl reg, 1
rcl mem, 1
rcl reg, imm (2)
rcl mem, imm (2)
rcl reg, cl
rcl mem, cl
SHLD / SHRD
shld operand1, operand2, immediate
shld operand1, operand2, cl
shrd operand1, operand2, immediate
shrd operand1, operand2, cl
Zadania
 Podaj zawartość DX po:
mov dh, 01101110b
or dh, 0f3h
mov cl, 15
ror cl,3
xor dh, cl
mov dl, cl
Skoki
Skoki bezwarunkowe
JMP target
JMP etykieta/wskaźnik adresu/ reg16
Przykład:
.model small
.data
napis1 db 'pierwszy $'
napis2 db 'drugi $'
.code
start:
mov ax,seg napis1
mov ds,ax
mov ah,9
dx,napis1
int 21h
jmp przeskocz
mov ah,9
mov dx,offset napis2
int 21h
przeskocz:
mov ah,4ch
int 21h
end start
end
Skoki warunkowe i instrukcje
porównawcze
.model small ;
ZGADNIJ CO TEN PROGRAM ROBI!
.data
liczba db 16d
komunikat1 db 'Podana liczba spełnia założenia ',13,10,'$'
komunikat2 db 'Podana liczba nie spełnia założenia ',13,10,'$'
.code
start:
mov ax,seg liczba
mov ds,ax
mov al,liczba
;sprawdzenie ????
test al,1
jnz nie_spelnia
; porównanie z liczba 6
cmp al, 6
jb nie_spelnia
cmp al, 15
jae nie_spelnia; teraz liczba spełnia podane warunki ??? JAKIE???
; wypisanie komunikatu
mov ah,9
mov dx,offset komunikat1
INT 21h
jmp koniec
nie_spelnia:
mov ah,9
mov dx,offset komunikat2
int 21h
koniec:
mov ah,4ch
int 21h
end start
end
;PROGRAM WYLICZA SUMĘ OT A DO B
.model small
.stack 24h
.486 ;udostępnienie instrukcji procesora 486
. data
liczba
dd 0 ; liczba do wypisania
dzielnik
dd 10
licznik
dw 0
napis
db '???????????????? : $'
.code
start:
mov ax,seg liczba ; = MOV AX, @DATA
mov ds,ax
xor ebx,ebx ; w ebx będzie przechowyw. SUMĘ
mov edx,4 ; A - ’Początek sumowania’
petla1:
cmp dx,122 ; B - ’Koniec sumowania’
ja wyjscie
;wyjście jeżeli dx>122
add ebx,edx
inc dx
; JAK MYŚLIŚ PO CO TO?
inc dx
; I TO 2 RAZY!.....
jmp petla1
wyjscie:
mov liczba,ebx
;przekopiowanie sumy do liczba
call wypisz_liczbe ; proc. wypisująca liczbę
;** wyjscie z programu **
mov ah,4ch
int 21h
wypisz_liczbe proc
pushad
;*** odlozenie na stos cyfr liczby ***
mov eax,liczba
; przenieść liczbę do eax
petla:
mov edx,0
div dzielnik ;dzieli edx:eax przez 32-u bitowy
; dzielnik .. reszta w edx wynik w eax
push dx ;reszta na stos (reszta z przedziału 0..9)
inc licznik ; zliczanie cyfr liczby
cmp ax,0 ;czy zakończyć dzielenie (wynik=0 to
tak)
jne petla
;*** wypisanie liczby ***
mov ah,9
mov dx,offset napis
int 21h
mov cx,licznik
; ile cyfr do wypisania
wypisz:
pop dx
add dx, 48
mov ah, 2
int 21h
loop wypisz
popad
ret
wypisz_liczbe ENDP
end start
Pętle w asemblerze
Pętla typu FOR...
Pętla typu while
LOOP(E/CX, etykieta)
..........
et1:
mov (e)cx, liczba
etykieta1:
push (e)cx
................
pop (e)cx
loop etykieta1
Pętla typu repeat...until
Skok:
................
cmp al,wynik
jne Skok
...............
.....
skok:
......
cmp ax, 1
je skok
jmp et1
OPERACJE ZE
ZNACZNIKACH
 AH i Rejestr Znacznikowy (instrukcje):
 LAHF (Load AH from Flags)
 SAHF (Store AH into Flags)
 Ustawianie i zerowanie znaczników
 CLD– wyzerowanie znacznika kierunku;
 STD– ustawianie znacznika kierunku;
 STC – ustawianie znacznika przeniesienia;
 CLC –wyzerowanie znacznika przeniesienia;
 CMC – migotanie znacznika przeniesienia
 STI – ustawienie znacznika przerwania(zezwolenie na
przerwanie)
 CLI –zatrzymanie przerwania;