asm2

Adrese
Orice adresa este formata din doua componente: segment si offset (deplasament), notatia uzuala
fiind segment:offset. Pentru partea de offset exista mai multe variante:
Constanta numerica. Exemplu: [100]
Valoarea unui registru general pe 32 biti. Exemplu: [EAX] (se poate scrie si cu litere mici)
Suma dintre valoarea unui registru general pe 32 biti si o constanta. Exemplu: [EBX+5]
Suma a doi registri generali pe 32 biti. Exemplu: [ECX+ESI]
Combinatia celor 2 variante anterioare: suma a 2 registri si a unei constante. Exemplu:
[EDX+EBP+14]
Suma a 2 registri, dintre care unul inmultit cu 2, 4, sau 8, la care se poate aduna o constanta.
Exemple: [EAX+EDI*2], [ECX+EDX*4+5]
Instructiunea de atribuire
Instructiuni de adunare
Instructiuni de scadere
Instructiuni pe biti
Instructiunea de atribuire: mov
Sintaxa: mov destinatie, sursa
Efect: pune in destinatie valoarea din sursa.
Destinatia, respectiv sursa, pot fi:
registru, registru. Exemple: mov eax, ebx;, mov al, bh;
registru, adresa de memorie. Exemplu: mov bl, [eax];
adresa de memorie, registru. Exemplu: mov [esi], esx;
registru, constanta numerica. Exemplu: mov ah, 0;
memorie, constanta numerica. Exemplu: mov [eax], 3;
Ex. 1:
#i ncl ude <st di o. h>
voi d mai n( ) {
_asm{
mov eax, 0;
mov ah, 1;
}
}
Ex. 2:
#i ncl ude <st di o. h>
voi d mai n( ) {
i nt i = 0;
_asm{
mov ax, i ;
}
}
Dimensiunea operanzilor:
1 of 19
mov byt e pt r [ eax] , 5; / / af ect eaza 1 oct et
mov wor d pt r [ eax] , 5; / / af ect eaza 2 oct et i
mov dwor d pt r [ eax] , 5; / / af ect eaza 4 oct et i ( doubl e wor d)
Instruciunea add
Sintaxa: add op1, op2
Efect: op1 = op1 + op2
Ex. 1:
#i ncl ude <st di o. h>
voi d mai n( ) {
i nt a=10;
_asm {
add a, 5
}
pr i nt f ( " %d\ n" , a) ;
}
Ex. 2:
#i ncl ude <st di o. h>
voi d mai n( ) {
_asm {
mov eax, 0xFFFFFFFF;
add eax, 2; / / r ezul t at ul est e 0x100000001; necesi t a 33 bi t i .
/ / set ar e car r y
mov eax, 0;
mov ax, 0xFFFF;
add ax, 2; / / doar ax se modi f i ca!
/ / desi r ezul t at ul est e 0x10001,
/ / al 17- l ea bi t di n eax nu se modi f i ca.
/ / se set eaza car r y

}
pr i nt f ( " %d\ n" , c) ;
}
Adunarea cu transport: adc (add with carry)
Sintaxa: adc op1, op2
Efect: op1 = op1 + op2 + carry
Ex.1 :
#i ncl ude <st di o. h>
voi d mai n( )
{
/ * Repr ezent amun nr pe 64 bi t i f ol osi nd un vect or de 2 i nt r egi */
unsi gned a[ 2] ={0x80000001, 1}, b[ 2] ={0x80000001, 1}, c[ 2] ={0, 0};
/ * Nr r epr ezent at de a est e a[ 1] * 2^32 + a[ 0] ( adi ca vomconcat ena
r epr ezent ar i l e) : 0x180000001 */
_asm {
/ / vomaduna " pe bucat i " i ncepand cu par t ea cea mai nesemni f i cat i va
/ / ( asa cumi n baza 10, adunar ea nr de mai mul t e ci f r e i ncepe cu uni t at i l e)
mov eax, a
add eax, b
/ / punem i n c[ 0] r ezul t at ul par t i al
mov c, eax;

/ / e posi bi l sa avem t r anspor t !
/ / vomf ol osi deci adc pent r u par t ea cea mai semni f i cat i va, pent r u a l ua i n
/ / consi der ar e si t r anspor t ul
mov eax, a[ 4]
adc eax, b[ 4]
mov c[ 4] , eax
/ / a[ 4] , b[ 4] , c[ 4] i n l oc de a[ 1] , . . . pent r u ca t r ebui e sa sar i m pest e
2 of 19
/ / 4 oct et i pent r u a accesa ur mat or ul numar i nt r eg
}
pr i nt f ( " %x%08x\ n" , c[ 1] , c[ 0] ) ;
}
Instruciunea sub
Sintaxa: sub op1, op2
Efect: op1 = op1 - op2
Ex. 1:
#i ncl ude <st di o. h>
voi d mai n( )
{
i nt a=10, b=14;
_asm {
mov eax, b
sub a, eax
}
pr i nt f ( " %d\ n" , a) ;
}
Scderea cu imprumut: sbb (subtract, borrow)
Sintaxa: sbb op1, op2
Efect: op1 = op1 - op2 - carry
Instruciuni pe bii
Instruciuni booleene: AND, OR, XOR, NOT
Sintaxa:
and destinatie, sursa
or destinatie, sursa
xor destinatie, sursa
not destinatie
Instruciunileand, or, xor modific indicatorul ZERO
Utilitateaprincipalaacestorinstruciuniesteinlucrulcumti.Deexemplu,dacneintereseaz
valoareabituluial5-leadinregistrulax,estesuficientsseexecuteand intre axivaloarea(scrisa
binar)0000000000010000(aceastasenumetemasc).Rezultatuloperaieivafi0(iarindicatorul
ZEROvadeveni1)dacbitulal5-leadinaxarevaloarea0,respectivvafidiferitde0(iarindicatorul
ZEROvadeveni0)dacbitulal5-leadinaxarevaloarea1.
Dezavantajulabordriidemaisusesteacelacinstruciuneaandmodificvaloareaprimuluioperand,
plasindacolorezultatuloperaiei.
Instruciuneatestareacelaiefectcaiand(executANDintrebiiicelordoioperanzi,modificlafel
indicatorul ZERO), dar nu altereaz valoarea primului operand. De exemplu:
t est ax, 0x0010 / / bi nar : 0000000000010000
modificindicatorulZEROcai
3 of 19
and ax, 0x0010
fraalteravaloareadinax.
asm3
Arhitectura Calculatoarelor
Cuprins
nmulireaimprireanlimbajdeasamblare
Instruciunipebii:(2)Instruciunidedeplasare
nmulirea i mprirea n limbaj de asamblare
nmulirea
Instruciunea mul nmulire de numere fr semn
Sintaxa: mul op
Efect: destinatie_implicita = operator_implicit * op
Operaiadenmulireesteooperaiebinar.Dinmomentcelainstruciuneamulseprecizeazunsingur
operand,esteevidentccelalaltoperandvafiimplicit.Operandulimplicitdepindededimensiunea
operandului explicit op(dupcumtimidelacelelalteinstruciunistudiate,operanziitrebuiesaib
aceeaidimensiune).ntabeluldemaijossuntprecizaioperanziiimpliciipentrufiecaredin
dimensiunile posibile ale operandului explicit.
nplus,trebuieobservatfaptulcreprezentarearezultatuluioperaieidenmulirepoateavealungime
dublfadelungimeaoperanzilor.Deexemplu,nmulindurmtoarele2numerereprezentatepecte8
bii,obinemunrezultatreprezentatpe16bii:
10110111 *
11010010
- - - - - - - - - - - - - - - -
0
10110111
10110111
10110111
10110111
- - - - - - - - - - - - - - - -
1001011000011110
Decidimensiuneadestinaieiimplicitetrebuiesfiedubluldimensiuniioperanzilor.
Tabeluldemaijosprezintoperanziiimpliciiidestinaiileimplicitepentrudiverseledimensiuniale
operandului implicit:
Dimensiune operand explicit Operand implicit Destinaie implicit
1 octet al ax
2 octei ax (dx, ax)
4 octei eax (edx, eax)
Operandul implicit nu poate fi constant numeric:
4 of 19
mul 10; / / EROARE
mul byt e pt r 2; / / EROARE
Eltrebuiesfieoriunregistru de date (al, ebx, ...), ori o adres de memorie.Dacadresadememorie
nuestedatprinnumelesimbolic(deexemplu,numeleuneivariabiledeclaratenprogramulCce
ncapsuleazcodulasm),ciprinmoduriledeadresarediscutateanterior,trebuieprecizatdimensiunea
nocteiazoneidememoriececoninerespectivuloperandexplicit,pentruaseputeastabilioperandul
implicitidestinaiaimplicit.
De exemplu:
mul byte ptr [ebp - 4]:operandulexplicitseaflnmemorielaadresa[ebp-4]iaredimensiunea
de1octet(valoareaefectivesteceadinoctetuldelaaceastaadresa)
mul word ptr [ebp - 4]:operandulexplicitseafllaadresa[ebp-4]iaredimensiuneade2octei
(valoareaefectivesteceacompusdinprimii2octeidelaaceastaadresa)
mul dword ptr [ebp - 4]:operandulexplicitseafllaadresa[ebp-4]iaredimensiuneade4
octei(valoareaefectivesteceacompusdinprimii4octeidelaaceastaadresa)
Cteva exemple:
linia de cod mul bl va avea urmatorul efect:
secalculeazrezultatulnmuliriidintrealibl (bl are dimensiunea de 1 octet, deci
operandulimplicitlanmulireesteal)
acest rezultat se pune n ax(careestedestinaiaimplicitpentrunmuliricuoperandul
explicit op de 1 octet
Mai concret, mul bl <=> ax = al * bl
linia de cod mul bx va avea urmatorul efect:
secalculeazrezultatulnmuliriidintreaxibx (bxaredimensiuneade2octei,deci
operandulimplicitlanmulireesteax)
acest rezultat se pune n (dx,ax)astfel:primii2octei(ceimaisemnificativi)dinrezultatvor
fiplasaindx,iarultimii2octei(ceimaipuinsemnificativi)nax
rezultatulnmuliriieste,defapt,dx*2
16
+ ax
Desigur,acestrezultatpe4octeiarfincputneax.Sefolosescnsregitrii(dx,ax) pentru
compatibilitateacumainilemaivechi,pe16bii.
Exemplu de cod:
#i ncl ude <st di o. h>
voi d mai n( ) {
_asm {
mov ax, 60000; / / i n baza 16: EA60
mov bx, 60000; / / i n baza 16: EA60
mul bx; / / r ezul t at ul i nmul t i r i i est e 3600000000;
/ / i n baza 16: D693A400, pl asat ast f el :
/ / i n r egi st r ul dx - par t ea cea mai semni f i cat i va: D693
/ / i n r egi st r ul ax - par t ea cea mai put i n semni f i cat i va: A400
}
}
linia de cod mul ebx va avea urmatorul efect:
secalculeazrezultatulnmuliriidintreeaxiebx (ebxaredimensiuneade4octei,deci
operandulimplicitlanmulireesteeax)
acest rezultat se pune n (edx,eax)astfel:primii4octei(ceimaisemnificativi)dinrezultat
vorfiplasainedx,iarultimii4octei(ceimaipuinsemnificativi)neax
rezultatulnmuliriieste,defapt,edx*2
32
+ eax
Exemplu de cod:
5 of 19
#i ncl ude <st di o. h>
voi d mai n( ) {
_asm {
mov eax, 60000; / / i n baza 16: 0000EA60
mov ebx, 60000; / / i n baza 16: 0000EA60
mul ebx; / / r ezul t at ul i nmul t i r i i est e 3600000000;
/ / i n baza 16: D693A400, pl asat ast f el :
/ / i n edx - par t ea cea mai semni f i cat i va: 00000000
/ / i n eax - par t ea cea mai put i n semni f i cat i va: D693A400
}
}
Instruciunea imul nmulire de numere cu semn (Integer MULtiply)
Sintaxa: imul op
Dupcumamprecizatmaisus,lainstruciuneamuloperanziisuntconsiderainumerefrsemn.
Aceastanseamncselucreazcunumerepozitive,iarbitulcelmaisemnificativdinreprezentareeste
primacifrareprezentriibinare,nubituldesemn.
Pentruoperaiidenmulirecareimplicnumerenegativeexistinstruciuneaimul(estenevoiededou
instruciunidistinctedeoarece,spredeosebiredeadunaresauscdere,agoritmuldenmulireestediferit
la numerele cu semn). Ceea s-a prezentat la mulestevalabilipentruimul.Diferenaesteaceeac
numerele care au bitul cel mai semnificativ 1 sunt considerate numere negative, reprezentate n
complementfade2.
Exemplu:
voi d mai n( ) {
_asm {
mov ax, 0xFFFF;
mov bx, 0xFFFE;
mul bx; / / r ezul t at ul i nmul t i r i i numer el or FARA SEMN:
/ / 65535 * 65534 = 4294770690;
/ / i n baza 16: FFFD0002, pl asat ast f el :
/ / i n dx - par t ea cea mai semni f i cat i va: FFFD
/ / i n ax - par t ea cea mai put i n semni f i cat i va: 0002
mov ax, 0xFFFF;
mov bx, 0xFFFE;
i mul bx; / / r ezul t at ul i nmul t i r i i numer el or CU SEMN:
/ / - 1 * - 2 = 2;
/ / i n baza 16: 00000002, pl asat ast f el :
/ / i n dx - par t ea cea mai semni f i cat i va: 0000
/ / i n ax - par t ea cea mai put i n semni f i cat i va: 0002
}
}
Exerciiu:
Fieurmtorulprogramcarecalculeazfactorialulunuinumr.Ssenlocuiascliniadecoddin
interiorul buclei for(f=f*i)cuunblocdecodasm,cuobinereaaceluiaiefect.Pentrusimplificare,
vomconsideracrezultatulnudepete4octei.
#i ncl ude <st di o. h>
voi d mai n( ) {
unsi gned i nt n = 10, i , f =1;
f or ( i =1; i <=n; i ++) {
f = f * i ;
}
pr i nt f ( " %u\ n" , f ) ;
}
mprirea
Instruciunea div mprire de numere fr semn
6 of 19
Sintaxa: div op
Efect: cat_implicit, rest_implicit = deimpartit_implicit : op
Instruciuneadivcorespundeoperaieidemprirecurest.
Cailanmulire,operandulimplicit(dempritul)idestinaiaimplicit(ctulirestul)depindde
dimensiunea operandului explicit op(mpritorul):
Dimensiune operand explicit
(mpritor)
Demprit Ct Rest
1 octet ax al ah
2 octei (dx, ax) ax dx
4 octei (edx, eax) eax edx
(Aseobservasimilaritateacuinstruciuneadenmulire.)
ntoatecazurile,ctulestedepusnjumtateaceamaipuinsemnificativadempritului,iarrestuln
ceamaisemnificativ.Acestmoddeplasarearezultatelorpermitereluareaoperaieidenmprirenn
bucl,dacestecazul,framaifinevoiedeoperaiidetransfersuplimentare.
Analogcunmulirea,operandulexplicit(mpritorul)poatefiunregistrusauolocaiedememorie,dar
nuoconstant:
di v ebx
di v cx
di v dh
di v byt e pt r [ . . . ]
di v wor d pt r [ . . . ]
di v dwor d pt r [ . . . ]
di v byt e pt r 10 / / er oar e
Operaiademprireridicoproblemcarenusentlnetenaltepri:mprireala0:
#i ncl ude <st di o. h>
voi d mai n( ) {
_asm {
mov eax, 1
mov edx, 1
mov ebx, 0
di v ebx
}
}
Programulvasemnalaoeroarelaexecuie(integerdividebyzero)ivafiterminatforat.
Efectundurmtoareamodificare:
#i ncl ude <st di o. h>
voi d mai n( ) {
_asm {
mov eax, 1
mov edx, 1
mov ebx, 1 / / 1 i n l oc de 0
di v ebx
}
}
seobineoalteroarelaexecuie:integeroverflow.
Motivulesteacelacsencearcmprireanumrului0x100000001la1,ctulfiind0x100000001.
Acestcttrebuiedepusnregistruleax,nsvaloarealuidepetevaloareamaximcepoatefipusn
acestregistru,adic0xFFFFFFFF.Maiconcret,ncazulncarectulnuncapenregistrul
corespunztor,seobineeroare:
32 32
7 of 19
(edx*2 +eax)/ebx2 <=>
edx*2
32
+eaxebx*2
32
<=>
eax(ebx-edx)*2
32
<=>
ebx edx
Cualtecuvinte,vomobinecusiguraneroaredacmpritorulestemaimicsauegalcuparteacea
maisemnificativadempritului.Pentruaevitaterminareaforataprogramului,trebuieverificat
aceastsituaienaintedeefectuareampririi.
Instruciunea idiv mprire de numere cu semn
Sintaxa: idiv op
idivfuncioneazcaidiv,cudiferenacnumerelecareaubitulcelmaisemnificativ1suntconsiderate
numerenegative,reprezentatencomplementfade2.
Exemple de cod
#i ncl ude <st di o. h>
voi d mai n( ) {
_asm {
mov ax, 35;
mov dx, 0; / / nu t r ebui e ui t at a i ni t i al i zar ea l ui ( e) dx!
/ / ( i n gener al , i ni t i al i zar ea par t i i cel ei mai
/ / semni f i cat i ve a dei mpar t i t ul ui )
mov bx, 7;
di v bx; / / r ezul t at : ax devi ne 5, adi ca 0x0005 ( cat ul )
/ / dx devi ne 0 ( r est ul )

mov ax, 35;
mov dx, 0;
mov bx, 7
i di v bx / / acel asi ef ect , deoar ece numer el e sunt pozi t i ve


mov ax, - 35; / / i n hexa ( compl ement f at a de 2) : FFDD
mov dx, 0;
mov bx, 7
di v bx / / dei mpar t i t ul est e ( dx, ax) , adi ca 0000FFDD
/ / i n baza 10: 65501
/ / r ezul t at : ax devi ne 0x332C, adi ca 13100 ( cat ul )
/ / dx devi ne 0x0001 ( r est ul )

mov ax, - 35; / / i n hexa ( compl ement f at a de 2) : FFDD
mov dx, 0;
mov bx, 7
i di v bx / / dei mpar t i t ul est e ( dx, ax) , adi ca 0000FFDD
/ / est e un mumar pozi t i v, adi ca, i n baza 10, 65501
/ / r ezul t at : ax devi ne 0x332C, adi ca 13100 ( cat ul )
/ / dx devi ne 0x0001 ( r est ul )
/ / ( ef ect ul est e acel asi ca l a secvent a de mai sus)

mov ax, - 35; / / i n hexa ( compl ement f at a de 2) : FFDD
mov dx, - 1; / / i n hexa ( compl ement f at a de 2) : FFFF
mov bx, 7
i di v bx / / dei mpar t i t ul est e ( dx, ax) , adi ca FFFFFFDD
/ / - numar negat i v, r epr ezent at i n compl ement f at a de 2
/ / i n baza 10: - 35
/ / r ezul t at : ax devi ne 0xFFF9, adi ca - 5 ( cat ul )
/ / dx devi ne 0 ( r est ul )

mov ax, - 35; / / i n hexa ( compl ement f at a de 2) : FFDD
mov dx, - 1; / / i n hexa ( compl ement f at a de 2) : FFFF
mov bx, 7
di v bx / / dei mpar t i t ul est e ( dx, ax) , adi ca FFFFFFDD
/ / - numar pozi t i v ( deoar ece f ol osi mdi v)
/ / i n baza 10: 4294967261
/ / r ezul t at : EROARE, deoar ece FFFF > 0007,
/ / cat ul ( 613566751, adi ca 2492491F) nu i ncape i n ax

8 of 19
}
}
Exerciiu
Fieurmtorulprogram.Ssenlocuiascliniile4i5cuunblocdecodasm,cuobinereaaceluiai
efect.
1. #i ncl ude <st di o. h>
2. voi d mai n( ) {
3. unsi gned a=500007, b=10, c, d;
4. c=a/ b;
5. d=a%b;
6. pr i nt f ( " %u %u\ n" , c, d) ;
7. }
Registrul FLAGS
Esteunregistrupe16bii(EFLAGSpe32bii),fiecarebitconinndinformaiidespreefectulultimei
operaiiexecutate.Dintreceimaiimportaniindicatori(bii),amintim:
Carry Flag (CY) =ultimulbitdeplasatnafaraoperanduluidestinaie;
Sign Flag (PL) =bitulcelmaisemnificativdinoperanduldestinaie;
Zero Flag (ZR) =1dacoperanduldestinaiedevine0,0altfel.
OverflowFlag(OV)=1dacodepirearitmeticaavutloclaultimaoperaie,0altfel.
Instruciuni de deplasare
Suntinstruciunicarepermitdeplasareabiilorncadruloperanzilorcuunnumrprecizatdepoziii.
Deplasrilepotfiaritmeticesaulogice.Deplasrilearitmeticepotfiutilizatepentruanmulisaumpri
numereprinputerialelui2.Deplasrilelogicepotfiutilizatepentruaizolabiinocteisaucuvinte.
Oilustrareadeplasriilogicelastngacuopoziie:
Instruciunilededeplasaresunt:
shr dest, count
shl dest, count
sar dest, count
sal dest, count
unde:
destsemnificdestinaiaacreivaloarevafimodificat;poatefiregistru sau locaie de memorie:
shl eax, 1
shl dx, 3
shl byte ptr [...], 2
countprecizeazcuctepoziiisefacedeplasarea;poateficonstant numeric sau registrul cl:
shl ebx, cl
Instruciunea shr (SHift Right)
Sintaxa: shr dest, count
Efect:deplasarealadreaptaabiilordindestcunumruldepoziiiprecizatdecount; completarea la
stngacu0;plasareanCarryaultimuluibitieit.
9 of 19
Exemplu:
mov bl , 33; / / bi nar : 00100001
shr bl , 3; / / bl devi ne 00000100
/ / Car r y devi ne 0
shr bl , 3 / / bl devi ne 00000000
/ / Car r y devi ne 1
Instruciunea shl (SHift Left)
Sintaxa: shl dest, count
Efect:deplasarealastngaabiilordindestcunumruldepoziiiprecizatdecount; completarea la
dreaptacu0;plasareanCarryaultimuluibitieit.
Exemplu:
mov bl , 33; / / bi nar : 00100001
shl bl , 3; / / bl devi ne 00001000
/ / Car r y devi ne 1
shl bl , 1 / / bl devi ne 00010000
/ / Car r y devi ne 0
Instruciunea sar (Shift Arithmetic Right)
Sintaxa: sar dest, count
Efect:deplasarealadreaptaabiilordindestcunumruldepoziiiprecizatdecount; bitul cel mai
semnificativipstreazvecheavaloare,daresteideplasatspredreapta(extensiedesemn);plasarea
nCarryaultimuluibitieit.
Exemplu:
mov bl , - 36; / / bi nar : 11011100
sar bl , 2; / / bl devi ne 11110111
/ / Car r y devi ne 0
Trebuiemenionatcsarnufurnizeazaceeaivaloarecaiidivpentruoperanziechivaleni,
deoarece idivtrunchiaztoatecturilectre0,ntimpcesartrunchiazcturilepozitivectre0iarpe
celenegativectreinfinitnegativ.
Exemplu
mov ah, - 7; / / bi nar : 11111001
sar ah, 1; / / t eor et i c, echi val ent cu i mpar t i r ea l a 2
/ / r ezul t at : 11111100, adi ca - 4
/ / i di v obt i ne cat ul - 3
Instruciunea sal (Shift Arithmetic Left)
Sintaxa: sal dest, count
Efect: identic cu shl.
Exerciiu:
Ssescrieunprogramcarenumrbiiide1dinreprezentareauneivariabilentregifrsemn.
asm4
10 of 19
Cuprins:
Instruciunidesalt
Instruciuni de salt
Instruciuniledesaltmodificvaloarearegistruluicontorprogram(EIP),astfelncturmtoarea
instruciunecareseexecutsnufieneapratceacareurmeaznmemorie.Suntutilepentru
implementarea,laniveldelimbajdeasamblare,astructurilordecontrol(testrisaubucle).
Salturile pot fi:
necondiionate:instruciuneajmp
condiionate:instruciunideformaj<condiie>
Sintaxa: instructiune_salt adresa
Vomconsiderancontinuaredoarcazulncareadresaesteoconstantreferitdeoetichet.
Exempluldemaijosilustrazmoduldedefinireiutilizareaetichetelor:
#i ncl ude <st di o. h>
voi d mai n( ) {
i nt i ;
_asm{
mov i , 11;
j mp et i chet a;
sub i , 3; / / aceast a i nst r uct i une nu se execut a
et i chet a:
add i , 4;
}
pr i nt f ( " %d\ n" , i ) ;
}
Saltul necondiionat (instruciunea jmp)
Nuintroduceoramificaienprogram,neexistndvariantedeexecuie.Esteutil,folositmpreuncu
salturicondiionate,pentrureluareauneisecvenededecodntr-obucl,aacumsevavedeantr-un
exemplu ulterior.
Salturi condiionate
Introducoramificaienprogram,deoareceavemdouvariante:
condiiadesaltesteadevratsefacesaltullaadresaindicat
condiiadesaltestefalssecontinucuinstruciuneaurmtoaredinmemoriecaicumnuarfi
existatinstruciunedesalt.
Instruciuni care testeaz indicatorii individuali
Celemaiutilelaacestnivelsuntcelecaretesteazindicatorii:Carry,Overflow,Sign,Zero.Pentru
fiecareindicatorexistdouinstruciunidesaltcondiionat:unacarefacesaltulcndindicatorultestat
arevaloarea1iunacarefacesaltulcndarevaloarea0.
indicator testat salt pe valoarea 1 salt pe valoarea 0
Carry jc jnc
Overflow jo jno
Zero jz jnz
Sign js jns
11 of 19
Exemplu:
#i ncl ude <st di o. h>
voi d mai n( ) {
i nt a, b, s=0;
pr i nt f ( " a=" ) ;
scanf ( " %x" , &a) ;
pr i nt f ( " b=" ) ;
scanf ( " %x" , &b) ;

_asm{
mov eax, a;
add eax, b;
j c semnal eaza_depasi r e; / / i n Vi sual C++ 6. 0,
/ / put em sar i l a o et i chet a di n codul C
mov s, eax;
j mp af i seaza_suma; / / sau di n al t bl oc asm

}
semnal eaza_depasi r e:
pr i nt f ( " S- a pr odus depasi r e! \ n" ) ;
r et ur n;
_asm{
af i seaza_suma:
}
pr i nt f ( " %x + %x = %x\ n" , a, b, s) ;
}
Instruciuni corespunztoare operatorilor relaionali
npractic,utilizmmaidesramificridictatedeoperatorirelaionali:<,<=,!=,etc.nacestsenseste
utilinstruciuneadecompararecmp:
cmpfuncioneazcaisub(aceleairestriciipentruoperanzi,aceiai indicatori modificai),nsnu
modificprimuloperand(destinaia).Prinverificareaindicatorilorsepoatestabilinurmaaceste
operaiirelaiadintreoperanzi.Instruciunilecarefacacesteverificrisunt:
relaie instruciune Comentariu
op1 < op2 jb "J ump if Below"
op1 <= op2 jbe "J ump if Below or Equal"
op1 > op2 ja "J ump if Above"
op1 >= op2 jae "J ump if Above or Equal"
pentru numere fr semn, respectiv
relaie instruciune Comentariu
op1 < op2 jl "J ump if Less than"
op1 <= op2 jle "J ump if Less than or Equal"
op1 > op2 jg "J ump if Greater than"
op1 >= op2 jge "J ump if Greater than or Equal"
pentru numere cu semn.
Suntnecesareinstruciunidiferitepentrunumerefrsemn,respectivcusemn,deoareceindicatoriice
trebuieverificaidifer.Deexemplu,comparnd00100110i11001101,artrebuisobinemrelaia
00100110<11001101dacsuntnumerefrsemn,i00100110>11001101dacsuntnumerecusemn.
Independentdestatutulbituluiceluimaisemnificativ(semnsaucifr)funcioneazinstruciunile:
relaie instruciune Comentariu
op1 == op2 je "J ump if Equal" (identic cu jz)
op1 != op2 jne "J ump if Not Equal" (identic cu jnz)
12 of 19
asm5
Arhitectura Calculatoarelor
Lucrulcustiva.Apelulfuncilor
Lucrul cu stiva
ProcesorulfoloseteopartedinmemoriaRAMpentruaoaccesadupodisciplindetipLIFO(can
cazuluneistructuridestiv).Dupcumsetie,singurainformaiefundamentalpentrugestiuneastivei
este vrfulacesteia.ncazulprocesorului,adresalacareseaflvrfulstiveiestememoratnperechea
deregitriSSiESP;deoareceregitriisegmentau,pemainilepe32debii,doarscopde"validare"a
adresei, vom lucra n continuare numai cu ESP.
Instruciunilecarepermitlucrulcustivasuntpushipop.
Instruciunea push
Realizeazintroducereauneivalorinstiv.
Sintaxa: push operand;
Operandulpoatefiregistru,locaiedememoriesauconstantnumeric.Stivalucreazdoarcuvaloride
2sau4octei,pentruuniformitatepreferndu-senumaioperanzide4octei(variantacu2sepstraz
pentru compatibilitate cu procesoarele mai vechi).
Exemple:
push eax
push dx
push dwor d pt r [ . . . ]
push wor d pt r [ . . . ]
push dwor d pt r 5
push wor d pt r 14
Introducereavaloriinstivsefaceastfel:sescadedinESPdimensiunea,noctei,avaloriicaresevrea
depusanstiv,dupacareprocesorulscrievaloareaoperanduluilaadresaindicatderegistrulESP
(vrfulstivei);dimensiuneapoatefi2sau4(seobservcseavanseaz"njos",delaadreselemaimari
laadreselemaimici);nacestmod,vrfulstiveiestepregtitpentruurmtoareaoperaiedescriere.
Deexemplu,instruciunea
push eax;
arfiechivalentcu:
sub esp, 4;
mov [ esp] , eax;
Prin folosirea lui pushnloculsecveneiechivalentesereduce,ns,risculerorilor.
Instruciunea pop
Extragevrfulstiveintr-unoperanddestinaie.
Sintaxa: pop operand;
13 of 19
Operandulpoatefiregistrusaulocaiedememorie,de2sau4octei.
Exemple:
pop eax
pop cx
pop dwor d pt r [ . . . ]
pop wor d pt r [ . . . ]
Extragereavaloriidinstivsefaceprindepunereandestinaieavaloriiaflatenvrfulstivei(laadresa
[ESP])iadunarea,laESP,anumruluideocteiaioperandului(acestaindic,practic,numrulde
octeiscoidinstiv).
Rolul stivei
Rolulstiveiprocesoruluiesteaceladeastocainformaiicucaractertemporar.Deexemplu,dacavem
nevoiesfolosimunregistrupentruniteoperaii,darnuavemladispoziieniciunregistruacrui
valoarecurentsnepermitemsopierdem,putemprocedacamaijos:
push eax; / / se sal veaza t empor ar val oar ea l ui eax pe st i va
. . . / / ut i l i zar e eax
pop eax / / r est aur ar e
Variabilelelocale(cuexcepiacelorstatice)suntplasatedeasemeneanstiv(deoareceaucaracter
temporar:suntcreatelaintrareanfuncieidistruselaieire).
n lucrul cu stiva, instruciunile de introducere n stiv trebuie riguros compensate de cele de scoatere,
dinpunctuldevederealnumruluideinstruciuniialdimensiuniioperanzilor.Oriceeroarepoate
afecta mai multe date, din cauza decalajelor.
push edx;
push eax;
. . . / / ut i l i zar e r egi st r i
pop ax / / se r ecuper eaza doar 2 oct et i di n val oar ea ant er i oar a a l ui eax
pop edx / / nu se r ecuper eaza edx, ci 2 oct et i di n eax, 2 di n edx
/ / decal aj ul se poat e pr opaga ast f el pana l a capat ul st i vei
OalteroarepoateapreaatuncicndregistrulESPestemanipulatdirect.Deexemplu,pentruaaloca
spaiuuneivariabilelocale(neiniializat),esuficientascdeadinESPdimensiuneavariabilei
respective.Similar,ladistrugereavariabilei,valoareaESPestecrescut.Aicinusefolosescngeneral
instruciunipush,repectivpop,deoarecenuintereseazvalorileimplicate,cidoarocupareaieliberarea
despaiu.SepreferadunareaiscdereadirectcuregistrulESP;evidentcoeroarenacesteoperaii
areconsecinedeaceeainaturcaiceledemaisus.
Apelulfunciilor
Unapeldefunciearatlaprimavederecaoinstruciunedesalt,nsensulcsentrerupeexecuia
liniaraprogramuluiisesarelaoaltadres.Diferenafundamentalconstnfaptulclaterminarea
funcieiserevinelaadresadeundes-afcutapelulisecontinucuinstruciuneaurmtoare.Din
momentcentr-unprogramsepoateapelaofunciedemaimulteori,dinmaimultelocuri,i
ntotdeaunaserevineundetrebuie,esteclarcadresalacaretrebuierevenitestememoratifolosit
atuncicndestecazul.Cumadresaderevenireestenmodevidentoinformaietemporar,loculsu
estetotpestiv.
Instruciunea call
Apeluluneifunciiserealizeazprininstruciuneacall.
Sintaxa: call adresa
n Visual C++vom folosi nume simbolicepentruaprecizaadresa,cumeniuneacdedataastanueste
14 of 19
vorbadeetichete,calasalturi,cichiardenumelefunciilorapelate.
Efectulinstruciuniicall:seintroducenstivadresainstruciuniiurmtoare(adresa de revenire)ise
face salt la adresa indicat.Acesteaciuniputeaufirealizateicuinstruciunipushijmp,dardinnou
seprefercallpentruevitareaerorilor.
Instruciunea ret
Revenireadintr-ofunciesefaceprininstruciunearet,carepoatefifolositfroperand.nacestcaz,
sepreiaadresadereveniredinvrfulstivei(similaruneiinstruciunipop)isefacesaltullaadresa
respectiv.DinmotivedeconlucrarecuVisualStudio,nuvomfolosiaceastinstruciune.
Transmiterea parametrilor
Parametriisunttotnitevariabilelocale,decisegsescpestiv.Celcarefaceapelulare
responsabilitateadea-ipunepestivlaapelidea-iscoatedepestivlerevenireadinfunciaapelat.
Avemladispoziieinstruciuneapushpentruplasareanstiv.Evident,aceastoperaietrebuierealizat
imediatnaintedeapelulpropriu-zis.nplus,nlimbajulC/C++(nuntoate),parametriitrebuiepuin
stivnordineinversceleincaresegsescnlistadeparametri.Larevenire,parametriitrebuiescoi
dinstiv,nemaifiindnecesari.Cumnuneintereseazpreluareavalorilorlor,nusefolosete
instruciuneapop,carearputeaalterainutilunregistru,deexemplu,ciseadunlaESPnumrultotalde
octeiocupatdeparametri(atenie,pestivselucreazngeneralcu4octei,chiardacoperanziiau
dimensiuni mai mici).
Slumcaexemplufunciaurmtoare:
voi d show_di f ( i nt a, i nt b) {
i nt c;
c=a- b;
pr i nt f ( " %d\ n" , c) ;
}
Apeluldif(5,9)setraduceprinsecvenacaresepoatevedeamaijos:
voi d mai n( ) {
_asm{
push dwor d pt r 9
push dwor d pt r 5
cal l show_di f
add esp, 8
}
}
Returnarea unei valori
ConvenianVisualC++(ilamajoritateacompilatoarelor)estecrezultatulsedepunentr-unanumit
registru,nfunciededimensiuneasa:
pentru tipurile de date de dimensiune 1 octet - n registrul AL
pentrutipurilededatededimensiune2octei-nregistrulAX
pentrutipurilededatededimensiune4octei-nregistrulEAX
pentrutipurilededatededimensiune8octei-nregitiiEDXiEAX
Evident,larevenireadinfuncie,celcareafcutapelultrebuiespreiarezultatuldinregistrul
corespunztor.
Vommodificaexempluldemaisusastfelnctfunciasreturnezediferenapecareocalculeazntr-o
secvendeinstruciuninlimbajdeasamblare:
#i ncl ude <st di o. h>
i nt comput e_di f ( i nt a, i nt b) {
_asm{
15 of 19

mov eax, a;
sub eax, b;
/ / i n eax r amane r ezul t at ul , car e
/ / va f i pr el uat l a t er mi ar ea f unct i ei
};
}
voi d mai n( ) {
i nt c;
_asm{
push dwor d pt r 9
push dwor d pt r 5
cal l comput e_di f / / se sal veaza adr esa de r eveni r e pe st i va
mov c, eax;
add esp, 8 / / " st er ger ea" par amet r i l or di n st i va
}
pr i nt f ( " Di f er ent a est e %d. \ n" , c) ;
}
Parametri
Exista o alta modalitate de accesa in cadrul unei functii parametrii acesteia in cadrul unui bloc limbaj de
asamblare. Ei se gasesc pe stiva incepand cu adresa [ebp+8] si ocupa numarul de octeti al tipului de
date respectiv.
Exemplu, o functie cu 3 parametri de tip int (o variabila de tip int are 4 octeti):
voi d f unct i e( i nt a, i nt b, i nt c) {
_asm{

mov eax, [ ebp+8] / / mut a i n eax val oar ea l ui a
mov ebx, [ ebp+12] / / mut a i n ebx val oar ea l ui b
mov ecx, [ ebp+16] / / mut a i n ecx val oar ea l ui c
};
}
Scris in aceasta maniera, exemplul de mai sus ar arata in felul urmator:
#i ncl ude <st di o. h>
i nt comput e_di f ( i nt , i nt ) { / / nu mai est e nevoi e sa punem nume var i abi l el or ,
deoar ece voml ucr a di r ect cu st i va
_asm{

mov eax, [ ebp+8] ;
sub eax, [ ebp+12] ;
/ / i n eax r amane r ezul t at ul , car e
/ / va f i pr el uat l a t er mi ar ea f unct i ei
};
}
voi d mai n( ) {
i nt c;
_asm{
push dwor d pt r 9
push dwor d pt r 5
cal l comput e_di f / / se sal veaza adr esa de r eveni r e pe st i va
mov c, eax;
add esp, 8 / / " st er ger ea" par amet r i l or di n st i va
}
pr i nt f ( " Di f er ent a est e %d. \ n" , c) ;
}
Numar de parametri variabil
O situatie speciala consta in transmiterea unui numar variabil de parametri la o functie pe care vrem sa o
apelam. In Visual C++o astfel de functie ar arata in felul urmator:
#i ncl ude <st di o. h>
i nt f unct i e( i nt nr _par amet r i , . . . ) {
_asm{
mov ecx, [ ebp+8] / / pr i mul par amet r u al f unct i ei car e ar e ca
val oar e
/ / numar ul de par amet r i de
dupa el ( val oar ea var i abi l ei nr _par amet r i ) , adi ca 3
/ / ast f el , de l a [ ebp+12] vom
16 of 19
avea r est ul par amet r i l or f unct i ei
mov eax, [ ebp+12] / / pr i mul par amet r u de dupa nr _par amet r i ,
adi ca 7
mov ebx, [ ebp+16] / / 6
mov edx, [ ebp+20] / / 5
}
}
voi d mai n( ) {
i nt c;
_asm{
push dwor d pt r 5
push dwor d pt r 6
push dwor d pt r 7
push dwor d pt r 3 / / pr i mul par amet r u ( nr _par amet r i )
cal l f unct i e / / se sal veaza adr esa de r eveni r e pe st i va
add esp, 16 / / " st er ger ea" par amet r i l or di n st i va ( 4 x nr de par amet r i =16)
}
}
Exerciii
1. Ssescrieunprogrampentrucalcululfactorialuluiunuinumrfrsemn.nfunciamain()seva
face n limbaj de asamblareapellaofunciececalculeaziterativ factorialul (tot n limbaj de
asamblare)ilreturneaz.
2. Aceeaiproblem,cudiferenacfactorialulvaficalculatdeofuncierecursiv.
3. Sa se scrie o functie cu numar variabil de parametri care calculeaza si returneaza suma
parametrilor si apelul acesteia din functia main.
asm6
Poi nt er i .
Pent r u a i nt el ege cumse f ol osesc t abl our i l e i n ASM, t r ebui e i nt el es mai i nt ai
concept ul de poi nt er .
Poi nt er - ul r epr ezi nt a o var i abi l a ce past r eaza o adr esa de memor i e a unei dat e
( " poi nt eaza" spr e o adr esa de memor i e) . Un poi nt er poat e f i ut i l i zat pent r u r ef er i r ea
a di f er i t e t i pur i de dat e ( t abl our i de t i p i nt , si r ur i de car acet er e, mat r i ci et c. )
sau st r uct ur i de dat e. Schi mband adr esa memor at a i n poi nt er , pot f i mani pul at e
i nf or mat i i si t uat e l a di f er i t e l ocat i i de memor i e.
Legat ur a di nt r e t abl our i si poi nt er i
Numel e unui t abl ou est e un poi nt er const ant spr e pr i mul sau el ement . Expr esi i l e de
mai j os sunt deci echi val ent e:
nume_t abl ou
&nume_t abl ou
&nume_t abl ou[ 0]
*nume_t abl ou
nume_t abl ou[ 0]
/ / Ex. 1 I nt er schi mbar ea a 2 val or i
#i ncl ude <st di o. h>
voi d swap ( i nt *a, i nt *b)
{
_asm{
mov eax, a; / / punem i n eax adr esa dat a de poi nt er ul *a
mov ecx, [ eax] ; / / punem i n ecx val oar ea ef ect i va a l ui *a
( val oar ea de l a adr esa poi nt er ul ui )
mov ebx, b; / / anal og pt b
mov edx, [ ebx] ;
mov [ eax] , edx; / / mut am l a adr esa l ui a val oar ea l ui *b
mov [ ebx] , ecx; / / anal og i nver s
}
}
voi d mai n( )
{
i nt a=2, b=3;
swap( &a, &b) ;
pr i nt f ( " %d %d" , a, b) ;
}
/ / Ex. 2 Suma el ement el or di nt r - un vect or
17 of 19
#i ncl ude <st di o. h>
i nt suma_vect or ( i nt *, i nt )
{
_asm
{
mov eax, 0 / / suma
mov ebx, [ ebp+8] / / pr i mul par amet r u, poi nt er l a vect or ul de
el ement e
mov ecx, 0 / / cont or
bucl a:
cmp ecx, [ ebp+12] / / al 2- l ea par amet r u, l ungi mea vect or ul ui de
el ement e
j ae st op
add eax, [ ebx+ecx*4] / / el ement ul vect or ul ui de pe pozi t i a ecx
i nc ecx
j mp bucl a
st op:
}
}
voi d mai n( )
{
i nt v[ 5] ={5, 1, 2, 3, 6};
i nt *p=v;
i nt s;
_asm{
push 5
push p
cal l suma_vect or
add esp, 8
mov s, eax
}
pr i nt f ( " Suma: %d" , s) ;
}
/ / Ex. 3 Lungi mea unui si r de car act er e ( un si r de numer e se t er mi na cu val oar ea 0)
#i ncl ude <st di o. h>
i nt l ungi me( char *)
{
_asm{
mov eax, 0
mov ebx, [ ebp+8] / / adr esa de i nceput a si r ul ui de car act er e
bucl a:
cmp [ ebx+eax] , 0 / / compar amcar act er ul cur ent cu 0
j e st op
i nc eax
j mp bucl a
st op:
}
}
voi d mai n( )
{
char *si r =" zi gyzagy" ;
i nt l ;
_asm{
push si r
cal l l ungi me
add esp, 4
mov l , eax
}
pr i nt f ( " Lungi me: %d %d\ n" , l , st r l en( si r ) ) ;
}
Pent r u mat r i ce de a[ n] [ m] ( n x mel ement e) , pent r u avea acces l a el ement ul de pe
pozi t i a [ i ] [ j ] ( l i ni a i , col oana j ) , va t r ebui sa af l am adr esa acest ui a.
" a[ i ] [ j ] " est e echi val ent cu: " &a + ( i *m+j ) *4" ( adr esa pr i mul ui el ement l a car e
adaugami x nr _col oane + j , t ot ul i nmul t i t cu di mensi unea el ement el or , i n cazul
nost r u 4 oct et i pent r u i nt )
/ / Ex. 4 - Const r ui r ea mat r i ci i uni t at e ( 1 pe di agonal a, 0 i n r est )
#i ncl ude <st di o. h>
voi d mat r i ce_uni t at e( i nt *, i nt )
{
_asm{
mov edi , [ ebp+8] / / adr esa l a pr i mul el ement di n
mat r i ce
18 of 19
mov ebx, 0
f or _i :
cmp ebx, [ ebp+12] / / di mensi unea mat r i ci i
j ae exi t 1

mov ecx, 0
f or _j :

cmp ecx, [ ebp+12]
j ae exi t 2
mov eax, [ ebp+12] / / const r ui m adr esa de pe pozi t i a
[ i ] [ j ]
mul ebx
add eax, ecx
cmp ebx, ecx
j ne not _eq
mov dwor d pt r [ edi +eax*4] , 1 / / i == j , deci vompune 1
j mp i nsi de
not _eq:
mov dwor d pt r [ edi +eax*4] , 0 / / al t f el , 0
i nsi de:
i nc ecx
j mp f or _j
exi t 2:
i nc ebx
j mp f or _i
exi t 1:
}
}
voi d mai n( )
{
i nt n=5;
i nt mat [ 5] [ 5] ;
i nt *p = mat [ 0] ;
_asm
{
push n
push p
cal l mat r i ce_uni t at e
add esp, 8
}
f or ( i nt i =0; i <n; i ++)
{
f or ( i nt j =0; j <n; j ++)
pr i nt f ( " %d " , mat [ i ] [ j ] ) ;
pr i nt f ( " \ n" ) ;
}
}
19 of 19