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-2010, 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.



Usada por:


Reduced Instruction Set Computer.
Proyecto dirigido por el Prof. Hennessy.
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.
(CC) 1999-2006, 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.

Operando
fuente 2
a = b + c
add a, b, c
Mnemónico de
la instrucción
Operando
de destino
Operando
fuente 1
(C) 1999-2010, José M. Foces-Morán.
Instrucció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
fuente 2
Nemónico de
la instrucción
Operando
fuente 1
Operando
de destino
(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 (Interinstrucció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
$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.
4*$t0
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
LOAD
D
ALU
D
D
STORE
(CC) 1999-2006, José M. Foces-Morán.
D
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, $s2
add $t1, $s3, $s4
sub $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 aceptan registros como operandos.


No existe ninguna instrucción en la ISA que nos
permita sumar el contenido de una dirección de
memoria con el contenido de un registro.
Tanto los operandos fuente como el operando de
destino deben ser registros.
sub $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 de los sistemas
basados en MIPS (ii)
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 (load).
Cargar el otro dato en otro registro (load).
Efectuar la operación cuyo resultado se obtendrá en otro
registro (Aritmética-lógica).
Salvar el resultado en su dirección de memoria (store).
MIPS es una arquitectura load-store.
El tamaño de palabra de la ISA MIPS es 32 bits.
(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.
Ejemplo: Instrucción Load
Word lw

Una instrucción de lectura de una palabra de
32 bits (load word).
lw $t0, 8($s3)
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.
[repetición] 
lw $t0, 8($s3)
La word que se carga
Un dato presente en memoria,
en $t0 procede de
aunque denotemos un registro
La dirección de memoria
…y, una constante
0x1008.
¿Cuál es su dirección?
Dirección = $s3 + 8
Si $s3 contiene 0x1000, entonces
la 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:


Se usan dos formas de cargar esa word en un
registro:



D, D+1, D+2 y D+3.
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.
¡intel! 
lw $t0, 8($s3)
MEMORIA
PRINCIPAL
RUTA DE
DATOS
(PROCESADOR )
Contenidos
de la
memoria
31
0x1c
0x8d
0x27
Byte-bajo
0x3f
0x27
0x8d
0x1008
0x1009
0x100a
0x1c
0x100b
...
0x3f
+
$t0
B
d ire u s d
e
cc
i on
es
0
0x
00
00
10
00
...
Bu
sd
ed
at o
s
Byte-alto
Dirección
de memoria
8
Ss3
(CC) 1999-2006, José M. Foces-Morán.
Byte bajo
lw $t0, 8($s3) ¡MIPS!
MEMORIA
PRINCIPAL
RUTA DE
DATOS
(PROCESADOR )
Contenidos
de la
memoria
31
0x3f
0x27
0x8d
Byte-bajo
0x3f
0x27
0x8d
0x1008
0x1009
0x100a
0x1c
0x100b
...
0x1c
+
$t0
B
d ire u s d
e
cc
i on
es
0
0x
00
00
10
00
...
Bu
sd
ed
at o
s
Byte-alto
Dirección
de memoria
8
Ss3
(CC) 1999-2006, José M. Foces-Morán.
Byte alto
La instrucción sw: store word.
LOAD: lw
D
ALU
D
D
STORE: sw
(CC) 1999-2006, José M. Foces-Morán.
D
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 donde
se salvará el contenido de $t0
El registro cuyo contenido
se 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[8];




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 h al registro $s2., por ejemplo.
$s3 contiene la dirección de memoria que es la base del array llamado 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[8];




Calcular la dirección donde está A[8]

$s3 contiene la dirección base del array A[]

8 x 4 = 32

4bytes/word, $s3(32) representa la dirección del entero 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[]
0($s3) “apunta a” A[0]
4($s3) “apunta a” A[1]
8($s3) “apunta a” A[2]
12($s3) “apunta a” A[3] 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 h al registro $s2, como en el ejemplo precedente.
$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 * 2
add $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[i];

Formamos la dirección de memoria de A[i]:

add $t2, $t1, $s3
Dirección de memoria de A[i]





(i * 4)
A[]
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
(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];
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:
(CC) 1999-2006, José M. Foces-Morán.
Etiquetas de datos y código en
SPIM.
Explicad qué operación lleva a cabo este programa:
.data
Astart:
.word
.word
.word
.word
0x00000060,
0x00000010,
0x00000000,
0x30303030,
0x00000050, 0x00000040
0x00000000
0x10101010, 0x20202020
0x40404040
.text
.globl main
main: la $t0, Astart
li $t1, 4
move $t2, $zero
siguiente:
lw $s0, 0($t0)
beq $s0, $zero, es_cero
add $t2, $t2, $s0
add $t0, $t0, $t1
j 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.
Este enfoque no es correcto
if (i == j)
goto fuera;
else
f = g + h;
El enfoque siguiente es el correcto:
emplear estructuras de programación
if (i != j){
f = g + h;
}
f = f – i;
fuera: f = f – i;
(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.
Representación binaria de la
instrucción add [Una instrucción del tipo
R]
Código
fuente
add $t0, $s1, $s2
Código
Objeto
(CC) 1999-2006, José M. Foces-Morán.
Formato binario de la instrucción
lw
[Una instrucción del tipo I].
Código
fuente
lw $t0, ($s1)32
Código
Objeto
(CC) 1999-2006, José M. Foces-Morán.
Formato Binario De La
Instrucción sw
[Una Instrucción Del Tipo I].
sw $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 sección:
Dos principios 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
condicional

Flujo de ejecución secuencial:



Salto a la dirección 32000:


1024, 1028, 32000…
beq $t0, $t1, destino0



PC <- PC + 4
1000, 1004, 1008, 1012,…
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.
Compilación De Una Estructura
if-then-else (II)
if (i == j)
f = g + h;
else
f = g – h;

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:...
(CC) 1999-2006, José M. Foces-Morán.
if-then-else
con bne
Secuencial
alternativa
Etiqueta
Exit
Secuencial
.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)
# ?
bne $t0, $t1, else
add $t4, $t2, $t3
j exit
else:
sub $t4, $t2, $t3
exit: sw $t4, 0($t7)
# El programa continúa…
(CC) 1999-2006, José M. Foces-Morán.
if-then-else
con beq
Secuencial
alternativa
Etiqueta
Exit
.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
Secuencial
(CC) 1999-2006, José M. Foces-Morán.
beq:
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 = 0;
Falso
¿j != 100?
Verdadero
Bloque de
Instrucciones
Evalúa j, ejemplo:
j = j + 5;
Etiqueta
Exit
(CC) 1999-2006, José M. Foces-Morán.
Estructura
repetitiva while:
Ejemplo.
j = 0;
Etiqueta
.data
j: .word 0x00000000
.text
.globl main
bucle_while
Falso
¿j != 100?
Verdadero
Bloque de
Instrucciones
Evalúa j, ejemplo:
j = j + 5;
Etiqueta
Exit
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…
(CC) 1999-2006, José M. Foces-Morán.
Compilación de un 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){
i = i + 1;
}
}
(CC) 1999-2006, José M. Foces-Morán.
F
¿vector[i] == k?
V
i = i + 1;
Bucle
while:
Ejemplo 2.
F
¿vector[i] == k?
V
i = i + 1;
int main(){
const int k = 1, i = 0;
static int vector[]={
1, 1, 1,
1, 1, 0,
0, 0, 1 };
while(vector[i] == k){
i = i + 1;
}
.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 # 2i
add $t1, $t1, $t1 # 4i
add $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
};
F
¿vector[i]==k?
V
int i = 0, j = 2, k = 1;
i = i + j;
while (vector[i] == k){
i = i + j;
}
}
(CC) 1999-2006, José M. Foces-Morán.
Compilación de un bucle while
Ejemplo 3.
Asumimos que:

i, j, k $s3, $s4, $s5

vector[]$s6
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
};

1.
int i = 0, j = 2, k = 1;
while (vector[i] == k){
i = i + j;
}
La dirección de comienzo del array vector
se encuentra en $s6.
Cargar el elemento vector[i] en un
registro temporal:
#Etiqueta de comienzo del bucle:
inicio_while:
add $t1, $s3, $s3 #i*2
add $t1, $t1, $t1 #i*4
add $t1, $t1, $s6 #vector+4*i
lw $t0, 0($t1)
#$t0  save[i]
}
(CC) 1999-2006, José M. Foces-Morán.
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
};

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
bne $t0, $s5, fin_while
3. Bloque falso (con respecto a bne):
int i = 0, j = 2, k = 1;
add $s3, $s3, $s4 ; i = i+j;
while (vector[i] == k){
i = i + j;
}
}
4. Saltar al comienzo:
j inicio_while
fin_while: ...
...
(CC) 1999-2006, José M. Foces-Morán.
; Resto del programa
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
};
F
¿vector[i]==k?
V
int i = 1, j = 2, k = 1;
i = i + j;
while (vector[i] == k){
i = i + j;
}
}
(CC) 1999-2006, José M. Foces-Morán.
Compilación de un bucle while,
Ejemplo 3.
inicio_while:
add $t1, $s3, $s3
add $t1, $t1, $t1
add $t1, $t1, $s6
lw $t0, 0($t1)
BNE
Branch if
NonEqual
$t0 = $s5
bne $t0, $s5, fin_while
add $s3, $s3, $s4
j inicio_while
fin_while:
(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.
$s0 >= $s1, $t0 = 0
...
...
slt $t0, $ s0, $ s1
bne $t0, $zero, less
...
...
...
less:
...
...
...
(CC) 1999-2006, José M. Foces-Morán.
$s0 < $s1, $t0 = 1
Compilar una estructura switch
usando una tabla de saltos.
switch (k) {
case 0:
f = i +
break;
case 1:
f = g +
break;
case 2:
f = g –
break;
case 3:
f = i –
break;

j;
h;
Según el valor de k, se
ejecuta una sentencia-bloque
diferente.


h;
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 ( } ).
j;
}
(CC) 1999-2006, José M. Foces-Morán.
$t0
L1
switch:
estrategia
jr $t0
inst
inst
inst
inst
$t4=JumpTable
inst
inst
Address
inst
j Exit
inst
inst
inst
k= 0
k
k=1
k=2
k=3
inst
L0
inst
L1
inst
L2
inst
L2
j Exit
inst
inst
inst
inst
j Exit
inst
inst
inst
Exit
inst
inst
inst
inst
(CC) 1999-2006, José M. Foces-Morán.
switch: k fuera de rango.
switch (k) {
case 0:
f = i +
break;
case 1:
f = g +
break;
case 2:
f = g –
break;
case 3:
f = i –
break;

j;

h;
h;
j;
slt
bne
slt
beq
}
(CC) 1999-2006, José M. Foces-Morán.
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
$t3,
$t3,
$t3,
$t3,
$s5, $zero
$zero, Exit
$s5, $t2
$zero, Exit
switch: k es el índice de una
tabla de saltos.
switch (
k) {
case 0:
f = i +
break;
case 1:
f = g +
break;
case 2:
f = g –
break;
case 3:
f = i –
break;


j;
Tabla = Array, en este caso.
Cada elemento de la tabla
es una dirección de salto.

h;
Es una cantidad de 32 bits = 4
bytes.


h;
j;

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 + 4k
}
(CC) 1999-2006, José M. Foces-Morán.
switch: 4 x k
k) {

switch (
case 0:
f = i +
break;
case 1:
f = g +
break;
case 2:
f = g –
break;
case 3:
f = i –
break;
}
JumpTable + 4k
$s5 = k

4  k:
add $t1, $s5, $s5
add $t1, $t1, $t1

j;
h;
h;
$t4 contiene JumpTable

JumpTable + 4  k :
add $t1, $t1, $t4


j;
Cargar el salto correspondiente
a k en $t0:
lw $t0, ($t1)0
(CC) 1999-2006, José M. Foces-Morán.
¡En $t0 tenemos
la dirección de
salto!
switch: saltar a la “dirección
de salto”
switch (
k) {
case 0:
f = i +
break;
case 1:
f = g +
break;
case 2:
f = g –
break;
case 3:
f = i –
break;

j;
$t0 contiene la dirección de
salto.

¿Cómo saltar a una dirección
contenida en un registro?

h;

h;
j;
Una instrucción de salto
incondicional nueva :
“jump through register”
jr $Registro
jr $t0
}
(CC) 1999-2006, José M. Foces-Morán.
;Así de fácil
switch: El resto del código
es... directo.
k) {
switch (
case 0:
f = i +
break;
case 1:
f = g +
break;
case 2:
f = g –
break;
case 3:
f = i –
break;
}
j;
h;
h;
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
...
j;
Esta obra está bajo una licencia AttributionShareAlike 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.
Descargar

Capítulo 3. Arquitectura Del set De Instrucciones