Arquitecturas de Computadoras Curso Propedéutico INSTITUTO POLITÉCNICO NACIONAL CENTRO DE INVESTIGACION EN COMPUTACION LABORATORIO DE MICROTECNOLOGÍA Y SISTEMAS EMBEBIDOS Grupo de Arquitectura de Computadoras y Sistemas Embebidos Arquitecturas de Computadoras Curso Propedéutico Programación a nivel de máquina I Programación en lenguaje ensamblador La presentación tiene como finalidad explicarles cual es el nicho de oportunidad y por que es importante trabajar en el Dr. Marco Antonio Ramírez Salinas Dr. Herón Molina Lozano

Programación a nivel de máquina Capitulo 3 Lenguaje 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”. Ley de moore

El modelo de ejecución Estado Visible por el programador: Capitulo 3 Estado Visible por el programador: PC: Contador de programa -dirección de la próxima instrucción Banco de Registros: -Fuertemente usado por los datos de programa. Códigos de condición -Almacena información de estado de las operaciones realizadas recientemente. Ley de moore Memoria: -Arreglo accesible por bytes Código, datos de usuario, datos de S.O. -Pila (Stack): memoria utilizada para soportar procedimientos

Convirtiendo código C a código objeto Capitulo 3 Código: archivos de texto Compila con el comando: -gcc p1.c, p2.c -o p.exe Optimizaciones: - 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 . Ley de moore

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!

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

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

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

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

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

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

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

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

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

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

Suma y resta en el MIPS (1/4) Sintaxis de las instrucciones: 1 2, 3, 4 Donde: nombre de la operación operando donde se obtiene el resultado (“destino”) 1er operando de la operación (“fuente 1”) 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

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

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

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 + h add $t1, $s3, $s4 # temp = i + j sub $s0, $t0, $t1 # f = (g + h) – (i + j)

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

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

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

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

Trivia Los tipos están asociados con declaration en C (normalmente), pero están asociados con instrucciones (operadores) en MIPS 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 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

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

MIPS: lectura y almacenamiento, decisión

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

Anatomía: los 5 componentes de cualquier computadora PC Computadora Procesador Despositivos Memoria Control (“cerebro”) Almacenamiento (hacía) Entrada Pagtrón de datos Registros Carga (desde) Salida

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

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”

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

Transferencia de datos: memoria a registros (3/4) Sintaxis para la instrucción de lectura 1 2, 3(4) Donde Es el nombre de la operación Registro que recibirá el valor Corrimiento numérico en bytes 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)

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

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

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

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

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], …

Compilación con memoria ¿Qué valor de corrimiento en lw se debe de tener para seleccionar A[5] en C? El corrimiento será 45 = 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]

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)

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 Último dígito hex. de la dir. es: 0 1 2 3 Alineado No 0, 4, 8, or Chex 1, 5, 9, or Dhex 2, 6, A, or Ehex 3, 7, B, or Fhex

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

Trivia A: add $s0, $s1, zero B: add $s1, $s0, zero C: lw $s0, 0($s1) Se desea trasladar *x = *y; hacia MIPS Los apuntadores, ya se encuentran en: $s0, $s1 ¿Qué instrucciones se deben utilizar? A: add $s0, $s1, zero B: add $s1, $s0, zero C: lw $s0, 0($s1) D: lw $s1, 0($s0) E: lw $t0, 0($s1) F: sw $t0, 0($s0) G: lw $s0, 0($t0) H: sw $s1, 0($t0)

Ejemplo addi $s1,$0,5 # x = 5 lw $t0,0($s0) # temp = m[*p] 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

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

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 xxxx xxxx xxxx xxxx xxxx xxxx zzz zzzz x byte cargado …se copia para “extender el signo” Este bit

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!

MIPS: lectura y almacenamiento, decisión

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

Anatomía: los 5 componentes de cualquier computadora PC Computadora Procesador Despositivos Memoria Control (“cerebro”) Almacenamiento (hacía) Entrada Pagtrón de datos Registros Carga (desde) Salida

Carga y Almacenamiento 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

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”

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

Transferencia de datos: memoria a registros (3/4) Sintaxis para la instrucción de lectura 1 2, 3(4) Donde Es el nombre de la operación Registro que recibirá el valor Corrimiento numérico en bytes 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)

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

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

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

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

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], …

Compilación con memoria ¿Qué valor de corrimiento en lw se debe de tener para seleccionar A[5] en C? El corrimiento será 45 = 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]

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)

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 Último dígito hex. de la dir. es: 0 1 2 3 Alineado No 0, 4, 8, or Chex 1, 5, 9, or Dhex 2, 6, A, or Ehex 3, 7, B, or Fhex

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

Trivia A: add $s0, $s1, zero B: add $s1, $s0, zero C: lw $s0, 0($s1) Se desea trasladar *x = *y; hacia MIPS Los apuntadores a, y se encuentran en: $s0, $s1 ¿Qué instrucciones se deben utilizar? A: add $s0, $s1, zero B: add $s1, $s0, zero C: lw $s0, 0($s1) D: lw $s1, 0($s0) E: lw $t0, 0($s1) F: sw $t0, 0($s0) G: lw $s0, 0($t0) H: sw $s1, 0($t0)

Ejemplo addi $s1,$0,5 # x = 5 lw $t0,0($s0) # temp = *p 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

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

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 xxxx xxxx xxxx xxxx xxxx xxxx zzz zzzz x byte cargado …se copia para “extender el signo” Este bit

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!

Decisión en C: declaraciones if En C existen dos tipos declaración if if (condición) clausula if (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

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” if (registro1 != registro2) goto L1 Llamados brincos condicionales

Instrucciones en MIPS para goto De manera adicional a los brincos condicionales, MIPS tiene brincos incondicionales j 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

Compilado if de C a MIPS (1/2) Compilado a mano if (i == j) f = g + h; else f = g – h; Utilizando este mapeo: f: $s0 g: $s1 h: $s2 i: $s3 j: $s4 Salida i == j? f=g+h f=g-h (falso) i != j (verdad) i == j

Compilado if de C a MIPS (2/2) Compilado a mano if (i == j) f = g + h; else f = g – h; Compilando en código MIPS beq $s3, $s4, verdad sub $s0, $s1, $s2 j Fin Verdad: add $s0, $s1, $s2 Fin: 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

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

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 detectado Suma (add) Suma inmediata (addi) Resta (sub) Estas instrucciones no causa que el sobreflujo sea detectado Suma 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

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

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]; if (i != h) goto repeticion; Utilizando este mapeo: g, h, i, j, base de A $s1, $s2, $s3, $s4, $s5

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 original repeticion: g = g + A[i]; i = i + j; if (i != h) goto repeticion;

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

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”

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 < h bne $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 …

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 

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…

¿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, $s1 sltu $t1, $s0, $s1

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)

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ódigo switch (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/ }

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

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 salida L1: 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 salida L2: 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 salida L3: 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:

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 siguiente instrucción: do {i - -;} while (__); 1: j < 2 && j < i 2: j ≥ 2 && j < i 3: j < 2 && j ≥ i 4: j ≥ 2 && j ≥ i 5: j > 2 && j < i 6: j < 2 || j < i 7: j ≥ 2 || j < i 8: j < 2 || j ≥ i 9: j ≥ 2 || j ≥ i 0: j > 2 || j < i

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

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

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

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 = a 1004 add $a1, $s1, $zero # y = b 1008 addi $ra, $zero, 1016 # $ra = 10016 1012 j suma 1016 … 2000 suma: add $v0, $a0, $a1 2004 jr $ra #nueva instrucción

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 manera 2000 suma: add $v0, $a0, $a1 2004 jr $ra #nueva instrucción

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 = 1016 1012 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

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

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

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

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:

Revisión de localidades en memoria ¥ Pila Espacio para guardar información de procedi- mientos $sp Apuntador de pila Monticulo Explicitamente se crea espacio, e.g., malloc(); apuntadores C Estático Variables declaradas Una vez por programa Código Programa

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 programa int sumaCuadrado(int x, int y) { return mult(x,x)+ y; }

Utilizando la pila (2/2) “push” “pop” Compilando a mano sumaCuadrada: 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”

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

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)

Estructura básica de una función Prólogo etiqueta_entrada: addi $sp,$sp, -trama sw $ra, trama-4($sp) # guardar $ra guardar otros registros si es necesario Cuerpo … (llamado a funciones) Epílogo: Restaura los otros registros si es necesario lw $ra, trama-4($sp) # restaurar $ra addi $sp,$sp, trama jr $ra ra memoria

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

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

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

Ensambladores Introducción: Capitulo 3 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) Ley de moore 108 108

Los procesos que producen un archivo ejecutable Ley de moore 109 109

ensamblador de MIPS # suma de dos enteros .data A: .word 2010 B: .word -2010 C: .word 00 .text lw $t4, A($0) # carga A al registro t4 lw $t5, B($0) # carga B al registro t5 add $t3, $t4, $t5 # suma A+B sw $t3, C($0) # almacena resultado en C 110

Lenguaje Máquina MIPS de la rutina suma Capitulo 3 .text .data 00111100000000010001000000000001 00000000001000000000100000100001 10001100001011000000000000000000 10001100001011010000000000000100 00000001100011010101100000100000 10101100001010110000000000001000 00000000000000000000011111011010 11111111111111111111100000100110 00000000000000000000000000000000 Ley de moore 111 111

Formato de Archivos objeto 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. 112

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 113

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

Área de Vectores de Excepciones

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)

Registro de Transmisión

Proceso de excepciones

Registros usados en Excepciones 119

120

Registro CAUSE 121

Campo de Interrupción Pendiente 122

Simulador MIPS MARS 123