1 / 58

Stack y Subrutinas

Stack y Subrutinas. 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 .

ziarre
Télécharger la présentation

Stack y Subrutinas

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. Stack y Subrutinas

  2. Soporte a la modularización Todos los procesadoresbrindansoporte al paradigma de modularizaciónincluyendoinstrucciones de salto a subrutina o funciones. Los módulos en un programa se colocan en subrutinas o funciones. Porendeunasubrutinaes un segmento de códigoquerealizaunatareadeterminada. Unasubrutinatieneparámetros de entrada y salida El HC11tienelassiguientesinstruccionesparamanejarfunciones o subrutinas JSR (JumptoSubroutine. Absoluto) BSR (BranchtoSubroutine. Relativo) RTS (Returnfromsubroutine)

  3. Soporte a la modularización JSR (JumptoSubroutine) 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 (returnfromsubrutine) que provoca un salto a la instrucción siguiente a la que hizo la llamada a la subrutina (JSR $2000).

  4. Soporte a la modularización $3000 JSR $2000 $2000 Inst. 1 Inst. 2 $3003 Prox. Inst. RTS

  5. 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. 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. Antes de ejecutar el salto la situación es la siguiente: Funcionamiento de Subrutinas SP=TOP_OF_STACK 0000 PC=3000 JSR $2000 PC=3003 PROX INST $FFFF

  8. Funcionamiento de Subrutinas Durante la ejecución 1  se guarda (PUSH) PCL en el stack 2  se decrementa el SP en 1 SP=TOP_OF_STACK-1 0000 PC=3000 JSR $2000 PC=3003 PROX INST $FFFF

  9. Durante la ejecución 3  se guarda (PUSH) PCH en el stack 4  se decrementa el SP en 1 Fncionamiento de Subrutinas SP=TOP_OF_STACK-2 0000 PC=3000 JSR $2000 PC=3003 PROXINST $FFFF

  10. Durante la ejecución 5  se carga $2000 en PC 6  se inicia la ejecución de la subrutina Funcionamiento de Subrutinas SP=TOP_OF_STACK-2 0000 PC=2000 1er Inst. Sub. $FFFF

  11. 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 SP=TOP_OF_STACK-2 $0000 PC=XXXX RTS $FFFF

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

  13. Funcionamiento de Subrutinas El SP es incrementado primero y luego el contenido de la posición apuntada por el es transferida a (PULL) PCL. SP=TOP_OF_STACK $0000 PC=3003 RTS $FFFF

  14. Funcionamiento de Subrutinas Resumen: Cuando se realiza la llamada a la subrutina: Se guarda (PUSH) el PCL en el STACK (PCL(SP)). Se decrementa el SP (SP-1 SP). Se guarda (PUSH) el PCH en el STACK (PCH(SP)). Se decrementa el SP (SP-1 SP). Se carga la dirección de la subrutina en el PC 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. Funcionamiento de Subrutinas Resumen (cont.) Cuando se realiza el retorno de la subrutina: Se incrementa el SP (SP+1SP). El contenido de lo apuntado por SP es transferido al PCH. (SP)PCH (PULL). Se incrementa el SP (SP+1SP). El contenido de lo apuntado por SP es transferido al PCL. (SP)PCL (PULL). 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. 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. Push Pull

  17. Funcionamiento de Subrutinas Esquema de invocación de subrutinas múltiples Inicio Subrutina 1 Subrutina 1.1 Subrutina 1.1.1 Fin

  18. 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. Instrucciones que operan con el stack Existen una serie de instrucciones que operan con el SP: PSHA ,PSHB ,PSHX ,PSHY Estas guardan registros en el stack PULA ,PULB ,PULX ,PULY Estas recuperan registros del stack TSX (SP)+1 IX TSY (SP)+1IY TXS (IX)-1SPTYS (IY)-1SP LDS Inicializa el SP (modos de direccionamiento:Todos) STS Guarda el SP (modos de direccionamiento:Todos) INS SP+1SP DES SP-1SP

  20. Ej.: PSHA Guarda el registro A en el Stack. (A NO CAMBIA) Antes de la ejecución el estado del procesador es el siguiente Instrucciones que operan con Stack SP=TOP_OF_STACK $0000 PSHA A=$F8 PROX. INST. A=$F8 $FFFF

  21. Durante de la ejecución: 1- A(SP) 2- SP-1SP Instrucciones que operan con Stack SP=TOP_OF_STACK -1 $0000 PSHA A=$F8 PROX. INST. A=$F8 $FFFF

  22. 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 SP=TOP_OF_STACK $0000 PSHX X=$ABCD PROX. INST. X=$ABCD $FFFF

  23. Primero se guarda la parte baja de X en el STACK Instrucciones que operan con Stack SP=TOP_OF_STACK - 1 $0000 PSHX X=$ABCD PROX. INST. X=$ABCD $FFFF

  24. Ej.: PSHX Guarda el registro X en el Stack. (X NO CAMBIA) Antes de la ejecución el estado del procesador es el siguiente Instrucciones que operan con Stack SP=TOP_OF_STACK -2 $0000 PSHX X=$ABCD PROX. INST. X=$ABCD $FFFF

  25. Ej.: PULA Guarda en el registro A el contenido de (SP+1) Antes de la ejecución el estado del procesador es el siguiente Instrucciones que operan con Stack SP=TOP_OF_STACK-1 0000 PULA A=$?? PROX. INST. $FFFF

  26. Después de la ejecución el estado del procesador es el siguiente: Instrucciones que operan con Stack SP=TOP_OF_STACK 0000 PULA A=$A9 PROX. INST. $FFFF

  27. 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: Instrucciones que operan con Stack SP=TOP_OF_STACK-2 0000 PULX X=$???? PROX. INST. $FFFF

  28. Intrucciones que operan con Stack Durante la ejecución: 1- SP+1  SP 2- (SP)  XH. SP=TOP_OF_STACK-1 0000 PULX X=$12?? PROX. INST. $FFFF

  29. Intrucciones que operan con Stack Durante la ejecución: 3- SP+1  SP 4- (SP)  XL. SP=TOP_OF_STACK 0000 PULX X=$1234 PROX. INST. $FFFF

  30. Intrucciones que operan con Stack Supongamos que existiese la instrucción: STAA 0,S siendo S el SP Entonces PSHA podría interpretarse como: STAA 0,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 LDAA 0,S (SP)A

  31. 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. Para que sirven las instrucciones de push y pull? Preservar el contenido de registros cuando se invoca un módulo/subrutina Pasar parámetros a una subrutina utilizando el stack Creación de variables temporales en stack Usos de Pull y Push Mr. Stack

  33. Preservación (backup) de registros durante una llamada a función o subrutina Luego de invocarunafunción los registrosdeberíanquedar en el valor quetenían antes de que se realizará la llamada a la función. Es decir la subrutina no deberíamodificarestosregistros o si lo hacedeberíavolver a colocarlos en suestado original. De no ocurrirestopuedenproducirseerrores 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. 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. 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. Ejemplo *********************************************** * Rutina de retardo Parámetro: AccA [1-255] * Registros modificados :AccA. Valor retornado:Ninguno *********************************************** pshx ;Salvo X loop2 ldx #100 ;Constante para Loop mas interno loop1 dex bne loop1 deca ;Contador mas interno del loop bne loop2 pulx ;Recupero X rts Preservación de registros durante una llama a función:

  37. 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 Preservación de registros durante una llama a función: GuardoRegistros SP RecuperoRegistros

  38. 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. Pasaje de Parámtros por stack (ejemplo): PSHX ;salvo X TSX ;SP+1X (X=Frame Pointer) PSHA ;Salvo A PSHB ;Salvo B (Acceso a parámetros) LDAA5,XParam1 LDAB4,XParam2 .............. .............. PULB ;Recupero B PULA ;Recupero A PULX RTS Ej.: PSHAParam1 PSHBParam2 JSR SUB INS INS SP X Stack Frame

  40. 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.: LDA DESP1,X Parametro1  A INC DESP1,X Parametro1+1  Parametro1 Siendo DESP1 el desplazamiento del parámetro 1 respecto del Frame Pointer.

  41. 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. Retorno de valores al programa principal Pasaje de Parámetros por stack: * Subrutina MAX: Compara 2 números no * signados de 8 bits y retorna el mayor. * PRM1 5 , PRM2 4 , RET1 5 MAX PSHX Salvo X TSX Creo el Frame Pointer PSHA Preservo A LDAA5,XParm1 A CMPA4,XParm1 - Parm2 BCC Mayor Menor LDAA4,XParm2 A Mayor STAA5,XParm1/2  Ret1 PULA Recupero A PULX Recupero X RTS SP Programa principal PSHAParam1 PSHBParam2 JSR MAX PULA PULA FP Stack Frame

  43. 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. Pasaje de Parámetros por stack: Ejemplo: PSHAParam1 PSHBParam2 DES DES JSR MAX Espacio adicional

  44. Pasaje de valores por referencia: Pasaje de Parámetros por stack: SP FP Programa principal LDX #$C000 Dirección del Param1 PSHX LDX #$C001 Dirección del Param2 PSHX JSRMAX2 PULX Libero stack PULA Libero stack PULA Valor de retorno StackFrame

  45. Pasaje de valores por referencia: Pasaje de Parámetros por stack: SP FP * Subrutina MAX2: Compara 2 números no * signados de 8 bits y Retorna el mayor. * Dir. PRM1 6 , Dir. PRM2 4 , RET1 7 MAX2PSHX Salvo X TSX Creo el Frame Pointer PSHY Preservo Y PSHA Preservo A LDY6,XDir.Parm1 Y LDAA0,YParm1 A LDY4,XDir.Parm2 Y CMPA0,YParm1 - Parm2 BCC Mayor Menor LDAA0,YParm2 A Mayor STAA7,XParm1/2  Ret1 PULA Recupero A PULY Recupero Y PULX Recupero X RTS StackFrame

  46. 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. 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 pocomáscomplejo y requiero de unazona de stack amplia. No tengoninguno de los problemasanteriores Pasaje de Parámetros por stack:

  48. Ejemplo (1) de uso de variables locales creadas en stack Utilizamos la intrucción des, psha, pshb u otra Pasaje de Parámetros por stack: SP FP Ej1.: PSHX Salvo el FP de la rutina que efectuó la llamada. DES Reservo 3 bytes para variables locales DES DES TSX X=Nuevo FP

  49. Ejemplo (2) de uso de variables locales creadas en stack Pasaje de Parámetros por stack: Ej2.: PSHX Salvo el FP de la rutina que efectuó la llamada. PSHX PSHX Reservo 6 Bytes para variables locales (1) PSHX TSX X=Nuevo FP (1) El valor de X es irrelevante en este caso pues solo es usado para decrementar el SP.

  50. 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: Pasaje de Parámetros por stack Ej.: SP-NSP Reservo N Bytes en el Stack PSHX Salvo el FP de la rutina que efectuó la llamada. TSXSP+1 X XGDX X <--> D SUBD #N D-N D XGDX X <--> D TXS X-1 SP (SP= New Top of Stack, X=New Frame Pointer) Nota:Obsérvese que D(A:B) no se altera

More Related