| CATEGORII DOCUMENTE |
INSTRUCTIUNI DE PRELUCRARE A DATELOR
SI INSTRUCTIUNI DE CONTROL AL PROGRAMULUI
(SALTURI PROPRIU-ZISE)
PENTRU MICROPROCESOARELE INTEL
1. Scopul lucrarii
Lucrarea de fata isi propune familiarizarea cu instructiunile de prelucrare a datelor precum si cu o parte dintre instructiunile de control al programului (salturile propriu-zise, conditionate si neconditionate) specifice microprocesoarelor Intel functionand "in modul real".
2. Memoriu de instructiuni
Conventiile folosite sunt cele aratate in lucrarea de laborator nr. 3. Se va acorda o atentie deosebita modului in care sunt afectate fanioanele. La conventiile amintite se adauga:
nrcel numarul de celule cu care se poate face deplasarea sau rotatia unui operand.
2.1. Instructiuni aritmetice
|
OF DF IF TF SF ZF AF PF CF |
||
|
ADD d,s |
Adunare |
x x x x x x |
Descrierea formala a semanticii, in general: (d) (d) + (s)
|
Operanzi |
Exemple |
Descrierea formala a semanticii |
|||
|
AL|AX, data |
ADD AL,33H |
( |
|||
|
r, data |
ADD CH,10H |
(CH) (CH) + 10H |
|||
|
mem, data |
ADD [BP],ALFA |
((SS) 0H+(BP)) ((SS) 0H+(BP)) + ALFA |
|||
|
r1, r2 |
ADD CL,CH |
(CL) (CL) + (CH) |
|||
|
r, mem |
ADD SI,[SI+22H] |
(SI) (SI) + ((DS) 0H + (SI) + 23H) ((DS) 0H + (SI) + 22H ) |
|||
|
mem, r |
ADD [BX],BX |
((DS) 0H+(BX)+1) ((DS) 0H+(BX)) ((DS) 0H+(BX)+1) ((DS) 0H+(BX)) + + (BX) |
|||
Adunare |
OF DF IF TF SF ZF AF PF CF |
|
||||
|
ADC d,s |
cu transport |
x x x x x x |
|
|||
|
||||||
Descrierea formala a semanticii, in general (d) (d) + (s) + (CF)
|
Operanzi |
Exemple |
Descrierea formala a semanticii |
|
AL|AX, data |
ADC AL,15H |
( |
|
r, data |
ADC BX,0100H |
(BX) (BX) + 100H + (CF) |
|
mem, data |
ADC [DI],1234H |
((DS) 0H+(DI)+1) ((DS) 0H+(DI)) ((DS) 0H+(DI)+1) ((DS) 0H+(DI)) + + 1234H +(CF) |
|
r1, r2 |
ADC AX,DI |
(AX) (AX) + (DI) + (CF) |
|
r, mem |
ADC DX,[BX] |
(DX) (DX) +((DS) 0H + (BX) + 1) ((DS) 0H + (BX)) + (CF) |
|
mem, r |
ADC [BX+DI+12H],DX |
((DS) 0H + (BX) + (DI) + 13H) ((DS) 0H + (BX) + (DI) +12H) ((DS) 0H + (BX) + (DI) + 13H) ((DS) 0H + (BX) + (DI) +12H) + + (DX) + (CF) |
|
Incrementarea |
OF DF IF TF SF ZF AF PF CF |
|
|
INC d |
destinatiei |
x x x x x |
Descrierea formala a semanticii, in general (d) (d) + 1
|
Operanzi |
Exemple |
Descrierea formala a semanticii |
|
r16 |
INC BX |
(BX) (BX) + 1 |
|
r8 |
INC |
( |
|
mem |
INC [BP+DI] |
((SS) 0H + (BP) + (DI)) ((SS) 0H + (BP) + (DI)) + 1 |
|
Ajustare ASCII |
OF DF IF TF SF ZF AF PF CF |
|
|
AAA |
pentru adunare |
? ? x ? x |
Descrierea
formala a semanticii: if (
(
(AH) (AH) + 1
(AF)
(CF) (AF)
(
|
Ajustare zecimala |
OF DF IF TF SF ZF AF PF CF |
|
|
DAA |
pentru adunare |
x x x x x |
Descrierea
formala a semanticii: if (
(
(AF)
if (
(
|
OF DF IF TF SF ZF AF PF CF |
||
|
SUB d,s |
Scadere |
x x x x x x |
Descrierea formala a semanticii, in general (d) (d) - (s)
|
Operanzi |
Exemple |
Descrierea formala a semanticii |
|
AL|AX, data |
SUB AL,20H |
( |
|
r, data |
SUB BX,5566H |
(BX) (BX) - 5566H |
|
mem, data |
SUB [BP+25H],444H |
((SS) 0H+(BP)+26H) ((SS) 0H+(BP)+25H) ((SS) 0H+(BP)+26H) ((SS) 0H+(BP)+25H) - - 0444H |
|
r1, r2 |
SUB DX,DI |
(DX) (DX) - (DI) |
|
r, mem |
SUB SI,[BX+100H] |
(SI) (SI) - ((DS) 0H + (BX) + 101H) ((DS) 0H + (BX) + 100H) |
|
mem, r |
SUB [BP+50H],AX |
((SS) 0H + (BP) + 51H) ((SS) 0H + (BP) + 50H) ((SS) 0H + (BP) + 51H) ((SS) 0H + (BP) + 50H) - (AX) |
|
OF DF IF TF SF ZF AF PF CF |
||
|
SBB d,s |
Scadere cu imprumut |
x x x x x x |
Descrierea formala a semanticii, in general (d) (d) - (s) - (CF)
|
Operanzi |
Exemple |
Descrierea formala a semanticii |
||
|
AL|AX, data |
SBB AX,1000H |
(AX) (AX) - 1000H - (CF) |
||
|
r, data |
SBB DI,23H |
(DI) (DI) - 0023H - (CF) |
||
|
mem, data |
SBB [BX+DI],33H |
((DS) 0H+(BX)+(DI)) ((DS) 0H+(BX)+(DI))- - 33H - (CF) |
||
|
r1, r2 |
SBB AL,BL |
( |
||
|
r, mem |
SBB AH,[DI+55H] |
(AH) (AH) - ((DS) 0H + (DI) + 55H) - (CF) |
||
|
mem, r |
SBB [BX],DL |
((DS) 0H + (BX)) ((DS) 0H + (BX)) - (DL) - (CF) |
||
|
Decrementarea |
OF DF IF TF SF ZF AF PF CF |
|||
|
DEC d |
destinatiei |
x x x x x |
||
Descrierea formala a semanticii, in general (d) (d) - 1
|
Operanzi |
Exemple |
Descrierea formala a semanticii |
|
r16 |
DEC AX |
(AX) (AX) - 1 |
|
r8 |
DEC DH |
(DH) (DH) - 1 |
|
mem |
DEC [BP+12H] |
((SS) 0H + (BP) + 12H) ((SS) 0H + (BP) + 12H) - 1 |
|
Complementare |
OF DF IF TF SF ZF AF PF CF |
|
|
NEG d |
fata de 2 |
x x x x x 1 |
|
a destinatiei |
Descrierea formala a semanticii, in general (d) 0H - (d)
|
Operanzi |
Exemple |
Descrierea formala a semanticii |
|
r |
NEG AX |
(AX) 0H - (AX) |
|
mem |
NEG [DI] |
((DS) 0H + (DI)) 0H - ((DS) 0H + (DI)) |
(CF) = 0 daca (d) = 0H
Compararea |
OF DF IF TF SF ZF AF PF CF |
|
|
CMP s1,s2 |
prin scadere |
x x x x x x |
|
a doi operanzi |
Descrierea formala a semanticii, in general (s ) - (s
|
Operanzi |
Exemple |
Descrierea formala a semanticii |
|
AL|AX, data |
CMP AX,0FFFFH |
(AX) - FFFFH |
|
r, data |
CMP BX,10H |
(BX) - 0010H |
|
mem, data |
CMP [BP+SI+5H],0ABH |
((SS) 0H + (BP) + (SI) + 5H) - ABH |
|
r1, r2 |
CMP AL,CL |
( |
|
r, mem |
CMP BH,[100H] |
(BH) - ((DS) 0H + 100H) |
|
mem, r |
CMP [BX+SI+45H],DX |
((DS) 0H + (BX) + (SI) + 46H) ((DS) 0H + (BX) + (SI) + 45H) - (DX) |
|
Ajustare ASCII |
OF DF IF TF SF ZF AF PF CF |
|
|
AAS |
pentru scadere |
? ? x ? x |
Descrierea
formala a semanticii if (
(
(AF)
(CF) (AF)
(
|
Ajustare zecimala |
OF DF IF TF SF ZF AF PF CF |
|
|
DAS |
pentru scadere |
x x x x x |
Descrierea
formala a semanticii: if (
(
(AF)
if (
(
(CF)
|
OF DF IF TF SF ZF AF PF CF |
||
|
MUL s |
Inmultire |
x ? ? ? ? x |
Descrierea formala a semanticii, in general:
pentru operatia pe 8 biti:
(AX)
(
(CF)
else (CF)
(OF) (CF)
iar pentru operatia pe 16 biti:
(DX) (AX) (AX) * (s) if (DX) = 0 then
(CF)
else (CF)
(OF) (CF)
|
Operanzi |
Exemple |
Descrierea formala a semanticii |
|
r8 |
MUL DL |
(AX)
( |
|
r16 |
MUL BX |
(DX) (AX) (AX) * (BX) |
|
mem8 |
MUL [BP+DI] |
(AX)
( |
|
mem16 |
MUL [1268H] |
(DX) (AX) (AX) * ((DS) 0H + 1269H) ((DS) 0H + 1268H) |
|
OF DF IF TF SF ZF AF PF CF |
||
|
IMUL s |
Inmultire cu semn |
x ? ? ? ? x |
Descrierea formala a semanticii, in general:
pentru operatia pe 8 biti:
(AX)
(
if (AH) = 0 or (AH) = FF then
(CF)
else (CF)
(OF) (CF)
iar pentru operatia pe 16 biti:
(DX) (AX) (AX) * (s)
if (DX) = 0 or (DX) = FFFF then
(CF)
else (CF)
(OF) (CF)
|
Operanzi |
Exemple |
Descrierea formala a semanticii |
|
r8 |
IMUL DL |
(AX)
( |
|
r16 |
IMUL CX |
(DX) (AX) (AX) * (CX) |
|
mem8 |
IMUL [0ABCDH] |
(AX)
( |
|
mem16 |
IMUL [BX+550H] |
(DX) (AX) (AX) * ((DS) 0H+(BX)+551H) ((DS) 0H+(BX)+550H) |
|
Ajustare ASCII |
OF DF IF TF SF ZF AF PF CF |
|
|
AAM |
pentru inmultire |
x x ? x ? |
|
(dupa inmutire) |
Descrierea
formala a semanticii (AH)
(
(
|
OF DF IF TF SF ZF AF PF CF |
||
|
DIV s |
Impartire |
? ? ? ? ? |
Descrierea formala a semanticii, in general:
pentru operatia pe 8 biti:
if (AX) div (s) > FF then
(SP) (SP) - 2
((SS) 0H + (SP) + 1) ((SS) 0H + (SP)) (F)
(IF)
(TF)
(SP) (SP) - 2
((SS) 0H + (SP) + 1) ((SS) 0H + (SP)) (CS)
(CS) (00003H) (00002H)
(SP) (SP) - 2
((SS) 0H + (SP) + 1) ((SS) 0H + (SP)) (IP)
(IP) (00001H) (00000H)
else (
(AH) (AX) mod (s) ,
iar pentru operatia pe 16 biti:
if (DX) (AX) div (s) > FFFF then
(SP) (SP) - 2
((SS) 0H + (SP) + 1) ((SS) 0H + (SP)) (F)
(IF)
(TF)
(SP) (SP) - 2
((SS) 0H + (SP) + 1) ((SS) 0H + (SP)) (CS)
(CS) (00003H) (00002H)
(SP) (SP) - 2
((SS) 0H + (SP) + 1) ((SS) 0H + (SP)) (IP)
(IP) (00001H) (00000H)
else (AX) (DX) (AX) div (s)
(DX) (DX) (AX) mod (s)
|
Operanzi |
Exemple |
Descrierea formala a semanticii |
|
r8 |
DIV CL |
( (AH) (AX) mod (CL) |
|
r16 |
DIV BX |
(AX) (DX) (AX) div (BX) (DX) (DX) (AX) mod (BX) |
|
mem8 |
DIV [BP+50H] |
( (AH) (AX) mod ((SS) 0H + (BP) + 50H) |
|
mem16 |
DIV [DI+41H] |
(AX) (DX) (AX) div ((DS) 0H+(DI)+42H) ((DS) 0H+(DI)+41H) (DX) (DX) (AX) mod ((DS) 0H+(DI)+42H) ((DS) 0H+(DI)+41H) |
|
OF DF IF TF SF ZF AF PF CF |
||
|
IDIV s |
Impartire cu semn |
? ? ? ? ? |
Descrierea formala a semanticii este similara cu cea de la instructiunea precedenta, cu exceptia comparatiei initiale care, pentru intregii cu semn, este:
pentru impartirea pe 8 biti:
if (AX) div (s) > 0 and (AX) div (s) > FF or
(AX) div (s) < 0 and (AX) div (s) < 0-FF-1 then
iar pentru impartirea pe 16 biti:
if (DX) (AX) div (s) > 0 and (DX) (AX) div (s) > FFFF or
(DX) (AX) div (s) < 0 and (DX) (AX) div (s) < 0-FFFF-1 then
|
Operanzi |
Exemple |
Descrierea formala a semanticii |
||
|
r8 |
DIV BL |
( (AH) (AX) mod (BL) |
||
|
r16 |
DIV CX |
(AX) (DX) (AX) div (CX) (DX) (DX) (AX) mod (CX) |
||
|
mem8 |
DIV [BX+SI] |
(AL) (AX) div ((DS) 0H + (BX) + (SI)) (AH) (AX) mod ((DS) 0H + (BX) + (SI)) |
||
|
mem16 |
DIV [BP] |
(AX) (DX) (AX) div ((SS) 0H +(BP) +1) ((SS) 0H +(BP)) (DX) (DX) (AX) mod ((SS) 0H +(BP) +1) ((SS) 0H +(BP)) |
||
|
Ajustare ASCII pt. |
OF DF IF TF SF ZF AF PF CF |
|||
|
AAD |
impartire (inainte |
x x ? x ? |
||
|
de imartire) | ||||
Descrierea
formala a semanticii: (
(AH) 0H
|
Extindere (cu semn) |
OF DF IF TF SF ZF AF PF CF |
|
|
CBW |
a unui octet la un | |
|
cuvant |
Descrierea
formala a semanticii: if (
(AH) 00H
else (AH) FFH
|
Extindere (cu semn) |
OF DF IF TF SF ZF AF PF CF |
|
|
CWD |
a unui cuvant la un | |
|
cuvant dublu |
Descrierea formala a semanticii: if (AX) < 8000H then
(DX) 0000H
else (DX) FFFFH
2.2. Operatii logice
|
Complementare |
OF DF IF TF SF ZF AF PF CF |
|
|
NOT d |
fata de 1 | |
|
a destinatiei |
Descrierea formala a semanticii, in general: (d) FFH - (d)
pentru operand pe 8 biti,
sau (d) FFFFH - (d)
pentru operand pe 16 biti.
|
Operanzi |
Exemple |
Descrierea formala a semanticii |
|
r |
NOT AX |
(AX) FFFFH - (AX) |
|
mem |
NOT [0EEFFH] |
((DS) 0H +EEFFH) FFH - - ((DS) 0H+EEFFH) |
|
OF DF IF TF SF ZF AF PF CF |
||
|
AND d,s |
SI logic |
x x ? x 0 |
Descrierea formala a semanticii, in general: (d) (d) & (s)
|
Operanzi |
Exemple |
Descrierea formala a semanticii |
|
AL|AX, data |
AND AX,0FFH |
(AX) (AX) & 0033H |
|
r, data |
AND CX,10H |
(CX) (CX) & 0010H |
|
mem, data |
AND [DI],0AAAAH |
((DS) 0H +(DI) +1) ((DS) 0H +(DI)) ((DS) 0H +(DI) +1) ((DS) 0H +(DI)) & & AAAAH |
|
r1, r2 |
AND CL,DL |
(CL) (CL) & (DL) |
|
r, mem |
AND DX,[BP] |
(DX) (DX) & ((SS) 0H + (BP) + 1H) ((SS) 0H + (BP)) |
|
mem, r |
AND [BX+DI],CL |
((DS) 0H+(BX)+(DI)) ((DS) 0H+(BX)+(DI)) & (CL) |
Compararea |
OF DF IF TF SF ZF AF PF CF |
|
|
TEST s1, s2 |
prin SI logic |
x x ? x 0 |
|
nedistructiv |
Descrierea formala a semanticii, in general (s ) & (s
|
Operanzi |
Exemple |
Descrierea formala a semanticii |
|
AL|AX, data |
TEST AL,55H |
( |
|
r, data |
TEST DI,1234H |
(DI) & 1234H |
|
mem, data |
TEST [SI],00101100B |
((DS) 0H + (SI)) & 00101100B |
|
r1, r2 |
TEST DI,BX |
(DI) & (BX) |
|
r, mem |
TEST CL,[SI] |
(CL) & ((DS) 0H + (SI)) |
|
OF DF IF TF SF ZF AF PF CF |
||
|
OR d,s |
SAU logic |
x x ? x 0 |
Descrierea formala a semanticii, in general (d) (d) (s)
|
Operanzi |
Exemple |
Descrierea formala a semanticii |
|
AL|AX, data |
OR AL,22H |
( |
|
r, data |
OR DX,1FFFH |
(DX) (DX) 1FFFH |
|
mem, data |
OR [BP+SI],1 |
((SS) 0H +(BP) + (SI)) ((SS) 0H +(BP) + (SI)) 01H |
|
r1, r2 |
OR CL,BL |
(CL) (CL) (BL) |
|
r, mem |
OR BX,[SI] |
(BX) (BX) ((DS) 0H + (SI) + 1H) ((DS) 0H + (SI)) |
|
mem, r |
OR [BP+DI],CX |
((SS) 0H +(BP) +(DI) +1) ((SS) 0H +(BP) +(DI)) ((SS) 0H +(BP) +(DI) +1) ((SS) 0H +(BP) +(DI)) (CX) |
|
OF DF IF TF SF ZF AF PF CF |
||
|
XOR d,s |
SAU exclusiv |
x x ? x 0 |
Descrierea formala a semanticii, in general: (d) (d) (s)
|
Operanzi |
Exemple |
Descrierea formala a semanticii |
|
AL|AX, data |
XOR AX,333H |
(AX) (AX) 0333H |
|
r, data |
XOR BP,245H |
(BP) (BP) 0245H |
|
mem, data |
XOR [DI],7788H |
((DS) 0H +(DI) +1H) ((DS) 0H +(DI)) ((DS) 0H +(DI) +1H) ((DS) 0H +(DI)) 7788H |
|
r1, r2 |
XOR DX,SI |
(DX) (DX) (SI) |
|
r, mem |
XOR CX,[BX+SI] |
(CX) (CX) ((DS) 0H +(BX) +(SI) +1H) ((DS) 0H +(BX) +(SI)) |
|
mem, r |
XOR [DI+0AAH],BL |
((DS) 0H +(DI) +AAH) ((DS) 0H +(DI) +AAH) (BL) |
2.3. Deplasari si rotatii
|
Deplasare stanga |
OF DF IF TF SF ZF AF PF CF |
|
|
SAL | SHL |
logica sau |
x x x ? x x |
|
s,nrcel |
aritmetica |
Descrierea formala a semanticii
|
Operanzi |
Exemple |
|
r, 1 |
SHL BX,1 |
|
r, CL |
SAL DX,CL |
|
mem, 1 |
SHL [BX+SI],1 |
|
mem, CL |
SHL [DI+10H],CL |
while nrcel do
(CF) (s)msb
(s) (s) * 2
(s)lsb
nrcel nrcel - 1
if nrcel = 1 then
if (s)msb (CF) then
(OF)
else (OF)
else (OF) nedeterminat .
|
Deplasare dreapta |
OF DF IF TF SF ZF AF PF CF |
|
|
SHR s, nrcel |
logica |
x x x ? x x |
Descrierea formala a semanticii
|
Operanzi |
Exemple |
|
r, 1 |
SHR DL,1 |
|
r, CL |
SHR BX,CL |
|
mem, 1 |
SHR [DI],1 |
|
mem, CL |
SHR [BP+SI+4H],CL |
while nrcel do
(s)msb
(s) (s) div 2
(CF) (s)lsb
nrcel nrcel - 1
if nrcel = 1 then
if (s)msb (s)msb-1 then
(OF)
else (OF)
else (OF) nedeterminat .
|
Deplasare dreapta |
OF DF IF TF SF ZF AF PF CF |
|
|
SAR s, nrcel |
aritmetica |
x x x ? x x |
Descrierea formala a semanticii este
|
Operanzi |
Exemple |
|
r, 1 |
SAR BH,1 |
|
r, CL |
SAR AX,CL |
|
mem, 1 |
SAR [BX],1 |
|
mem, CL |
SAR [BP+SI],CL |
similara cu cea a instructiunii
precedente (singura deosebire fiind ca msb trebuie sa fie pastrat, iar OF este resetat si daca nrcel
|
OF DF IF TF SF ZF AF PF CF |
||
|
ROL s, nrcel |
Rotatie stanga |
x x |
Descrierea formala a semanticii
|
Operanzi |
Exemple |
|
r, 1 |
ROL SI,1 |
|
r, CL |
ROL DX,CL |
|
mem, 1 |
ROL [BX+DI],1 |
|
mem, CL |
ROL [BP+100H],CL |
while nrcel do
(s) (s) * 2
(CF) (s)msb
(s)lsb (s)msb
nrcel nrcel - 1
if nrcel = 1 then
if (s)msb (CF) then
(OF)
else (OF)
else (OF) nedeterminat .
|
OF DF IF TF SF ZF AF PF CF |
||
|
ROR s, nrcel |
Rotatie dreapta |
x x |
Descrierea formala a semanticii:
|
Operanzi |
Exemple |
|
r, 1 |
ROR AX,1 |
|
r, CL |
ROR DX,CL |
|
mem, 1 |
ROR [BP],1 |
|
mem, CL |
ROR [1000H],CL |
while nrcel do
(s) (s) div 2
(s)msb (s)lsb
(CF) (s)lsb
nrcel nrcel - 1
if nrcel = 1 then
if (s)msb (s)msb-1 then
(OF)
else (OF)
else (OF) nedeterminat .
|
Rotatie stanga |
OF DF IF TF SF ZF AF PF CF |
|
|
RCL s, nrcel |
cu transport |
x x |
Descrierea formala a semanticii este
asemanatoare cu rotatia stanga simpla.
|
Operanzi |
Exemple |
|
r, 1 |
RCL CX,1 |
|
r, CL |
RCL AL,CL |
|
mem, 1 |
RCL [SI],1 |
|
mem, CL |
RCL [BX+DI],CL |
|
Rotatie dreapta |
OF DF IF TF SF ZF AF PF CF |
|
|
RCR s,nrcel |
cu transport |
x x |
Descrierea formala a semanticii este
asemanatoare cu a celorlalte rotatii.
|
Operanzi |
Exemple |
|
r, 1 |
RCR AX,1 |
|
r, CL |
RCR BX,CL |
|
mem, 1 |
RCR [BP+DI],1 |
|
mem, CL |
RCR [BX],CL |
2.4. Salturi propriu-zise neconditionate
|
Salt propriu-zis, |
OF DF IF TF SF ZF AF PF CF |
|
|
JMP adr |
neconditionat | |
Descrierea formala a semanticii, in functie de modul de adresare folosit:
a) Salt cu adresare absoluta (directa) intersegment
JMP adr32 ; (CS) adr32h
(IP) adr32l
Sau, punand in evidenta faptul ca adresa completa face parte din formatul instructiunii
(CS) ((CS) 0H+(IP)+4) ((CS) 0H+(IP)+3)
(IP) ((CS) 0H+(IP)+2) ((CS) 0H+(IP)+1)
b) Salt cu adresare relativa:
JMP disp8|disp16 ; (IP) (IP) + disp8|disp16
Deplasamentul face parte din formatul instructiunii curente
c) Salt cu adresare in registru sau indirecta in memorie, intrasegment
JMP r16 | mem16 ; (IP) (r16) | (mem16)
d) Salt cu adresare indirecta in memorie, intersegment
JMP mem32 ; (CS) (mem32)h
(IP) (mem32)l
|
Operanzi |
Exemple |
Descrierea formala a semanticii |
|
adr32 |
JMP ET-IN-ALT-SEG |
(CS) ((CS) 0H+(IP)+4) ((CS) 0H+(IP)+3) (IP) ((CS) 0H+(IP)+2) ((CS) 0H+(IP)+1) |
|
disp16 |
JMP ET-IN-SEG |
(IP) (IP) + + ((CS) 0H+(IP)+2) ((CS) 0H+(IP)+1) |
|
disp8 |
JMP FOARTE-APROAPE |
(IP) (IP) + ((CS) 0H+(IP)+1) |
|
r16 |
JMP BX |
(IP) (BX) |
|
mem* |
JMP [BX] |
(IP) ((DS) 0H+(BX)+1) ((DS) 0H+(BX)) |
|
mem** |
JMP [DI] |
(CS) ((DS) 0H+(DI)+3) ((DS) 0H+(DI)+2) (IP) ((DS) 0H+(DI)+1) ((DS) 0H+(DI)) |
* salt cu adresare indirecta definit cu directiva de asamblare ca salt intra-segment;
** salt cu adresare indirecta definit cu directiva de asamblare ca salt inter-segment.
2.5. Salturi conditionate
|
Salt propriu-zis, |
OF DF IF TF SF ZF AF PF CF |
|
|
Jxx disp8 |
neconditionat | |
Descrierea formala a semanticii:
if conditie then
(IP) (IP) + disp8 sau, detaliat:
(IP) (IP) + ((CS) 0H+(IP)+1)
Adunarea se face prin extensie cu semn la un numar de16 biti.
|
Mnemonica |
Cond. testata |
Interpretare |
|
JA | JNBE |
(CF)sau(ZF)=0 |
Salt daca 'peste' daca 'nu sub sau egal' |
|
JAE|JNB|JNC |
(CF)=0 |
Salt daca 'peste sau egal' daca 'nu sub' daca 'nu exista transport' |
|
JB|JNAE|JC |
(CF)=1 |
Salt daca 'sub" daca 'nu peste sau egal" daca "exista transport' |
|
JBE | JNA |
(CF)sau(ZF)=1 |
Salt daca 'sub sau egal daca 'nu peste' |
|
JE | JZ |
(ZF)=1 |
Salt daca 'egal' daca ' zero' |
|
JG | JNLE |
((SF)A(OF))sau(ZF)=0 |
Salt daca 'mai mare' daca 'nu mai mic sau egal' |
|
JGE | JNL |
(SF)A(OF)=0 |
Salt daca 'mai mare sau egal ' daca 'nu mai mic' |
|
JL | JNGE |
(SF)A(OF)=1 |
Salt daca 'mai mic' daca 'nu mai mare sau egal' |
|
JLE | JNG |
((SF)A(OF))sau(ZF)=1 |
Salt daca 'mai mic sau egal ' daca 'nu mai mare ' |
|
JNE | JNZ |
(ZF)=0 |
Salt daca 'ne-egal' daca 'non-zero' |
|
JNO |
(OF)=0 |
Salt daca 'nu exista depasire' |
|
JNP | JPO |
(PF)=0 |
Salt daca ' non- paritate' daca 'impar' |
|
JNS |
(SF)=0 |
Salt daca 'non-semn' daca 'pozitiv' |
|
JO |
(OF)=1 |
Salt daca 'exista depasire' |
|
JP | JPE |
(PF)=1 |
Salt daca 'exista paritate' daca 'par' |
|
JS |
(SF)=1 |
Salt daca 'exist semn' |
NOTA: - conditiile care se traduc cu 'mai mare' sau 'mai mic' se refera la operatii asupra unor numere cu semn;
- exprimarile 'sub' sau 'peste' se aplica operatiilor asupra unor numere fara semn.
3. Indicatii importante cu privire la operatiile aritmetice
Microprocesorul este un automat care executa anumite operatii predefinite. Acesta nu poate sa cunoasca semnificatia operatorilor si rezultatelor; de aceea, daca programatorul nu controleaza foarte strict aceste semnificatii, este foarte probabil ca rezultatele obtinute sa fie eronate. Din acest motiv:
- trebuie sa se cunoasca modul de reprezentare a numerelor in memorie: intregi cu sau fara semn, ZCB impachetat, ASCII, cu virgula fixa (pentru reprezentarea numerelor fractionare);
- trebuie sa se faca estimarea marimii rezultatelor si operatorilor, pentru a se putea alege lungimea locatiilor de memorie necesara pentru stocarea lor;
- trebuie sa se cunoasca foarte bine modul de afectare a fanioanelor in urma unei operatii, deoarece salturile conditionate se fac relativ la acestea si, in plus, fanioanele ne pot da indicatii asupra corectitudinii executiei.
4. Modul de lucru recomandat
Lucrarea de laborator a fost structurata in doua parti. In prima parte sunt date doua programe care nu au un scop anume, fiind alcatuite dintr-o insiruire de instructiuni, grupate dupa anumite criterii, care ilustreaza tipul de operatii de interes. Primul program se ocupa de instructiunile aritmetice si logice, iar al doilea, de salturile conditionate si neconditionate.
Cand se editeaza acest program, se vor ignora comentariile. Acestea vor trebui urmarite cand se va face rularea pas cu pas a programelor, deoarece explica semnificatia fiecarei instructiuni. De asemenea, se indica ce registre si ce zone de memorie se modifica.
A doua parte a lucrarii contine doua aplicatii propriu-zise care isi propun sa ilustreze rezolvarea unor probleme reale. Aici se va acorda atentie atat algoritmului cat si sintaxei instructiunilor.
5. Desfasurarea lucrarii
5.1. Se lanseaza turbo-asamblorul TASMB si se editeaza textul programului 1, fara comentarii.
5.2. Se salveaza programul sursa pe disc, cu un nume oarecare, apoi se activeaza O) optiunea F8 - COM FILE si se asambleaza.
5.3. Se vizualizeaza lista de simboluri S) si se noteaza adresele de memorie ale celor patru operanzi.
5.4. Se paraseste TASMB Q) si se lanseaza AFD. Se incarca L programul salvat anterior cu extensia COM si se ruleaza pas cu pas, urmarindu-se, in paralel, indicatiile date in comentarii.
5.6. Se repeta punctele 5.1.-5.4. pentru programele 2, 3 si 4.
Programul 1
Observatie: La toate instructiunile de prelucrare a datelor, trebuie sa se urmareasca cum sunt afectate fanioanele si sa se verifice aceasta confruntandu-le cu explicatiile date in memoriul de instructiuni.
org 100h
mov ax,cs
mov ds,ax
conv: mov al,opb1
mov bl,opb2
xor ah,ah ;AH=0
xor bh,bh ;BH=0
cbw ;converteste
tipul operandului din
;din byte in word, prin extinderea ;bitului de semn
xchg ax,bx
cbw
compl: mov ax,bx
neg bx ;complementare fata de 2
not ax ;negare logica (bit cu bit)
;operatiile NEG si NOT se efectueaza ;asupra aceleasi valori. Diferenta
;intre AX si BX ilustreaza efectul ;diferit al celor doua operatii
inc bx ;se urmaresc registrul BX si zona
dec opb2 ;de memorie de la adresa "opb2"
comp: xor cx,cx ;CF=0
cmp opw2,24h ;comparare prin scadere: opw2-24h
test opw2,20h ;comparare prin SI logic: opw2 AND 20h
cmp opw2,23h ;in general, dupa instructiunile
cmp opw2,20h ;de comparare, urmeaza un salt ;conditionat. De aceea trebuie urmarit
;modul in care sunt afectate fanioanele
;si diferenta dintre CMP si TEST
deplas: inc opb2
mov dx,opw1
mov cl,3
shl dx,1 ;deplasare logica stinga cu o pozitie
shl dx,cl ;si cu 3 pozitii
mov dl,opb1
shr dl,1 ;deplasare logica dreapta cu o pozitie
sal dl,1 ;se remarca diferenta intre deplasarile
;aritmetice si cele logice si intre
sar dl,1 ;deplasarile cu o pozitie si cele
sar dl,cl ;cu mai multe pozitii folosind CL
rotatii: mov al,opb2
inc cl
rol al,1 ;se remarca diferenta dintre deplasari
;si rotatii
ror al,1
xor si,si ;CF=0
rcl al,1
rcr al,1 ;se remarca diferenta dintre rotatiile
rcr al,cl ;'simple' si cele prin intermediul lui ;CF
op_log: and al,00000010b;mai intii se estimeaza
or al,10000000b;rezultatele celor doua operatii
;si apoi se verifica rezultatul
adun: mov bx,opw1 ;aceasta secventa simuleaza o adunare
add bl,byte ptr opw2
;pe 16 biti din adunari pe 8 biti
adc bh,byte ptr opw2+1
mov ax,bx ;mai intii se estimeaza rezultatul
daa ;in cele doua cazuri: operatori priviti
;ca intregi cu semn, si fara semn.
;se observa ca rezultatul obtinut
;inainte de DAA, este eronat daca
;operanzii sunt considerati fara semn
;(apare o depasire), sau este corect ;daca sunt considerati cu semn.
scad: mov dx,opw1 ;secventa de instructiuni simuleaza
;o scadere pe 16 biti,
sub dl,low opw2
;din scaderi pe 8 biti.
sbb dh,high opw2
mov ax,dx ;se evalueaza rezultatele in cele doua
;cazuri specificate la adunare,
das ;apoi se verifica corectitudinea lor,
;inainte de DAS
imult: mov ax,opw1 ;se remarca diferenta dintre mul opw2 ;rezultatele obtinute in (DX)|(AX)
mov ax,opw1 ;pentru cele doua cazuri de inmultire.
imul opw2 ;pentru aceasta, rezultatul obtinut
aam ;dupa prima inmultire trebuie notat
impart: mov ax,opw1 ;se remarca diferenta dintre cele
mov dx,0 ;doua tipuri de impartire, observand
div opw2 ;diferentele intre rezultatele
mov ax,opw2 ;obtinute in AH si AL. Este bine
and dx,0 ;sa se observe necesitatea de a scrie
idiv opw1 ;0 in DX, inainte de impartire
int 20h
opw1: dw 0fffdh ;65533 valoare fara semn
;-3 valoare cu semn
opw2: dw 23h ;35 valoare cu sau fara semn
opb1: db 0feh ;254 valoare fara semn
;-2 valoare cu semn
opb2: db 23h ;35 valoare cu sau fara semn.
Programul 2
Observatii:
In programele scrise in limbaj de asamblare, datele se declara in general la sfarsit. Daca se fac declaratiile la inceput, procesorul va interpreta aceste date ca pe niste instructiuni. Efectul acestora este greu de prevazut. Pentru a evita acest lucru este necesar ca programul sa inceapa cu un salt neconditionat la prima instructiune.
In programul urmator, pentru a usura rularea pas cu pas, dupa fiecare salt conditionat se revine la instructiunea imediat urmatoare, cu ajutorul unui salt neconditionat indirect prin BX. De aceea, se poate observa in program ca, inainte de salturile conditionate, se pregateste registrul BX
org 100h
jmp start
op1: db 0feh ; valoare fara semn 253
; valoare cu semn -2
op2: db 3
start: mov ax,cs
mov ds,ax
; SALTURI CONDITIONATE
mov al,op1
lea bx,adr1
cmp al,op2 ;in functie de starea fanioanelor
;dupa CMP se estimeaza, mai intii,
ja fin ;efectul celor doua instructiuni
;JA si JG, iar apoi se verifica
adr1: jg fin
mov al,op2 ;in functie de starea fanioanelor
lea bx,adr2 ;dupa CMP se estimeaza, mai intii,
cmp al,op1 ;efectul celor doua instructiuni
jb fin ; JB si JL, iar apoi se verifica
adr2: jl fin
lea bx,adr3
cmp al,op2
jz fin
adr3: lea bx,adr4
and al,0feh
jnp fin
adr4: jp fin
jmp ies ; SALT NECONDITIONAT
fin: jmp bx ; SALT INDIRECT
ies: int 20h
end
Programul 3
Programul simuleaza o inmultire pe 16 biti din inmultiri pe 8 biti. Rezultatul, care poate avea maximum 32 de biti, se memoreaza in cuvintele de memorie 'hrez' si 'lrez'.
Algoritmul de calcul este urmatorul:
Un numar de 16 biti se poate reprezenta astfel:
XYZTh = XY 256 + ZT
(XY este continutul octetului 'high' iar ZT este continutul octetului 'low').
Atunci:
ABCDh XYZTh=AB XY 256 + (AB ZT+XY CD) 256 + CD ZT.
Operatiile de inmultire cu puteri ale lui doi se fac prin deplasari. La sfarsitul programului se face direct inmultirea pe 16 biti a celor doi operanzi, pentru a putea verifica corectitudinea algoritmului.
org 100h
start: mov al,byte ptr op1+1
mul byte ptr [op2+1]
mov hrez,ax
mov al,byte ptr op1+1
mul byte ptr op2
mov dx,ax
mov cl,8
sal ax,cl
mov cl,8
shr dx,cl
add lrez,ax
adc hrez,0
add hrez,dx
mov al,byte ptr op2+1
mul byte ptr op1
mov dx,ax
mov cl,8
shl ax,cl
mov cl,8
shr dx,cl
add lrez,ax
adc hrez,0
add hrez,dx
mov al,byte ptr op1
mul byte ptr op2
add lrez,ax
adc hrez,0
mov ax,lrez
mov dx,hrez
mov ax,op1
mul op2
int 20h
op1: dw 300
op2: dw 200
lrez: dw ?
hrez: dw ?s
end
Programul 4
Se considera un sir de maximum 16 cuvinte care ar trebui sa fie identice intre ele si egale cu o valoare de referinta 'ref'. Algoritmul isi propune sa gaseasca toate elementele diferite si sa specifice adresa lor.
Zona de memorie de la adresa 'nrdif' va contine numerele din sir diferite de referinta, iar 'poz' adresele acestor numere.
org 100h
mov ax,cs
mov ds,ax
lea di,sir
cld
mov bx,0ffffh
mov ax,ref
mov cx,(nrdif-sir)/2
et1: repz scasw
jz fin
inc bx
mov dx,[di-2]
shl bx,1
mov [nrdif+bx],dx
mov dx,di
sub dx,2
mov [poz+bx],dx
shr bx,1
jmp et1
fin: inc bx
int 20h
sir dw 1,1,2,3,1,1,1,1,4,1,5,1,1,1,4,1
nrdif dw 16 dup (0ffffh)
poz dw 16 dup (0ffffh)
ref equ 1
end
|
Politica de confidentialitate | Termeni si conditii de utilizare |
Vizualizari: 1210
Importanta: 
Termeni si conditii de utilizare | Contact
© SCRIGROUP 2024 . All rights reserved
