3. Instrucciones: lenguaje de la m´aquinahpc.aut.uah.es/~rduran/FFCC/pdf/Cap3Hand.pdf · Curso...

Revision: 1.8

Iniciacion a la arquitectura de la maquina MIPSRepertorio de instrucciones y modos de direccionamiento

SubrutinasProgramando y ejecutando

3. Instrucciones: lenguaje de la maquinaFundamentos de Computadores

Ingenierıa de Telecomunicacion

Raul Duran Dıaz

Departamento de AutomaticaEscuela Politecnica Superior

Curso academico 2009–2010

Raul Duran Dıaz 3. Instrucciones: lenguaje de la maquina 1 / 50

Revision: 1.8



Contenidos

1 Iniciacion a la arquitectura de la maquina MIPS

2 Repertorio de instrucciones y modos de direccionamiento

3 Subrutinas

4 Programando y ejecutando


Revision: 1.8



Introduccion

Para manejar la maquina, hablamos su lenguaje.

Las “palabras” son instrucciones.El vocabulario es el ((repertorio de instrucciones)).

Las instrucciones deben ser

lo mas sencillas que sea posible, pero. . .deben permitir cualquier operacion, es decir, el repertorio debeser completo.

En la practica, los repertorios de instrucciones de todas lasmaquinas se parecen.


Revision: 1.8



Concepto de programa almacenado

La idea clave de von Neumann es representar las instruccionesmediante codigos numericos, susceptibles de ser almacenadosen memoria como cualquier otro tipo de dato.

Nosotros no manejamos directamente los codigos numericos,sino un mnemonico asociado a cada instruccion.

Al conjunto de todos los mnemonicos lo llamamos lenguajemaquina.

Existe un formato de instruccion, que nos permitira traducirlos codigos numericos a lenguaje maquina y viceversa.


Revision: 1.8



Arquitectura MIPS

Tipo RISC (reduced intruction set computer):

esto significa mınimo numero de instrucciones, todas muysimples.

Dotado con 32 registros de proposito general y el contador deprograma, todos ellos de 32 bits.

Observacion

Limitar el numero de registros es bueno para poder conseguir unaelevada velocidad de operacion en el hardware.


Revision: 1.8



Arquitectura MIPS

Esta arquitectura es del tipo carga-almacenamiento:

⇒ Solo permite operaciones con valores en los registros.⇒ Interactua con la memoria por medio de unicamente un par de

instrucciones de carga (lectura de memoria a registro) yalmacenamiento (escritura de registro a memoria).

La memoria es como un gran vector, direccionable byte a byte.

Lo normal es acceder en direcciones multiplos del tamanoaccedido.


Revision: 1.8



Excursus: acceso a memoria big endian

El byte 0 esta en la posicion mas alta.

Usado en IBM 370, Sun SPARC, HP-PARISC, etc.

31 24 23 16 15 8 7 0

8 9 10 11

4 5 6 7

0 1 2 3

Direccionesaltas⇑

Direccionesbajas


Revision: 1.8



Excursus: acceso a memoria little endian

El byte 0 esta en la posicion mas baja.

Usado en x86, Digital VAX, Digital Alpha, Digital Unix, etc.

31 24 23 16 15 8 7 0

11 10 9 8

7 6 5 4

3 2 1 0

Direccionesaltas⇑

Direccionesbajas


Revision: 1.8



Arquitectura MIPS: registros

Los registros se nombran $0, $1,. . . ,$31.

Son casi de proposito 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 sinonimo. Veamos el siguiente cuadro.


Revision: 1.8



Nombres de los registros en MIPS

Nombre Numero Uso$zero 0 constante 0

$v0–$v1 2–3 resultados, evaluacion de expresiones$a0–$a3 4–7 argumentos$t0–$t7 8–15 temporales$s0–$s7 16–23 preservados en llamadas$t8–$t9 24–25 temporales

$gp 28 puntero global$sp 29 puntero de pila$fp 30 puntero de cuadro$ra 31 direccion de retorno


Revision: 1.8



Instrucciones basicasInstrucciones de control de flujoRepresentacion de las instrucciones

Instrucciones para operaciones aritmeticas

¿Como ensamblamos un codigo como este?

Ejemplo en C

int i, j, f, g, h;f = (g + h) - (i + j);

Podemos asignar las variables a registros y usar lainstrucciones de suma y resta enteras:

Lo mismo, ensamblado

add $t0, $s3, $s4add $t1, $s0, $s1sub $s2, $t0, $t1

en donde las instrucciones de suma y resta significan:

Regs[x ] = Regs[y ]± Regs[z ]


Revision: 1.8




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


Revision: 1.8





Ejemplo en C

int h, A[100];

A[4] = h + A[8];A[4] += 5;


lw $t0, 32($s1)add $t0, $t0, $s0sw $t0, 16($s1) ; se puede eliminaraddi $t0, $t0, 5sw $t0, 16($s1)


Revision: 1.8





Ejemplo en C

int i, g, h, A[100];

g = h + A[i];


add $t0, $s0, $s0add $t0, $t0, $t0add $t0, $t0, $s3lw $t1, 0($t0)add $s1, $s2, $t1


Revision: 1.8




Observaciones respecto a lo visto

En un programa hay mas variables que registros. . .

⇒ ponganse en registros las variables mas usadas.

El direccionamiento tipo base + desplazamiento es util paradireccionar vectores y campos de estructuras.

Los operandos de todas las instrucciones estan siempre enregistros.


Revision: 1.8




Instrucciones de desplazamiento logico y aritmetico

Operacion en C en ensamblador

Shift left << sll $s1,$s2,dShift right >> srl $s1,$s2,d

AND bit a bit & and $s1,$s2,$s3OR bit a bit | or $s1,$s2,$s3


Revision: 1.8




Resumen de instrucciones basicas

Instruccion Funcion

add $r3, $r2, $r1 $r3 ← $r1 + $r2sub $r3, $r2, $r1 $r3 ← $r1 - $r2addi $r2, $r1, n $r2 ← $r1 + nlw $r2, n($r1) $r2 ← M[$r1 + n]sw $r1, n($r2) M[$r2 + n] ← $r1sll $r1, $r2, d $r1 ← $r2 << dsrl $r1, $r2, d $r1 ← $r2 >> dand $r1, $r2, $r3 $r1 ← $r2 & $r3or $r1, $r2, $r3 $r1 ← $r2 | $r3

Atencion: El numero n puede ser positivo o negativo.


Revision: 1.8




Tomando decisiones

La gran potencia de la programacion es la toma dinamica dedecisiones: para ello introducimos los saltos condicionales.

La idea es que la ejecucion del codigo “salte” a una zona uotra en funcion del resultado de la comparacion de dosregistros.

Las instrucciones basicas sonbeq $r1, $r2, Etiq1 ; Ir a Etiq1 si $r1 = $r2bne $r1, $r2, Etiq2 ; Ir a Etiq2 si $r1 6= $r2

Tambien existe el salto incondicionalj Etiqueta ; salta a Etiqueta incondicionalmente.


Revision: 1.8




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, Elseadd $s2, $s3, $s4j Fin

Else:sub $s2, $s3, $s4

Fin:


Revision: 1.8




Ensamblamos un bucle

Ejemplo en C

int i, j, k, A[100];

while (A[i] == k) i = i + j;


Bucle: add $t0, $s0, $s0add $t0, $t0, $t0add $t0, $t0, $s3lw $t1, 0($t0)bne $t1, $s2, Finadd $s0, $s0, $s1j Bucle

Fin:


Revision: 1.8




Mas 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 tambien

slti $r2, $r1, n

$r2 recibe un 1 si $r1 < n y un 0 en caso contrario.


Revision: 1.8




Y otra instruccion de salto

Tenemos una instruccion que nos permite saltar a unadireccion variable, que este contenida en un registro:

jr $r1

La instruccion siguiente a esta sera la que resida en ladireccion que esta contenida en el registro $r1.


Revision: 1.8




Resumen de instrucciones de control de flujo

Instruccion Funcion

beq $r1, $r2, etiq ($r1 == $r2)? $PC ← $PC+etiq : ∅bne $r1, $r2, etiq ($r1 != $r2)? $PC ← $PC+etiq : ∅slt $r1, $r2, $r3 ($r2 < $r3)? $r1 ← 1 : $r1 ← 0slti $r1, $r2, n ($r2 < n)? $r1 ← 1 : $r1 ← 0j etiq $PC ← etiqjr $r1 $PC ← $r1jal etiq $ra ← $PC+4; $PC ← etiq

Atencion: Como antes, el numero n puede ser positivo o negativo.


Revision: 1.8




Representacion de las instrucciones

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

De esta forma, la interpretacion de la instruccion es massencilla y uniforme.


Revision: 1.8





Para las instrucciones tipo R (varios registros involucrados):

op code RS RT RD SHAMT FUNC

6 bits 5 bits 5 bits 5 bits 5 bits 6 bits

Significado de los camposop code: codigo de operacion basica

RS: registro fuente 1RT: registro fuente 2RD: registro destinoSHAMT: shift amountFUNC: codigo de funcion concreta


Revision: 1.8





Para las instrucciones tipo I (valores inmediatos involucrados):

op code RS RT direccion

6 bits 5 bits 5 bits 16 bits


RS: registro fuenteRT: registro destinodireccion: numero de 16 bits (±32767)


Revision: 1.8





Para las instrucciones tipo J (transferencia de control):

op code direccion de salto

6 bits 26 bits


direccion de salto: direccion de la siguiente instruccion a ejecutar


Revision: 1.8




Representacion de las instrucciones basicas

Tipo Opcode RS RT RD SHAMT FUNC dir

add R 0 reg reg reg 0 32 n/a

sub R 0 reg reg reg 0 34 n/a

addi I 8 reg reg n/a n/a n/a inm

lw I 35 reg reg n/a n/a n/a dir

sw I 43 reg reg n/a n/a n/a dir

j J 2 n/a n/a n/a n/a n/a n/a

Traducir el lenguaje ensamblador a codigo maquina es el papel delas (o programa ensamblador).


Revision: 1.8




Representacion de las instrucciones de control


beq I 4 reg reg n/a n/a n/a dir

bne I 5 reg reg n/a n/a n/a dir

slt R 0 reg reg reg 0 42 n/a

jr R 0 reg 0 0 0 8 n/a

jal J 3 n/a n/a n/a n/a n/a n/a


Revision: 1.8




Representacion de las instrucciones logicas


sll R 0 0 reg reg d 0 n/a

srl R 0 0 reg reg d 2 n/a

sra R 0 0 reg reg d 3 n/a

and R 0 reg reg reg 0 36 n/a

or R 0 reg reg reg 0 37 n/a


Revision: 1.8




Resumen de modos de direccionamiento

1 Registro: los operandos estan en registros.

2 Inmediato: El operando es una constante contenida en lapropia instruccion.

3 Indexado, (base mas desplazamiento): Un operando esta enmemoria. La direccion es la suma del contenido de un registroy de un valor inmediato.

4 Relativo a $PC: La direccion del operando es la suma delregistro $PC mas una constante contenida en la instruccion.

5 Directo: La direccion de salto esta (casi) contenida en lainstruccion.


Revision: 1.8



Subrutinas o procedimientos

Las subrutinas o procedimientos estructuran el codigo: se lespasan valores (argumentos) y devuelven resultados.

Permiten el reuso del software.

Aıslan unas piezas del codigo de otras, facilitando elmantenimiento.

Es un sirviente al que se le dan unos datos (los “argumentos”)y nos devuelve un resultado (“valor de retorno”).


Revision: 1.8



Subrutinas o procedimientos

Para ejecutar correctamente una subrutina, los pasos son:

Actor Accion

Principal: coloca argumentos en un lugar accesible a la subrutina.Principal: transfiere el control.Subrutina: reserva espacio para su ejecucion.Subrutina: ejecuta su funcion.Subrutina: coloca el resultado en un lugar accesible al principal.Subrutina: devuelve el control al punto de partida.


Revision: 1.8



Mas registros. . .

Para el intercambio de datos se utilizan ciertos registrosconvenidos:

Nombre Uso$a0–$a3 para pasar argumentos$v0–$v1 para devolver los resultados

$ra para la direccion de retorno


Revision: 1.8



. . . y una nueva instruccion

Una instruccion especialmente pensada nos permite “saltar”al comienzo de la subrutina al tiempo que se guarda ladireccion de retorno en el registro $ra.

jal Procedimiento

El nombre jal significa jump-and-link. El sentido es queconservamos en $ra la direccion a la que se debe retornar.

La direccion de la instruccion que se ha de ejecutar se guardaen el registro de instruccion, o $PC. Por tanto la direccion quese ha de guardar en $ra es $PC+4.


Revision: 1.8



Resumen de llamada a la subrutina

Los pasos para la llamada seran:1 El principal coloca en $a0–$a3 los argumentos necesarios para

la ejecucion de la subrutina.2 Esta realiza los calculos y devuelve el/los resultado(s) en

$v0–$v1.3 Devuelve el control con un simple jr $ra.

¿Y si no bastan con los registros de que se dispone? Ahora lovemos.


Revision: 1.8



Un nuevo registro y la pila

Es muy probable que una subrutina necesite mas registros quelos $a0–$a3 y $v0–$v1.

Antes de poder usar otros registros, estos se deben archivar.

Para ello, se dedica un trozo de memoria, suficientementegrande, como repositorio temporal.

Este repositorio se llama pila (en ingles, stack).

Se usa un registro, $sp, para saber en donde comienza elespacio libre. Cada vez que se almacena o se extrae algo, seajusta.

Por razones historicas, crece hacia las direcciones bajas dememoria.

Las operaciones de almacenamiento y extraccion se llamanpush y pop, respectivamente.


Revision: 1.8



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


Revision: 1.8




Subrutina en ensamblador

sub1:subi $sp, $sp, 12sw $t0, 8($sp)sw $t1, 4($sp)sw $s0, 0($sp)

add $t0, $a0, $a1add $t1, $a2, $a3sub $s0, $t0, $t1

...


Revision: 1.8




Subrutina en ensamblador...

add $v0, $s0, $zero

lw $s0, 0($sp)lw $t1, 4($sp)lw $t0, 8($sp)addi $sp, $sp, 12

jr $ra


Revision: 1.8



Convenios sobre el uso de registros

Convenimos en que los registros $t0–$t9 son temporales y nohace 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.


Revision: 1.8



¿Y si la subrutina llama a otra?

Si una subrutina llama a otra, probablemente necesita usartambien los registros $a0–$a3, y guardar en $ra la direccionde retorno. Hay un conflicto en el uso de los registros.

La solucion es guardarlos en la pila antes de modificarlos,restaurando su valor al final.


Revision: 1.8



Subrutina recursiva

Subrutina en C

int fact(int n){

if (n == 1) return 1;else

return n*fact(n - 1);}


Revision: 1.8



Subrutina recursiva

Subrutina ensamblada (I)

fact:subi $sp, $sp, 8sw $ra, 4($sp)sw $a0, 0($sp)subi $t0, $a0, 1bne $t0, $zero, F1

addi $v0, $zero, 1addi $sp, $sp, 8jr $ra

...


Revision: 1.8



Subrutina recursiva

Subrutina ensamblada (II)...

F1: subi $a0, $a0, 1jal fact

lw $a0, 0($sp)lw $ra, 4($sp)addi $sp, $sp, 8

mul $v0, $v0, $a0jr $ra


Revision: 1.8



Estado de los registros en llamadas a subrutinas

Por convenio, el comportamiento es ası:

Preservados No preservados

$s0–$s7 $t0–$t9$sp $a0–$a3$ra $v0–$v1

Memoria encima de $sp Memoria debajo de $sp


Revision: 1.8



Ciclo de programacion

Compilador Ensamblador Linker Cargador

Programa C Código ensamblado Código máquina Ejecutable Programa cargado

Figura: Procesos y resultados del ciclo de programacion


Revision: 1.8



Estructura del programa cargado

Datos estáticos

Código (texto)

Reservado

Pila

Datos dinámicos

1000 0000

0040 0000

1000 8000

7fff fffc

0

pc

$gp

$sp

Figura: Zonas de memoria, una vez cargado el programa


Revision: 1.8



Estructura de un fichero objeto

Segmento de código

Cabecera fichero objeto

Segmento de datos

Información de realojo

Tabla de símbolos

Información de depuración

Figura: Partes de un fichero objeto, con extension .o


Revision: 1.8



Lenguajes de programacion de alto nivel

COBOL, PL/I

FORTRAN

PASCAL, C

ADA

Java, C++, SmallTalk

. . .


3. Instrucciones: lenguaje de la m´aquinahpc.aut.uah.es/~rduran/FFCC/pdf/Cap3Hand.pdf · Curso...

Documents

Transcript of 3. Instrucciones: lenguaje de la m´aquinahpc.aut.uah.es/~rduran/FFCC/pdf/Cap3Hand.pdf · Curso...