Mips

Estructura de computadores
Tema 3. Programacin en ensamblador
Departamento de Informtica
Grupo de Arquitectura de Computadores, Comunicaciones y Sistemas
UNIVERSIDAD CARLOS III DE MADRID
Contenido
Fundamentos bsicos de la programacin en ensamblador
Ensamblador del MIPS 32, modelo de memoria y
representacin de datos
Formato de las instrucciones y modos de direccionamiento
Llamadas a procedimientos y uso de la pila
ARCOS-UC3M
Estructura de Computadores
Motivacin para aprender ensamblador

Para comprender qu ocurre
cuando un computador
ejecuta una sentencia de un
lenguaje de alto nivel.
C, C++, Java,
Para poder determinar el
impacto en tiempo de
ejecucin de una instruccin
de alto nivel.
Porque es til en dominios
especficos.
Compiladores,
SSOO
Juegos
Sistemas empotrados
Etc.
ARCOS-UC3M
Motivacin para usar MIPS 32

Arquitectura simple.
Facilidad de
aprendizaje.
Ensamblador similar al de
otros procesadores RISC
Usado en diversos
dispositivos
4
ARCOS-UC3M
Qu es un computador?
resultados
datos
Procesador
Instrucciones
ARCOS-UC3M
Instruccin mquina
001 AB 00000000101
Cdigo de operacin
Operandos
ARCOS-UC3M
Registros
Direcciones de memoria
Nmeros
Fases de ejecucin de una instruccin

Lectura de la instruccin (ciclo de fetch)
MAR
PC
Lectura
MBR
Memoria
PC
PC + 1
RI
MBR
PC
000100
RI
MAR
Decodificacin de la instruccin
Direccin
000100
MBR
Contenido
0010000000000000
Ejecucin de la instruccin
Volver a fetch
Memoria
ARCOS-UC3M
Propiedades de las instrucciones mquina

Realizan una nica y sencilla tarea
Operan sobre un nmero fijo de operandos
Son autocontenidas, incluyen toda la informacin necesaria
para su ejecucin
Incluye:
La operacin a realizar
Dnde se encuentran los operandos:
En registros
En memoria
En la propia instruccin
Dnde dejar los resultados

Una referencia a la siguiente instruccin a ejecutar
De forma implcita la siguiente
De forma explcita en las instrucciones de bifurcacin
ARCOS-UC3M
Programa
Secuencia ordenada de instrucciones mquina que se ejecutan
en secuencia
00001001110001101010111101011000
10101111010110000000100111000110
11000110101011110101100000001001
01011000000010011100011010101111
ARCOS-UC3M
temp = v[k];
v[k] = v[k+1];
v[k+1] = temp;
Diferentes niveles de lenguajes
Lenguaje de alto nivel

(ej: C, C++)
temp = v[k];
v[k] = v[k+1];
v[k+1] = temp;
compilador
Lenguaje ensamblador
(Ej: MIPS)
lw
lw
sw
sw
$t0, 0($2)
$t1, 4($2)
$t1, 0($2)
$t0, 4($2)
Ensamblador
Lenguaje Mquina
(MIPS)
ARCOS-UC3M
0000
1010
1100
0101
1001
1111
0110
1000
1100
0101
1010
0000
0110
1000
1111
1001
1010
0000
0101
1100
1111
1001
1000
0110
0101
1100
0000
1010
1000
0110
1001
1111
10
Lenguaje ensamblador
Emplea cdigos nemnicos para representar instrucciones
add suma
lw carga un dato de memoria
Emplea nombres simblicos para designar a datos y
referencias
$t0 identificador de un registro
Cada instruccin en ensamblador se corresponde con una
instruccin mquina
add $t1, $t2, $t3
ARCOS-UC3M
11
Modelo de programacin de un
computador
Un computador ofrece un modelo de programacin que est
formando:
Juego de instrucciones (lenguaje ensamblador)
Una instruccin incluye:
Cdigo de operacin
Otros elementos: identificadores de registros, direcciones de
memoria o nmeros
Elementos de almacenamiento
Registros
Memoria
Registros de los controladores de E/S
Modos de ejecucin
ARCOS-UC3M
12
Arquitectura MIPS
MIPS R2000/R3000
Procesador de 32 bits
Tipo RISC
CPU +
coprocesadores auxiliares
Coprocesador 0
excepciones, interrupciones
y sistema de memoria
virtual
Coprocesador 1
FPU (Unidad de Punto
Flotante)
ARCOS-UC3M
13
Banco de registros
Nombre
Simblico
del
registro
Nmero
Uso
zero
Constante 0
at
Reservado para el ensamblador
v0, v1
2, 3
Resultado de una rutina (o expresin)
a0, , a3
4, , 7
Argumento de entrada para rutinas
t0, , t7
8, , 15
Temporal (NO se conserva entre llamadas)
s0, , s7
16, , 23
Temporal (se conserva entre llamadas)
t8, t9
24, 25
Temporal (NO se conserva entre llamadas)
k0, k1
26, 27
Reservado para el sistema operativo
gp
28
Puntero al rea global
sp
29
Puntero a pila
fp
30
Puntero a marco de pila
ra
31
Direccin de retorno (rutinas)
ARCOS-UC3M
Hay 32 registros
Tamao de
1 palabra (4 bytes)
Se nombran con
un $ al principio
Convenio de uso
Reservados
Argumentos
Resultados
Temporales
Punteros
14
Tipos de instrucciones
De transferencia
Aritmtica
Lgicas
De desplazamiento
De rotacin
De comparacin
De bifurcacin
ARCOS-UC3M
15
Transferencia de datos
Copia de un dato en un registro. Carga inmediata
li $t0 5
$t0
5
Registro a registro
move $a0 $t0
$a0
$t0
Instrucciones de acceso a memoria (ms adelante)

De registro a memoria
De memoria a registro
ARCOS-UC3M
16
Aritmticas
Realiza operaciones aritmticas de entero (ALU) o aritmtica de
coma flotante (FPU)
Ejemplos de operaciones con enteros
Sumar
add $t0, $t1, $t2 $t0
addi $t0, $t1, 5
$t0
addu $t0, $t1, $t2 $t0
Restar
sub $t0 $t1 1
Multiplicar
mul $t0 $t1 $t2
Dividir
div $t0, $t1, $t2
$t0
rem $t0, $t1, $t2
$t0
ARCOS-UC3M
$t1 + $t2
$t1 + 5
$t1 + $t2
suma con desbordamiento

suma con desbordamiento
suma sin desbordamiento
$t1 / $t2 divisin entera

$t1 % $t2 resto de divisin entera
17
Ejemplo
int
int
int
int
a = 5;
b = 7;
c = 8;
d;
d = a * (b + c)
ARCOS-UC3M
li $t0, 5
li $t1, 7
li $t2, 8
add $t1, $t1, $t2

mul $t3, $t1, $t0
18
Ejemplo
int
int
int
int
a = 5;
b = 7;
c = 8;
d;
li
li
li
li
$t0, 5
$t1, 7
$t2, 8
$t3 10
d=-(a*(b-10)+c)
sub
mul
add
li
mul
ARCOS-UC3M
$t4,
$t4,
$t4,
$t5,
$t4,
$t1,
$t4,
$t4,
-1
$t4,
$t3
$t0
$t2
$t5
19
Lgicas
Operaciones booleanas
Ejemplos:
AND
and $t0 $t1 $t2
1100
($t0 = $t1 & $t2)

AND
OR
or $t0 $t1 $t2 ($t0 = $t1 | $t2)
ori $t0 $t1 80 ($t0 = $t1 | 80)
1010
1000
1100
OR
1010
1110
NOT
not $t0 $t1
XOR
or $t0 $t1 $t2
($t0 = ! $t1)
NOT
10
01
1100
($t0 = $t1 ^ $t2)
XOR
1010
0110
ARCOS-UC3M
20
Ejemplo
li $t0, 5
li $t1, 8
Cul es el valor de $t2?

and $t2, $t1, $t0
ARCOS-UC3M
21
Solucin
li $t0, 5
li $t1, 8

and $t2, $t1, $t0
and
ARCOS-UC3M
000 . 0101 $t0

000 .. 1000 $t1
000 .. 0000 $t2
22
Desplazamientos
De movimiento de bits
Ejemplos:
Desplazamiento lgico a la derecha
srl $t0 $t0 4 ($t0 = $t0 >> 4 bits)
01110110101
Desplazamiento lgico a la izquierda

sll $t0 $t0 5 ($t0 = $t0 << 5 bits)
01110110101
Desplazamiento aritmtico a la derecha

mantiene el signo
sra $t0 $t0 2 ($t0 = $t0 >> 2 bits)
11110110101
ARCOS-UC3M
23
Ejemplo
li $t0, 5
li $t1, 6

sra $t0, $t1, 1
ARCOS-UC3M
24
Ejemplo
li $t0, 5
li $t1, 6

sra
$t0, $t1, 1
ARCOS-UC3M
000 . 0110 $t1

Se desplaza 1 bit a la
derecha
000 .. 0011 $t0
25
Ejemplo
li $t0, 5
li $t1, 6

sra $t0, $t1, 1
ARCOS-UC3M
26
Ejemplo
li $t0, 5
li $t1, 6

sra $t0, $t1, 1
ARCOS-UC3M
000 . 0110 $t1

Se desplaza 1 bit a
la izquierda
000 .. 1100 $t0
27
Rotaciones
De movimiento de bits
Ejemplos:
Rotacin a la izquierda
rol $t0 $t0 4
rotan 4 bits
Rotacin a la derecha
ror $t0 $t0 5 rotan 5 bits
ARCOS-UC3M
01110110101
01110110101
28
Instrucciones de comparacin
seq $t0, $t1, $t2
sneq $t0, $t1, $t2
sge $t0, $t1, $t2
sgt $t0, $t1, $t2
sle $t0, $t1, $t2
slt $t0, $t1, $t2
ARCOS-UC3M
if ($t1 == $t2)
if ($t1 !=$t2)
if ($t1 >= $t2)
if ($t1 > $t2)
if ($t1 <= $t2)
if ($t1 < $t2)
$t0 = 1;
$t0 = 1;
$t0 = 1;
$t0 = 1;
$t0 = 1;
$t0 = 1;
else $t0 = 0
else $t0 = 0
else $t0 = 0
else $t0 = 0
else $t0 = 0
else $t0 = 0
29
Instrucciones de comparacin
seq $t0, $t1, $t2
sneq $t0, $t1, $t2
sge $t0, $t1, $t2
sgt $t0, $t1, $t2
sle $t0, $t1, $t2
slt $t0, $t1, $t2
ARCOS-UC3M
Set if equal
Set if no equal
Set if greater or equal
Set if greater than
Set if less or equal
Set if less than
30
Instrucciones de bifurcacin
Cambian la secuencia de ejecucin de las instrucciones
de un programa
Distintos tipos:
Bifurcacin o salto condicional:
beq $t0 $t1 0xE00012
Salta a la posicin 0xE00012, si valor $t0 == $t1
beqz $t1 direccion

Salta a la instruccin etiqueta con direccion si $t1 == 0
Bifurcacin o salto incondicional:
El salto se realiza siempre

j 0x10002E
b direccion
Llamadas a funciones:
jal 0x20001E jr $ra
ARCOS-UC3M
31
Instrucciones de bifurcacin
beqz
beq
bneq
bge
bgt
ble
blt
ARCOS-UC3M
$t0, direccion
$t0, $t1, direccion
$t0, $t1, direccion
$t0, $t1, direccion
$t0, $t1, direccion
$t0, $t1, direccion
$t0, $t1, direccion
Branch if $t0 == 0
Branch if equal (t0 == t1)
Branch if not equal (t0 t1)
Branch if greater or equal (t0 t1)
Branch if greater than (t0 > t1)
Branch if less or equal (t0 t1)
Branch if less than (t0 <t1)
32
Estructuras de control
while
int i;
i=0;
while (i < 10)
{
/* accin */
i = i + 1 ;
}
while:
li
$t0 0
li
$t1 10
bge $t0 t1 fin

# accin
addi $t0 $t0 1
b while
fin:
...
ARCOS-UC3M
33
Ejemplo
Calcular la suma 1 + 2 + 3 + . + 10
i=0;
s=0;
while (i <= 10)
{
s = s + i;
i = i + 1;
}
}
Resultado en $t1
ARCOS-UC3M
34
Solucin
Calcular la suma 1 + 2 + 3 + . + 10
i=0;
s=0;
while (i <= 10)
{
s = s + i;
i = i + 1;
}
}
while:
fin:
li
li
li
bge
add
addi
b
...
$t0 0
$t1 0
$t2 10
$t0 t2 fin
$t1 $t1 $t0
$t0 $t0 1
while
Resultado en $t1
ARCOS-UC3M
35
Ejemplo
Calcular el nmero de 1s que hay en un registro ($t0).
Resultado en $t3
i = 0;
n = 45; #numero
s=0;
while (i < 32)
{
b = ultimo bit de n
s = s + b;
se desplaza n un bit
a la derecha
i = i + 1 ;
}
}
ARCOS-UC3M
36
Solucin
Calcular el nmero de 1s que hay en un registro ($t0).
Resultado en $t3
i = 0;
n = 45; #numero
s=0;
while (i < 32)
{
b = ultimo bit de n
s = s + b;
se desplaza n un bit
a la derecha
i = i + 1 ;
}
}
ARCOS-UC3M
while:
fin:
li
li
li
li
bge
and
add
srl
addi
b
...
$t0 0
#i
$t1 45
#n
$t2 32
$t3 0
#s
$t0 t2 fin
$t4 $t1 1
$t3 $t3 $t4
$t1 $t1 1
$t0 $t0 1
while
37
Ejemplo
Obtener los 16 bits superiores de un registro ($t0) y dejarlos en
los 16 bits inferiores de otro ($t1)
ARCOS-UC3M
38
Solucin
Obtener los 16 bits superiores de un registro ($t0) y dejarlos en
los 16 bits inferiores de otro ($t1)
srl
ARCOS-UC3M
$t1,
01110110101
$t0,
16
Se desplaza a la derecha 16
Posiciones (de forma lgica)
39
if
int b1 = 4;
int b2 = 2;
li
li
li
if (b2 == 8) {
b1 = 0;
}
...
fin:
ARCOS-UC3M
$t0 4
$t1 2
$t2 8
bneq $t0 $t2

li
$t0 0
...
fin
40
if-else
int a=1;
int b=2;
li
$t1 1
li
$t2 2
if (a < b)
{
// accin 1
}
else
{
// accin 2
}
blt $t1 $t2 then
# cond.
else: ...
# accin 2
b
fin
# incond.
then: ...
# accin 1
fin: ...
ARCOS-UC3M
41
Ejemplo
Determinar si el contenido de un registro ($t2) es par. Si es par
se almacena en $t1 un 1, sino se almacena un 0
ARCOS-UC3M
42
Solucin
se almacena en $t1 un 1, sino se almacena un 0
li
$t2
li
$t1
rem $t1
$t2
beq $t1
$0
$t1
then
# se obtiene el resto
# cond.
else: li $t1 0
b fin
# incond.
then: li $t1 1
fin: ...
ARCOS-UC3M
43
Ejemplo
se almacena en $t1 un 1, sino se almacena un 0. En este caso
consultando el ltimo bit
ARCOS-UC3M
44
Solucin
se almacena en $t1 un 1, sino se almacena un 0. En este caso
consultando el ltimo bit
li
$t2 9
li
$t1 1
and $t1
$t2
beq $t1 $0
$t1
then
# se obtiene el ltimo bit

# cond.
else: li $t1 0
b fin
# incond.
then: li $t1 1
fin: ...
ARCOS-UC3M
45
Ejemplo
Calcular an
a en $t0
n en $t1
El resultado en $t2
a=8
n=4;
i=0;
p = 1;
while (i < n)
{
p = p * a
i = i + 1 ;
}
}
ARCOS-UC3M
46
Solucin
Calcular an
a en $t0
n en $t1
El resultado en $t2
a=8
n=4;
i=0;
p = 1;
while (i < n)
{
p = p * a
i = i + 1 ;
}
}
while:
fin:
ARCOS-UC3M
li
li
li
li
$t0
$t1
$t2
$t4
8
4
1
0
bge
mul
addi
b
move
$t4 $t1 fin

$t2 $t2 $t0
$t4 $t4 1
while
$t2 $t4
47
Contenido
ARCOS-UC3M
48
Simulador SPIM
http://pages.cs.wisc.edu/~larus/spim.html
SPIM es un simulador de una

arquitectura MIPS
Aplicacin multiplataforma:
Linux
Windows
MacOS
Permite simular una
arquitectura MIPS
ARCOS-UC3M
49
Simulador SPIM (otra versin)

http://sourceforge.net/projects/spimsimulator/files/
SPIM es un simulador de una

arquitectura MIPS
Aplicacin multiplataforma:
Linux
Windows
MacOS
Permite simular una
arquitectura MIPS
ARCOS-UC3M
50
Tarea
Instalar en el simulador SPIM que se va a utilizar en las
prcticas.
http://pages.cs.wisc.edu/~larus/spim.html
http://sourceforge.net/projects/spimsimulator/files/
Probar en el simulador pequeos programas en ensamblador
ARCOS-UC3M
51
MIPS: Visin general
ARCOS-UC3M
52
Arquitectura MIPS
MIPS R2000/R3000
Procesador de 32 bits
Tipo RISC
CPU +
coprocesadores auxiliares
Coprocesador 0
excepciones, interrupciones
y sistema de memoria
virtual
Coprocesador 1
FPU (Unidad de Punto
Flotante)
ARCOS-UC3M
53
Banco de registros
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
ARCOS-UC3M
Hay 32 registros
4 bytes de tamao
(una palabra)
Se nombran con
un $ al principio
Convenio de uso
Reservados
Argumentos
Resultados
Temporales
Punteros
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
54
Banco de registros
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
ARCOS-UC3M
$zero
Valor cableado a cero

No puede modificarse
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
55
Banco de registros
0
1
2
3
4
5
6
7
$zero
8
9
$t0
$t1
$t2
$t3
$t4
$t5
$t6
$t7
Valores temporales
10
11
12
13
14
15
ARCOS-UC3M
$t8
$t9
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
56
Banco de registros
0
1
2
3
4
5
6
7
$zero
8
9
$t0
$t1
$t2
$t3
$t4
$t5
$t6
$t7
Valores guardados
10
11
12
13
14
15
ARCOS-UC3M
$s0
$s1
$s2
$s3
$s4
$s5
$s6
$s7
$t8
$t9
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
57
Banco de registros
0
1
2
3
4
5
6
7
$zero
8
9
10
11
12
13
14
15
ARCOS-UC3M
$v0
$v1
$a0
$a1
$a2
$a3
$t0
$t1
$t2
$t3
$t4
$t5
$t6
$t7
$s0
$s1
$s2
$s3
$s4
$s5
$s6
$s7
$t8
$t9
Paso de parmetros y
Gestin de subrutinas
$sp
$fp
$ra
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
58
Banco de registros
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
ARCOS-UC3M
$zero
$at
$v0
$v1
$a0
$a1
$a2
$a3
$t0
$t1
$t2
$t3
$t4
$t5
$t6
$t7
Otros
$s0
$s1
$s2
$s3
$s4
$s5
$s6
$s7
$t8
$t9
$k0
$k1
$gp
$sp
$fp
$ra
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
59
Distribucin de la memoria
Hay 4 GB de memoria
direccionables en total
Parte de esa memoria la
utilizan los distintos
segmentos de un
proceso
Otra parte de la
memoria est reservada:
Un mini-sistema
operativo reside en
los primeros 4 MB
de memoria
ARCOS-UC3M
60
Distribucin de la memoria de un
programa
ARCOS-UC3M
61
Mapa de memoria de un programa

$fp
El programa de usuario se divide

en segmentos
01011001
Segmento de Pila
$sp
01011001
Segmento de pila
Variables locales
Contexto de funciones
Segmento de datos
Datos estticos
$gp
Segmento de cdigo (texto)

Cdigo
01011001
Segmento de Datos
Segmento de Texto
ARCOS-UC3M
pc
01011001
62
Estructura de un programa
ARCOS-UC3M
63
Simulador SPIM
Banco de
registros
$0, $1, $2,
$f0, $f1,
Segmento
de cdigo
Segmento
de datos
Segmento
de pila
Otros
ARCOS-UC3M
64
Simulador SPIM
Banco de
registros
$0, $1, $2,
$f0, $f1,
Segmento
de cdigo
Segmento
de datos
Segmento
de pila
ARCOS-UC3M
65
Ejemplo: Hola mundo

hola.s
.data
msg_hola: .asciiz "hola mundo\n"
.text
.globl main
main:
# printf("hola mundo\n") ;
li $v0 4
la $a0 msg_hola
syscall
ARCOS-UC3M
66
Ejemplo: Hola mundo

# comentario hasta fin de la lnea
instruccin/pseudoinstruccin
etiqueta:
operandos
.directiva
hola.s
.data
.text
.globl main
main:
li $v0 4
la $a0 msg_hola
syscall
ARCOS-UC3M
67
Ejemplo: Hola mundo

hola.s
.data
.text
.globl main
main:
li $v0 4
#cdigo de llamada
la $a0 msg_hola
syscall
ARCOS-UC3M
68
Programa en ensamblador: directivas

Directivas
Uso
.data
Siguientes elementos van al segmento de dato
.text
Siguientes elementos van al segmento de cdigo
.ascii
tira de caracteres
Almacena cadena caracteres NO terminada en carcter nulo
.asciiz
tira de caracteres
Almacena cadena caracteres terminada en carcter nulo
.byte
1, 2, 3
Almacena bytes en memoria consecutivamente
.half
300, 301, 302
Almacena medias palabras en memoria consecutivamente
.word
800000, 800001
Almacena palabras en memoria consecutivamente
.float
1.23, 2.13
Almacena float en memoria consecutivamente
.double 3.0e21
Almacena double en memoria consecutivamente
.space
Reserva un espacio de 10 bytes en el segmento actual
10
.extern etiqueta n
Declara que etiqueta es global de tamao n
.globl
etiqueta
Declara etiqueta como global
.align
Alinea el siguiente dato en un lmite de 2^n
ARCOS-UC3M
69
Definicin de datos estticos
ARCOS-UC3M
70
Llamadas al sistema
El simulador incluye un pequeo sistema operativo.
Ofrece 17 servicios.
Invocacin:
Cdigo de servicio en $v0.
Otros parmetros en registros concretos.
Invocacin mediante instruccin syscall.
ARCOS-UC3M
71
Llamadas al sistema
Servicio
Cdigo de
llamada ($v0)
Argumentos
Resultado
print_int
$a0 = integer
print_float
$f12 = float
print_double
$f12 = double
print_string
$a0 = string
read_int
integer en $v0
read_float
float en $f0
read_double
double en $f0
read_string
$a0=buffer,
$a1=longitud
sbrk
$a0=cantidad
exit
10
ARCOS-UC3M
direccin en $v0
72
Llamadas al sistema
Servicio
Cdigo de
llamada ($v0)
Argumentos
Resultado
print_char
11
read_char
12
open
13
Equivalente a $v0 = open($a0, $a1, $a2)
read
14
Equivalente a $v0 = read ($a0, $a1, $a2)
write
15
Equivalente a $v0 = write($a0, $a1, $a2)
close
16
Equivalente a $v0 = close($a0)
exit2
17
Termina el programa y hace que spim devuelva

el cdigo de error almacenado en $a0
ARCOS-UC3M
$a0 (cdigo ASCII)

$v0 (cdigo ASCII)
73
Ejemplo
ARCOS-UC3M
74
Ejemplo
ARCOS-UC3M
75
Modelo de memoria.
Direccionamiento por bytes
Los computadores actuales direccionan la memoria por bytes.
Un computador con direcciones de n bits puede direccionar 2n
bytes
Un computador con direcciones de 32 bits (MIPS 32)
puede direccionar 232 bytes de memoria= 4 GB
Las direcciones que genera un computador se refieren a bytes
El MIPS incluye instrucciones para acceder a:
bytes
palabras (4 bytes consecutivos)
ARCOS-UC3M
76
Espacio de direcciones.
Direcciones Byte
(contenido)
de bytes
0
1
2
3
4
5
6
Direccin: 6 (000110)
Contenido: 00001101 (9)
00001101
2n-1
ARCOS-UC3M
77
Espacio de direcciones.
Direcciones Byte
de bytes
(contenido)
0x0F000000
0x0F000001
0x0F000002
0x0F000003
ARCOS-UC3M
Direccin: 0x0F000002
Contenido: 00001101 (9)
00001101
78
Espacio de direcciones
Direcciones Byte
(contenido)
de bytes
0
1
2
3
4
5
6
00001101
Por razones de velocidad, las memorias

principales suelen tener un ancho de
palabra de 32 o 64 bits
El acceso a la memoria se realiza por
palabras
El mapa de memoria y la construccin
de la memoria son diferentes.
2n-1
ARCOS-UC3M
79
Espacio de direcciones y memoria fsica

Lgicamente
Direcciones Byte
(contenido)
de bytes
0
1
2
3
4
5
6
7
8
4
3
Fsicamente
Direcciones
de palabras
0
1
2
3
4
Palabra de 32 bits
(contenido)
7
byte 0
byte 1
byte 2
byte 3
2n-4
Un computador de 32 bits que direcciona la memoria

por bytes tiene un espacio de direcciones de 332 bytes
y 230 palabras
2n-1
ARCOS-UC3M
80
Acceso a memoria
Para un computador de 32 bits con direccionamiento por bytes:
La palabra tiene 32 bits (cuatro bytes)
Se pueden direccionar 232 bytes
La memoria est formada por 230 palabras
Existen instrucciones que permite acceder a:
Bytes almacenados en una direccin: A31 A0
Palabras almacenadas a partir de una direccin: A31 A0
El acceso fsico a la memoria se realiza a una palabra

completa con la direccin: A31 A2
Un byte situado en la direccin A31 A0 se encuentra
En la palabra de memoria A31 A2
En el byte A1A0 dentro de la palabra
ARCOS-UC3M
81
Espacio de direcciones y acceso a bytes

lb
$t1, 0x6
Direcciones Byte
(contenido)
de bytes
0
1
2
3
4
5
6
Contenido: 00001101 (9)
00001101
$t1
31
24 23
16 15
87
2n-1
ARCOS-UC3M
82

lb
$t1, 0x6
Direcciones Byte
(contenido)
de bytes
0
1
2
3
4
5
6
Contenido: 00001101 (9)
00001101
$t1
00000000
00000000
00000000
31
24 23
16 15
87
00001101
0
2n-1
ARCOS-UC3M
83

lb
$t1, 0x6
Direcciones Byte
(contenido)
de bytes
0
1
2
3
4
5
6
Contenido: 11111101 (-3 en complemento a 2)
11111101
$t1
31
24 23
16 15
87
2n-1
ARCOS-UC3M
84

lb
$t1, 0x6
Direcciones Byte
(contenido)
de bytes
0
1
2
3
4
5
6
11111101
$t1
31
11111111
11111111
11111111
24 23
16 15
87
11111101
0
2n-1
ARCOS-UC3M
85

lb
$t1, 0x6
Direcciones Byte
(contenido)
de bytes
0
1
2
3
4
5
6
11111101
$t1
31
11111111
11111111
11111111
24 23
16 15
87
11111101
0
Mantiene el signo
2n-1
ARCOS-UC3M
86

lbu $t1, 0x6
Direcciones Byte
(contenido)
de bytes
0
1
2
3
4
5
6
11111101
$t1
31
24 23
16 15
87
2n-1
ARCOS-UC3M
87

lbu $t1, 0x6
Direcciones Byte
(contenido)
de bytes
0
1
2
3
4
5
6
11111101
$t1
00000000
00000000
31
24 23
16 15
0000000
87
11111101
0
2n-1
ARCOS-UC3M
88

lbu $t1, 0x6
Direcciones Byte
(contenido)
de bytes
0
1
2
3
4
5
6
11111101
$t1
00000000
00000000
31
24 23
16 15
0000000
87
11111101
0
Carga sin mantener el signo
2n-1
ARCOS-UC3M
89
Espacio de direcciones y acceso a fsico a

bytes
Lgicamente
lbu $t1, 0x5
Fsicamente
Byte
0
1
2
3
4
5
6
7
Palabra de 32 bits
7
8
4
3
5
3
2
7
0
1
2
3
4
7
5
8
3
byte 0
4
2
byte 1
3
7
byte 2
byte 3
$t1
31
ARCOS-UC3M
24 23
16 15
87
90

bytes
Lgicamente
lbu $t1, 0x5
Fsicamente
Byte
0x5
0
1
2
3
4
5
6
7
Palabra de 32 bits
7
8
4
3
5
3
2
7
0
1
2
3
4
7
5
8
3
byte 0
4
2
byte 1
3
7
byte 2
byte 3
Para acceder al byte de la direccin

0x5 = 00000.000101
$t1
31
ARCOS-UC3M
24 23
16 15
87
91

bytes
Lgicamente
lbu $t1, 0x5
Fsicamente
Byte
0x5
0
1
2
3
4
5
6
7
7
8
4
3
5
3
2
7
Palabra de 32 bits
0
1
2
3
4
0x1
7
5
8
3
byte 0
4
2
byte 1
3
7
byte 2
byte 3
Se transfiere la segunda palabra:

00000.000101
30
$t1
31
ARCOS-UC3M
24 23
16 15
87
92

bytes
Lgicamente
lbu $t1, 0x5
Fsicamente
Byte
0x5
0
1
2
3
4
5
6
7
7
8
4
3
5
3
2
7
Palabra de 32 bits
0
1
2
3
0x1
7
5
8
3
byte 0
4
2
byte 1
3
7
byte 2
byte 3
Se transfiere al
procesador
5
$t1
31
ARCOS-UC3M
24 23
16 15
87
93

bytes
Lgicamente
lbu $t1, 0x5
Fsicamente
Byte
0
1
2
3
4
5
6
7
Palabra de 32 bits
7
8
4
3
5
3
2
7
0
4
8
12
16
7
5
8
3
byte 0
4
2
byte 1
3
7
byte 2
byte 3
00000.000101
2
5
Se copia el byte 01 (A1 A0) de la palabra
$t1
0
31
ARCOS-UC3M
0
24 23
0
16 15
3
87
94
Almacenamiento de palabras en la
memoria
Direcciones Byte
(contenido)
de bytes
0
1
2
3
4
5
6
7
8
4 bytes forman una palabra
Palabra almacenada a partir del byte 0

Palabra almacenada a partir del byte 4
2n-1
ARCOS-UC3M
95
memoria
Direcciones Byte
(contenido)
de bytes
0
1
2
3
4
5
6
7
8
Palabra de 32 bits
byte0
byte1
31
24 23
+ significativo
byte2
16 15
byte3
87
0
- significativo
2n-1
ARCOS-UC3M
96
memoria
Palabra de 32 bits
byte0
byte1
31
24 23
+ significativo
A
A+1
A+2
A+3
byte2
16 15
byte3
87
byte0
byte1
byte2
byte3
0
- significativo
A
A+1
A+2
A+3
BigEndian
byte3
byte2
byte1
byte0
LittleEndian
El nmero 27(10 = 11011(2 = 000000000000000000000000000011011

A
A+1
A+2
A+3
00000000
00000000
00000000
00011011
A
A+1
A+2
A+3
BigEndian
ARCOS-UC3M
00011011
00000000
00000000
00000000
LittleEndian
97
Problemas en la comunicacin entre

computadores con arquitectura distinta
El nmero 27(10 = 11011(2 = 000000000000000000000000000011011
A
A+1
A+2
A+3
00000000
00000000
00000000
00011011
A
A+1
A+2
A+3
BigEndian
ARCOS-UC3M
LittleEndian
98

El nmero 27(10 = 11011(2 = 000000000000000000000000000011011
A
A+1
A+2
A+3
00000000
00000000
00000000
00011011
BigEndian
ARCOS-UC3M
Transmisin de
datos por la red
A
A+1
A+2
A+3
LittleEndian
99

El nmero 27(10 = 11011(2 = 000000000000000000000000000011011
A
A+1
A+2
A+3
00000000
00000000
00000000
00011011
BigEndian
ARCOS-UC3M
Transmisin de
datos por la red
A
A+1
A+2
A+3
00000000
00000000
00000000
00011011
LittleEndian
100

El nmero 27(10 = 11011(2 = 000000000000000000000000000011011
A
A+1
A+2
A+3
00000000
00000000
00000000
00011011
A
A+1
A+2
A+3
BigEndian
00000000
00000000
00000000
00011011
LittleEndian
El nmero almacenado es: 000110110000000000000000000000000

que no es el 27
ARCOS-UC3M
101
Espacio de direcciones y acceso a palabras

Lgicamente
lw $t1, 0x4
Byte
0
1
2
3
4
5
6
7
00000000
00000000
00000001
00001101
Direccin 4 (000110)
Contenido: 00000000000000000000000100001101(2 = 269(10
Computador BigEndian
$t1
31
ARCOS-UC3M
24 23
16 15
87
102

palabras
Lgicamente
lw $t1, 0x4
Fsicamente
Byte
0
1
2
3
4
5
6
7
Palabra de 32 bits
0
1
2
3
4
00000000
00000000
00000001
00001101
00000000
byte 0
00000000
byte 1
00000001
byte 2
00001101
byte 3
$t1
31
ARCOS-UC3M
24 23
16 15
87
103

palabras
Lgicamente
lw $t1, 0x4
Fsicamente
Byte
0x4
0
1
2
3
4
5
6
7
Palabra de 32 bits
0
1
2
3
00000000
00000000
00000001
00001101
00000000
00000000
byte 0
byte 1
00000001
byte 2
00001101
byte 3
Para acceder a la palabra de la direccin

0x4 = 00000.000100
$t1
31
ARCOS-UC3M
24 23
16 15
87
104

palabras
Lgicamente
lw $t1, 0x4
Fsicamente
Byte
0x4
0
1
2
3
4
5
6
7
Palabra de 32 bits
0
1
2
3
00000000
00000000
00000001
00001101
00000000
00000000
byte 0
00000001
byte 1
byte 2
00001101
byte 3
Se transfiere al procesador
la palabra de memoria 1
00000000
00000000
00000001
00001101
$t1
31
ARCOS-UC3M
24 23
16 15
87
105

palabras
Lgicamente
lw $t1, 0x4
Fsicamente
Byte
0
1
2
3
4
5
6
7
Palabra de 32 bits
0
1
2
3
00000000
00000000
00000001
00001101
00000000
byte 0
00000000
00000000
byte 1
00000000
00000001
byte 2
00000001
00001101
byte 3
00001101
Se copia la palabra
$t1
00000000
31
ARCOS-UC3M
00000000
00000001
24 23
16 15
00001101
87
106
Diferencias entre lw, lb, lbu, la

Direcciones Byte
de bytes
(contenido)
0x0F000000
0x0F000001
0x0F000002
0x0F000003
ARCOS-UC3M
lw $t1, 0x0F000000
0xCB
0x12
0x08
0x02
107

Direcciones Byte
de bytes
(contenido)
0x0F000000
0x0F000001
0x0F000002
0x0F000003
lw $t1, 0x0F000000
0xCB
0x12
0x08
0x02
Se copia la palabra
(el contenido de la direccin)
0xCB
$t1
11001011
31
ARCOS-UC3M
0x12
0x08
0x02
00010010
00001000
00000010
24 23
16 15
87
108

Direcciones Byte
de bytes
(contenido)
0x0F000000
0x0F000001
0x0F000002
0x0F000003
lbu $t1, 0x0F000002
0xCB
0x12
0x08
0x02
Se copia el byte (el contenido)
0x08
$t1
00000000
31
ARCOS-UC3M
00000000
00000000
24 23
16 15
00001000
87
109

Direcciones Byte
de bytes
(contenido)
la $t1, 0x0F000000
Se copia la direccin,
no el contenido
0x0F000000
0x0F000001
0x0F000002
0x0F000003
0xCB
0x12
0x08
0x02
0x0F
$t1
00001111
31
ARCOS-UC3M
0x00
0x00
0x00
00000000
00000000
00000000
24 23
16 15
87
0
110
Ejemplo
Direcciones Byte
(contenido)
de bytes
li $t1, 18
li $t2, 24
0x0F000000
0x0F000001
0x0F000002
0x0F000003
0x0F000004
0x0F000005
0x0F000006
0x0F000007
ARCOS-UC3M
111
Ejemplo
Direcciones Byte
(contenido)
de bytes
0x0F000000
0x0F000001
0x0F000002
0x0F000003
0x0F000004
0x0F000005
0x0F000006
0x0F000007
li $t1, 18
li $t2, 24
$t1
00000000
31
$t2
00000000
31
ARCOS-UC3M
00000000
00000000
24 23
16 15
00010010
87
00000000
00000000
24 23
16 15
00011000
87
112
Ejemplo
Direcciones Byte
de bytes
(contenido)
sw $t1, 0x0F000000
Escribe el contenido de un registro en memoria (la
palabra completa)
0x0F000000
0x0F000001
0x0F000002
0x0F000003
0x0F000004
0x0F000005
0x0F000006
0x0F000007
00000000
00000000
00000000
00010000
$t1
00000000
31
$t2
00000000
31
ARCOS-UC3M
00000000
00000000
24 23
16 15
00010010
87
00000000
00000000
24 23
16 15
00011000
87
113
Ejemplo
Direcciones Byte
de bytes
(contenido)
0x0F000000
0x0F000001
0x0F000002
0x0F000003
0x0F000004
0x0F000005
0x0F000006
0x0F000007
00000000
00000000
00000000
00010000
00000000
00000000
00000000
00011000
sw $t1, 0x0F000000
sw $t2, 0x0F000004
$t1
00000000
31
$t2
00000000
31
ARCOS-UC3M
00000000
00000000
24 23
16 15
00010010
87
00000000
00000000
24 23
16 15
00011000
87
114
Ejemplo
Direcciones Byte
de bytes
(contenido)
sb $t1, 0x0F000001
Escribe el contenido del byte menos significativo
del registro $t1 en memoria
0x0F000000
0x0F000001
0x0F000002
0x0F000003
0x0F000004
0x0F000005
0x0F000006
0x0F000007
00010010
$t1
00000000
31
ARCOS-UC3M
00000000
00000000
24 23
16 15
00010010
87
115
Ejemplo
Direcciones Byte
de bytes
(contenido)
0x0F000000
0x0F000001
0x0F000002
0x0F000003
0x0F000004
0x0F000005
0x0F000006
0x0F000007
00000000
00000000
00000000
00010000
00000000
00000000
00000000
00011000
lw $t3, 0x0F000000
$t3
00000000
31
$t1
00000000
31
$t2
00000000
31
ARCOS-UC3M
00000000
00000000
24 23
16 15
00010010
87
00000000
00000000
24 23
16 15
00010010
87
00000000
00000000
24 23
16 15
00011000
87
116
Datos no alineados
Lgicamente
lw $t1, 0x05
????
Byte
0
1
2
3
4
5
6
7
8
Palabra de 32 bits
0
1
2
00000000
00000000
00000001
00001101
Fsicamente
3
4
00000000
00000000
00000001
00001101
byte 0
byte 1
byte 2
byte 3
Palabra
La palabra que est almacenada a partir

de la direccin 0x05 no est alineada porque
se encuentra en dos palabras de memoria
distintas
ARCOS-UC3M
117
Alineacin de datos
direccin
31
0
4
8
12
23
15
Esta palabra est alineada, el resto no
16
20
24
ARCOS-UC3M
118
Alineacin de datos
En general:
Un dato que ocupa K bytes est alineado cuando la
direccin D utilizada para accederlo cumple que:
D mod K = 0
La alineacin supone que:

Los datos que ocupan 2 bytes se encuentran en direcciones
pares
Los datos que ocupan 4 bytes se encuentran en direcciones
mltiplo de 4
Los datos que ocupan 8 bytes (double) se encuentran en
direcciones mltiplo de 8
ARCOS-UC3M
119
Alineacin de datos
En general los computadores no permiten el acceso a datos no
alineados
Objetivo: minimizar el nmero de accesos a memoria
El compilador se encarga de asignar a los datos las
direcciones adecuadas
Algunas arquitecturas como Intel permiten el acceso a datos no
alineados
El acceso a un dato no alineado implica varios accesos a
Palabra de 32 bits
memoria
0
1
2
3
4
ARCOS-UC3M
00000000
00000000
00001110
00001101
byte 0
byte 1
byte 2
byte 3
120
Resumen
Un programa para poder ejecutarse debe estar cargado junto
con sus datos en memoria
Todas las instrucciones y los datos se almacenan en memoria,
por tanto todo tiene una direccin de memoria
Las instrucciones y los datos
En un computador como el MIPS 32 (de 32 bits)
Los registros son de 32 bits
En la memoria se pueden almacenar bytes (8 bits)
Instrucciones memoria registro: lb, lbu, sb
Instrucciones registro memoria: sb
En la memoria se pueden almacenar palabras (32 bits)

Instruccin memoria registro: lw
Instruccin registro memoria: sw
ARCOS-UC3M
121
Instrucciones y pseudoinstrucciones
Una instruccin en ensamblador se corresponde con una
instruccin mquina
Ocupa 32 bits
addi $t1, $t1, 2
Una pseudoinstruccin en ensamblador se corresponde con
varias instrucciones mquina.
li $t1, 0x00800010
No cabe en 32 bits, pero se puede utilizar como
pseudoinstruccin.
Es equivalente a:
lui $t1, 0x0080
ori $t1, $t1, 0x0010
ARCOS-UC3M
122
Otro ejemplo de pseudoinstruccin

La pseudoinstruccin move
move
reg2,reg1
Se convierte en:
add
ARCOS-UC3M
reg2,$zero,reg1
123
Formatos de las instrucciones de acceso a

memoria
lw
sw
lb
sb
lbu
ARCOS-UC3M
Registro, direccin de memoria

Nmero que representa una
direccin
Etiqueta simblica que representa
una direccin
(registro): representa la direccin
almacenada en el registro
num(registro): representa la
direccin que se obtiene de sumar
num con la direccin almacenada
en el registro
124
Otros usos de la instruccin la, lw y lb

Direcciones Byte
de bytes
(contenido)
0x0F000000
0x0F000001
0x0F000002
0x0F000003
0xCB
0x12
0x08
0x02
$t0
31
24 23
16 15
87
31
24 23
16 15
87
$t1
ARCOS-UC3M
125

Direcciones Byte
de bytes
(contenido)
0x0F000000
0x0F000001
0x0F000002
0x0F000003
la $t0, 0x0F000000
0xCB
0x12
0x08
0x02
$t0
31
24 23
16 15
87
31
24 23
16 15
87
$t1
ARCOS-UC3M
126

Direcciones Byte
de bytes
(contenido)
0x0F000000
0x0F000001
0x0F000002
0x0F000003
la $t0, 0x0F000000
Se copia la direccin,
no el contenido
0xCB
0x12
0x08
0x02
$t0
00001111
00000000
00000000
31
24 23
16 15
00000000
87
31
87
$t1
ARCOS-UC3M
24 23
16 15
127

Direcciones Byte
de bytes
(contenido)
0x0F000000
0x0F000001
0x0F000002
0x0F000003
lbu
$t1, ($t0)
0xCB
0x12
0x08
0x02
$t0
00001111
00000000
00000000
31
24 23
16 15
00000000
87
31
87
$t1
ARCOS-UC3M
24 23
16 15
128

Direcciones Byte
de bytes
(contenido)
0x0F000000
0x0F000001
0x0F000002
0x0F000003
0xCB
0x12
0x08
0x02
lbu
Se copia el byte almacenado en la posicin de

memoria cuya direccin est almacenada en $t0
$t0
$t1
ARCOS-UC3M
$t1, ($t0)
00001111
00000000
00000000
31
24 23
16 15
00000000
87
00000000
00000000
00000000
31
24 23
16 15
11001011
87
129

Direcciones Byte
de bytes
(contenido)
0x0F000000
0x0F000001
0x0F000002
0x0F000003
0xCB
0x12
0x08
0x02
lw
Se copia la palabra almacenada en la posicin de

memoria cuya direccin est almacenada en $t0
$t0
$t1
ARCOS-UC3M
$t1, ($t0)
00001111
00000000
00000000
31
24 23
16 15
00000000
87
11001011
00010010
00001000
31
24 23
16 15
00000010
87
130

lbu $t0, 0x0F000002
Direccionamiento directo. Se carga en $t0 el byte
almacenado en la posicin de memoria 0x0F000002
lbu $t0, ($t1)
Direccionamiento indirecto de registro. Se carga en $t0 el
byte almacenado en la posicin de memoria almacenada en
$t1
lbu $t0, 80($t1)
Direccionamiento relativo. Se carga en $t0 el byte
almacenado en la posicin de memoria que se obtiene de
sumar el contenido de $t1 con 80
ARCOS-UC3M
131
Instrucciones de escritura en memoria

sw $t0, 0x0F000000
Copia la palabra almacenada en $t0 en la direccin
0x0F000000
sb $t0, 0x0F000000
Copia la byte almacenado en $t0 en la direccin
0x0F000000
ARCOS-UC3M
132
Tipo de datos bsicos

enteros
.data
int
resultado ;
int
op1 = 100 ;
int
op2 = -10 ;
resultado:
op1:
op2:
.word 0
.word 100
.word -10
...
...
.text
.globl main
main: lw $t1 op1
main ()
lw $t2 op2
{
resultado = op1 + op2 ;
...
}
ARCOS-UC3M
add $t3 $t1 $t2

la $t4 resultado
sw $t3 ($t4)
...
133
Ejercicio
Indique un fragmento de cdigo en ensamblador con la misma
funcionalidad que:
int
int
int
int
b;
a = 100 ;
c = 5 ;
d;
main ()
{
d = 80;
b = -(a+b*c+a);
}
Asumiendo que a, b, c y d son variables que residen en memoria

ARCOS-UC3M
134

vectores (arrays)
Conjunto de elementos ordenados
consecutivamente en memoria
La direccin del elemento j se
obtiene como:
Direccion_inicio + j * p
Siendo p el tamao de cada
elemento
ARCOS-UC3M
Direccion_inicio
v[0]
v[1]
v[2]
v[N-1]
135

vectores (arrays)
.data
.align
#siguiente dato alineado a 4
vec: .space 20
int vec[5] ;
...
main ()
{
vec[4] = 8;
#5 elem.*4 bytes
.text
.globl main
main:
la $t1 vec
li $t2
sw $t2 16($t1)
...
ARCOS-UC3M
136

vectores (arrays)
.data
.align
vec: .space 20
int vec[5] ;
...
main ()
{
vec[4] = 8;
#5 elem.*4 bytes
.text
.globl main
main:
li
$t0 16
la
$t1
vec
add $t3, $t1, $t0

li
$t2
sw
$t2, ($t3)
...
ARCOS-UC3M
137

vectores (arrays)
.data
int vec[5] ;
...
.align
2
#siguiente dato alineado
vec: .space 20
#5 elem.*4 bytes
a 4
.text
main ()
{
vec[4] = 8;
}
.globl main
main:
li $t2
li $t1
16
sw $t2 vec($t1)
...
ARCOS-UC3M
138
Ejercicio
Si V es un array de nmeros enteros (int)
V representa la direccin de inicio de vector
En qu direccin se encuentra el elemento V[5]?
Qu instruccin permite cargar en el registro $t0 el valor
v[5]?
ARCOS-UC3M
139

matrices
Una matriz m x n se compone de m
vectores de longitud n
Normalmente se almacenan en
memoria por filas
El elemento aij se encuentra en la
direccin:
direccion_inicio + (i n + j) p
1 vector
2 vector
siendo p el tamao de cada elemento
ARCOS-UC3M
140

matrices
.data
.align 2
int vec[5] ;
int mat[2][3] = {{11,12,13},
{21,22,23}};
...
vec: .space 20
#5 elem.*4 bytes
mat: .word 11, 12, 13

.word 21, 22, 23
...
main ()
{
m[0][1] = m[0][0] +
m[1][0] ;
...
}
.text
.globl main
main:
lw $t1 mat+0
lw $t2 mat+12
add $t3 $t1 $t2
sw
$t3 mat+4
...
ARCOS-UC3M
141

string
Array de bytes
El fin se marca con
el cdigo 0
char c1 ;
char c2=h ;
char *ac1 = hola ;
...
main ()
{
printf(%s,ac1) ;
...
}
ARCOS-UC3M
.data
c1: .space 1
# 1 byte
c2: .byte h
ac1: .asciiz hola
...
.text
.globl main
main:
li $v0 4
la $a0 ac1
syscall
...
142

Longitud de un string
.data
char
char
char
Char
...
c1 ;
c2=h ;
*ac1 = hola ;
*c;
c1:
.space 1
c2:
.byte h
# 1 byte
ac1: .asciiz hola

...
.text
.globl main
main:
la $t0, ac1
li $a0, 1
main ()
{
c = ac1; int l = 0;
while (*c != NULL) {
c++; l++;
}
printf(%d, l);
...
}
lbu $t1, ($t0)

buc:
beqz $t1, fin

addi $t1, $t1, 1
addi $a0, $a0, 1
lbu
$t1, ($t0)
b buc
fin:
li $v0 1
syscall
...
ARCOS-UC3M
143
Vectores y cadenas
En general:
lw $t0, 4($s3) # $t0
sw $t0, 4($s3) # M[$s3+4]
ARCOS-UC3M
M[$s3+4]
$t0
144
Ejercicio
Escriba un programa en ensamblador equivalente a:
int vec[100] ;
...
main ()
{
int i = 0;
for (i = 0; i < 100; i++)
vec[i] = 5;
Asumiendo que en $a0 se encuentra almacenada la direccin del

vector
ARCOS-UC3M
145
Ejercicio
Escriba un programa en ensamblador equivalente a:
int vec[100] ;
...
main ()
{
int i = 0;
suma = 0;
for (i = 0; i < 100; i++)
suma = suma + vec[i];
}
Asumiendo que en $a0 se encuentra almacenada la direccin del

vector y que el resultado ha de almacenarse en $v0
ARCOS-UC3M
146
Ejercicio
Escriba un programa que:
Indique el nmero de veces que aparece un carcter en una
cadena de caracteres
La direccin de la cadena se encuentra en $a0
El carcter a buscar se encuentra en $a1
El resultado se dejar en $v0
ARCOS-UC3M
147
Instrucciones de coma flotante

Banco de registros de coma flotante (32 registros)
$f0, $f1, .. $31
Para valores de simple precisin: $f0, .. $f31
Se corresponde con variables de tipo float
Para valores de doble precisin (64 bits) se utilizan por
parejas: $f0, $f2, $f4, .
Se corresponden con variables
FPU
de tipo double
$f1
$f3
$f0
$f2
$f31
$f30
B.R.
ALU
BUS
ARCOS-UC3M
148
Instrucciones de coma flotante

Sumas de precisin simple (add.s) y doble (add.d)
Restas de precisin simple (sub.s) y doble (add.d)
Multiplicacin de precisin simple (mul.s) y doble (mul.d)
Divisin de coma flotante (div.s) y doble (div.d)
Comparacin de precisin simple (c.x.s) y doble (c.x.d)
x puede ser: eq, neq, lt, le, gt, ge
Salto condicional en coma flotante
Verdadero (bclt) o falso (bclf)
ARCOS-UC3M
149
Operaciones en coma flotante

Aritmtica de coma flotante IEEE 754 en la FPU
Ejemplos:
FPU
Suma simple precisin
add.s
$f0
$f1
$f1 $f4
$f3
$f0
$f2
$f31
$f30
B.R.
f0 = f1 + f4
ALU
Suma doble precisin
add.d
$f0 $f2
$f4
BUS
(f0,f1) = (f2,f3) + (f4,f5)
Otras operaciones en simple precisin:

add.s, sub.s, mul.s, div.s, abs.s
Operaciones en doble precisin:
add.d, sub.d, mul.d, div.d, abs.d
ARCOS-UC3M
150
Operaciones en coma flotante

Transferencia entre registros de coma flotante y memoria:
lwc1
$f0,
direccion:
Carga en $f0 un valor de tipo float almacenado en

direccion
swc1 $f0, direccion:

Almacena el valor de tipo float de $f0 en memoria
l.s y s.s son equivalentes

ldc1 $f0, direccion:
Carga en ($f0, $f1) un valor de tipo double
sdc1 $f0, direccion

Almacena el valor de tipo double ($f0, $f1) en
memoria
l.d y s.d son equivalentes

ARCOS-UC3M
151

float
.data
resultado:
op1:
op2:
float resultado ;
float op1 = 100 ;
.float
.float 100
.float -10
...
float op2 = -10 ;

...
.text
.globl main
main: l.s
main ()
l.s
{
resultado = op1 + op2 ;
...
}
ARCOS-UC3M
add.s
s.s
...
$f0 op1
$f1 op2
$f3 $f1 $f2
$f3 resultado
152

double
.data
resultado:
op1:
op2:
double resultado ;
double op1 = 100 ;
.double
.double 100
.double -10.27
...
double op2 = -10.27 ;

...
.text
.globl main
main: l.d
main ()
l.d
{
resultado = op1 * op2 ;
...
}
ARCOS-UC3M
mul.d
s.d
...
$f0 op1
$f2 op2
# ($f0,$f1)
# ($f2,$f3)
$f6 $f0 $f2

$f6 resultado
153
Operaciones con registros (CPU, FPU)
mtc1
$t0
$f1
FPU
CPU
t0
t1
B.R. enteros
$f1
$f3
$f31
$f0
$f2
$f30
B.R.
U.C
ALU
BUS
ARCOS-UC3M
ALU
BUS
154
Operaciones con registros (CPU, FPU)
mfc1
$t0
$f1
FPU
CPU
t0
t1
B.R. enteros
$f1
$f3
$f31
$f0
$f2
$f30
B.R.
U.C
ALU
BUS
ARCOS-UC3M
ALU
BUS
155
Operaciones con registros (FPU, FPU)
mov.s
$f0
$f1
FPU
FPU
$f1
$f0
$f1
$f3
$f2
$f3
$f31
$f30
ALU
BUS
B.R.
$f31
$f0
$f2
$f30
ALU
BUS
$f0
ARCOS-UC3M
B.R.
$f1
156
Operaciones con registros (FPU, FPU)
mov.d
$f0
FPU
FPU
$f1
$f0
$f1
$f3
$f2
$f3
$f31
$f30
B.R.
$f31
$f0
$f2
$f30
B.R.
ALU
ALU
BUS
BUS
($f0, $f1)
ARCOS-UC3M
$f2
($f2, $f3)
157
Operaciones de conversin
cvt.s.w $f2 $f1
Convierte un entero ($f1) a simple precisin ($f2)
cvt.w.s $f2 $f1
Convierte de simple precisin ($f1) a entero ($f2)
cvt.d.w $f2 $f0
Convierte un entero ($f0) a doble precisin ($f2)
cvt.w.d $f2 $f0
Convierte de doble precisin ($f0) a entero ($f2)
cvt.d.s $f2 $f0
Convierte de simple precisin ($f0) a doble ($f2)
cvt.s.d $f2 $f0
Convierte de doble precisin ($f0) a simple($f2)
ARCOS-UC3M
158
Operaciones de carga
li.s $f4, 8.0
Carga el valor float 8.0 en el registro $f4
li.d $f2, 12.4
Carga el valor double 12.4 en el registro $f2
ARCOS-UC3M
159
Ejemplo
float PI
int
.text
.globl main
= 3,1415;
radio = 4;
float longitud;
main:
longitud = PI * radio;
ARCOS-UC3M
li.s
li
$f0 3.1415
$t0 4
mtc1
cvt.s.w
mul.s
$t0 $f1
$f2 $f1
$f0 $f2 $f1
# 4 en Ca2
# 4 ieee754
160
Ejemplo
float PI
int
.text
.globl main
= 3,1415;
radio = 4;
float longitud;
main:
longitud = PI * radio;
FPU
CPU
t0
t1
B.R. enteros
$f1
$f3
$f31
$f0
$f2
$f30
B.R.
li.s
li
$f0 3.1415
$t0 4
mtc1
cvt.s.w
mul.s
$t0 $f1
$f2 $f1
$f0 $f2 $f1
# 4 en Ca2
# 4 ieee754
U.C
ALU
BUS
ARCOS-UC3M
ALU
BUS
161
Ejercicio
Escriba un programa que:
Cargue el valor -3.141516 en el registro $f0
Permita obtener el valor del exponente y de la mantisa
almacenada en el registro $f0 (en formato IEEE 754)
Imprima el signo
Imprima el exponente
Imprima la mantisa
ARCOS-UC3M
162
Solucin
li $s0, 0x80000000
and $a0, $t0, $s0
srl $a0, $a0, 31
li $v0, 1
syscall
.data
saltolinea:
.text
.globl main
main:
li.s
.asciiz
"\n"
la $a0,
li $v0,
syscall
$f0, -3.141516
saltolinea
4
#se imprime
mov.s $f12, $f0
li $v0, 2
syscall
li $s0, 0x7F800000
and $a0, $t0, $s0
srl $a0, $a0, 23
li $v0, 1
syscall
la $a0,
li $v0,
syscall
la $a0,
li $v0,
syscall
# se
mfc1
saltolinea
4
copia al procesador
$t0, $f12
#signo
#exponente
saltolinea
4
li $s0, 0x007FFFFF
and $a0, $t0, $s0
li $v0, 1
syscall
#mantisa
jr $ra
ARCOS-UC3M
163
Contenido
ARCOS-UC3M
164
Informacin de una instruccin

El tamao de la instruccin se ajusta al de palabra (o mltiplo)
Se divide en campos:
Operacin a realizar
Operandos a utilizar
Puede haber operando implcitos
El formato de una instruccin indica los campos y su tamao:

Uso de formato sistemtico
Tamao de un campo limita los valores que codifica
ARCOS-UC3M
165
Informacin de una instruccin

Se utiliza unos pocos formatos:
Una instruccin pertenecen a un formato
Segn el cdigo de operacin se conoce el formato asociado
Ejemplo: formatos en MIPS

Tipo R
op.
rs
rt
rd
shamt
func.
6 bits
5 bits
5 bits
5 bits
5 bits
6 bits
Tipo I
op.
rs
rt
offset
transferencia
inmediato
6 bits
5 bits
5 bits
16 bits
Tipo J
op.
aritmticas
offset
saltos
6 bits
ARCOS-UC3M
26 bits
166
Campos de una instruccin

En los campos se codifica:
Operacin a realizar (cdigo Op.)
Instruccin y formato de la misma
Operandos a utilizar
Ubicacin de los operandos
Ubicacin del resultado
Ubicacin de la siguiente instruccin (si op. salto)
Implcito: PC
PC + 4 (apuntar a la siguiente
instruccin)
Explcito: j 0x01004
(modifica el PC)
ARCOS-UC3M
167
Ubicaciones posibles para los operandos
En la propia instruccin
En los registros del procesador
En memoria principal
En unidades de Entrada/Salida (I/O)
ARCOS-UC3M
168
Modos de direccionamiento
El modo de direccionamiento es un procedimiento que permite
determinar la ubicacin de un operando o una instruccin
Tipos:
Inmediato
Directo
De registro
Indirecto
Indirecto de registro
Relativo
A registro base
A registro ndice
A contador de programa
Implcito
De pila
ARCOS-UC3M
169
Direccionamiento inmediato
El operando es parte de la instruccin.
Ejemplo:
li
$a0
addi $t1
25
$t2
50
Es rpido: no es necesario acceder a memoria.

No siembre cabe el valor en una palabra:
li $t1, 0x00800010
No cabe en 32 bits, es equivalente a:
lui $t1, 0x0080
ori $t1, $t1, 0x0010
ARCOS-UC3M
170
Direccionamiento de registro
El operando se encuentra en el registro.
Ejemplo: move $a0 $a1
Copia en el registro $a0 el valor que hay en el registro $a1.
El identificador de $a0 y $a1 estn codificados en la instruccin.
op
rs
rt
16 bits
Operando
B.Reg.
Ventajas:
Acceso a registros es rpido
El nmero de registros es pequeo => pocos bits para
sucodificacin, instrucciones ms cortas
ARCOS-UC3M
171
Direccionamiento directo
El operando se encuentra en memoria, y la direccin est
codificada en la instruccin.
Ejemplo (MIPS): lw $t1, 0xFFF0
Carga en $t1 el dato que hay en la posicin de memoria 0xFFF0
memoria
Operando
op
rs
rt
16 bits
Desventajas:
Acceso a memoria es lento comparado con los registros
Direcciones largas => instrucciones ms largas
ARCOS-UC3M
172
Direccionamiento indirecto de registro

Se indica en la instruccin el registro
que almacena la direccin del operando
memoria
B.Reg.
operando
Ejemplo (MIPS): lw $a0 ($a1)

Carga en $a0 lo que hay en la direccin
de memoria almacenada en $a1.
op
rs
rt
direccin
16 bits
Ventajas:
Instrucciones cortas
En el caso del MIPS permite direccionar toda la memoria (32 bits)
ARCOS-UC3M
173
Direccionamiento indirecto a memoria

Se indica en la instruccin la direccin donde est
la direccin del operando (no disponible en el MIPS)
Ejemplo: LD R1 [DIR] (IEEE 694)
Carga en R1 lo que hay en la direccin
de memoria que est almacenada en la direccin de
memoria DIR.
op
memoria
operando
direccin2
direccion1
Desventajas:
Puede requerir varios accesos a memoria
Es ms lento
ARCOS-UC3M
174
Direccionamiento relativo a registro base

Ejemplo:
lw $a0 12($t1)
Carga en $a0 el contenido de la posicin de memoria dada por: $t1 + 12
Instruccin
Codop Registro R
Desplazamiento
Memoria
Banco de Registros
Direccin de memoria
ARCOS-UC3M
Operando
175
Utilidad: acceso a vectores

Se carga en el registro
la direccin de inicio
del vector
.data
.align
vec: .space 20
#5 elem.*4 bytes
.text
int vec[5] ;
...
.globl main
main:
la $t1 vec
li $t2
main ()
{
v[4] = 8;
sw $t2 16($t1)
...
ARCOS-UC3M
176
Direccionamiento relativo a registro ndice

Ejemplo:
lw $a0 direccion($t1)
Carga en $a0 el contenido de la posicin de memoria

dada por: $t1 + direccion
$t1 representa un ndice
Instruccin
Codop Registro R
direccin
Memoria
Registros
ndice/desplazamiento
ARCOS-UC3M
Operando
177
Utilidad: acceso a vectores

Se carga en el registro
la direccin de inicio
del vector
.data
.align
vec: .space 20
#5 elem.*4 bytes
.text
int vec[5] ;
...
.globl main
main:
li $t1 12
li $t2
main ()
{
v[3] = 8;
v[4] = 8;
sw $t2 vec($t1)
addi $t1
$t1
sw $t2 vec($t1)
...
}
ARCOS-UC3M
178
Direccionamiento relativo a contador de

programa
Ejemplo:
beqz $t1 etiqueta
Si $t1 es 0, se actualiza el PC => PC = PC + etiqueta

Etiqueta representa un desplazamiento
Instruccin
Codop
desplazamiento
PC
ARCOS-UC3M
179
Contador de programa en el MIPS 32

Los registros tienen 32 bits
El contador de programa tiene 32 bits
Las instrucciones ocupan 32 bits (una palabra)
El contador de programa almacena la direccin donde se
encuentra una instruccin
La siguiente instruccin se encuentra 4 bytes despus.
Por tanto el contador de programa se actualiza:
PC = PC + 4
Direccin:
0x00400000
0x00400004
0x00400008
0x0040000c
0x00400010
0x00400014
ARCOS-UC3M
Instruccin:
or
$2,$0,$0
slt
$8,$0,$5
beq
$8,$0,3
add
$2,$2,$4
addi $5,$5,-1
j
0x100001
180
Direccionamiento relativo a PC en el MIPS

La instruccin beq
en la instruccin:
etiqueta se codifica
$9,$0,
16
CO
rs
rt
Dato inmediato
Etiqueta tiene que codificarse en el campo Dato inmediato

Cmo se actualiza el PC si $t0 == $1 y cunto vale fin
cuando se genera cdigo mquina?
bucle:
beq
add
addi
j
$t0,$1, fin
$t8,$t4,$t4
$t0,$0,-1
bucle
fin:
ARCOS-UC3M
181
Direccionamiento relativo a PC en el MIPS

Si se cumple la condicin
PC = PC + (etiqueta* 4)
Por tanto en:
bucle:
beq
add
addi
j
$t0,$1, fin
$t8,$t4,$4t4
$t0,$0,-1
bucle
fin:
fin ==
Cuando se ejecuta una instruccin, el PC apunta a la siguiente
ARCOS-UC3M
182
Utilidad: desplazamientos en bucles

fin representa la
direccin donde se
encuentra la instruccin
move
while:
fin:
ARCOS-UC3M
li
li
li
li
bge
mul
addi
b
move
$t0 8
$t1 4
$t2 1
$t4 0
$t4 $t1 fin
$t2 $t2 $t0
$t4 $t4 1
while
$t2 $t4
183

Direccin
while:
fin:
ARCOS-UC3M
li
li
li
li
bge
mul
addi
b
move
$t0 8
$t1 4
$t2 1
$t4 0
$t4 $t1 fin
$t2 $t2 $t0
$t4 $t4 1
while
$t2 $t4
Contenido
0x0000100
li
0x0000104
li
$t1 4
0x0000108
li
$t2 1
0x000010C
li
$t4 0
0x0000110
bge
$t4 $t1 fin
0x0000114
mul
$t2 $t2 $t0
0x0000118
addi $t4 $t4 1
0x000011C
0x0000120
move $t2
$t0
while
$t4
184

Direccin
while:
fin:
li
li
li
li
bge
mul
addi
b
move
$t0 8
$t1 4
$t2 1
$t4 0
$t4 $t1 fin
$t2 $t2 $t0
$t4 $t4 1
while
$t2 $t4
fin representa un desplazamiento

respecto al PC actual => 3
PC = PC + 3 * 4
while representa un desplazamiento
respecto al PC actual =>-4
PC = PC + (-4)*4
ARCOS-UC3M
Contenido
0x0000100
li
0x0000104
li
$t1 4
0x0000108
li
$t2 1
0x000010C
li
$t4 0
0x0000110
bge
$t4 $t1 fin
0x0000114
mul
$t2 $t2 $t0
0x0000118
addi $t4 $t4 1
0x000011C
0x0000120
move $t2
$t0
while
$t4
185
Diferencia entre las instruccin b y j

Instruccin
j direccion
op.
direccion
6 bits
26 bits
Direccin de salto => PC = direccion
Instruccin
b desplazamiento
op.
6 bits
desplazamiento
5 bits
5 bits
16 bits
Direccin de salto => PC = PC + desplazamiento
ARCOS-UC3M
186
Direccionamiento implcito
El operando no est codificado en la instruccin,
pero forma parte de esta.
Ejemplo: beqz $a0 etiqueta1
Si registro $a0 es cero, salta a etiqueta.
$a0 es un operando, $zero es el otro.
op
rs
16 bits
Ventajas
Es rpido: no es necesario acceder a memoria.
Instrucciones ms cortas
ARCOS-UC3M
187
Direccionamiento de pila
PUSH Reg
Apila el contenido del registro (dato)
dato
cima
$sp
$sp
cima
crece hacia direcciones bajas
ARCOS-UC3M
188
POP Reg
dato
Desapila el contenido del registro (dato)

Copia dato en el registro Reg
$sp
dato
cima
cima
$sp
ARCOS-UC3M
189
190
MIPS no dispone de instrucciones PUSH o POP.

El registro puntero de pila ($sp) es visible al programador.
Se va a asumir que el puntero de pila apunta al ltimo
elemento de la pila
PUSH $t0
POP $t0
lw $t0, ($sp)
add $sp, $sp, 4
sub $sp, $sp, 4

sw $t0, ($sp)
ARCOS-UC3M
190
Ejemplos de tipos de direccionamiento
la $t0 label
inmediato
El segundo operando de la instruccin es una direccin
PERO no se accede a esta direccin, la propia direccin es el operando
directo a memoria
lw $t0 label
El segundo operando de la instruccin es una direccin
Hay que acceder a esta direccin para tener el valor con el que trabajar
bne $t0 $t1 label
relativo a registro PC
El tercer operando de la instruccin representa un desplazamiento
PERO no se accede a esta direccin, la propia direccin es PARTE del
operando
En el formato de esta instruccin, label se codifica como un nmero en
complemento a dos que representa el desplazamiento (como palabras)
relativo al registro PC
ARCOS-UC3M
191
Modos de direccionamiento en el MIPS

Direccionamientos:
Inmediato
De registro
Directo
Indirecto de registro
Relativo a registro base
Relativo a registro ndice
Relativo a PC
Relativo a pila
ARCOS-UC3M
valor
$reg
dir
($reg)
desplazamiento($reg)
direccion($reg)
beq etiqueta
desplazamiento($sp)
192
Formato de instrucciones
Una instruccin mquina es autocontenida e incluye:
Cdigo de operacin
Direccin de los operandos
Direccin del resultado
Direccin de la siguiente instruccin
Tipos de representacin de los operandos
Una instruccin se divide en campos
Ejemplo de campos en una instruccin del MIPS:
op.
ARCOS-UC3M
rs
rt
rd
shamt
func.
193
Formato de instrucciones
Una instruccin normalmente ocupa una palabra pero
puede ocupar ms en algunos computadores
En el caso del MIPS todas las instrucciones ocupan una
palabra
Campo de cdigo:
Con n bits se pueden codificar 2n instrucciones
Si se quiere codificar ms se utiliza un campo de extensin
Ejemplo: en el MIPS las instrucciones aritmticas tienen
como cdigo de op = 0. La funcin concreta se codifica en el
campo func.
Tipo R
op.
rs
rt
rd
shamt
func.
aritmticas
ARCOS-UC3M
194
Formato de una instruccin

195
Especifica el significado de cada uno de los bits que forma la

instruccin.
Longitud del formato: Nmero de bits que componen la
instruccin.
La instruccin se divide en campos.
Normalmente una arquitectura ofrece unos pocos formatos de
instruccin.
Simplicidad en el diseo de la unidad de control.
Uso sistemtico:
Campos del mismo tipo siempre igual longitud.
Seleccin mediante cdigo de operacin.
Normalmente el primer campo.
ARCOS-UC3M
195
Longitud de formato
196
Alternativas:
Longitud nica: Todas las instrucciones tienen la misma
longitud de formato.
MIPS32: 32 bits
PowerPC: 32 bits
Longitud variable: Distintas instrucciones tienen distinta
longitud de formato.
Cmo se sabe la longitud de la instruccin? Cod. Op.
IA32 (Procesadores Intel): Nmero variable de bytes.
ARCOS-UC3M
196
Ejemplo: Formato de las instrucciones del

MIPS
197
CO
rs
rt
rd
sa
func
26
CO
Dato inmediato
add $t0, $t0, $t1
16
CO
rs
rt
Dato inmediato
ARCOS-UC3M
addi $t0, $t0, 1
197
Ejemplo de formato en el MIPS

MIPS Instruction:
add
$8,$9,$10
Formato a utilizar:
6
CO
rs
rt
rd
sa
func
Representacin decimal de cada campo:
10
32
Representacin binaria de cada campo
000000 01001 01010 01000 00000 100000

ARCOS-UC3M
198
Ejemplo de formato en el MIPS

MIPS Instruction:
addi
$21,$22,-50
Formato a utilizar:
6
16
CO
rs
rt
Dato inmediato
Representacin decimal de cada campo:
22
21
-50
Representacin binaria de cada campo
001000 10110 10101 1111111111001110

ARCOS-UC3M
199
Cmo utilizar addi con un valor de 32 bits?

Qu ocurre si se utiliza desde el ensamblador?
addi
$t0,$t0, 0xABABCDCD
El valor inmediato es de 32 bits. Esta instruccin no se
puede codificar en una palabra de 32 bits.
ARCOS-UC3M
200
Cmo utilizar addi con un valor de 32 bits?

Qu ocurre si se utiliza desde el ensamblador?
addi
$t0,$t0, 0xABABCDCD
El valor inmediato es de 32 bits. Esta instruccin no se
puede codificar en una palabra de 32 bits.
Solucin:
Desde el ensamblador se puede utilizar, pero al final se
traduce en:
lui
$at, 0xABAB
ori
$at, $at, 0xCDCD
add
$t0, $t0, $at
El registro $at est reservado para el ensamblador por
convenio
ARCOS-UC3M
201
Pregunta
202
Cmo sabe la unidad de control el formato de la instruccin

que est ejecutando?
Cmo sabe la unidad de control el nmero de operandos de
una instruccin?
Cmo sabe la unidad de control el formato de cada
operacin?
ARCOS-UC3M
202
Cdigo de operacin
203
Tamao fijo:
n bits
2n cdigos de operacin.
m cdigos de operacin
log2m bits.
Campos de extensin
MIPS (instrucciones aritmticas-lgicas)
Op = 0; la instruccin est codificada en func
Tipo R
op.
rs
rt
rd
shamt
func.
aritmticas
Tamao variable:
Instrucciones ms frecuentes = Tamaos ms cortos.
ARCOS-UC3M
203
Ejemplo
Sea un computador de 16 bits de tamao de palabra,

que incluye un repertorio con 60 instrucciones mquina
y con un banco de registros que incluye 8 registros.
Se pide:
Indicar el formato de la instruccin ADDx R1 R2 R3, donde
R1, R2 y R3 son registros.
ARCOS-UC3M
204
Solucin
palabra -> 16 bits
60 instrucciones
8 registros (en BR)
ADDx R1(reg.), R2(reg.), R3(reg.)
Palabra de 16 bits define el tamao de la instruccin
16 bits
ARCOS-UC3M
205
Solucin
palabra -> 16 bits

60 instrucciones
8 registros (en BR)
Para 60 instrucciones se necesitan 6 bits (mnimo)
16 bits
6 bits
Cdigo de
operacin
ARCOS-UC3M
206
palabra -> 16 bits

60 instrucciones
8 registros (en BR)
Solucin
Para 8 registros se necesitan 3 bits (mnimo)
16 bits
ARCOS-UC3M
6 bits
3 bits 3 bits 3 bits
Cdigo de
operacin
Operandos
(3 registros)
207
palabra -> 16 bits

60 instrucciones
8 registros (en BR)
Solucin
Sobra 1 bit (16-6-3-3-3 = 1), usado de relleno
16 bits
6 bits
Cdigo de
operacin
ARCOS-UC3M
3 bits 3 bits 3 bits 1 bit

Operandos
(3 registros)
208
Ejercicio
Sea un computador de 16 bits, que direcciona la memoria por
bytes y que incluye un repertorio con 60 instrucciones
mquina. El banco de registros incluye 8 registros. Indicar el
formato de la instruccin ADDV R1, R2, M, donde R1 y R2
son registros y M es una direccin de memoria.
ARCOS-UC3M
209
Ejercicio
Sea un computador de 32 bits, que direcciona la memoria por
bytes. El computador incluye 64 instrucciones mquina y 128
registros. Considere la instruccin SWAPM dir1, dir2, que
intercambia el contenido de las posiciones de memoria dir1 y
dir2. Se pide:
Indicar el espacio de memoria direccionable en este
computador.
Indicar el formato de la instruccin anterior.
Especifique un fragmento de programa en ensamblador del
MIPS 32 equivalente a la instruccin mquina anterior.
Si se fuerza a que la instruccin quepa en una palabra, qu
rango de direcciones se podra contemplar considerando que
las direcciones se representan en binario puro.
ARCOS-UC3M
210
CISC-RISC
CISC: Complex Instruction Set Architecture (http://es.wikipedia.org/wiki/RISC)
Muchas instrucciones.
Complejidad variable.
Diseo irregular.
RISC: Reduced Instruction Set Code (http://es.wikipedia.org/wiki/CISC)
Instrucciones bastante simples.
Nmero reducido de instrucciones.
Instrucciones de tamao fijo.
Banco de registros grande.
La mayora de las instrucciones usan registros.
Paso de parmetros a travs del banco de registros.
Arquitecturas segmentadas.
ARCOS-UC3M
211
Modelos de ejecucin
212
Una mquina tiene un modelo de ejecucin asociado.

Modelo de ejecucin indica el nmero de direcciones y tipo
de operandos que se pueden especificar en una instruccin.
0 direcciones
1 direccin
2 direcciones
Memoria.
3 direcciones
Memoria.
ARCOS-UC3M
Pila.
Registro acumulador.
Registros, Registro-Memoria, MemoriaRegistros, Registro-Memoria, Memoria-
212
Modelo de 3 direcciones
213
Registros
Los 3 operandos son registros.
Requiere operaciones de carga/almacenamiento.
ADD .R0, .R1, .R2
Memoria-Memoria
Los 3 operandos son direcciones de memoria.
ADD /DIR1, /DIR2, /DIR3
Registro-Memoria
Hbrido.
ADD .R0, /DIR1, /DIR2
ADD .R0, .R1, /DIR1
ARCOS-UC3M
213
Ejemplo
214
X = A + B * C
/DA
/DB
/DC
/DX
Modelo de ejecucin
ARCOS-UC3M
214
3 direcciones: R-R
215
LOAD
LOAD
MUL
LOAD
ADD
STORE
ARCOS-UC3M
.R0,
.R1,
.R0,
.R2,
.R0,
.R0,
/DB
/DC
.R0, .R1
/DA
.R0, .R2
/DX
6 instrucciones
4 acceso a memoria de datos
10 accesos a registros
215
3 direcciones: M-M
216
MUL /DX, /DB, /DC

ADD /DX, /DX, /DA
2 instrucciones
0 accesos a registro
ARCOS-UC3M
216
217
Registros
Los 2 operandos son registros.
Requiere operaciones de carga/almacenamiento.
ADD .R0, .R1 (R0 <- R0 + R1)
Memoria-Memoria
Los 2 operandos son direcciones de memoria.
ADD /DIR1, /DIR2 (MP[DIR1] <- MP[DIR1] +
MP[DIR2])
Registro-Memoria
Hbrido.
ADD .R0, /DIR1 (R0 <- R0 + MP[DIR1])
ARCOS-UC3M
217
2 direcciones: R-R
218
LOAD
LOAD
MUL
LOAD
ADD
STORE
.R0,
.R1,
.R0,
.R3,
.R0,
.R0,
/DB
/DC
.R1
/DA
.R3
/DX
6 instrucciones
ARCOS-UC3M
218
2 direcciones: M-M
219
MOVE /DX, /DB

MUL /DX, /DC
ADD /DX, /DA
3 instrucciones
ARCOS-UC3M
219
2 direcciones: R-M
220
LOAD
MUL
ADD
STORE
.R0,
.R0,
.R0,
.R0,
/DB
/DC
/DA
/DX
4 instrucciones
4 accesos a memoria de datos
ARCOS-UC3M
220
Modelo de 1 direccin
221
Todas las operaciones utilizan un operando implcito:

Registro acumulador
Ejemplo: ADD R1 -> AC <- AC + R1
Operaciones de carga y almacenamiento siempre sobre

acumulador.
Posibilidad de movimiento entre registro acumulador y otros
registros
ARCOS-UC3M
221
1 direccin
222
LOAD
MUL
ADD
STORE
/DB
/DC
/DA
/DX
4 instrucciones
ARCOS-UC3M
222
223
Todas las operaciones referidas a la pila.

Operandos en la cima de la pila.
Al hacer la operacin se retiran de la pila.
Resultado se coloca en la cima de la pila.
Dos operaciones especiales:
PUSH
POP
ARCOS-UC3M
223
Operacin sobre la pila

224
PUSH 5
ARCOS-UC3M
224

225
PUSH 5
PUSH 7
7
5
ARCOS-UC3M
225

226
PUSH 5
PUSH 7
ADD
12
ARCOS-UC3M
226

227
PUSH 5
PUSH 7
ADD
POP /DX
ARCOS-UC3M
227
0 direcciones
228
PUSH
PUSH
MUL
PUSH
ADD
POP
/DB
/DC
/DA
/DX
ARCOS-UC3M
6 instrucciones
10 accesos a memoria de pila
228
Recordatorio:
Informacin de instruccin
229
Informacin:
Operacin a realizar.
Operandos.
Resultado.
Ubicacin de siguiente instruccin.
Parte de la informacin puede ser implcita.
ARCOS-UC3M
229
Contenido
ARCOS-UC3M
230
Procedimientos
Un procedimiento (funcin, subrutina) es un subprograma que
realiza una tarea especifica cuando se le invoca
Recibe argumentos o parmetros de entrada
Devuelve algn resultado
En ensamblador un procedimiento se asocia con un nombre
simblico que denota su direccin de inicio.
ARCOS-UC3M
231
Pasos en la ejecucin de un
procedimiento/funcin
Situar los parmetros en un lugar donde el procedimiento
pueda accederlos.
Transferir el control al procedimiento.
Adquirir los recursos de almacenamiento necesarios para el
procedimiento.
Realizar la tarea deseada.
Poner el resultado en un lugar donde el programa o
procedimiento que realiza la llamada pueda accederlo.
Devolver el control al punto de origen.
ARCOS-UC3M
232
Funciones en un lenguaje de alto nivel

233
int main() {
int z;
z=factorial(x);
print_int(z);
}
ARCOS-UC3M
int factorial(int x) {
int i;
int r=1;
for (i=1;i<=x;i++) {
r*=i;
}
return r;
}
233
Llamadas a funciones en MIPS

234
Llamada a funcin en el MIPS (instruccin jal)
factorial:
jal factorial
jr $ra
factorial representa la direccin

de inicio de la subrutina (funcin)
ARCOS-UC3M
234

235
0x00401000 factorial:
0x00001000 jal 0x00401000

0x00001004
jr $ra
$ra = PC = 0x00001004
PC = 0x00401000
ARCOS-UC3M
235

236
0x00401000
0x00001000 jal 0x00401000

0x00001004
jr $ra
$ra = 0x00001004
ARCOS-UC3M
236

237
Retorno de subrutina (instruccin jr )

0x00401000
0x00001000 jal 0x00401000

0x00001004
jr $ra
PC = $ra = 0x00001004
$ra = 0x00001004
ARCOS-UC3M
237

238
0x00401000
0x00001000 jal 0x00401000

0x00001004
jr $ra
PC = $ra = 0x00001004
ARCOS-UC3M
238
Instrucciones jal/jr
239
Qu hace la instruccin jal?

$ra $PC
$PC Direccin de salto
Qu hace la instruccin jr?

$PC $ra
ARCOS-UC3M
239
Llamadas anidadas
0x00401000
jal 0x000080000
0x00008000
0x00001000 jal 0x00401000

0x00001004
jr $ra
jr $ra
$ra = PC = 0x00001004
PC = 0x00401000
ARCOS-UC3M
240
Llamadas anidadas
0x00401000
0x00401020 jal 0x000080000

0x00401024
0x00008000
0x00001000 jal 0x00401000

0x00001004
jr $ra
jr $ra
$ra = PC = 0x00401024
PC = 0x00008000
ARCOS-UC3M
241
Llamadas anidadas
0x00401000
0x00401020 jal 0x000080000

0x00401024
0x00008000
0x00001000 jal 0x00401000

0x00001004
jr $ra
jr $ra
PC = $ra = 0x00401024
ARCOS-UC3M
242
Llamadas anidadas
0x00401000
0x00401020 jal 0x000080000

0x00401024
0x00008000
0x00001000 jal 0x00401000

0x00001004
jr $ra
jr $ra
?
PC = $ra = 0x00401024
ARCOS-UC3M
243
Llamadas anidadas
0x00401000
0x00401020 jal 0x000080000

0x00401024
0x00008000
0x00001000 jal 0x00401000

0x00001004
jr $ra
jr $ra
?
PC = $ra = 0x00401024
Se ha perdido la direccin de retorno
ARCOS-UC3M
244
Dnde guardar la direccin de retorno?

El computador dispone de dos elementos para almacenamiento
Registros
Memoria
No se pueden utilizar los registros porque su nmero es
limitado
Se guarda en memoria principal
En una zona del programa que se denomina pila
ARCOS-UC3M
245
Ejecucin de un programa
Memoria
Principal
Sistema
Operativo
Disco
instrucciones
datos
Programa
en ejecucion
Fichero
ejecutable
pila
ARCOS-UC3M
246
Mapa de memoria de un proceso
memoria
pc
Segmento de Texto
El programa de usuario se divide

en segmentos
01011001
Segmento de pila
Variables locales
Contexto de funciones
Segmento de Datos
Segmento de datos
$sp
01011001
Datos estticos, variables

globales
Segmento de cdigo (texto)

Cdigo, instrucciones mquina
Segmento de Pila
ARCOS-UC3M
247
Pila
PUSH Reg
Apila el contenido del registro (dato)
dato
cima
$sp
$sp
cima
ARCOS-UC3M
248
Pila
POP Reg
dato
Desapila el contenido del registro (dato)

Copia dato en el registro Reg
$sp
dato
cima
cima
$sp
ARCOS-UC3M
249
Uso de la pila en el MIPS

250
MIPS no dispone de instrucciones PUSH o POP.

El registro puntero de pila ($sp) es visible al programador.
Se va a asumir que el puntero de pila apunta al ltimo
elemento de la pila
PUSH $t0
POP $t0
lw
$t0, ($sp)
addu $sp, $sp, 4
subu $sp, $sp, 4

sw
$t0, ($sp)
ARCOS-UC3M
250
Operacin PUSH en el MIPS
$sp
Estado inicial: el registro puntero de pila ($sp) apunta a l ltimo

elemento situado en la cima de la pila
ARCOS-UC3M
251
$sp
7
8
subu $sp, $sp, 4

Se resta 4 al registro puntero de pila para poder insertar una
nueva palabra en la pila
ARCOS-UC3M
252
$sp
7
8
li
sw
$t2, 9
$t2 ($sp)
Se inserta el contenido del registro $t2 en la cima de la pila
ARCOS-UC3M
253
Operacin POP en el MIPS
$sp
7
8
lw
$t2 ($sp)
Se copia en $t2 el dato almacenado en la cima de la pila (9)
ARCOS-UC3M
254
Operacin POP en el MIPS
9
7
$sp
addu $sp, $sp, 4

Se actualiza el registro puntero de pila para apuntar a la nueva
cima de la pila. El dato desapilado (9) sigue estando en memoria
pero ser sobrescrito en futuras operaciones PUSH
ARCOS-UC3M
255
Pila
uso de push y pop consecutivos
push $a0
push $t1
push $t2
push $s2
...
pop $s2
pop $t2
pop $t1
pop $a0
ARCOS-UC3M
256
Pila
sub $sp $sp 4
sw
push
push
push
push
$a0
$t1
$t2
$s2
$a0
($sp)
sub $sp $sp 4

sw
$t1
($sp)
sub $sp $sp 4

sw
$t2
($sp)
sub $sp $sp 4
...
sw
$s2
($sp)
...
pop
pop
pop
pop
$s2
$t2
$t1
$a0
lw $s2 ($sp)
add $sp $sp 4
lw $s2 ($sp)
add $sp $sp 4
lw $s2 ($sp)
add $sp $sp 4
lw $s2 ($sp)
add $sp $sp 4
ARCOS-UC3M
257
Pila
push
push
push
push
$a0
$t1
$t2
$s2
...
pop
pop
pop
pop
sub $sp $sp 16

sw
$a0
12($sp)
sw
$t1
8($sp)
sw
$t2
4($sp)
sw
$s2
($sp)
...
$s2
$t2
$t1
$a0
lw
$s2
($sp)
lw
$t2
4($sp)
lw
$t1
8($sp)
lw
$a0
12($sp)
add $sp
ARCOS-UC3M
$sp
16
258
Ejemplo
(1) Se parte de un cdigo en lenguaje de alto nivel
259
int main() {
int z;
z=factorial(5);
print_int(z);
.
.
.
}
ARCOS-UC3M
int i;
int r=1;
for (i=1;i<=x;i++) {
r*=i;
}
return r;
}
259
Ejemplo
(2) Pensar en el paso de parmetros
260
Los parmetros en el MIPS se pasan en $a0, $a1, $a2 y $a3

Los resultados en el MIPS se recogen en $v0, $v1
Ms adelante se ver con ms detalle
En la llamada z=factorial(5);
Un parmetro de entrada: en $a0
Un resultado en $v0
ARCOS-UC3M
260
El parmetro se pasa en $a0

El resultado se devuelve en $v0
Ejemplo
(3) Se pasa a ensamblador cada funcin
261
int main() {
int z;
z=factorial(5);
print_int(z);
. . .
}
li $a0, 5
jal factorial
move $a0, $v0
li $v0, 1
syscall
# argumento
# llamada
# resultado
# llamada para
# imprimir un int
...
int i;
int r=1;
for (i=1;i<=x;i++) {
r*=i;
}
return r;
}
ARCOS-UC3M
factorial: li
li
bucle: bgt
mul
addi
b
fin: move
jr
$s1, 1
#s1 para r
$s0, 1
#s0 para i
$s0, $a0, fin
$s1, $s1, $s0
$s0, $s0, 1
bucle
$v0, $s1 #resultado
$ra
261
Ejemplo
(4) Se analizan los registros que se modifican
262
int i;
int r=1;
for (i=1;i<=x;i++) {
r*=i;
}
return r;
}
factorial: li
li
bucle: bgt
mul
addi
b
fin: move
jr
$s1, 1
#s1 para r
$s0, 1
#s0 para i
$s0, $a0, fin
$s1, $s1, $s0
$s0, $s0, 1
bucle
$v0, $s1 #resultado
$ra
La funcin factorial trabaja (modifica) con los registros $s0, $s1

Si estos registros se modifican dentro de la funcin, podra afectar a la funcin que
realiz la llamada (la funcin main)
Por tanto, la funcin factorial debe guardar el valor de estos registros en la pila al
principio y restaurarlos al final
ARCOS-UC3M
262
Ejemplo
(5) Se guardan los registros en la pila
263
int i;
int r=1;
for (i=1;i<=x;i++) {
r*=i;
}
return r;
}
factorial: sub
sw
sw
li
li
bucle: bgt
mul
addi
b
fin: move
lw
lw
add
jr
$sp, $sp, 8
$s0, 4($sp)
$s1, ($sp)
$s1, 1
#s1 para r
$s0, 1
#s0 para i
$s0, $a0, fin
$s1, $s1, $s0
$s0, $s0, 1
bucle
$v0, $s1 #resultado
$s1, ($sp)
$s0, 4($sp)
$sp, $sp, 8
$ra
No es necesario guardar $ra. La rutina factorial es terminal

Se guarda en la pila $s0 y $s1 porque se modifican
Si se hubiera utilizado $t0 y $t1 no habra hecho falta hacerlo
ARCOS-UC3M
263
Ejemplo 2
264
int main()
{
int z;
int f1 (int a, int b)

{
int r;
r = a + a + f2(b);
return r;
z=f1(5, 2);
print_int(z);
}
int f2(int c)
{
int s;
s = c * c * c;
return s;
}
ARCOS-UC3M
264
Ejemplo 2. Invocacin
265
int main()
{
int z;
li
$a0, 5
li
$a1, 2
jal f1
move $a0, $v0
li
$v0, 1
syscall
z=f1(5, 2);
print_int(z);
#
#
#
#
primer argumento
segundo argumento
llamada
resultado
# llamada para
# imprimir un int
Los parmetros se pasan en $a0 y $a1

El resultado se devuelve en $v0
ARCOS-UC3M
265
Ejemplo 2. Cuerpo de f1
266

{
int r;
r = a + a + f2(b);
return r;
f1: add
$s0, $a0, $a0
move
jal
add
$a0, $a1
f2
$v0, $s0, $v0
jr
$ra
}
int f2(int c)
{
int s;
s = c * c * c;
return s;
}
ARCOS-UC3M
266
Ejemplo 2. Se analizan los registros que se

modifican en f1
267

{
int r;
r = a + a + f2(b);
return r;
f1: add
$s0, $a0, $a0
move
jal
add
$a0, $a1
f2
$v0, $s0, $v0
jr
$ra
}
int f2(int c)
{
int s;
f1 modifica $s0, $a0 y $ra, por lo tanto se guardan en la pila

El registro $ra se modifica en la instruccin jal f2
El registro $a0 se modifica al pasar el argumento a f2
s = c * c * c;
return s;
}
ARCOS-UC3M
267
Ejemplo 2. Cuerpo de f1 guardando en la

pila los registros que se modifican
268

{
int r;
r = a + a + f2(b);
return r;
}
int f2(int c)
{
int s;
s = c * c * c;
return s;
f1: sub
sw
sw
sw
$sp, $sp, 12
$s0, 8($sp)
$a0, 4($sp)
$ra, ($sp)
add
$s0, $a0, $a0
move
jal
add
$a0, $a1
f2
$v0, $s0, $v0
lw
lw
lw
add
jr
$ra, ($sp)
$a0, 4($sp)
$s0, 8($sp)
$sp, $sp, 12
$ra
ARCOS-UC3M
268
Ejemplo 2. Cuerpo de f2
269

{
int r;
r = a + a + f2(b);
return r;
}
f2: mul $t0, $a0, $a0

mul $t0, $t0, $a0
jr $ra
int f2(int c)
{
int s;
s = c * c * c;
return s;
La funcin f2 no modifica el registro $ra porque no

llama a ninguna otra funcin
El registro $t0 no es necesario guardarlo porque no se ha
de preservar su valor
ARCOS-UC3M
269
Tipos de subrutinas
270
Subrutina terminal.
No invoca a ninguna otra subrutina.
Subrutina no terminal.
Invoca a alguna otra subrutina.
ARCOS-UC3M
270
Activacin de procedimientos
Marco de pila
El marco de pila es el mecanismo que utiliza el compilador
para activar los procedimientos (subrutinas)
El marco de pila lo construyen en la pila el procedimiento
llamante y el llamado
Su manipulacin se hace a travs de dos registros:
$sp: puntero de pila, que apunta siempre a la cima de la
pila
$fp: puntero de marco de pila, que marca la zona de la pila
que pertenece al procedimiento llamado
El registro marco de pila ($fp) se utiliza en el procedimiento
llamado para:
Acceder a los parmetros que se pasan en la pila
Acceder a las variables locales del procedimiento
ARCOS-UC3M
271
Marco de pila
El marco de pila almacena:
Los parmetros introducidos por el procedimiento
llamante en caso de ser necesarios
El registro marco de pila del procedimiento
llamante (antiguo $fp)
Los registros guardados por la funcin (incluyen al
registro $ra en caso de procedimientos no
terminales)
Variables locales
ARCOS-UC3M
272
Marco de pila
$sp
Direcciones bajas
Variables locales del
procedimiento llamado
Registros guardados
$fp
por el llamado
Crecimiento de la pila
$fp antiguo
Parmetros
del llamante
Direcciones altas
ARCOS-UC3M
273
Acceso a parmetros y variables locales

usando el marco de pila
Direcciones bajas
int f (int n1, n2, n3,

n4, n5, n6)
{
int v[4];
int k;
for (k= 0; k <3; k++)
v[i] = n1+n2+n3+n4+n5+n6;
Crecimiento
return (v[1]);
de la pila
$sp
Los parmetros n1, n2, n3 y n4

se pasan:
En $a0, $a1, $a2, $a3
Los parmetros n5, n6 se pasan:
En la pila
ARCOS-UC3M
Argumento n5
Argumento n6
Direcciones altas
274

Direcciones bajas

n4, n5, n6)
{
int v[4];
int k;
$sp
v[0]
v[1]
for (k= 0; k <3; k++)

v[i] = n1+n2+n3+n4+n5+n6;
v[2]
$fp
return (v[1]);
v[3]
Crecimiento
de la pila
$fp antiguo
Una vez invocada la funcin, f

debe reservar en el marco de
pila espacio para las variables
locales que no quepan en
registros (en este ejemplo v)
ARCOS-UC3M
Argumento n5
Argumento n6
Direcciones altas
275

Direcciones bajas

n4, n5, n6)
{
int v[4];
int k;
$sp
v[0]
v[1]
for (k= 0; k <3; k++)

v[i] = n1+n2+n3+n4+n5+n6;
v[2]
$fp
return (v[1]);
v[3]
Crecimiento
de la pila
$fp antiguo
El valor de n1 est en $a0

El valor de n5 est en 4($fp)
El valor de n6 est en 8($fp)
El valor de v[3] est en -4($fp)
El valor de v[0] est en -16($fp)
Argumento n5
Argumento n6
Direcciones altas
ARCOS-UC3M
276
Convenio de paso de parmetros

277
Convenio que describe:

Uso del banco de registros generales.
Uso del banco de registros FPU.
Uso de la pila.
Afecta a cdigo llamante y cdigo llamado.
Distintos compiladores usan distintos convenios.

ABI
ARCOS-UC3M
Application Binary Interface.
277
Convencin en el uso de los registros en el

MIPS
Registro
Uso
Preservar el valor
$v0-$v1
Resultados
No
$a0..$a3
Argumentos
Si
$t0..$t9
Temporales
No
$s0..$s7
Salvados
Si
$sp
Puntero de pila
Si
$fp
Puntero marco de pila
Si
$ra
Direccin de retorno
si
ARCOS-UC3M
278
Subrutinas paso a paso

279
Subrutina que hace la llamada
Subrutina llamada
Salvaguarda de registros que no quiera que

modifique la subrutina llamada
Paso de parmetros
Llamada a subrutina
Reserva del marco de pila
Salvaguarda de registros
Ejecucin de subrutina
Restauracin de valores guardados
Liberacin de marco de pila
Salida de subrutina
Restauracin de registros guardados
ARCOS-UC3M
279
Salvaguarda de registros
Subrutina llamante
280
Registros $t
Una subrutina puede

modificar libremente los
registros $t.
Antes de invocar una
subrutina se deben
guardar los registros $t
de los que se quiera
preservar su valor.
pila
subu $sp, $sp, 8

sw $t0,($sp)
sw $t1, 4($sp)
jal
funcion
lw $t1, 4($sp)
lw $t0, ($sp)
addu $sp, $sp, 8
ARCOS-UC3M
280
Paso de parmetros
Subrutina llamante
281
Los primeros parmetros se pasan mediante registros

$a0, $a1, $a2, $a3
$f12, $f14 (coma flotante)
Resto de parmetros a travs de pila
ARCOS-UC3M
281
Paso de 2 parmetros
Banco de registros
282
$a0
$a1
$a2
$a3
Registros $t
Parmetro 1
Parmetro 2
Parmetro 3
Parmetro 4
pila
li $a0, 5
li $a1, 8
// param 1
// param 2
jal func
addu $sp, $sp, 16
ARCOS-UC3M
282
Paso de 6 parmetros
Banco de registros
283
$a0
$a1
$a2
$a3
Parmetro 5
Parmetro 6
Parmetro 1
Parmetro 2
Parmetro 3
Parmetro 4
Registros $t
li
li
li
li
pila
$a0,
$a1,
$a2,
$a3,
5
8
7
9
//
//
//
//
param
param
param
param
1
2
3
4
subu $sp, $sp, 8

li $t0, 10
// param 6
sw $t0, 4($sp)
li $t0, 7
s2 $t0, ($sp)
// param 5
jal func
addu $sp, $sp, 8
ARCOS-UC3M
283
Llamada a subrutina
Subrutina llamante
284
Instruccin de salto and link

jal etiqueta
bal etiqueta
bltzal $reg, etiqueta
bgezal $reg, etiqueta
jalr $reg
jalr $reg, $reg
ARCOS-UC3M
284
Reserva del marco de pila

Subrutina llamada
285
La subrutina llamada guarda en la pila

El registro $fp antiguo
Los registros guardados por la funcin
Los registros $s que vaya a modificar.
El registro $ra en las subrutinas no terminales.
Variables locales
Para reservar el marco de pila, restar su tamao al puntero de
pila.
ARCOS-UC3M
285
Ejecucin de la subrutina
286
La subrutina deja los valores de retorno en:

Normalmente los registros $v0 y $v1
Para coma flotante $f0 y $f2.
Si hace falta ms espacio se deja informacin en la pila.
ARCOS-UC3M
286
Al final
287
Subrutina llamada:
Restauracin de valores guardados
Se restauran los valores que se guardaron
Liberacin del marco de pila.

Se suma a $sp el tamao del marco de pila
$sp = $fp
Se restaura el valor de $fp
Se vuelve a la subrutina llamante.

jr $ra
Subrutina llamante:
Se restauran los valores guardados en la pila
ARCOS-UC3M
287
Ejemplo: factorial
int factorial ( int a )

{
if (a < 2) then
return 1 ;
return a * factorial(a-1) ;
}
factorial(a=4)
(a < 2) ?
6 * 4
factorial(a=3)
(a < 2) ?
2 * 3
void main () {
int resultado ;
resultado=factorial(4) ;
factorial(a=2)
(a < 2) ?
1 * 2
factorial(a=1)
printf(f(4)=%d,resultado);
}
ARCOS-UC3M
(a < 2) ?
288
Ejemplo: factorial
Direcciones bajas
Justo antes de la llamada
$sp
Direcciones altas
ARCOS-UC3M
289
Ejemplo: factorial
factorial:
Direcciones bajas
# frame stack
subu $sp $sp 12
sw
$ra 4($sp)
sw
$fp 8($sp)
addu $fp $sp 8
$sp
$fp
$ra
$fp (antiguo)
Direcciones altas
ARCOS-UC3M
290
Ejemplo: factorial
factorial:
Direcciones bajas
# frame stack
subu $sp $sp 12
sw
$ra 4($sp)
sw
$fp 8($sp)
addu $fp $sp 8
bge $a0 2 b_else
li $v0 1
b
b_efs
b_else: sw $a0 -8($fp)
addi $a0 $a0 -1
jal factorial
lw $v1 -8($fp)
mul $v0 $v0 $v1
$sp
$a0
$fp
$ra
$fp (antiguo)
Direcciones altas
ARCOS-UC3M
291
Ejemplo: factorial
factorial:
Direcciones bajas
# frame stack
subu $sp $sp 12
sw
$ra 4($sp)
sw
$fp 8($sp)
addu $fp $sp 8
bge $a0 2 b_else
li $v0 1
b
b_efs
b_else: sw $a0 -8($fp)
addi $a0 $a0 -1
jal factorial
lw $v1 -8($fp)
mul $v0 $v0 $v1
# end frame stack
b_efs: lw $ra 4($sp)
lw $fp ($fp)
addu $sp $sp 12
jr $ra
ARCOS-UC3M
$a0
$ra
$sp
$fp (antiguo)
Direcciones altas
292
Convenio o32 (MIPS)

Los primeros parmetros se pasan mediante registros:
$a0, $a1, $a2, $a3
$f12, $f14 (coma flotante)
Resto de parmetros a travs de pila
En cualquiera caso hay que dejar hueco para los parmetros

$a0, $a1, $a2 y $a3 en la pila (No se copian, solo se deja el
hueco)
Este espacio solamente se acaba usando si se acaba llamando a
otra subrutina
Para reservar el marco de pila, restar su tamao al puntero de

pila.
Debe ser mltiplo de 8 (por convenio)
ARCOS-UC3M
293
Convenio o32. Paso de 2 parmetros

294
Banco de registros
Hueco para $a0
Hueco para $a1
Hueco para $a2
Hueco para $a3
$a0
$a1
$a2
$a3
Parmetro 1
Parmetro 2
Parmetro 3
Parmetro 4
Registros $t
pila
ARCOS-UC3M
294
Traduccin y ejecucin de programas

Elementos que intervienen en la traduccin y ejecucin de un
programa:
Compilador
Ensamblador
Enlazador
Cargador
ARCOS-UC3M
295
Cdigo compilado frente a interpretado

Cdigo compilado:
Los programas son traducidos a cdigo mquina de un
computador
El cdigo es ejecutado directamente por el computador
Generalmente ms eficiente
Cdigo interpretado:
Un interprete es un programa que ejecuta otros programas
Un interprete ejecuta un conjunto de instrucciones independientes
de la mquina. Las instrucciones son ejecutadas por un programa
Ejemplo: Java es traducido a un byte code que es ejecutado por
un interprete (Java Virtual Machine)
Generalmente es ms fcil escribir un interprete. Mayor
portabilidad
ARCOS-UC3M
296
Etapas en la traduccin y ejecucin de un

programa (programa en C)
Programa C
Compilador
Programa en ensambaldor
Ensamblador
Objeto: mdulo en lenguaje mquina
Objeto: bibliotecas en lenguaje mquina
Enlazador
Ejecutable: programa en lenguaje mquina
Cargador
ARCOS-UC3M
Memoria
297
Compilador
Entrada: lenguaje de alto nivel (C, C++, )
Salida: cdigo en lenguaje ensamblador
Puede contener pseudoinstrucciones
Una pseudoinstruccin es una instruccin que entiende el
ensamblador pero que no tiene correspondencia directa con
una instruccin en lenguaje mquina
move $t1, $t2 or $t1, $t2, $zero
ARCOS-UC3M
298
Ensamblador
Entrada: cdigo en lenguaje ensamblador
Salida: Cdigo objeto escrito en lenguaje mquina
En ensamblador convierte las pseudoinstrucciones a
instrucciones mquina
Analiza las sentencias en ensamblador de forma
independiente, sentencia a sentencia
El ensamblador produce un fichero objeto (.o)
ARCOS-UC3M
299
Anlisis de sentencias en ensamblador

Se comprueba si la instruccin es correcta (cdigo de
operacin, operandos, direccionamientos vlidos, )
Se comprueba si la sentencia tiene etiqueta. Si la tiene
comprueba que el cdigo simblico no est repetido y le
asigna el valor correspondiente a la posicin de memoria que
habr de ocupara la instruccin o el dato.
Construye una tabla de smbolos con todas las etiquetas
simblicas
En una primera fase o pasada se determinan todos los
valores que no conllevan referencias adelantadas
En una segunda fase o pasada se resuelven aquellas
etiquetas que han quedado pendientes
ARCOS-UC3M
300
Formato de un fichero objeto

Cabecera del fichero. Describe el tamao y posicin de los
elementos dentro del fichero
Segmento de texto: contiene el cdigo mquina
Segmento de datos: contiene los datos de las variables globales
Informacin de reubicacin: identifica instrucciones o palabras
de datos que dependen de una direccin absoluta cuando el
programa se cargue en memoria
Cualquier etiqueta de j or jal (internas o externas)
Direcciones de datos
Tabla de smbolos: etiquetas no definidas en este mdulo

(referencias externas)
Informacin de depuracin. Permite asociar instrucciones
mquina con cdigo C e interpretar las estructuras de datos
ARCOS-UC3M
301
Enlazador
Entrada: ficheros en cdigo objeto
Salida: Cdigo ejecutable
Combina varios archivos objeto (.o) en un nico fichero
ejecutable
Resuelve todas las referencias (instrucciones de salto y
direcciones de datos)
En enlazador asume que la primera palabra del segmento de
texto est en la direccin 0x00000000
Permite la compilacin separada de ficheros
El cambio en un fichero no implica recompilar todo el
programa completo
Permite el uso de funciones de biblioteca (.a)
ARCOS-UC3M
302
Enlazador
.o file 1
text 1
data 1
info 1
Linker
.o file 2
text 2
data 2
info 2
ARCOS-UC3M
a.out
Relocated text 1
Relocated text 2
Relocated data 1
Relocated data 2
303
Formato de un fichero ejecutable

Cabecera del fichero. Describe el tamao y posicin de los
elementos dentro del fichero. Incluye la direccin de inio del
programa
Segmento de texto: contiene el cdigo mquina
Segmento de datos: contiene los datos de las variables globales
con valor inicial
Informacin de reubicacin: en caso de utilizar bibliotecas
dinmicas
ARCOS-UC3M
304
Cargador
Lee un fichero ejecutable (a.out) y lo carga en memoria
Memoria
Principal
Sistema
Operativo
Disco
instrucciones
datos
Programa
en ejecucion
Fichero
ejecutable
pila
ARCOS-UC3M
305
Cargador
Forma parte del sistema operativo
Lee la cabecera del ejecutable para determinar el tamao de
los segmentos de texto y datos
Crea un nuevo espacio de direcciones en memoria para ubicar
el segmento de texto, datos y pila
Copia las instrucciones y los datos con valor inicial del fichero
ejecutable (disco) a memoria
Copia los argumentos que se pasan al programa en la pila
Inicializa los registros. Fija el PC y el SP a sus posiciones
ARCOS-UC3M
306
Bibliotecas
Una biblioteca es una coleccin de objetos normalmente
relacionados entre s
Los mdulos objetos de los programas pueden incluir
referencias a smbolos definidos en alguno de los objetos de
una biblioteca (funciones o variables exportadas)
Las bibliotecas del sistema son un conjunto de bibliotecas
predefinidas que ofrecen servicios a las aplicaciones
Tipos:
Bibliotecas estticas: se enlazan con los ficheros objeto para
producir un fichero ejecutable que incluye todas las
referencias resueltas. Un cambio en la biblioteca implica
volver a enlazar y generar el ejecutable
Bibliotecas dinmicas (DLL, dynamically linked library)
ARCOS-UC3M
307
Bibliotecas dinmicas
Las rutinas de las bibliotecas no se enlazan en el archivo
ejecutable y no se cargan hasta que el programa se ejecuta
El programa incluye informacin para la localizacin de las
bibliotecas y la actualizacin de las referencias externas
durante la ejecucin
Ventajas:
Da lugar a ejecutables ms pequeos.
Solo se carga de la biblioteca aquello que se utiliza durante
la ejecucin.
El cambio en una biblioteca no afecta al ejecutable. No se
necesita volver a generar un nuevo ejecutable.
ARCOS-UC3M
308
Ejemplo
C ASM bj Exe Ejecucin
Programa C: ejemplo.c
#include <stdio.h>
int main (int argc, char *argv[])
{
int i, sum = 0;
for (i = 1; i <= 10; i++)
sum = sum + i + i;
printf (La suma 1 + ... +10
es %d\n",
sum);
printf(): funcin de biblioteca en libc.a
ARCOS-UC3M
309
Compilacin
.text
.align
2
.globl
main
main:
subu $sp,$sp,24
sw $ra, 20($sp)
sw $a0, 4($sp)
sw $a1, 8($sp)
li $t0, 0
li $t1, 0
bucle:
bgt $t0, 10, fin
add $t1, $t1, $t0
addi $t0, $t0, 1
b bucle
ARCOS-UC3M
fin:
la $a0, str
li $a1, $t1
jal printf
move $v0, $0
lw $ra, 20($sp)
lw $a0, 4($sp)
lw $a1, 8($sp)
addiu $sp,$sp,24
jr $ra
.data
.align
0
str:
.asciiz " La suma
1 + ... +10 es
%d\n "
310
Compilacin
.text
.align
2
.globl
main
main:
subu $sp,$sp,24
sw $ra, 20($sp)
sw $a0, 4($sp)
sw $a1, 8($sp)
li $t0, 0
li $t1, 0
bucle:
bgt $t0, 10, fin
add $t1, $t1, $t0
addi $t0, $t0, 1
b bucle
ARCOS-UC3M
fin:
la $a0, str
li $a1, $t1
jal printf
move $v0, $0
lw $ra, 20($sp)
lw $a0, 4($sp)
lw $a1, 8($sp)
addiu $sp,$sp,24
jr $ra
.data
7 pseudo.align
0
instructiones
str:
.asciiz " La suma
1 + ... +10 es
%d\n "
311
Compilacin
Eliminacin de pseudoinstrucciones
.text
.align
2
.globl
main
main:
addiu $29,$29,-24
sw $31, 20($29)
sw $4, 4($29)
sw $5, 8($29)
ori $8, $0, 0
ori $9, $0, 0
bucle:
slti $1, $8, 11
beq $1, $0, fin
add $9, $9, $8
addi $8, $8, 1
bgez $0, bucle
ARCOS-UC3M
fin:
lui $4, l.str
ori $4, $4, r.str
addu $4, $0, $9
jal printf
addu $2, $0, $0
lw $31, 20($29)
lw $4, 4($29)
lw $5, 8($29)
addiu $29,$29,24
jr $31
312
Compilacin
Asignacin de direcciones
00
04
08
0c
10
14
18
1c
20
24
28
addiu $29,$29,-24
sw
$31, 20($29)
sw
$4, 4($29)
sw $5, 8($29)
ori $8, $0, 0
ori $9, $0, 0
slti $1, $8, 11
beq $1, $0, fin
add $9, $9, $8
addi $8, $8, 1
bgez $0, bucle
ARCOS-UC3M
2c
30
34
38
3c
40
44
48
4c
50
lui $4, l.str

ori $4, $4, r.str
addu $4, $0, $9
jal printf
addu $2, $0, $0
lw
$31, 20($29)
lw $4, 4($29)
lw $5, 8($29)
addiu $29,$29,24
jr $31
313
Compilacin
Creacin de la tabla de smbolos y de reubicacin
Tabla de smbolos
Etiqueta
main:
bucle:
str:
direccin (en modulo) tipo

0x00000000
global text
0x0000001c
local text
0x00000000
local data
Informacin de reubicacin
Direccn
tipo Instr.
0x0000002c
lui
0x00000030
ori
0x00000038
jal
ARCOS-UC3M
Dependencia
l.str
r.str
printf
314
Compilacin
Resolver etiquetas relativas a PC
00
04
08
0c
10
14
18
1c
20
24
28
addiu $29,$29,-24
sw
$31, 20($29)
sw
$4, 4($29)
sw $5, 8($29)
ori $8, $0, 0
ori $9, $0, 0
slti $1, $8, 11
beq $1, $0, 3
add $9, $9, $8
addi $8, $8, 1
bgez $0, -4
ARCOS-UC3M
2c
30
34
38
3c
40
44
48
4c
50
lui $4, l.str

ori $4, $4, r.str
addu $4, $0, $9
jal printf
addu $2, $0, $0
lw
$31, 20($29)
lw $4, 4($29)
lw $5, 8($29)
addiu $29,$29,24
jr $31
315
Segmento de texto en el fichero objeto

0x000000
0x000004
0x000008
0x00000c
0x000010
0x000014
0x000018
0x00001C
0x000020
0x000024
0x000028
0x00002C
0x000030
0x000034
0x000038
0x00003c
0x000040
0x000044
0x000048
0x00004c
0x000050
ARCOS-UC3M
00100111101111011111111111101000
10101111101111110000000000010100
10101111101001000000000000000100
10101111101001010000000000001000
10001101000000000000000000000000
10101101001000000000000000011100
00101000001010000000000000001011
00010000001000000000000000000011
00000001001010000100100000100000
00100001000010000000000000000001
00000100000000001111111111111100
00111100000001000000000000000000
00110100100001000000000000000000
00000001001001000000000000100001
00001100000000000000000000000000
00000000000000000001000001000001
10001111101111110000000000010100
10001111101001000000000000000100
10001111101001010000000000001000
00000011111000000000000000011000
00000000000000001110100000001000
316
Enlazado
Combinar ejemplo.o y libc.a
Crear las direcciones de memoria absolutas
Modificar y mezclar las tablas de smbolos y de reubicacin
Symbol Table
Label
main:
loop:
str:
printf:
Address
0x00000000
0x0000001c
0x10000430
0x000003b0
Relocation Information
Address
0x0000002c
0x00000030
0x00000038
ARCOS-UC3M
Instr. Type Dependency

lui
l.str
ori
r.str
jal
printf
317
Enlazado
Resolver las direcciones
00
04
08
0c
10
14
18
1c
20
24
28
addiu $29,$29,-24
sw
$31, 20($29)
sw
$4, 4($29)
sw $5, 8($29)
ori $8, $0, 0
ori $9, $0, 0
slti $1, $8, 11
beq $1, $0, 3
add $9, $9, $8
addi $8, $8, 1
bgez $0, -4
ARCOS-UC3M
2c
30
34
38
3c
40
44
48
4c
50
lui $4, 4096

ori $4, $4, 1072
addu $4, $0, $9
jal 812
addu $2, $0, $0
lw
$31, 20($29)
lw $4, 4($29)
lw $5, 8($29)
addiu $29,$29,24
jr $31
318
Enlazado
Generacin del fichero ejecutable
nico segmento de texto
nico segmento de datos
Cabecera con informacin sobre las secciones
ARCOS-UC3M
319

Mips

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Mips

Încărcat de

Drepturi de autor:

Formate disponibile

Estructura de computadores

Tema 3. Programacin en ensamblador

Motivacin para aprender ensamblador

Motivacin para usar MIPS 32

Fases de ejecucin de una instruccin

Propiedades de las instrucciones mquina

Dnde dejar los resultados

Diferentes niveles de lenguajes

Lenguaje de alto nivel

Reservado para el ensamblador

Resultado de una rutina (o expresin)

Argumento de entrada para rutinas

Temporal (NO se conserva entre llamadas)

Temporal (se conserva entre llamadas)

Temporal (NO se conserva entre llamadas)

Reservado para el sistema operativo

Puntero al rea global

Puntero a marco de pila

Direccin de retorno (rutinas)

Instrucciones de acceso a memoria (ms adelante)

suma con desbordamiento

$t1 / $t2 divisin entera

add $t1, $t1, $t2

($t0 = $t1 & $t2)

($t0 = $t1 ^ $t2)

Cul es el valor de $t2?

Cul es el valor de $t2?

000 . 0101 $t0

Desplazamiento lgico a la izquierda

Desplazamiento aritmtico a la derecha

Cul es el valor de $t0?

Cul es el valor de $t0?

000 . 0110 $t1

Cul es el valor de $t0?

Cul es el valor de $t0?

000 . 0110 $t1

beqz $t1 direccion

El salto se realiza siempre

bge $t0 t1 fin

bneq $t0 $t2

blt $t1 $t2 then

# se obtiene el ltimo bit

$t4 $t1 fin

SPIM es un simulador de una

Simulador SPIM (otra versin)

SPIM es un simulador de una

Probar en el simulador pequeos programas en ensamblador

MIPS: Visin general

Valor cableado a cero

Mapa de memoria de un programa

El programa de usuario se divide

Segmento de cdigo (texto)

Ejemplo: Hola mundo

Ejemplo: Hola mundo

Ejemplo: Hola mundo

Programa en ensamblador: directivas

Siguientes elementos van al segmento de dato

Siguientes elementos van al segmento de cdigo

Almacena cadena caracteres NO terminada en carcter nulo

Almacena cadena caracteres terminada en carcter nulo

Almacena bytes en memoria consecutivamente

300, 301, 302

Almacena medias palabras en memoria consecutivamente

Almacena palabras en memoria consecutivamente