Estructura de Computadores

Estructura de Computadores Tema 3. Programación en ensamblador Departamento de Informática Grupo de Arquitectura de Computadores, Comunicaciones y Sistemas UNIVERSIDAD CARLOS III DE MADRID

Contenido Fundamentos básicos de la programación en ensamblador Ensamblador del MIPS 32, modelo de memoria y representación de datos Formato de las instrucciones y modos de direccionamiento Llamadas a procedimientos y uso de la pila ARCOS Estructura de Computadores 2

Motivación para aprender ensamblador Para comprender qué ocurre cuando un computador ejecuta una sentencia de un lenguaje de alto nivel. C, C++, Java, PASCAL, Para poder determinar el impacto en tiempo de ejecución de una instrucción de alto nivel. Porque es útil en dominios específicos. Compiladores, SSOO Juegos Sistemas empotrados Etc. ARCOS Estructura de Computadores 3

Motivación para usar MIPS 32 Arquitectura simple. Facilidad de aprendizaje. Ensamblador similar al de otros procesadores RISC Usado en diversos dispositivos 4 ARCOS Estructura de Computadores 4

Qué es un computador? datos Procesador resultados Instrucciones ARCOS Estructura de Computadores 5

Instrucción máquina 001 AB 00000000101 Código de operación Operandos Registros Direcciones de memoria Números ARCOS Estructura de Computadores 6

Fases de ejecución de una instrucción Lectura de la instrucción (ciclo de fetch) MAR PC Lectura MBR Memoria PC PC + 1 RI MBR MAR PC RI 000100 MBR Decodificación de la instrucción Ejecución de la instrucción Dirección Contenido 000100 0010000000000000 Volver a fetch Memoria ARCOS Estructura de Computadores 7

Propiedades de las instrucciones máquina Realizan una única y sencilla tarea Operan sobre un número fijo de operandos Son autocontenidas, incluyen toda la información necesaria para su ejecución Incluye: La operación a realizar Dónde se encuentran los operandos: En registros En memoria En la propia instrucción Dónde dejar los resultados Una referencia a la siguiente instrucción a ejecutar De forma implícita la siguiente De forma explícita en las instrucciones de bifurcación ARCOS Estructura de Computadores 8

Programa Secuencia ordenada de instrucciones máquina que se ejecutan en secuencia 00001001110001101010111101011000 10101111010110000000100111000110 11000110101011110101100000001001 01011000000010011100011010101111 temp = v[k]; v[k] = v[k+1]; v[k+1] = temp; ARCOS Estructura de Computadores 9

Diferentes niveles de lenguajes Lenguaje de alto nivel (ej: C, C++) compilador Lenguaje ensamblador (Ej: MIPS) Lenguaje Máquina (MIPS) Ensamblador temp = v[k]; v[k] = v[k+1]; v[k+1] = temp; lw $t0, 0($2) lw $t1, 4($2) sw $t1, 0($2) sw $t0, 4($2) 0000 1001 1100 0110 1010 1111 0101 1000 1010 1111 0101 1000 0000 1001 1100 0110 1100 0110 1010 1111 0101 1000 0000 1001 0101 1000 0000 1001 1100 0110 1010 1111 ARCOS Estructura de Computadores 10

Lenguaje ensamblador Emplea códigos nemónicos para representar instrucciones add suma lw carga un dato de memoria Emplea nombres simbólicos para designar a datos y referencias $t0 identificador de un registro Cada instrucción en ensamblador se corresponde con una instrucción máquina add $t1, $t2, $t3 ARCOS Estructura de Computadores 11

Modelo de programación de un computador Un computador ofrece un modelo de programación que está formando: Juego de instrucciones (lenguaje ensamblador) Una instrucción incluye: Código de operación Otros elementos: identificadores de registros, direcciones de memoria o números Elementos de almacenamiento Registros Memoria Registros de los controladores de E/S Modos de ejecución ARCOS Estructura de Computadores 12

Lenguaje ensamblador Emplea códigos nemónicos para representar instrucciones add suma lw carga un dato de memoria Emplea nombres simbólicos para designar a datos y referencias $t0 identificador de un registro Cada instrucción en ensamblador se corresponde con una instrucción máquina add $t1, $t2, $t3 ARCOS Estructura de Computadores 13

Arquitectura MIPS MIPS R2000/R3000 Procesador de 32 bits Tipo RISC CPU + coprocesadores auxiliares Coprocesador 0 excepciones, interrupciones y sistema de memoria virtual Coprocesador 1 FPU (Unidad de Punto Flotante) ARCOS Estructura de Computadores 14

Banco de registros Nombre Simbólico del registro Número zero 0 Constante 0 Uso at 1 Reservado para el ensamblador v0, v1 2, 3 Resultado de una rutina (o expresión) a0,, a3 4,, 7 Argumento de entrada para rutinas t0,, t7 8,, 15 Temporal (NO se conserva entre llamadas) s0,, s7 16,, 23 Temporal (se conserva entre llamadas) t8, t9 24, 25 Temporal (NO se conserva entre llamadas) k0, k1 26, 27 Reservado para el sistema operativo gp 28 Puntero al área global sp 29 Puntero a pila fp 30 Puntero a marco de pila ra 31 Dirección de retorno (rutinas) Hay 32 registros Tamaño de 1 palabra (4 bytes) Se nombran con un $ al principio Convenio de uso Reservados Argumentos Resultados Temporales Punteros ARCOS Estructura de Computadores 15

Tipos de instrucciones De transferencia Aritmética Lógicas De desplazamiento De rotación De comparación De bifurcación ARCOS Estructura de Computadores 16

Transferencia de datos Copia de un dato en un registro. Carga inmediata li $t0 5 $t0 5 Registro a registro move $a0 $t0 $a0 $t0 Instrucciones de acceso a memoria (más adelante) De registro a memoria De memoria a registro ARCOS Estructura de Computadores 17

Aritméticas Realiza operaciones aritméticas de entero (ALU) o aritmética de coma flotante (FPU) Ejemplos de operaciones con enteros Sumar add $t0, $t1, $t2 $t0 $t1 + $t2 suma con desbordamiento addi $t0, $t1, 5 $t0 $t1 + 5 suma con desbordamiento addu $t0, $t1, $t2 $t0 $t1 + $t2 suma sin desbordamiento Restar sub $t0 $t1 1 Multiplicar mul $t0 $t1 $t2 Dividir div $t0, $t1, $t2 $t0 $t1 / $t2 división entera rem $t0, $t1, $t2 $t0 $t1 % $t2 resto de división entera ARCOS Estructura de Computadores 18

Ejemplo int a = 5; int b = 7; int c = 8; int d; li $t0, 5 li $t1, 7 li $t2, 8 d = a * (b + c) add $t1, $t1, $t2 mul $t3, $t1, $t0 ARCOS Estructura de Computadores 19

Ejemplo int a = 5; int b = 7; int c = 8; int d; d=-(a*(b-10)+c) li $t0, 5 li $t1, 7 li $t2, 8 li $t3 10 sub $t1, $t1, $t3 add $t1, $t1, $t2 mul $t0, $t0, $t1 li $t1, -1 mul $t0, $t0, $t1 ARCOS Estructura de Computadores 20

Lógicas Operaciones booleanas Ejemplos: AND and $t0 $t1 $t2 ($t0 = $t1 && $t2) OR or $t0 $t1 $t2 ($t0 = $t1 $t2) ori $t0 $t1 80 ($t0 = $t1 80) NOT not $t0 $t1 ($t0 =! $t1) XOR or $t0 $t1 $t2 ($t0 = $t1 ^ $t2) AND OR NOT XOR 1100 1010 1000 1100 1010 1110 10 01 1100 1010 0110 ARCOS Estructura de Computadores 21

Ejemplo li $t0, 5 li $t1, 8 Cuál es el valor de $t2? and $t2, $t1, $t0 ARCOS Estructura de Computadores 22

Solución li $t0, 5 li $t1, 8 and $t2, $t1, $t0 Cuál es el valor de $t2? 000. 0101 $t0 000.. 1000 $t1 and 000.. 0000 $t2 ARCOS Estructura de Computadores 23

Desplazamientos De movimiento de bits Ejemplos: Desplazamiento lógico a la derecha 0 srl $t0 $t0 4 ($t0 = $t0 >> 4 bits) 01110110101 Desplazamiento lógico a la izquierda sll $t0 $t0 5 ($t0 = $t0 << 5 bits) 01110110101 0 Desplazamiento aritmético a la derecha mantiene el signo sra $t0 $t0 2 ($t0 = $t0 >> 2 bits) 11110110101 ARCOS Estructura de Computadores 24

Rotaciones De movimiento de bits Ejemplos: Rotación a la izquierda rol $t0 $t0 4 ($t0 = $t0 >> 4 bits) Rotación a la derecha ror $t0 $t0 5 ($t0 = $t0 << 5 bits) 01110110101 01110110101 ARCOS Estructura de Computadores 25

Instrucciones de comparación seq $t0, $t1, $t2 if ($t1 == $t2) $t0 = 1; else $t0 = 0 sneq $t0, $t1, $t2 if ($t1!=$t2) $t0 = 1; else $t0 = 0 sge $t0, $t1, $t2 if ($t1 >= $t2) $t0 = 1; else $t0 = 0 sgt $t0, $t1, $t2 if ($t1 > $t2) $t0 = 1; else $t0 = 0 sle $t0, $t1, $t2 if ($t1 <= $t2) $t0 = 1; else $t0 = 0 slt $t0, $t1, $t2 if ($t1 < $t2) $t0 = 1; else $t0 = 0 ARCOS Estructura de Computadores 26

Instrucciones de comparación seq $t0, $t1, $t2 sneq $t0, $t1, $t2 sge $t0, $t1, $t2 sgt $t0, $t1, $t2 sle $t0, $t1, $t2 slt $t0, $t1, $t2 Set if equal Set if no equal Set if greater or equal Set if greater than Set if less or equal Set if less than ARCOS Estructura de Computadores 27

Instrucciones de bifurcación Cambian la secuencia de ejecución de las instrucciones de un programa Distintos tipos: Bifurcación o salto condicional: beq $t0 $t1 0xE00012 Salta a la posición 0xE00012, si valor $t0 == $t1 beqz $t1 direccion Salta a la instrucción etiqueta con direccion si $t1 == 0 Bifurcación o salto incondicional: El salto se realiza siempre j 0x10002E b direccion Llamadas a funciones: jal 0x20001E jr $ra ARCOS Estructura de Computadores 28

Instrucciones de bifurcación beqz $t0, direccion Branch if $t0 == 0 beq $t0, $t1 direccion Branch if equal (t0 == t1) bneq $t0, $t1 direccion Branch if not equal (t0 t1) bge $t0, $t1 direccion Branch if greater or equal (t0 t1) bgt $t0, $t1 direccion Branch if greater than (t0 > t1) ble $t0, $t1 direccion Branch if less or equal (t0 t1) blt $t0, $t1 direccion Branch if less than (t0 <t1) ARCOS Estructura de Computadores 29

Estructuras de control while } int i; i=0; while (i < 10) { /* acción */ i = i + 1 ; } li $t0 0 li $t1 10 while: bge $t0 t1 fin # acción addi $t0 $t0 1 b while fin:... ARCOS Estructura de Computadores 30

Ejemplo Calcular la suma 1 + 2 + 3 +. + 10 } i=0; s=0; while (i < 10) { s = s + i; i = i + 1; } li $t0 0 li $t1 0 li $t2 10 while: bge $t0 t2 fin add $t1 $t1 $t0 addi $t0 $t0 1 b while fin:... Resultado en $t1 ARCOS Estructura de Computadores 31

Ejemplo Calcular el número de 1 s que hay en un registro ($t0). Resultado en $t3 } i = 0; n = 45; #numero s=0; while (i < 32) { b = ultimo bit de n s = s + b; se desplaza n un bit a la derecha i = i + 1 ; } li $t0 0 #i li $t1 45 #n li $t2 32 li $t3 0 #s while: bge $t0 t2 fin and $t4 $t1 1 add $t3 $t3 $t4 srl $t1 $t1 1 addi $t0 $t0 1 b while fin:... ARCOS Estructura de Computadores 32

Ejemplo Obtener los 16 bits superiores de un registro ($t0) y dejarlos en los 16 bits inferiores de otro ($t1) srl $t1, $t0, 16 0 01110110101 Se desplaza a la derecha 16 Posiciones (de forma lógica) ARCOS Estructura de Computadores 33

Estructuras de control if int b1 = 4; int b2 = 2; if (b2 == 8) { b1 = 0; }... li $t0 4 li $t1 2 li $t2 8 bneq $t0 $t2 fin li $t0 0 fin:... ARCOS Estructura de Computadores 34

Estructuras de control if-else int a=1; int b=2; if (a < b) { // acción 1 } else { // acción 2 } li $t1 1 li $t2 2 blt $t1 $t2 then # cond. else:... # acción 2 b fin # incond. then:... # acción 1 fin:... ARCOS Estructura de Computadores 35

Ejemplo Determinar si el contenido de un registro ($t2) es par. Si es par se almacena en $t1 un 1, sino se almacena un 0 li $t2 9 li $t1 2 rem $t1 $t2 $t1 # se obtiene el resto beq $t1 $0 then # cond. else: li $t1 0 b fin # incond. then: li $t1 1 fin:... ARCOS Estructura de Computadores 36

Ejemplo Determinar si el contenido de un registro ($t2) es par. Si es par se almacena en $t1 un 1, sino se almacena un 0. En este caso consultando el último bit li $t2 9 li $t1 1 and $t1 $t2 $t1 # se obtiene el último bit beq $t1 $0 then # cond. else: li $t1 0 b fin # incond. then: li $t1 1 fin:... ARCOS Estructura de Computadores 37

Ejemplo Calcular a n a en $t0 n en $t1 El resultado en $t2 } a=8 n=4; i=0; p = 1; while (i < n) { p = p * a i = i + 1 ; } li $t0 8 li $t1 4 li $t2 1 li $t4 0 while: bge $t4 $t1 fin mul $t2 $t2 $t0 addi $t4 $t4 1 b while fin: move $t2 $t4 ARCOS Estructura de Computadores 38

Simulador SPIM http://pages.cs.wisc.edu/~larus/spim.html SPIM es un simulador de una arquitectura MIPS Aplicación multiplataforma: Linux Windows MacOS Permite simular una arquitectura MIPS ARCOS Estructura de Computadores 40

Tarea Instalar en el simulador SPIM que se va a utilizar en las prácticas. http://pages.cs.wisc.edu/~larus/spim.html Probar en el simulador pequeños programas en ensamblador ARCOS Estructura de Computadores 41

MIPS: Visión general ARCOS Estructura de Computadores 42

Arquitectura MIPS MIPS R2000/R3000 Procesador de 32 bits Tipo RISC CPU + coprocesadores auxiliares Coprocesador 0 excepciones, interrupciones y sistema de memoria virtual Coprocesador 1 FPU (Unidad de Punto Flotante) ARCOS Estructura de Computadores 43

Banco de registros 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Hay 32 registros 4 bytes de tamaño (una palabra) Se nombran con un $ al principio Convenio de uso Reservados Argumentos Resultados Temporales Punteros 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ARCOS Estructura de Computadores 44

Banco de registros 0 $zero 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Valor cableado a cero No puede modificarse 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ARCOS Estructura de Computadores 45

Banco de registros 0 $zero 1 2 Valores temporales 3 4 5 6 7 8 $t0 $t8 9 $t1 $t9 10 $t2 11 $t3 12 $t4 13 $t5 14 $t6 15 $t7 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ARCOS Estructura de Computadores 46

Banco de registros 0 $zero $s0 1 $s1 2 Valores guardados $s2 3 $s3 4 $s4 5 $s5 6 $s6 7 $s7 8 $t0 $t8 9 $t1 $t9 10 $t2 11 $t3 12 $t4 13 $t5 14 $t6 15 $t7 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ARCOS Estructura de Computadores 47

Banco de registros 0 $zero $s0 1 $s1 2 $v0 $s2 3 $v1 $s3 4 $a0 $s4 5 $a1 $s5 6 $a2 $s6 7 $a3 $s7 8 $t0 $t8 9 $t1 $t9 10 $t2 11 $t3 12 $t4 Paso de parámetros y 13 $t5 Gestión de subrutinas $sp 14 $t6 $fp 15 $t7 $ra 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ARCOS Estructura de Computadores 48

Banco de registros 0 $zero $s0 1 $at $s1 2 $v0 $s2 3 $v1 $s3 4 $a0 $s4 5 $a1 $s5 6 $a2 $s6 7 $a3 $s7 8 $t0 $t8 9 $t1 $t9 10 $t2 $k0 11 $t3 $k1 12 $t4 Otros $gp 13 $t5 $sp 14 $t6 $fp 15 $t7 $ra 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ARCOS Estructura de Computadores 49

Distribución de la memoria Hay 4 GB de memoria direccionables en total Parte de esa memoria la utilizan los distintos segmentos de un proceso Otra parte de la memoria está reservada: Un mini-sistema operativo reside en los primeros 4 MB de memoria ARCOS Estructura de Computadores 50

Distribución de la memoria de un programa ARCOS Estructura de Computadores 51

Mapa de memoria de un programa Segmento de Pila Segmento de Datos Segmento de Texto $fp 01011001 $sp 01011001 $gp 01011001 pc 01011001 El programa de usuario se divide en segmentos Segmento de pila Variables locales Contexto de funciones Segmento de datos Datos estáticos Segmento de código (texto) Código ARCOS Estructura de Computadores 52

Estructura de un programa ARCOS Estructura de Computadores 53

Simulador SPIM Banco de registros $0, $1, $2, $f0, $f1, Segmento de código Segmento de datos Segmento de pila Otros ARCOS Estructura de Computadores 54

Ejemplo: Hola mundo.data msg_hola:.asciiz "hola mundo\n" hola.s.text.globl main main: # printf("hola mundo\n") ; li $v0 4 la $a0 msg_hola syscall ARCOS Estructura de Computadores 55

Ejemplo: Hola mundo # comentario hasta fin de la línea etiqueta: instrucción/pseudoinstrucción.directiva operandos.data msg_hola:.asciiz "hola mundo\n" hola.s.text.globl main main: # printf("hola mundo\n") ; li $v0 4 la $a0 msg_hola syscall ARCOS Estructura de Computadores 56

Ejemplo: Hola mundo.data msg_hola:.asciiz "hola mundo\n" hola.s.text.globl main main: # printf("hola mundo\n") ; li $v0 4 #código de llamada la $a0 msg_hola syscall ARCOS Estructura de Computadores 57

Programa en ensamblador: directivas de preproceso.data.text Directivas Uso Siguientes elementos van al segmento de dato Siguientes elementos van al segmento de código.ascii tira de caracteres.asciiz tira de caracteres.byte 1, 2, 3.half 300, 301, 302.word 800000, 800001.float 1.23, 2.13.double 3.0e21 Almacena cadena caracteres NO terminada en carácter nulo Almacena cadena caracteres terminada en carácter nulo Almacena bytes en memoria consecutivamente Almacena medias palabras en memoria consecutivamente Almacena palabras en memoria consecutivamente Almacena float en memoria consecutivamente Almacena double en memoria consecutivamente.space 10 Reserva un espacio de 10 bytes en el segmento actual.extern etiqueta n.globl etiqueta.align n Declara que etiqueta es global de tamaño n Declara etiqueta como global Alinea el siguiente dato en un límite de 2^n ARCOS Estructura de Computadores 58

Definición de datos estáticos ARCOS Estructura de Computadores 59

Llamadas al sistema El simulador incluye un pequeño sistema operativo. Ofrece 17 servicios. Invocación: Código de servicio en $v0. Otros parámetros en registros concretos. Invocación mediante instrucción syscall. ARCOS Estructura de Computadores 60

Llamadas al sistema Servicio Código de llamada ($v0) Argumentos print_int 1 $a0 = integer print_float 2 $f12 = float print_double 3 $f12 = double print_string 4 $a0 = string Resultado read_int 5 integer en $v0 read_float 6 float en $f0 read_double 7 double en $f0 read_string 8 $a0=buffer, $a1=longitud sbrk 9 $a0=cantidad dirección en $v0 exit 10 ARCOS Estructura de Computadores 61

Llamadas al sistema Servicio Código de llamada ($v0) Argumentos print_char 11 $a0 (código ASCII) Resultado read_char 12 $v0 (código ASCII) open 13 Equivalente a $v0 = open($a0, $a1, $a2) read 14 Equivalente a $v0 = read ($a0, $a1, $a2) write 15 Equivalente a $v0 = write($a0, $a1, $a2) close 16 Equivalente a $v0 = close($a0) exit2 17 Termina el programa y hace que spim devuelva el código de error almacenado en $a0 ARCOS Estructura de Computadores 62

Ejemplo ARCOS Estructura de Computadores 63

Ejemplo ARCOS Estructura de Computadores 64

Modelo de memoria. Direccionamiento por bytes Los computadores actuales direccionan la memoria por bytes. Un computador con direcciones de n bits puede direccionar 2 n bytes Un computador con direcciones de 32 bits (MIPS 32) puede direccionar 2 32 bytes de memoria= 4 GB Las direcciones que genera un computador se refieren a bytes ARCOS Estructura de Computadores 65

Espacio de direcciones. Direccionamiento por bytes Direcciones de bytes Byte (contenido) 0 1 2 3 4 5 6 00001101 Dirección: 6 (000110) Contenido: 00001101 (9) 2 n -1 ARCOS Estructura de Computadores 66

Espacio de direcciones. Direccionamiento por bytes Direcciones de bytes Byte (contenido) 0x0F000000 0x0F000001 0x0F000002 00001101 0x0F000003 Dirección: 0x0F000002 Contenido: 00001101 (9) ARCOS Estructura de Computadores 67

Espacio de direcciones Direcciones de bytes 0 1 2 3 4 5 6 00001101 Byte (contenido) Por razones de velocidad, las memorias principales suelen tener un ancho de palabra de 32 o 64 bits El acceso a la memoria se realiza por palabras El mapa de memoria y la construcción de la memoria son diferentes.? 2 n -1 ARCOS Estructura de Computadores 68

Espacio de direcciones y memoria física Lógicamente Físicamente Direcciones de bytes Byte (contenido) Direcciones de palabras Palabra de 32 bits (contenido) 0 7 1 8 2 4 3 3 4 5 6 0 7 8 4 3 4 8 12 16 byte 0 byte 1 byte 2 byte 3 2 n -4 2 n -1 Un computador de 32 bits que direcciona la memoria por bytes tiene un espacio de direcciones de 3 32 bytes y 2 30 palabras ARCOS Estructura de Computadores 69

Acceso a memoria Para un computador de 32 bits con direccionamiento por bytes: La palabra tiene 32 bits (cuatro bytes) Se pueden direccionar 2 32 bytes La memoria está formada por 2 30 palabras Existen instrucciones que permite acceder a: Bytes almacenados en una dirección: A 31 A 0 Palabras almacenadas a partir de una dirección: A 31 A 0 El acceso físico a la memoria se realiza a una palabra completa con la dirección: A 31 A 2 Un byte situado en la dirección A 31 A 0 se encuentra En la palabra de memoria A 31 A 2 En el byte A 1 A 0 dentro de la palabra ARCOS Estructura de Computadores 70

Espacio de direcciones y acceso a bytes Direcciones de bytes Byte (contenido) lb $t1, 0x6 0 1 2 3 4 5 6 00001101 Dirección: 6 (000110) Contenido: 00001101 (9) $t1 31 24 23 16 15 8 7 0 2 n -1 ARCOS Estructura de Computadores 71

Espacio de direcciones y acceso a bytes Direcciones de bytes Byte (contenido) lb $t1, 0x6 0 1 2 3 4 5 6 00001101 Dirección: 6 (000110) Contenido: 00001101 (9) $t1 00000000 00000000 00000000 00001101 31 24 23 16 15 8 7 0 2 n -1 ARCOS Estructura de Computadores 72

Espacio de direcciones y acceso a bytes Direcciones de bytes Byte (contenido) lb $t1, 0x6 0 1 2 3 4 5 6 11111101 Dirección: 6 (000110) Contenido: 11111101 (-3 en complemento a 2) $t1 31 24 23 16 15 8 7 0 2 n -1 ARCOS Estructura de Computadores 73

Espacio de direcciones y acceso a bytes Direcciones de bytes Byte (contenido) lb $t1, 0x6 0 1 2 3 4 5 6 11111101 Dirección: 6 (000110) Contenido: 11111101 (-3 en complemento a 2) $t1 11111111 11111111 11111111 11111101 31 24 23 16 15 8 7 0 2 n -1 ARCOS Estructura de Computadores 74

Espacio de direcciones y acceso a bytes Direcciones de bytes Byte (contenido) lbu $t1, 0x6 0 1 2 3 4 5 6 11111101 Dirección: 6 (000110) Contenido: 11111101 (-3 en complemento a 2) $t1 31 24 23 16 15 8 7 0 2 n -1 ARCOS Estructura de Computadores 75

Espacio de direcciones y acceso a bytes Direcciones de bytes Byte (contenido) lbu $t1, 0x6 0 1 2 3 4 5 6 11111101 Dirección: 6 (000110) Contenido: 11111101 (-3 en complemento a 2) $t1 00000000 00000000 0000000 11111101 31 24 23 16 15 8 7 0 2 n -1 ARCOS Estructura de Computadores 76

Espacio de direcciones y acceso a físico a bytes Lógicamente Byte lbu $t1, 0x5 Físicamente Palabra de 32 bits 0 7 1 8 2 4 3 3 4 5 5 3 6 2 7 7 0 7 8 4 3 4 5 3 2 7 8 12 16 byte 0 byte 1 byte 2 byte 3 $t1 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 77

Espacio de direcciones y acceso a físico a bytes Lógicamente Byte lbu $t1, 0x5 Físicamente Palabra de 32 bits 0x5 0 7 1 8 2 4 3 3 4 5 5 3 6 2 7 7 0 7 8 4 3 4 5 3 2 7 8 12 16 byte 0 byte 1 byte 2 byte 3 Para acceder al byte de la dirección 0x5 = 00000.000101 $t1 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 78

Espacio de direcciones y acceso a físico a bytes Lógicamente Byte lbu $t1, 0x5 Físicamente Palabra de 32 bits 0x5 0 7 1 8 2 4 3 3 4 5 5 3 6 2 7 7 0 7 8 4 3 4 5 3 2 7 8 12 16 byte 0 byte 1 byte 2 byte 3 Se transfiere la segunda palabra: 00000.000101 30 $t1 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 79

Espacio de direcciones y acceso a físico a bytes Lógicamente Byte lbu $t1, 0x5 Físicamente Palabra de 32 bits 0x5 0 7 1 8 2 4 3 3 4 5 5 3 6 2 7 7 0x1 0 7 8 4 3 4 5 3 2 7 8 16 byte 0 byte 1 byte 2 byte 3 Se transfiere al procesador 5 3 2 7 $t1 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 80

Espacio de direcciones y acceso a físico a bytes Lógicamente Byte lbu $t1, 0x5 Físicamente Palabra de 32 bits 0 7 1 8 2 4 3 3 4 5 5 3 6 2 7 7 0 7 8 4 3 4 5 3 2 7 8 12 16 byte 0 byte 1 byte 2 byte 3 $t1 5 3 2 7 Se copia el byte 01 (A1 A0) de la palabra 0 0 0 3 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 81

Almacenamiento de palabras en la memoria Direcciones de bytes Byte (contenido) 4 bytes forman una palabra 0 1 2 3 4 5 6 7 8 Palabra almacenada a partir del byte 0 Palabra almacenada a partir del byte 4 2 n -1 ARCOS Estructura de Computadores 82

Almacenamiento de palabras en la memoria Direcciones de bytes Byte (contenido) 0 1 2 3 4 5 6 7 8? Palabra de 32 bits byte0 byte1 byte2 byte3 31 24 23 16 15 8 7 0 + significativo - significativo 2 n -1 ARCOS Estructura de Computadores 83

Almacenamiento de palabras en la memoria Palabra de 32 bits byte0 byte1 byte2 byte3 31 24 23 16 15 8 7 0 + significativo - significativo A A+1 A+2 A+3 byte0 byte1 byte2 byte3 BigEndian A A+1 A+2 A+3 byte3 byte2 byte1 byte0 LittleEndian El número 27 (10 = 11011 (2 = 000000000000000000000000000011011 A A+1 A+2 A+3 00000000 00000000 00000000 00011011 BigEndian A A+1 A+2 A+3 00011011 00000000 00000000 00000000 LittleEndian ARCOS Estructura de Computadores 84

Espacio de direcciones y acceso a palabras Lógicamente lw $t1, 0x4 Byte 0 1 2 3 4 00000000 5 00000000 6 00000001 7 00001101 Dirección 4 (000110) Contenido: 00000000000000000000000100001101 (2 = 269 (10 Computador BigEndian $t1 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 85

Espacio de direcciones y acceso a físico a palabras Lógicamente Byte lw $t1, 0x4 Físicamente Palabra de 32 bits 0 1 2 3 4 00000000 5 00000000 6 00000001 7 00001101 0 4 00000000 00000000 00000001 00001101 8 12 16 byte 0 byte 1 byte 2 byte 3 $t1 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 86

Espacio de direcciones y acceso a físico a palabras Lógicamente Byte lw $t1, 0x4 Físicamente Palabra de 32 bits 0x4 0 1 2 3 4 00000000 5 00000000 6 00000001 7 00001101 0 4 00000000 00000000 00000001 00001101 8 12 byte 0 byte 1 byte 2 byte 3 Para acceder a la palabra de la dirección 0x4 = 00000.000100 $t1 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 87

Espacio de direcciones y acceso a físico a palabras Lógicamente Byte lw $t1, 0x4 Físicamente Palabra de 32 bits 0x4 0 1 2 3 4 00000000 5 00000000 6 00000001 7 00001101 0 4 00000000 00000000 00000001 00001101 8 12 byte 0 byte 1 byte 2 byte 3 Se transfiere al procesador 00000000 00000000 00000001 00001101 $t1 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 88

Espacio de direcciones y acceso a físico a palabras Lógicamente Byte lw $t1, 0x4 Físicamente Palabra de 32 bits 0 1 2 3 4 00000000 5 00000000 6 00000001 7 00001101 0 4 00000000 00000000 00000001 00001101 8 12 byte 0 byte 1 byte 2 byte 3 Se copia la palabra 00000000 00000000 00000001 00001101 $t1 00000000 00000000 00000001 00001101 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 89

Diferencias entre lw, lb, lbu, la Direcciones de bytes Byte (contenido) lw $t1, 0x0F000000 0x0F000000 0xCB 0x0F000001 0x12 0x0F000002 0x08 0x0F000003 0x02 ARCOS Estructura de Computadores 90

Diferencias entre lw, lb, lbu, la Direcciones de bytes Byte (contenido) lw $t1, 0x0F000000 0x0F000000 0xCB 0x0F000001 0x12 0x0F000002 0x08 0x0F000003 0x02 Se copia la palabra $t1 11001011 00010010 00001000 00000010 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 91

Diferencias entre lw, lb, lbu, la Direcciones de bytes Byte (contenido) lbu $t1, 0x0F000002 0x0F000000 0xCB 0x0F000001 0x12 0x0F000002 0x08 0x0F000003 0x02 Se copia el byte $t1 00000000 00000000 00000000 00001000 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 92

Diferencias entre lw, lb, lbu, la Direcciones de bytes Byte (contenido) la $t1, 0x0F000000 Se copia la dirección, no el contenido 0x0F000000 0xCB 0x0F000001 0x12 0x0F000002 0x08 0x0F000003 0x02 $t1 00001111 00000000 00000000 00000000 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 93

Ejemplo Direcciones Byte (contenido) de bytes li $t1, 18 li $t2, 24 0x0F000000 0x0F000001 0x0F000002 0x0F000003 0x0F000004 0x0F000005 0x0F000006 0x0F000007 ARCOS Estructura de Computadores 94

Ejemplo Direcciones Byte (contenido) de bytes li $t1, 18 li $t2, 24 0x0F000000 0x0F000001 0x0F000002 0x0F000003 0x0F000004 0x0F000005 0x0F000006 0x0F000007 $t1 00000000 00000000 00000000 00010010 31 24 23 16 15 8 7 0 $t2 00000000 00000000 00000000 00011000 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 95

Ejemplo Direcciones de bytes Byte (contenido) sw $t1, 0x0F000000 0x0F000000 00000000 0x0F000001 00000000 0x0F000002 00000000 0x0F000003 00010000 0x0F000004 0x0F000005 0x0F000006 0x0F000007 $t1 00000000 00000000 00000000 00010010 31 24 23 16 15 8 7 0 $t2 00000000 00000000 00000000 00011000 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 96

Ejemplo Direcciones de bytes Byte (contenido) sw $t1, 0x0F000000 sw $t2, 0x0F000004 0x0F000000 00000000 0x0F000001 00000000 0x0F000002 00000000 0x0F000003 00010000 0x0F000004 00000000 0x0F000005 00000000 0x0F000006 00000000 0x0F000007 00011000 $t1 00000000 00000000 00000000 00010010 31 24 23 16 15 8 7 0 $t2 00000000 00000000 00000000 00011000 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 97

Ejemplo Direcciones de bytes Byte (contenido) lw $t3, 0x0F000000 0x0F000000 00000000 0x0F000001 00000000 0x0F000002 00000000 0x0F000003 00010000 0x0F000004 00000000 0x0F000005 00000000 0x0F000006 00000000 0x0F000007 00011000 $t1 00000000 00000000 00000000 00010010 31 24 23 16 15 8 7 0 $t2 $t3 00000000 00000000 00000000 00011000 31 24 23 16 15 8 7 0 00000000 00000000 00000000 00010010 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 98

Datos no alineados Lógicamente Byte lw $t1, 0x05???? Físicamente Palabra de 32 bits 0 1 2 3 4 5 00000000 6 00000000 7 00000001 8 00001101 Palabra 0 4 00000000 00000000 00000001 12 00001101 16 20 byte 0 byte 1 byte 2 byte 3 La palabra que está almacenada a partir de la dirección 0x05 no está alineada porque se encuentra en dos palabras de memoria distintas ARCOS Estructura de Computadores 99

Alineación de datos dirección 0 4 8 12 16 20 24 31 23 15 7 0 Esta palabra está alineada, el resto no ARCOS Estructura de Computadores 100

Alineación de datos En general: Un dato que ocupa K bytes está alineado cuando la dirección D utilizada para accederlo cumple que: D mod K = 0 La alineación supone que: Los datos que ocupan 2 bytes se encuentran en direcciones pares Los datos que ocupan 4 bytes se encuentran en direcciones múltiplo de 4 Los datos que ocupan 8 bytes (double) se encuentran en direcciones múltiplo de 8 ARCOS Estructura de Computadores 101

Alineación de datos En general los computadores no permiten el acceso a datos no alineados Objetivo: minimizar el número de accesos a memoria El compilador se encarga de asignar a los datos las direcciones adecuadas Algunas arquitecturas como Intel permiten el acceso a datos no alineados El acceso a un dato no alineado implica varios accesos a memoria Palabra de 32 bits 0 4 00000000 00000000 00001110 8 00001101 16 20 byte 0 byte 1 byte 2 byte 3 ARCOS Estructura de Computadores 102

Resumen Un programa para poder ejecutarse debe estar cargado junto con sus datos en memoria Todas las instrucciones y los datos se almacenan en memoria, por tanto todo tiene una dirección de memoria Las instrucciones y los datos En un computador como el MIPS 32 (de 32 bits) Los registros son de 32 bits En la memoria se pueden almacenar bytes (8 bits) Instrucciones lb, lbu, sb, sbu En la memoria se pueden almacenar palabras (32 bits) Instrucciones lw, sw ARCOS Estructura de Computadores 103

Instrucciones y pseudoinstrucciones Una instrucción en ensamblador se corresponde con una instrucción máquina Ocupa 32 bits addi $t1, $t1, 2 Una pseudoinstrucción en ensamblador se corresponde con varias instrucciones máquina. li $t1, 0x00800010 No cabe en 32 bits, pero se puede utilizar como pseudoinstrucción. Es equivalente a: lui $t1, 0x0080 ori $t1, $t1, 0x0010 ARCOS Estructura de Computadores 104

Otro ejemplo de pseudoinstrucción La pseudoinstrucción move move reg2,reg1 Se convierte en: add reg2,$zero,reg1 ARCOS Estructura de Computadores 105

Otros usos de la instrucción lw, lb Direcciones de bytes Byte (contenido) 0x0F000000 0xCB 0x0F000001 0x12 0x0F000002 0x08 0x0F000003 0x02 $t0 $t1 31 24 23 16 15 8 7 0 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 106

Otros usos de la instrucción lw, lb Direcciones de bytes Byte (contenido) la $t0, 0x0F000002 0x0F000000 0xCB 0x0F000001 0x12 0x0F000002 0x08 0x0F000003 0x02 $t0 $t1 31 24 23 16 15 8 7 0 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 107

Otros usos de la instrucción lw, lb Direcciones de bytes Byte (contenido) la $t0, 0x0F000002 0x0F000000 0xCB 0x0F000001 0x12 0x0F000002 0x08 0x0F000003 0x02 Se copia la dirección, no el contenido $t0 $t1 00001111 00000000 00000000 00000010 31 24 23 16 15 8 7 0 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 108

Otros usos de la instrucción lw, lb Direcciones de bytes Byte (contenido) lbu $t0, ($t1) 0x0F000000 0xCB 0x0F000001 0x12 0x0F000002 0x08 0x0F000003 0x02 $t0 $t1 00001111 00000000 00000000 00000010 31 24 23 16 15 8 7 0 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 109

Otros usos de la instrucción lw, lb Direcciones de bytes Byte (contenido) lbu $t0, ($t1) 0x0F000000 0xCB 0x0F000001 0x12 0x0F000002 0x08 0x0F000003 0x02 Se copia el byte almacenado en la dirección almacenada en $t0 $t0 $t1 00001111 00000000 00000000 00000010 31 24 23 16 15 8 7 0 00000000 00000000 00000000 00001000 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 110

Otros usos de la instrucción lw, lb Direcciones de bytes Byte (contenido) lw $t0, ($t1) 0x0F000000 0xCB 0x0F000001 0x12 0x0F000002 0x08 0x0F000003 0x02 Se copia la palabra almacenada en la dirección almacenada en $t0 $t0 $t1 00001111 00000000 00000000 00000000 31 24 23 16 15 8 7 0 11001011 00010010 00001000 00000010 31 24 23 16 15 8 7 0 ARCOS Estructura de Computadores 111

Otros usos de la instrucción lw, lb lbu $t0, 0x0F000002 Direccionamiento directo. Se carga en $t0 el byte almacenado en la posición de memoria 0x0F000002 lbu $t0, ($t1) Direccionamiento indirecto de registro. Se carga en $t0 el byte almacenado en la posición de memoria almacenada en $t1 lbu $t0, 80($t1) Direccionamiento relativo. Se carga en $t0 el byte almacenado en la posición de memoria que se obtiene de sumar el contenido de $t1 con 80 ARCOS Estructura de Computadores 112

Instrucciones de escritura en memoria sw $t0, 0x0F000000 Copia la palabra almacenada en $t0 en la dirección 0x0F000000 sb $t0, 0x0F000000 Copia la byte almacenada en $t0 en la dirección 0x0F000000 ARCOS Estructura de Computadores 113

Tipo de datos básicos enteros int resultado ; int op1 = 100 ; int op2 = -10 ;... main () { resultado = op1 + op2 ;... }.data resultado:.word 0 op1:.word 100 op2:.word -10....text.globl main main: lw $t1 op1 lw $t2 op2 add $t3 $t1 $t2 la $t4 resultado sw $t3 ($t4)... ARCOS Estructura de Computadores 114

Ejercicio Indique un fragmento de código en ensamblador con la misma funcionalidad que: int b; int a = 100 ; int c = 5 ; int d main () { } d = 80; b = -(a+b*c+a); Asumiendo que a, b, c y d son variables que residen en memoria ARCOS Estructura de Computadores 115

Tipo de datos básicos vectores.data.align 2 #siguiente dato alineado a 4 int vec[5] ;... vec:.space 20 #5 elem.*4 bytes main () { v[4] = 8; }.text main:....globl main la $t1 vec li $t2 8 sw $t2 16($t1) ARCOS Estructura de Computadores 116

Tipo de datos básicos vectores.data.align 2 #siguiente dato alineado a 4 int vec[5] ;... main () { v[4] = 8; } vec:.space 20 #5 elem.*4 bytes.text.globl main main: li $t0 16 la $t1 vec add $t3, $t1, $t0 li $t2 8 sw $t2, ($t3)... ARCOS Estructura de Computadores 117

Tipo de datos básicos vectores.data int vec[5] ;... main () { v[4] = 8; }.align 2 #siguiente dato alineado a 4 vec:.space 20 #5 elem.*4 bytes.text main:....globl main li $t2 8 li $t1 16 sw $t2 vec($t1) ARCOS Estructura de Computadores 118

Ejercicio Si V es un array de números enteros (int) V representa la dirección de inicio de vector En qué dirección se encuentra el elemento V[5]? Qué instrucción permite cargar en el registro $t0 el valor v[5]? ARCOS Estructura de Computadores 119

Tipo de datos básicos vectores.data.align 2 #siguiente dato alineado a 4 int vec[5] ; int mat[2][3] = {{11,12,13}, {21,22,23}};... main () { m[0][1] = m[0][0] + m[1][0] ;... } vec:.space 20 #5 elem.*4 bytes mat:.word 11, 12, 13.word 21, 22, 23....text.globl main main:... lw $t1 mat+0 lw $t2 mat+12 add $t3 $t1 $t2 sw $t3 mat+4 ARCOS Estructura de Computadores 120

Tipo de datos básicos string.data char c1 ; char c2= h ; char *ac1 = hola ;... main () { printf( %s,ac1) ;... } c1:.space 1 # 1 byte c2:.byte h ac1:.asciiz hola....text.globl main main: li $v0 4 la $a0 ac1 syscall... ARCOS Estructura de Computadores 121

Vectores y cadenas En general: lw $t0, 4($s3) # $t0 M[$s3+4] sw $t0, 4($s3) # M[$s3+4] $t0 ARCOS Estructura de Computadores 122

Ejercicio Escriba un programa en ensamblador equivalente a: int vec[100] ;... main () { int i = 0; for (i = 0; i < 100; i++) vec[i] = 5; } Asumiendo que en $a0 se encuentra almacenada la dirección del vector ARCOS Estructura de Computadores 123

Ejercicio Escriba un programa en ensamblador equivalente a: int vec[100] ;... main () { int i = 0; suma = 0; } for (i = 0; i < 100; i++) suma = suma + vec[i]; Asumiendo que en $a0 se encuentra almacenada la dirección del vector y que el resultado ha de almacenarse en $v0 ARCOS Estructura de Computadores 124

Ejercicio Escriba un programa que: Calcule la longitud de la cadena de caracteres: La dirección de la cadena se encuentra en $a0 El resultado se dejará en $v0 ARCOS Estructura de Computadores 125

Ejercicio Escriba un programa que: Indique el número de veces que aparece un carácter en una cadena de caracteres La dirección de la cadena se encuentra en $a0 El carácter a buscar se encuentra en $a1 El resultado se dejará en $v0 ARCOS Estructura de Computadores 126

Instrucciones de coma flotante Banco de registros de coma flotante (32 registros) $f0, $f1,.. $31 Para valores de simple precisión: $f0,.. $f31 Para valores de doble precisión (64 bits) se utilizan por parejas: $f0, $f2, $f4,. FPU $f1 $f0 $f3 $f2 $f31 $f30 B.R. ALU BUS ARCOS Estructura de Computadores 127

Operaciones en coma flotante Aritmética de coma flotante IEEE 754 en la FPU Ejemplos: Suma simple precisión add.s $f0 $f1 $f4 f0 = f1 + f4 Suma doble precisión add.d $f0 $f2 $f4 FPU $f1 $f0 $f3 $f2 $f31 $f30 (f0,f1) = (f2,f3) + (f4,f5) Otras operaciones en simple precisión: add.s, sub.s, mul.s, div.s, abs.s Operaciones en doble precisión: add.d, sub.d, mul.d, div.d, abs.d BUS ALU B.R. ARCOS Estructura de Computadores 128

Tipo de datos básicos float.data float resultado ; float op1 = 100 ; float op2 = -10 ;... resultado:.float op1:.float 100 op2:.float -10....text.globl main main () { resultado = op1 + op2 ;... } main: l.s $f0 op1 l.s $f1 op2 add.s $f3 $f1 $f2 s.s $f3 resultado... ARCOS Estructura de Computadores 129

Tipo de datos básicos double.data double resultado ; double op1 = 100 ; double op2 = -10.27 ;... resultado:.double op1:.double 100 op2:.double -10.27....text.globl main main () { resultado = op1 * op2 ;... } main: l.d $f0 op1 # ($f0,$f1) l.d $f2 op2 # ($f2,$f3) mul.d $f6 $f0 $f2 s.s $f6 resultado... ARCOS Estructura de Computadores 130

Operaciones con registros mtc1 $t0 $f1 CPU FPU t0 t1 B.R. enteros $f1 $f0 $f3 $f2 $f31 $f30 B.R. U.C ALU ALU BUS BUS ARCOS Estructura de Computadores 131

Operaciones con registros mfc1 $t0 $f1 CPU FPU t0 t1 B.R. enteros $f1 $f0 $f3 $f2 $f31 $f30 B.R. U.C ALU ALU BUS BUS ARCOS Estructura de Computadores 132

Operaciones de conversión cvt.s.w $f2 $f1 Convierte un entero ($f1) a simple precisión ($f2) cvt.w.s $f2 $f1 Convierte de simple precisión ($f1) a entero ($f2) cvt.d.w $f2 $f0 Convierte un entero ($f0) a doble precisión ($f2) cvt.w.d $f2 $f0 Convierte de doble precisión ($f0) a entero ($f2) cvt.d.s $f2 $f0 Convierte de simple precisión ($f0) a doble ($f2) cvt.s.d $f2 $f0 Convierte de doble precisión ($f0) a simple($f2) ARCOS Estructura de Computadores 133

Ejemplo float PI = 3,1415; int radio = 4; float longitud; longitud = PI * radio;.text main:.globl main li.s $f0 3.1415 li $t0 4 mtc1 $t0 $f1 # 4 en Ca2 cvt.s.w $f2 $f1 # 4 ieee754 mul.s $f0 $f2 $f1 ARCOS Estructura de Computadores 134

Ejemplo float PI = 3,1415; int radio = 4; float longitud; longitud = PI * radio;.text main:.globl main li.s $f0 3.1415 li $t0 4 CPU t0 t1 B.R. enteros FPU $f1 $f0 $f3 $f2 $f31 $f30 B.R. mtc1 $t0 $f1 # 4 en Ca2 cvt.s.w $f2 $f1 # 4 ieee754 mul.s $f0 $f2 $f1 U.C ALU ALU BUS BUS ARCOS Estructura de Computadores 135

Ejercicio Escriba un programa que: Cargue el valor 3.141516 en el registro $f0 Permita obtener el valor del exponente y de la mantisa almacenada en el registro $f0 (en formato IEEE 754) Exponente en el registro $v0 Mantisa en el registro $v1 ARCOS Estructura de Computadores 136

Información de una instrucción El tamaño de la instrucción se ajusta al de palabra (o múltiplo) Se divide en campos: Operación a realizar Operandos a utilizar Puede haber operando implícitos El formato de una instrucción indica los campos y su tamaño: Uso de formato sistemático Tamaño de un campo limita los valores que codifica ARCOS Estructura de Computadores 138

Información de una instrucción Se utiliza unos pocos formatos: Una instrucción pertenecen a un formato Según el código de operación se conoce el formato asociado Ejemplo: formatos en MIPS Tipo R aritméticas Tipo I transferencia inmediato op. rs rt rd shamt func. 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits op. rs rt offset 6 bits 5 bits 5 bits 16 bits Tipo J saltos op. 6 bits offset 26 bits ARCOS Estructura de Computadores 139

Campos de una instrucción En los campos se codifica: Operación a realizar (código Op.) Instrucción y formato de la misma Operandos a utilizar Ubicación de los operandos Ubicación del resultado Ubicación de la siguiente instrucción (si op. salto) Implícito: PC PC + 4 (apuntar a la siguiente instrucción) Explícito: j 0x01004 (modifica el PC) ARCOS Estructura de Computadores 140

Ubicaciones posibles para los operandos En la propia instrucción En los registros del procesador En memoria principal En unidades de Entrada/Salida (I/O) ARCOS Estructura de Computadores 141

Modos de direccionamiento El modo de direccionamiento es un procedimiento que permite determinar la ubicación de un operando o una instrucción Tipos: Inmediato Directo De registro Indirecto Indirecto de registro Relativo A registro base A registro índice A contador de programa Implícito De pila ARCOS Estructura de Computadores 142

Direccionamiento inmediato El operando es parte de la instrucción. Ejemplo: li $a0 25 addi $t1 $t2 50 Es rápido: no es necesario acceder a memoria. No siembre cabe el valor en una palabra: li $t1, 0x00800010 No cabe en 32 bits, es equivalente a: lui $t1, 0x0080 ori $t1, $t1, 0x0010 ARCOS Estructura de Computadores 143

Direccionamiento de registro El operando se encuentra en el registro. Ejemplo: move $a0 $a1 Copia en el registro $a0 el valor que hay en el registro $a1. El identificador de $a0 y $a1 está en codificado la instrucción. op rs rt 16 bits Operando B.Reg. Ventajas: Acceso a registros es rápido El número de registros es pequeño => pocos bits para sucodificación, instrucciones más cortas ARCOS Estructura de Computadores 144

Direccionamiento directo El operando se encuentra en memoria, y la dirección está codificada en la instrucción. Ejemplo: lw $t1, 0xFFF03000 Carga en $t1 lo que hay en la posición de memoria 0xFFF03000 memoria Operando op rs rt 16 bits Problemas: Acceso a memoria es lento comparado con los registros Direcciones largas => instrucciones más largas ARCOS Estructura de Computadores 145

Direccionamiento indirecto de registro Se indica en la instrucción el registro que almacena la dirección del operando Ejemplo: lw $a0 ($a1) Carga en $a0 lo que hay en la dirección de memoria que almacenada en $a1. B.Reg. dirección memoria operando op rs rt 16 bits Ventajas: Instrucciones cortas ARCOS Estructura de Computadores 146

Direccionamiento indirecto a memoria Se indica en la instrucción la dirección de la dirección del operando (no disponible en el MIPS) Ejemplo: LD R1 [DIR] (IEEE 694) Carga en R1 lo que hay en la dirección de memoria que está almacenada en la dirección de memoria DIR. memoria operando dirección2 op direccion1 Problemas: Puede requerir varios accesos a memoria Es más lento ARCOS Estructura de Computadores 147

Direccionamiento relativo a registro base Ejemplo: lw $a0 12($t1) Carga en $a0 lo que hay en la posición de memoria dada por $t1 + 12 Instrucción Codop Registro R Desplazamiento Registros Memoria Dirección de memoria + Operando ARCOS Estructura de Computadores 148

Utilidad: acceso a vectores Se carga en el registro la dirección de inicio del vector int vec[5] ;... main () { v[4] = 8;.data.align 2 #siguiente dato alineado a 4 vec:.space 20 #5 elem.*4 bytes.text.globl main main:... la $t1 vec li $t2 8 sw $t2 16($t1) } ARCOS Estructura de Computadores 149

Direccionamiento relativo a registro índice Ejemplo: lw $a0 direccion($t1) Carga en $a0 lo que hay en la posición de memoria dada por $t1 + direccion $t1 representa un índice Instrucción Codop Registro R dirección Registros Memoria Índice/desplazamiento + Operando ARCOS Estructura de Computadores 150

Utilidad: acceso a vectores Se carga en el registro la dirección de inicio del vector int vec[5] ;... main () { v[3] = 8; v[4] = 8;.data.align 2 #siguiente dato alineado a 4 vec:.space 20 #5 elem.*4 bytes.text.globl main main: li $t1 12 li $t2 8 sw $t2 vec($t1) addi $t1 $t1 4 sw $t2 vec($t1)... } ARCOS Estructura de Computadores 151

Direccionamiento relativo a contador de programa Ejemplo: beqz $t1 etiqueta Si $t1 es 0, se actualiza el PC => PC = PC + etiqueta Etiqueta representa un desplazamiento Instrucción Codop desplazamiento PC + ARCOS Estructura de Computadores 152

Contador de programa en el MIPS 32 Los registros tienen 32 bits El contador de programa tiene 32 bits Las instrucciones ocupan 32 bits (una palabra) El contador de programa almacena la dirección donde se encuentra una instrucción La siguiente instrucción se encuentra 4 bytes después. Por tanto el contador de programa se actualiza: PC = PC + 4 Dirección: Instrucción: 0x00400000 or $2,$0,$0 0x00400004 slt $8,$0,$5 0x00400008 beq $8,$0,3 0x0040000c add $2,$2,$4 0x00400010 addi $5,$5,-1 0x00400014 j 0x100001 ARCOS Estructura de Computadores 153

Direccionamiento relativo a PC en el MIPS La instrucción beq en la instrucción: 6 5 5 CO rs rt $9,$0, etiqueta se codifica 16 Dato inmediato Etiqueta tiene que codificarse en el campo Dato inmediato Cómo se actualiza el PC si $9 == $0 y cuento vale fin cuando se genera código máquina? bucle: beq $t0,$1, fin add $t8,$t4,$4t4 addi $t0,$0,-1 j bucle fin: ARCOS Estructura de Computadores 154

Direccionamiento relativo a PC en el MIPS Si se cumple la condición PC = PC + (etiqueta* 4) Por tanto en: bucle: beq $t0,$1, fin add $t8,$t4,$4t4 addi $t0,$0,-1 j bucle fin: fin == 3 ARCOS Estructura de Computadores 155

Utilidad: desplazamientos en bucles fin representa la dirección donde se encuentra la instrucción move li $t0 8 li $t1 4 li $t2 1 li $t4 0 while: bge $t4 $t1 fin mul $t2 $t2 $t0 addi $t4 $t4 1 b while fin: move $t2 $t4 ARCOS Estructura de Computadores 156

Utilidad: desplazamientos en bucles li $t0 8 li $t1 4 li $t2 1 li $t4 0 while: bge $t4 $t1 fin mul $t2 $t2 $t0 addi $t4 $t4 1 b while fin: move $t2 $t4 Dirección 0x0000100 0x0000104 0x0000108 0x000010C 0x0000110 0x0000114 0x0000118 0x000011C 0x0000120 Contenido li $t0 8 li $t1 4 li $t2 1 li $t4 0 bge $t4 $t1 fin mul $t2 $t2 $t0 addi $t4 $t4 1 b while move $t2 $t4 ARCOS Estructura de Computadores 157

Utilidad: desplazamientos en bucles li $t0 8 li $t1 4 li $t2 1 li $t4 0 while: bge $t4 $t1 fin mul $t2 $t2 $t0 addi $t4 $t4 1 b while fin: move $t2 $t4 fin representa un desplazamiento respecto al PC actual => 3 PC = PC + 3 * 4 while representa un desplazamiento respecto al PC actual =>-5 PC = PC + (-5)*4 Dirección 0x0000100 0x0000104 0x0000108 0x000010C 0x0000110 0x0000114 0x0000118 0x000011C 0x0000120 Contenido li $t0 8 li $t1 4 li $t2 1 li $t4 0 bge $t4 $t1 fin mul $t2 $t2 $t0 addi $t4 $t4 1 b while move $t2 $t4 ARCOS Estructura de Computadores 158

Diferencia entre las instrucción b y j Instrucción j direccion op. 6 bits direccion 26 bits Dirección de salto => PC = direccion Instrucción b desplazamiento op. 6 bits 5 bits 5 bits desplazamiento 16 bits Dirección de salto => PC = PC + desplazamiento ARCOS Estructura de Computadores 159

Direccionamiento implícito El operando no está codificado en la instrucción, pero forma parte de esta. Ejemplo: beqz $a0 etiqueta1 Si registro $a0 es cero, salta a etiqueta. $a0 es un operando, $zero es el otro. op rs 16 bits Ventajas Es rápido: no es necesario acceder a memoria. Instrucciones más cortas ARCOS Estructura de Computadores 160

Direccionamiento de pila PUSH Reg Apila el contenido del registro (dato) cima $sp dato cima $sp crece hacia direcciones bajas ARCOS Estructura de Computadores 161

Direccionamiento de pila POP Reg Desapila el contenido del registro (dato) Copia dato en el registro Reg dato cima $sp dato cima $sp crece hacia direcciones bajas ARCOS Estructura de Computadores 162

Direccionamiento de pila 163 MIPS no dispone de instrucciones PUSH o POP. El registro puntero de pila ($sp) es visible al programador. Se va a asumir que el puntero de pila apunta al último elemento de la pila PUSH $t0 sub $sp, $sp, 4 sw $t0, ($sp) POP $t0 lw $t0, ($sp) add $sp, $sp, 4 ARCOS Estructura de Computadores 163

Ejemplos de tipos de direccionamiento la $t0 label inmediato El segundo operando de la instrucción es una dirección PERO no se accede a esta dirección, la propia dirección es el operando lw $t0 label directo a memoria El segundo operando de la instrucción es una dirección Hay que acceder a esta dirección para tener el valor con el que trabajar bne $t0 $t1 label relativo a registro PC El tercer operando de la instrucción representa un desplazamiento PERO no se accede a esta dirección, la propia dirección es PARTE del operando En el formato de esta instrucción, label se codifica como un número en complemento a dos que representa el desplazamiento (como palabras) relativo al registro PC ARCOS Estructura de Computadores 164

Modos de direccionamiento en el MIPS Direccionamientos: Inmediato valor De registro $r Directo dir Indirecto de registro ($r) Relativo a registro desplazamiento($r) Relativo a PC beq etiqueta Relativo a pila desplazamiento($sp) ARCOS Estructura de Computadores 165

Formato de instrucciones Una instrucción máquina es autocontenida e incluye: Código de operación Dirección de los operandos Dirección del resultado Dirección de la siguiente instrucción Tipos de representación de los operandos Una instrucción se divide en campos Ejemplo de campos en una instrucción del MIPS: op. rs rt rd shamt func. ARCOS Estructura de Computadores 166

Formato de instrucciones Una instrucción normalmente ocupa una palabra pero puede ocupar más en algunos computadores En el caso del MIPS todas las instrucciones ocupan una palabra Campo de código: Con n bits se pueden codificar 2 n instrucciones Si se quiere codificar más se utiliza un campo de extensión Ejemplo: en el MIPS las instrucciones aritméticas tienen como código de op = 0. La función concreta se codifica en el campo func. Tipo R aritméticas op. rs rt rd shamt func. ARCOS Estructura de Computadores 167

Formato de una instrucción 168 Especifica el significado de cada uno de los bits que forma la instrucción. Longitud del formato: Número de bits que componen la instrucción. La instrucción se divide en campos. Normalmente una arquitectura ofrece unos pocos formatos de instrucción. Simplicidad en el diseño de la unidad de control. Uso sistemático: Campos del mismo tipo siempre igual longitud. Selección mediante código de operación. Normalmente el primer campo. ARCOS Estructura de Computadores 168

Longitud de formato 169 Alternativas: Longitud única: Todas las instrucciones tienen la misma longitud de formato. MIPS32: 32 bits PowerPC: 32 bits Longitud variable: Distintas instrucciones tienen distinta longitud de formato. Cómo se sabe la longitud de la instrucción? Cod. Op. IA32 (Procesadores Intel): Número variable de bytes. ARCOS Estructura de Computadores 169

170 Ejemplo: Formato de las instrucciones del MIPS 6 5 5 5 5 6 CO rs rt rd sa func 6 26 add $t0, $t0, $t1 CO Dato inmediato 6 5 5 16 addi $t0, $t0, 1 CO rs rt Dato inmediato ARCOS Estructura de Computadores 170

Ejemplo de formato en el MIPS MIPS Instruction: add $8,$9,$10 Formato a utilizar: 6 5 5 5 5 6 CO rs rt rd sa func Representación decimal de cada campo: 0 9 10 8 0 32 Representación binaria de cada campo 000000 01001 01010 01000 00000 100000 ARCOS Estructura de Computadores 171

Ejemplo de formato en el MIPS MIPS Instruction: addi $21,$22,-50 Formato a utilizar: 6 5 5 CO rs rt 16 Dato inmediato Representación decimal de cada campo: 8 22 21-50 Representación binaria de cada campo 001000 10110 10101 1111111111001110 ARCOS Estructura de Computadores 172

Cómo utilizar addi con un valor de 32 bits? Qué ocurre si se utiliza desde el ensamblador? addi $t0,$t0, 0xABABCDCD El valor inmediato es de 32 bits. Esta instrucción no se puede codificar en una palabra de 32 bits. ARCOS Estructura de Computadores 173

Cómo utilizar addi con un valor de 32 bits? Qué ocurre si se utiliza desde el ensamblador? addi $t0,$t0, 0xABABCDCD El valor inmediato es de 32 bits. Esta instrucción no se puede codificar en una palabra de 32 bits. Solución Desde el ensamblador se puede utilizar, pero al final se traduce en: lui $at, 0xABAB ori $at, $at, 0xCDCD add $t0, $t0, $at El registro $at está reservado para el ensamblador por convenio ARCOS Estructura de Computadores 174

Pregunta 175 Cómo sabe la unidad de control el formato de la instrucción que está ejecutando? Cómo sabe la unidad de control el número de operandos de una instrucción? Cómo sabe la unidad de control el formato de cada operación? ARCOS Estructura de Computadores 175

Código de operación 176 Tamaño fijo: n bits 2 n códigos de operación. m códigos de operación log 2 m bits. Campos de extensión MIPS (instrucciones aritméticas-lógicas) Tipo R aritméticas op. rs rt rd shamt func. Tamaño variable: Instrucciones más frecuentes = Tamaños más cortos. ARCOS Estructura de Computadores 176

Ejemplo Sea un computador de 16 bits de tamaño de palabra, que incluye un repertorio con 60 instrucciones máquina y con un banco de registros que incluye 8 registros. Se pide: Indicar el formato de la instrucción ADDx R1 R2 R3, donde R1, R2 y R3 son registros. ARCOS Estructura de Computadores 177

Solución palabra -> 16 bits 60 instrucciones 8 registros (en BR) ADDx R1(reg.), R2(reg.), R3(reg.) Palabra de 16 bits define el tamaño de la instrucción 16 bits ARCOS Estructura de Computadores 178

Solución palabra -> 16 bits 60 instrucciones 8 registros (en BR) ADDx R1(reg.), R2(reg.), R3(reg.) Supongo un solo formato de instrucciones para todas Para 60 instrucciones necesito 6 bits (mínimo) 6 bits 16 bits Código de operación ARCOS Estructura de Computadores 179

Solución palabra -> 16 bits 60 instrucciones 8 registros (en BR) ADDx R1(reg.), R2(reg.), R3(reg.) Para 8 registros necesito 3 bits (mínimo) 16 bits 6 bits 3 bits 3 bits 3 bits Código de operación Operandos (3 registros) ARCOS Estructura de Computadores 180

Solución palabra -> 16 bits 60 instrucciones 8 registros (en BR) ADDx R1(reg.), R2(reg.), R3(reg.) Sobra 1 bit (16-6-3-3-3 = 1), usado de relleno 16 bits 6 bits 3 bits 3 bits 3 bits 1 bit Código de operación Operandos (3 registros) ARCOS Estructura de Computadores 181

Ejercicio Sea un computador de 16 bits, que direcciona la memoria por bytes y que incluye un repertorio con 60 instrucciones máquina. El banco de registros incluye 8 registros. Indicar el formato de la instrucción ADDV R1, R2, M, donde R1 y R2 son registros y M es una dirección de memoria. ARCOS Estructura de Computadores 182

Ejercicio Sea un computador de 32 bits, que direcciona la memoria por bytes. El computador incluye 64 instrucciones máquina y 128 registros. Considere la instrucción SWAPM dir1, dir2, que intercambia el contenido de las posiciones de memoria dir1 y dir2. Se pide: Indicar el espacio de memoria direccionable en este computador. Indicar el formato de la instrucción anterior. Especifique un fragmento de programa en ensamblador del MIPS 32 equivalente a la instrucción máquina anterior. Si se fuerza a que la instrucción quepa en una palabra, qué rango de direcciones se podría contemplar considerando que las direcciones se representan en binario puro. ARCOS Estructura de Computadores 183

CISC-RISC CISC: Complex Instruction Set Architecture. Muchas instrucciones. Complejidad variable. Diseño irregular. RISC: Reduced Instruction Set Code Instrucciones bastante simples. Número reducido de instrucciones. Instrucciones de tamaño fijo. Banco de registros grande. La mayoría de las instrucciones usan registros. Paso de parámetros a través del banco de registros. Arquitecturas segmentadas. ARCOS Estructura de Computadores 184

Modelos de ejecución 185 Una máquina tiene un modelo de ejecución asociado. Modelo de ejecución indica el número de direcciones y tipo de operandos que se pueden especificar en una instrucción. 0 direcciones Pila. 1 dirección Registro acumulador 2 direcciones Registros, Registro-Memoria, Memoria- Memoria. 3 direcciones Registros, Registro-Memoria, Memoria- Memoria ARCOS Estructura de Computadores 185

Modelo de 3 direcciones 186 Registros Los 3 operandos son registros. Requiere operaciones de carga/almacenamiento. ADD.R0,.R1,.R2 Memoria-Memoria Los 3 operandos son direcciones de memoria. ADD /DIR1, /DIR2, /DIR3 Registro-Memoria Híbrido. ADD.R0, /DIR1, /DIR2 ADD.R0,.R1, /DIR1 ARCOS Estructura de Computadores 186

Caso práctico 187 X = A + B * C /DA /DB /DC A B C Modelo de ejecución /DX X ARCOS Estructura de Computadores 187

3 direcciones: R-R 188 LOAD.R0, /DB LOAD.R1, /DC MUL.R0,.R0,.R1 LOAD.R2, /DA ADD.R0,.R0,.R2 STORE.R0, /DX 6 instrucciones 4 acceso a memoria de datos 10 accesos a registros ARCOS Estructura de Computadores 188

3 direcciones: M-M 189 MUL /DX, /DB, /DC ADD /DX, /DX, /DA 2 instrucciones 6 acceso a memoria de datos 0 accesos a registro ARCOS Estructura de Computadores 189

Modelo de 2 direcciones 190 Registros Los 2 operandos son registros. Requiere operaciones de carga/almacenamiento. ADD.R0,.R1 (R0 <- R0 + R1) Memoria-Memoria Los 2 operandos son direcciones de memoria. ADD /DIR1, /DIR2 (MP[DIR1] <- MP[DIR1] + MP[DIR2]) Registro-Memoria Híbrido. ADD.R0, /DIR1 (R0 <- R0 + MP[DIR1]) ARCOS Estructura de Computadores 190

2 direcciones: R-R 191 LOAD.R0, /DB LOAD.R1, /DC MUL.R0,.R1 LOAD.R3, /DA ADD.R0,.R3 STORE.R0, /DX 6 instrucciones 4 acceso a memoria de datos 8 accesos a registro ARCOS Estructura de Computadores 191

2 direcciones: M-M 192 MOVE /DX, /DB MUL /DX, /DC ADD /DX, /DA 3 instrucciones 6 acceso a memoria de datos 0 accesos a registro ARCOS Estructura de Computadores 192

2 direcciones: R-M 193 LOAD.R0, /DB MUL.R0, /DC ADD.R0, /DA STORE.R0, /DX 4 instrucciones 4 accesos a memoria de datos 4 accesos a registro ARCOS Estructura de Computadores 193

Modelo de 1 dirección 194 Todas las operaciones utilizan un operando implícito: Registro acumulador Ejemplo: ADD R1 -> AC <- AC + R1 Operaciones de carga y almacenamiento siempre sobre acumulador. Posibilidad de movimiento entre registro acumulador y otros registros ARCOS Estructura de Computadores 194

1 dirección 195 LOAD /DB MUL /DC ADD /DA STORE /DX 4 instrucciones 4 accesos a memoria de datos 0 accesos a registro ARCOS Estructura de Computadores 195

Modelo de 0 direcciones 196 Todas las operaciones referidas a la pila. Operandos en la cima de la pila. Al hacer la operación se retiran de la pila. Resultado se coloca en la cima de la pila. Dos operaciones especiales: PUSH POP ARCOS Estructura de Computadores 196

Operación sobre la pila 197 PUSH 5 PUSH 7 ADD POP /DX PUSH 5 PUSH 7 7 5 ADD 12 POP /DX ARCOS Estructura de Computadores 197

0 direcciones 198 PUSH /DB PUSH /DC MUL PUSH /DA ADD POP /DX 6 instrucciones 4 accesos a memoria de datos 10 accesos a memoria de pila ARCOS Estructura de Computadores 198

199 Recordatorio: Información de instrucción Información: Operación a realizar. Operandos. Resultado. Ubicación de siguiente instrucción. Parte de la información puede ser implícita. ARCOS Estructura de Computadores 199

Lenguajes de alto nivel: Funciones 201 int main() { int z; z=factorial(x); print_int(z); } int factorial(int x) { int i; int r=1; for (i=1;i<=x;i++) { r*=i; } return r; } ARCOS Estructura de Computadores 201

Ensamblador: Subrutina 202 factorial: jal factorial jr $ra ARCOS Estructura de Computadores 202

Ensamblador: Lenguaje máquina 203 0x00401000 0x00001000 0x00001004 jal 0x00401000 jr $ra $ra = PC = 0x00001004 PC = 0x00401000 ARCOS Estructura de Computadores 203

Ensamblador: Lenguaje máquina 204 0x00401000 0x00001000 0x00001004 jal 0x00401000 jr $ra $ra = 0x00001004 ARCOS Estructura de Computadores 204

Ensamblador: Lenguaje máquina 205 0x00401000 0x00001000 0x00001004 jal 0x00401000 jr $ra PC = $ra = 0x00001004 $ra = 0x00001004 ARCOS Estructura de Computadores 205

Ensamblador: Lenguaje máquina 206 0x00401000 0x00001000 0x00001004 jal 0x00401000 jr $ra PC = $ra = 0x00001004 ARCOS Estructura de Computadores 206

jal/jr 207 Qué hace la instrucción jal? $ra $PC $PC Dirección de salto Qué hace la instrucción jr? $PC $ra ARCOS Estructura de Computadores 207

Llamadas anidadas 0x00401000 jal 0x000080000 0x00008000 0x00001000 0x00001004 jal 0x00401000 jr $ra jr $ra $ra = PC = 0x00001004 PC = 0x00401000 ARCOS Estructura de Computadores 208

Llamadas anidadas 0x00401000 0x00401020 0x00401024 jal 0x000080000 0x00008000 0x00001000 0x00001004 jal 0x00401000 jr $ra jr $ra $ra = PC = 0x00401024 PC = 0x00008000 ARCOS Estructura de Computadores 209

Llamadas anidadas 0x00401000 0x00001000 0x00001004 jal 0x00401000 0x00401020 0x00401024 jal 0x000080000 jr $ra 0x00008000 jr $ra PC = $ra = 0x00401024 ARCOS Estructura de Computadores 210

Llamadas anidadas 0x00401000 0x00401020 0x00401024 jal 0x000080000 0x00008000 0x00001000 0x00001004 jal 0x00401000 jr $ra jr $ra? PC = $ra = 0x00401024 ARCOS Estructura de Computadores 211

Llamadas anidadas 0x00401000 0x00001000 0x00001004 jal 0x00401000 0x00401020 0x00401024 jal 0x000080000 jr $ra? 0x00008000 jr $ra PC = $ra = 0x00401024 Se ha perdido la dirección de retorno ARCOS Estructura de Computadores 212

Dónde guardar la dirección de retorno? El computador dispone de dos elementos para almacenamiento Registros Memoria No se pueden utilizar los registros porque su número es limitado Se guarda en memoria principal En una zona del programa que se denomina pila ARCOS Estructura de Computadores 213

Ejecución de un programa Memoria Principal Sistema Operativo Disco instrucciones Programa en ejecucion datos pila Fichero ejecutable ARCOS Estructura de Computadores 214

Mapa de memoria de un proceso memoria Segmento de Texto Segmento de Datos Segmento de Pila pc 01011001 $sp 01011001 El programa de usuario se divide en segmentos Segmento de pila Variables locales Contexto de funciones Segmento de datos Datos estáticos, variables globales Segmento de código (texto) Código, instrucciones máquina ARCOS Estructura de Computadores 215

Pila PUSH Reg Apila el contenido del registro (dato) cima $sp dato cima $sp crece hacia direcciones bajas ARCOS Estructura de Computadores 216

Pila POP Reg Desapila el contenido del registro (dato) Copia dato en el registro Reg dato cima $sp dato cima $sp crece hacia direcciones bajas ARCOS Estructura de Computadores 217

Antes de empezar 218 MIPS no dispone de instrucciones PUSH o POP. El registro puntero de pila ($sp) es visible al programador. Se va a asumir que el puntero de pila apunta al último elemento de la pila PUSH $t0 subu $sp, $sp, 4 sw $t0, ($sp) POP $t0 lw $t0, ($sp) addu $sp, $sp, 4 ARCOS Estructura de Computadores 218

Pila uso de push y pop consecutivos push $a0 push $t1 push $t2 push $s2... pop $s2 pop $t2 pop $t1 pop $a0 ARCOS Estructura de Computadores 219

Pila uso de push y pop consecutivos push $a0 push $t1 push $t2 push $s2... sub $sp $sp 4 sw $a0 ($sp) sub $sp $sp 4 sw $t1 ($sp) sub $sp $sp 4 sw $t2 ($sp) sub $sp $sp 4 sw $s2 ($sp)... pop $s2 pop $t2 pop $t1 pop $a0 lw $s2 ($sp) add $sp $sp 4 lw $s2 ($sp) add $sp $sp 4 lw $s2 ($sp) add $sp $sp 4 lw $s2 ($sp) add $sp $sp 4 ARCOS Estructura de Computadores 220

Marco de pila uso de multiples push y pop agrupados push $a0 push $t1 push $t2 push $s2 sub $sp $sp 16 sw $a0 12($sp) sw $t1 8($sp) sw $t2 4($sp) sw $s2 ($sp)...... pop $s2 pop $t2 pop $t1 pop $a0 lw $s2 ($sp) lw $t2 4($sp) lw $t1 8($sp) lw $a0 12($sp) add $sp $sp 16 ARCOS Estructura de Computadores 221

222 Ejemplo (1) Se parte de un código en lenguaje de alto nivel int main() { int z; z=factorial(5); print_int(z);... } int factorial(int x) { int i; int r=1; for (i=1;i<=x;i++) { r*=i; } return r; } ARCOS Estructura de Computadores 222

223 Ejemplo (1) Pensar en el paso de parámetros Los parámetros se pasan en $a0, $a1, $a2 y $a3 Los resultados se recogen en $v0, $v1 Más adelante se verá con más detalle En la llamada z=factorial(5); Un parámetro de entrada: en $a0 Un resultado en $v0 ARCOS Estructura de Computadores 223

224 Ejemplo (2) Se pasa a ensamblador cada función El parámetro se pasa en $a0 El resultado se devuelve en $v0 int main() { int z; z=factorial(5); print_int(z);... } li $a0, 5 # argumento jal factorial # llamada move $a0, $v0 # resultado li $v0, 1 syscall # llamada para # imprimir un int... } # imprimir un int int factorial(int x) { int i; int r=1; for (i=1;i<=x;i++) { r*=i; } return r; } factorial: li $s1, 1 #s1 para r li $s0, 1 #s0 para i bucle: bgt $s0, $a0, fin mul $s1, $s1, $s0 addi $s0, $s0, 1 b bucle fin: move $v0, $s1 #resultado jr $ra ARCOS Estructura de Computadores 224

225 Ejemplo (3) Se analizan los registros que se modifican int factorial(int x) { int i; int r=1; for (i=1;i<=x;i++) { r*=i; } return r; } factorial: li $s1, 1 #s1 para r li $s0, 1 #s0 para i bucle: bgt $s0, $a0, fin mul $s1, $s1, $s0 addi $s0, $s0, 1 b bucle fin: move $v0, $s1 #resultado jr $ra La función factorial trabaja (modifica) con los registros $s0, $s1 Si estos registros se modifican dentro de la función, podría afectar a la función que realizó la llamada (la función main) Por tanto, la función factorial debe guardar el valor de estos registros en la pila al principio y restaurarlos al final ARCOS Estructura de Computadores 225

226 Ejemplo (4) Se guardan los registros en la pila int factorial(int x) { int i; int r=1; for (i=1;i<=x;i++) { r*=i; } return r; } No es necesario guardar $ra. La rutina factorial es terminal Se guarda en la pila $s0 y $s1 porque se modifican Si se hubiera utilizado $t0 y $t1 no habría hecho falta hacerlo factorial: sub $sp, $sp, 8 sw $s0, 4($sp) sw $s1, ($sp) li $s1, 1 #s1 para r li $s0, 1 #s0 para i bucle: bgt $s0, $a0, fin mul $s1, $s1, $s0 addi $s0, $s0, 1 b bucle fin: move $v0, $s1 #resultado lw $s1, ($sp) lw $s0, 4($sp) add $sp, $sp, 8 jr $ra ARCOS Estructura de Computadores 226

Ejemplo 2 227 int main() { int z; int f1 (int a, int b) { int r; } z=f1(5, 2); print_int(z); } r = a + a + f2(b); return r; int f2(int c) { int s; } s = c * c * c; return s; ARCOS Estructura de Computadores 227

Ejemplo 2. Invocación 228 int main() { int z; } z=f1(5, 2); print_int(z); li $a0, 5 # primer argumento li $a1, 2 # segundo argumento jal f1 # llamada move $a0, $v0 # resultado li $v0, 1 syscall # llamada para # imprimir un int Los parámetros se pasan en $a0 y $a1 El resultado se devuelve en $v0 ARCOS Estructura de Computadores 228

Ejemplo 2. Cuerpo de f1 229 int f1 (int a, int b) { int r; } r = a + a + f2(b); return r; f1: add $s0, $a0, $a0 move $a0, $a1 jal f2 add $v0, $s0, $v0 jr $ra int f2(int c) { int s; } s = c * c * c; return s; ARCOS Estructura de Computadores 229

230 Ejemplo 2. Se analizan los registros que se modifican en f1 int f1 (int a, int b) { int r; } r = a + a + f2(b); return r; int f2(int c) { int s; f1: add $s0, $a0, $a0 move $a0, $a1 jal f2 add $v0, $s0, $v0 jr $ra f1 modifica $s0, $a0 y $ra, por lo tanto se guardan en la pila El registro $ra se modifica en la instrucción jal f2 El registro $a0 se modifica al pasar el argumento a f2 } s = c * c * c; return s; ARCOS Estructura de Computadores 230

231 Ejemplo 2. Cuerpo de f1 guardando en la pila los registros que se modifican int f1 (int a, int b) { int r; } r = a + a + f2(b); return r; int f2(int c) { int s; } s = c * c * c; return s; f1: sub $sp, $sp, 12 sw $s0, 8($sp) sw $a0, 4($sp) sw $ra, ($sp) add $s0, $a0, $a0 move $a0, $a1 jal f2 add $v0, $s0, $v0 lw $ra, ($sp) lw $a0, 4($sp) lw $s0, 8($sp) add $sp, $sp, 12 jr $ra ARCOS Estructura de Computadores 231

Ejemplo 2. Cuerpo de f2 232 int f1 (int a, int b) { int r; } r = a + a + f2(b); return r; f2: mul $t0, $a0, $a0 int f2(int c) { int s; } s = c * c * c; return s; mul $t0, $t0, $a0 jr $ra La función f2 no modifica el registro $ra porque no llama a ninguna otra función El registro $t0 no es necesario guardarlo porque no se ha de preservar su valor ARCOS Estructura de Computadores 232

Marco de pila El marco de pila es el espacio de la pila en el que se almacenan: Los registros guardados por la función La dirección de retorno (en $ra) Variables locales ARCOS Estructura de Computadores 233

Convenio de paso de parámetros 234 Convenio que describe: Uso del banco de registros generales. Uso del banco de registros FPU. Uso de la pila. Afecta a código llamante y código llamado. Distintos compiladores usan distintos convenios. ABI Application Binary Interface. Aquí se usará el convenio o32 (MIPS). ARCOS Estructura de Computadores 234

Convención en el uso de los registros Registro Uso Preservar el valor $v0-$v1 Resultados No $a0..$a3 Argumentos Si $t0..$t9 Temporales No $s0..$s7 Salvados Si $sp Puntero de pila Si $fp Puntero marco de pila Si $ra Dirección de retorno si ARCOS Estructura de Computadores 235

Subrutinas paso a paso 236 Subrutina que hace la llamada Subrutina llamada Salvaguarda de registros que no quiera que modifique la subrutina llamada Paso de parámetros Llamada a subrutina Reserva del marco de pila Salvaguarda de registros Ejecución de subrutina Restauración de valores guardados Liberación de marco de pila Salida de subrutina Restauración de registros guardados ARCOS Estructura de Computadores 236

Tipos de subrutinas 237 Subrutina terminal. No invoca a ninguna otra subrutina. Subrutina no terminal. Invoca a alguna otra subrutina. Si la rutina es terminal se pueden ahorrar pasos ARCOS Estructura de Computadores 237

Salvaguarda de registros 238 Una subrutina puede modificar libremente los registros $t. Antes de invocar una subrutina se deben guardar los registros $t de los que se quiera preservar su valor. Registros $t pila ARCOS Estructura de Computadores 238

Paso de parámetros 239 Los primeros parámetros se pasan mediante registros $a0, $a1, $a2, $a3 $f12, $f14 (coma flotante) Resto de parámetros a través de pila En cualquiera caso hay que dejar hueco para los parámetros $a0, $a1, $a2 y $a3 en la pila Este espacio solamente se acaba usando si se acaba llamando a otra subrutina ARCOS Estructura de Computadores 239

Paso de 2 parámetros 240 Banco de registros Hueco para $a0 $a0 Parámetro 1 Hueco para $a1 $a1 Parámetro 2 Hueco para $a2 $a2 Parámetro 3 Hueco para $a3 $a3 Parámetro 4 Registros $t pila ARCOS Estructura de Computadores 240

Paso de 6 parámetros 241 Banco de registros Hueco para $a0 $a0 Hueco para $a1 $a1 Hueco para $a2 Hueco $a2 para $a3 $a3 Parámetro 5 Parámetro 6 Parámetro 1 Parámetro 2 Parámetro 3 Parámetro 4 Registros $t pila ARCOS Estructura de Computadores 241

Llamada a subrutina 242 Instrucción de salto and link jal etiqueta bal etiqueta bltzal $reg, etiqueta bgezal $reg, etiqueta jalr $reg jalr $reg, $reg ARCOS Estructura de Computadores 242

Reserva del marco de pila 243 El marco de pila es el espacio de la pila en el que se almacenan las: Los registros guardados por la función La dirección de retorno (en $ra) Variables locales Para reservar el marco de pila, restar su tamaño al puntero de pila. Debe ser múltiplo de 8 (por convenio) ARCOS Estructura de Computadores 243

Marco de pila 244 Marco de pila Registros guardados por la función Dirección de retorno Variables locales Parámetros $t pila ARCOS Estructura de Computadores 244

Salvaguarda de registros 245 La subrutina debe guardar en la pila. Los registros $s que vaya a modificar. El registro $ra en las subrutinas no terminales. ARCOS Estructura de Computadores 245

Ejecución de la subrutina 246 La subrutina deja los valores de retorno en: Normalmente los registros $v0 y $v1 Para coma flotante $f0 y $f2. Si hace falta más espacio se deja información en la pila. ARCOS Estructura de Computadores 246

Al final 247 Restauración de valores guardados Se restauran los valores que se guardaron Liberación del marco de pila. Se suma a $sp el tamaño del marco de pila Se vuelve a la subrutina llamante. jr $ra ARCOS Estructura de Computadores 247

Reglas 248 Sección de parámetros. Sección de registro de retorno. Sección de registros preservados. Sección de relleno. Sección de almacenamiento local. ARCOS Estructura de Computadores 248

Sección de parámetros 249 Solamente para subrutinas no terminales. Reglas: El tamaño debe permitir almacenar cualquier subrutina que se pueda llamar de la actual. Tamaño mínimo de 4 palabras. Los cuatro primero parámetros no se copian físicamente en la pila, pero hay que dejar el hueco. La subrutina invocada podría decidir preservar los registros $a en los huecos. ARCOS Estructura de Computadores 249

Ejemplo 250 int func(int x1, int x2, int x3, int x4, char c) {/*..*/} int main(int argc, char** argv) { int x,y=1,z=2,k=3,j=4; char c= a ; x=func(y,z,k,j,c); Sección parámetros: 5 palabras return 0; } ARCOS Estructura de Computadores 250

Sección de registro de retorno 251 Solamente para subrutinas no terminales. Sección de una palabra. Protocolo: Al entrar en la subrutina se guarda el registro $ra. Al salir de la subrutina se restaura el registro $ra. ARCOS Estructura de Computadores 251

Registros preservados 252 Se debe salvaguardar los registros $s y $a que se usen en la subrutina. Reglas: Una palabra por registro preservado. Los registros se preservan al entrar en la subrutina. Los registros se restauran al salir de la subrutina. Toda esta zona debe tener un tamaño múltiplo de doble palabra (múltiplo de 8 bytes). Puede incluir una sección de relleno. ARCOS Estructura de Computadores 252

Sección de almacenamiento local 253 Se usa para: Variables locales que necesiten almacenarse en memoria Reglas: El tamaño de la sección debe ser múltiplo de 8 bytes. Organización de la sección es responsabilidad de la subrutina. La sección solamente se usa por la subrutina. El acceso a las variables locales almacenadas en la pila se hace utilizando el registro $sp como registro base ARCOS Estructura de Computadores 253

Ejemplo 254 int main(int argc, char ** argv) { int z; z=factorial(5); $t0 print_int(z); return 0; } Sección de parámetros: 4 Sección de registro de retorno: 1 Sección registros preservados: 0 Sección de relleno: 0 Sección de almacenamiento local: 0 Prólogo # z=factorial(5) li $a0, 5 jal factorial move $a0, $v0 li $v0, 1 syscall Epílogo ARCOS Estructura de Computadores 254

Prólogo/Epílogo 255 Marco de pila: 4 huecos para parámetros $a. Registro de retorno. Tamaño del marco de pila: 24 bytes Qué salvar? Al menos $ra y $a0 ARCOS Estructura de Computadores 255

Prólogo/Epílogo 256 sub $sp, $sp, 24 sw $ra, 4($sp) sw $a0, 20($sp) Cuerpo lw $ra, 4($sp) lw $a0, 20($sp) add $sp, $sp, 24 Relleno $ra Hueco $a3 Hueco $a2 Hueco $a1 $a0 pila El puntero de pila apunta al último elemento de la pila $sp ARCOS Estructura de Computadores 256