Escola d’Enginyeria ESTRUCTURA DE COMPUTADORS

Enginyeria Informàtica PROBLEMES

REPERTORI D’INSTRUCCIONS

ESTRUCTURA DE COMPUTADORS

SOLUCIONS PROBLEMES PROPOSATS

Repertori d’Instruccions
CURS 2023-24
Escola d’Enginyeria ESTRUCTURA DE COMPUTADORS
Enginyeria Informàtica PROBLEMES
REPERTORI D’INSTRUCCIONS

Problemes dels que publicarem la solució

Problema 11.
Escriure un programa en llenguatge assemblador que realitzi la funcionalitat que
es descriu en cadascun dels següents apartats:

a) Emmagatzemi en R1 un 1 si es compleix una qualsevol de les dues

condicions següents o bé si es compleixen les dues:
• el contingut de R2 es 0
• el contingut de R4 es més petit o igual que el de R5.
En qualsevol altre cas emmagatzemi un 0 en R1.

if: MOV R1, 1

CMP R2, 0
JE endif
CMP R4, R5
JLE endif
MOV R1, 0
endif:

b) Emmagatzemi en R1 un 1 si es compleix una i sols una de les

condicions següents:
• el contingut de R2 es 0
• el contingut de R4 es més petit o igual que el de R5.
En qualsevol altre cas emmagatzemi un 0 en R1.

MOV R1, 1
CMP R2, 0
JE continue1
MOV R1,0
Continue1: MOV R7, 1
CMP R4, R5
JLE continue2
MOV R7, 0
Continue2: XOR R1, R7
Escola d’Enginyeria ESTRUCTURA DE COMPUTADORS
Enginyeria Informàtica PROBLEMES
REPERTORI D’INSTRUCCIONS

Problema 12.
L’objectiu d’aquest problema consisteix en traduir fragments de codi en C a
llenguatge assemblador.
En els codis escrits en C no declarem les variables que es fan servir. Suposem
que aquestes variables ja les tenim. Tampoc heu de reservar espai en memòria
ni inicialitzar les variables. L’adreça simbòlica de memòria que cal fer servir per
accedir a una ha de coincidir amb el nom de la variable en C.
Traduïu a llenguatge assemblador cadascun dels següents fragments de codi.

a) Suma dels elements d’un vector. Considereu que no ens interessa el

valor final de les variables partial_sum, i i N. Per optimitzar el
codi heu de fer servir registres del processador per emmagatzemar
els seus valors. Suposeu que s'ha definit la variable V com a vector
d'enters de 32 bits i la variable sum com a nombre enter de 32 bits i
que es troben emmagatzemats a partir de les adreces simbòliques
de memòria V i sum, respectivament.
N = 6;
sum = 0;
partial_sum = 0;
i = 0;
while ( i < N) {
partial_sum = partial_sum + V[i];
i = i + 1;
}
sum = partial_sum;

OPCIÓ 1
MOV [N],6 ; N
MOV [sum],0 ; valor de la variable sum
MOV [partial_sum],0 ; valor de la varible
partial_sum
MOV [i],0 ; valor d ela variable i
MOV R1,[N]
SAL R1,2
MOV R2,[i]
MOV R3,[partial_sum]
while:
CMP R2,R1 ; quan R2 arribi al valor de R1
haurem acabat
JGE end
ADD R3,[V+R2]
MOV [partial_sum],R3
ADD R2,4
JMP while ; repetim el procés.
end:
MOV [sum],R3
Escola d’Enginyeria ESTRUCTURA DE COMPUTADORS
Enginyeria Informàtica PROBLEMES
REPERTORI D’INSTRUCCIONS

OPCIÓ 2
MOV R1,6
SAL R1,2
MOV R2,0
MOV R3,0
while:
CMP R2,R1 ; quan R2 arribi al valor de R1
haurem acabat
JGE end
ADD R3,[V+R2]
ADD R2,4
JMP while ; repetim el procés.
end:
MOV [sum], R3

VERSIÓ RISC-V
ADDI x7,x0,6
SLLI x7,x7,2
ADDI x8,x0,0
ADDI x9,x0,0
while:
BEQ x7,x8,end ; quan R2 arribi al valor de R1
haurem acabat
LW x10,V(x8)
ADD x9,x9,x10
ADDI x8,x8,4
JAL x0,while ; repetim el procés.
end:
SW x9,sum(x0)
Escola d’Enginyeria ESTRUCTURA DE COMPUTADORS
Enginyeria Informàtica PROBLEMES
REPERTORI D’INSTRUCCIONS

b) Càlcul de num termes de la successió de Fibonacci fent servir for.

Suposar que cada valor és un sencer de 32 bits.
num = 10;
fib[0] = 1;
fib[1] = 1;
for (i=2;i<num;i++) {
fib[i]=fib[i-1]+fib[i-2];
}

MOV R1, 10
SAL R1, 2
MOV R2, 0
MOV [FIB+R2], 1
MOV R3, 4
MOV [FIB+R3], 1
MOV R4, 8
for: CMP R4, R1
JGE fi
MOV R5, [FIB+R2]
ADD R5, [FIB+R3]
MOV [FIB+R4], R5
ADD R2, 4
ADD R3, 4
ADD R4, 4
JMP for
fi:
Escola d’Enginyeria ESTRUCTURA DE COMPUTADORS
Enginyeria Informàtica PROBLEMES
REPERTORI D’INSTRUCCIONS

Problema 13.

Es defineixen tres matrius (A, B i C) de 4x4 components de 4 bytes cadascuna.

Donat el següent codi en alt nivell que realitza el producte de les matrius A per
B i genera la matriu C:

int A[4][4], B[4][4], C[4][4];

int i, j, k;

for (i=0; i <4; i++)

{
for (j=0; j <4; j++)
{
C[i][j]=0;
for (k=0; k <4; k++)
C[i][j]=C[i][j]+A[i][k]*B[k][j];
}
}

completeu el següent codi en assemblador:

INI: MOV ESI, 0

BUCLE_i: CMP ESI, 4
JGE FI_i
MOV _EDI_, 0
BUCLE_j: CMP EDI, 4
JGE FI_j
CALL Calc_Index
MOV [Posi], _EBX_
MOV C[EBX],0
MOV ECX, 0
BUCLE_k: CMP ECX, 4
JGE Fi_k
_PUSH_ EDI
MOV EDI, _ECX_
CALL Calc_Index
Escola d’Enginyeria ESTRUCTURA DE COMPUTADORS
Enginyeria Informàtica PROBLEMES
REPERTORI D’INSTRUCCIONS

POP EDI
MOV EAX, _A[EBX]_
PUSH ESI
MOV ESI, ECX
CALL Calc_Index
POP ESI
MOV _EDX_, B[EBX]
MUL EDX
MOV EBX, [Posi]
ADD C[EBX], _EAX_
INC ECX
JMP BUCLE_k
FI_k: INC EDI
JMP BUCLE_j
FI_j: INC ESI
JMP BUCLE_i
FI_i: END

Calc_Index: PUSH EAX

MOV _EBX_, ESI
SHL EBX, 4
MOV EAX,EDI
_SHL_ EAX, 2
ADD EBX, EAX
POP EAX
RET
Escola d’Enginyeria ESTRUCTURA DE COMPUTADORS
Enginyeria Informàtica PROBLEMES
REPERTORI D’INSTRUCCIONS

PROBLEMA 14.

Considerem un microprocessador senzill amb les següents característiques:

o La quantitat màxima de memòria que pot adreçar és de 256 bytes i la unitat
mínima adreçable és un byte.
o Disposa dels registres de 8 bits: A (acumulador), X, SP y PC.
o Totes les instruccions ocupen 2 bytes.
o El model d’execució és de 1 adreça:
▪ un dels operands està en memòria i s’especifica utilitzant els modes
d’adreçament que s’especifiquen més endavant.
▪ L’altre operand és un registre que s’indica de forma implícita en el codi
d’operació de la instrucció.

El repertori d’instruccions conté les següents instruccions i modes d’adreçament:

Instruccions:
LDAA n Carregar a l’Acumulador (A) el contingut de la posició de memòria n
LDX n Carregar al registre índex X el contingut de la posició de memòria n
STAA n Emmagatzemar el contingut de Acumulador (A) a la posició de memòria n
STX n Emmagatzemar el contingut del registre índex X a la posició de memòria n
ADDA n Sumar el contingut de l’Acumulador (A) amb el contingut de la posició de
memòria i emmagatzemar el resultat al registre acumulador.
JSR n Salt a subrutina
RET Retorn de subrutina

Modes d’adreçament:
#n : immediat n : directe
n,X : indexat sobre X [n]: indirecte
[n,X]: indexat sobre X, indirecte [n],X : indirecte,indexat sobre X

La pila s’implementa en memòria amb el registre SP. Creix cap a adreces de

memòria més baixes. El registre SP sempre apunta a l’última posició introduïda
de la pila.

Donat el següent fragment de codi, mostrar com va variant el contingut de les

primeres posicions de memòria, i dels registres PC, A, SP i X, després de
l’execució de cadascuna de les instruccions del programa, així com l’adreça
efectiva que s’utilitza en cada instrucció (DIR). La primera fila mostra l’estat
inicial de la memòria i els registres.
Escola d’Enginyeria ESTRUCTURA DE COMPUTADORS
Enginyeria Informàtica PROBLEMES
REPERTORI D’INSTRUCCIONS

Memòria Principal Registres

Programa 0 1 2 3 4 5 6 7 8 9 A X SP PC DIR
1 4 4 1 2 1 2 1 5 0 5 0 9 10h ---
10h LDAA #1 1 12h -
12h ADDA 1 Rd 5 14h 1
14h LDX [1] Rd Rd 2 16h 4
16h JSR #$30h 18h 8 18h/ 8
30h
30h ADDA 3,X Rd 6 32h 5
32h STAA [3],X 6 34h 3
34h LDAA [3,X] Rd Rd 4 36h 1
36h STAA [2],X Rd 4 38h 6
38h RET Rd 9 3Ah 8
/18h
Escola d’Enginyeria ESTRUCTURA DE COMPUTADORS
Enginyeria Informàtica PROBLEMES
REPERTORI D’INSTRUCCIONS

PROBLEMA 15.

Suposem que disposem de 3 màquines amb diferents arquitectures i modes de

execució. Els seus repertoris d’instruccions es descriuen de la manera següent:

ARQUITECTURES
6502 x86 RISC-V
LDA M MOV Ri, M MOV M, Rj LW rd,m(rs1)
STA M ADD Ri, Rj ADD Ri, M SW rs2,m(rs1)
ADD M SUB Ri, Rj SUB Ri, M ADD rd, rs1, rs2
Repertori SUB M (Ri=Ri-Rj) (Ri=Ri-M) SUB rd, rs1, rs2
d’Instruccions (Ac=Ac-M) MUL Ri, Rj MUL Ri, M (rd=rs1-rs2)
MUL M DIV Ri, Rj DIV Ri, M MUL rd, rs1, rs2
DIV M (Ri=Ri/Rj) (Ri=Ri/M) DIV rd, rs1, rs2
(Ac=Ac/M) (rd=rs1/rs2)
• En tots els casos, l’operand de més a l’esquerra (el primer operand) és
l’operand destí on s’emmagatzema el resultat).
• Les instruccions Load i Store transfereixen una dada entre memòria i un
registre. Per a la màquina de 1 adreça el registre destí és el registre
acumulador i per a les màquines de 2 i 3 adreces és qualsevol registre
del processador.
• La màquina de 1 adreça té un sol registre disponible, anomenat
acumulador, que es utilitzat per les instruccions operatives de forma
implícita. El codi d’operació es representa amb 8 bits i les adreces de
memòria amb 24 bits.
• La màquina de 2 adreces disposa de 32 registres. El codi d’operació es
representa amb 7 bits i les adreces de memòria amb 20 bits.
• La màquina de 3 adreces té 64 registres, i pot especificar fins a 3
operands de tipus registre per a les instruccions operatives, i un registre
i una adreça de memòria per a les de LOAD/STORE. El codi de operació
es representa amb 6 bits i les adreces de memòria amb 20 bits.
Per a les tres arquitectures:

- La longitud de les instruccions és un número múltiple de 8 bits.

- Els operands són 32 bits.
- El bus de dades és de 16 bits.
- L’execució de la instrucció de multiplicar (mul) requereix 40 ns, la de la
instrucció de dividir (div) 60 ns i la de la resta d’instruccions 20 ns. Aquests
temps no inclouen el temps necessari per a dur a terme els accessos a
memòria necessaris.
- El temps d’accés a la memòria per a lectura o escriptura és de 20 ns.
Escola d’Enginyeria ESTRUCTURA DE COMPUTADORS
Enginyeria Informàtica PROBLEMES
REPERTORI D’INSTRUCCIONS

a) Especificar per a cada arquitectura el format de cada tipus

d’instrucció del repertori.

Arquitectura 6502

Tipus d’Instrucció Format Mida (bits)

Op M COP (8) + Dir (24) 8+24= 32

Arquitectura x86

Tipus d’Instrucció Format Mida (bits)

Op Ri,M COP (7) + Reg (5) + Dir (20) 7+5+20= 32

Op M,Ri COP (7) + Dir (20) + Reg (5) 7+20+5= 32

Op Ri, Rj 7+5+5= 17
COP (7) + Reg (5) + Reg (5)
24

Arquitectura RISC-V

Tipus d’Instrucció Format Mida (bits)

Op Ri,M COP (6) + Reg (6) + Dir (20) 6+6+20= 32

Op M, Ri COP (6) + Dir (20) + Reg (6) 6+20+6= 32

Op Ri,Rj, Rk COP (6) + Reg (6) + Reg (6) + Reg (6) 6+6+6+6= 24

b) Escriure, per a cada una de les 3 màquines, el programa en

llenguatge assemblador que implementi el càlcul de la següent
expressió.
A=(E*(B-C))/( E-D)
Calcular la mida en bytes del programa, el número d’accessos a memòria per a
llegir el programa, el número de accessos a memòria per a accedir a les dades
i el temps total d’execució. Suposar que inicialment totes les dades estan a
memòria, que el resultat s’ha de deixar a memòria i que no s’han de modificar
els valors de les variables inicials.
Escola d’Enginyeria ESTRUCTURA DE COMPUTADORS
Enginyeria Informàtica PROBLEMES
REPERTORI D’INSTRUCCIONS

Màquina 6502
Instrucció N. bytes Accessos Accessos Temps total
instrucció (inst.) (dades)
1 LOAD E 4 2 2 20+80 = 100ns
2 SUB D 4 2 2 20+80 = 100ns
3 STORE A 4 2 2 20+80 = 100ns
4 LOAD B 4 2 2 20+80 = 100ns
5 SUB C 4 2 2 20+80 = 100ns
6 MUL E 4 2 2 40+80 = 120ns
7 DIV A 4 2 2 60+80 = 140ns
8 STORE A 4 2 2 20+80 = 100ns
… Total: 860ns

Màquina x86
Instrucció N. bytes Accessos Accessos Temps total
instrucció (inst.) (dades)
1 MOVE R1,E 4 2 2 20+80 = 100ns
2 SUBm R1,D 4 2 2 20+80 = 100ns
3 MOVE R2,B 4 2 2 20+80 = 100ns
4 SUBm R2,C 4 2 2 20+80 = 100ns
5 MULm R2,E 4 2 2 40+80 = 120ns
6 DIV R2,R1 3 2 0 60+40 = 100ns
7 MOVE A, R2 4 2 2 20+80 = 100ns
… Total: 720ns

Màquina RISC-V
Instrucció N. bytes Accessos Accessos Temps total
instrucció (inst.) (dades)
1 LOAD R1, E 4 2 2 20+80 = 100ns
2 LOAD R2, D 4 2 2 20+80 = 100ns
3 SUB R3,R1,R2 3 2 0 20+40 = 60ns
4 LOAD R4, B 4 2 2 20+80 = 100ns
5 LOAD R5, C 4 2 2 20+80 = 100ns
6 SUB R6,R4,R5 3 2 0 20+ 40 = 60ns
7 MUL R6,R1,R6 3 2 0 40+40 = 80ns
8 DIV R6,R6,R3 3 2 0 60+40 = 100ns
9 STORE A, R6 4 2 2 20+80 = 100ns

… Total: 800ns