Considere que código ascii: `A` → 65 y `0` → 48. Puede usar macro

Certamen 1.
ELO311 Estructuras de Computadores.
Segundo Semestre 2009
1. Dado el siguiente programa en C (60 ptos)
int n = 28;
char a = ‘0’;
char b = ’0’;
char *p;
void itoah(register int x, register char *y) {
register int t = 0;
t = x + ‘0’;
if(t > ‘9’) t += 7;
*y = t; return;
}
int main(void) {
register int z = 0;
p = &a; z = n >> 4;
itoah(z, p);
p = &b; z = n & 0x0f;
itoah(z, p);
return 0;
}
2.
Considere que código ascii: 'A' → 65 y '0'
→ 48. Puede usar macro “la”. Use
registro $s0 para t en itoah y z en main.
Use registros temporales a partir de $t0.
a) Muestre contenido de la zona de
datos estáticos. (10 pts)
b) Dibuje el uso del stack para main e
itoah,
justifique
el
espacio
asignado. (10 pts)
c) Traducir a assembler
función main. (20 pts)
MIPS
d) Traducir a assembler
función itoah. (20 pts)
MIPS
Dado el siguiente código en Assembler MIPS, indique su equivalente en Lenguaje C. (40 pts)
add $t1,$zero,$zero
add $t3,$zero,$zero
lui $t1, 4096
lw $t2, 0($t1)
arriba: addi $t3, $t3, 1
bne $t3, $t2, arriba
Solución:
Pregunta 1 :
.data
n:
.word 0x1c
a1:
.byte 0x30
a2:
.byte 0x30
.align 2
p:
.word 0x0
.globl itoah
.text
itoah:
addu $sp,$sp,-4
sw $s0,0($sp)
# zona de datos estaticos (10 puntos)
TOS de itoah
# comienzo de la funcion itoah (20 puntos)
# abrir stack frame para itoah
# guardar $s0 en el stack de itoah
addi $s0, $a0, 48
addi $t0, $zero, 57
slt $t1, $t0, $s0
beq $t1, $zero, endif
addi $s0, $s0, 7
endif:
sb $s0,0($a1)
# $s0 = x + '0'
# $t0 = '9'
# $t1 =1 si $t0 < $S0 ('9' < t)
lw $s0,0($sp)
addu $sp,$sp,4
jr $ra
# recuperar $s0 desde el stack
# desarmar el stack frame de itoah
# retornar a main
TOS de itoah
$s0 de main
# *y = t = $s0
TOS de itoah
.end itoah
.globl main
.text
.align 2
.ent main
main:
addu $sp,$sp,-8
sw $s0,4($sp)
sw $ra,0($sp)
add $s0,$zero, $zero
la $t0, a1
la $t1, p
sw $t0, 0($t1)
la $t2, n
# comienzo de main (20 puntos)
# abrir stack frame para main
# guardar $s0 en el stack de main
# guardar $ra en el stack de main
# $t0 = &a1
# $t1 = &p
# p = &a
TOS de main
TOS de main
$s0 del llamante a
main
$ra del llamante a
main
lw $t3, 0($t2)
sra $s0,$t3, 4
add $a0, $zero, $s0
lw $a1, 0($t1)
jal itoah
la $t0, a2
la $t1, p
sw $t0, 0($t1)
la $t2, n
lw $t3, 0($t2)
andi $s0, $t3, 15
add $a0, $zero, $s0
lw $a1, 0($t1)
jal itoah
add $v0,$zero, $zero
# $t3 = n
# sra conceptualmente correcto, se accepta srl
# $a0 = z
# $a1 = p
lw $s0,4($sp)
lw $ra,0($sp)
addu $sp,$sp,8
jr $ra
.end main
# recuperar $s0 desde el stack frame de main
# recuperar $ra desde el stack frame de main
# desarmar el stack frame de itoah
# retornar a la funcion llamante de main
# $t0 = &a2
# $t1 = &p
# p = &b
# $t3 = n
# $s0 = n & 0x0f
# $a0 = z
# $a1 = p
# setear registro de retorno a 0
TOS de main
Pregunta 2 :
En C:
Dado la existencia de una instrucción lui y lw se puede inferir que se esta cargando un valor de una
variable declarada en memoria estática (variable global) por ejemplo en la dirección
0x10000000 x: .word 0x????????
# x contiene “algún valor”
Ahora dado que la condición se verifica después de ingresar al bloque a partir del rótulo arriba se
puede pensar en una estructura del tipo do-while
int x=0x????????;
(10 ptos)
y = 0;
do{
(10 ptos) // y = $t3
y = y +1;
}while(y != x)
(10 ptos)
(10 ptos)