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

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 of A)

Assembly instructions

S1S2S3

BC

B

C

A

LW (Load Word)LW (Load Word)

SW (Store Word)B+C

+

NOMENCLATURA DE LOS REGISTROS DEL MIPS

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,$4lw $4,32($3)add $1,$2,$4

FORMATOS DE INSTRUCCIÓN DEL MIPS

FORMATO TIPO R

FORMATO TIPO I

FORMATO TIPO J

Operaciones Aritmético lógicasadd, 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 incondicionalj, 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 = *aadd $s1,$s2,$t0 # g = h + a

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,$s2Exit:...

EJEMPLOS DE REPASO


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 loopExit: ...

EJEMPLOS DE REPASO


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 LoopExit: ...

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.

MODOS DE DIRECCIONAMIENTOCISC 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.

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: a es decir de -32768 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 PCLa 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.

DIRECCIONAMIENTO PSEUDO-DIRECTOLa 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.

5 MODOS DE DIRECCIONAMIENTO DEL MIPS

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?

address op

rs rt rd

shamt

funct

loop: ssl $t1, $s3, 2 80000 0 0 19

9 2 0

add $t1, $t1, $s6

80004 0 9 22

9 0 32

lw $t0,0($t1)

80008 35 9 8 0

bne $t0, $s5,exit

80012 5 8 21

2

add $s3, $s3, 1

80016 8 19

19

1

j loop 80020 2 20000

exit: … 80024 ...

address or offset

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.


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.


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.


Instrucción MIPS para invocar un procedimiento: jal (jump and link)

jal ProcAddress

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

3 Target address

6 bits 26 bitsFormato J

Instrucción MIPS para retorno de procedimiento: jr (jump register)

jr $ra

0 31 0 0 0 8

opcode rs funct

PC = R[rs]

Formato R


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

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)

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ón1000 add $a0,$s0,$zero # x = a1004 add $a1,$s1,$zero # y = b 1008 addi $ra,$zero,1016 # $ra = 10161012 j suma # desvio para suma1016 ...2000 suma: add $v0,$a0,$a12004 jr $ra #regre. p/ origen,

#a la direicc 1016

1

23

5

4

6

C

MIPS

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ón1000 add $a0,$s0,$zero # x = a1004 add $a1,$s1,$zero # y = b 1008 jal suma #prepara $ra y

#jump p/ proc suma1012 ...2000 suma: add $v0,$a0,$a12004 jr $ra # regre p/ origen,

# a la direcc 1012

1

23

5

4

6

C

MIPS

PASOS EN LA EJECUCION DE UN PROCEDIMIENTOEjemplo:¿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 = iadd $a1,$zero,$s1 # $a1 = jjal sub # Llamado a la funcion subadd $s0,$v0,$zero # i = sub(i,j)...

sub: sub $v0,$a0,$a1 # $v0 = a-b jr $ra # retorno al origen

C

MIPS

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

$sptop of stack


• 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 – 4El dato se lleva al stack en el nuevo $sp

Recuperar un dato del stack: POPDato tomado del stack en $sp$sp = $sp + 4

PILAStack Pointer $SP

Memoria

Ultima posición de Memoria

PUSHDecrementar $SPMover valor

Stack Pointer $SP valor

POPLeer valorIncrementar $SP

CONVENSION PARA EL USO DE REGISTROS DEL MIPS


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.

SOPORTE DE BAJO NIVEL PARA PROCEDIMIENTOSproc: 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


ValorPILA

$SP

Memoria

Valor de $s0Valor de $t0Valor de $t1

PILA

$SP

Memoria

Valor de $s0Valor de $t0Valor 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?


• 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)

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?

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.


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.

suma_rec: addi $sp, $sp, -8 #Prepara la pila para recibir 2 valores sw $ra, 4($sp) #Empila $rasw $a0, 0($sp) #Empila $a0slti $t0, $a0, 1 #Prueba si n<1beq $t0, $zero, L1 #Si n<1 va a L1addi $v0, $zero, 0 #Valor de retorno 0addi $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 nlw $ra, 4($sp) #Restaura la dirección de retornoaddi $sp, $sp, 8 #Remueve 2 valores de la pilaadd $v0, $a0, $v0 #Retorna (n + suma_rec(n-1))jr $ra #Retorna para la función llamadora

Ejemplo: suma_recursiva

suma_rec: addi $sp, $sp, -8 sw $ra, 4($sp)sw $a0, 0($sp)slti $t0, $a0, 1beq $t0, $zero, L1addi $v0, $zero, 0addi $sp, $sp, 8jr $ra

L1: addi $a0, $a0, -1jal suma_rec

Ri: lw $a0, 0($sp)lw $ra, 4($sp)addi $sp, $sp, 8add $v0, $a0, $v0jr $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=3jal suma_rec #llamado a la función suma_rec

X: … lo que siga después del procedimiento





PILA$SP

$a0 = 3$ra =$v0 =








PILA$SP

$a0 = 3$ra = X $v0 =








PILA$SP

$a0 = 3$ra = X$v0 =





PILA

$SP

$a0 = 3$ra = X$v0 =





Contenido de $a0 (n=3)Contenido de $ra (X)

PILA

$SP

$a0 = 3$ra = X$v0 =






PILA

$SP

$a0 = 3$ra = X$v0 =

slti (set less than inmediate)

Formato:slti Rdest, RF1, RF2

Funcionalidad:Rdest=1 si RF1<RF2Rdest=0 si RF!>=RF2






PILA

$SP

$a0 = 2$ra = X$v0 =






PILA

$SP

$a0 = 2$ra = Ri$v0 =





$a0 = 2$ra = Ri$v0 =


PILA

$SP





Contenido de $a0 (n=2)Contenido de $ra (Ri)


PILA

$SP

$a0 = 2$ra = Ri$v0 =





$a0 = 2$ra = Ri$v0 =



PILA

$SP





$a0 = 1$ra = Ri$v0 =



PILA

$SP





$a0 = 1$ra = Ri$v0 =



PILA

$SP





$a0 = 1$ra = Ri$v0 =



PILA

$SP





$a0 = 1$ra = Ri$v0 =




PILA

$SP





$a0 = 1$ra = Ri$v0 =




PILA

$SP





$a0 = 0$ra = Ri$v0 =




PILA

$SP





$a0 = 0$ra = Ri$v0 =




PILA

$SP





$a0 = 0$ra = Ri$v0 =




PILA

$SP





$a0 = 0$ra = Ri$v0 =





PILA

$SP





$a0 = 0$ra = Ri$v0 =





PILA

$SP





$a0 = 0$ra = Ri$v0 =





PILA

$SP

La Condición no se Cumple¡¡¡¡





$a0 = 0$ra = Ri$v0 = 0





PILA

$SP





$a0 = 0$ra = Ri$v0 = 0





PILA

$SP





$a0 = 0$ra = Ri$v0 = 0





PILA

$SP





$a0 = 1$ra = Ri$v0 = 0





PILA

$SP





$a0 = 1$ra = Ri$v0 = 0





PILA

$SP





$a0 = 1$ra = Ri$v0 = 0 + 1





PILA

$SP





$a0 = 2$ra = Ri$v0 = 0 + 1





PILA

$SP





$a0 = 2$ra = Ri$v0 = 0 + 1





PILA

$SP





$a0 = 2$ra = Ri$v0 = 0 + 1 + 2





PILA

$SP





$a0 = 2$ra = Ri$v0 = 0 + 1 + 2





PILA

$SP





$a0 = 3$ra = X$v0 = 0 + 1 + 2





PILA

$SP





$a0 = 3$ra = X$v0 = 0 + 1 + 2





PILA$SP





$a0 = 3$ra = X$v0 = 0 + 1 + 2 + 3





PILA$SP





$a0 = 3$ra = X$v0 = 0 + 1 + 2 + 3





PILA$SP





$a0 = 3$ra = X$v0 = 0 + 1 + 2 + 3





PILA$SP



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 addressSaved local regs (if any)Local arrays & structures (if any)

$fp

REFERENCIAS

• http://microe.udea.edu.co/~farivera/docencia.html• http://www.cse.hcmut.edu.vn/~

anhvu/teaching/2010/BTKT-KTMT/MIPS%20Green%20Card.pdf• http://www.ece.eng.wayne.edu/~

gchen/ece4680/lecture-notes/lecture-notes.html• http://www.cs.uiowa.edu/~ghosh/6011.html• http://www.cse.hcmut.edu.vn/~anhvu/teaching/2010/504002CS/• http://cs.wellesley.edu/~cs240/• http://www.utdallas.edu/~dodge/EE2310/• Computer organization and design. The hardware/software interface, 3rd

ed., Chapter 2. D. Patterson and J. Hennessy. Morgan Kaufmann Publishers

http://microe.udea.edu.co/~farivera/docencia.html

http://microe.udea.edu.co/~farivera/docencia.html

http://arch.eece.maine.edu/ece473/index.php/Lectures











Date post:	03-Feb-2015
Category:	Documents
Upload:	inez-pizarro
View:	2 times
Download:	0 times

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

Documents