Prctica 1 - Assembly MIPS

Arquitectura de Computadores, DIE, UDEC

9 de abril de 2014

Problemas
Escriba funciones en assembly MIPS que implementen las siguientes funciones en C.

Problema 1
Funcin que recibe como argumento dos numeros enteros y retorna el mayor de estos.
1
2
3
4
5

int mayor ( int a , int b )

{
if ( a > b ) return a ;
else return b ;
}

Problema 2
Funcin que calcula el determinante de una matriz cuadrada de orden 2, esta funcin recibe como
argumento un puntero con la direccion del primer elemento de la matriz, la cul es almacenada como un
array en memoria.
1
2
3
4

int det2 ( int * matriz )

{
int p1 = *( matriz ++) ;
int p2 = *( matriz ++) ;

p2 = p2 *(*( matriz ++) ) ;

p1 = p1 *(* matriz ) ;

6
7
8

return p1 - p2 ;

9
10

Problema 3
Funcin que recibe como argumento el puntero a un string y un caracter, esta funcin busca el caracter
en el string y retorna la posicin de este, en caso de no encontrar el caracter retorna -1.
1
2
3
4
5
6
7
8
9
10

int charfind ( char * str , char p )

{
int k = 0;
while (* str != 0)
{
if (*( str ++) == p ) return k ;
k ++;
}
return -1;
}

Solucin
Problema 1
1
2
3
4
5

MAYOR : ble $a0 , $a1 , FINM

move $v0 , $a0
jr $ra
FINM : move $v0 , $a1
jr $ra

#
#
#
#
#

if ( $a0 <= $a1 ) goto FINM

$a0 a valor de retorno
termina la funcion
$a1 a valor de retorno
termina la funcion

Problema 2
1
2

DET2 : lw $t0 , 0( $a0 )

lw $t1 , 4( $a0 )

# carga el primer valor desde memoria

# carga el segundo valor desde memoria

3
4
5
6
7

lw $t2 , 8( $a0 )
mul $t1 , $t2 , $t1
lw $t2 , 12( $a0 )
mul $t0 , $t2 , $t0

#
#
#
#

carga el tercer valor desde memoria

multiplica el tercer valor con el segundo
carga el cuarto valor desde memoria
multiplica el cuarto valor con el primero

sub $v0 , $t0 , $t1

jr $ra

# resta ambos resultados de multip licaci on

# termina la funcion

8
9
10

Problema 3
1
2
3
4
5
6
7
8
9

CHRFIND : li $v0 , 0
INICIO : add $t1 , $a0 , $v0
lb $t1 , 0( $t1 )
beq $t1 , $zero , FIN_1
beq $t1 , $a1 , FIN_2
addi $v0 , $v0 , 1
b INICIO
FIN_1 : li $v0 , -1
FIN_2 : jr $ra

#
#
#
#
#
#
#
#
#

k = 0
str + k
carga el valor de str + k de memoria
if (* str == 0) goto FIN_1
if (* str == p ) goto FIN_2
k ++
reincia ciclo
-1 a retorno
return

Ejemplo simulacin
A modo de ejemplo se muestra un programa en C que utiliza las funciones anteriores, adems se
muestra su equivalente en assembly MIPS.

Programa en C
1

# include < stdio .h >

2
3
4
5
6
7
8
9
10
11
12

int charfind ( char * str , char p )

{
int k = 0;
while (* str != 0)
{
if (*( str ++) == p ) return k ;
k ++;
}
return -1;
}

13
14
15
16
17
18

int mayor ( int a , int b )

{
if ( a > b ) return a ;
else return b ;
}

19
20
21
22
23

int det2 ( int * matriz )

{
int p1 = *( matriz ++) ;
int p2 = *( matriz ++) ;

24

p2 = p2 *(*( matriz ++) ) ;

p1 = p1 *(* matriz ) ;

25
26
27

return p1 - p2 ;

28
29

30
31
32
33
34

int main ()
{
char string [] = " Hola z " ;
char p = o ;

35

int matriz [2][2] = {{5 ,2} ,{2 ,2}};

36
37

int det = det2 (* matriz ) ;

int pos = charfind ( string , p ) ;

38
39
40

printf ( " Determinante %d \ n " , det ) ;

printf ( " Posicion %d \ n " , pos ) ;

41
42
43

printf ( " El mayor es %d \ n " , mayor ( det , pos ) ) ;

44
45

return 0;

46
47

Programa en Assembly
1
2
3

. data
mat : . word 5 , 2 , 2 , 2
str : . asciiz " Hola z "

4
5
6
7

det : . asciiz " Determinante "

pos : . asciiz " Posicion "
may : . asciiz " El mayor es "

fin : . asciiz " \ n "

9
10

. text

11
12
13
14
15
16
17
18
19
20
21
22

# main
main :

la $a0 , mat
sw $fp , -4( $sp )
addi $fp , $sp , -4
sw $ra , -4( $fp )
addi $sp , $fp , -4
jal DET2
addi $sp , $fp , 4
lw $ra , -4( $fp )
lw $fp , 0( $fp )
move $t0 , $v0

#
#
#
#
#
#
#
#
#

li $v0 , 4
la $a0 , det
syscall

# se configura el syscall para imprimir string

# se carga el string a imprimir
# se imprime string

li $v0 , 1
move $a0 , $t0
syscall

# se configura el syscall para impimir entero

#
#

li $v0 , 4
la $a0 , fin
syscall

# se configura el syscall para imprimir string

# se carga el string a imprimir
# se imprime string

la $a0 , str
li $a1 , 111
sw $fp , -4( $sp )
addi $fp , $sp , -4
sw $ra , -4( $fp )
sw $t0 , -8( $fp )

#
#
#
#

guarda el valor de fp en stack

fp como la nueva base del stack
guarda ra en stack
sp como el tope del stack
recupera el tope del stack
recupera ra
recupera fp
guarda valor en temporal

23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

decimal de o
guarda el valor de fp en stack
fp como la nueva base del stack
guarda ra en stack

42
43
44
45
46
47
48
49

addi $sp , $fp , -8

jal CHRFIND
addi $sp , $fp , 4
lw $t1 , -8( $fp )
lw $ra , -4( $fp )
lw $fp , 0( $fp )
move $t0 , $v0

# sp como el tope del stack

#
# recupera el tope del stack

li $v0 , 4
la $a0 , pos
syscall

# se configura el syscall para imprimir string

# se carga el string a imprimir
# se imprime string

li $v0 , 1
move $a0 , $t0
syscall

# se configura el syscall para impimir entero

#
#

li $v0 , 4
la $a0 , fin
syscall

# se configura el syscall para imprimir string

# se carga el string a imprimir
# se imprime string

move $a0 , $t1

move $a1 , $t0
sw $fp , -4( $sp )
addi $fp , $sp , -4
sw $ra , -4( $fp )
addi $sp , $fp , -4
jal MAYOR
addi $sp , $fp , 4
lw $ra , -4( $fp )
lw $fp , 0( $fp )
move $t0 , $v0

#
#
#
#
#
#
#
#
#

li $v0 , 4
la $a0 , may
syscall

# se configura el syscall para imprimir string

# se carga el string a imprimir
# se imprime string

# recupera ra
# recupera fp
# guarda valor en temporal

50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

guarda el valor de fp en stack

fp como la nueva base del stack
guarda ra en stack
sp como el tope del stack
recupera el tope del stack
recupera ra
recupera fp
guarda valor en temporal

74
75
76
77
78

79
80
81

li $v0 , 1
move $a0 , $t0
syscall

# se configura el syscall para impimir entero

#
#

li $v0 , 4
la $a0 , fin
syscall

# se configura el syscall para imprimir string

# se carga el string a imprimir
# se imprime string

li $v0 ,10
syscall

# se configura el syscall para terminar programa

# termina programa

82
83
84
85
86
87
88
89
90

# charfind

91
92
93
94
95
96
97
98
99
100

CHRFIND : li $v0 , 0
INICIO : add $t1 , $a0 , $v0
lb $t1 , 0( $t1 )
beq $t1 , $zero , FIN_1
beq $t1 , $a1 , FIN_2
addi $v0 , $v0 , 1
b INICIO
FIN_1 : li $v0 , -1
FIN_2 : jr $ra

#
#
#
#
#
#
#
#
#

k = 0
str + k
carga el valor de str + k de memoria
if (* str == 0) goto FIN_1
if (* str == p ) goto FIN_2
k ++
reincia ciclo
-1 a retorno
return

101
102

# det2

103
104

DET2 :

105

lw $t0 , 0( $a0 )
lw $t1 , 4( $a0 )

# carga el primer valor desde memoria

# carga el segundo valor desde memoria

lw $t2 , 8( $a0 )
mul $t1 , $t2 , $t1
lw $t2 , 12( $a0 )
mul $t0 , $t2 , $t0

#
#
#
#

sub $v0 , $t0 , $t1

jr $ra

# resta ambos resultados de mult iplica cion

# termina la funcion

ble $a0 , $a1 , FINM

move $v0 , $a0
jr $ra
move $v0 , $a1
jr $ra

#
#
#
#
#

106
107
108
109
110

carga el tercer valor desde memoria

multiplica el tercer valor con el segundo
carga el cuarto valor desde memoria
multiplica el cuarto valor con el primero

111
112
113
114
115

# mayor

116
117

MAYOR :

118
119
120
121

FINM :

if ( $a0 <= $a1 ) goto FINM

$a0 a valor de retorno
termina la funcion
$a1 a valor de retorno
termina la funcion