Documentos de Académico
Documentos de Profesional
Documentos de Cultura
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
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
de
aprendizaje.
! Ensamblador similar al de
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
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
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;
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
"
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
v0, v1
2, 3
a0, , a3
4, , 7
t0, , t7
8, , 15
s0, , s7
16, , 23
t8, t9
24, 25
k0, k1
26, 27
gp
28
sp
29
Puntero a pila
fp
30
ra
31
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
ARCOS
Estructura de Computadores
17
Aritmticas
! Realiza operaciones aritmticas de entero (ALU) o aritmtica de
"
"
"
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
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
"
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
XOR
1010
0110
ARCOS
Estructura de Computadores
21
Ejemplo
li $t0, 5
li $t1, 8
ARCOS
Estructura de Computadores
22
Solucin
li $t0, 5
li $t1, 8
and
ARCOS
Estructura de Computadores
23
Desplazamientos
! De movimiento de bits
! Ejemplos:
"
01110110101
"
01110110101
"
11110110101
ARCOS
Estructura de Computadores
24
Ejemplo
li $t0, 5
li $t1, 6
ARCOS
Estructura de Computadores
25
Ejemplo
li $t0, 5
li $t1, 6
sra
$t0, $t1, 1
ARCOS
Estructura de Computadores
26
Ejemplo
li $t0, 5
li $t1, 6
ARCOS
Estructura de Computadores
27
Ejemplo
li $t0, 5
li $t1, 6
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
!
!
!
!
!
!
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
!
!
!
!
!
!
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:
}
j 0x10002E
b direccion
ARCOS
Llamadas a funciones:
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
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
ARCOS
Estructura de Computadores
40
Solucin
! Obtener los 16 bits superiores de un registro ($t0) y dejarlos en
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
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
}
# 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
ARCOS
Estructura de Computadores
44
Solucin
! Determinar si el contenido de un registro ($t2) es par. Si es par
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
ARCOS
Estructura de Computadores
46
Solucin
! Determinar si el contenido de un registro ($t2) es par. Si es par
$t2 9
li
$t1 1
and $t1
$t2
beq $t1 $0
$t1
then
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
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
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
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
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
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
Segmento de Pila
en segmentos
"
! Variables locales
! Contexto de funciones
$sp
01011001
$gp
Segmento de pila
"
Segmento de datos
! Datos estticos
"
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
.text
.globl
main
main:
#
printf("hola
mundo\n")
;
li
$v0
4
la
$a0
msg_hola
syscall
ARCOS
Estructura de Computadores
68
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
.text
.globl
main
main:
#
printf("hola
mundo\n")
;
li
$v0
4
#cdigo
de
llamada
la
$a0
msg_hola
syscall
ARCOS
Estructura de Computadores
70
Uso
.data
.text
.ascii
tira de caracteres
.byte
1, 2, 3
.half
.word
800000, 800001
.float
1.23, 2.13
.double 3.0e21
.space
10
.extern etiqueta n
.globl
etiqueta
.align
ARCOS
Estructura de Computadores
71
ARCOS
Estructura de Computadores
72
Llamadas al sistema
! El simulador incluye un pequeo sistema operativo.
"
Ofrece 17 servicios.
! Invocacin:
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
read
14
write
15
close
16
exit2
17
ARCOS
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:
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
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
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
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
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
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
Byte
(contenido)
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
Byte
(contenido)
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
Byte
(contenido)
Direccin: 6 (000110)
Contenido: 11111101 (-3 en complemento a 2)
11111101
$t1
00000000
00000000
31
24 23
16 15
0000000
11111101
87
Estructura de Computadores
90
Almacenamiento de palabras en la
memoria
Direcciones
de bytes
0
1
2
3
4
5
6
7
8
Byte
(contenido)
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
00000000
00000000
00000000
00011011
A
A+1
A+2
A+3
BigEndian
ARCOS
00011011
00000000
00000000
00000000
LittleEndian
Estructura de Computadores
93
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
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
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
A
A+1
A+2
A+3
00000000
00000000
00000000
00011011
A
A+1
A+2
A+3
BigEndian
00000000
00000000
00000000
00011011
LittleEndian
ARCOS
Estructura de Computadores
97
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
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
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
$t1
31
ARCOS
24 23
Estructura de Computadores
16 15
87
100
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
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
0x0F000000
0x0F000001
0x0F000002
0x0F000003
ARCOS
Byte
(contenido)
lw $t1, 0x0F000000
0xCB
0x12
0x08
0x02
Estructura de Computadores
103
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
0x0F000000
0x0F000001
0x0F000002
0x0F000003
Byte
(contenido)
0xCB
0x12
0x08
0x02
0x08
$t1
00000000
31
ARCOS
00000000
00000000
24 23
16 15
Estructura de Computadores
00001000
87
105
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
ARCOS
Estructura de Computadores
113
Alineacin de datos
direccin
0
4
8
12
31
23
15
16
20
24
ARCOS
Estructura de Computadores
114
Alineacin de datos
! En general:
"
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
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
Estructura de Computadores
118
move
reg2,reg1
! Se convierte en:
add
ARCOS
reg2,$zero,reg1
Estructura de Computadores
119
lw
sw
lb
sb
lbu
ARCOS
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
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
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
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
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
0x0F000000
0x0F000001
0x0F000002
0x0F000003
Byte
(contenido)
0xCB
0x12
0x08
0x02
lbu
$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
0x0F000000
0x0F000001
0x0F000002
0x0F000003
Byte
(contenido)
0xCB
0x12
0x08
0x02
lw
$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
ARCOS
Estructura de Computadores
127
ARCOS
Estructura de Computadores
128
resultado ;
int
op1 = 100 ;
int
op2 = -10 ;
resultado:
op1:
op2:
.word 0
.word 100
.word -10
...
...
.text
.globl main
main ()
lw $t2 op2
{
resultado = op1 + op2 ;
...
}
ARCOS
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);
}
Estructura de Computadores
130
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]
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
vec: .space 20
int vec[5] ;
...
main ()
{
vec[4] = 8;
#5 elem.*4 bytes
.text
.globl main
main:
li
$t0 16
la
$t1
vec
$t2
sw
$t2, ($t3)
...
ARCOS
Estructura de Computadores
133
.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[5]?
ARCOS
Estructura de Computadores
135
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
vec: .space 20
#5 elem.*4 bytes
main:
lw $t1 mat+0
lw $t2 mat+12
add $t3 $t1 $t2
sw
$t3 mat+4
...
ARCOS
Estructura de Computadores
137
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
char
char
char
Char
...
c1 ;
c2=h ;
*ac1 = hola ;
*c;
c1:
.space 1
c2:
.byte h
# 1 byte
la $t0, ac1
li $a0, 1
main ()
{
c = ac1; int l = 0;
while (*c != NULL) {
c++; l++;
}
printf(%d, l);
...
}
$t1, ($t0)
b buc
fin:
li $v0 1
syscall
...
ARCOS
Estructura de Computadores
139
Vectores y cadenas
! En general:
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;
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];
}
Estructura de Computadores
142
Ejercicio
! Escriba un programa que:
" Indique
ARCOS
Estructura de Computadores
143
$f1
$f3
$f31
$f0
$f2
B.R.
$f30
ALU
BUS
ARCOS
Estructura de Computadores
144
ARCOS
Estructura de Computadores
145
FPU
$f1
$f3
$f31
$f0
$f2
B.R.
$f30
ALU
BUS
ARCOS
Estructura de Computadores
146
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
float resultado ;
float op1 = 100 ;
.float
.float 100
.float -10
...
.text
.globl main
main: l.s
main ()
{
resultado = op1 + op2 ;
...
}
ARCOS
l.s
$f0 op1
$f1 op2
add.s
s.s
...
$f3 resultado
Estructura de Computadores
148
double resultado ;
double op1 = 100 ;
.double
.double 100
.double -10.27
...
.text
.globl main
main: l.d
main ()
{
resultado = op1 * op2 ;
...
}
ARCOS
l.d
$f0 op1
$f2 op2
mul.d
s.d
...
$f6 resultado
Estructura de Computadores
# ($f0,$f1)
# ($f2,$f3)
149
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
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
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
FPU
$f1
$f0
$f1
$f3
$f2
$f3
$f31
$f30
ALU
BUS
B.R.
$f31
$f0
$f2
$f30
B.R.
ALU
BUS
ARCOS
Estructura de Computadores
153
Operaciones de conversin
! cvt.s.w
$f2
$f1
!
!
!
!
!
ARCOS
Estructura de Computadores
154
Operaciones de carga
! li.s
$f4,
8.0
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:
! 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
Operacin a realizar
Operandos a utilizar
! Puede haber operando implcitos
ARCOS
Estructura de Computadores
161
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
"
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
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
"
"
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
li $t1,
0x00800010
ARCOS
Estructura de Computadores
166
Direccionamiento de registro
! El operando se encuentra en el registro.
! Ejemplo: move $a0 $a1
"
"
rs
rt
16 bits
Operando
B.Reg.
! Ventajas:
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
memoria
Operando
op
rs
rt
16 bits
! Problemas:
ARCOS
Estructura de Computadores
168
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
op
memoria
operando
direccin2
direccion1
! Problemas:
"
"
Es ms lento
ARCOS
Estructura de Computadores
170
Instruccin
Codop Registro R
Desplazamiento
Memoria
Banco de Registros
Direccin de memoria
ARCOS
Estructura de Computadores
Operando
171
.data
.align
la direccin de inicio
del vector
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
lw $a0 direccion($t1)
direccin
Memoria
Registros
ndice/desplazamiento
ARCOS
Estructura de Computadores
Operando
173
.data
.align
la direccin de inicio
del vector
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
Instruccin
Codop
desplazamiento
PC
ARCOS
Estructura de Computadores
175
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
beq
en la instruccin:
etiqueta se codifica
$9,$0,
16
CO
rs
rt
Dato inmediato
beq
add
addi
j
$t0,$1, fin
$t8,$t4,$t4
$t0,$0,-1
bucle
fin:
ARCOS
Estructura de Computadores
177
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
Estructura de Computadores
178
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
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
0x0000114
mul
0x0000118
0x000011C
0x0000120
move $t2
Estructura de Computadores
$t0
while
$t4
180
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
Contenido
0x0000100
li
0x0000104
li
$t1 4
0x0000108
li
$t2 1
0x000010C
li
$t4 0
0x0000110
bge
0x0000114
mul
0x0000118
0x000011C
0x0000120
move $t2
Estructura de Computadores
$t0
while
$t4
181
j direccion
op.
direccion
6 bits
26 bits
Instruccin
b desplazamiento
op.
6 bits
desplazamiento
5 bits
5 bits
16 bits
Estructura de Computadores
182
Direccionamiento implcito
!El operando no est codificado en la instruccin,
rs
16 bits
! Ventajas
" Es
ARCOS
Estructura de Computadores
183
Direccionamiento de pila
PUSH Reg
dato
cima
$sp
$sp
cima
ARCOS
Estructura de Computadores
184
Direccionamiento de pila
POP Reg
dato
$sp
dato
cima
cima
$sp
ARCOS
Estructura de Computadores
185
Direccionamiento de pila
186
PUSH $t0
POP $t0
lw $t0, ($sp)
add $sp, $sp, 4
ARCOS
Estructura de Computadores
186
! 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
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
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
Tipo R
aritmticas
ARCOS
op.
rs
rt
Estructura de Computadores
rd
shamt
func.
190
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
ARCOS
Estructura de Computadores
192
193
CO
rs
rt
rd
sa
func
26
Dato inmediato
CO
ARCOS
16
CO
rs
rt
Dato inmediato
Estructura de Computadores
193
add
$8,$9,$10
" Formato a utilizar:
"
CO
rs
rt
rd
sa
func
10
32
Estructura de Computadores
194
16
CO
rs
rt
Dato inmediato
22
21
-50
Estructura de Computadores
195
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
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
una instruccin?
! Cmo sabe la unidad de control el formato de cada
operacin?
ARCOS
Estructura de Computadores
198
Cdigo de operacin
199
! Tamao fijo:
! Campos de extensin
op.
rs
rt
rd
shamt
func.
! Tamao variable:
" Instrucciones
ARCOS
199
Ejemplo
ARCOS
Estructura de Computadores
200
Solucin
palabra -> 16 bits
60 instrucciones
8 registros (en BR)
ADDx R1(reg.), R2(reg.), R3(reg.)
16 bits
ARCOS
Estructura de Computadores
201
Solucin
16 bits
6 bits
Cdigo de
operacin
ARCOS
Estructura de Computadores
202
Solucin
16 bits
ARCOS
6 bits
Cdigo de
operacin
Operandos (3
registros)
Estructura de Computadores
203
Solucin
16 bits
6 bits
Cdigo de
operacin
ARCOS
Estructura de Computadores
204
Ejercicio
! Sea un computador de 16 bits, que direcciona la memoria por
ARCOS
Estructura de Computadores
205
Ejercicio
! Sea un computador de 32 bits, que direcciona la memoria por
Estructura de Computadores
206
CISC-RISC
! CISC: Complex Instruction Set Architecture (http://es.wikipedia.org/wiki/RISC)
"
"
"
Muchas instrucciones.
Complejidad variable.
Diseo irregular.
ARCOS
Estructura de Computadores
207
Modelos de ejecucin
208
Memoria.
!3 direcciones # Registros, Registro-Memoria, MemoriaMemoria.
ARCOS
Estructura de Computadores
208
Modelo de 3 direcciones
209
! Registros
! Memoria-Memoria
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
2 instrucciones
6 acceso a memoria de datos
0 accesos a registro
ARCOS
Estructura de Computadores
212
Modelo de 2 direcciones
213
! Registros
! Memoria-Memoria
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
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
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
ARCOS
Estructura de Computadores
219
PUSH 5
ARCOS
Estructura de Computadores
220
PUSH 5
PUSH 7
7
5
ARCOS
Estructura de Computadores
221
PUSH 5
PUSH 7
ADD
12
ARCOS
Estructura de Computadores
222
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
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
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
factorial:
jal factorial
jr $ra
ARCOS
Estructura de Computadores
230
0x00401000 factorial:
jr $ra
$ra = PC = 0x00001004
PC = 0x00401000
ARCOS
Estructura de Computadores
231
0x00401000
jr $ra
$ra = 0x00001004
ARCOS
Estructura de Computadores
232
jr $ra
PC = $ra = 0x00001004
$ra = 0x00001004
ARCOS
Estructura de Computadores
233
0x00401000
jr $ra
PC = $ra = 0x00001004
ARCOS
Estructura de Computadores
234
Instrucciones jal/jr
235
ARCOS
Estructura de Computadores
235
Llamadas anidadas
0x00401000
jal 0x000080000
0x00008000
jr $ra
jr $ra
$ra = PC = 0x00001004
PC = 0x00401000
ARCOS
Estructura de Computadores
236
Llamadas anidadas
0x00401000
0x00008000
jr $ra
jr $ra
$ra = PC = 0x00401024
PC = 0x00008000
ARCOS
Estructura de Computadores
237
Llamadas anidadas
0x00401000
0x00008000
jr $ra
jr $ra
PC = $ra = 0x00401024
ARCOS
Estructura de Computadores
238
Llamadas anidadas
0x00401000
0x00008000
jr $ra
jr $ra
?
PC = $ra = 0x00401024
ARCOS
Estructura de Computadores
239
Llamadas anidadas
0x00401000
0x00008000
jr $ra
jr $ra
?
PC = $ra = 0x00401024
ARCOS
Estructura de Computadores
240
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
Segmento de Texto
pc
01011001
en segmentos
"
! Variables locales
! Contexto de funciones
Segmento
de
Datos
"
Segmento de datos
! Datos estticos, variables
$sp
01011001
Segmento de pila
globales
"
Segmento de Pila
ARCOS
Estructura de Computadores
243
Pila
PUSH Reg
dato
cima
$sp
$sp
cima
ARCOS
Estructura de Computadores
244
Pila
POP Reg
dato
$sp
dato
cima
cima
$sp
ARCOS
Estructura de Computadores
245
Antes de empezar
246
POP $t0
lw
$t0, ($sp)
addu $sp, $sp, 4
ARCOS
Estructura de Computadores
246
$sp
ARCOS
Estructura de Computadores
247
$sp
7
8
ARCOS
Estructura de Computadores
248
$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
$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
9
7
$sp
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)
$t1
($sp)
$t2
($sp)
...
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
$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
ARCOS
Estructura de Computadores
256
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
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
ARCOS
Estructura de Computadores
258
Ejemplo
259
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
Estructura de Computadores
259
Ejemplo 2
260
int main()
{
int z;
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
ARCOS
Estructura de Computadores
261
Ejemplo 2. Cuerpo de f1
262
f1: add
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
f1: add
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
263
264
f1: sub
sw
sw
sw
$sp, $sp, 12
$s0, 8($sp)
$a0, 4($sp)
$ra, ($sp)
add
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
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
Estructura de Computadores
267
Marco de pila
! El marco de pila almacena:
" Los
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
Crecimiento
return (v[1]);
de la pila
$sp
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
$sp
v[0]
v[1]
Direcciones bajas
v[2]
$fp
return (v[1]);
v[3]
Crecimiento
de la pila
$fp antiguo
Estructura de Computadores
Argumento n5
Argumento n6
Direcciones altas
271
$sp
v[0]
v[1]
}
!
!
!
!
!
Direcciones bajas
v[2]
$fp
return (v[1]);
v[3]
Crecimiento
de la pila
$fp antiguo
ARCOS
Estructura de Computadores
Argumento n5
Argumento n6
Direcciones altas
272
ARCOS
Estructura de Computadores
273
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
Si
$ra
Direccin de retorno
Si
ARCOS
Estructura de Computadores
274
Subrutina llamada
ARCOS
Estructura de Computadores
275
276
Salvaguarda de registros
Subrutina llamante
Registros $t
de invocar una
subrutina se deben
guardar los registros $t
de los que se quiera
preservar su valor.
pila
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
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
pila.
ARCOS
Estructura de Computadores
281
Ejecucin de la subrutina
282
ARCOS
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
! jr $ra
! Subrutina llamante:
" Se
ARCOS
283
Ejemplo: factorial
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
$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
pila.
" Debe
ARCOS
289
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
programa:
" Compilador
" Ensamblador
" Enlazador
" Cargador
ARCOS
Estructura de Computadores
291
ARCOS
Estructura de Computadores
292
Ensamblador
Objeto: mdulo en lenguaje mquina
Enlazador
Ejecutable: programa en lenguaje mquina
Cargador
ARCOS
Estructura de Computadores
Memoria
293
Compilador
!
!
!
!
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
Estructura de Computadores
296
(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
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
!
!
!
!
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
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
309
Compilacin
Creacin de la tabla de smbolos y de reubicacin
! Tabla de smbolos
Etiqueta
main:
bucle:
str:
! 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
311
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
314
Enlazado
! Generacin del fichero ejecutable
ARCOS
Estructura de Computadores
315