1 / 32

MIPS Intermedio

MIPS Intermedio. Seudo-instrucciones. Son instrucciones que el ensamblador reconoce pero que no existen en la definición del hardware. El ensamblador mapea cada seudo-instrucción a dos o mas instrucciones reales . Se usan para comodidad de los programadores.

topper
Télécharger la présentation

MIPS Intermedio

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. MIPS Intermedio

  2. Seudo-instrucciones • Son instrucciones que el ensamblador reconoce pero que no existen en la definición del hardware. • El ensamblador mapea cada seudo-instrucción a dos o mas instrucciones reales. • Se usan para comodidad de los programadores. • Algunas seudo-instrucciones no son standard. Dependen de cada ensamblador Arquitectura de Computadoras

  3. Seudo-instrucciones • Por ejemplo, la seudo-instrucción li (load immediate): li $t0, 0x12345678 se traduce a: lui $t0, 0x1234 ori $t0, 0x5678 Arquitectura de Computadoras

  4. Seudo-instrucciones • Lista de algunas seudo-instrucciones: Arquitectura de Computadoras

  5. Registros Arquitectura de Computadoras

  6. Registros • Los registros $at (1), $k0 (26), y $k1 (27) están reservados por el ensamblador y el sistema operativo y no deben ser usados por programas. • Los registros $a0–$a3 (4–7) se usan para pasar los primeros cuatro argumentos a las rutinas (los demás argumentos se pasan en la pila). Los registros $v0 y $v1 (2, 3) se usan para regresar valores de funciones. • Los registros $t0–$t9 (8–15, 24, 25) son registros salvados por el llamador que se usan para guardar cantidades temporales que no necesitan ser preservados entre llamadas. Arquitectura de Computadoras

  7. Registros • Los registros $s0–$s7 (16–23) son registros salvados por el llamado que se usan para guardar cantidades temporales que si necesitan ser preservados entre llamadas. • El registro $gp (28) es un apuntador global que apunta a la mitad de un bloque de memoria de 64K en el segmento de datos estáticos. • El registro $sp (29) es el stack pointer, que apunta al tope de la pila. El registro $fp (30) es el frame pointer. La instrucción jal escribe en el registro $ra (31) la dirección de retorno de una llamada a procedimiento. Arquitectura de Computadoras

  8. Llamadas a procedimiento • En lenguajes de alto nivel (C, Java) las llamadas a procedimiento son transparentes al usuario. • En ensamblador, el programador debe implementar las llamadas y retorno de procedimiento. • Las llamadas y regreso de procedimiento involucran un bloque de memoria llamado procedure call frame. • Como en la mayoría de los lenguajes las llamadas a procedimiento siguen un orden LIFO (last-in, first-out), a estos bloques también se les conoce como stack frames. Arquitectura de Computadoras

  9. Stack frame • El stack frame guarda: • Argumentos (a partir del quinto) al procedimiento. • Los registros que se deben preservar. • Las variables locales al procedimiento. • El procedimiento llamado utiliza el frame pointer para accesar la memoria. lw $v0, 0($fp) ; $v0 = Memoria[$fp] Arquitectura de Computadoras

  10. Stack frame … Alta memoria Argumento 6 Argumento 5 $fp La pila crece Registros salvados Variables locales $sp Baja memoria Arquitectura de Computadoras

  11. Stack frame • Por convención, el tamaño mínimo de un stack frame es 24 bytes. • 16 bytes para guardar $a0-$a3. • 8 bytes para guardar $ra alineada a doble palabra. • Por convención, el stack pointer también se mantiene alineado a doble palabra, es decir, $sp se incrementa de 8 en 8 bytes. Arquitectura de Computadoras

  12. Antes de la llamada El llamador hace lo siguiente: • Pasar argumentos. Por convención, los primeros 4 argumentos van en $a0-$a3. Los demás argumentos se pasan en la pila. • Guarda los registros. No hay garantía que $a0-$a3 ni $t0-$t9 mantengan su valor después de la llamada. Si el llamador espera usar alguno de esos registros, debe salvarlos en la pila. • Ejecuta una instrucción jal. La dirección de regreso se guarda en $ra automáticamente. Arquitectura de Computadoras

  13. Después de la llamada El llamado, antes de correr, hace lo siguiente: • Reservar espacio para el frame, restándole al stack pointer el tamaño del frame. • Salvar los registros $s0-$s7 si es que se usan en el procedimiento. $fp debe salvarse y $ra solo en caso de que el procedimiento haga a su vez una llamada. • Dejar a $fp apuntando al comienzo del frame, sumando al stack pointer el tamaño del frame menos 4. Arquitectura de Computadoras

  14. Antes de regresar al llamador Antes de regresar, el llamado hace lo siguiente: • Si el llamado regresa un valor, guardar el valor en $v0. • Restaurar los registros que se salvaron al comienzo. • Eliminar (pop) el stack frame sumándole el tamaño del frame al stack pointer. • Brincar a la dirección almacenada en $ra. Arquitectura de Computadoras

  15. Ejemplo 1 Traducir a MIPS la siguiente función hecha en C: int foo (int g, int h, int i, int j) { int f; f = (g + h) – (i + j); return f; } Arquitectura de Computadoras

  16. Ejemplo 1 • Reservar espacio en la pila para el frame. • Salvar los registros que se van a usar: $s0, $t0 y $t1. foo: addi $sp, $sp, -12 ; El frame ocupa 12 bytes sw $t1, 8($sp) ; Guarda $t1 sw $t0, 4($sp) ; Guarda $t0 sw $s0, 0($sp) ; Guarda $s0 Arquitectura de Computadoras

  17. Alta memoria sp $t1 $t0 $s0 sp Baja memoria Antes Después Ejemplo 1 • Pila del sistema antes y después de guardar el stack frame de foo. Arquitectura de Computadoras

  18. Ejemplo 1 • Código del procedimiento. • Se asume que los argumentos g, h, i, y j están en $a0, $a1, $a2 y $a3, respectivamente. add $t0, $a0, $a1 ; $t0 = g + h add $t1, $a2, $a3 ; $t1 = i + j sub $s0, $t0, $t1 ; $s0 = $t0 - $t1 add $v0, $s0, $zero ; El valor se regresa en $v0 Arquitectura de Computadoras

  19. Ejemplo 1 • Restaurar los valores de $t0, $t1 y $s0 sacándolos de la pila. • Regresar el control al procedimiento llamador. lw $s0, 0($sp) ; Restaura $s0 lw $t0, 4($sp) ; Restaura $t0 lw $t1, 8($sp) ; Restaura $t1 addi $sp, $sp, 12 ; Ajusta la pila jr $ra ; Brinca al llamador Arquitectura de Computadoras

  20. Alta memoria sp $t1 $t0 $s0 sp Baja memoria Durante Ejemplo 1 • Pila del sistema durante y después de la llamada a foo. Después Arquitectura de Computadoras

  21. Ejemplo 2 Traducir a MIPS el siguiente código en C: main () { printf (“El factorial de 10 es %d\n", fact (10)); } int fact (int n) { if (n < 1) return (1); else return (n * fact (n - 1)); } Arquitectura de Computadoras

  22. Ejemplo 2 - main • El main reserva 32 bytes para su stack frame. • 24 bytes para $a0-$a3 y $ra mas 8 bytes para guardar $fp alineado a doble palabra. main: li $t0, 32 subu $sp, $sp, $t0 ; Stack frame es de 32 bytes sw $ra, 20($sp) ; Guarda la dirección de regreso sw $fp, 16($sp) ; Guarda el frame pointer anterior addiu $fp, $sp, 28 ; Pone el frame pointer Arquitectura de Computadoras

  23. Ejemplo 2 - main • El main pone el argumento 10 en $a0 y llama a fact. • Luego invoca a la función de librería printf. li $a0, 10 ; Guarda el argumento (10) en $a0 jal fact ; Llama a la función factorial la $a0, $LC ; Guarda el string de formato en $a0 move $a1, $v0 ; Mueve el resultado de fact a $a1 jal printf ; Llama a la función para imprimir Arquitectura de Computadoras

  24. Ejemplo 2 - main • El main restaura los registros y regresa. lw $ra, 20($sp) ; Restaura $ra lw $fp, 16($sp) ; Restaura el frame pointer addiu $sp, $sp, 32 ; Saca (pop) el stack frame jr $ra ; Regresa al llamador $LC: .ascii “El factorial de 10 es %d\n\000” Arquitectura de Computadoras

  25. Ejemplo 2 - fact • El inicio de fact es parecido. Salva $ra y $fp. Además salva $a0 porque ahí pasa el argumento en las llamadas recursivas. fact: li $t0, 32 subu $sp, $sp, $t0 ; Stack frame es de 32 bytes sw $ra, 20($sp) ; Salva la dirección de regreso sw $fp, 16($sp) ; Salva el frame pointer addiu $fp, $sp, 28 ; Pone el frame pointer sw $a0, 0($fp) ; Salva el argumento (n) Arquitectura de Computadoras

  26. Ejemplo 2 - fact • Esta parte implementa el cuerpo principal de fact. lw $v0, 0($fp) ; Carga n bgtz $v0, $L2 ; Brinca si n > 0 li $v0,1 ; Regresa 1 jr $L1 ; Brinca para regresar $L2: lw $v1, 0($fp) ; Carga n subu $v0, $v1, 1 ; Calcula n - 1 move $a0, $v0 ; Mueve el valor a $a0 jal fact ; Llama a fact lw $v1, 0($fp) ; Carga n mul $v0, $v0, $v1 ; Calcula fact(n-1) * n Arquitectura de Computadoras

  27. Ejemplo 2 - fact • Finalmente, fact restaura los registros y regresa. $L1: ; Resultado está en $v0 lw $ra, 20($sp) ; Restaura $ra lw $fp, 16($sp) ; Restaura $fp addiu $sp, $sp, 32 ; Pop stack jr $ra ; Regresa a main Arquitectura de Computadoras

  28. Ejemplo 2 – stack frames • Durante la llamada a fact (8). main $ra $fp $a0 $ra $fp fact (10) Pila crece $a0 $ra $fp fact (9) $a0 $ra $fp fact (8) Arquitectura de Computadoras

  29. Resumen • Instrucciones sencillas, todas de 32 bits. • Tres formatos de instrucción: • R – los operandos son registros. • I – un operando es inmediato. • J – brinco. Arquitectura de Computadoras

  30. Resumen • Arquitectura load/store. • Los datos deben estar en registros para realizar aritmética. • Las únicas instrucciones que accesan la memoria son las instrucciones de transferencia de datos. • Byte addressing con memoria alineada. • Las palabras comienzan en direcciones múltiplos de 4. • 232 bytes con direcciones de 0 a 232 – 1. • 230 palabras con direcciones de 0 a 232 – 4. Arquitectura de Computadoras

  31. Resumen • El registro $zero siempre contiene valor 0. • Los registro $at, $k0, $k1 están reservados. • Los registros $gp, $sp, $fp y $ra son de propósito especial. • En particular $sp, $fp y $ra se usan en las llamadas. • Los registros $t0-$t9 son para temporales de vida corta. • Los registros $s0-$s7 son para temporales de vida larga. • Los registros $a0-$a3 se usan para pasar argumentos. • Los registros $v0 y $v1 se usan para regresar valores. Arquitectura de Computadoras

  32. Arquitectura de Computadoras

More Related