Arquitectura de Computadores

Prctica N 1
27/04/2010
1. Ejemplo
==========
Cdigo C
==========
...
char c[LARGO], tmp;
int n = LARGO;
int i, m;
...
m = n/2;
for(i=0; i<m; i++){
tmp = c[i];
c[i] = c[n-1-i];
c[n-1-i] = tmp;
}
...
============================
Cdigo Assembly (optimizado)
============================
#el rtulo D_C contiene la direccin del comienzo de la ristra c
#el rtulo D_N contiene la direccin de la variable n

FOR:

FIN:

la $t0, D_C
la $t1, D_N
lw $t1, 0($t1)
li $t2, 2
div $t1, $t2
mflo $t2

#
#
#
#
#
#

Carga Direccin de D_C, puntero a ristra

Carga Direccin de D_N, puntero a n
Carga entero n
Carga un 2 en $t2
Divide n en 2
Mueve resultado divisin a $t2

add $t1, $t1, $t0

addi $t1, $t1 , -1
add $t2, $t0, $t2

# Suma D_C con n, puntero final ristra +1

# Resta $t1 1, puntero final ristra
# Suma D_C con n/2, puntero a mitad ristra

beq $t0, $t2, FIN

lb $t3, 0($t0)
lb $t4, 0($t1)
sb $t4, 0($t0)
sb $t3, 0($t1)

#
#
#
#
#

addi $t0,$t0,1
addi $t1,$t1,-1

# Suma 1 a $t0
# Resta 1 a $t1

b FOR

# Salta a FOR

Si $t0 == $t2, salta a FIN

$t3 = ristra[$t0] (un char)
$t4 = ristra[$t1] (un char)
ristra[$t0] = $t4 (un char)
ristra[$t1] = $t3 (un char)

...

Pgina 1

2. Ejercicio
============
Cdigo C
============
char *string1, *string2, *p, *end;
int i, len;
...
end = string1;
len = 0;
while (*end != /0) {
end++;
len++;
}
p = string1;
do {
if ((*p > 64) && (*p < 91)) *string2 = *p + 32;
else if ((*p > 96) && (*p < 123)) *string2 = *p - 32;
p++
string2++;
} while (p -1 < end);
===============
Cdido Assembly
===============
#Rtulos DIR_STRING1, DIR_STRING2 son las direcciones donde apuntan los
#punteros string1 y string2. DIR_LEN contiene la posicin de memoria de
#la variable "len".
la $t0, DIR_STRING1
la $t1, DIR_LEN

#se carga direccion string1

#se carga direccion de len

li $t3, 0
move $t4, $t0

#len = 0
#end = string1

WHILE:

lb $t5, 0($t4)
beq $t5, $zer, FIN_W
addi $t4, $t4, 1
addi $t3, $t3, 1
b WHILE

#load char posicion $t4

#compara 0 con el char
#end++
#len++

FIN_W:

sb $t3, 0($t1)

#guarda len

la
li
li
li

#carga direccion string2

$t1,
$t5,
$t6,
$t7,

DIR_STRING2
64
91
96

Pgina 2

li $t8, 123
DO:

lb $t3, 0($t0)

#p = string1

ble $t3, $t5, STRING2

bge $t3, $t6, IF2
addi $t3, $t3, 32
b F_IF

#b si *p <= 64
#b si *p >= 91
#*string2=*p+32

IF2:

ble $t3, $t7, STRING2

bge $t3, $t8, F_IF
addi $t3, $t3, -32

#b si *p<=96
#b si *p>=123
#*string2=*p-32

F_IF:

sw $t3, 0($t1)

#store char modific.

STRING2:addi $t0, $t0, 1

addi $t1, $t1, 1
addi $t3, $t0, -1
blt $t3, $t4, DO

#p++
#string2++
#p - 1
#b si (p-1 < end)

...

Pgina 3

3. Ejemplo
=========
Cdigo C
=========
int v[10], n; // n argumento funcin
...
int cont = 0;
int i = 0;
while (i<n) {
if (v[i] == 1)
cont++;
i++;
}
...
================
Cdigo Assembly
================
#rotulos C_V y C_N y C_CONT contienen dir. de mem. inicio del vector v,
y variables n y cont.
CUNOS: la
la
li
li

$t0,
$t1,
$t4,
$t5,

C_V
C_N
1
0

addi $t1, $t1, -1

add $t1, $a0, $t1
WHILE: bge $t0, $t1, FIN
lw $t3, 0($t0)
bnq $t3, $t4, SEGUIR

#
#
#
#

Carga
Carga
Carga
Carga

direccin C_V, puntero a vector

direccin C_N, puntero a n
entero $t4 = 1
entero $t5 = 0 (cont)

# Resta 1 a $t1, puntero a vector -1

# Suma n a $t1, puntero a v[n]
# Si i >= n, salta a FIN
# $t3 = v[i]
# Si $t3 = 1, salta a SEGUIR

addi $t5, 1

# Suma 1 a cont

SEGUIR: addi $t0, 4

b WHILE

# Suma 1 a i
# Salta a WHILE

FIN:

...

Pgina 4

4. Ejercicio adicional
=========
Cdigo C
=========
unsigned int vec1[10],vec2[10],vec3[10],sum;
int i;
...
sum = 0;
for(i=0;i<10;i++) {
if (vec1[i] > vec2[i]) vec3[i] = vec1[i] - vec2[i];
else vec3[i] = vec2[i] - vec1[i];
sum = sum + vec3[i];
}
================
Cdigo Assembly
================

Pgina 5