Capitulo 3 INSTITUTO POLITÉCNICO NACIONAL CENTRO DE INVESTIGACION EN COMPUTACION LABORATORIO DE...

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


¿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


¿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


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


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


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


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


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


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


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


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


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


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


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


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


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:


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


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


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


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


¿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


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


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


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



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



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


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


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


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

Capitulo 3 INSTITUTO POLITÉCNICO NACIONAL CENTRO DE INVESTIGACION EN COMPUTACION LABORATORIO DE...

Documents

Transcript of Capitulo 3 INSTITUTO POLITÉCNICO NACIONAL CENTRO DE INVESTIGACION EN COMPUTACION LABORATORIO DE...