La descarga está en progreso. Por favor, espere

La descarga está en progreso. Por favor, espere

CLASE 12. UTILIZANDO REGISTROS Processor Memory C/C++ statement A = B + C; LW $S1, (address of B) LW $S2, (address of C) ADD $S3, $S2, $S1 SW $S3, (address.

Presentaciones similares


Presentación del tema: "CLASE 12. UTILIZANDO REGISTROS Processor Memory C/C++ statement A = B + C; LW $S1, (address of B) LW $S2, (address of C) ADD $S3, $S2, $S1 SW $S3, (address."— Transcripción de la presentación:

1 CLASE 12

2 UTILIZANDO REGISTROS Processor Memory C/C++ statement A = B + C; LW $S1, (address of B) LW $S2, (address of C) ADD $S3, $S2, $S1 SW $S3, (address of A) Assembly instructions S1 S2 S3 B C B C A LW (Load Word) SW (Store Word) B+C +

3 NOMENCLATURA DE LOS REGISTROS DEL MIPS

4 ACCESO A MEMORIA Ejemplo: Asuma que A es una array de 100 palabras (word), y el compilador ha asociado las variables g y h con los registros $1 y $2. También asuma que la dirección base del array esta en $3. Convierta a instrucciones en ensamblador la siguiente expresión en C. load store g = h + A[8] lw $4,8($3) add $1,$2,$4 lw $4,32($3) add $1,$2,$4

5 FORMATOS DE INSTRUCCIÓN DEL MIPS FORMATO TIPO R FORMATO TIPO I FORMATO TIPO J Operaciones Aritmético lógicas add, sub, and, or, nor, sll, srl, slt Instrucciones inmediatas, de acceso a memoria, saltos condicionales addi, andi, ori, nori, lw, sw, beq, bne Instrucciones de salto incondicional j, jal

6 EJEMPLOS DE REPASO Ejemplo: Suponga que tenemos un apuntador a para un entero que está en la memoria, con la dirección de memoria dado en el registrador $s3 (o sea, el apuntador a está en $s3). Suponga además que el compilador asoció las variables g y h a los registradores $s1 y $s2. Cuál es el código para el siguiente trecho en C? g = h + *a; Solución: lw $t0,0($s3)# $t0 = *a add $s1,$s2,$t0# g = h + a

7 EJEMPLOS DE REPASO Ejemplo: Compilar la siguiente porción de código en ensamblador del MIPS: if (i == j) f = g + h; else f = g - h; Solución: Asumiendo que la variables f, g, h, i y j se encuentran asociadas a los registros $s0, $s1, $s2, $s3, $s4 bne $s3,$s4,Else add $s0,$s1,$s2 j Exit Else: sub $s2,$s1,$s2 Exit:...

8 EJEMPLOS DE REPASO Ejemplo: Compilar la siguiente porción de código en ensamblador del MIPS: while(save[i] == k) i += 1; Solución: Asumiendo que la variables i y k corresponden a los registros $s3 y $s5, y la dirección base de save esta en $s6 Loop: add $t1,$s3,$s3 add $t1,$t0,$t0 add $t1,$t0,$s6 lw $t0,0($t1) bne $t0,$s5,Exit addi $s3,$s3,1 j loop Exit:...

9 EJEMPLOS DE REPASO Ejemplo: Compilar la siguiente porción de código en ensamblador del MIPS: while (i < k) i += 1; Solución: Asumiendo que la variables i y k corresponden a los registros $s3 y $s5. Loop: stl $t0,$s3,$s5 beq $t0,$zero,Exit addi $s3,$s3,1 j Loop Exit:...

10 EJEMPLOS DE REPASO Hasta ahora vimos una instrucción de desvío incondicional, a través de la instrucción: j Label# desvio para el Label En esta instrucción, tenemos que especificar un Label, o sea una dirección fija, para la cual el Program Counter será desviado. En diversas situaciones, puede ser interesante que desviemos para una dirección variable, almacenada en un registrador. Por lo tanto, existe la instrucción jr: jr registrador#desvio para dirección #contenida en el registrador Ejemplo: El lenguaje C define la instrucción switch, la cual permite que el programador seleccione una alternativa entre varias, dependiendo de un valor único. Cómo compilar el siguiente de código en C?

11 MODOS DE DIRECCIONAMIENTO Los operandos fuente y resultado pueden estar en alguna de las siguientes áreas: Memoria principal: se debe indicar la dirección de la celda que contiene el operando. Registro del CPU: La CPU contiene uno o más registros que pueden ser referenciados por las instrucciones de máquina. Dispositivo de E/S: La instrucción debe especificar el módulo y dispositivo de E/S para la operación. Dentro de la Instrucción misma: Como es el caso de un operando inmediato.

12 MODOS DE DIRECCIONAMIENTO Existen múltiples formas para especificar la dirección de los operandos. MODOS DE DIRECCIONAMIENTO. Dos aspectos importantes: Cómo se especifica la dirección de un operando o referencia. Como se organizan los bits de una instrucción para definir las direcciones de los operandos y la operación que realiza dicha instrucción. Los modos de direccionamiento dependen del procesador.

13 MODOS DE DIRECCIONAMIENTO CISC ISA: Intel x86RISC ISA: SPARC Modos de direccionamiento 12 modos: Register, immediate, direct, base, base + displacement, index + displacement, scaled index + displacement, based index,based scaled index, based index + displacement, based scaled index + displacement, relative. 5 Modos: Register indirect with immediate displacement, register indirect indexed by another register, register direct, immediate, PC relative. Tamaño de los operandos Pueden ser de 8, 16, 32, 48, 64, or 80 bits de longitud. Tambien soporta todas las operaciones string. Cuatro tamaños para los operadores: 1, 2, 4 u 8 bytes. Codificacion de las instrucciones La instrucción mas pequeña es de 1 byte. La mas grande es de 17 bytes de longitud. 3 formatos de instruccion con 3 pequeñas variaciones. Todas las instrucciones tienen 32 bits de ancho.

14 MODOS DE DIRECCIONAMIENTO El MIPS implementa 5 modos de direccionamiento: Registro. Inmediato. Base o desplazamiento. Relativo al PC. Pseudo-directo.

15 DIRECCIONAMIENTO DE REGISTROS Modo de direccionamiento mas simple, se caracteriza por que el operando esta en un registro Se ejecuta rápidamente por que se evita el retardo asociado al acceso de memoria. Como el numero de registros es limitado se necesitan pocos bits para seleccionar un registro. Dentro de este grupo caen las instrucciones aritmetico-logicas: add, sub, and, or, nor, sll, srl, slt.

16 DIRECCIONAMIENTO INMEDIATO Un operando es una constante de (16 bits) que se encuentra dentro de la instrucción misma.

17 DIRECCIONAMIENTO CON DESPLAZAMIENTO (O CON REGISTRO BASE) El operando está en una posición de memoria cuya dirección es la suma de un registro y una constante de 16 bits contenida en la instrucción Empleado en instrucciones de acceso a memoria como lw y sw.

18 DIRECCIONAMIENTO RELATIVO AL PC La dirección de la instrucción en memoria es la suma del PC y una constante de 16 bits contenida dentro de la instrucción. Target address = PC + offset x 4 (PC ya incrementado en 4). Registro de dirección de la instrucción (PC = Program counter): Su uso es automáticamente implicado en el salto. El PC se actualiza (PC + 4) durante el ciclo de búsqueda de manera que mantiene la dirección de la próxima instrucción. En las instrucciones de salto, la dirección efectiva solo podrá moverse posiciones hacia arriba o hacia abajo del contador, por que el offset es un numero de complemento a 2 de 16 bits. Empleado en instrucciones de salto condicional como: ben, beq.

19 DIRECCIONAMIENTO PSEUDO-DIRECTO La dirección del salto está formada por el campo de 26 bits concatenado con los 4 bits más significativos del PC. Target address = PC[31..28] : (address × 4) Empleado en instrucciones de salto incondicional: j y jal.

20 5 MODOS DE DIRECCIONAMIENTO DEL MIPS

21 MODOS DE DIRECCIONAMIENTO - EJEMPLO Suponiendo que la etiqueta loop está en la posición de memoria, ¿cuál es el código de máquina para este bucle? addressoprsrtrdshamtfunct loop: ssl $t1, $s3, add $t1, $t1, $s lw $t0,0($t1) bne $t0, $s5,exit add $s3, $s3, j loop exit: … address or offset

22 INSTRUCCIONES PARA SOPORTAR LLAMADAS A PROCEDIMIENTOS Y SUBRUTINAS Los procedimientos son bloques de código independientes que interactúan con el resto de los programas mediante el paso de parámetros y la entrega de resultados. Los procedimientos permiten una programación estructurada (facilitan la comprensión de los programas y su reutilización). El uso de procedimientos permite reutilización de código evitando lo que conocemos como reinvención de la rueda.

23 INSTRUCCIONES PARA SOPORTAR LLAMADAS A PROCEDIMIENTOS Y SUBRUTINAS En la ejecución de un procedimiento, un programa debe seguir los siguientes pasos: Colocar los argumentos (parámetros) en un lugar donde el procedimiento puede accederlos. Transferir el control al procedimiento. Ejecutar la tarea deseada (del procedimiento). Colocar el resultado de la ejecución en un lugar en el cual el código que llamó el procedimiento pueda accederlo. Retornar el control para el lugar de origen.

24 INSTRUCCIONES PARA SOPORTAR LLAMADAS A PROCEDIMIENTOS Y SUBRUTINAS Convención del ensamblador MIPS para el uso de registros durante la llamada a procedimientos: $a0-$a3: Registros de Argumentos. Se usan para el paso de parámetros. $v0-$v1: Registros de valores. Se usan para pasar los resultados. $ra: Registro de dirección de retorno. Se usa para retornar al punto de origen.

25 INSTRUCCIONES PARA SOPORTAR LLAMADAS A PROCEDIMIENTOS Y SUBRUTINAS Instrucción MIPS para invocar un procedimiento: jal (jump and link) jalProcAddress Salta a una dirección ( ProcAddress ) y simultáneamente guarda la dirección de la instrucción consecutiva en $ra. ( R[31]=PC+4, PC = ProcAddress ). 3Target address 6 bits26 bits Formato J Instrucción MIPS para retorno de procedimiento: jr (jump register) jr$ra opcodersfunct PC = R[rs] Formato R

26 INSTRUCCIONES PARA SOPORTAR LLAMADAS A PROCEDIMIENTOS Y SUBRUTINAS Invocación del procedimiento: jal ProcAddress ( R[31]=PC+8, PC = ProcAddress ) Retorno del procedimiento: jr $ra ( PC = R[rs] )

27 PASOS EN LA EJECUCION DE UN PROCEDIMIENTO 1. La rutina principal (caller) ubica los parámetros donde el procedimiento (callee) pueda acceder a ellos.( $a0-$a3 ). 2. La rutina principal transfiere el control al procedimiento. 3. El procedimiento reserva los recursos de almacenamiento necesarios. 4. El procedimiento ejecuta la tarea deseada. 5. El procedimiento ubica los resultados en un lugar donde la rutina principal pueda acceder a ellos. ( $v0-$v1 ) 6. El procedimiento devuelve el control a la rutina principal ( $ra )

28 EJEMPLO DE UN PROCEDIMIENTO... suma(a,b);... /* a:$s0; b:$s1 */ } int suma(int x, int y) { /* x:$a0; y:$a1 */ return x+y; } Dirección 1000 add $a0,$s0,$zero # x = a 1004 add $a1,$s1,$zero# y = b 1008 addi $ra,$zero,1016# $ra = j suma # desvio para suma suma: add $v0,$a0,$a jr $ra#regre. p/ origen, #a la direicc C MIPSMIPS

29 EJEMPLO DE UN PROCEDIMIENTO... suma(a,b);... /* a:$s0; b:$s1 */ } int suma(int x, int y) { /* x:$a0; y:$a1 */ return x+y; } Dirección 1000 add $a0,$s0,$zero # x = a 1004 add $a1,$s1,$zero# y = b 1008 jal suma#prepara $ra y #jump p/ proc suma suma: add $v0,$a0,$a jr $ra# regre p/ origen, # a la direcc C MIPSMIPS

30 PASOS EN LA EJECUCION DE UN PROCEDIMIENTO Ejemplo: ¿Cuál es le código en assemblador del MIPS equivalente al siguiente procedimiento en C, estando i en $s0 y j en $s1?... i = sub(i,j);... } int sub(a,b) { return (a-b); } add $a0,$zero,$s0# $a0 = i add $a1,$zero,$s1# $a1 = j jal sub# Llamado a la funcion sub add $s0,$v0,$zero # i = sub(i,j)... sub: sub $v0,$a0,$a1# $v0 = a-b jr $ra# retorno al origen C MIPSMIPS

31 SOPORTE DE BAJO NIVEL PARA PROCEDIMIENTOS ¿Qué sucede si el procedimiento requiere más registros de los dedicados al paso de argumentos y resultados? El procedimiento debe hacer uso de la pila (stack) para guardar y restaurar los registros empleados por el procedimiento Estructura de datos Last-in-first-out (LIFO) que reside en memoria. El registro $sp ( $29 ) se emplea para direccionar el stack apuntando al tope de la pila. El stack crece de las direcciones superiores a las inferiores. low addr high addr $sp top of stack

32 SOPORTE DE BAJO NIVEL PARA PROCEDIMIENTOS El stack pointer (registro $sp ) apunta al tope de la pila El stack crece de las direcciones superiores a las inferiores. Operaciones sobre el stack: Llevar un dato al stack: PUSH $sp = $sp – 4 El dato se lleva al stack en el nuevo $sp Recuperar un dato del stack: POP Dato tomado del stack en $sp $sp = $sp + 4 PILA Stack Pointer $SP Memoria Ultima posición de Memoria PUSH Decrementar $SP Mover valor Stack Pointer $SP valor POP Leer valor Incrementar $SP

33 CONVENSION PARA EL USO DE REGISTROS DEL MIPS

34 SOPORTE DE BAJO NIVEL PARA PROCEDIMIENTOS Ejemplo: Dado el siguiente procedimiento en C ¿Cuál es su implementación en ensamblador? int proc (int g, int j, int i, int h) { int f; f = (g+h) – (i+j); return f; } Solución: Los argumentos g, h, i y j son asociados a los registrados $a0, $a1, $a2 y $a3. f es colocada en $s0. (Por lo tanto necesita ser almacenada en el stack) El resultado es llevado a $v0.

35 SOPORTE DE BAJO NIVEL PARA PROCEDIMIENTOS proc: addi $sp,$sp,-12 #reserva 3 posiciones en la pila sw $t1, 8($sp) # guarda reg. $t1 sw $t0, 4($sp) # guarda reg. $t0 sw $s0, 0($sp) # guarda reg. $s0 add $t0, $a0, $a1 #reg. $t0 almacena a+b add $t1, $a2, $a3 #reg. $t1 almacena c+d sub $s0, $t0, $t1 # f queda con $t0-$t1 add $v0, $s0, $zero # retorna f en $v0 lw $s0, 0($sp) # recupera reg. $s0 lw $t0, 4($sp) # recupera reg. $t0 lw $t1, 8($sp) # recupera reg. $t1 addi $sp, $sp, 12 # restaura la pila jr $ra # regresa adonde fue llamado

36 SOPORTE DE BAJO NIVEL PARA PROCEDIMIENTOS Valor PILA $SP Memoria Valor de $s0 Valor de $t0 Valor de $t1 PILA $SP Memoria Valor de $s0 Valor de $t0 Valor de $t1 PILA $SP Antes: Antes de la ejecución del Procedimiento Durante: Después de volcar los registros Después: Después de hacer el proceso de POP ¿Cómo queda la pila?

37 SOPORTE DE BAJO NIVEL PARA PROCEDIMIENTOS En el ejemplo anterior se usaron registros temporales, asumiendo que sus valores debían ser preservados. Para evitar guardar y restaurar un registro cuyo valor no es usado, MIPS agrupa 18 de los registros en 2 grupos. $t0-$t9: 10 registradores temporales que no son preservados por el procedimiento invocado. $s0-$s7: 8 registros (saved) que deben preservarse en la llamada a un procedimiento.(si se van a usar el procedimiento debe guardarlos y restaurarlos)

38 PROCEDIMIENTOS ANIDADOS Suponga que el programa principal llama la función A con el argumento 3, al colocar 3 en $a0 y utiliza la instrucción jal A. Suponga además que la función A llama la función B con argumento 7, al colocar 7 en $a0 y utiliza la instrucción jal B. Una vez que A todavía no terminó de ejecutarse tendremos un conflicto en el uso del registrador $a0. Un problema también aparece para el registrador $ra, que ahora contiene el valor para el retorno de B. Si no tenemos cuidado, podríamos no ser capaces ni de regresar al programa principal!!!Cómo resolver este problema?

39 PROCEDIMIENTOS ANIDADOS Un procedimiento puede invocar a otro procedimiento o, incluso, puede invocarse a sí mismo (recursivo). Es necesario tener cuidado al manipular los registros para evitar conflictos. Una posible solución: El segmento del programa que invoca debe poner en la pila cualquier registro de argumentos ($a0-$a3) o registro temporal ($t0-$t9) que se necesiten después de la llamada. El procedimiento invocado debe poner en la pila el registro de dirección de retorno ($ra) y cualquier registro de variables ($s0-$s7) invocado por él. El stack pointer se debe ajustar según el número de registros almacenados por el STACK.

40 SOPORTE DE BAJO NIVEL PARA PROCEDIMIENTOS Ejemplo: Suponga que tenemos el siguiente código, que calcula la suma: n + (n-1) + … de forma recursiva: int suma_rec (int n) { if (n < 1) { return 0; } else { return n + suma_recursiva(n-1); } Solución: Vamos generar el código correspondiente en assemblador del MIPS.

41 suma_rec:addi $sp, $sp, -8 #Prepara la pila para recibir 2 valores sw $ra, 4($sp)#Empila $ra sw $a0, 0($sp)#Empila $a0 slti $t0, $a0, 1#Prueba si n<1 beq $t0, $zero, L1#Si n<1 va a L1 addi $v0, $zero, 0#Valor de retorno 0 addi $sp, $sp, 8#Remueve 2 valores de la pila jr $ra#Retorna para después del Jal L1: addi $a0, $a0, -1#Argumento pasa a ser (n-1) jal suma_rec#Calcula suma para (n-1) Ri: lw $a0, 0($sp)#Restaura el valor de n lw $ra, 4($sp)#Restaura la dirección de retorno addi $sp, $sp, 8#Remueve 2 valores de la pila add $v0, $a0, $v0#Retorna (n + suma_rec(n-1)) jr $ra#Retorna para la función llamadora Ejemplo: suma_recursiva

42 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación PILA $SP $a0 = $ra = $v0 = Se realiza el llamado a la función desde el código principal add $a0, $cero, 3 #n=3 jal suma_rec #llamado a la función suma_rec X: … lo que siga después del procedimiento Se realiza el llamado a la función desde el código principal add $a0, $cero, 3 #n=3 jal suma_rec #llamado a la función suma_rec X: … lo que siga después del procedimiento

43 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación PILA $SP $a0 = 3 $ra = $v0 = Se realiza el llamado a la función desde el código principal add $a0, $cero, 3 #n=3 jal suma_rec #llamado a la función suma_rec X: … lo que siga después del procedimiento Se realiza el llamado a la función desde el código principal add $a0, $cero, 3 #n=3 jal suma_rec #llamado a la función suma_rec X: … lo que siga después del procedimiento

44 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación PILA $SP $a0 = 3 $ra = X $v0 = Se realiza el llamado a la función desde el código principal add $a0, $cero, 3 #n=3 jal suma_rec #llamado a la función suma_rec X: … lo que siga después del procedimiento Se realiza el llamado a la función desde el código principal add $a0, $cero, 3 #n=3 jal suma_rec #llamado a la función suma_rec X: … lo que siga después del procedimiento

45 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación PILA $SP $a0 = 3 $ra = X $v0 =

46 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación PILA $SP $a0 = 3 $ra = X $v0 =

47 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP $a0 = 3 $ra = X $v0 =

48 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP $a0 = 3 $ra = X $v0 = slti (set less than inmediate) Formato: slti Rdest, RF1, RF2 Funcionalidad: Rdest=1 si RF1=RF2 slti (set less than inmediate) Formato: slti Rdest, RF1, RF2 Funcionalidad: Rdest=1 si RF1=RF2

49 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP $a0 = 2 $ra = X $v0 =

50 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP $a0 = 2 $ra = Ri $v0 =

51 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 2 $ra = Ri $v0 = Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

52 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP $a0 = 2 $ra = Ri $v0 =

53 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 2 $ra = Ri $v0 = Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

54 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 1 $ra = Ri $v0 = Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

55 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 1 $ra = Ri $v0 = Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

56 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 1 $ra = Ri $v0 = Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

57 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 1 $ra = Ri $v0 = Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

58 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 1 $ra = Ri $v0 = Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

59 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 0 $ra = Ri $v0 = Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

60 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 0 $ra = Ri $v0 = Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

61 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 0 $ra = Ri $v0 = Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

62 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 0 $ra = Ri $v0 = Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

63 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 0 $ra = Ri $v0 = Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

64 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 0 $ra = Ri $v0 = Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP La Condición no se Cumple¡¡¡¡

65 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 0 $ra = Ri $v0 = 0 Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

66 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 0 $ra = Ri $v0 = 0 Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

67 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 0 $ra = Ri $v0 = 0 Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

68 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 1 $ra = Ri $v0 = 0 Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

69 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 1 $ra = Ri $v0 = 0 Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

70 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 1 $ra = Ri $v0 = Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

71 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 2 $ra = Ri $v0 = Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

72 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 2 $ra = Ri $v0 = Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

73 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 2 $ra = Ri $v0 = Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

74 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 2 $ra = Ri $v0 = Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

75 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 3 $ra = X $v0 = Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

76 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 3 $ra = X $v0 = Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

77 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 3 $ra = X $v0 = Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

78 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 3 $ra = X $v0 = Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP

79 suma_rec:addi $sp, $sp, -8 sw $ra, 4($sp) sw $a0, 0($sp) slti $t0, $a0, 1 beq $t0, $zero, L1 addi $v0, $zero, 0 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal suma_rec Ri: lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra suma_recursiva Simulación $a0 = 3 $ra = X $v0 = Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) PILA $SP add $a0, $cero, 3 #n=3 jal suma_rec #llamado a la función suma_rec X: … lo que siga después del procedimiento add $a0, $cero, 3 #n=3 jal suma_rec #llamado a la función suma_rec X: … lo que siga después del procedimiento

80 DATOS LOCALES EN EL STACK El stack también se emplea para almacenar variables locales de los procedimientos que no caben en el banco de registros (vectores, estructuras locales). El segmento del stack que contiene los valores volcados y las variables locales se denomina procedure frame o activation record El registro frame pointer ( $fp ) apunta a la primera palabra del marco del procedimiento. Proporciona un registro base estable para las referencias a variables locales en el procedimiento (debido a que el stack puede cambiar durante el procedimiento). low addr high addr $sp Saved argument regs (if any) Saved return address Saved local regs (if any) Local arrays & structures (if any) $fp

81 REFERENCIAS KTMT/MIPS%20Green%20Card.pdf KTMT/MIPS%20Green%20Card.pdf notes.html notes.html Computer organization and design. The hardware/software interface, 3rd ed., Chapter 2. D. Patterson and J. Hennessy. Morgan Kaufmann Publishers


Descargar ppt "CLASE 12. UTILIZANDO REGISTROS Processor Memory C/C++ statement A = B + C; LW $S1, (address of B) LW $S2, (address of C) ADD $S3, $S2, $S1 SW $S3, (address."

Presentaciones similares


Anuncios Google