CLASE 12.

CLASE 12

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

NOMENCLATURA DE LOS REGISTROS DEL MIPS

ACCESO A MEMORIA Ejemplo:
load store 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. lw $4,8($3) add $1,$2,$4 lw $4,32($3) add $1,$2,$4 g = h + A[8]

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

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

EJEMPLOS DE REPASO Ejemplo: Solución:
Compilar la siguiente porción de código en ensamblador del MIPS: 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:... if (i == j) f = g + h; else f = g - h;

Compilar la siguiente porción de código en ensamblador del MIPS: 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: ... while(save[i] == k) i += 1;

Compilar la siguiente porción de código en ensamblador del MIPS: 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: ... while (i < k) i += 1;

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?

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.

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.

CISC ISA: Intel x86 RISC 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.

El MIPS implementa 5 modos de direccionamiento: Registro. Inmediato. Base o desplazamiento. Relativo al PC. Pseudo-directo. (Diapositiva 10)

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.

DIRECCIONAMIENTO INMEDIATO
Un operando es una constante de (16 bits) que se encuentra dentro de la instrucción misma. La ventaja de este tipo de instrucciones es que no se requiere acceso a memoria para traer un operando. El operando inmediato esta limitado a 16 bits. (Por lo que solo permite manejar numeros en el rango: −2 15 a −1 es decir de a 32767). Algunas instrucciones inmediatas: addi, andi, ori, nori.

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.

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.

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. (diapositiva 10)

5 MODOS DE DIRECCIONAMIENTO DEL MIPS
(diapositiva 10)

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? address op rs rt rd shamt funct loop: ssl $t1, $s3, 2 80000 19 9 2 add $t1, $t1, $s6 80004 22 32 lw $t0,0($t1) 80008 35 8 bne $t0, $s5,exit 80012 5 21 add $s3, $s3, 1 80016 1 j loop 80020 20000 exit: … 80024 ... address or offset (diapositiva 10)

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. (Diapositiva 2)

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. (Diapositiva 2)

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. (Diapositiva 2)

Instrucción MIPS para invocar un procedimiento: jal (jump and link) 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). jal ProcAddress Formato J 3 Target address 6 bits 26 bits Instrucción MIPS para retorno de procedimiento: jr (jump register) (Diapositiva 2) jr $ra PC = R[rs] Formato R 31 8 opcode rs funct

(Diapositiva 2) Invocación del procedimiento: jal ProcAddress (R[31]=PC+8, PC = ProcAddress ) Retorno del procedimiento: jr $ra (PC = R[rs])

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

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 addi $ra,$zero,1016 # $ra = j suma # desvio para suma 2000 suma: add $v0,$a0,$a jr $ra #regre. p/ origen, #a la direicc 1016 C M I P S (Diapositiva 2) 1 2 3 4 6 5

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 jal suma #prepara $ra y #jump p/ proc suma 2000 suma: add $v0,$a0,$a jr $ra # regre p/ origen, # a la direcc 1012 C M I P S (Diapositiva 2) 1 2 3 4 6 5

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); C (Diapositiva 2) 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 M I P S

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 (Diapositiva 2)

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 Memoria POP PUSH (Diapositiva 2) Decrementar $SP Mover valor Leer valor Incrementar $SP Stack Pointer $SP valor Stack Pointer $SP PILA Ultima posición de Memoria

CONVENSION PARA EL USO DE REGISTROS DEL MIPS
(Diapositiva 2)

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. (Diapositiva 2)

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 (Diapositiva 2)

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

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) (Diapositiva 2)

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? (Diapositiva 2)

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. (Diapositiva 2)

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); (Diapositiva 2) Solución: Vamos generar el código correspondiente en assemblador del MIPS.

Ejemplo: suma_recursiva
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 add $v0, $a0, $v0 #Retorna (n + suma_rec(n-1)) jr $ra #Retorna para la función llamadora

suma_recursiva Simulación
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) add $v0, $a0, $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 $SP PILA $a0 = $ra = $v0 =

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) add $v0, $a0, $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 $SP PILA $a0 = 3 $ra = $v0 =

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) add $v0, $a0, $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 $SP PILA $a0 = 3 $ra = X $v0 =

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) add $v0, $a0, $v0 $SP PILA $a0 = 3 $ra = X $v0 =

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) add $v0, $a0, $v0 Contenido de $a0 (n=3) Contenido de $ra (X) $SP PILA $a0 = 3 $ra = X $v0 =

slti (set less than inmediate) Formato: slti Rdest, RF1, RF2 Funcionalidad: Rdest=1 si RF1<RF2 Rdest=0 si RF!>=RF2 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) add $v0, $a0, $v0 Contenido de $a0 (n=3) Contenido de $ra (X) $SP PILA $a0 = 3 $ra = X $v0 =

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) add $v0, $a0, $v0 Contenido de $a0 (n=3) Contenido de $ra (X) $SP PILA $a0 = 2 $ra = X $v0 =

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) add $v0, $a0, $v0 Contenido de $a0 (n=3) Contenido de $ra (X) $SP PILA $a0 = 2 $ra = Ri $v0 =

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) add $v0, $a0, $v0 Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) $SP PILA $a0 = 2 $ra = Ri $v0 =

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) add $v0, $a0, $v0 Contenido de $a0 (n=2) Contenido de $ra (Ri) Contenido de $a0 (n=3) Contenido de $ra (X) $SP PILA $a0 = 1 $ra = Ri $v0 =

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) add $v0, $a0, $v0 Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $a0 (n=3) Contenido de $ra (X) $SP PILA $a0 = 1 $ra = Ri $v0 =

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) add $v0, $a0, $v0 Contenido de $a0 (n=1) Contenido de $ra (Ri) Contenido de $a0 (n=2) Contenido de $a0 (n=3) Contenido de $ra (X) $SP PILA $a0 = 0 $ra = Ri $v0 =

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) add $v0, $a0, $v0 Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $a0 (n=2) Contenido de $a0 (n=3) Contenido de $ra (X) $SP PILA $a0 = 0 $ra = Ri $v0 =

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) add $v0, $a0, $v0 Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $a0 (n=2) Contenido de $a0 (n=3) Contenido de $ra (X) La Condición no se Cumple¡¡¡¡ $SP PILA $a0 = 0 $ra = Ri $v0 =

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) add $v0, $a0, $v0 Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $a0 (n=2) Contenido de $a0 (n=3) Contenido de $ra (X) $SP PILA $a0 = 0 $ra = Ri $v0 = 0

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) add $v0, $a0, $v0 Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $a0 (n=2) Contenido de $a0 (n=3) Contenido de $ra (X) $SP PILA $a0 = 1 $ra = Ri $v0 = 0

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) add $v0, $a0, $v0 Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $a0 (n=2) Contenido de $a0 (n=3) Contenido de $ra (X) $SP PILA $a0 = 1 $ra = Ri $v0 = 0 + 1

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) add $v0, $a0, $v0 Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $a0 (n=2) Contenido de $a0 (n=3) Contenido de $ra (X) $SP PILA $a0 = 2 $ra = Ri $v0 = 0 + 1

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) add $v0, $a0, $v0 Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $a0 (n=2) Contenido de $a0 (n=3) Contenido de $ra (X) $SP PILA $a0 = 2 $ra = Ri $v0 =

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) add $v0, $a0, $v0 Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $a0 (n=2) Contenido de $a0 (n=3) Contenido de $ra (X) $SP PILA $a0 = 3 $ra = X $v0 =

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) add $v0, $a0, $v0 add $a0, $cero, 3 #n=3 jal suma_rec #llamado a la función suma_rec X: … lo que siga después del procedimiento Contenido de $a0 (n=0) Contenido de $ra (Ri) Contenido de $a0 (n=1) Contenido de $a0 (n=2) Contenido de $a0 (n=3) Contenido de $ra (X) $SP PILA $a0 = 3 $ra = X $v0 =

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

REFERENCIAS http://microe.udea.edu.co/~farivera/docencia.html
Computer organization and design. The hardware/software interface, 3rd ed., Chapter 2. D. Patterson and J. Hennessy. Morgan Kaufmann Publishers

CLASE 12.

Presentaciones similares

Presentación del tema: "CLASE 12."— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback

Iniciar la sesión

Autorizarse a través de una red social:

CLASE 12.

Presentaciones similares

Presentación del tema: "CLASE 12."— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback