Raport

Arhitectura Calculatoarelor
Lucrarea de laborator NR.2
Tema: „Bazele limbajului Assembler”

Elaborat: Cerlat Pavel FAF-192

Controlat: Postovan Dumitru
Scopul:
Se prezinta problemele principale legate de conversii de date, reprezentarea datelor
întregi,reprezentarea întregilor in format BCD, reprezentarea caracterelor si a
șirurilor de caractere.

EX #1
INCLUDE Irvine32.inc

.data

alfa DW 3 DUP(?)

.code
main proc
mov ax,17 ; adresare indirecta a operandului sursa
mov ax,10101b ;
mov ax,11b ;
mov ax,21o ;
mov alfa,ax ; Adresare directa a operandului destinatie
mov cx,ax ; Interschimba registrele ax si bx
mov ax,bx ; Folosind registrul cx
mov ax,cx
xchg ax,bx ; Interschimba direct cele 2 registre.
mov si,2
mov alfa[si],ax ; Adresare relativa cu registrul si
mov ebx,offset alfa ; Adresare imediata a operandului sursa
lea ebx,alfa ; Acelasi efect
mov esi,2
mov cx,[ebx][esi] ; Adresare bazata indexata a sursei
mov cx,alfa[2] ; Acelasi efect.
mov cx,[alfa+2] ; Acelasi efect
mov di,4
mov byte ptr [ebx][edi],55h ;
mov esi,2
mov ebx,3
mov alfa[ebx][esi],33h ; Adresare bazata indexata relativa a destinatiei
mov alfa[ebx+esi],33h ; Notatii echivalente
mov [alfa+ebx+esi],33h
mov [ebx][esi]+alfa,33h
exit ;Procedura de iesire din Irvine32.inc
main ENDP ;Terminarea procedurii main
END main ;Punctul de terminare a programului

Listingul codului:
00000000 .data

00000000 00000003 [ alfa WORD 3 DUP(?)

0000
]
00000000 .code
00000000 main proc
00000000 66| B8 0011 mov ax,17 ; adresare indirecta a operandului sursa
00000004 66| B8 0015 mov ax,10101b
00000008 66| B8 0003 mov ax,11b
0000000C 66| B8 0011 mov ax,21o
00000010 66| A3 mov alfa,ax ; Adresare directa a operandului destinatie
00000000 R
00000016 66| 8B C8 mov cx,ax ; copiem valoarea registrului ax in registrul cx
00000019 66| 8B C3 mov ax,bx ;copiem valoarea registrului bx in registrul ax
0000001C 66| 8B C1 mov ax,cx ; restauram valoarea anterioara a ax din registrul cx
0000001F 66| 93 xchg ax,bx ; schimbam cu locul valorile ax si bx
00000021 66| BE 0002 mov si,2 ; copiem valoarea 2 in registrul si (source index)
00000025 66| 89 04 35 mov alfa[si],ax ; copiem valoarea registrului ax in al doilea cuvant al tabloului alfa
00000000 R
0000002D BE 00000002 mov esi,2 ; scriem valoarea 2 in registrul esi
00000032 BB 00000000 Rmov ebx,offset alfa ; copiem miscarea alfa in registrul ebx
00000037 8D 1D 00000000 R lea ebx,alfa ; copiem adresa (miscarea) alfa in registrul ebx
0000003D 8B 0C 33 mov ecx,[ebx][esi] ; copiem valoarea celui de-al doilea cuvant al tabloului alfa in registrul
ecx
00000040 66| 8B 0D mov cx,alfa[2] ; copiem valoarea celui de-al doilea cuvant al tabloului alfa in registrul cx
00000002 R
00000047 66| 8B 0D mov cx,[alfa+2] ; copiem valoarea celui de-al doilea cuvant al tabloului alfa in registrul
00000002 R
0000004E 66| BF 0004 mov di,4 ; scriem valoarea 4 in registrul di (destination index)
00000052 C6 04 3B 55 mov byte ptr [ebx][edi],55h; scriem 55h in al cincilea octet alfa (primul octet de 3 cuvinte)
00000056 BE 00000002 mov esi,2 ; scriem valoarea 2 in registrul esi
0000005B BB 00000003 mov ebx,3 ; scriem valoarea 3 in registrul ebx
00000060 66| C7 84 33 mov alfa[ebx][esi],33h ; scriem 33h in al doilea octet 3 cuvinte din tabloul alfa
00000000 R
0033
0000006A 66| C7 84 33 mov alfa[ebx+esi],33h ; scriem 33h in al doilea octet 3 cuvinte din tabloul alfa
00000000 R
0033
00000074 66| C7 84 33 mov [alfa+ebx+esi],33h; scriem 33h in al doilea octet 3 cuvinte din tabloul alfa
00000000 R
0033
0000007E 66| C7 84 33 mov [ebx][esi]+alfa,33h ; scriem 33h in al doilea octet 3 cuvinte din tabloul alfa
00000000 R
0033
 exit
00000088 6A 00 * push +000000000h
0000008A E8 00000000 E * call ExitProcess
0000008F main ENDP
END main

Ex #2
Sa se calculeze expresia aritmetica: e=((a+b*c-d)/f+g*h)/i. Se cere obţinerea
fisierului executabil si rularea apoi pas cu pas.

INCLUDE Irvine32.inc
; Sa se calculeze expresia aritmetica: e=((a+b*c-d)/f+g*h)/i
; se considera a, d, f – cuvant b, c, g, h, i –byte
; ca sa putem executa impartirea cu f convertim impartitorul la dublucuvânt
; ne vor interesa doar caturile impartirilor, rezultatul va fi de tip octet
.data
a dw 5 ;valoarea 5 de marimea de 2 biti pentru a
b db 6 ;valoarea 6 de tipul bit pentru b
cd db 10 ;valoarea 10 de tipul bit pentru cd
d dw 5 ;valoarea 5 de marimea de 2 biti pentru d
f dw 6 ;valoarea 6 de marimea de 2 biti pentru f
g db 10 ;valoarea 10 de tipul bit pentru g
h db 11 ;valoarea 11 de tipul bit pentru h
i db 10 ;valoarea 10 de tipul bit pentru i
interm dw ? ;valoare de marimea 2 biti
rez db ? ;bit cu valoarea nealeasa
.code
main proc
mov eax,0
mov al, b
imul cd ; in ax avem b*c
add ax, a ; ax=b*c+a
sub ax, d ; ax=b*c+a-d
cwd ; am convertit cuvantul din ax, in dublu cuvantul , retinut in dx:ax
idiv f ; obtinem câtul în ax si restul în dx ax=(a+b*c-d)/f
mov interm, ax ; interm=(a+b*c-d)/f
mov al, g
imul h ; ax=g*h
add ax, interm ; ax=(a+b*c-d)/f+g*h
idiv i ; se obtine catul în al si restul în ah
mov rez, al
exit
main ENDP
END main
Rezultatul obtinut ((a+b*c-d)/f+g*h)/i=((5+6*10-5)/6+10*11)/10= 12

Listingul EX #2
00000000 .data
00000000 0005 a dw 5
00000002 06 b db 6
00000003 0A cd db 10
00000004 0005 d dw 5
00000006 0006 f dw 6
00000008 0A g db 10
00000009 0B h db 11
0000000A 0A i db 10
0000000B 0000 interm dw ?
0000000D 00 rez db ?
00000000 .code
00000000 main proc
00000000 B8 00000000 mov eax,0
00000005 A0 00000002 R mov al, b
0000000A F6 2D 00000003 R imul cd ; in ax avem b*c
00000010 66| 03 05 add ax, a ; ax=b*c+a
00000000 R
00000017 66| 2B 05 sub ax, d ; ax=b*c+a-d
00000004 R
0000001E 66| 99 cwd ; am convertit cuvantul din ax, in dublu cuvantul , retinut in dx:ax
00000020 66| F7 3D idiv f ; obtinem c?tul ?n ax si restul ?n dx ax=(a+b*c-d)/f
00000006 R
00000027 66| A3 mov interm, ax ; interm=(a+b*c-d)/f
0000000B R
0000002D A0 00000008 R mov al, g
00000032 F6 2D 00000009 R imul h ; ax=g*h
00000038 66| 03 05 add ax, interm ; ax=(a+b*c-d)/f+g*h
0000000B R
0000003F F6 3D 0000000A R idiv i ; se obtine catul ?n al si restul ?n ah
00000045 A2 0000000D R mov rez, al
exit
0000004A 6A 00 * push +000000000h
0000004C E8 00000000 E * call ExitProcess
00000051 main ENDP
END main
EX #3
Varianta #6
z=(a-b*c/d)/(c+2-a/b)+5
Codul:
INCLUDE Irvine32.inc
.data
a dw 5 ; cu o valoare de 5 cuvinte de tip pentru a
b db 1 ; cu o valoare de 1 octet un cuvânt pentru b
cd db 10 ; cu o valoare de 10 octeți un cuvânt pentru cd
d dw 5 ; cu o valoare de 5 cuvinte de tip pentru d
interm dd ?
rez dd ?
.code
main proc
mov eax,0 ; punem valoarea 0 în registrul eax
mov al, b ; punem valoarea 0 în registrul eax
imul cd ; rezultatul b * c este salvat în ax
cwd ; extindem al la ax (ținând cont de semn)
idiv d ; coeficientul în ax și restul în dx,ax = b * c/d
mov interm, eax; ; interm = b * c / d
sub a, ax ; ax = a – b * c / d
cwd ;extindem cuvântul din ax, într-un cuvânt dublu în dx: ax
mov interm, eax ; interm = a – b * c / d
mov ax, a ; scriem in ax
idiv b ; executam a / b
cwd ; extindem rezultatul împărțirii de la ax în eax(păstrând semnul)
mov ecx, eax ; copiem rezultatul a / b în ecx
mov al, cd
cbw
add ax, 2
mov ebx, interm ; copiem valoarea interm în registrul ebx
mov word ptr interm, ax ; copiem in interm mic și mare cuvintele rezultate
mov word ptr interm[2], dx
sub interm, ecx ; executam a / b - c + a
mov eax, ebx ; copiem rezultatul a-b * c / d în registrul eax
cdq ; extindem eax la edx: eax (luand in seama semnul)
idiv interm ; executam (a-b * c / d) / (c + 2-a / b)
mov ax, 5 ; scriem 5 in ax
add interm, eax ; executam eax=(a-b*c/d)/(c+2-a/b)+5
cbw ; extindem rezultatul diviziunii de la al la ax(păstrând semnul)
cwd ; extindem rezultatul împărțirii de la ax pana la eax (păstrând semnul)
mov rez, eax ; copiem rezultatul în rez
exit ;Procedura de iesire din Irvine32.inc
main ENDP ;Terminarea procedurii main
END main ;Punctul de terminare a programului
Listingul:
00000000 .data

00000000 0005 a dw 5

00000002 01 b db 1

00000003 0A cd db 10

00000004 0005 d dw 5

00000006 00000000 interm dd ?

0000000A 00000000 rez dd ?

00000000 .code

00000000 main proc

00000000 B8 00000000 mov eax,0

00000005 A0 00000002 R mov al, b

0000000A F6 2D 00000003 R imul cd ; în ax rezultatul b * c este salvat (cu un semn)

00000010 66| 99 cwd

00000012 66| F7 3D idiv d ; ax=b*c/d

00000004 R

00000019 A3 00000006 R mov interm, eax

0000001E 66| 29 05 sub a, ax; ax=b*c/d-a

00000000 R

00000025 66| 99 cwd ; am extins cuvântul din ax, într-un cuvânt dublu în dx: ax

00000027 98 cwd ; extindem ax pana la eax (pastrand semnul)

00000028 A3 00000006 R mov interm, eax; interm=ax=b*c/d-a

0000002D 66| A1 mov ax, a ; scriem a in ax

00000000 R

00000033 F6 3D 00000002 R idiv b ; executam a/b

00000039 98 cwd ; extindem rezultatul împărțirii de la ax în eax(păstrând semnul)

0000003A 8B C8 mov ecx, eax ; copiem rezultatul a / b pe ecx

0000003C A0 00000003 R mov al, cd

00000041 66| 98 cbw

00000043 66| 83 C0 02 add ax, 2

00000047 8B 1D 00000006 R mov ebx, interm ; copiem valoarea interm în registrul ebx

0000004D 66| A3 mov word ptr interm, ax ;

00000006 R

00000053 66| 89 15 mov word ptr interm[2], dx

00000008 R

0000005A 29 0D 00000006 R sub interm, ecx ; executam a/b - c+a

00000060 8B C3 mov eax, ebx ; copiem rezultatul a-b * c / d în registrul eax

00000062 99 cdq ; extindem eax la edx: eax (luand semnul in seama)

00000063 F7 3D 00000006 R idiv interm ; executam (a-b * c / d) / (c + 2-a / b)

00000069 66| B8 0005 mov ax, 5 ; scriem 5 in ax

0000006D 01 05 00000006 R add interm, eax ; executam z=(a-b*c/d)/(c+2-a/b)+5

00000073 66| 98 cbw ; extindem rezultatul diviziunii de la al la ax (păstrând semnul)

00000075 98 cwd; extindem rezultatul împărțirii de la ax la eax(păstrând semnul)

00000076 A3 0000000A R mov rez, eax; copeim rezultatul in rez

exit

00000082 main ENDP

END main
Concluzie:
In urma acestui laborator am invatsat tipurile de date ale microprocesoarelor, lucrul cu
cifrele in diferite "medii",directive,sisteme de calcul. Am executat un program in
limbajul assembler care executa operatia aritmetica oferita.