You are on page 1of 315

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

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

Estructura de Computadores

Motivacin para usar MIPS 32


! Arquitectura simple.
" Facilidad

de
aprendizaje.

! Ensamblador similar al de

otros procesadores RISC


! Usado en diversos

dispositivos

4
ARCOS

Estructura de Computadores

Qu es un computador?
datos

resultados
Procesador
Instrucciones

ARCOS

Estructura de Computadores

Instruccin mquina

001 AB 00000000101

Cdigo de operacin

Operandos

ARCOS

Registros
Direcciones de memoria
Nmeros

Estructura de Computadores

Fases de ejecucin de una instruccin


PC

! Lectura de la instruccin (ciclo de fetch)


"
"
"
"
"

MAR
PC
Lectura
MBR
Memoria
PC
PC + 1
RI
MBR

000100

RI
MAR

! Decodificacin de la instruccin

Direccin
000100

! Ejecucin de la instruccin

MBR

Contenido
0010000000000000

! Volver a fetch

Memoria
ARCOS

Estructura de Computadores

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

Estructura de Computadores

Programa
! Secuencia ordenada de instrucciones mquina que se ejecutan

en secuencia

00001001110001101010111101011000
10101111010110000000100111000110
11000110101011110101100000001001
01011000000010011100011010101111

ARCOS

Estructura de Computadores

temp = v[k];
v[k] = v[k+1];
v[k+1] = temp;

Diferentes niveles de lenguajes

Lenguaje de alto nivel


(ej: C, C++)
compilador
Lenguaje ensamblador
(Ej: MIPS)

temp = v[k];
v[k] = v[k+1];
v[k+1] = temp;
lw
lw
sw
sw

$t0, 0($2)
$t1, 4($2)
$t1, 0($2)
$t0, 4($2)

Ensamblador
Lenguaje Mquina
(MIPS)

ARCOS

0000
1010
1100
0101

1001
1111
0110
1000

1100
0101
1010
0000

Estructura de Computadores

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

Estructura de Computadores

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

"

ARCOS

Modos de ejecucin

Estructura de Computadores

12

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

Estructura de Computadores

13

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

Estructura de Computadores

14

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

! Hay 32 registros

Estructura de Computadores

"

Tamao de
1 palabra (4 bytes)
Se nombran con
un $ al principio

! Convenio de uso
" Reservados
" Argumentos
" Resultados
" Temporales
" Punteros

15

Tipos de instrucciones
!
!
!
!
!
!
!

De transferencia
Aritmtica
Lgicas
De desplazamiento
De rotacin
De comparacin
De bifurcacin

ARCOS

Estructura de Computadores

16

Transferencia de datos
! Copia de un dato en un registro. Carga inmediata

li $t0 5

$t0

! Registro a registro
" move $a0 $t0

$a0

"

"

$t0

Instrucciones de acceso a memoria (ms adelante)


! De registro a memoria
! De memoria a registro

ARCOS

Estructura de Computadores

17

Aritmticas
! Realiza operaciones aritmticas de entero (ALU) o aritmtica de

coma flotante (FPU)


! Ejemplos de operaciones con enteros
"

"
"
"

ARCOS

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

$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

Estructura de Computadores

18

Ejemplo
int
int
int
int

a = 5;
b = 7;
c = 8;
d;

d = a * (b + c)

ARCOS

li $t0, 5
li $t1, 7
li $t2, 8
add $t1, $t1, $t2
mul $t3, $t1, $t0

Estructura de Computadores

19

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

Estructura de Computadores

$t4,
$t4,
$t4,
$t5,
$t4,

$t1,
$t4,
$t4,
-1
$t4,

$t3
$t0
$t2
$t5

20

Lgicas
! Operaciones booleanas
! Ejemplos:
" AND
and $t0 $t1 $t2
"

($t0 = $t1 & $t2)

OR
or $t0 $t1 $t2 ($t0 = $t1 | $t2)
ori $t0 $t1 80 ($t0 = $t1 | 80)

1100

AND

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

Estructura de Computadores

21

Ejemplo
li $t0, 5
li $t1, 8

Cul es el valor de $t2?

and $t2, $t1, $t0

ARCOS

Estructura de Computadores

22

Solucin
li $t0, 5
li $t1, 8

Cul es el valor de $t2?

and $t2, $t1, $t0

and

ARCOS

Estructura de Computadores

000 . 0101 $t0


000 .. 1000 $t1
000 .. 0000 $t2

23

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

Estructura de Computadores

24

Ejemplo
li $t0, 5
li $t1, 6

Cul es el valor de $t0?

sra $t0, $t1, 1

ARCOS

Estructura de Computadores

25

Ejemplo
li $t0, 5
li $t1, 6
sra

Cul es el valor de $t0?

$t0, $t1, 1

000 . 0110 $t1


Se desplaza 1 bit a la derecha

000 .. 0011 $t0

ARCOS

Estructura de Computadores

26

Ejemplo
li $t0, 5
li $t1, 6

Cul es el valor de $t0?

sra $t0, $t1, 1

ARCOS

Estructura de Computadores

27

Ejemplo
li $t0, 5
li $t1, 6

Cul es el valor de $t0?

sra $t0, $t1, 1

000 . 0110 $t1


Se desplaza 1 bit a la izquierda

000 .. 1100 $t0

ARCOS

Estructura de Computadores

28

Rotaciones
! De movimiento de bits
! Ejemplos:
"

Rotacin a la izquierda
rol $t0 $t0 4
rotan 4 bits
01110110101

"

ARCOS

Rotacin a la derecha
ror $t0 $t0 5 rotan 5 bits

Estructura de Computadores

01110110101

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

if ($t1 == $t2)
if ($t1 !=$t2)
if ($t1 >= $t2)
if ($t1 > $t2)
if ($t1 <= $t2)
if ($t1 < $t2)

Estructura de Computadores

$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

30

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

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

Estructura de Computadores

31

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

ARCOS

Llamadas a funciones:

} jal 0x20001E jr $ra

Estructura de Computadores

32

Instrucciones de bifurcacin
!
!
!
!
!
!
!

beqz
beq
bneq
bge
bgt
ble
blt

ARCOS

$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)

Estructura de Computadores

33

Ejercicio
Dada la siguiente expresin de un lenguaje de alto nivel
int a = 6;
int b = 7;
int c = 3;
int d;
d = (a+b) * (a+b);
Indique un fragmento de cdigo en ensamblador del MIPS 32 que
permita evaluar la expresin anterior. El resultado ha de
almacenarse en el registro $t5.

ARCOS

Estructura de Computadores

34

Estructuras de control
while
int i;
i=0;
while (i < 10)
{
/* accin */
i = i + 1 ;
}
}

ARCOS

li
li
while:

$t0 0
$t1 10

bge $t0 t1 fin


# accin
addi $t0 $t0 1

fin:

Estructura de Computadores

b while
...

35

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

Estructura de Computadores

36

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

Estructura de Computadores

37

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

Estructura de Computadores

38

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 ;
}

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

}
ARCOS

Estructura de Computadores

39

Ejemplo
! Obtener los 16 bits superiores de un registro ($t0) y dejarlos en

los 16 bits inferiores de otro ($t1)

ARCOS

Estructura de Computadores

40

Solucin
! Obtener los 16 bits superiores de un registro ($t0) y dejarlos en

los 16 bits inferiores de otro ($t1)


srl

ARCOS

$t1,

01110110101

$t0,

16

Se desplaza a la derecha 16
Posiciones (de forma lgica)

Estructura de Computadores

41

Estructuras de control
if
int b1 = 4;
int b2 = 2;

li
li
li

if (b2 == 8) {
b1 = 0;
}
...
fin:

ARCOS

Estructura de Computadores

$t0 4
$t1 2
$t2 8

bneq $t0 $t2


li
$t0 0
...

fin

42

Estructuras de control
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

Estructura de Computadores

43

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

Estructura de Computadores

44

Solucin
! Determinar si el contenido de un registro ($t2) es par. Si es par

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

Estructura de Computadores

45

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. En este caso


consultando el ltimo bit

ARCOS

Estructura de Computadores

46

Solucin
! Determinar si el contenido de un registro ($t2) es par. Si es par

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

Estructura de Computadores

47

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

Estructura de Computadores

48

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

Estructura de Computadores

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

49

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

Estructura de Computadores

50

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

Estructura de Computadores

51

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

Estructura de Computadores

52

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

Estructura de Computadores

53

MIPS: Visin general

ARCOS

Estructura de Computadores

54

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

Estructura de Computadores

55

Banco de registros
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

ARCOS

! Hay 32 registros
"
"

4 bytes de tamao
(una palabra)
Se nombran con
un $ al principio

! Convenio de uso
"
"
"
"
"

Reservados
Argumentos
Resultados
Temporales
Punteros

Estructura de Computadores

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
8
9
10
11
12
13
14
15

ARCOS

$zero

Valor cableado a cero


No puede modificarse

Estructura de Computadores

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

$t0
$t1
$t2
$t3
$t4
$t5
$t6
$t7

Valores temporales

10
11
12
13
14
15

ARCOS

$t8
$t9

Estructura de Computadores

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

$zero

$t0
$t1
$t2
$t3
$t4
$t5
$t6
$t7

Valores guardados

10
11
12
13
14
15

ARCOS

Estructura de Computadores

$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

59

Banco de registros
0
1
2
3
4
5
6
7

$zero

8
9

10
11
12
13
14
15

ARCOS

$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

Estructura de Computadores

$sp
$fp
$ra

16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

60

Banco de registros
0
1
2
3
4
5
6
7
8
9

10
11
12
13
14
15

ARCOS

$zero
$at
$v0
$v1
$a0
$a1
$a2
$a3
$t0
$t1
$t2
$t3
$t4
$t5
$t6
$t7

Otros

Estructura de Computadores

$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

61

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

Estructura de Computadores

62

Distribucin de la memoria de un
programa

ARCOS

Estructura de Computadores

63

Mapa de memoria de un programa


$fp
01011001

Segmento de Pila

! El programa de usuario se divide

en segmentos
"

! Variables locales
! Contexto de funciones

$sp
01011001

$gp

Segmento de pila

"

Segmento de datos
! Datos estticos

"

Segmento de cdigo (texto)


! Cdigo

01011001

Segmento de Datos
Segmento de Texto

ARCOS

pc
01011001

Estructura de Computadores

64

Estructura de un programa

ARCOS

Estructura de Computadores

65

Simulador SPIM

Banco de
registros
$0, $1, $2,
$f0, $f1,

Segmento
de cdigo
Segmento
de datos
Segmento
de pila
Otros

ARCOS

Estructura de Computadores

66

Simulador SPIM

Banco de
registros
$0, $1, $2,
$f0, $f1,

Segmento
de cdigo
Segmento
de datos
Segmento
de pila

ARCOS

Estructura de Computadores

67

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

Estructura de Computadores

68

Ejemplo: Hola mundo


# comentario hasta fin de la lnea
etiqueta:

instruccin/pseudoinstruccin

operandos

.directiva
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

Estructura de Computadores

69

Ejemplo: Hola mundo


hola.s
.data
msg_hola: .asciiz "hola mundo\n"

.text
.globl main
main:
# printf("hola mundo\n") ;
li $v0 4 #cdigo de llamada
la $a0 msg_hola
syscall

ARCOS

Estructura de Computadores

70

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

Estructura de Computadores

71

Definicin de datos estticos

ARCOS

Estructura de Computadores

72

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

Estructura de Computadores

73

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

Estructura de Computadores

direccin en $v0

74

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

$a0 (cdigo ASCII)


$v0 (cdigo ASCII)

Estructura de Computadores

75

Ejemplo

ARCOS

Estructura de Computadores

76

Ejemplo

ARCOS

Estructura de Computadores

77

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

Estructura de Computadores

78

Espacio de direcciones.
Direccionamiento por bytes
Direcciones
de bytes
0
1
2
3
4
5
6

Byte
(contenido)

Direccin: 6 (000110)
Contenido: 00001101 (9)
00001101

2n-1
ARCOS

Estructura de Computadores

79

Espacio de direcciones.
Direccionamiento por bytes
Direcciones
de bytes

0x0F000000
0x0F000001
0x0F000002
0x0F000003

ARCOS

Byte
(contenido)

Direccin: 0x0F000002
Contenido: 00001101 (9)
00001101

Estructura de Computadores

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


! Medias palabras almacenadas a partir de una direccin: A31 A0
! Palabras almacenadas a partir de una direccin: A31 A0

ARCOS

Estructura de Computadores

81

Espacio de direcciones.
Diferentes tamaos de acceso
Direcciones
de bytes

0x0F000000
0x0F000001
0x0F000002
0x0F000003
0x0F000004
0x0F000005
0x0F000006
0x0F000007
0x0F000008

ARCOS

Byte
(contenido)

byte
Media palabra (16 bits)
Palabra (32 bits)

Estructura de Computadores

82

Espacio de direcciones y acceso a bytes


Direcciones
de bytes
0
1
2
3
4
5
6

Byte
(contenido)

lb $t1, 0x6

Direccin: 6 (000110)
Contenido: 00001101 (9)
00001101

$t1
31

24 23

16 15

87

2n-1
ARCOS

Estructura de Computadores

83

Espacio de direcciones y acceso a bytes


Direcciones
de bytes
0
1
2
3
4
5
6

Byte
(contenido)

lb $t1, 0x6

Direccin: 6 (000110)
Contenido: 00001101 (9)
00001101

$t1

00000000
00000000
00000000
31
24 23
16 15
87

00001101
0

2n-1
ARCOS

Estructura de Computadores

84

Espacio de direcciones y acceso a bytes


Direcciones
de bytes
0
1
2
3
4
5
6

Byte
(contenido)

lb $t1, 0x6

Direccin: 6 (000110)
Contenido: 11111101 (-3 en complemento a 2)
11111101

$t1
31

24 23

16 15

87

2n-1
ARCOS

Estructura de Computadores

85

Espacio de direcciones y acceso a bytes


Direcciones
de bytes
0
1
2
3
4
5
6

Byte
(contenido)

lb $t1, 0x6

Direccin: 6 (000110)
Contenido: 11111101 (-3 en complemento a 2)
11111101

$t1
31

11111111
11111111
11111111
24 23
16 15
87

11111101
0

2n-1
ARCOS

Estructura de Computadores

86

Espacio de direcciones y acceso a bytes


Direcciones
de bytes
0
1
2
3
4
5
6

Byte
(contenido)

lb $t1, 0x6

Direccin: 6 (000110)
Contenido: 11111101 (-3 en complemento a 2)
11111101

$t1
31

11111111
11111111
11111111
24 23
16 15
87

11111101
0

Mantiene el signo
2n-1
ARCOS

Estructura de Computadores

87

Espacio de direcciones y acceso a bytes


Direcciones
de bytes
0
1
2
3
4
5
6

Byte
(contenido)

lbu $t1, 0x6

Direccin: 6 (000110)
Contenido: 11111101 (-3 en complemento a 2)
11111101

$t1
31

24 23

16 15

87

2n-1
ARCOS

Estructura de Computadores

88

Espacio de direcciones y acceso a bytes


Direcciones
de bytes
0
1
2
3
4
5
6

Byte
(contenido)

lbu $t1, 0x6

Direccin: 6 (000110)
Contenido: 11111101 (-3 en complemento a 2)
11111101

$t1

00000000
00000000
31
24 23
16 15

0000000

11111101
87

2n-1
ARCOS

Estructura de Computadores

89

Espacio de direcciones y acceso a bytes


Direcciones
de bytes
0
1
2
3
4
5
6

Byte
(contenido)

lbu $t1, 0x6

Direccin: 6 (000110)
Contenido: 11111101 (-3 en complemento a 2)
11111101

$t1

00000000
00000000
31
24 23
16 15

0000000

11111101
87

Carga sin mantener el signo


2n-1
ARCOS

Estructura de Computadores

90

Almacenamiento de palabras en la
memoria
Direcciones
de bytes
0
1
2
3
4
5
6
7
8

Byte
(contenido)

4 bytes forman una palabra


Palabra almacenada a partir del byte 0

Palabra almacenada a partir del byte 4

2n-1
ARCOS

Estructura de Computadores

91

Almacenamiento de palabras en la
memoria
Direcciones
de bytes
0
1
2
3
4
5
6
7
8

Byte
(contenido)

Palabra de 32 bits
byte0

byte1

31
24 23
+ significativo

byte2
16 15

byte3
87

0
- significativo

2n-1
ARCOS

Estructura de Computadores

92

Almacenamiento de palabras en la
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

00011011
00000000
00000000
00000000

LittleEndian
Estructura de Computadores

93

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

LittleEndian

Estructura de Computadores

94

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

BigEndian

ARCOS

Transmisin de
datos por la red

Estructura de Computadores

A
A+1
A+2
A+3

LittleEndian

95

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

BigEndian

ARCOS

Transmisin de
datos por la red

Estructura de Computadores

A
A+1
A+2
A+3

00000000
00000000
00000000
00011011

LittleEndian

96

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

00000000
00000000
00000000
00011011

LittleEndian

El nmero almacenado es: 000110110000000000000000000000000


que no es el 27

ARCOS

Estructura de Computadores

97

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

24 23

Estructura de Computadores

16 15

87

98

Espacio de direcciones y acceso a fsico a


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

24 23

Estructura de Computadores

16 15

87

99

Espacio de direcciones y acceso a fsico a


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

24 23

Estructura de Computadores

16 15

87

100

Espacio de direcciones y acceso a fsico a


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

24 23

Estructura de Computadores

16 15

87

101

Espacio de direcciones y acceso a fsico a


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

Estructura de Computadores

00000000
00000001
24 23
16 15

00001101
87

102

Diferencias entre lw, lb, lbu, la


Direcciones
de bytes

0x0F000000
0x0F000001
0x0F000002
0x0F000003

ARCOS

Byte
(contenido)

lw $t1, 0x0F000000

0xCB
0x12
0x08
0x02

Estructura de Computadores

103

Diferencias entre lw, lb, lbu, la


Direcciones
de bytes

0x0F000000
0x0F000001
0x0F000002
0x0F000003

Byte
(contenido)

lw $t1, 0x0F000000

0xCB
0x12
0x08
0x02

Se copia la palabra
(el contenido de la direccin)

0xCB

$t1

11001011
31

ARCOS

0x12

0x08

0x02

00010010
00001000
00000010
24 23
16 15
87

Estructura de Computadores

104

Diferencias entre lw, lb, lbu, la


Direcciones
de bytes

0x0F000000
0x0F000001
0x0F000002
0x0F000003

Byte
(contenido)

lbu $t1, 0x0F000002

0xCB
0x12
0x08
0x02

Se copia el byte (el contenido)

0x08

$t1

00000000
31

ARCOS

00000000
00000000
24 23
16 15

Estructura de Computadores

00001000
87

105

Diferencias entre lw, lb, lbu, la


Direcciones
de bytes

Byte
(contenido)

la $t1, 0x0F000000

Se copia la direccin,
no el contenido
0x0F000000
0x0F000001
0x0F000002
0x0F000003

0xCB
0x12
0x08
0x02

0x0F

$t1

00001111
31

ARCOS

0x00

0x00

0x00

00000000
00000000
00000000
24 23
16 15
87
0

Estructura de Computadores

106

Ejemplo
Direcciones
de bytes

Byte
(contenido)

li $t1, 18
li $t2, 24

0x0F000000
0x0F000001
0x0F000002
0x0F000003
0x0F000004
0x0F000005
0x0F000006
0x0F000007

ARCOS

Estructura de Computadores

107

Ejemplo
Direcciones
de bytes

0x0F000000
0x0F000001
0x0F000002
0x0F000003
0x0F000004
0x0F000005
0x0F000006
0x0F000007

Byte
(contenido)

li $t1, 18
li $t2, 24

$t1

00000000
31

$t2

00000000
31

ARCOS

00000000
00000000
24 23
16 15

00010010
87

00000000
00000000
24 23
16 15

00011000
87

Estructura de Computadores

108

Ejemplo
Direcciones
de bytes

Byte
(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

00000000
00000000
24 23
16 15

00010010
87

00000000
00000000
24 23
16 15

00011000
87

Estructura de Computadores

109

Ejemplo
Direcciones
de bytes

0x0F000000
0x0F000001
0x0F000002
0x0F000003
0x0F000004
0x0F000005
0x0F000006
0x0F000007

Byte
(contenido)

00000000
00000000
00000000
00010000
00000000
00000000
00000000
00011000

sw $t1, 0x0F000000
sw $t2, 0x0F000004

$t1

00000000
31

$t2

00000000
31

ARCOS

00000000
00000000
24 23
16 15

00010010
87

00000000
00000000
24 23
16 15

00011000
87

Estructura de Computadores

110

Ejemplo
Direcciones
de bytes

Byte
(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

00000000
00000000
24 23
16 15

Estructura de Computadores

00010010
87

111

Ejemplo
Direcciones
de bytes

0x0F000000
0x0F000001
0x0F000002
0x0F000003
0x0F000004
0x0F000005
0x0F000006
0x0F000007

Byte
(contenido)

00000000
00000000
00000000
00010000
00000000
00000000
00000000
00011000

lw $t3, 0x0F000000

$t3

00000000
31

$t1

00000000
31

$t2

00000000
31

ARCOS

00000000
00000000
24 23
16 15

00010010
87

00000000
00000000
24 23
16 15

00010010
87

00000000
00000000
24 23
16 15

00011000
87

Estructura de Computadores

112

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

Estructura de Computadores

113

Alineacin de datos

direccin
0
4
8
12

31

23

15

Esta palabra est alineada, el resto no

16
20
24

ARCOS

Estructura de Computadores

114

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

Estructura de Computadores

115

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

00000000

00000000

00001110

00001101
byte 0

Estructura de Computadores

byte 1

byte 2

byte 3

116

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

Estructura de Computadores

117

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:
"
"

ARCOS

lui $t1, 0x0080


ori $t1, $t1, 0x0010

Estructura de Computadores

118

Otro ejemplo de pseudoinstruccin


! La pseudoinstruccin move

move

reg2,reg1

! Se convierte en:

add

ARCOS

reg2,$zero,reg1

Estructura de Computadores

119

Formatos de las instrucciones de acceso a


memoria

lw
sw
lb
sb
lbu

ARCOS

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
Estructura de Computadores

120

Otros usos de la instruccin la, lw, lb


Direcciones
de bytes

0x0F000000
0x0F000001
0x0F000002
0x0F000003

Byte
(contenido)

0xCB
0x12
0x08
0x02

$t0
31

24 23

16 15

87

31

24 23

16 15

87

$t1

ARCOS

Estructura de Computadores

121

Otros usos de la instruccin lw, lb


Direcciones
de bytes

0x0F000000
0x0F000001
0x0F000002
0x0F000003

Byte
(contenido)

la $t0, 0x0F000002

0xCB
0x12
0x08
0x02

$t0
31

24 23

16 15

87

31

24 23

16 15

87

$t1

ARCOS

Estructura de Computadores

122

Otros usos de la instruccin lw, lb


Direcciones
de bytes

0x0F000000
0x0F000001
0x0F000002
0x0F000003

Byte
(contenido)

la $t0, 0x0F000002

Se copia la direccin,
no el contenido

0xCB
0x12
0x08
0x02

$t0

00001111
00000000
00000000
31
24 23
16 15

00000010
87

31

87

$t1

ARCOS

24 23

Estructura de Computadores

16 15

123

Otros usos de la instruccin lw, lb


Direcciones
de bytes

0x0F000000
0x0F000001
0x0F000002
0x0F000003

Byte
(contenido)

lbu

$t0, ($t1)

0xCB
0x12
0x08
0x02

$t0

00001111
00000000
00000000
31
24 23
16 15

00000010
87

31

87

$t1

ARCOS

24 23

Estructura de Computadores

16 15

124

Otros usos de la instruccin lw, lb


Direcciones
de bytes

0x0F000000
0x0F000001
0x0F000002
0x0F000003

Byte
(contenido)

0xCB
0x12
0x08
0x02

lbu

Se copia el byte almacenado en la posicin de


memoria cuya direccin est almacenada en $t0

$t0

$t1

ARCOS

$t0, ($t1)

00001111
00000000
00000000
31
24 23
16 15

00000010
87

00000000
00000000
00000000
31
24 23
16 15

00001000
87

Estructura de Computadores

125

Otros usos de la instruccin lw, lb


Direcciones
de bytes

0x0F000000
0x0F000001
0x0F000002
0x0F000003

Byte
(contenido)

0xCB
0x12
0x08
0x02

lw

Se copia la palabra almacenada en la posicin de


memoria cuya direccin est almacenada en $t0

$t0

$t1

ARCOS

$t0, ($t1)

00001111
00000000
00000000
31
24 23
16 15

00000000
87

11001011
00010010
00001000
31
24 23
16 15

00000010

Estructura de Computadores

87

126

Otros usos de la instruccin lw, lb


! 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

Estructura de Computadores

127

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

Estructura de Computadores

128

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

add $t3 $t1 $t2


la $t4 resultado
sw $t3 ($t4)
...

Estructura de Computadores

129

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

Estructura de Computadores

130

Tipo de datos bsicos


vectores
! 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

Estructura de Computadores

Direccion_inicio

v[0]
v[1]
v[2]

v[N-1]

Tipo de datos bsicos


vectores
.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

Estructura de Computadores

132

Tipo de datos bsicos


vectores
.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:

li

$t0 16

la

$t1

vec

add $t3, $t1, $t0


li

$t2

sw

$t2, ($t3)

...

ARCOS

Estructura de Computadores

133

Tipo de datos bsicos


vectores
.data
int vec[5] ;
...
main ()
{
vec[4] = 8;
}

.align
2
#siguiente dato alineado
vec: .space 20
#5 elem.*4 bytes

a 4

.text
.globl main

main:
li $t2

li $t1

16

sw $t2 vec($t1)
...

ARCOS

Estructura de Computadores

134

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

Estructura de Computadores

135

Tipo de datos bsicos


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
siendo p el tamao de cada elemento

ARCOS

Estructura de Computadores

1 vector

2 vector

Tipo de datos bsicos


matrices
.data
.align 2
int vec[5] ;
int mat[2][3] = {{11,12,13},
{21,22,23}};
...
main ()
{
m[0][1] = m[0][0] +
m[1][0] ;
...
}

#siguiente dato alineado a 4

vec: .space 20

#5 elem.*4 bytes

mat: .word 11, 12, 13


.word 21, 22, 23
...
.text
.globl main

main:

lw $t1 mat+0
lw $t2 mat+12
add $t3 $t1 $t2
sw

$t3 mat+4

...

ARCOS

Estructura de Computadores

137

Tipo de datos bsicos


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

.data
c1: .space 1
# 1 byte
c2: .byte h
ac1: .asciiz hola
...
.text
.globl main
main:
li $v0 4
la $a0 ac1
syscall
...

Estructura de Computadores

138

Tipo de datos bsicos


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

Estructura de Computadores

139

Vectores y cadenas
! En general:

lw $t0, 4($s3) # $t0


M[$s3+4]
" sw $t0, 4($s3) # M[$s3+4]
$t0
"

ARCOS

Estructura de Computadores

140

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

Estructura de Computadores

141

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

Estructura de Computadores

142

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

Estructura de Computadores

143

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

$f31

$f0
$f2

B.R.

$f30

ALU
BUS

ARCOS

Estructura de Computadores

144

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

Estructura de Computadores

145

Operaciones en coma flotante


! Aritmtica de coma flotante IEEE 754 en la FPU
! Ejemplos:
" Suma simple precisin

add.s $f0 $f1 $f4


f0 = f1 + f4
"

FPU
$f1
$f3

$f31

$f0
$f2

B.R.

$f30

Suma doble precisin

ALU

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

Estructura de Computadores

146

Operaciones en coma flotante


! Transferencia entre registros de coma flotante y
!
!
!
!
!
!

memoria
lwc1 $f0, direccion:
" Carga en $f0 un valor de tipo float
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

Estructura de Computadores

147

Tipo de datos bsicos


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 ()
{
resultado = op1 + op2 ;
...
}

ARCOS

l.s

$f0 op1
$f1 op2

add.s

$f3 $f1 $f2

s.s
...

$f3 resultado

Estructura de Computadores

148

Tipo de datos bsicos


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 ()
{
resultado = op1 * op2 ;
...
}

ARCOS

l.d

$f0 op1
$f2 op2

mul.d

$f6 $f0 $f2

s.d
...

$f6 resultado

Estructura de Computadores

# ($f0,$f1)
# ($f2,$f3)

149

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

ALU
BUS

Estructura de Computadores

150

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

ALU
BUS

Estructura de Computadores

151

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

B.R.

ALU
BUS

$f0 $f1

ARCOS

Estructura de Computadores

152

Operaciones con registros (FPU, FPU)

mov.d $f0 $f2


FPU

FPU
$f1

$f0

$f1

$f3

$f2

$f3

$f31

$f30
ALU
BUS

B.R.

$f31

$f0
$f2

$f30

B.R.

ALU
BUS

($f0, $f1) ($f2, $f3)

ARCOS

Estructura de Computadores

153

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

Estructura de Computadores

154

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

Estructura de Computadores

155

Ejemplo

float PI
int

= 3,1415;

radio = 4;

float longitud;
longitud = PI * radio;

ARCOS

.text
.globl main

main:

li.s $f0 3.1415
li $t0 4

mtc1 $t0 $f1 # 4 en Ca2
cvt.s.w $f2 $f1 # 4 ieee754
mul.s $f0 $f2 $f1

Estructura de Computadores

156

Ejemplo

float PI
int

= 3,1415;

radio = 4;

float longitud;
longitud = PI * radio;

FPU

CPU
t0
t1

B.R. enteros

$f1
$f3

$f31

$f0
$f2

$f30

U.C
ALU
BUS

ARCOS

B.R.

.text
.globl main

main:

li.s $f0 3.1415
li $t0 4

mtc1 $t0 $f1 # 4 en Ca2
cvt.s.w $f2 $f1 # 4 ieee754
mul.s $f0 $f2 $f1

ALU
BUS

Estructura de Computadores

157

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

Estructura de Computadores

158

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

la $a0,
li $v0,
syscall

# se
mfc1

saltolinea
4

li $s0, 0x7F800000
and $a0, $t0, $s0
srl $a0, $a0, 23
li $v0, 1
syscall

#se imprime
mov.s $f12, $f0
li $v0, 2
syscall

la $a0,
li $v0,
syscall

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

Estructura de Computadores

159

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

Estructura de Computadores

160

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

Estructura de Computadores

161

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
aritmticas

Tipo I
transferencia
inmediato

Tipo J
saltos

op.

rs

rt

rd

shamt

func.

6 bits

5 bits

5 bits

5 bits

5 bits

6 bits

op.

rs

rt

offset

6 bits

5 bits

5 bits

16 bits

op.

offset

6 bits

ARCOS

26 bits

Estructura de Computadores

162

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

Estructura de Computadores

163

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

Estructura de Computadores

164

Modos de direccionamiento
! El modo de direccionamiento es un procedimiento que permite

determinar la ubicacin de un operando o una instruccin


! Tipos:
"
"
"
"
"
"

"
"

ARCOS

Inmediato
Directo
De registro
Indirecto
Indirecto de registro
Relativo
! A registro base
! A registro ndice
! A contador de programa
Implcito
De pila
Estructura de Computadores

165

Direccionamiento inmediato
!El operando es parte de la instruccin.
!Ejemplo:
"li
"addi

$a0
$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

Estructura de Computadores

166

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

Estructura de Computadores

167

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

! Problemas:

Acceso a memoria es lento comparado con los registros


" Direcciones largas => instrucciones ms largas
"

ARCOS

Estructura de Computadores

168

Direccionamiento indirecto de registro


! Se indica en la instruccin el registro

que almacena la direccin del operando


! Ejemplo (MIPS): lw $a0 ($a1)
" Carga en $a0 lo que hay en la direccin
de memoria almacenada en $a1.

op

rs

rt

memoria
B.Reg.

operando

direccin

16 bits

! Ventajas:
" Instrucciones cortas
" En el caso del MIPS permite direccionar toda la memoria (32 bits)

ARCOS

Estructura de Computadores

169

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

! Problemas:
"

Puede requerir varios accesos a memoria

"

Es ms lento

ARCOS

Estructura de Computadores

170

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

Estructura de Computadores

Operando

171

Utilidad: acceso a vectores


! Se carga en el registro

.data
.align

la direccin de inicio
del vector

#siguiente dato alineado a 4

vec: .space 20

#5 elem.*4 bytes

.text

int vec[5] ;
...
main ()
{
v[4] = 8;

.globl main

main:

la $t1 vec
li $t2

sw $t2 16($t1)
...

ARCOS

Estructura de Computadores

172

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

Estructura de Computadores

Operando

173

Utilidad: acceso a vectores


! Se carga en el registro

.data
.align

la direccin de inicio
del vector

#siguiente dato alineado a 4

vec: .space 20

#5 elem.*4 bytes

.text

int vec[5] ;
...
main ()
{
v[3] = 8;
v[4] = 8;

.globl main

main:

li $t1 12
li $t2

sw $t2 vec($t1)
addi $t1

$t1

sw $t2 vec($t1)
...

}
ARCOS

Estructura de Computadores

174

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

Estructura de Computadores

175

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

Estructura de Computadores

Instruccin:
or
$2,$0,$0
slt
$8,$0,$5
beq
$8,$0,3
add
$2,$2,$4
addi $5,$5,-1
j
0x100001

176

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

Estructura de Computadores

177

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 ==
"

ARCOS

Cuando se ejecuta una instruccin, el PC apunta a la siguiente

Estructura de Computadores

178

Utilidad: desplazamientos en bucles


! fin representa la

direccin donde se
encuentra la instruccin
move
while:

fin:

ARCOS

Estructura de Computadores

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

179

Utilidad: desplazamientos en bucles


Direccin

while:

fin:

ARCOS

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

Estructura de Computadores

$t0

while
$t4

180

Utilidad: desplazamientos en bucles


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

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

Estructura de Computadores

$t0

while
$t4

181

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

Estructura de Computadores

182

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

Estructura de Computadores

183

Direccionamiento de pila
PUSH Reg

Apila el contenido del registro (dato)

dato
cima

$sp

$sp

cima

crece hacia direcciones bajas

ARCOS

Estructura de Computadores

184

Direccionamiento de pila
POP Reg

dato

Desapila el contenido del registro (dato)


Copia dato en el registro Reg

$sp

dato

cima

cima

$sp

crece hacia direcciones bajas

ARCOS

Estructura de Computadores

185

Direccionamiento de pila
186

! 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

Estructura de Computadores

186

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

! lw $t0 label
"
"

directo a memoria
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


"
"
"

ARCOS

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
Estructura de Computadores

187

Modos de direccionamiento en el MIPS


! Direccionamientos:

Inmediato
" De registro
" Directo
" Indirecto de registro
" Relativo a registro
" Relativo a PC
" Relativo a pila
"

ARCOS

valor
$r
dir
($r)
desplazamiento($r)
beq etiqueta
desplazamiento($sp)

Estructura de Computadores

188

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

rs

rt

rd

shamt

Estructura de Computadores

func.

189

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
aritmticas

ARCOS

op.

rs

rt

Estructura de Computadores

rd

shamt

func.

190

Formato de una instruccin


191

! 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

Estructura de Computadores

191

Longitud de formato
192

! 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

Estructura de Computadores

192

193

Ejemplo: Formato de las instrucciones del


MIPS
6

CO

rs

rt

rd

sa

func

26

Dato inmediato

CO

ARCOS

add $t0, $t0, $t1

16

CO

rs

rt

Dato inmediato

Estructura de Computadores

addi $t0, $t0, 1

193

Ejemplo de formato en el MIPS


! MIPS Instruction:

add
$8,$9,$10
" Formato a utilizar:
"

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

Estructura de Computadores

194

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

Estructura de Computadores

195

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

Estructura de Computadores

196

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

Estructura de Computadores

197

Pregunta
198

! 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

Estructura de Computadores

198

Cdigo de operacin
199

! 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
aritmticas

op.

rs

rt

rd

shamt

func.

! Tamao variable:
" Instrucciones

ARCOS

ms frecuentes = Tamaos ms cortos.


Estructura de Computadores

199

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

Estructura de Computadores

200

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

Estructura de Computadores

201

Solucin

palabra -> 16 bits


60 instrucciones
8 registros (en BR)
ADDx R1(reg.), R2(reg.), R3(reg.)

! Para 60 instrucciones se necesitan 6 bits (mnimo)

16 bits
6 bits
Cdigo de
operacin

ARCOS

Estructura de Computadores

202

palabra -> 16 bits


60 instrucciones
8 registros (en BR)
ADDx R1(reg.), R2(reg.), R3(reg.)

Solucin

! Para 8 registros se necesitan 3 bits (mnimo)

16 bits

ARCOS

6 bits

3 bits 3 bits 3 bits

Cdigo de
operacin

Operandos (3
registros)

Estructura de Computadores

203

palabra -> 16 bits


60 instrucciones
8 registros (en BR)
ADDx R1(reg.), R2(reg.), R3(reg.)

Solucin

! Sobra 1 bit (16-6-3-3-3 = 1), usado de relleno

16 bits
6 bits
Cdigo de
operacin

ARCOS

3 bits 3 bits 3 bits 1 bit


Operandos (3
registros)

Estructura de Computadores

204

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

Estructura de Computadores

205

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

Estructura de Computadores

206

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)


"
"
"
"
"
"
"

ARCOS

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.

Estructura de Computadores

207

Modelos de ejecucin
208

! 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 # Pila.
!1 direccin # Registro acumulador.
!2 direcciones # Registros, Registro-Memoria, Memoria-

Memoria.
!3 direcciones # Registros, Registro-Memoria, MemoriaMemoria.

ARCOS

Estructura de Computadores

208

Modelo de 3 direcciones
209

! Registros

" Los 3 operandos son registros.


" Requiere operaciones de carga/almacenamiento.
" ADD .R0, .R1, .R2

! Memoria-Memoria

" Los 3 operandos son direcciones


" ADD /DIR1, /DIR2, /DIR3

de memoria.

! Registro-Memoria
" Hbrido.
" ADD .R0,
" ADD .R0,

ARCOS

/DIR1, /DIR2
.R1, /DIR1

Estructura de Computadores

209

Ejemplo
210

X = A + B * C
/DA

/DB

/DC

/DX

Modelo de ejecucin

ARCOS

Estructura de Computadores

210

3 direcciones: R-R
211

LOAD
LOAD
MUL
LOAD
ADD
STORE

ARCOS

.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

Estructura de Computadores

211

3 direcciones: M-M
212

MUL /DX, /DB, /DC


ADD /DX, /DX, /DA

2 instrucciones
6 acceso a memoria de datos
0 accesos a registro

ARCOS

Estructura de Computadores

212

Modelo de 2 direcciones
213

! Registros

" Los 2 operandos son registros.


" Requiere operaciones de carga/almacenamiento.
" ADD .R0, .R1
(R0 <- R0 + R1)

! Memoria-Memoria

" Los 2 operandos son


" ADD /DIR1, /DIR2

direcciones de memoria.
(MP[DIR1] <- MP[DIR1] +

MP[DIR2])
! Registro-Memoria
" Hbrido.
" ADD .R0, /DIR1 (R0 <- R0 + MP[DIR1])

ARCOS

Estructura de Computadores

213

2 direcciones: R-R
214

LOAD
LOAD
MUL
LOAD
ADD
STORE

ARCOS

.R0,
.R1,
.R0,
.R3,
.R0,
.R0,

/DB
/DC
.R1
/DA
.R3
/DX

6 instrucciones
4 acceso a memoria de datos
8 accesos a registro

Estructura de Computadores

214

2 direcciones: M-M
215

MOVE /DX, /DB


MUL /DX, /DC
ADD /DX, /DA

3 instrucciones
6 acceso a memoria de datos
0 accesos a registro

ARCOS

Estructura de Computadores

215

2 direcciones: R-M
216

LOAD
MUL
ADD
STORE

.R0,
.R0,
.R0,
.R0,

/DB
/DC
/DA
/DX

4 instrucciones
4 accesos a memoria de datos
4 accesos a registro

ARCOS

Estructura de Computadores

216

Modelo de 1 direccin
217

! 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

Estructura de Computadores

217

1 direccin
218

LOAD
MUL
ADD
STORE

/DB
/DC
/DA
/DX

4 instrucciones
4 accesos a memoria de datos
0 accesos a registro

ARCOS

Estructura de Computadores

218

Modelo de 0 direcciones
219

! 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

Estructura de Computadores

219

Operacin sobre la pila


220

PUSH 5

ARCOS

Estructura de Computadores

220

Operacin sobre la pila


221

PUSH 5
PUSH 7

7
5

ARCOS

Estructura de Computadores

221

Operacin sobre la pila


222

PUSH 5
PUSH 7
ADD

12

ARCOS

Estructura de Computadores

222

Operacin sobre la pila


223

PUSH 5
PUSH 7
ADD
POP /DX

ARCOS

Estructura de Computadores

223

0 direcciones
224

PUSH
PUSH
MUL
PUSH
ADD
POP

ARCOS

/DB
/DC
/DA
/DX

6 instrucciones
4 accesos a memoria de datos
10 accesos a memoria de pila

Estructura de Computadores

224

225

Recordatorio:
Informacin de instruccin
! Informacin:
" Operacin

a realizar.
" Operandos.
" Resultado.
" Ubicacin de siguiente instruccin.
! Parte de la informacin puede ser implcita.

ARCOS

Estructura de Computadores

225

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

Estructura de Computadores

226

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

Estructura de Computadores

227

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

Estructura de Computadores

228

Funciones en un lenguaje de alto nivel


229

int main() {
int z;
z=factorial(x);
print_int(z);
}

ARCOS

int factorial(int x) {
int i;
int r=1;
for (i=1;i<=x;i++) {
r*=i;
}
return r;
}

Estructura de Computadores

229

Llamadas a funciones en MIPS


230

Llamada a funcin en el MIPS (instruccin jal)

factorial:

jal factorial

jr $ra

factorial representa la direccin


de inicio de la subrutina (funcin)

ARCOS

Estructura de Computadores

230

Llamadas a funciones en MIPS


231

0x00401000 factorial:

0x00001000 jal 0x00401000


0x00001004

jr $ra

$ra = PC = 0x00001004
PC = 0x00401000

ARCOS

Estructura de Computadores

231

Llamadas a funciones en MIPS


232

0x00401000

0x00001000 jal 0x00401000


0x00001004

jr $ra

$ra = 0x00001004

ARCOS

Estructura de Computadores

232

Llamadas a funciones en MIPS


233

Retorno de subrutina (instruccin jr )


0x00401000

0x00001000 jal 0x00401000


0x00001004

jr $ra

PC = $ra = 0x00001004

$ra = 0x00001004

ARCOS

Estructura de Computadores

233

Llamadas a funciones en MIPS


234

0x00401000

0x00001000 jal 0x00401000


0x00001004

jr $ra

PC = $ra = 0x00001004

ARCOS

Estructura de Computadores

234

Instrucciones jal/jr
235

! Qu hace la instruccin jal?


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

ARCOS

Estructura de Computadores

235

Llamadas anidadas
0x00401000

jal 0x000080000

0x00001000 jal 0x00401000


0x00001004

0x00008000

jr $ra

jr $ra

$ra = PC = 0x00001004
PC = 0x00401000

ARCOS

Estructura de Computadores

236

Llamadas anidadas
0x00401000

0x00401020 jal 0x000080000


0x00401024

0x00001000 jal 0x00401000


0x00001004

0x00008000

jr $ra

jr $ra

$ra = PC = 0x00401024
PC = 0x00008000

ARCOS

Estructura de Computadores

237

Llamadas anidadas
0x00401000

0x00401020 jal 0x000080000


0x00401024

0x00001000 jal 0x00401000


0x00001004

0x00008000

jr $ra

jr $ra

PC = $ra = 0x00401024

ARCOS

Estructura de Computadores

238

Llamadas anidadas
0x00401000

0x00401020 jal 0x000080000


0x00401024

0x00001000 jal 0x00401000


0x00001004

0x00008000

jr $ra

jr $ra

?
PC = $ra = 0x00401024

ARCOS

Estructura de Computadores

239

Llamadas anidadas
0x00401000

0x00401020 jal 0x000080000


0x00401024

0x00001000 jal 0x00401000


0x00001004

0x00008000

jr $ra

jr $ra

?
PC = $ra = 0x00401024

Se ha perdido la direccin de retorno

ARCOS

Estructura de Computadores

240

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

Estructura de Computadores

241

Ejecucin de un programa
Memoria
Principal
Sistema
Operativo

Disco

instrucciones

Programa
en ejecucion

datos

Fichero
ejecutable

pila

ARCOS

Estructura de Computadores

242

Mapa de memoria de un proceso


memoria

Segmento de Texto

pc
01011001

! El programa de usuario se divide

en segmentos
"

! Variables locales
! Contexto de funciones

Segmento de Datos
"

Segmento de datos
! Datos estticos, variables

$sp
01011001

Segmento de pila

globales
"

Segmento de cdigo (texto)


! Cdigo, instrucciones mquina

Segmento de Pila

ARCOS

Estructura de Computadores

243

Pila
PUSH Reg

Apila el contenido del registro (dato)

dato
cima

$sp

$sp

cima

crece hacia direcciones bajas

ARCOS

Estructura de Computadores

244

Pila
POP Reg

dato

Desapila el contenido del registro (dato)


Copia dato en el registro Reg

$sp

dato

cima

cima

$sp

crece hacia direcciones bajas

ARCOS

Estructura de Computadores

245

Antes de empezar
246

! 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

Estructura de Computadores

246

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

Estructura de Computadores

247

Operacin PUSH en el MIPS

$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

Estructura de Computadores

248

Operacin PUSH en el MIPS

$sp

7
8

li $t2, 9
sw $t2 ($sp)
Se inserta el contenido del registro $t2 en la cima de la pila

ARCOS

Estructura de Computadores

249

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

Estructura de Computadores

250

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

Estructura de Computadores

251

Pila
uso de push y pop consecutivos
push $a0
push $t1
push $t2
push $s2
...
pop $s2
pop $t2
pop $t1
pop $a0

ARCOS

Estructura de Computadores

252

Pila
uso de push y pop consecutivos
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

Estructura de Computadores

253

Pila
uso de push y pop consecutivos
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

Estructura de Computadores

$sp

16

254

Ejemplo
(1) Se parte de un cdigo en lenguaje de alto nivel
255

int main() {
int z;
z=factorial(5);
print_int(z);
.
.
.
}

ARCOS

int factorial(int x) {
int i;
int r=1;
for (i=1;i<=x;i++) {
r*=i;
}
return r;
}

Estructura de Computadores

255

Ejemplo
(2) Pensar en el paso de parmetros
256

! 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

Estructura de Computadores

256

El parmetro se pasa en $a0


El resultado se devuelve en $v0

Ejemplo
(3) Se pasa a ensamblador cada funcin
257

int main() {
int z;
z=factorial(5);
print_int(z);
. . .
}

int factorial(int x) {
int i;
int r=1;
for (i=1;i<=x;i++) {
r*=i;
}
return r;
}

ARCOS

li $a0, 5
jal factorial
move $a0, $v0
li $v0, 1
syscall

# argumento
# llamada
# resultado
# llamada para
# imprimir un int

...
factorial: li
li
bucle: bgt
mul
addi
b
fin: move
jr

Estructura de Computadores

$s1, 1
#s1 para r
$s0, 1
#s0 para i
$s0, $a0, fin
$s1, $s1, $s0
$s0, $s0, 1
bucle
$v0, $s1 #resultado
$ra

257

Ejemplo
258

(4) Se analizan los registros que se modifican

int factorial(int x) {
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

Estructura de Computadores

258

Ejemplo
259

(5) Se guardan los registros en la pila

int factorial(int x) {
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

Estructura de Computadores

259

Ejemplo 2
260

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

Estructura de Computadores

260

Ejemplo 2. Invocacin
261

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

Estructura de Computadores

261

Ejemplo 2. Cuerpo de f1
262

int f1 (int a, int b)


{
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

Estructura de Computadores

262

263

Ejemplo 2. Se analizan los registros que se


modifican en f1
int f1 (int a, int b)
{
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

Estructura de Computadores

263

264

Ejemplo 2. Cuerpo de f1 guardando en la


pila los registros que se modifican
int f1 (int a, int b)
{
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

Estructura de Computadores

264

Ejemplo 2. Cuerpo de f2
265

int f1 (int a, int b)


{
int r;
r = a + a + f2(b);
return r;
}
int f2(int c)
{
int s;
s = c * c * c;
return s;

f2: mul $t0, $a0, $a0


mul $t0, $t0, $a0
jr $ra

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

Estructura de Computadores

265

Tipos de subrutinas
266

! Subrutina terminal.
" No invoca a ninguna otra subrutina.
! Subrutina no terminal.
" Invoca a alguna otra subrutina.

ARCOS

Estructura de Computadores

266

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

Estructura de Computadores

267

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

Estructura de Computadores

268

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

Estructura de Computadores

269

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

Estructura de Computadores

Argumento n5
Argumento n6

Direcciones altas

270

Acceso a parmetros y variables locales


usando el marco de pila
int f (int n1, n2, n3,
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;

Direcciones bajas

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

Estructura de Computadores

Argumento n5
Argumento n6

Direcciones altas

271

Acceso a parmetros y variables locales


usando el marco de pila
int f (int n1, n2, n3,
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;

}
!
!
!
!
!

Direcciones bajas

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)

ARCOS

Estructura de Computadores

Argumento n5
Argumento n6

Direcciones altas

272

Convenio de paso de parmetros


273

! 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 # Application Binary Interface.

ARCOS

Estructura de Computadores

273

Convencin en el uso de los registros en el


MIPS
Registro

Uso

Preservar el valor

$v0-$v1

Resultados

No

$a0..$a3

Argumentos

No

$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

Estructura de Computadores

274

Subrutinas paso a paso


275

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

Estructura de Computadores

275

276

Salvaguarda de registros
Subrutina llamante
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

Estructura de Computadores

276

277

Paso de parmetros
Subrutina llamante
! Los primeros parmetros se pasan mediante registros
" $a0, $a1, $a2, $a3
" $f12, $f14
(coma flotante)
" Resto de parmetros a travs de pila

ARCOS

Estructura de Computadores

277

Paso de 2 parmetros
Banco de registros

278

$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

Estructura de Computadores

278

Paso de 6 parmetros

Banco de registros

279

$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

Estructura de Computadores

279

280

Llamada a subrutina
Subrutina llamante
! Instruccin de salto and link
" jal etiqueta
" bal etiqueta
" bltzal $reg, etiqueta
" bgezal $reg, etiqueta
" jalr $reg
" jalr $reg, $reg

ARCOS

Estructura de Computadores

280

281

Reserva del marco de pila


Subrutina llamada
! 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

Estructura de Computadores

281

Ejecucin de la subrutina
282

! La subrutina deja los valores de retorno en:


" Normalmente los registros $v0 y $v1
" Para coma flotante $f0 y $f2.
" Si

ARCOS

hace falta ms espacio se deja informacin en la pila.

Estructura de Computadores

282

Al final
283

! 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
ARCOS

restauran los valores guardados en la pila


Estructura de Computadores

283

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) ;
printf(f(4)=%d,resultado);
}

ARCOS

factorial(a=2)
(a < 2) ?
1 * 2
factorial(a=1)
(a < 2) ?

Estructura de Computadores

284

Ejemplo: factorial
Direcciones bajas

Justo antes de la llamada

$sp

Direcciones altas

ARCOS @ UC3M

285

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

286

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

287

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

$a0
$ra
$sp

$fp (antiguo)

Direcciones altas

ARCOS @ UC3M

288

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
ARCOS

ser mltiplo de 8 (por convenio)


Estructura de Computadores

289

Convenio o32. Paso de 2 parmetros


290

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

Estructura de Computadores

290

Traduccin y ejecucin de programas


! Elementos que intervienen en la traduccin y ejecucin de un

programa:
" Compilador
" Ensamblador
" Enlazador
" Cargador

ARCOS

Estructura de Computadores

291

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

Estructura de Computadores

292

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

Estructura de Computadores

Memoria
293

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

Estructura de Computadores

294

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

Estructura de Computadores

295

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

Estructura de Computadores

296

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

Estructura de Computadores

297

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

Estructura de Computadores

298

Enlazador
.o file 1
text 1
data 1
info 1
Linker
.o file 2
text 2
data 2
info 2
ARCOS

Estructura de Computadores

a.out
Relocated text 1
Relocated text 2
Relocated data 1
Relocated data 2

299

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

Estructura de Computadores

300

Cargador
! Lee un fichero ejecutable (a.out) y lo carga en memoria
Memoria
Principal
Sistema
Operativo

Disco

instrucciones

Programa
en ejecucion

datos

Fichero
ejecutable

pila

ARCOS

Estructura de Computadores

301

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

Estructura de Computadores

302

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

Estructura de Computadores

303

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

Estructura de Computadores

304

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

Estructura de Computadores

305

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

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 "
Estructura de Computadores

306

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

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 "
Estructura de Computadores

307

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

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

Estructura de Computadores

308

Compilacin
Asignacin de direcciones
00
04
08
0c
10
14
18
1c
20
24
28

ARCOS

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

2c
30
34
38
3c
40
44
48
4c
50

Estructura de Computadores

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

309

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
0x0000002c
0x00000030
0x00000038

ARCOS

tipo Instr.
lui
ori
jal

Estructura de Computadores

Dependencia
l.str
r.str
printf

310

Compilacin
Resolver etiquetas relativas a PC
00
04
08
0c
10
14
18
1c
20
24
28

ARCOS

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

2c
30
34
38
3c
40
44
48
4c
50

Estructura de Computadores

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

311

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

00100111101111011111111111101000
10101111101111110000000000010100
10101111101001000000000000000100
10101111101001010000000000001000
10001101000000000000000000000000
10101101001000000000000000011100
00101000001010000000000000001011
00010000001000000000000000000011
00000001001010000100100000100000
00100001000010000000000000000001
00000100000000001111111111111100
00111100000001000000000000000000
00110100100001000000000000000000
00000001001001000000000000100001
00001100000000000000000000000000
00000000000000000001000001000001
10001111101111110000000000010100
10001111101001000000000000000100
10001111101001010000000000001000
00000011111000000000000000011000
00000000000000001110100000001000

Estructura de Computadores

312

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
Address
main:
0x00000000
loop:
0x0000001c
str:
0x10000430
printf: 0x000003b0

! Relocation Information
" Address
Instr. Type Dependency
0x0000002c
lui
l.str
0x00000030
ori
r.str
0x00000038
jal
printf
ARCOS

Estructura de Computadores

313

Enlazado
Resolver las direcciones
00
04
08
0c
10
14
18
1c
20
24
28

ARCOS

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

2c
30
34
38
3c
40
44
48
4c
50

Estructura de Computadores

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

314

Enlazado
! Generacin del fichero ejecutable

nico segmento de texto


" nico segmento de datos
" Cabecera con informacin sobre las secciones
"

ARCOS

Estructura de Computadores

315