(cc) 1999-2010, josé m. foces-morán. capítulo 3. arquitectura del set de instrucciones del...
TRANSCRIPT
(CC) 1999-2010, José M. Foces-Morán.
Capítulo 3. Arquitectura Del set De Instrucciones Del Microprocesador MIPS.
Instrucciones. Los Registros arquitectónicos.Modos de direccionamiento.Tipos de datos.La pila
Esta obra está bajo una licencia Attribution-ShareAlike 2.5 de Creative Commons.Para ver una copia de esta licencia, visite http://creativecommons.org/licenses/by-sa/2.5/ o envie una carta a Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.
(CC) 1999-2006, José M. Foces-Morán.
¿Qué significa ISA ? ISA significa Instruction Set Architecture
Es una abstracción esencial Representa el punto de vista de un programador
que posee el mayor nivel de privilegio en el acceso a los recursos ofrecidos por el computador.
No representa un único nivel: en diversas situaciones sus componentes pueden ser distintas.
Esta abstracción representa todos los recursos necesarios para programar un computador.
Nivel más bajo que el de los lenguajes de alto nivel.
Las instrucciones de control de flujo ofrecen unas posibilidades muy básicas.
Las operaciones son también muy básicas.
(CC) 1999-2006, José M. Foces-Morán.
Objetivo de este capítulo. Aprender una ISA simple: La del
microprocesador MIPS. Cómo afectan al hardware resultante las
opciones disponibles en sus diversas componentes.
El concepto de programa almacenado. La representación uniforme de datos e instrucciones.
Cómo los lenguajes de alto nivel hacen uso de las posibilidades de la ISA.
Usaremos el lenguaje C.
(CC) 1999-2006, José M. Foces-Morán.
Princeton vs. Harvard Von Neumann trabajó en la
Universidad de Princeton La memoria contiene las instrucciones y
los datos CISC: Complex Instruction set Computer
En la Universidad de Harvard probaron otra organización
Dos memorias separadas Instrucciones Datos
RISC: Reduced Instruction Set Computer.
(CC) 1999-2006, José M. Foces-Morán.
El microprocesador MIPS Una ISA del tipo RISC.
Reduced Instruction Set Computer. Proyecto dirigido por el Prof. Hennessy.
Usada por: NEC, Nintendo, Silicon Graphics, Sony, etc.
Una ISA simple, bastante ortogonal, potente y fácilmente estudiable. SPIM: Un simulador del microprocesador
MIPS. Lo emplearemos en algunas prácticas.
(C) 1999-2010, José M. Foces-Morán.
Las instrucciones representan operaciones. Todas las instrucciones aritméticas y
lógicas de la ISA MIPS tienen tres operandos. El orden de los operandos es fijo.
Ejemplo: Sumar b y c, salvar resultado en a. a = b + c
add a, b, cOperando de destino
Operando fuente 1
Operando fuente 2
Mnemónico dela instrucción
InstrucciónInstrucción
(CC) 1999-2006, José M. Foces-Morán.
Operandos para la ALU: Registros. La ALU sólo opera sobre registros (RISC) Entonces, a, b y c han de ser registros.
add a, b, c
Operando de destino
Operando fuente 1
Operando fuente 2
Nemónico dela instrucción
(CC) 1999-2006, José M. Foces-Morán.
Dos tipos de registros. No arquitectónicos.
Son necesarios para que el microprocesador pueda salvar resultados intermedios a lo largo de la ejecución de una instrucción (Intra-instrucción).
Los estudiaremos en el capítulo 5.
Arquitectónicos. Permiten que guardemos resultados temporales, los
cuales, podrán ser usados por instrucciones posteriores (Inter-instrucción).
Ejemplo: Realizar un programa que multiplique por 4 el contenido de $t0 y salve el resultado en $t1.
(CC) 1999-2006, José M. Foces-Morán.
Registros arquitecturados MIPS, I.
Comunicación de resultados entre instrucciones.
Ejemplo: Realizar un programa que multiplique por 4 el contenido de $t0 y salve el resultado en $t1.
add $t1, $t0, $t0 #2 * $t0 guardado en $t1 add $t1, $t1, $t1 #2 * $t1 guardado en $t1, o sea 4*$t0
$t1 guarda el doble de $t0 temporalmente para que la siguiente instrucción calcule su doble, a su vez.
(CC) 1999-2006, José M. Foces-Morán.
Registros arquitecturados MIPS, II. MIPS contiene 32 registros de propósito
general [GPR, General Purpose Register]. El ancho de cada registro es de 32 bits.
MIPS es una arquitectura de 32 bits. $0 siempre vale 0. Los nombres son $1 .. $31. Reciben otros nombres (alias) que estudiaremos en
breve. Las instrucciones aritmético-lógicas (ALU) sólo
operan sobre registros: MIPS es una arquitectura load-store.
(CC) 1999-2006, José M. Foces-Morán.
MIPS: Una ISA load/store
D
D
D
D
LOAD
STORE
ALU
(CC) 1999-2006, José M. Foces-Morán.
Compilación de una expresión a base de operadores + y -. f = (g + h) – (i + j);
f : $s0, g : $s1, h : $s2, i : $s3, j : $s4
add $t0, $s1, $s2add $t1, $s3, $s4sub $s0, $t0, $t1
Las variables de este programa son simples: contienen un único dato de ancho 32 bits.
¿Cómo se pueden construir agregados de datos (arrays) cuando se programa a nivel de ISA (Lenguaje de ensamblaje)?
(CC) 1999-2006, José M. Foces-Morán.
Ya visto: Los operandos posibles en la ISA de MIPS Las instrucciones aritméticas y lógicas de
MIPS sólo sólo aceptan registros como operandos. No existe No existe ningunaninguna instrucción en la ISA que nos instrucción en la ISA que nos
permita sumar el permita sumar el contenidocontenido de una dirección de de una dirección de memoria con el contenido de un registro.memoria con el contenido de un registro.
Tanto los operandos fuente como el operando de Tanto los operandos fuente como el operando de destino deben ser destino deben ser registrosregistros..
sub $22, $10, $9sub $22, $10, $9
(CC) 1999-2006, José M. Foces-Morán.
El fichero de registros de MIPS Contiene 32 registros de 32 bits de ancho
cada uno de ellos. Los nombres son $0 .. $31
También reciben otros nombres que tienen que ver con las funciones específicas de cada registro.
Por ejemplo: $s0, $s1 etc. son los registros que emplearemos para las
variables de los programas de ejemplo escritos en C. $t0, $t1 etc. Son los registros temporales que
emplearemos al compilar los programas escritos en C.
(CC) 1999-2006, José M. Foces-Morán.
La memoria de los sistemas basados en MIPS (i) Claramente, el número de registros (32),
es pequeño. La memoria está organizada en casillas
de 8 bits de ancho cada una de ellas. Cada una de las casillas de 8 bits está
identificada por su dirección de memoria. El número de posiciones de memoria es muy
grande en comparación con el número de registros.
(CC) 1999-2006, José M. Foces-Morán.
La memoria es muy amplia. Si la ALU sólo opera sobre registros…
Continuamente deberemos acceder a la memoria en busca de datos:
Cargar el dato en un registro (loadload). Cargar el otro dato en otro registro (loadload). Efectuar la operación cuyo resultado se obtendrá en
otro registro (Aritmética-lógicaAritmética-lógica). Salvar el resultado en su dirección de memoria (store).(store).
MIPS es una arquitectura load-store. El tamaño de palabra de la ISA MIPS es 32
bits.
La memoria de los sistemas basados en MIPS (ii)
(CC) 1999-2006, José M. Foces-Morán.
Modelo funcional de la memoria Cada posición de memoria guarda un
dato de 8 bits (1byte). Cada posición tiene un nombre, un
entero de 32 bits Conocido como dirección de memoria La primera es la 0 La última es la 232-1
Ya estudiaremos las estructuras y la tecnología
(CC) 1999-2006, José M. Foces-Morán.
Una instrucción de lectura de una palabra de 32 bits (load word).
lw $t0, 8($s3)
Ejemplo: Instrucción Load Word lw
Un dato presente en memoria•En la dirección = $s3 + 8
El registro al que se transfiere el dato leído desde la memoria.
(CC) 1999-2006, José M. Foces-Morán.
lw $t0, 8($s3)
[repetición]
aunque denotemos un registro
La word que se cargaen $t0 procede deLa dirección de memoria0x1008.
Un dato presente en memoria,
¿Cuál es su dirección?Dirección = $s3 + 8
…y, una constante
Si $s3 contiene 0x1000, entoncesla dirección de memoria efectiva es 0x1008
(CC) 1999-2006, José M. Foces-Morán.
Un ejemplo.
lw $t0, 8($s3)
Supongamos que $s3 contiene 0x00001000.
La dirección formada es = 0x1000 + 8 Supongamos que esta dirección contiene 0x1c8d273f
El dato que se carga en $t0 es 0x1c8d273f
(CC) 1999-2006, José M. Foces-Morán.
Lectura de memoria: más detalles.
El dato en memoria se ha de extender a lo largo cuatro posiciones consecutivas: El dato tiene 32 bits (4 bytes) Cada posición de memoria: 1 byte Son necesarias 4 posiciones seguidas.
(CC) 1999-2006, José M. Foces-Morán.
Hay varias formas de construir el dato en el registro.
Extremista-superior: La posición de memoria del dato (0x1008) contiene el byte alto del dato Así funciona MIPS.
Extremista-inferior: La posición de memoria del dato (0x1008) contiene el byte bajo del dato Así funciona el i386ex.
(CC) 1999-2006, José M. Foces-Morán.
MIPS es big-endian (Extremista superior). Una word ocupa 4 posiciones de memoria.
La word que reside en la posición de memoria D está formada por los bytes que residen en las direcciones siguientes:
D, D+1, D+2 y D+3.
Se usan dos formas de cargar esa word en un registro:
Cargando el extremo superior en primer lugar (Big endian) Cargando el extremo inferior en primer lugar (Little
endian).
¡SPIM es little-endian!
(CC) 1999-2006, José M. Foces-Morán.
lw $t0, 8($s3) ¡intel!
(CC) 1999-2006, José M. Foces-Morán.
lw $t0, 8($s3) ¡MIPS!
(CC) 1999-2006, José M. Foces-Morán.
La instrucción sw: store word.
D
D
D
D
LOAD: lw
STORE: sw
ALU
(CC) 1999-2006, José M. Foces-Morán.
La instrucción sw: store word. Salva la word contenida en $t0 en la
posición de memoria 8+$s3.
sw $t0, 8($s3)
La posición de memoria dondese salvará el contenido de $t0
El registro cuyo contenidose va a salvar en memoria
(CC) 1999-2006, José M. Foces-Morán.
Un programa en C que usa las instrucciones lw y sw. Compilar la expresión siguiente:
//Crear un array de 100 enteros (1 word cada uno)int A[100]; A[8] = h + A[88];
A[100] está formado por un conjunto de 100 enteros guardados en memoria consecutivamente.
Cada entero (int) ocupa una word A[100] ocupa 100 words (400 bytes). Para hacer la suma (+) necesitamos que A[8] y h estén cargados
en sendos registros. Asociaremos hh al registro $s2$s2., por ejemplo. $s3$s3 contiene la dirección de memoria que es la base del array llamado
A[].A[]. Cargaremos A[8] en el registro $t0. Sumaremos $t0 y $s2 y pondremos el resultado en $t0. Salvaremos el resultado recién obtenido en la dirección de memoria
A[8].
(CC) 1999-2006, José M. Foces-Morán.
Un programa en C que usa lw y sw (ii)
Compilar la expresión siguiente:
A[8] = h + A[88];
Calcular la dirección donde está A[8] $s3 contiene la dirección base del array $s3 contiene la dirección base del array A[]A[] 8 x 4 = 32 8 x 4 = 32 4bytes/word, $s3(32) representa la dirección del entero 4bytes/word, $s3(32) representa la dirección del entero
A[8]A[8] Cargaremos el contenido de A[8] en el registro $t0.
lw $t0, 32($s3) Sumamos $s2 y $t0 y guardamos el resultado en $t0.
add $t0, $t0, $s2 Guardamos este resultado en la dirección de memoria de A[8].
sw $t0, $s3(32)
(CC) 1999-2006, José M. Foces-Morán.
Un programa en C que usa lw y sw (iii) Compilar la expresión siguiente:
A[8] = h + A[8]; $s3 contiene la dirección base del array A[]$s3 contiene la dirección base del array A[] 0($s3) “apunta a” 0($s3) “apunta a” A[0]A[0] 4($s3) “apunta a” 4($s3) “apunta a” A[1]A[1] 8($s3) “apunta a” 8($s3) “apunta a” A[2]A[2] 12($s3) “apunta a” 12($s3) “apunta a” A[3] A[3] y, así sucesivamente.y, así sucesivamente.
lw $t0, 32($s3)
add $t0, $t0, $s2
sw $t0, 32($s3)
(CC) 1999-2006, José M. Foces-Morán.
Ejemplo de lw y sw más sofisticado
Compilar la expresión siguiente:A[i] = h + A[i];
Asociamos hh al registro $s2$s2, como en el ejemplo precedente.
$s3$s3 contiene la dirección de memoria base de A[]. La variable i la asociamos al registro $s4. La dirección de memoria de A[i] será:
(Dirección Base de A) + (4 i) ¿Por qué multiplicamos por 4?
Cada word tiene 4 bytes Cada byte ocupa una dirección de memoria
add $t1, $s4, $s4 ; i * 2add $t1$t1, $t1, $t1 ; i * 2 * 2
(CC) 1999-2006, José M. Foces-Morán.
Ejemplo de lw y sw más sofisticado
Compilar la expresión siguiente:A[i] = h + A[ii];
Formamos la dirección de memoria de A[i]: add $t2, $t1, $s3
Cargamos el dato dentro del registro $t1, p.ej.: lw $t1, ($t2)0 Sumamos h a $t1: add $t1, $s2, $t1 El resultado, esto es, el contenido del registro $t1 lo
salvamos en memoria –en la misma dirección de memoria de A[i]:sw $t1, ($t2)0
(i * 4) A[]Dirección de memoria de A[i]
(CC) 1999-2006, José M. Foces-Morán.
Ejemplo de lw y sw más sofisticado
Compilar la expresión siguiente:A[i] = h + A[ii];
add $t1, $s4, $s4
add $t1, $t1, $t1
add $t2, $t1, $s3
lw $t1, ($t2)0
add $t1, $s2, $t1
sw $t1, ($t2)0
(CC) 1999-2006, José M. Foces-Morán.
Las instrucciones [cadenas de 32
bits] tienen dirección de memoria. [Instrucciones y datos se representan del mismo
modo]. La forma binaria de las instrucciones MIPS tienen 32
bits (todas). Cada instrucción ocupa 4 direcciones de memoria seguidas. Por tanto, una instrucción, al igual que un dato, posée
dirección de memoria. ¿Cuál es la dirección de memoria de una instrucción? Las direcciones de memoria de los datos [Variables, arrays]
las representamos simbólicamente con el operador &:&contador1
Las direcciones de memoria de las instrucciones también se pueden representar simbólicamente mediante una etiqueta:inicio:
Etiquetas de datos y código en SPIM.
Explicad qué operación lleva a cabo este programa:Explicad qué operación lleva a cabo este programa:
.dataAstart:
.word 0x00000060, 0x00000050, 0x00000040
.word 0x00000010, 0x00000000
.word 0x00000000, 0x10101010, 0x20202020
.word 0x30303030, 0x40404040
.text
.globl main
main: la $t0, Astart li $t1, 4move $t2, $zero
siguiente: lw $s0, 0($t0)beq $s0, $zero, es_cero add $t2, $t2, $s0add $t0, $t0, $t1j siguiente
es_cero: sw $t2, 0($t0)
(CC) 1999-2006, José M. Foces-Morán.
Direcciones de memoria de instrucciones y de datos: Un ejemplo en C.
if (i == j)
goto fuerafuera;
else
f = g + h;
fuera:fuera: f = f – i;
El enfoque siguiente es el correcto: emplear estructuras de programación
if (i != j){
f = g + h;
}
f = f – i;
if (i != j){
f = g + h;
}
f = f – i;
(CC) 1999-2006, José M. Foces-Morán.
Este enfoque no es correcto
(CC) 1999-2006, José M. Foces-Morán.
Producción de un programa.
(CC) 1999-2006, José M. Foces-Morán.
Producción de un programa: Denominación de los ficheros intermedios.
(CC) 1999-2006, José M. Foces-Morán.
Intro. Codificación de instrucciones: add
La siguiente instrucción está representada en lenguaje de ensamblaje:
add $t0, $s1, $s2
El computador no “entiende” las instrucciones en este formato fuente.
Sin embargo, esta representación es conveniente para las personas.
El programa que traduce el texto escrito en lenguaje de ensamblaje es el programa ensamblador.
El ensamblador traduce el texto fuente a “texto o código objeto” (Una forma de código máquina).
El texto objeto está “lleno” de instrucciones en forma binaria.
(CC) 1999-2006, José M. Foces-Morán.
add $t0$t0, $s1, $s2
Representación binaria de la instrucción add [Una instrucción del tipo RR]
CódigoObjeto
Códigofuente
(CC) 1999-2006, José M. Foces-Morán.
Formato binario de la instrucción lw
[Una instrucción del tipo II].
Códigofuente
CódigoObjeto
lw $t0$t0, ($s1)32
(CC) 1999-2006, José M. Foces-Morán.
Formato Binario De La Instrucción sw
[Una Instrucción Del Tipo II].
sw $t0$t0, ($s1)32
http://paloalto.unileon.es/mel/docs/DecodeMap.pdf
(CC) 1999-2006, José M. Foces-Morán.
Un resumen de lo visto hasta ahora.
(CC) 1999-2006, José M. Foces-Morán.
Y, para terminar esta Y, para terminar esta sección: sección:
Dos principios Dos principios fundamentales.fundamentales.
• Las instrucciones se representan en binario, igual que los datos numéricos.
• Los programas y los datos que manejan, se almacenan en el mismo sitio: la memoria.
(CC) 1999-2006, José M. Foces-Morán.
Instrucciones de salto Instrucciones de salto condicional condicional
Flujo de ejecución secuencial: PC <- PC + 4 1000, 1004, 1008, 1012,…
Salto a la dirección 32000: 1024, 1028, 32000…
beq $t0, $t1, destino0 Branch if equal Salta a destino0 si $t0 es igual $t1
bne $s3, $v0, destino1 Branch if non-equal Salta a destino1 si $s3 es distinto de $v0
(CC) 1999-2006, José M. Foces-Morán.
Compilación de una estructura
if-then-else (I) Las variables f, g, h, i y j están
asociadas a los registros $s0 a $s4.
if (i == j)
f = g + h;
else
f = g – h;
(CC) 1999-2006, José M. Foces-Morán.
Comprobar la condición opuesta porque:
b (branch) no es ejecutar este bloque es saltar a un bloque
bne $s3, $s4, else
add $s0, $s1, $s2
j exit #Salto incondicional.
else: sub $s0, $s1, $s2
exit:...
Compilación De Una Estructura
if-then-else (II)
if (i == j)
f = g + h;
else
f = g – h;
(CC) 1999-2006, José M. Foces-Morán.
.datai: .word 0x00102030j: .word 0x00000000f: .word 0x00000000g: .word 0x0fffffffh: .word 0x00000001.text.globl mainmain:la $t7, ilw $t0, 0($t7)la $t7, jlw $t1, 0($t7)la $t7, glw $t2, 0($t7)la $t7, hlw $t3, 0($t7)# ?bne $t0, $t1, else
add $t4, $t2, $t3j exit
else:sub $t4, $t2, $t3 exit: sw $t4, 0($t7)# El programa continúa…
if-then-elsecon bne
Etiqueta Exit
Secuencial
Secuencial
alternativa
(CC) 1999-2006, José M. Foces-Morán.
.data
i: .word 0x00102030
j: .word 0x00000000
f: .word 0x00000000
g: .word 0x0fffffff
h: .word 0x00000001
.text
.globl main
main:
la $t7, i
lw $t0, 0($t7)
la $t7, j
lw $t1, 0($t7)
la $t7, g
lw $t2, 0($t7)
la $t7, h
lw $t3, 0($t7)
# ?
#Escribid un programa equivalente,
#pero, usando beq:
if-then-else con beq
Etiqueta Exit
Secuencial
Secuencial
alternativa
(CC) 1999-2006, José M. Foces-Morán.
Estructuras repetitivas. Un bloque de
instrucciones es ejecutado una vez tras otra:
Mientras cierta condición sea verdadera: Que j sea distinto de 100.
En cada iteración se modifica el valor empleado para evaluar la condición (j=j+5).
En algún momento, el valor hará que la condición sea falsa y que el bucle no se repita más veces: Salto a Exit.
¿j != 100?
Bloque de
Instrucciones
Evalúa j, ejemplo:
j = j + 5;
Verdadero
Falso
j = 0;
Etiqueta Exit
(CC) 1999-2006, José M. Foces-Morán.
Estructura repetitiva while:Ejemplo.
¿j != 100?
Bloque de
Instrucciones
Evalúa j, ejemplo:
j = j + 5;
Verdadero
Falso
j = 0;
.data
j: .word 0x00000000
.text
.globl main
main:
la $t7, j
lw $t0, 0($t7)li $t1, 100#Carga inmediato 100 en $t1
bucle_while:
beq $t0, $t1, Exit
addi $t0, $t0, 5
j bucle_while
Exit: sw $t0, 0($t7)
# El programa continúa…Etiqueta Exit
Etiqueta
bucle_while
(CC) 1999-2006, José M. Foces-Morán.
Compilación de un bucle whileEjemplo 2.int main(){const int k = -1, i = 0;static int vector[]={-1,-1,-1,-1,-1, 0, 0, 0, 1 };
while(vector[i] == k){while(vector[i] == k){i = i + 1;i = i + 1;
}}
¿vector[i] == k?
i = i + 1;
V
F
(CC) 1999-2006, José M. Foces-Morán.
Bucle while:Ejemplo 2.
int main(){
const int k = 1, i = 0;static int vector[]={ 1, 1, 1,
1, 1, 0, 0, 0, 1 };
while(vector[i] == k){while(vector[i] == k){i = i + 1;i = i + 1;
}
}
¿vector[i] == k?
i = i + 1;
V
F
.data
i: .word 0x00000000
k: .word 1
vector: .sword 1, 1, 1
.sword 1, 1, 0
.sword 0, 0, 1
.text
.globl main
main:
la $t7, i
lw $t0, 0($t7)
la $t7, k
lw $t5, 0($t7)la $t2, vector # vector[]
bucle_while:add $t1, $t0, $t0 # 2iadd $t1, $t1, $t1 # 4iadd $t3, $t1, $t2 # vector+4i
lw $t4, 0($t3)
bne $t4, $t5, Exit
addi $t0, $t0, 1
j bucle_while
Exit:
(CC) 1999-2006, José M. Foces-Morán.
Compilación de un bucle while.Ejemplo 3.
Traducid este programa al leng. de ensamblaje MIPS:
int main(){static int vector[20]={0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,0,0,0};
int i = 0, j = 2, k = 1;
while (vector[i] == k){i = i + j;
}
}
¿vector[i]==k?
i = i + j;
V
F
(CC) 1999-2006, José M. Foces-Morán.
Asumimos que: i, j, k $s3, $s4, $s5 vector[]$s6
La dirección de comienzo del array vector se encuentra en $s6.
1. Cargar el elemento vector[i] en un registro temporal:#Etiqueta de comienzo del bucle:inicio_while: add $t1, $s3, $s3 #i*2add $t1, $t1, $t1 #i*4add $t1, $t1, $s6 #vector+4*ilw $t0, 0($t1) #$t0 save[i]
Compilación de un bucle while Ejemplo 3.
int main(){
static int vector[20]={0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,0,0,0};
int i = 0, j = 2, k = 1;
while (vector[i] == k){i = i + j;
}
}
(CC) 1999-2006, José M. Foces-Morán.
i, j, k $s3, $s4, $s5 save$s6 save[i]$t0
2. Comparar save[i] con k:;Saltar a fin_while;en caso de que $t0 != $s5
bnne $t0, $s5, fin_while
3. Bloque falso (con respecto a bne):add $s3, $s3, $s4 ; i = i+j;
4. Saltar al comienzo:j inicio_while
fin_while: ... ; Resto del programa ...
Compilación de un bucle while, Ejemplo 3.
int main(){static int vector[20]={0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,0,0,0};
int i = 0, j = 2, k = 1;
while (vector[i] == k){i = i + j;
}
}
(CC) 1999-2006, José M. Foces-Morán.
Compilación de un bucle while.Ejemplo 4.
Traducid este programa al leng. de ensamblaje MIPS:
int main(){static int vector[20]={0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,0,0,0};
int i = 1, j = 2, k = 1;
while (vector[i] == k){i = i + j;
}
}
¿vector[i]==k?
i = i + j;
V
F
(CC) 1999-2006, José M. Foces-Morán.
Compilación de un bucle while, Ejemplo 3.
(CC) 1999-2006, José M. Foces-Morán.
Compilación de un bucle while Ejemplo 3.
(CC) 1999-2006, José M. Foces-Morán.
Comparación de magnitud: x < y, x y
El test igualdad (beq) y el test des-igualdad (bne) son muy comunes.
Los tests mayor que y menor que, son también muy comunes.
(CC) 1999-2006, José M. Foces-Morán.
Comparación de magnitud: x < y, x y
¿Cómo se hace para determinar si $x es menor que $y?
Usaremos una instrucción nueva llamada slt (Set-on-less-than).
“Poner [el primer registro] a 1 si [el segundo registro] es menor que [el tercer registro]”.
slt $r, $x, $y
Cuando finaliza la instrucción: Si $r contiene un 1 $x < $y Si $r contiene un 0 $x $y
(CC) 1999-2006, José M. Foces-Morán.
Ejemplo: ¿a < b?
Realizad un programa que salte a la etiqueta less si a < b.
Supondremos que a $s0 y que b $s1.
Usaremos $t0 como registro temporal.
(CC) 1999-2006, José M. Foces-Morán.
Compilar una estructura switch usando una tabla de saltos.
switch (k) {case 0:case 0:
f = i + j; break;
case 1:case 1: f = g + h; break;
case 2:case 2: f = g – h; break;
case 3:case 3: f = i – j; break;
}
Según el valor de k, se ejecuta una sentencia-bloque diferente.
Si k < 0 o k 4, no se ejecutará ninguno de los bloques case.
En cada caso 0..3, break hace que el programa abandone la estructura ( } ).
(CC) 1999-2006, José M. Foces-Morán.
switch: estrategia
(CC) 1999-2006, José M. Foces-Morán.
switch: k fuera de rango.switch (k) {
case 0:case 0: f = i + j; break;
case 1:case 1: f = g + h; break;
case 2:case 2: f = g – h; break;
case 3:case 3: f = i – j; break;
}
Si k < 0 o k 4, no se ejecutará ninguno de los bloques case.
f = $s0, g = $s1, h = $s2, i = $s3, j = $s4, k = $s5$t2 = 4$t2 = 4
slt $t3, $s5, $zero
bne $t3, $zero, ExitExit
slt $t3, $s5, $t2
beq $t3, $zero, ExitExit
(CC) 1999-2006, José M. Foces-Morán.
Tabla = Array, en este caso.
Cada elemento de la tabla es una dirección de salto.
Es una cantidad de 32 bits = 4 bytes.
Cada salto ocupa 4 bytes. Como si fueran enteros de
32bits. ¿Cuál es la dirección de
memoria de un elemento de la tabla?
JumpTable + 4k
switch: k es el índice de una tabla de saltos.switch (kk) {
case 0:case 0: f = i + j; break;
case 1:case 1: f = g + h; break;
case 2:case 2: f = g – h; break;
case 3:case 3: f = i – j; break;
}
(CC) 1999-2006, José M. Foces-Morán.
JumpTable + 4k $s5 = k 4 k:
add $t1, $s5, $s5add $t1, $t1, $t1
$t4 contiene JumpTable JumpTable + 4 k :
add $t1, $t1, $t4
Cargar el salto correspondiente a k en $t0:
lw $t0$t0, ($t1)0
switch (kk) {case 0:case 0:
f = i + j; break;
case 1:case 1: f = g + h; break;
case 2:case 2: f = g – h; break;
case 3:case 3: f = i – j; break;
}
switch: 4 x k
¡En $t0 tenemos la dirección de
salto!
(CC) 1999-2006, José M. Foces-Morán.
switch: saltar a la “dirección de salto”
$t0 contiene la dirección de salto.
¿Cómo saltar a una dirección contenida en un registro?
Una instrucción de salto incondicional nueva : “jump through register”
jr $Registro
jr $t0 ;Así de fácil
switch (kk) {case 0:case 0:
f = i + j; break;
case 1:case 1: f = g + h; break;
case 2:case 2: f = g – h; break;
case 3:case 3: f = i – j; break;
}
(CC) 1999-2006, José M. Foces-Morán.
switch (kk) {case 0:case 0:
f = i + j; break;
case 1:case 1: f = g + h; break;
case 2:case 2: f = g – h; break;
case 3:case 3: f = i – j; break;
}
L0: add $s0, $s3, $s4
j Exit
L1: add $s0, $s1, $s2
j Exit
L2: sub $s0, $s1, $s2
j Exit
L3: sub $s0, $s3, $s4
Exit: ;Resto del programa ...
...
switch: El resto del código es... directo.
Esta obra está bajo una licencia Attribution-ShareAlike 2.5 de Creative Commons.Para ver una copia de esta licencia, visite http://creativecommons.org/licenses/by-sa/2.5/ o envie una carta a Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.