1 / 81

CLASE 12

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

lynch
Download Presentation

CLASE 12

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. CLASE 12

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

  3. NOMENCLATURA DE LOS REGISTROS DEL MIPS

  4. ACCESO A MEMORIA 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]

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

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

  8. EJEMPLOS DE REPASO Ejemplo: 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;

  9. EJEMPLOS DE REPASO Ejemplo: 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;

  10. EJEMPLOS DE REPASO Hasta ahora vimos una instrucción de desvío incondicional, a través de la instrucción: jLabel # desvio para el Label • En esta instrucción, tenemos que especificar un Label, o sea una dirección fija, para la cual el ProgramCounterserá 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: jrregistrador#desviopara 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

  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. • 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: a es decir de -32768 a 32767). • Algunas instrucciones inmediatas: addi, andi, ori, nori.

  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 lwy 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 32768 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 80000 de memoria, ¿cuál es el código de máquina para este bucle?

  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: • Colocarlos argumentos (parámetros) en un lugar donde el procedimiento puede accederlos. • Transferir el control al procedimiento. • Ejecutarla 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) • 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 Instrucción MIPS para retorno de procedimiento: jr (jumpregister) jr $ra 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 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)

  28. EJEMPLO DE UN PROCEDIMIENTO ...suma(a,b);... /* a:$s0; b:$s1 */} int suma(int x, int y) { /* x:$a0; y:$a1 */returnx+y;} Dirección 1000add $a0,$s0,$zero # x = a1004add $a1,$s1,$zero # y = b1008addi $ra,$zero,1016 # $ra = 10161012 j suma # desvio para suma1016 ... 2000 suma: add $v0,$a0,$a12004jr $ra #regre. p/ origen, #a la direicc 1016 C 1 2 3 5 4 6 MIPS

  29. EJEMPLO DE UN PROCEDIMIENTO ...suma(a,b);... /* a:$s0; b:$s1 */} int suma(int x, int y) { /* x:$a0; y:$a1 */returnx+y;} Dirección1000add $a0,$s0,$zero # x = a1004add $a1,$s1,$zero # y = b1008jal suma #prepara $ra y #jump p/ proc suma1012 ... 2000 suma: add $v0,$a0,$a12004jr $ra # regre p/ origen, # a la direcc 1012 C 1 2 3 5 4 6 MIPS

  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); } C 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 MIPS

  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. high addr $sp top of stack low addr

  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 • Recuperarun dato del stack: POP • Datotomado del stack en $sp • $sp= $sp + 4 Memoria POP PUSH Leer valor Incrementar $SP Decrementar $SP Mover valor valor Stack Pointer $SP Stack Pointer $SP PILA Ultima posición de Memoria

  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? intproc (int g, int j, int i, int h) { int f; f = (g+h) – (i+j); returnf; } • 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 ¿Cómo queda la pila? • Durante: Después de volcar los registros Antes: Antes de la ejecución del Procedimiento Memoria Memoria Valor de $s0 Valor de $t0 Valor de $t1 Valor $SP $SP PILA PILA Valor de $s0 Valor de $t0 Valor de $t1 Después: Después de hacer el proceso de POP $SP 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 invocadodebe 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) + … + 2 + 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. 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 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

  42. suma_recursiva Simulación 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 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 $SP PILA $a0 = $ra = $v0 =

  43. suma_recursiva Simulación 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 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 $SP PILA $a0 = 3 $ra = $v0 =

  44. suma_recursiva Simulación 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 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 $SP PILA $a0 = 3 $ra = X $v0 =

  45. 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) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra $SP PILA $a0 = 3 $ra = X $v0 =

  46. 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) addi $sp, $sp, 8 add $v0, $a0, $v0 jr $ra $SP PILA $a0 = 3 $ra = X $v0 =

  47. suma_recursiva Simulación Contenido de $a0 (n=3) Contenido de $ra (X) 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 $SP PILA $a0 = 3 $ra = X $v0 =

  48. suma_recursiva Simulación slti (set lessthaninmediate) Formato: sltiRdest, RF1, RF2 Funcionalidad: Rdest=1 si RF1<RF2 Rdest=0 si RF!>=RF2 Contenido de $a0 (n=3) Contenido de $ra (X) 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 $SP PILA $a0 = 3 $ra = X $v0 =

  49. suma_recursiva Simulación Contenido de $a0 (n=3) Contenido de $ra (X) 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 $SP PILA $a0 = 2 $ra = X $v0 =

  50. suma_recursiva Simulación Contenido de $a0 (n=3) Contenido de $ra (X) 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 $SP PILA $a0 = 2 $ra = Ri $v0 =

More Related