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

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

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

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.

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.

Funcionamiento de Subrutinas Antes de ejecutar el salto la situación es la siguiente: 0000 Libre JSR $2000 PC=3000 PROX INST PC=3003 SP=TOP_OF_STACK $FFFF

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

Fncionamiento de Subrutinas Durante la ejecución 3  se guarda (PUSH) PCH en el stack 4  se decrementa el SP en 1 0000 Libre PCH=$30 PCL=$03 JSR $2000 PC=3000 PROX INST PC=3003 SP=TOP_OF_STACK-2 $FFFF

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

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 $0000 Libre PCH=$30 PCL=$03 RTS PC=XXXX SP=TOP_OF_STACK-2 $FFFF

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

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

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

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

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

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

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.

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 SP TYS (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

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

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

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

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

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

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

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

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

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

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

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

Intrucciones que operan sobre el Stack Que fecto tendría las siguientes instrucciones? CASO 1 pshb pula CASO 2 pshx pulb CASO 3 psha B -> A X -> D (A:B) B <-> A

Usos de Pull y Push 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 Mr. Stack

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.

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.

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.

Preservación de registros durante una llama a función: 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: 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 Guardo Registros Libre XH XL A SP Recupero Registros

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.

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) LDAA 5,X Param1 LDAB 4,X Param2 .............. PULB ;Recupero B PULA ;Recupero A PULX RTS Ej.: PSHA Param1 PSHB Param2 JSR SUB INS Libre XH XL 1 PCH 2 PCL 3 Param2 4 Param1 5 SP X Stack Frame

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.

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.

Pasaje de Parámetros por stack: Retorno de valores al programa principal * 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 LDAA 5,X Parm1  A CMPA 4,X Parm1 - Parm2 BCC Mayor Menor LDAA 4,X Parm2  A Mayor STAA 5,X Parm1/2  Ret1 PULA Recupero A PULX Recupero X RTS SP Programa principal PSHA Param1 PSHB Param2 JSR MAX PULA Libre XH XL 1 PCH 2 PCL 3 Prm2 4 Prm1/Ret1 5 FP Stack Frame

Pasaje de Parámetros por stack: 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: PSHA Param1 PSHB Param2 DES JSR MAX Espacio adicional

Pasaje de Parámetros por stack: Pasaje de valores por referencia: SP Programa principal LDX #$C000 Dirección del Param1 PSHX LDX #$C001 Dirección del Param2 JSR MAX2 PULX Libero stack PULA Libero stack PULA Valor de retorno Libre XH XL 1 PCH 2 PCL 3 Dir2_H 4 Dir2_L 5 Dir1_H 6 Dir1_L / Ret1 7 FP Stack Frame

Pasaje de Parámetros por stack: 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 MAX2 PSHX Salvo X TSX Creo el Frame Pointer PSHY Preservo Y PSHA Preservo A LDY 6,X Dir.Parm1  Y LDAA 0,Y Parm1  A LDY 4,X Dir.Parm2  Y CMPA 0,Y Parm1 - Parm2 BCC Mayor Menor LDAA 0,Y Parm2  A Mayor STAA 7,X Parm1/2  Ret1 PULA Recupero A PULY Recupero Y PULX Recupero X RTS Stack Frame SP Libre XH XL 1 PCH 2 PCL 3 Dir2_H 4 Dir2_L 5 Dir1_H 6 Dir1_L / Ret1 7 FP

Pasaje de Parámetros por stack: 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: 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: Ejemplo (1) de uso de variables locales creadas en stack Utilizamos la intrucción des, psha, pshb u otra SP FP Ej1.: PSHX Salvo el FP de la rutina que efectuó la llamada. DES Reservo 3 bytes para variables locales DES TSX X=Nuevo FP Libre LOC(1) LOC(2) 1 LOC(3) 2 XH:XL 3/4 PCH:PCL 5/6

Pasaje de Parámetros por stack: Ejemplo (2) de uso de variables locales creadas en stack Ej2.: PSHX Salvo el FP de la rutina que efectuó la llamada. PSHX PSHX Reservo 6 Bytes para variables locales (1) TSX X=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 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 PSHX Salvo el FP de la rutina que efectuó la llamada. TSX SP+1 X XGDX X <--> D SUBD #N D-N D TXS X-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: 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) 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) SP FP

Pasaje de Parámetros por stack: Para liberar el área usada por las variables locales el procedimiento es el siguiente: SP FP FP+KSP Libero K variables del Stack. LDB #K ABX FP+KFP TXS FP-1SP PULB recupero B PULX X=FP previo RTS Libre LOC(1) LOC(2) 1 LOC(K) K-1 ACCB XH:XL PCH:PCL

Pasaje de Parámetros por stack: 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 PSHX Salvo FP0 CLRX PSHX LOC1 y LOC2 = 0 (inicializo locales) TSX FP1 ----------- LDY RET,X PCH:PCL  Y LDX FP0,X Recupero el FP0 (previo) TXS Actualizo SP JMP 0,Y (RTS) Libre LOC 1 (=0) LOC 2 (=0) XH:XL (FP0) FP0 PCH:PCL RET IY/ Libre 0 LOC 0 SP FP1 SP FP0

Pasaje de Parámetros por stack: Stack Frame después de dos llamadas sucesivas: Libre Locales Registros XH :XL (FP previo)[FP1] PCH : PCL (Dirección de retorno2) XH :XL (FP previo) PCH : PCL (Dirección de retorno1) SP FP2 SP FP1

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

Ventajas del uso de variables locales: El uso de variables locales permite un uso más racional de la memoria Las subrutinas que utilizan variables locales pueden ser recursivas o reentrantes (subrutinas que generan un conjunto de variables nuevas cada vez que son invocadas) 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. 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.

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