capitulo 3 instituto politÉcnico nacional centro de investigacion en computacion laboratorio de...
TRANSCRIPT
Capitulo
3
INSTITUTO POLITÉCNICO NACIONALCENTRO DE INVESTIGACION EN COMPUTACION
LABORATORIO DE MICROTECNOLOGÍA Y SISTEMAS EMBEBIDOS Grupo de Arquitectura de Computadoras y Sistemas Embebidos
Arquitecturas de ComputadorasCurso Propedéutico
Programación a nivel de máquina IProgramación en lenguaje ensamblador
Dr. Marco Antonio Ramírez SalinasDr. Herón Molina Lozano
Capitulo
3
2
Programación a nivel de máquinaLenguaje Ensamblador
Introducción:
Para dar ordenes al hardware una computadora, debes hablar su idioma. Las palabras de un lenguaje de máquina se llaman instrucciones y su vocabulario se llama conjunto de instrucciones de la arquitectura (ISA). En este capitulo se aprenderá el diseño y uso de un conjunto de instrucciones de una máquina real, en la forma escrita por las personas y en la forma que la maquina “entiende”.
Capitulo 3
Capitulo
3
3
El modelo de ejecución Capitulo 3
Estado Visible por el programador: PC: Contador de programa-dirección de la próxima instrucciónBanco de Registros: -Fuertemente usado por los datos de programa.Códigos de condición-Almacena información de estado de las operaciones realizadas recientemente.
Memoria: -Arreglo accesible por bytesCódigo, datos de usuario, datos de S.O.-Pila (Stack): memoria utilizada para soportar procedimientos
CPU
Banco de Registros
CODIGOSDE CONDICION
GENERADOR DE
DIRECCIONESPC
MEMORIA
CODIGO OBJETO
DATOS DE PROGRAMA
DATOS DE SISTEMA OPERATIVO
PILA(STACK)
DIRECCIONES
INSTRUCCIONES
DATOS
Capitulo
3
4
Convirtiendo código C a código objeto Capitulo 3
Programa en Lenguaje C (p1.c, p2.c)
Programa en Lenguaje Ensamblador (p1.s, p2.s)
Programa Objeto (p1.o, p2.o)
Programa Ejecutable (p1, p2)
LibreríasEstáticas
(*.a)
Compilador
Ensamblador
Ligador
Texto
Texto
Binario
Binario
Código: archivos de texto Compila con el comando:-gcc p1.c, p2.c -o p.exeOptimizaciones: - O-O0:-O1:-O2:Enlace (Link)-Enlaza programas p1.o, p2.o con librerías estáticas.Salida (-o p.exe)-Pone el programa binario en el archivo p.exe
.
Capitulo
3
Características del lenguaje ensamblador
Tipos de datos reducido:•Datos de enteros de 1, 2 ó 4 bytes
• Valores de datos• Direcciones (apuntadores sin tipo)
•Datos de Punto Flotante 4, 8 ó 16 bytes•No agrega tipos como arreglos o estructuras•Asigna bytes en direcciones contiguas de memoria
¡El programador tiene el control total de la máquina!
5
Capitulo
3
6
Características del lenguaje ensamblador
Operaciones primarias:•Realiza funciones aritméticas sobre valores almacenados en registros o sobre valores almacenados en memoria.
• ADD, SUB, MUL, etc.
• Transfiere datos entre registros y memoria• Carga datos de memoria a registros (LOAD)• Almacena datos de registros en Memoria (STORE)
•Transfiere el control del programa• Saltos incondicionales hacia/desde procedimientos• Saltos condicionales
Capitulo
3
Conjunto de instrucciones de la arquitectura
Cuando se diseñaron los primeros procesadores, una manera de diseño consistía en agregar mas y mas instrucciones a los CPU’s para elaborar tareas complicadas Por ejemplo, la arquitectura de una VAX tiene
instrucciones inclusive para multiplicar polinomios Por otro lado, la filosofía de las computadoras RISC (Cocke
IBM, Patterson, Hennessy, 1980’s-Reduced Instruction Set Computing) que tienen un Conjunto Reducido de Instrucciones para Cálculo tienen las siguientes características: Mantiene el conjunto de instrucciones pequeño y
sencillo, de manera que se hace fácil el diseño de hardware rápido
Se le deja al software realizar operaciones complicadas por medio de la composición de instrucciones simples
Capitulo
3
Arquitectura del MIPS
El procesador MIPS fue una de las primeras arquitecturas que estaban disponibles comercialmente
¿Por qué estudiar el MIPS en vez del procesador Intel x86? MIPS es simple y elegante. No es
necesario entrar con tanto detalle con instrucciones que posiblemente ni siquiera se utilicen nunca
MIPS es ampliamente utilizado en dispositivos embebidos, los x86son poco utilizados en sistemas embebidos, y existen más computadoras embebidas
Capitulo
3
Registros (1/4)
A diferencias de los lenguajes de alto nivel como C o Java, el lenguaje ensamblador no utiliza variables ¿Por qué no? Esto hace que el hardware sea
simple Los operadores ensamblados son registros
Hay un número limitado de localidades especiales que son construidas directamente en hardware
Las operaciones sólo se pueden realizar en estos registros
Beneficios: Debido a que los registros se encuentran directamente en hardware, son muy rápidos
Capitulo
3
Registros (2/4)
Desventajas: Debido a que los registros se encuentran en hardware, hay un número predeterminado de ellos Hay una solución: El código del MIPS debe ser
cuidadosamente programado para un uso eficiente de registros
Existen 32 registros en el MIPS ¿Por qué 32? Mientras más pequeño más rápido
A su vez, cada registro del MIPS tiene un ancho de 32 bits Grupos de 32 bits es llamado palabra en el MIPS
Capitulo
3
Registros (3/4)
Los registros son numerados del 0 al 31
Cada registro puede ser referido por su número o por su nombre
Por ejemplo, referencias numéricas:$0, $1, $2, …, $30, $31
Capitulo
3
Registros (4/4)
Por conveniencia, cada registro tiene un nombre para hacerlo fácil de codificar y recordar
Por ahora para nosotros: $16 A $ 23 equivalen a los registros $s0 a $s7
( y que corresponde a variables en C) $8 A $15 equivalen a $t0 a $t7
(que corresponden a variables temporales) Posteriormente veremos los nombres de los otros
registros En general, se utilizan nombres para que el
código sea más entendible
Capitulo
3
Variables en C y Java vs. registros
En C (y la mayoría de los lenguajes de alto nivel) las variables se declaran al principio y se les asigna un tipo Ejemplo: int fahr, celsius; char a, b, c, d e;
Cada variable puede SÓLO representar un valor del tipo con el que fue declarado (no se puede mezclar y empatar las variables int y char)
En lenguaje ensamblador, los registros no tienen tipo; el tipo de operación determina como el contenido de los registros es tratado
Capitulo
3
Comentarios sobre lenguaje ensamblador
Otra forma de hacer que el código ensamblador sea más entendible es utilizar comentarios
El símbolo de gato (hash) # es utilizado por MIPS para realizar comentarios Cualquier expresión después de # hasta el fin de esa
línea es un comentarios y será ignorado Esto es igual que si se utilizará en C99 el símbolo //
Nota: Diferencias respecto a C C también tiene el formato /* … */ para realizar comentarios De forma que se pueden incluir varias líneas
Capitulo
3
Instrucciones en ensamblador
En lenguaje ensamblador cualquier expresión (llamada instrucción), ejecuta exactamente un comando de una lista corta de éstos.
A diferencia de C (y la mayoría de los lenguajes de alto nivel), cada línea de código ensamblado contiene al menos 1 instrucción
Las instrucciones están relacionadas con las operaciones (=, +, -, , /) en C o en Java
Veamos ahora algunos ejemplos para MIPS
Capitulo
3
Suma y resta en el MIPS (1/4)
Sintaxis de las instrucciones:1 2, 3, 4 Donde:1) nombre de la operación2) operando donde se obtiene el resultado
(“destino”)3) 1er operando de la operación (“fuente 1”)4) 2do operando de la operación (fuente 2”)
La sintaxis es rígida: i.e. 1 operador, 3 operandos ¿Por qué? Mantiene al hardware simple debido a la
regularidad
Capitulo
3
Suma y resta en el MIPS (2/4)
Suma en ensamblador Ejemplo: add $s0, $s1, $s2 (en MIPS) Equivale a: a = b + c (en C) Donde los registros del MIPS $s0, $s1 y $s2 están
asociados a C con las variables a, b y c respectivamente
Resta en ensamblador Ejemplo: sub $s3, $s4, $s5 (en MIPS) Equivale a: d = e – f ( en C) Donde los registros del MIPS $s3, $s4 y $s5 están
asociados a C con las variables d, e y f respectivamente
Capitulo
3
Suma y resta en el MIPS (3/4)
¿Cómo se implementa la siguiente instrucción de C a MIPS?
a = b +c + d – e; La instrucción se divide en múltiples
instrucciones add $t0, $s1, $s2 # temp = b + c add $t0, $t0, $s3 # temp = temp + d add $s0, $st0, $s4 # a = temp – e
Hay que notar que una sóla línea en C puede dividirse en varias instrucciones en MIPS
Además, todo aquello después del # en cada línea es ignorado
Capitulo
3
Suma y resta en el MIPS (4/4)
¿Cómo se implementa la siguiente instrucción?
f = (g + h) – (i + j); Se utilizan registros intermedios
add $t0, $s1, $s2 # temp = g + hadd $t1, $s3, $s4 # temp = i + jsub $s0, $t0, $t1 # f = (g + h) – (i + j)
Capitulo
3
Registro cero
Un valor inmediato particular, el número cero (0), aparece en MIPS constantemente
De manera que se ha definido un registro cero ($0 o $zero) y que siempre tiene el valor 0; e.g. add $s0, $s1, $zero (en MIPS) f = g (en C) Donde los registros del MIPS $s0 y $s1 están
asociados a C con las variables f y g De acuerdo con la definición anterior, la
instrucción: add $zero, $zero, $0
No realizaría nada
Capitulo
3
Valores inmediatos (1/3)
Los valores inmediatos son constantes numéricas
Aparecen constantemente en el código para los MIPS, de manera que son instrucciones especiales
Suma inmediata: addi $s0, $s1, 10 (en MIPS) f = g + 10; (en C) Donde los registros del MIPS $s0 y $s1 están
asociados a C con las variables f y g La sintaxis es similar a la instrucción add,
excepto que el último argumento es un número en vez de un registro
Capitulo
3
Valores inmediatos (2/3)
No existe una instrucción de resta inmediata en MIPS: ¿Por qué?
Existe un límite en el número de operaciones que pueden ser implementadas físicamente con el propósito de mantener un conjunto de instrucciones mínimo, además se ahorra en área de silicio Si la instrucción puede ser descompuesta e
implementada por otras operaciones que ya existen, entonces este tipo de instrucción (posiblemente subi) no se incluye
addi ., ., -X = subi ., ., X de manera que no existe subi
Capitulo
3
Valores inmediatos (3/3)
addi $s0, $s1, -10 (en MIPS)f = g – 10; (en C)Donde los registros del MIPS $s0
y $s1 están asociados a C con las variables f y g
Capitulo
3
Trivia
A. Los tipos están asociados con declaration en C (normalmente), pero están asociados con instrucciones (operadores) en MIPS
B. Debido a que hay solamente 8 registros locales ($s0-$s7) y 8 registros variables temporales ($t0-$t7), no podemos escribir en MIPS expresiones de lenguaje C que contengan más de 16 variables
C. Si p (almacenado en $s0) fuera un apuntador a un arreglo de enteros (ints), entonces p++; pudiera ser implementado con la instrucción en MIPS:
addi $s0, $s0, 1
Capitulo
3
Resumen
En el lenguaje ensamblador en MIPS: Los registros reemplazan a las variables en C Se tiene una instrucción (simple operación)
por línea Simple es mejor Más pequeño es más rápido Instrucciones nuevas vistas: add, addi, sub Nuevos registros Variables en C: $s0 - $s7 Variables temporales: $t0 - $t7 Cero: $0 ó $zero
Capitulo
3
MIPS: lectura y almacenamiento, decisión
Capitulo
3
Ensamble de operandos: Memoria
Las variables en lenguaje C se mapean hacía registros; ¿Qué sucederá con estructuras de datos grandes como los arreglos?
En 1 de los 5 componentes principales de la computadora en este caso la memoria, contiene tales estructuras de datos
Sin embargo en el caso de los MIPS las instrucciones aritméticas sólo operan sobre registros, nunca directamente sobre la memoria
Las instrucciones de transferencia de datos se realiza entre registros y memoria: De memoria a registros De registros a memoria
Capitulo
3
Anatomía: los 5 componentes de cualquier computadora
PC
Procesador
Computadora
Control(“cerebro”)
Pagtrón de datosRegistros
Memoria Despositivos
Entrada
SalidaCarga (desde)Carga (desde)
AlmacenamientoAlmacenamiento (hacía)(hacía)
Capitulo
3
Los registros se encuentran en el camino de datos del procesador; si los operandos se encuentran en memoria, se deben de transferir los datos para que el procesador opere sobre ellos, y entonces se vuelve a realizar la transferencia de nuevo a memoria
A continuación se presentan las instrucciones para transferencia de datos
Capitulo
3
Transferencia de datos: memoria a registros (1/4)
Para transferir palabras a datos se necesita especificar dos cosas:
Registros: se especifican por medio de ($0-$31) o con un nombre simbólico
Dirección de memoria: es más difícil de indicar Hay que pensar en la memoria como un arreglo
de una sóla dimensión, de manera que se pueda direccionar de manera sencilla por medio de un apuntador a una dirección de memoria
En otras ocasiones, se debe de ser capaz de realizar un desplazamiento (offset) a partir de este apuntador
Recordar: “leer (cargar) desde la memoria”
Capitulo
3
Transferencia de datos: memoria a registros (2/4)
Para especificar a una dirección de memoria para copiar datos; se especifican dos valores: Un registro que contenga un apuntador a
memoria Una desplazamiento (en bytes)
La dirección de memoria deseada es la suma de estos dos valores
Ejemplo: 8($t0) Especifica la dirección de memoria a la que se
apunta a partir de valor en $t0, más 8 bytes
Capitulo
3
Transferencia de datos: memoria a registros (3/4)
Sintaxis para la instrucción de lectura 1 2, 3(4) Donde
1. Es el nombre de la operación
2. Registro que recibirá el valor
3. Corrimiento numérico en bytes
4. Registro que contiene el apuntador a memoria Nombre de la instrucción para el MIPS:
lw (significa “load word” (carga de palabra), de manera que se cargan 32 bits o una palabra a la vez)
Capitulo
3
Transferencia de datos: memoria a registros (4/4)
Ejemplo: lw $t0, 12($s0) Esta instrucción tomará el apuntador en $s0, se le
sumarán los 12 bytes, y se cargará el valor el valor de la localidad de memoria a la que se apunta hacía el registro $t0
Notas: $s0 Es llamado registro base El valor 12 será llamado corrimiento El corrimiento se utiliza generalmente para accesar
elementos del arreglo o de la estructura: el registro base apunta al comienzo del arreglo o de la estructura (hay que notar el corrimiento debe de ser una constante conocida al momento de que se ensambla el programa)
Flujo de Datos
Capitulo
3
Transferencia de datos: registro a memoria (1/2)
También se desea almacenar desde un registro hacía una localidad de memoria La sintaxis de la instrucción de escritura
(almacenamiento) es idéntica a la de lectura Nombre de la instrucción para el MIPS:
sw (que significa “store word” (almacenar palabra), de manera que 32 bits o una palabra se almacena a a la vez
Capitulo
3
Transferencia de datos: registro a memoria (2/2)
Ejemplo: sw $t0, 12($s0) Esta instrucción tomará el apuntador en $s0,
le sumará 12 desplazamientos (bytes), y almacenará el valor del registro $t0 hacía la dirección de memoria
Hay que recordar: “Almacenar haciá la memoria”
Flujo de Datos
Capitulo
3
Apuntadores vs. valores
Concepto clave: un registro puede tener cualquier valor de 32 bits. Ese valor puede ser (con signo) int, un unsigned int, un apuntador (a dirección de memoria), entre otros Si se escribe add $t2, $t1, $t0 entonces $t0 y $t1 lo mejor será que tengan valores
a sumar Si se escribe lw $t2, 0($t0) entonces $t0 deberá tener un apuntador
No hay que confundir los conceptos
Capitulo
3
Direccionamiento: bytes vs. palabra
Cada palabra en memoria tiene una dirección, que es similar a un índice en un arreglo:
memoria[0], memoria[1], memoria[2], …
Llamada la dirección de la palabra Las computadoras necesitan un acceso de 8 bits
(bytes) así como a palabras (4 bytes por palabra)
Actualmente la dirección de memoria de las máquinas como bytes (i.e., “direccionamiento por bytes”) es de 32 bits (4 bytes) direcciones por palabra diferida por 4
memoria[0], memoria[4], memoria[8], …
Capitulo
3
Compilación con memoria
¿Qué valor de corrimiento en lw se debe de tener para seleccionar A[5] en C?
El corrimiento será 45 = 20 para seleccionar A[5]: byte vs. Palabra
Compilar a mano utilizando los registros: g = h + A[5];
g: $s1, h: $s2, $s3: Dirección base de A
1ra. Transferencia de memoria al registro: lw $t0, 20($s3) # $t0 obtiene A[5]
Suma 20 a $s3 para seleccionar A[5], y colocar en $t0 A continuación añadirlo a h y colocarlo en g
add $s1, $s2, $t0 # $s1 = h + A[5]
Capitulo
3
Notas sobre la memoria
Error: Al olvidar que una palabra secuencial direcciona en máquina con un direccionamiento de 1 byte no difiere de 1 Muchos programadores de lenguaje
ensamblador han trabajado sobre errores hechos bajo el supuesto que la dirección de la siguiente palabra puede encontrarse incrementando la dirección de un registro en 1 byte en vez del tamaño de palabra en bytes
Por lo tanto, hay que recordar que tanto para lw y sw la suma de la dirección base y el corrimiento debe de ser múltiplo de 4 (para que quede alineado con la palabra)
Capitulo
3
Más notas sobre memoria: alineamiento
MIPS requiere que todas las palabras comiencen en un byte de dirección que sea múltiplo de 4 bytes
Llamado alineamiento: los datos deben caer en una dirección que sea múltiplo de su tamaño
0 1 2 3
Alineado
NoAlineado
0, 4, 8, or Chex
Último dígito hex. de la dir. es:
1, 5, 9, or Dhex
2, 6, A, or Ehex
3, 7, B, or Fhex
Capitulo
3
El rol de los registros vs. memoria
¿Qué pasa si hay más variables que registros? El compilador trataría de mantener las variables más
utilizadas en los registros Menos común en memoria: derramamiento (spilling)
¿Por qué no mantener todas las variables en memoria? Mientras más pequeña más rápida: los registros son
más rápidos que la memoria Los registros son más versátiles:
Las instrucciones aritméticas del MIPS pueden leer 2 operadores, y escribir 1 registro por instrucción
La transferencia de datos del MIPS permite leer o escribir 1 operando por instrucción, sin operación
Capitulo
3
Trivia
Se desea trasladar *x = *y; hacia MIPS Los apuntadores, ya se encuentran en: $s0,
$s1 ¿Qué instrucciones se deben utilizar?
1.A: add $s0, $s1, zero2.B: add $s1, $s0, zero3.C: lw $s0, 0($s1)4.D: lw $s1, 0($s0)5.E: lw $t0, 0($s1)6.F: sw $t0, 0($s0)7.G: lw $s0, 0($t0)8.H: sw $s1, 0($t0)
Capitulo
3
Ejemplo
Se desea realizar lo siguiente:int x = 5;*p = *p + x + 10;
En MIPS (asumiendo que $s0 tiene a p, $s1 es x)
addi $s1,$0,5 # x = 5
lw $t0,0($s0) # temp = m[*p]
add $t0,$t0,$s1 # temp+= x
addi $t0,$t0,10 # temp+= 10
sw $t0,0($s0) # m[*p]= temp
Capitulo
3
Leyendo y guardando bytes (1/2)
De manera adicional a la transferencia de datos de palabras (lw, sw), MIPS realiza transferencia de bytes:
Leer un byte: lb Guardar un byte: sw Tiene el mismo formato que lw y sw E.g., lb $s0, 3($s1)
El contenido de la localidad de memoria con la dirección = suma de “3” más el contenido del registro s1 se copia a la posición de la parte baja del byte del registro s0
Capitulo
3
Leyendo y almacenando bytes (2/2)
¿Qué hacer con los otros 24 bits en un registro de 32 bits?
lb: extiende el signo hasta llenar los 24 bits
Normalmente no se desea extender el signo de un carácter (char)
Existe una instrucción del MIPS que no extiende el signo cuando se leen bytes:
Leer byte sin signo: lbu
xbytecargado…se copia para “extender el signo”
Este bit
xxxx xxxx xxxx xxxx xxxx xxxx zzz zzzz
Capitulo
3
Hasta ahora
Todas las instrucciones hasta ahora sólo manipulan datos…por lo que hemos construido una calculadora
A fin de construir una computadora, se necesita la habilidad de hacer decisiones…
C (y MIPS) tienen etiquetas que soportan la instrucción “goto” y saltar a algún lugar en el código del programa
En C: sería un estilo horrible: ¡en MIPS es necesario!
Capitulo
3
MIPS: lectura y almacenamiento, decisión
Capitulo
3
Ensamble de operandos: Memoria
Las variables en lenguaje C se mapean hacía registros; ¿Qué sucederá con estructuras de datos grandes como los arreglos?
En 1 de los 5 componentes principales de la computadora en este caso la memoria, contiene tales estructuras de datos
Sin embargo en el caso de los MIPS las instrucciones aritméticas sólo operan sobre registros, nunca directamente sobre la memoria
Las instrucciones de transferencia de datos se realiza entre registros y memoria: De memoria a registros De registros a memoria
Capitulo
3
Anatomía: los 5 componentes de cualquier computadora
PC
Procesador
Computadora
Control(“cerebro”)
Pagtrón de datosRegistros
Memoria Despositivos
Entrada
SalidaCarga (desde)Carga (desde)
AlmacenamientoAlmacenamiento (hacía)(hacía)
Capitulo
3
Los registros se encuentran en el camino de datos del procesador; si los operándos se encuentran en memoria, se deben de transferir los datos para que el procesador opere sobre ellos, y entonces se vuelve a realizar la transferencia de nuevo a memoria
A continuación se presentan las instrucciones para transferencia de datos
Carga y Almacenamiento
Capitulo
3
Transferencia de datos: memoria a registros (1/4)
Para transferir palabras a datos se necesita especificar dos cosas:
Registros: se especifican por medio de # ($0-$31) o con un nombre simbólico
Dirección de memoria: es más difícil de indicar Hay que pensar en la memoria como un arreglo
de una sóla dimensión, de manera que se pueda direccionar de manera sencilla por medio de un apuntador a una dirección de memoria
En otras ocasiones, se debe de ser capaz de realizar un desplazamiento (offset) a partir de este apuntador
Recordar: “leer (cargar) desde la memoria”
Capitulo
3
Transferencia de datos: memoria a registros (2/4)
Para especificar a una dirección de memoria para copiar datos; se especifican dos valores: Un registro que contenga un apuntador a
memoria Una corrimiento (en bytes)
La dirección de memoria deseada es la suma de estos dos valores
Ejemplo: 8($t0) Especifica la dirección de memoria a la que se
apunta a partir de valor en $t0, más 8 bytes
Capitulo
3
Transferencia de datos: memoria a registros (3/4)
Sintaxis para la instrucción de lectura 1 2, 3(4) Donde
1. Es el nombre de la operación
2. Registro que recibirá el valor
3. Corrimiento numérico en bytes
4. Registro que contiene el apuntador a memoria Nombre de la instrucción para el MIPS:
lw (significa “load word” (carga de palabra), de manera que se cargan 32 bits o una palabra a la vez)
Capitulo
3
Transferencia de datos: memoria a registros (4/4)
Ejemplo: lw $t0, 12($s0) Esta instrucción tomará el apuntador en $s0, se le
sumarán los 12 bytes, y se cargará el valor el valor de la localidad de memoria a la que se apunta hacía el registro $t0
Notas: $s0 Es llamado registro base El valor 12 será llamado corrimiento El corrimiento se utiliza generalmente para accesar
elementos del arreglo o de la estructura: el registro base apunta al comienzo del arreglo o de la estructura (hay que notar el corrimiento debe de ser una constante conocida al momento de que se ensambla el programa)
Flujo de Datos
Capitulo
3
Transferencia de datos: registro a memoria (1/2)
También se desea almacenar desde un registro hacía una localidad de memoria La sintaxis de la instrucción de escritura
(almacenamiento) es idéntica a la de lectura Nombre de la instrucción para el MIPS:
sw (que significa “store word” (almacenar palabra), de manera que 32 bits o una palabra se almacena a a la vez
Capitulo
3
Transferencia de datos: registro a memoria (2/2)
Ejemplo: sw $t0, 12($s0) Esta instrucción tomará el apuntador en $s0,
le sumará 12 bytes, y almacenará el valor del registro $t0 hacía la dirección de memoria
Hay que recordar: “Almacenar haciá la memoria”
Flujo de Datos
Capitulo
3
Apuntadores vs. valores
Concepto clave: un registro puede tener cualquier valor de 32 bits. Ese valor puede ser (con signo) int, un unsigned int, un apuntador (a dirección de memoria), entre otros Si se escribe add $t2, $t1, $t0 entonces $t0 y $t1 lo mejor será que tengan valores
a sumar Si se escribe lw $t2, 0($t0) entonces $t0 deberá tener un apuntador
No hay que confundir los conceptos
Capitulo
3
Direccionamiento: bytes vs. palabra
Cada palabra en memoria tiene una dirección, que es similar a un índice en un arreglo:
memoria[0], memoria[1], memoria[2], …
Llamada la dirección de la palabra Las computadoras necesitan un acceso de 8 bits
(bytes) así como a palabras (4 bytes por palabra)
Actualmente la dirección de memoria de las máquinas como bytes (i.e., “direccionamiento por bytes”) es de 32 bits (4 bytes) direcciones por palabra diferida por 4
memoria[0], memoria[4], memoria[8], …
Capitulo
3
Compilación con memoria
¿Qué valor de corrimiento en lw se debe de tener para seleccionar A[5] en C?
El corrimiento será 45 = 20 para seleccionar A[5]: byte vs. Palabra
Compilar a mano utilizando los registros: g = h + A[5];
g: $s1, h: $s2, $s3: Dirección base de A
1ra. Transferencia de memoria al registro: lw $t0, 20($s3) # $t0 obtiene A[5]
Suma 20 a $s3 para seleccionar A[5], y colocar en $t0 A continuación añadirlo a h y colocarlo en g
add $s1, $s2, $t0 # $s1 = h + A[5]
Capitulo
3
Notas sobre la memoria
Error: Al olvidar que una palabra secuencial direcciona en máquina con un direccionamiento de 1 byte no difiere de 1 Muchos programadores de lenguaje
ensamblador han trabajado sobre errores hechos bajo el supuesto que la dirección de la siguiente palabra puede encontrarse incrementando la dirección de un registro en 1 byte en vez del tamaño de palabra en bytes
Por lo tanto, hay que recordar que tanto para lw y sw la suma de la dirección base y el corrimiento debe de ser múltiplo de 4 (para que quede alineado con la palabra)
Capitulo
3
Más notas sobre memoria: alineamiento
MIPS requiere que todas las palabras comiencen en un byte de dirección que sea múltiplo de 4 bytes
Llamado alineamiento: los datos deben caer en una dirección que sea múltiplo de su tamaño
0 1 2 3
Alineado
NoAlineado
0, 4, 8, or Chex
Último dígito hex. de la dir. es:
1, 5, 9, or Dhex
2, 6, A, or Ehex
3, 7, B, or Fhex
Capitulo
3
El rol de los registros vs. memoria
¿Qué pasa si hay más variables que registros? El compilador trataría de mantener las variables más
utilizadas en los registros Menos común en memoria: derramamiento (spilling)
¿Por qué no mantener todas las variables en memoria? Mientras más pequeña más rápida: los registros son
más rápidos que la memoria Los registros son más versátiles:
Las instrucciones aritméticas del MIPS pueden leer 2 operadores, y escribir 1 registro por instrucción
La transferencia de datos del MIPS permite leer o escribir 1 operando por instrucción, sin operación
Capitulo
3
Trivia
Se desea trasladar *x = *y; hacia MIPS Los apuntadores a, y se encuentran en: $s0,
$s1 ¿Qué instrucciones se deben utilizar?
1.A: add $s0, $s1, zero2.B: add $s1, $s0, zero3.C: lw $s0, 0($s1)4.D: lw $s1, 0($s0)5.E: lw $t0, 0($s1)6.F: sw $t0, 0($s0)7.G: lw $s0, 0($t0)8.H: sw $s1, 0($t0)
Capitulo
3
Ejemplo
Se desea realizar lo siguiente:int x = 5;*p = *p + x + 10;
En MIPS (asumiendo que $s0 tiene a p, $s1 es x)
addi $s1,$0,5 # x = 5
lw $t0,0($s0) # temp = *p
add $t0,$t0,$s1 # temp += x
addi $t0,$t0,10 # temp += 10
sw $t0,0($s0) # *p = temp
Capitulo
3
Leyendo y guardando bytes (1/2)
De manera adicional a la transferencia de datos de palabras (lw, sw), MIPS realiza transferencia de bytes:
Leer un byte: lb Guardar un byte: sb Tiene el mismo formato que lw y sw E.g., lb $s0, 3($s1)
El contenido de la localidad de memoria con la dirección = suma de “3” más el contenido del registro s1 se copia a la posición de la parte baja del byte del registro s0
Capitulo
3
Leyendo y almacenando bytes (2/2)
¿Qué hacer con los otros 24 bits en un registro de 32 bits?
lb: extiende el signo hasta llenar los 24 bits
Normalmente no se desea extender el signo de un carácter (char)
Existe una instrucción del MIPS que no extiende el signo cuando se leen bytes:
Leer byte sin signo: lbu
xbytecargado…se copia para “extender el signo”
Este bit
xxxx xxxx xxxx xxxx xxxx xxxx zzz zzzz
Capitulo
3
Hasta ahora
Todas las instrucciones hasta ahora sólo manipulan datos…por lo que hemos construido una calculadora
A fin de construir una computadora, se necesita la habilidad de hacer decisiones…
C (y MIPS) tienen etiquetas que soportan la instrucción “goto” y saltar a algún lugar en el código del programa
En C: sería un estilo horrible: ¡en MIPS es necesario!
Capitulo
3
Decisión en C: declaraciones if
En C existen dos tipos declaración ifif (condición) clausulaif (condición) clausula1 else clausula2
Rearreglando la segunda forma de if tenemos:if (condición) goto L1;
clausula2;goto L2;
L1: clausula1;L2:
No es tan elegante como if-else, pero significa lo mismo
Capitulo
3
Instrucciones de decisión en MIPS
beq registro1, registro2, L2 beq es “brinca si (el registro es) igual”
Tiene el mismo significado que (utilizando C):if (registro1 ==registro2) goto L1
Instrucciones complementarias en MIPS para decisión: bne registro1, registro2, L1 bne es “brinca si (registros son) no iguales”
Tiene el mismo significado que (utilizando C):if (registro1 != registro2) goto L1
Llamados brincos condicionales
Capitulo
3
Instrucciones en MIPS para goto
De manera adicional a los brincos condicionales, MIPS tiene brincos incondicionalesj etiqueta
Llamada instrucción de salto: salta (o brinca) directamente a la etiqueta dada sin necesidad de ninguna condición
Mismo significado que (utilizando C): goto etiqueta Tecnicamente, es lo mismo que:
beq $0, $0, etiqueta Ya que siempre se satisface la condición
Capitulo
3
Compilado if de C a MIPS (1/2)
Compilado a manoif (i == j) f = g + h;else f = g – h;
Utilizando este mapeo:
f: $s0g: $s1h: $s2i: $s3j: $s4
Salida
i == j?
f=g+h f=g-h
(falso) i != j
(verdad) i == j
Capitulo
3
Compilado if de C a MIPS (2/2)
Compilado a manoif (i == j) f = g + h;else f = g – h;
Compilando en código MIPSbeq $s3, $s4, verdadsub $s0, $s1, $s2j FinVerdad: add $s0, $s1, $s2Fin:
Nota: el compilador crea las etiquetas automáticamente para manejar decisiones (brincos).
Generalmente no se encuentran en el código del lenguaje de alto nivel
Fin
i == j?
f=g+h f=g-h
(falso) i != j
(verdad) i == j
Capitulo
3
Sobreflujo en aritmética (1/2)
Recordaremos que: el sobreflujo ocurre cuando existe un error en la aritmética debido a la limitación en la precisión de la computadora
Ejemplo (números de 4 bits sin signo)
+15 1111 +3 +0011+18 10010
Pero no existe espacio para 5 bits la respuesta de la solución será 0010 que es +2, pero es una repuesta equivocada
Capitulo
3
Sobreflujo en aritmética (2/2)
Algunos lenguajes pueden detectar sobreflujo (como Ada), algunos no (como C)
La solución de MIPS es que existen dos tipos de instrucciones de aritmética que reconocen sobreflujo: Estas instrucciones causan que el sobreflujo sea detectadoSuma (add)Suma inmediata (addi)Resta (sub)
Estas instrucciones no causa que el sobreflujo sea detectadoSuma sin signo (addu)Suma inmediata sin signa (addiu)Resta sin signo (subu)
Los compiladores seleccionan la aritmética apropiada El compilador C a MIPS produce
addu, addiu, subiu
Capitulo
3
Instrucciones lógicas
Aquí hay dos nuevas instrucciones: Corrimiento a la izquierda: sll $s1, $s2, 2 # s1 =
s2<<2 En $s1 se almacena el valor de $s2 con un
corrimiento de 2 bits a la izquierda, se insertan 0’s a la derecha; es << in C Antes: 0000 0002hex
0000 0000 0000 0000 0000 0000 0000 0010two
Después: 0000 0008hex
0000 0000 0000 0000 0000 0000 0000 1000two
¿Qué efecto aritmético tiene corriemiento a la izquierda?Corrimiento a la derecha: srl y es opuesto al de la izquierda; >>
Capitulo
3
Repeticiones en C/ensamblador (1/3)
Una repetición simple en C; A[ ] es un arreglo de ints do{
g = g + A[i];i = i + j;
} while (i != h); Se rescribe como: repeticion: g = g + A[i];
i = i + j; if (i != h) goto repeticion;
Utilizando este mapeo: g, h, i, j, base de A $s1, $s2, $s3, $s4, $s5
Capitulo
3
Repeticiones en C/ensamblador (2/3)
Código final compilado en MIPS:Loop: sll $t1,$s3,2 #$t1= 4*i
add $t1,$t1,$s5 #$t1=sum regA lw $t1,0($t1) #$t1=A[i] add $s1,$s1,$t1 #g=g+A[i] add $s3,$s3,$s4 #i=i+j bne $s3,$s2,Loop# goto
# repeticion # if i!=h
Código originalrepeticion: g = g + A[i];
i = i + j; if (i != h) goto repeticion;
Capitulo
3
Repeticiones en C/ensamblador (3/3)
Hay tres tipos de repeticiones en C: while do... while for Cada uno se puede rescribir utilizando
cualquiera de los otros dos, de manera que el ejemplo utilizado en el ejemplo anterior puede ser aplicado a while y for también
Concepto clave: pensando que existen multiples formas de repeticiones en MIPS, la clave es el salto condicional
Capitulo
3
Desigualdades en MIPS (1/3)
Hasta ahora hemos probado con dos desigualdades (== y != en C). Generalmente los programas necesitan también probar < y >.
Instrucciones de desigualdades con MIPS:“Activar con menor que (set on less than)”Sintaxis: slt, reg1, reg2, reg3
Significado:if (reg2 < reg3)reg1 = 1;else reg1 = 0;
Computacionalmente “activar” significa “colocar a 1”, “reactivar” significa “colocar a 0”
Capitulo
3
Desigualdades en MIPS (2/3)
¿Cómo utilizamos esta instrucción? Compilado a mano:if (g < h) goto menor; #g: $s0, h: $s1
Respuesta: Compilando en código MIPS…slt $t0, $s0, $s1 # $t0 = 1 if g < hbne $t0, $s0, menor #goto menor
# if $t0 != 0 # (if (g < h)) menor:
Salta si $t0 != 0 (g < h) El registro $0 siempre contiene el valor 0, de manera
que bne y beq a menudo lo utilizan para realizar comparaciones después de la instrucción slt
El par de instrucciones slt bne significa ( … < …) goto …
Capitulo
3
Desigualdades en MIPS (1/3)
Ahora se puede implementar <, pero ¿cómo se podría implementar >, y ?
Se podría haber diseñado estas instrucciones e implementarlas en el MIPS pero recordaremos: simple es mejor
Se puede implementar utilizando uno o dos instrucciones utilizando slt y por medio de saltos.
Y acerca de > y
Capitulo
3
Desigualdades inmediatas
Existe también una versión inmediata de slt que es la instrucción: slti
Esta instrucción ayuda mucho para repeticiones tipo for En C: if (g 1) goto repeticion; En MIPS:
slti $t0, $s0, 1 # $t0 = 1 if # $s0 < 1 (g < 1)beq # goto repeticion # if $t0 == 0 # (if (g >= 1))
El par de instrucciones slt beq significa if (… …) goto…
Capitulo
3
¿Y qué sucede con los números sin signo?
También existen instrucciones de desigualdades sin signo:sltu, sltiu
… son instrucciones que activan un registro a 1 o 0 dependiendo de la comparación sin signo que se realice
¿Qué valores tendrán $t0 y $t1, si ($s0 = FFFF FFFAhex y $s1 = 0000 FFFAhex)?slt $t0, $s0, $s1sltu $t1, $s0, $s1
Capitulo
3
Instrucciones MIPS con signo y sin signo
¿Qué significado tiene las instrucciones del MIPS que manejan datos con signo y sin signo?
Las instrucciones signo vs. sin signo es un termino para manejo de “sobreflujo”
Extiende/no extiende signo(lb, lbu)
No realiza sobreflujo(addu, addiu, subu, multu, divu)
Comparación son/sin signo(slt, slti/sltu,sltiu)
Capitulo
3
Ejemplo: La instrucción switch en C (1/3)
Seleccionar entre cuatro alternativas depende de que la variable k tenga los valores 0, 1, 2 o 3
Compile este códigoswitch (k) {
case 0: f = i + j; break; /* k = 0*/case 1: f = g + h; break; /* k =
1*/case 2: f = g - h; break; /* k =
2*/case 3: f = i - j; break; /* k = 3/
}
Capitulo
3
Ejemplo: La instrucción switch en C (2/3)
Esto parece algo complicado de manera que simplifiquemos
Rescribiendo estas instrucciones como una cadena de instrucciones if-else, que con anterioridad conocemos:if(k==0) f=i+j; else if(k==1) f=g+h; else if(k==2) f=g–h; else if(k==3) f=i–j;
Utilizando este mapeo: f:$s0, g:$s1, h:$s2,
i:$s3, j:$s4, k:$s5
Capitulo
3
Ejemplo: La instrucción switch en C (3/3)
El código MIPS compilado será: bne $s5,$0,L1 # salta k!=0
add $s0,$s3,$s4 # k==0 asi que f=i+j j salida # termina caso salidaL1: addi $t0,$s5,-1 # $t0=k-1 bne $t0,$0,L2 # salta k!=1 add $s0,$s1,$s2 # k==1 asi que f=g+h j salida # termina caso salidaL2: addi $t0,$s5,-2 # $t0=k-2 bne $t0,$0,L3 # salta k!=2 sub $s0,$s1,$s2 # k==2 asi que f=g-h j salida # termina caso salidaL3: addi $t0,$s5,-3 # $t0=k-3 bne $t0,$0,salida # salta k!=3 sub $s0,$s3,$s4 # k==3 asi que f=i-j salida:
Capitulo
3
Trivia
Lazo:addi $s0,$s0,-1 # i = i - 1 slti $t0,$s1,2 # $t0 = (j < 2) beq $t0,$0 ,Lazo # goto Lazo if $t0 == 0
slt $t0,$s1,$s0 # $t0 = (j < i) bne $t0,$0 ,Lazo # goto Lazo if $t0 != 0
($s0=i, $s1=j)
¿Qué código en C propia-mente va en la siguienteinstrucción:
do {i - -;} while (__);
1: j < 2 && j < i2: j ≥ 2 && j < i3: j < 2 && j ≥ i4: j ≥ 2 && j ≥ i5: j > 2 && j < i6: j < 2 || j < i7: j ≥ 2 || j < i8: j < 2 || j ≥ i9: j ≥ 2 || j ≥ i0: j > 2 || j < i
Capitulo
3
Funciones en C
main() {int i,j,k,m;...i = mult(j,k); ... m = mult(i,i); ...
}/* La función mult */int mult (int mcand, int mlier){
int product; product = 0;
while (mlier > 0) { product = product + mcand; mlier = mlier -1; }return product;}
Capitulo
3
Las funciones hacen un llamado para mantener ciertos datos
Los registros juegan un rol principal en mantener guardada cierta información al momento de hacer un llamado a funciones
Convención de registros Dirección de regreso $ra Argumentos $a0, $a1, $a2, $a3 Valor de regreso $v0, $v1 Variables locales $s0, $s1, …, $s7
La memoria de pila también se utiliza
Capitulo
3
Instrucciones de soporte para funciones (1/6)
En lenguaje C… sum (a, b); … /* a, b: $s0, $s1 */}int sum(int x, int y) {return x + y;}
En MIPS todas las instrucciones son de 4 bytes, y son guardadas en memoria como si se tratara de datos. De manera que es importante tener en cuenta la dirección donde son almacenados los programas
Capitulo
3
Instrucciones de soporte para funciones (2/6)
En lenguaje C… sum (a, b); … /* a, b: $s0, $s1 */}int sum(int x, int y) {return x + y;}
En MIPS dirección
1000 add $a0, $s0, $zero # x = a1004 add $a1, $s1, $zero # y = b1008 addi $ra, $zero, 1016 # $ra = 100161012 j suma1016 …2000 suma: add $v0, $a0, $a12004 jr $ra #nueva instrucción
Capitulo
3
Instrucciones de soporte para funciones (3/6)
En lenguaje C… sum (a, b); … /* a, b: $s0, $s1 */}int sum(int x, int y) {return x + y;}
En MIPS Pregunta: ¿Por qué se utiliza la instrucción jr? ¿Por qué
no simplemente utilizar j? Respuesta: La etiqueta suma podría ser llamada por
varias funciones, de manera que no siempre se regresa a la misma dirección. El procedimiento para llamar a suma debe de permitir regresar a esa dirección de alguna manera2000 suma: add $v0, $a0, $a12004 jr $ra #nueva instrucción
Capitulo
3
Instrucciones de soporte para funciones (4/6)
Instrucción simple para saltar y guardar una dirección: saltar y enlaza (jump and link) jal
Antes:1008 addi $ra, $zero, 1016 #$ra = 10161012 j suma
Después:1008 jal suma # $ra = 1012, goto suma
¿Por qué se tiene la instrucción jal? Se realiza el caso más común rapidamente: El llamado a funciones es común. También, no es necesario saber dónde se carga (la dirección) el código en memoria con jal
Capitulo
3
Instrucciones de soporte para funciones (5/6)
Sintaxis para jal (salta y enlaza) es la misma que para j (salta):jal etiqueta
La instrucción jal en realidad debería de llamarse laj por enlaza y salta (link and jump):Paso 1 (enlaza): Se guarda la dirección de la siguiente instrucción en el registro $ra (¿por qué la siguiente instrucción? ¿por qué no la actual?Paso 2 (salto): salta a la etiqueta designada
Capitulo
3
Instrucciones de soporte para funciones (6/6)
Sintaxis para jr-salto de registro (jump register): jr registro En vez de proveer una etiqueta hacia donde
saltar, la instrucción jr permite que un registro que contiene la dirección indique a donde saltar
Solamente es útil cuando se conoce exactamente la dirección hacía donde saltar
Es muy útil para el llamado a funciones: jal almacena la dirección de regreso en el registro $ra jr $ra regresa a la dirección
Capitulo
3
Procedimientos anidados (1/2)
int sumaCuadrado (int x, int y) {return mult (x, x) + y;}
Primero se hace un llamado a sumaCuadrado, después sumaCuadrado llama a mult
De manera que el valor en $ra que sumaCuadrado necesita para regresar, pero será sobrescrito cuando se haga el llamado a mult
Se necesita que salvar la dirección de regreso de sumaCuadrado antes de llamar a mult
Capitulo
3
Procedimientos anidados (2/2)
En general, se necesita salvar información extra además de $ra
Cuando se corre un programa en C existe 3 áreas de memoria que deben de tenerse en cuenta:
La dirección de memoria estática: las variables que se declaran una vez por programa, cesan de existir hasta que la ejecución del programa termina. E.g. Las variables globales en C
Montículo:
Capitulo
3
Revisión de localidades en memoria
0
Código Programa
EstáticoVariables declaradasUna vez por programa
MonticuloExplicitamente secrea espacio, e.g.,malloc(); apuntadores C
PilaEspacio para guardar información de procedi-mientos
$sp Apuntador
de pila
Capitulo
3
Utilizando la pila (1/2)
El registro $sp siempre apunta a la última localidad de la pila
Para utilizar la memoria de pila, se decrementa este apuntador por un monto del espacio que se necesita y entonces llenarlo de información
De manera que cómo se compilaría esta sección del programaint sumaCuadrado(int x, int y) {
return mult(x,x)+ y;}
Capitulo
3
Utilizando la pila (2/2)
Compilando a manosumaCuadrada:
addi $sp,$sp,-8 # espacio en la pila sw $ra, 4($sp) # guardar la dirección de regreso
sw $a1, 0($sp) # guardar y
add $a1,$a0,$zero # preparar argumentos jal mult # llamar a mult
lw $a1, 0($sp) # restaurar y
add $v0,$v0,$a1 # mult()+y lw $ra, 4($sp) # obtener la dirección de regreso addi $sp,$sp,8 # restaurar la pila
jr $ra mult: ...
“push”
“pop”
Capitulo
3
Pasos para hacer un llamado a un procedimiento
Guardar los valores necesarios en la pila Asignar los argumentos en caso de ser
necesario Llamar a jal Restaurar los valores de la pila
Capitulo
3
Llamado a procedimientos
Cuando se hace un llamado con la instrucción jal, regresa a jr $ra
Acepta hasta 4 argumentos en $a0, $a1, $a2 y $a3
Regresa un valor en $v0 (y si es necesario en $v1)
Debe seguir convensiones de (inclusive en funciones que sólo uno puede llamar)
Capitulo
3
Estructura básica de una función
Prólogo etiqueta_entrada: addi $sp,$sp, -tramasw $ra, trama-4($sp) # guardar $raguardar otros registros si es necesario
Cuerpo … (llamado a funciones) Epílogo: Restaura los otros registros si es necesariolw $ra, trama-4($sp) # restaurar $raaddi $sp,$sp, trama jr $ra
ra
memoria
Capitulo
3
Registros del MIPS
La constante 0 $0 $zero Reservado $1 $at Regreso de valores $2-$3 $v0-$v1 Argumentos $4-$7 $a0-$a3 Temporales $8-$15 $t0-$t7 Salvar $16-$23 $s0-$s7 Más temporales $24-$25 $t8-$t9 Usado por el kernel $26-$27 $k0-$k1 Apuntador global $28 $gp Apuntador de pila $29 $sp Apuntador de marco $30 $fp Regreso de dirección $31 $ra
Capitulo
3
Otros registros
$at: puede ser utilizado por el ensamblador en cualquier momento; no es seguro usarlo
$k0-$k1: pueden ser usados por el sistema operativo en cualquier momento; no es seguro usarlos
$gp, $fp: no hay que preocuparse por ellos Nota: se pueden utilizar los registros $gp y $fp
libremente, pero se puede escribir excelente código en MIPS sin necesidad de usarlos
Capitulo
3
En conclusión
Llamado a funciones con jal, regreso con jr $ra La pila es su amiga: hay que utilizarla cuando
se desea guardar lo que se necesite. Sólo hay que dejarla como se encontró antes de usarla
Instrucciones que se han visto hasta ahora Aritméticas: add, addi, sub, addu, addiu, subu Memoria: lw, sw, lb, sb, lbu Decisión: beq, bne, slt, slti, sltu, sltiu Saltos incondicionales (brincos): j, jal, jr Registro que se han visto hasta ahora: todos
Capitulo
3
108
Ensambladores
Introducción:
Una herramienta llamada Ensamblador, traduce el lenguaje ensamblador a instrucciones en binario. Los ensambladores nos proporcionan una representación mas amigable que los 0’s y 1’s de las computadoras .
Un ensamblador lee un archivo fuente en lenguaje ensamblador (.asm) y nos produce un archivo objeto (.obj) conteniendo las instrucciones de máquina y una bitácora de información que nos ayuda a combinar varios archivos .obj en un programa (.exe)
Capitulo 3
Capitulo
3
109
Los procesos que producen un archivo ejecutable
Archivo1.asm
Archivo2.asm
Archivo3.asm
ensamblador
ensamblador
ensamblador
Achivo1.obj
Achivo2.obj
Achivo3.obj
Linker
Liberias
Archivo.exe
Capitulo
3
ensamblador de MIPS
110
# suma de dos enteros
.dataA: .word 2010B: .word -2010C: .word 00.text
lw $t4, A($0) # carga A al registro t4lw $t5, B($0) # carga B al registro t5add $t3, $t4, $t5 # suma A+Bsw $t3, C($0) # almacena resultado en C
Capitulo
3
111
Lenguaje Máquina MIPS de la rutina suma Capitulo 3
00111100000000010001000000000001
00000000001000000000100000100001
10001100001011000000000000000000
00111100000000010001000000000001
00000000001000000000100000100001
10001100001011010000000000000100
00000001100011010101100000100000
00111100000000010001000000000001
00000000001000000000100000100001
10101100001010110000000000001000
00000000000000000000011111011010
11111111111111111111100000100110
00000000000000000000000000000000
00000000000000000000000000000000
00000000000000000000000000000000
00000000000000000000000000000000
00000000000000000000000000000000
00000000000000000000000000000000
00000000000000000000000000000000
00000000000000000000000000000000
.text .data
Capitulo
3
Formato de Archivos objeto
112
ENCABEZADOSEGMENTO DE
TEXTOSEGMENTO DE
PROGRAMAINFORMACION DE
REASIGACIONTABLA DE SIMBOLOS
INFORMACION PARA DEBUG
ENCABEZADO: describe el tamaño y posición de las otras piezas del archivo.SEGMENTO DE TEXTO: Contienen el código en lenguaje maquina de las rutinas del archivo fuente.SEGMENTO DE DATOS: Contienen la representación binaria de los datos del archivo fuente. INF. De REASIGNACION: Identifica instrucciones y datos que dependen de asignaciones absolutas. TABLA DE SIMBOLOS: Asocia direcciones con etiquetas externas en el archivo fuente y lista las referencias no resueltas. INF. PARA DEBUG: Contienen información concisa de cómo fue compilado el programa. -líneas, instrucciones, estructuras, etc.
Capitulo
3
Excepciones e Interrupciones
Una excepción es un evento asíncrono, o condición de error que cambia el flujo normal de un programa en ejecución.
Interrupciones de hardware, solicitadas por dispositivos de E/S. por ejemplo: teclado, mouse, etc.Excepciones por software, por condiciones especificas en la ejecución de un programa. por ejemplo: Sobre flujo, error de segmento, fallo de cache, etc.
113
Capitulo
3
114
Manejo de excepciones en MIPS
Cuando un excepción ocurre, MIPS intenta completar la instrucción presente, para el procesamiento de las instrucciones del programa, maneja la excepción, y regresa a la dirección donde el programa fue interrumpido para continuar con el proceso. El procesador maneja las excepciones por realizar las siguiente secuencia de acciones.
Prende el EXL (bit 1) del registro de estado del CP0, con lo que se deshabilitan otras interrupciones y causa que el procesador ejecute el nivel de la excepción.Salva el PC de la instrucción que causo la excepción en el registro EPC Cambia el PC a la dirección del vector de excepción apropiado.
Capitulo
3
Área de Vectores de Excepciones
Capitulo
3
Ejemplo Práctico
Crear el manejador de excepciones para dispositivos de entrada/salida de la herramienta de Teclado y Terminal del simulador de MIPS (MARS)
Capitulo
3
Registro de Transmisión
Capitulo
3
Proceso de excepciones
Programa en ejecución
Rutina de servicio de Excepción
2
3
1
4
5
Capitulo
3
Registros usados en Excepciones
119
Capitulo
3
120
Capitulo
3
Registro CAUSE
121
Capitulo
3
Campo de Interrupción Pendiente
122
Capitulo
3
Simulador MIPS MARS
123