3. Instrucciones: lenguaje de la máquina

Transcripción

Iniciación a la arquitectura de la máquina MIPS
Repertorio de instrucciones y modos de direccionamiento
Subrutinas
Programando y ejecutando
3. Instrucciones: lenguaje de la máquina
Fundamentos de Computadores
Ingenierı́a de Telecomunicación
Raúl Durán Dı́az
Departamento de Automática
Escuela Politécnica Superior
Curso académico 2009–2010
Revisión: 1.8
1 / 50
Subrutinas
Contenidos
1
2
3
Subrutinas
4
Revisión: 1.8
2 / 50
Subrutinas
Introducción
Para manejar la máquina, hablamos su lenguaje.
Las “palabras” son instrucciones.
El vocabulario es el ((repertorio de instrucciones)).
Las instrucciones deben ser
lo más sencillas que sea posible, pero. . .
deben permitir cualquier operación, es decir, el repertorio debe
ser completo.
En la práctica, los repertorios de instrucciones de todas las
máquinas se parecen.
Revisión: 1.8
3 / 50
Subrutinas
Concepto de programa almacenado
La idea clave de von Neumann es representar las instrucciones
mediante códigos numéricos, susceptibles de ser almacenados
en memoria como cualquier otro tipo de dato.
Nosotros no manejamos directamente los códigos numéricos,
sino un mnemónico asociado a cada instrucción.
Al conjunto de todos los mnemónicos lo llamamos lenguaje
máquina.
Existe un formato de instrucción, que nos permitirá traducir
los códigos numéricos a lenguaje máquina y viceversa.
Revisión: 1.8
4 / 50
Subrutinas
Arquitectura MIPS
Tipo RISC (reduced intruction set computer):
esto significa mı́nimo número de instrucciones, todas muy
simples.
Dotado con 32 registros de propósito general y el contador de
programa, todos ellos de 32 bits.
Observación
Limitar el número de registros es bueno para poder conseguir una
elevada velocidad de operación en el hardware.
Revisión: 1.8
5 / 50
Subrutinas
Arquitectura MIPS
Esta arquitectura es del tipo carga-almacenamiento:
⇒ Sólo permite operaciones con valores en los registros.
⇒ Interactúa con la memoria por medio de únicamente un par de
instrucciones de carga (lectura de memoria a registro) y
almacenamiento (escritura de registro a memoria).
La memoria es como un gran vector, direccionable byte a byte.
Lo normal es acceder en direcciones múltiplos del tamaño
accedido.
Revisión: 1.8
6 / 50
Subrutinas
Excursus: acceso a memoria big endian
El byte 0 está en la posición más alta.
Usado en IBM 370, Sun SPARC, HP-PARISC, etc.
31
24
23
8
4
0
16
15
8
9
5
1
7
0
10
6
2
11
7
3
Direcciones
altas
⇑
Direcciones
bajas
Revisión: 1.8
7 / 50
Subrutinas
Excursus: acceso a memoria little endian
El byte 0 está en la posición más baja.
Usado en x86, Digital VAX, Digital Alpha, Digital Unix, etc.
31
24
11
7
3
23
16
10
6
2
15
8
9
5
1
7
0
8
4
0
Direcciones
altas
⇑
Direcciones
bajas
Revisión: 1.8
8 / 50
Subrutinas
Arquitectura MIPS: registros
Los registros se nombran $0, $1,. . . ,$31.
Son casi de propósito general, excepto:
el registro 1, llamado $at, reservado al ensamblador;
los registros 26–27, llamados $k0 y $k1, reservados al kernel;
los registros 28–31, reservados a ciertos punteros.
El resto tiene un uso convenido, pero arbitrario.
Al final, todos tienen un sinónimo. Veamos el siguiente cuadro.
Revisión: 1.8
9 / 50
Subrutinas
Nombres de los registros en MIPS
Nombre
$zero
$v0–$v1
$a0–$a3
$t0–$t7
$s0–$s7
$t8–$t9
$gp
$sp
$fp
$ra
Número
0
2–3
4–7
8–15
16–23
24–25
28
29
30
31
Uso
constante 0
resultados, evaluación de expresiones
argumentos
temporales
preservados en llamadas
temporales
puntero global
puntero de pila
puntero de cuadro
dirección de retorno
Revisión: 1.8
10 / 50
Subrutinas
Instrucciones básicas
Instrucciones de control de flujo
Representación de las instrucciones
Instrucciones para operaciones aritméticas
¿Cómo ensamblamos un código como éste?
Ejemplo en C
int i, j, f, g, h;
f = (g + h) - (i + j);
Podemos asignar las variables a registros y usar la
instrucciones de suma y resta enteras:
Lo mismo, ensamblado
add $t0, $s3, $s4
add $t1, $s0, $s1
sub $s2, $t0, $t1
en donde las instrucciones de suma y resta significan:
Regs[x] = Regs[y ] ± Regs[z]
Revisión: 1.8
Subrutinas
11 / 50
Instrucciones de acceso a memoria
Ejemplo en C
int g, h, A[100];
g = h + A[8];
lw $t0, 32($s2)
add $s0, $t0, $s1
Revisión: 1.8
12 / 50
Subrutinas
Ejemplo en C
int h, A[100];
A[4] = h + A[8];
A[4] += 5;
lw
$t0, 32($s1)
add $t0, $t0, $s0
sw
$t0, 16($s1) ; se puede eliminar
addi $t0, $t0, 5
sw
$t0, 16($s1)
Revisión: 1.8
Subrutinas
13 / 50
Ejemplo en C
int i, g, h, A[100];
g = h + A[i];
add $t0, $s0, $s0
add $t0, $t0, $t0
add $t0, $t0, $s3
lw $t1, 0($t0)
add $s1, $s2, $t1
Revisión: 1.8
14 / 50
Subrutinas
Observaciones respecto a lo visto
En un programa hay más variables que registros. . .
⇒ pónganse en registros las variables más usadas.
El direccionamiento tipo base + desplazamiento es útil para
direccionar vectores y campos de estructuras.
Los operandos de todas las instrucciones están siempre en
registros.
Revisión: 1.8
Subrutinas
15 / 50
Instrucciones de desplazamiento lógico y aritmético
Operación
Shift left
Shift right
AND bit a bit
OR bit a bit
en C
<<
>>
&
|
en ensamblador
sll $s1,$s2,d
srl $s1,$s2,d
and $s1,$s2,$s3
or $s1,$s2,$s3
Revisión: 1.8
16 / 50
Subrutinas
Resumen de instrucciones básicas
Instrucción
add $r3, $r2, $r1
sub $r3, $r2, $r1
addi $r2, $r1, n
lw $r2, n($r1)
sw $r1, n($r2)
sll $r1, $r2, d
srl $r1, $r2, d
and $r1, $r2, $r3
or $r1, $r2, $r3
Función
$r3 ← $r1 + $r2
$r3 ← $r1 - $r2
$r2 ← $r1 + n
$r2 ← M[$r1 + n]
M[$r2 + n] ← $r1
$r1 ← $r2 << d
$r1 ← $r2 >> d
$r1 ← $r2 & $r3
$r1 ← $r2 | $r3
Atención: El número n puede ser positivo o negativo.
Revisión: 1.8
Subrutinas
17 / 50
Tomando decisiones
La gran potencia de la programación es la toma dinámica de
decisiones: para ello introducimos los saltos condicionales.
La idea es que la ejecución del código “salte” a una zona u
otra en función del resultado de la comparación de dos
registros.
Las instrucciones básicas son
beq $r1, $r2, Etiq1 ; Ir a Etiq1 si $r1 = $r2
bne $r1, $r2, Etiq2 ; Ir a Etiq2 si $r1 =
6 $r2
También existe el salto incondicional
j Etiqueta ; salta a Etiqueta incondicionalmente.
Revisión: 1.8
18 / 50
Subrutinas
Ensamblamos una sentencia if-then-else
Ejemplo en C
int i, j, f, g, h;
if (i == j) f = g + h; else f = g - h;
bne $s0, $s1, Else
add $s2, $s3, $s4
j Fin
Else:
sub $s2, $s3, $s4
Fin:
Revisión: 1.8
Subrutinas
19 / 50
Ensamblamos un bucle
Ejemplo en C
int i, j, k, A[100];
while (A[i] == k) i = i + j;
Bucle: add $t0, $s0, $s0
add $t0, $t0, $t0
add $t0, $t0, $s3
lw $t1, 0($t0)
bne $t1, $s2, Fin
add $s0, $s0, $s1
j
Bucle
Fin:
Revisión: 1.8
20 / 50
Subrutinas
Más instrucciones de control de flujo
Para comparar un “menor que” tenemos:
slt $r3, $r1, $r2
$r3 recibe un 1 si $r1 < $r2 y un 0 en caso contrario.
Tenemos también
slti $r2, $r1, n
$r2 recibe un 1 si $r1 < n y un 0 en caso contrario.
Revisión: 1.8
Subrutinas
21 / 50
Y otra instrucción de salto
Tenemos una instrucción que nos permite saltar a una
dirección variable, que esté contenida en un registro:
jr $r1
La instrucción siguiente a ésta será la que resida en la
dirección que está contenida en el registro $r1.
Revisión: 1.8
22 / 50
Subrutinas
Resumen de instrucciones de control de flujo
Instrucción
beq $r1, $r2, etiq
bne $r1, $r2, etiq
slt $r1, $r2, $r3
slti $r1, $r2, n
j etiq
jr $r1
jal etiq
Función
($r1 == $r2)? $PC ← $PC+etiq : ∅
($r1 != $r2)? $PC ← $PC+etiq : ∅
($r2 < $r3)? $r1 ← 1 : $r1 ← 0
($r2 < n)? $r1 ← 1 : $r1 ← 0
$PC ← etiq
$PC ← $r1
$ra ← $PC+4; $PC ← etiq
Atención: Como antes, el número n puede ser positivo o negativo.
Revisión: 1.8
Subrutinas
23 / 50
Las instrucciones se representan binariamente, usando bytes.
En MIPS, todas las instrucciones tienen 4 bytes.
Los 32 bits se reparten en campos, algunos de los cuales son
fijos.
De esta forma, la interpretación de la instrucción es más
sencilla y uniforme.
Revisión: 1.8
24 / 50
Subrutinas
Para las instrucciones tipo R (varios registros involucrados):
op code
6 bits
RS
5 bits
RT
5 bits
RD
5 bits
SHAMT
5 bits
FUNC
6 bits
Significado de los campos
op code: código de operación básica
RS:
registro fuente 1
RT:
registro fuente 2
RD:
registro destino
SHAMT: shift amount
FUNC:
código de función concreta
Revisión: 1.8
Subrutinas
25 / 50
Para las instrucciones tipo I (valores inmediatos involucrados):
op code
6 bits
RS
5 bits
RT
5 bits
dirección
16 bits
op code: código de operación básica
RS:
registro fuente
RT:
registro destino
dirección: número de 16 bits (±32767)
Revisión: 1.8
26 / 50
Subrutinas
Para las instrucciones tipo J (transferencia de control):
op code
6 bits
dirección de salto
26 bits
op code:
código de operación básica
dirección de salto: dirección de la siguiente instrucción a ejecutar
Revisión: 1.8
27 / 50
Subrutinas
Representación de las instrucciones básicas
add
sub
addi
lw
sw
j
Tipo
R
R
I
I
I
J
Opcode
0
0
8
35
43
2
RS
reg
reg
reg
reg
reg
n/a
RT
reg
reg
reg
reg
reg
n/a
RD
reg
reg
n/a
n/a
n/a
n/a
SHAMT
0
0
n/a
n/a
n/a
n/a
FUNC
32
34
n/a
n/a
n/a
n/a
dir
n/a
n/a
inm
dir
dir
n/a
Traducir el lenguaje ensamblador a código máquina es el papel del
as (o programa ensamblador).
Revisión: 1.8
28 / 50
Subrutinas
Representación de las instrucciones de control
beq
bne
slt
jr
jal
Tipo
I
I
R
R
J
Opcode
4
5
0
0
3
RS
reg
reg
reg
reg
n/a
RT
reg
reg
reg
0
n/a
RD
n/a
n/a
reg
0
n/a
SHAMT
n/a
n/a
0
0
n/a
FUNC
n/a
n/a
42
8
n/a
dir
dir
dir
n/a
n/a
n/a
Revisión: 1.8
29 / 50
Subrutinas
Representación de las instrucciones lógicas
sll
srl
sra
and
or
Tipo
R
R
R
R
R
Opcode
0
0
0
0
0
RS
0
0
0
reg
reg
RT
reg
reg
reg
reg
reg
RD
reg
reg
reg
reg
reg
SHAMT
d
d
d
0
0
FUNC
0
2
3
36
37
dir
n/a
n/a
n/a
n/a
n/a
Revisión: 1.8
30 / 50
Subrutinas
Resumen de modos de direccionamiento
1
Registro: los operandos están en registros.
2
Inmediato: El operando es una constante contenida en la
propia instrucción.
3
Indexado, (base más desplazamiento): Un operando está en
memoria. La dirección es la suma del contenido de un registro
y de un valor inmediato.
4
Relativo a $PC: La dirección del operando es la suma del
registro $PC más una constante contenida en la instrucción.
5
Directo: La dirección de salto está (casi) contenida en la
instrucción.
Revisión: 1.8
31 / 50
Subrutinas
Subrutinas o procedimientos
Las subrutinas o procedimientos estructuran el código: se les
pasan valores (argumentos) y devuelven resultados.
Permiten el reuso del software.
Aı́slan unas piezas del código de otras, facilitando el
mantenimiento.
Es un sirviente al que se le dan unos datos (los “argumentos”)
y nos devuelve un resultado (“valor de retorno”).
Revisión: 1.8
32 / 50
Subrutinas
Subrutinas o procedimientos
Para ejecutar correctamente una subrutina, los pasos son:
Actor
Principal:
Principal:
Subrutina:
Subrutina:
Subrutina:
Subrutina:
Acción
coloca argumentos en un lugar accesible a la subrutina.
transfiere el control.
reserva espacio para su ejecución.
ejecuta su función.
coloca el resultado en un lugar accesible al principal.
devuelve el control al punto de partida.
Revisión: 1.8
33 / 50
Subrutinas
Más registros. . .
Para el intercambio de datos se utilizan ciertos registros
convenidos:
Nombre Uso
$a0–$a3 para pasar argumentos
$v0–$v1 para devolver los resultados
$ra
para la dirección de retorno
Revisión: 1.8
34 / 50
Subrutinas
. . . y una nueva instrucción
Una instrucción especialmente pensada nos permite “saltar”
al comienzo de la subrutina al tiempo que se guarda la
dirección de retorno en el registro $ra.
jal Procedimiento
El nombre jal significa jump-and-link. El sentido es que
conservamos en $ra la dirección a la que se debe retornar.
La dirección de la instrucción que se ha de ejecutar se guarda
en el registro de instrucción, o $PC. Por tanto la dirección que
se ha de guardar en $ra es $PC+4.
Revisión: 1.8
35 / 50
Subrutinas
Resumen de llamada a la subrutina
Los pasos para la llamada serán:
1
2
3
El principal coloca en $a0–$a3 los argumentos necesarios para
la ejecución de la subrutina.
Ésta realiza los cálculos y devuelve el/los resultado(s) en
$v0–$v1.
Devuelve el control con un simple jr $ra.
¿Y si no bastan con los registros de que se dispone? Ahora lo
vemos.
Revisión: 1.8
36 / 50
Subrutinas
Un nuevo registro y la pila
Es muy probable que una subrutina necesite más registros que
los $a0–$a3 y $v0–$v1.
Antes de poder usar otros registros, éstos se deben archivar.
Para ello, se dedica un trozo de memoria, suficientemente
grande, como repositorio temporal.
Este repositorio se llama pila (en inglés, stack).
Se usa un registro, $sp, para saber en donde comienza el
espacio libre. Cada vez que se almacena o se extrae algo, se
ajusta.
Por razones históricas, crece hacia las direcciones bajas de
memoria.
Las operaciones de almacenamiento y extracción se llaman
push y pop, respectivamente.
Revisión: 1.8
37 / 50
Subrutinas
Ensamblando una subrutina
Subrutina en C
int sub1(int g, int h, int i, int j)
{
int f;
f = (g + h) - (i + j);
return f;
}
Revisión: 1.8
38 / 50
Subrutinas
Subrutina
sub1:
subi
sw
sw
sw
add
add
sub
en ensamblador
$sp,
$t0,
$t1,
$s0,
$sp, 12
8($sp)
4($sp)
0($sp)
$t0, $a0, $a1
$t1, $a2, $a3
$s0, $t0, $t1
...
Revisión: 1.8
39 / 50
Subrutinas
Subrutina en ensamblador
...
add
$v0, $s0, $zero
lw
lw
lw
addi
$s0,
$t1,
$t0,
$sp,
jr
$ra
0($sp)
4($sp)
8($sp)
$sp, 12
Revisión: 1.8
40 / 50
Subrutinas
Convenios sobre el uso de registros
Convenimos en que los registros $t0–$t9 son temporales y no
hace falta guardarlos antes de usarlos.
En cambio, los registros $s0–$s7 sı́ deben ser “salvados”
antes de ser usados.
En la subrutina anterior nos ahorramos dos pushes.
Revisión: 1.8
41 / 50
Subrutinas
¿Y si la subrutina llama a otra?
Si una subrutina llama a otra, probablemente necesita usar
también los registros $a0–$a3, y guardar en $ra la dirección
de retorno. Hay un conflicto en el uso de los registros.
La solución es guardarlos en la pila antes de modificarlos,
restaurando su valor al final.
Revisión: 1.8
42 / 50
Subrutinas
Subrutina recursiva
Subrutina en C
int fact(int n)
{
if (n == 1) return 1;
else
return n*fact(n - 1);
}
Revisión: 1.8
43 / 50
Subrutinas
Subrutina recursiva
Subrutina ensamblada (I)
fact:
subi $sp, $sp, 8
sw
$ra, 4($sp)
sw
$a0, 0($sp)
subi $t0, $a0, 1
bne
$t0, $zero, F1
addi
addi
jr
$v0, $zero, 1
$sp, $sp, 8
$ra
...
Revisión: 1.8
44 / 50
Subrutinas
Subrutina recursiva
Subrutina ensamblada (II)
...
F1: subi
jal
$a0, $a0, 1
fact
lw
lw
addi
$a0, 0($sp)
$ra, 4($sp)
$sp, $sp, 8
mul
jr
$v0, $v0, $a0
$ra
Revisión: 1.8
45 / 50
Subrutinas
Estado de los registros en llamadas a subrutinas
Por convenio, el comportamiento es ası́:
Preservados
$s0–$s7
$sp
$ra
Memoria encima de $sp
No preservados
$t0–$t9
$a0–$a3
$v0–$v1
Memoria debajo de $sp
Revisión: 1.8
46 / 50
Subrutinas
Ciclo de programación
Programa C
Código ensamblado
Compilador
Código máquina
Ejecutable
Linker
Ensamblador
Programa cargado
Cargador
Figura: Procesos y resultados del ciclo de programación
Revisión: 1.8
47 / 50
Subrutinas
Estructura del programa cargado
$sp
$gp
7fff fffc
1000 8000
Pila
Datos dinámicos
Datos estáticos
1000 0000
Código (texto)
pc
0040 0000
Reservado
0
Figura: Zonas de memoria, una vez cargado el programa
Revisión: 1.8
48 / 50
Subrutinas
Estructura de un fichero objeto
Cabecera fichero objeto
Segmento de código
Segmento de datos
Información de realojo
Tabla de símbolos
Información de depuración
Figura: Partes de un fichero objeto, con extensión .o
Revisión: 1.8
49 / 50
Subrutinas
Lenguajes de programación de alto nivel
COBOL, PL/I
FORTRAN
PASCAL, C
ADA
Java, C++, SmallTalk
...
Revisión: 1.8
50 / 50

3. Instrucciones: lenguaje de la máquina

Transcripción

Documentos relacionados

El Teorema de [height=.3 in]Futurama.jpg

Llengua Catalana - Estudia a la UIB