1. Considerando que el prototipo de la función f1 es: int f1(int x, int y

UNIVERSIDAD TECNICA FEDERICO SANTA MARIA
DEPARTAMENTO DE ELECTRONICA
ELO311 Estructuras de Computadores
Primer Certamen
1.
Considerando que el prototipo de la función f1 es: int f1(int x, int y, int z);
El código contempla el convenio de uso para los registros.
.text
f1:
add $t8, $zero, $zero
a) Escribir el código de la función f1 en lenguaje C.
j
test
b) Calcular el retorno de la función para f1(9, 4, 5).
bloque: andi $t7, $a0, 1
beq $t7, $0, test
addu $a1, $a1, $a2
test:
blt $t8, $a0, bloque
add $v0, $a1, $zero
j
$ra
Solución.
a)
Los registros a0, a1 y a2 representan a los enteros: x, y, z respectivamente. Los
registros temporales se emplean, en este caso, para construir expresiones.
int f1(int x, int y, int z)
{ while ( 0 < x) if ( (x&1) != 0) y=y+z;
return( y);
}
b)
Como la función no modifica en valor de x, si éste es un valor mayor que cero, se
produce una repetición infinita, no saliendo del lazo while. Esto se considera un
error programación.
Ver al final otra solución.
2. Se tiene la siguiente función:
Los nombres de los argumentos deben escogerse de la lista, en el siguiente orden: w, x, y, z.
Los nombres de la variables locales debe escogerse de la lista, en el siguiente orden: l, m, n,
p.
.text
a) Determinar el tipo datos de los
f2:
addu $t0, $zero, $zero
argumentos de la función, en lenguaje C.
j
test
Indicando si son por valor o por
bloque:
sll
$t1, $t0, 2
referencia.
addu $v0, $t1, $a1
b) Declarar las variables locales que emplea
lw
$t2, 0($v0)
la función.
beq
$t2, $a3, salir
c) Por el uso que se les da a $t0 y $t1 con
addiu $t0, $t0, 1
qué tipo de datos opera la función. Qué se
test:
blt
$t0, $a0, bloque
almacena en $t2.
addu $v0, $zero, $zero
d) Cual es el tipo de datos del retorno de la
salir:
jr
$ra
función.
e) Código en lenguaje C de la función.
f) Qué realiza la función
Solución Primer Certamen.
09-09-2002
1
UNIVERSIDAD TECNICA FEDERICO SANTA MARIA
DEPARTAMENTO DE ELECTRONICA
ELO311 Estructuras de Computadores
Primer Certamen
Solución.
a)
Los argumentos vienen, por convenio en los registros $a0, $a1, $a2, $a3.
Los argumentos en a0 y a3 se usan en comparaciones, entonces son valores enteros de 32
bits, y corresponden a las variables w y z respectivamente. No se usa en el código de la
función a2. Debido a que en t2 se carga con la dirección contenida en v0, y que en este
registro se ha formado una expresión que es la suma de a1 con el valor del registro t1, se
desprende que el argumento a1 trae una dirección. Por los tanto es un parámetro por
referencia.
Entonces la lista de argumentos queda: (int w, int * x, int z)
b)
Se emplean los registros temporales t0, t1 y t2. Que llevarán los nombres: l, m y n.
No se emplean registros s.
Entonces la declaración de las locales queda: register int l = 0, m, n;
c)
Al inicio se efectúa t0 = 0; luego t1 = t0*4, después v0 = a1 + t0*4, para almacenar
en t2 el contenido de la dirección almacenada en v0. Se desprende entonces que la
función está manipulando un arreglo de enteros, cuya dirección inicial viene dada en
a1, y que el índice del arreglo se mantiene en t1.
d)
Por convenio el retorno de la función se devuelve en v=0, y en este registro se
mantiene una dirección de una componente del arreglo, o bien el valor cero. Entonces
la función retorna un puntero a un entero.
e)
La función puede escribirse:
int * f2(int w, int * x, int z)
{ register int l ;
for (l=0 ; l < w; l++) if (*(x+l) == z) return (x+l);
return( int *(0) );
/* o bien return (NULL) */
}
0
1
2
x
w-1
Nótese que el cálculo m=4*l; que realiza la función assembler no se refleja en el código en
C, ya que éste se abstrae del número de bytes del objeto apuntado. En C, un incremento de
un puntero en uno, se refleja en un incremento en cuatro bytes(el tamaño del entero), en
este caso. Es en el assembler en donde se materializa la abstracción de los tamaños de los
objetos direccionados por punteros; así como también la introducción de saltos y
bifurcaciones que levantan la abstracción de las sentencias de control de ejecución en alto
nivel.
f)
Se tiene un arreglo de w enteros apuntado por x.
Solución Primer Certamen.
09-09-2002
2
UNIVERSIDAD TECNICA FEDERICO SANTA MARIA
DEPARTAMENTO DE ELECTRONICA
ELO311 Estructuras de Computadores
Primer Certamen
Se compara el contenido de cada componente del arreglo con el valor almacenado en z. Si
los contenidos son iguales retorna la dirección de la componente de igual valor que z.
Si no encuentra el valor z en las w componentes de arreglo retorna un puntero nulo,
indicando que la búsqueda de z falló.
Usando notación de arreglos:
int * f2(int w, int x[ ], int z)
{ register int l ;
for (l=0 ; l < w; l++) if (x[ l ] == z) return (x+l);
return( NULL );
}
3. Desensamblar el siguiente código MIPS:
Dirección
0x0040003c
0x00400040
0x00400044
0x00400048
0x0040004c
0x00400050
0x00400054
Contenido Hex
0x341e000a
0x17d70001
0x02deb021
0x02d7b021
0x27deffff
0x001e402a
0x1500fffa
a) Considerando:
• Emplear símbolos para los registros y las
direcciones.
• Indicar con un rótulo en la instrucción
que corresponda, si se realiza algún salto.
• Escribir en equivalente decimal los
campos inmediatos.
b) Explicar en lenguaje C el algoritmo que
se realiza.
Solución:
a) Pasando de hexadecimal a binario:
Dirección
0x0040003c
0x00400040
0x00400044
0x00400048
0x0040004c
0x00400050
0x00400054
Contenido en Binario
0011 0100 0001 1110 0000 0000 0000 1010
0001 0111 1101 0111 0000 0000 0000 0001
0000 0010 1101 1110 1011 0000 0010 0001
0000 0010 1101 0111 1011 0000 0010 0001
0010 0111 1101 1110 1111 1111 1111 1111
0000 0000 0001 1110 0100 0000 0010 1010
0001 0101 0000 0000 1111 1111 1111 1010
Determinando el código de operación, y empleando el campo funct para las instrucciones
aritmética de tipo R, se obtiene:
Solución Primer Certamen.
09-09-2002
3
UNIVERSIDAD TECNICA FEDERICO SANTA MARIA
DEPARTAMENTO DE ELECTRONICA
ELO311 Estructuras de Computadores
Primer Certamen
Dirección
Contenido en Binario
op
funct
Instrucción Formato Instrucción
Cop
funct
0x0040003c 001101 00000111100000000000001010
ori
0x00400040 000101 11110101110000000000000001
bne
0x00400044 000000 10110111101011000000 100001
000000
0x00400048 000000 10110101111011000000 100001
000000
0x0040004c 001001 11110111101111111111111111
addiu
0x00400050 000000 00000111100100000000 101010
000000
0x00400054 000101 01000000001111111111111010
bne
Formando los campos de cada instrucción, de acuerdo al formato, se logra:
Dirección
op
Contenido en Binario
rs
rt
rd
shamt Funct
Inm16
I
I
R
R
I
R
I
Instrucción
addu
addu
slt
Formato
0x0040003c 001101 00000 11110 0000000000001010
I
ori
0x00400040 000101 11110 10111 0000000000000001
I
bne
0x00400044 000000 10110 11110 10110 00000 100001
R
addu
0x00400048 000000 10110 10111 10110 00000 100001
R
addu
0x0040004c 001001 11110 11110 1111111111111111
I
addiu
0x00400050 000000 00000 11110 01000 00000 101010
R
slt
0x00400054 000101 01000 00000 1111111111111010
I
bne
Considerando:
•
Emplear símbolos para los registros y las direcciones.
•
Indicar con un rótulo en la instrucción que corresponda, si se realiza algún salto.
•
Escribir en equivalente decimal los campos inmediatos.
Assembler
Assembler
Simbólico
Simbólico
Dirección
Contenido
Numérico
Hex
0x0040003c
0x00400040
0x00400044
0x00400048
0x0040004c
0x00400050
0x00400054
0x341e000a
0x17d70001
0x02deb021
0x02d7b021
0x27deffff
0x001e402a
0x1500fffa
Solución Primer Certamen.
ori $30, $0, 10
bne $30, $23, 1
addu $22, $22, $30
addu $22, $22, $23
addiu $30, $30, -1
slt
$8, $0, $30
bne $8, $0, -6
09-09-2002
do:
else:
ori $s8, $zero, 10
bne $s8, $s7, else
addu $s6, $s6, $s8
addu $s6, $s6, $s7
addiu $s8, $s8, -1
slt
$t0, $zero, $s8
bne $t0, $zero, do
4
UNIVERSIDAD TECNICA FEDERICO SANTA MARIA
DEPARTAMENTO DE ELECTRONICA
ELO311 Estructuras de Computadores
Primer Certamen
b) Llevando a lenguaje C, se obtiene:
do:
else:
ori
bne
addu
addu
addiu
slt
bne
$s8, $zero, 10
$s8, $s7, else #
$s6, $s6, $s8 #
$s6, $s6, $s7 #
$s8, $s8, -1
#
$t0, $zero, $s8 #
$t0, $zero, do #
$s8 != $s7
$s6 = $s6 + $s8
$s6 = $s6 + $s7
$s8 = $s8 - 1
$t0 = 1 si $zero <$s8
$t0 != $s7
s8 =10;
do
{
if( s8 == s7) s6+= s8;
s6 += s7;
s8--;
}
while(s8 > 0)
for(s8 = 10 ; s8 > 0; s8--)
j
for
{
ori
$s8, $zero, 10
if( s8 == s7) s6+= s8;
do:
bne $s8, $s7, else #
$s8 != $s7
s6 += s7;
addu $s6, $s6, $s8 #
$s6 = $s6 + $s8
}
else: addu $s6, $s6, $s7 #
$s6 = $s6 + $s7
addiu $s8, $s8, -1
#
$s8 = $s8 - 1
for:
slt
$t0, $zero, $s8 #
$t0 = 1 si $s8 > $zero
bne $t0, $zero, do #
$t0 != $s7
Noté que puede explicarse como un for, agregando un
salto al test de la condición, y un rótulo. Esta no era la
situación planteada.
1. Considerando que el prototipo de la función f1 es: int f1(int x, int y, int z);
El código contempla el convenio de uso para los registros. Con las modificaciones
realizadas durante el certamen, en el curso de R. Malonnek.
.text
f1:
add $t8, $zero, $zero
a) Escribir el código de la función f1 en lenguaje C.
j
test
b) Calcular el retorno de la función para f1(9, 4, 5).
bloque: andi $t7, $a0, 1
beq $t7, $0, test
addu $t8, $a1, $a2
test:
blt $t8, $a0, bloque
add $v0, $t8, $zero
j
$ra
a)
Los registros a0, a1 y a2 se reemplazan por las variables: x, y , z respectivamente.
Se emplea el registro temporal t8 como variable local i. El registro t7 se emplea para
construir la expresión condicional en C: si x es impar se cambia i a la suma de y mas z.
Solución Primer Certamen.
09-09-2002
5
UNIVERSIDAD TECNICA FEDERICO SANTA MARIA
DEPARTAMENTO DE ELECTRONICA
ELO311 Estructuras de Computadores
Primer Certamen
int f1(int x, int y, int z)
{ register int i=0;
while (i < x ) if ((x&1) != 0 ) i = y + z ;
return ( i )
}
b)
Al ingresar con x = 9, se efectúa la acción del while. Como x es impar, se actualiza i
al valor 4 + 5, y se vuelve a evaluar la condición del while. Esta vez no se cumple la
condición( ya que 9 < 9 es falso), y retorna el valor de i, que es 9.
Solución Primer Certamen.
09-09-2002
6