La descarga está en progreso. Por favor, espere

La descarga está en progreso. Por favor, espere

Stack y Subrutinas Introducción a la Computación 1 Ing. Diego Figueyra Stack y Subrutinas.

Presentaciones similares


Presentación del tema: "Stack y Subrutinas Introducción a la Computación 1 Ing. Diego Figueyra Stack y Subrutinas."— Transcripción de la presentación:

1 Stack y Subrutinas Introducción a la Computación 1 Ing. Diego Figueyra Stack y Subrutinas

2 Introducción a la Computación 2 Ing. Diego Figueyra Soporte a la modularización Todos los procesadores brindan soporte al paradigma de modularización incluyendo instrucciones de salto a subrutina o funciones. Los módulos en un programa se colocan en subrutinas o funciones. Por ende una subrutina es un segmento de código que realiza una tarea determinada. Una subrutina tiene parámetros de entrada y salida El HC11 tiene las siguientes instrucciones para manejar funciones o subrutinas – JSR(Jump to Subroutine. Absoluto) –BSR(Branch to Subroutine. Relativo) –RTS(Return from subroutine)

3 Stack y Subrutinas Introducción a la Computación 3 Ing. Diego Figueyra Soporte a la modularización JSR(Jump to Subroutine) Esta instrucción realiza un salto absoluto a una subrutina. –Ej.: Supongamos que tenemos una subrutina en la dirección $2000. Podemos llamar a esta subrutina de la siguiente manera: JSR$2000(suponer modo extendido) Esta instrucción salta a la dirección $2000 (como lo haría un JMP $2000).A partir de ahí el procesador comienza a ejecutar instrucción por instrucción de la subrutina hasta encontrar la instrucción RTS (return from subrutine) que provoca un salto a la instrucción siguiente a la que hizo la llamada a la subrutina (JSR $2000).

4 Stack y Subrutinas Introducción a la Computación 4 Ing. Diego Figueyra Soporte a la modularización JSR $2000 $3000 RTS Inst. 1 Inst. 2 $2000 Prox. Inst. $3003

5 Stack y Subrutinas Introducción a la Computación 5 Ing. Diego Figueyra Funcionamiento de Subrutinas Lo expuesto deja flotando una pregunta: Como sabe la instrucción RTS a donde debe volver ? –Evidentemente el llamado a la subrutina (JSR $2000) dejo una marca en algún lugar de manera que cuando la subrutina finaliza (RTS) el procesador sepa adonde regresar. –Ese lugar se conoce como STACK (Pila) y es una zona de memoria RAM que puede estar ubicada en cualquier parte del mapa de 64 KB. Donde empieza y termina esta zona lo define exclusivamente el programador.

6 Stack y Subrutinas Introducción a la Computación 6 Ing. Diego Figueyra Funcionamiento de Subrutinas Cuando un programa comienza debe indicarle al procesador la zona de inicio del STACK. –NO OLVIDAR ESTE PUNTO Para informarle al procesador el inicio del STACK el programa debe cargar en el registro SP (Stack pointer o puntero a la pila) la dirección de inicio. Esto se puede hacer mediante la instrucción –LDS #SP_ADDRESS siendo SP_ADDRESS la dirección de inicio del STACK (también llamada TOP OF STACK). Cada vez que se llama a una subrutina el procesador guarda en el STACK la dirección de retorno que corresponde a la próxima instrucción después de la llamada a la subrutina.

7 Stack y Subrutinas Introducción a la Computación 7 Ing. Diego Figueyra Antes de ejecutar el salto la situación es la siguiente: Libre SP=TOP_OF_STACK JSR $2000 PC=3000 PROX INST PC= $FFFF Funcionamiento de Subrutinas

8 Stack y Subrutinas Introducción a la Computación 8 Ing. Diego Figueyra Libre PCL=$03 JSR $2000 PC=3000 PROX INST PC= $FFFF SP=TOP_OF_STACK-1 Funcionamiento de Subrutinas Durante la ejecución 1 se guarda (PUSH) PCL en el stack 2 se decrementa el SP en 1

9 Stack y Subrutinas Introducción a la Computación 9 Ing. Diego Figueyra Durante la ejecución 3 se guarda (PUSH) PCH en el stack 4 se decrementa el SP en 1 Libre PCH=$30 PCL=$03 JSR $2000 PC=3000 PROX INST PC= $FFFF SP=TOP_OF_STACK-2 Fncionamiento de Subrutinas

10 Stack y Subrutinas Introducción a la Computación 10 Ing. Diego Figueyra Durante la ejecución 5 se carga $2000 en PC 6 se inicia la ejecución de la subrutina Libre PCH=$30 PCL=$03 1er Inst. Sub. PC= $FFFF SP=TOP_OF_STACK-2 Funcionamiento de Subrutinas

11 Stack y Subrutinas Introducción a la Computación 11 Ing. Diego Figueyra Libre PCH=$30 PCL=$03 RTS PC=XXXX $0000 $FFFF SP=TOP_OF_STACK-2 Funcionamiento de Subrutinas La subrutina finaliza con la ejecución de la instrucción RTS. Ahora el proceso es el inverso. El estado en el momento de ejecución de RTS es el siguiente

12 Stack y Subrutinas Introducción a la Computación 12 Ing. Diego Figueyra Libre PCH=$30 PCL=$03 RTS PC=30XX $0000 $FFFF SP=TOP_OF_STACK-1 Funcionamiento de Subrutinas El SP es incrementado primero y luego el contenido de la posición apuntada por el es transferida (PULL) a PCH.

13 Stack y Subrutinas Introducción a la Computación 13 Ing. Diego Figueyra Libre PCH=$30 PCL=$03 RTS PC=3003 $0000 $FFFF SP=TOP_OF_STACK Funcionamiento de Subrutinas El SP es incrementado primero y luego el contenido de la posición apuntada por el es transferida a (PULL) PCL.

14 Stack y Subrutinas Introducción a la Computación 14 Ing. Diego Figueyra Funcionamiento de Subrutinas Resumen: Cuando se realiza la llamada a la subrutina: 1.Se guarda (PUSH) el PCL en el STACK (PCL (SP)). 2.Se decrementa el SP (SP-1 SP). 3.Se guarda (PUSH) el PCH en el STACK (PCH (SP)). 4.Se decrementa el SP (SP-1 SP). 5.Se carga la dirección de la subrutina en el PC 6.Empieza la ejecución de la subrutina. Nota: Observar que el SP siempre queda apuntando a la próxima posición libre en el STACK.

15 Stack y Subrutinas Introducción a la Computación 15 Ing. Diego Figueyra Funcionamiento de Subrutinas Resumen (cont.) Cuando se realiza el retorno de la subrutina: 1.Se incrementa el SP (SP+1 SP). 2.El contenido de lo apuntado por SP es transferido al PCH. (SP) PCH (PULL). 3.Se incrementa el SP (SP+1 SP). 4.El contenido de lo apuntado por SP es transferido al PCL. (SP) PCL (PULL). 5.Empieza la ejecución de la instrucción posterior al llamado. Notas:Las dos posiciones del STACK no cambiaron.El orden en que PCH:PCL se guardan en el STACK respeta la convención Big Endian.

16 Stack y Subrutinas Introducción a la Computación 16 Ing. Diego Figueyra PushPull Funcionamiento de Subrutinas Notas: Obsérvese que el ultimo valor guardado en el STACK es el primero en salir.Es decir que el orden que se sacan los datos del STACK es inverso al que se guardaron.Todo dispositivo que responda a este comportamiento es conocido como memoria LIFO (Last In First Out) y el STACK pertenece a esa categoría.

17 Stack y Subrutinas Introducción a la Computación 17 Ing. Diego Figueyra Funcionamiento de Subrutinas Esquema de invocación de subrutinas múltiples Inicio Subrutina 1 Subrutina 1.1 Subrutina Fin

18 Stack y Subrutinas Introducción a la Computación 18 Ing. Diego Figueyra Funcionamiento de Subrutinas Otra cuestión que quedo sin aclarar es donde termina el STACK ? La respuestas es: depende. En realidad la extensión del stack no está determinada por el microprocesador, sino que es una zona de memoria que establece el programador. En general se debe estimar cuanta memoria reservar y setear el comienzo del mismo. Esta estimación se realiza en función del número de subrutinas anidadas que pueda tener el programa mas otros factores que mencionaran mas adelante (ej: pasaje de parámetros). Una vez que se estima la cantidad de memoria necesaria para el stack el programador se deber asegurar que otras porciones de código no la utilicen.

19 Stack y Subrutinas Introducción a la Computación 19 Ing. Diego Figueyra Instrucciones que operan con el stack Existen una serie de instrucciones que operan con el SP: 1.PSHA,PSHB,PSHX,PSHY Estas guardan registros en el stack 2.PULA,PULB,PULX,PULY Estas recuperan registros del stack 3.TSX (SP)+1 IXTSY (SP)+1 IY 4.TXS (IX)-1 SPTYS (IY)-1 SP 5.LDS Inicializa el SP (modos de direccionamiento:Todos) 6.STS Guarda el SP (modos de direccionamiento:Todos) 7.INS SP+1 SP DES SP-1 SP

20 Stack y Subrutinas Introducción a la Computación 20 Ing. Diego Figueyra Ej.: PSHA Guarda el registro A en el Stack. (A NO CAMBIA) –Antes de la ejecución el estado del procesador es el siguiente Libre PSHA A=$F8 $0000 $FFFF SP=TOP_OF_STACK PROX. INST. A=$F8 Instrucciones que operan con Stack

21 Stack y Subrutinas Introducción a la Computación 21 Ing. Diego Figueyra Durante de la ejecución: 1- A (SP) 2- SP-1 SP Libre $F8 PSHA A=$F8 $0000 $FFFF SP=TOP_OF_STACK -1 PROX. INST. A=$F8 Instrucciones que operan con Stack

22 Stack y Subrutinas Introducción a la Computación 22 Ing. Diego Figueyra Libre PSHX X=$ABCD $0000 $FFFF SP=TOP_OF_STACK PROX. INST. X=$ABCD Instrucciones que operan con Stack Ej.: PSHX Guarda el registro X en el Stack. (X NO CAMBIA) –Antes de la ejecución el estado del procesador es el siguiente

23 Stack y Subrutinas Introducción a la Computación 23 Ing. Diego Figueyra PROX. INST. Primero se guarda la parte baja de X en el STACK Libre $CD PSHX X=$ABCD $0000 $FFFF SP=TOP_OF_STACK - 1 X=$ABCD Instrucciones que operan con Stack

24 Stack y Subrutinas Introducción a la Computación 24 Ing. Diego Figueyra PROX. INST. Ej.: PSHX Guarda el registro X en el Stack. (X NO CAMBIA) –Antes de la ejecución el estado del procesador es el siguiente Libre $AB $CD PSHX X=$ABCD $0000 $FFFF SP=TOP_OF_STACK -2 X=$ABCD Instrucciones que operan con Stack

25 Stack y Subrutinas Introducción a la Computación 25 Ing. Diego Figueyra Ej.: PULA Guarda en el registro A el contenido de (SP+1) –Antes de la ejecución el estado del procesador es el siguiente Libre $A9 PULA A=$?? 0000 $FFFF SP=TOP_OF_STACK-1 PROX. INST. Instrucciones que operan con Stack

26 Stack y Subrutinas Introducción a la Computación 26 Ing. Diego Figueyra Después de la ejecución el estado del procesador es el siguiente: Libre $A9 PULA A=$A $FFFF SP=TOP_OF_STACK PROX. INST. Instrucciones que operan con Stack

27 Stack y Subrutinas Introducción a la Computación 27 Ing. Diego Figueyra Ej.: PULX Guarda en el registro X el contenido de (SP+1:SP+2) –Antes de la ejecución el estado del procesador es el siguiente: Libre $12 $34 PULX X=$???? 0000 $FFFF SP=TOP_OF_STACK-2 PROX. INST. Instrucciones que operan con Stack

28 Stack y Subrutinas Introducción a la Computación 28 Ing. Diego Figueyra Libre $12 $34 PULX X=$12?? 0000 $FFFF SP=TOP_OF_STACK-1 PROX. INST. Intrucciones que operan con Stack Durante la ejecución: 1- SP+1 SP 2- (SP) XH.

29 Stack y Subrutinas Introducción a la Computación 29 Ing. Diego Figueyra Libre $12 $34 PULX X=$ $FFFF SP=TOP_OF_STACK PROX. INST. Intrucciones que operan con Stack Durante la ejecución: 3- SP+1 SP 4- (SP) XL.

30 Stack y Subrutinas Introducción a la Computación 30 Ing. Diego Figueyra Intrucciones que operan con Stack Supongamos que existiese la instrucción: STAA 0,S siendo S el SP Entonces PSHA podría interpretarse como: STAA0,S A (SP) DES SP-1 Análogamente si existiese la instrucción LDAA 0,S entonces la instrucción PULA podría interpretarse como: INS SP+1 SP LDAA0,S (SP) A

31 Stack y Subrutinas Introducción a la Computación 31 Ing. Diego Figueyra Que fecto tendría las siguientes instrucciones? –CASO 1 pshb pula –CASO 2 pshx pula pulb –CASO 3 psha pshb pula pulb Intrucciones que operan sobre el Stack B -> A X -> D (A:B) B A

32 Stack y Subrutinas Introducción a la Computación 32 Ing. Diego Figueyra Para que sirven las instrucciones de push y pull? 1.Preservar el contenido de registros cuando se invoca un módulo/subrutina 2.Pasar parámetros a una subrutina utilizando el stack 3.Creación de variables temporales en stack Usos de Pull y Push Mr. Stack

33 Stack y Subrutinas Introducción a la Computación 33 Ing. Diego Figueyra Preservación (backup) de registros durante una llamada a función o subrutina Luego de invocar una función los registros deberían quedar en el valor que tenían antes de que se realizará la llamada a la función. Es decir la subrutina no debería modificar estos registros o si lo hace debería volver a colocarlos en su estado original. De no ocurrir esto pueden producirse errores de programa graves. Cómo podría resolverse este problema? Se podrían guardar los registros antes de invocar a la función en una zona de variables temporales y luego restaurarlos. La implementación de esta estrategia es simple : –Se salvan en el stack mediante el uso de las instrucciones push aquellos registros que no deseamos que sean alterados. –Luego se llama a la subrutina. –Una vez finalizada la misma mediante el uso de las instrucciones pull podemos recuperarlos.

34 Stack y Subrutinas Introducción a la Computación 34 Ing. Diego Figueyra Preservación de registros durante una llamada a función: Si bien la solución previa es correcta existe una cuestión que se debe discutir: Porque el que llama a la subrutina debe asumir la responsabilidad de los daños que puede provocar un tercero (en este caso la subrutina) ? En otras palabras porque no se hace cargo la subrutina de esta cuestión. Después de todo ella es la que puede ocasionar el daño. La subrutina podría salvar solamente aquellos registros que va a utilizar lo cual es mas eficiente que la primera solución. Ahora que pasaría si el programador de la subrutina se olvida de salvar algún registro ? Este escenario está en marcado en el concepto de programación defensiva. El programador debe protegerse de sus propios errores o errores de los demás para generar un código robusto.

35 Stack y Subrutinas Introducción a la Computación 35 Ing. Diego Figueyra Preservación de registros durante una llamada a función: Ante el escenario de backup de registros antes o durante la llamada de funciones recomendamos lo siguiente: –Si el la reputación del programador que escribió las subrutinas es buena. Y las funciones están correctamente docuemntadas vamos a dejar que la subrutina haga la preservación de registros. – Si no conocemos la calidad del programador/programa apalancándonos en la programación defensiva haremos un backup de los registros antes de invocar a la subrutina. – Si nosotros debemos escribir la subrutina y el programa principal, recomendamos por una cuestión de eficiencia hacer el backup en la subrutina. Ya que la misma conoce los registros que va a modificar.

36 Stack y Subrutinas Introducción a la Computación 36 Ing. Diego Figueyra Ejemplo *********************************************** * Rutina de retardo Parámetro: AccA [1-255] * Registros modificados :AccA. Valor retornado:Ninguno *********************************************** pshx;Salvo X loop2ldx#100;Constante para Loop mas interno loop1dex bneloop1 deca;Contador mas interno del loop bneloop2 pulx;Recupero X rts Preservación de registros durante una llama a función:

37 Stack y Subrutinas Introducción a la Computación 37 Ing. Diego Figueyra En el caso de que tengamos que preservar registros es muy importante tener en cuenta el orden en que se recuperan dichos registros. Se debe tener en cuenta que el stack es LIFO (Last in First Out) por ende se deben recuperar los registros en el orden inverso al que fueron guardados. Ej: psha pshx..... pulx pula rts Libre XH XL A SP Preservación de registros durante una llama a función: Guardo Registros Recupero Registros

38 Stack y Subrutinas Introducción a la Computación 38 Ing. Diego Figueyra Pasaje de Parámetros a una subrutina: Si una subrutina requiere de parámetros externos a la misma para operar se pude recurrir a dos métodos: –Pasaje de Parámetros por registro: Se cargan los registros que pasan los parámetros antes de invocar a la función. Siguiendo la docuementación correcta el programador utilizará los registros para tomar los datos que necesita. –Pasaje de Parámetros por stack: En ocasiones el numero de parámetros que recibe una subrutina excede el numero de registros disponibles en el procesador. En estos casos los parámetros deben pasarse a la subrutina por stack. Para tal fin antes de invocar a la subrutina se guardan en el stack los parámetros que la subrutina debe recibir. Luego se invoca a la subrutina la cual accede a los parámetros que fueron guardados en el stack utilizando el SP. Finalmente cuando se vuelve de la subrutina el programa que la invoco libera la memoria usada en el stack para pasar los parámetros.

39 Stack y Subrutinas Introducción a la Computación 39 Ing. Diego Figueyra Ej.: PSHAParam1 PSHBParam2 JSRSUB INS Libre XH0 XL1 PCH2 PCL3 Param24 Param15 SP PSHX;salvo X TSX;SP+1 X (X=Frame Pointer) PSHA;Salvo A PSHB;Salvo B (Acceso a parámetros) LDAA 5,XParam1 LDAB4,XParam PULB ;Recupero B PULA ;Recupero A PULX RTS X Stack Frame Pasaje de Parámtros por stack (ejemplo):

40 Stack y Subrutinas Introducción a la Computación 40 Ing. Diego Figueyra Pasaje de Parámetros por stack: Notas: Una vez dentro de la subrutina lo primero que se hace es transferir el SP incrementado en uno al registro X. Este registro (Frame Pointer) sirve de referencia para acceder a los parámetros ya residentes en el stack. Ej.: LDADESP1,XParametro1 A INCDESP1,XParametro1+1 Parametro1 Siendo DESP1 el desplazamiento del parámetro 1 respecto del Frame Pointer.

41 Stack y Subrutinas Introducción a la Computación 41 Ing. Diego Figueyra Pasaje de Parámetros por stack: Notas: Los parámetros recibidos en el stack son una copia de los valores originales de los mismos. Esta forma de pasar dichos parámetros se la conoce como: Pasaje de parámetros por valor. Las instrucciones INS que están después de la llamada a la subrutina tienen por objeto liberar el espacio usado en el stack para el pasaje de los parámetros.

42 Stack y Subrutinas Introducción a la Computación 42 Ing. Diego Figueyra Retorno de valores al programa principal Programa principal PSHAParam1 PSHBParam2 JSRMAX PULA * Subrutina MAX: Compara 2 números no * signados de 8 bits y retorna el mayor. * PRM1 5, PRM2 4, RET1 5 MAXPSHXSalvo X TSXCreo el Frame Pointer PSHAPreservo A LDAA5,X Parm1 A CMPA4,X Parm1 - Parm2 BCCMayor MenorLDAA4,X Parm2 A MayorSTAA5,X Parm1/2 Ret1 PULARecupero A PULXRecupero X RTS Libre XH0 XL1 PCH2 PCL3 Prm24 Prm1/Ret15 SP FP Stack Frame Pasaje de Parámetros por stack:

43 Stack y Subrutinas Introducción a la Computación 43 Ing. Diego Figueyra Notas: En este caso la subrutina MAX devuelve un valor que es retornado usando la posición en la que estaba ubicado el parámetro 1.Esto puede hacerse porque el valor del parámetro 1 ya no es mas necesario. En el caso de que se retornen mas valores que parámetros, el programa que llama a la subrutina debe proveer espacio adicional para almacenar a estos últimos. Ejemplo: PSHAParam1 PSHBParam2 DES JSRMAX Espacio adicional Pasaje de Parámetros por stack:

44 Stack y Subrutinas Introducción a la Computación 44 Ing. Diego Figueyra Pasaje de valores por referencia: Programa principal LDX#$C000 Dirección del Param1 PSHX LDX#$C001 Dirección del Param2 PSHX JSRMAX2 PULXLibero stack PULALibero stack PULAValor de retorno Libre XH0 XL1 PCH2 PCL3 Dir2_H4 Dir2_L5 Dir1_H6 Dir1_L / Ret17 SP FP Stack Frame Pasaje de Parámetros por stack:

45 Stack y Subrutinas Introducción a la Computación 45 Ing. Diego Figueyra Pasaje de valores por referencia: * Subrutina MAX2: Compara 2 números no * signados de 8 bits y Retorna el mayor. * Dir. PRM1 6, Dir. PRM2 4, RET1 7 MAX2PSHXSalvo X TSXCreo el Frame Pointer PSHYPreservo Y PSHAPreservo A LDY6,X Dir.Parm1 Y LDAA0,Y Parm1 A LDY4,X Dir.Parm2 Y CMPA0,Y Parm1 - Parm2 BCCMayor MenorLDAA0,Y Parm2 A MayorSTAA7,X Parm1/2 Ret1 PULARecupero A PULYRecupero Y PULXRecupero X RTS SP FP Libre XH0 XL1 PCH2 PCL3 Dir2_H4 Dir2_L5 Dir1_H6 Dir1_L / Ret17 Stack Frame Pasaje de Parámetros por stack:

46 Stack y Subrutinas Introducción a la Computación 46 Ing. Diego Figueyra Notas: En este caso, la subrutina MAX2 recibe las direcciones de los parámetros, NO sus copias como ocurría con la subrutina MAX. Esta forma de pasar los parámetros se la conoce como: Pasaje de parámetros por referencia. Cuando se reciben valores por referencia se debe tener cuidado pues los valores originales ahora pueden ser alterados desde la subrutina. No tengo una copia del parámetro sino la posibilidad de acceder a la variable directamente referenciando su dirección. Pasaje de Parámetros por stack:

47 Stack y Subrutinas Introducción a la Computación 47 Ing. Diego Figueyra Variables Locales Existen situaciones en las que la subrutina necesita de variables para guardar cálculos intermedios o parciales. Frente a esta situación se pueden seguir dos caminos: –Reservar una zona de memoria para este fin. Esto trae aparejado dos puntos importantes: –Si utiliza una zona de memoria compartida por otras subrutinas se pierde control absoluto sobre las variables. Otra subrutina podría acceder a ellas por error o con intensión. –No se podrían crear subrutinas recursivas »Una subrutina recursiva es una subrutina que se invoca a si mismo (en la clase de macros se expandirá este concepto) –Crear una zona de memoria en el stack. El manejo de variables es un poco más complejo y requiero de una zona de stack amplia. No tengo ninguno de los problemas anteriores Pasaje de Parámetros por stack:

48 Stack y Subrutinas Introducción a la Computación 48 Ing. Diego Figueyra Ejemplo (1) de uso de variables locales creadas en stack –Utilizamos la intrucción des, psha, pshb u otra Ej1.: PSHXSalvo el FP de la rutina que efectuó la llamada. DESReservo 3 bytes para variables locales DES TSXX=Nuevo FP Libre LOC(1)0 LOC(2)1 LOC(3)2 XH:XL3/4 PCH:PCL5/6 SP FP Pasaje de Parámetros por stack:

49 Stack y Subrutinas Introducción a la Computación 49 Ing. Diego Figueyra Ejemplo (2) de uso de variables locales creadas en stack Ej2.: PSHXSalvo el FP de la rutina que efectuó la llamada. PSHX PSHXReservo 6 Bytes para variables locales (1) PSHX TSXX=Nuevo FP (1) El valor de X es irrelevante en este caso pues solo es usado para decrementar el SP. Pasaje de Parámetros por stack:

50 Stack y Subrutinas Introducción a la Computación 50 Ing. Diego Figueyra Ejemplo (3) de uso de variables locales creadas en stack –Si el numero de variables temporales es grande el procedimiento anterior deja de ser eficiente. Por ejemplo si se necesitan 100 bytes tendríamos que repetir esa misma cantidad de veces la instrucción DES (o la mitad de PSHX). En este caso se puede hacer lo siguiente: Ej.: SP-N SP Reservo N Bytes en el Stack PSHXSalvo el FP de la rutina que efectuó la llamada. TSXSP+1 X XGDXX D SUBD #ND-N D XGDXX D TXSX-1 SP (SP= New Top of Stack, X=New Frame Pointer) Nota:Obsérvese que D(A:B) no se altera Pasaje de Parámetros por stack

51 Stack y Subrutinas Introducción a la Computación 51 Ing. Diego Figueyra Un stack frame con N variables locales y K parámetros (y/o valores de retorno) podría esquematizarse de la siguiente manera: Libre Locales (1)0 Locales (2)1 Locales (N-1)N-2 Locales (N)N-1 XH :XL (FP previo)N/N+1 PCH : PCL (Dirección de retorno)N+2/N+3 Param1. / Ret1. (Parámetros y/o valores de retorno)N+4 Param2. / Ret2. (Parámetros y/o valores de retorno)N+5 ParamK. / RetK. (Parámetros y/o valores de retorno)N+4+(K-1) Pasaje de Parámetros por stack: SP FP

52 Stack y Subrutinas Introducción a la Computación 52 Ing. Diego Figueyra Para liberar el área usada por las variables locales el procedimiento es el siguiente: FP+K SP Libero K variables del Stack. LDB#K ABXFP+K FP TXSFP-1 SP PULB recupero B PULXX=FP previo RTS Libre LOC(1)0 LOC(2)1 LOC(K)K-1 ACCB XH:XL PCH:PCL SP FP Pasaje de Parámetros por stack:

53 Stack y Subrutinas Introducción a la Computación 53 Ing. Diego Figueyra Otra forma de liberar el área usada por las variables locales y los parámetros de una sola vez podría ser la siguiente: PSHY JSR SUB PULY Subrutina PSHXSalvo FP0 CLRX PSHXLOC1 y LOC2 = 0 (inicializo locales) TSXFP LDYRET,XPCH:PCL Y LDXFP0,XRecupero el FP0 (previo) TXSActualizo SP JMP0,Y(RTS) Libre LOC 1 (=0) LOC 2 (=0) XH:XL (FP0)FP0 PCH:PCLRET IY/ Libre 0 LOC 0 SP FP1 SP FP0 Pasaje de Parámetros por stack:

54 Stack y Subrutinas Introducción a la Computación 54 Ing. Diego Figueyra Stack Frame después de dos llamadas sucesivas: SP FP1 Libre Locales Registros XH :XL (FP previo)[FP1] PCH : PCL (Dirección de retorno2) Locales Registros XH :XL (FP previo) PCH : PCL (Dirección de retorno1) SP FP2 Pasaje de Parámetros por stack:

55 Stack y Subrutinas Introducción a la Computación 55 Ing. Diego Figueyra Pasaje de Parámetros por stack: Resumen: 1.Al comienzo de una subrutina se debería guardar el registro índice X o Y, dependiendo de cual sea la elección del FP. 2. Se guardan (backup)todos los registros que van a ser usados. 3.Se reserva lugar para variables locales usando las técnicas antes descriptas. 4.Se crea un FP para estas variables, es decir un puntero para referenciarlas dentro del stack

56 Stack y Subrutinas Introducción a la Computación 56 Ing. Diego Figueyra Ventajas del uso de variables locales: 1.El uso de variables locales permite un uso más racional de la memoria 2.Las subrutinas que utilizan variables locales pueden ser recursivas o reentrantes (subrutinas que generan un conjunto de variables nuevas cada vez que son invocadas) 3.El uso de variables locales le permite al programador evitar que sean vistas por otros segmentos de código. Esto le da privacidad y confiabilidad. 4.El creador de las subrutina controla completamente las variables que son devueltas al programa que la invoca. Sólo se hará visible lo que el programador defina en la documentación.

57 Stack y Subrutinas Introducción a la Computación 57 Ing. Diego Figueyra Notas finales El uso de el paradigma de programación modular permite realizar programas mas seguros,confiables y fáciles de mantener. Lenguajes como el C,pascal y C++ traen incorporado este paradigma en forma natural. El programador debe realizar todo el esfuerzo posible para aprovechar los benéficos de este paradigma. Decide which modules you want...Partition the program so that data is hidden in modules Bjarne Stroustrup

58 Stack y Subrutinas Introducción a la Computación 58 Ing. Diego Figueyra


Descargar ppt "Stack y Subrutinas Introducción a la Computación 1 Ing. Diego Figueyra Stack y Subrutinas."

Presentaciones similares


Anuncios Google