Upload
encarnacion-sabado
View
6
Download
2
Embed Size (px)
Citation preview
Stack y SubrutinasIntroducción a la Computación
1Ing. Diego Figueyra
Stack y Subrutinas
Stack y SubrutinasIntroducción a la Computación
2Ing. 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)
Stack y SubrutinasIntroducción a la Computación
3Ing. 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).
Stack y SubrutinasIntroducción a la Computación
4Ing. Diego Figueyra
Soporte a la modularización
JSR $2000$3000
RTS
Inst. 1
Inst. 2
$2000
Prox. Inst.$3003
Stack y SubrutinasIntroducción a la Computación
5Ing. 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.
Stack y SubrutinasIntroducción a la Computación
6Ing. 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.
Stack y SubrutinasIntroducción a la Computación
7Ing. Diego Figueyra
• Antes de ejecutar el salto la situación es la siguiente:
Libre
Libre
Libre
Libre
Libre
Libre
LibreSP=TOP_OF_STACK
JSR $2000JSR $2000 PC=3000
PROX INSTPROX INST PC=3003
0000
$FFFF
Funcionamiento de Subrutinas
Stack y SubrutinasIntroducción a la Computación
8Ing. Diego Figueyra
Libre
Libre
Libre
Libre
Libre
Libre
PCL=$03
JSR $2000JSR $2000 PC=3000
PROX INSTPROX INST PC=3003
0000
$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
Stack y SubrutinasIntroducción a la Computación
9Ing. Diego Figueyra
Durante la ejecución 3 se guarda (PUSH) PCH en el stack4 se decrementa el SP en 1
Libre
Libre
Libre
Libre
Libre
PCH=$30
PCL=$03
JSR $2000JSR $2000 PC=3000
PROX INSTPROX INST PC=3003
0000
$FFFF
SP=TOP_OF_STACK-2
Fncionamiento de Subrutinas
Stack y SubrutinasIntroducción a la Computación
10Ing. Diego Figueyra
Durante la ejecución 5 se carga $2000 en PC 6 se inicia la ejecución de la
subrutina
Libre
Libre
Libre
Libre
Libre
PCH=$30
PCL=$03
1er Inst. Sub.1er Inst. Sub. PC=20000000
$FFFF
SP=TOP_OF_STACK-2
Funcionamiento de Subrutinas
Stack y SubrutinasIntroducción a la Computación
11Ing. Diego Figueyra
Libre
Libre
Libre
Libre
Libre
PCH=$30
PCL=$03
RTSRTS 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
Stack y SubrutinasIntroducción a la Computación
12Ing. Diego Figueyra
Libre
Libre
Libre
Libre
Libre
PCH=$30
PCL=$03
RTSRTS 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.
Stack y SubrutinasIntroducción a la Computación
13Ing. Diego Figueyra
Libre
Libre
Libre
Libre
Libre
PCH=$30
PCL=$03
RTSRTS 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.
Stack y SubrutinasIntroducción a la Computación
14Ing. 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.
Stack y SubrutinasIntroducción a la Computación
15Ing. 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”.
Stack y SubrutinasIntroducción a la Computación
16Ing. Diego Figueyra
Push Pull
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.
Stack y SubrutinasIntroducción a la Computación
17Ing. Diego Figueyra
Funcionamiento de Subrutinas
• Esquema de invocación de subrutinas múltiples
Inicio
Subrutina 1
Subrutina 1.1
Subrutina 1.1.1Fin
Stack y SubrutinasIntroducción a la Computación
18Ing. 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.
Stack y SubrutinasIntroducción a la Computación
19Ing. 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
stack2. PULA ,PULB ,PULX ,PULY Estas recuperan registros del
stack3. TSX (SP)+1 IX TSY (SP)+1 IY4. TXS (IX)-1 SP TYS (IY)-1 SP5. LDS Inicializa el SP (modos de direccionamiento:Todos)6. STS Guarda el SP (modos de direccionamiento:Todos)7. INS SP+1SP DES SP-1SP
Stack y SubrutinasIntroducción a la Computación
20Ing. 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
Libre
Libre
Libre
Libre
Libre
Libre
PSHAPSHA A=$F8$0000
$FFFF
SP=TOP_OF_STACK
PROX. INST.PROX. INST. A=$F8
Instrucciones que operan con Stack
Stack y SubrutinasIntroducción a la Computación
21Ing. Diego Figueyra
• Durante de la ejecución: 1- A(SP) 2- SP-1SP
Libre
Libre
Libre
Libre
Libre
Libre
$F8
PSHAPSHA A=$F8$0000
$FFFF
SP=TOP_OF_STACK -1
PROX. INST.PROX. INST. A=$F8
Instrucciones que operan con Stack
Stack y SubrutinasIntroducción a la Computación
22Ing. Diego Figueyra
Libre
Libre
Libre
Libre
Libre
Libre
Libre
PSHXPSHX X=$ABCD$0000
$FFFF
SP=TOP_OF_STACK
PROX. INST.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
Stack y SubrutinasIntroducción a la Computación
23Ing. Diego Figueyra
PROX. INST.PROX. INST.
• Primero se guarda la parte baja de X en el STACK
Libre
Libre
Libre
Libre
Libre
Libre
$CD
PSHXPSHX X=$ABCD$0000
$FFFF
SP=TOP_OF_STACK - 1
X=$ABCD
Instrucciones que operan con Stack
Stack y SubrutinasIntroducción a la Computación
24Ing. Diego Figueyra
PROX. INST.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
Libre
Libre
Libre
Libre
$AB
$CD
PSHXPSHX X=$ABCD$0000
$FFFF
SP=TOP_OF_STACK -2
X=$ABCD
Instrucciones que operan con Stack
Stack y SubrutinasIntroducción a la Computación
25Ing. 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
Libre
Libre
Libre
Libre
Libre
$A9
PULA A=$??0000
$FFFF
SP=TOP_OF_STACK-1
PROX. INST.
Instrucciones que operan con Stack
Stack y SubrutinasIntroducción a la Computación
26Ing. Diego Figueyra
• Después de la ejecución el estado del procesador es el siguiente:
Libre
Libre
Libre
Libre
Libre
Libre
$A9
PULA A=$A90000
$FFFF
SP=TOP_OF_STACK
PROX. INST.
Instrucciones que operan con Stack
Stack y SubrutinasIntroducción a la Computación
27Ing. 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
Libre
Libre
Libre
Libre
$12
$34
PULX X=$????0000
$FFFF
SP=TOP_OF_STACK-2
PROX. INST.
Instrucciones que operan con Stack
Stack y SubrutinasIntroducción a la Computación
28Ing. Diego Figueyra
Libre
Libre
Libre
Libre
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.
Stack y SubrutinasIntroducción a la Computación
29Ing. Diego Figueyra
Libre
Libre
Libre
Libre
Libre
$12
$34
PULX X=$12340000
$FFFFSP=TOP_OF_STACK
PROX. INST.
Intrucciones que operan con Stack
• Durante la ejecución: 3- SP+1 SP 4- (SP) XL.
Stack y SubrutinasIntroducción a la Computación
30Ing. 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:
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+1SPLDAA 0,S (SP)A
Stack y SubrutinasIntroducción a la Computación
31Ing. Diego Figueyra
• Que fecto tendría las siguientes instrucciones?– CASO 1
pshbpula
– CASO 2
pshxpulapulb
– CASO 3
pshapshbpulapulb
Intrucciones que operan sobre el Stack
B -> A
X -> D (A:B)
B <-> A
Stack y SubrutinasIntroducción a la Computación
32Ing. Diego Figueyra
• Para que sirven las instrucciones de push y pull?1. Preservar el contenido de registros cuando se invoca un
módulo/subrutina2. Pasar parámetros a una subrutina utilizando el stack3. Creación de variables temporales en stack
Usos de Pull y Push
Mr. Stack
Stack y SubrutinasIntroducción a la Computación
33Ing. 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.
Stack y SubrutinasIntroducción a la Computación
34Ing. 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.
Stack y SubrutinasIntroducción a la Computación
35Ing. 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.
Stack y SubrutinasIntroducción a la Computación
36Ing. Diego Figueyra
Ejemplo************************************************ Rutina de retardo Parámetro: AccA [1-255]* Registros modificados :AccA. Valor retornado:Ninguno***********************************************
pshx ;Salvo Xloop2 ldx #100 ;Constante para Loop mas internoloop1 dex
bne loop1 deca ;Contador mas interno del loopbne loop2pulx ;Recupero Xrts
Preservación de registros durante una llama a función:
Stack y SubrutinasIntroducción a la Computación
37Ing. 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
Libre
XH
XL
A
SP
Preservación de registros durante una llama a función:
Guardo Registros
Recupero Registros
Stack y SubrutinasIntroducción a la Computación
38Ing. 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.
Stack y SubrutinasIntroducción a la Computación
39Ing. Diego Figueyra
Ej.:
PSHA Param1
PSHB Param2
JSR SUB
INS
INS
Libre
XH 0
XL 1
PCH 2
PCL 3
Param2 4
Param1 5
SP PSHX ;salvo XTSX ;SP+1X(X=Frame Pointer)PSHA ;Salvo APSHB ;Salvo B(Acceso a parámetros)LDAA 5,X Param1 LDAB 4,X Param2 ............................PULB ;Recupero BPULA ;Recupero APULXRTS
X
Stack Frame
Pasaje de Parámtros por stack (ejemplo):
Stack y SubrutinasIntroducción a la Computación
40Ing. 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.: LDA DESP1,X Parametro1 AINC DESP1,X Parametro1+1 Parametro1
Siendo DESP1 el desplazamiento del parámetro 1 respecto del Frame Pointer.
Stack y SubrutinasIntroducción a la Computación
41Ing. 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.
Stack y SubrutinasIntroducción a la Computación
42Ing. Diego Figueyra
• Retorno de valores al programa principal
Programa principal
PSHA Param1PSHB Param2 JSR MAXPULAPULA
* Subrutina MAX: Compara 2 números no* signados de 8 bits y retorna el mayor.* PRM1 5 , PRM2 4 , RET1 5
MAX PSHX Salvo XTSX Creo el Frame PointerPSHA Preservo A
LDAA 5,X Parm1 ACMPA 4,X Parm1 - Parm2BCC Mayor
Menor LDAA 4,X Parm2 AMayor STAA 5,X Parm1/2 Ret1
PULA Recupero APULX Recupero XRTS
Libre
XH 0
XL 1
PCH 2
PCL 3
Prm2 4
Prm1/Ret1 5
SP
FP
Stack Frame
Pasaje de Parámetros por stack:
Stack y SubrutinasIntroducción a la Computación
43Ing. 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:
PSHA Param1PSHB Param2 DESDES JSR MAX
Espacio adicional
Pasaje de Parámetros por stack:
Stack y SubrutinasIntroducción a la Computación
44Ing. Diego Figueyra
• Pasaje de valores por referencia:
Programa principal
LDX #$C000 Dirección del Param1PSHXLDX #$C001 Dirección del Param2PSHX
JSR MAX2
PULX Libero stackPULA Libero stackPULA Valor de retorno
Libre
XH 0
XL 1
PCH 2
PCL 3
Dir2_H 4
Dir2_L 5
Dir1_H 6
Dir1_L / Ret1 7
SP
FP
Stack Frame
Pasaje de Parámetros por stack:
Stack y SubrutinasIntroducción a la Computación
45Ing. 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
MAX2 PSHX Salvo XTSX Creo el Frame PointerPSHY Preservo YPSHA Preservo ALDY 6,X Dir.Parm1 YLDAA 0,Y Parm1 ALDY 4,X Dir.Parm2 YCMPA 0,Y Parm1 - Parm2BCC Mayor
Menor LDAA 0,Y Parm2 AMayor STAA 7,X Parm1/2 Ret1
PULA Recupero APULY Recupero YPULX Recupero XRTS
SP
FPLibre
XH 0
XL 1
PCH 2
PCL 3
Dir2_H 4
Dir2_L 5
Dir1_H 6
Dir1_L / Ret1 7
Stack Frame
Pasaje de Parámetros por stack:
Stack y SubrutinasIntroducción a la Computación
46Ing. 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:
Stack y SubrutinasIntroducción a la Computación
47Ing. 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:
Stack y SubrutinasIntroducción a la Computación
48Ing. Diego Figueyra
• Ejemplo (1) de uso de variables locales creadas en stack– Utilizamos la intrucción des, psha, pshb u otra
Ej1.:
PSHX Salvo el FP de la rutina que efectuó la llamada.DES Reservo 3 bytes para variables localesDESDESTSX X=Nuevo FP
Libre
LOC(1) 0
LOC(2) 1
LOC(3) 2
XH:XL 3/4
PCH:PCL 5/6
SP
FP
Pasaje de Parámetros por stack:
Stack y SubrutinasIntroducción a la Computación
49Ing. Diego Figueyra
• Ejemplo (2) de uso de variables locales creadas en stack
Ej2.:
PSHX Salvo el FP de la rutina que efectuó la llamada.PSHXPSHX Reservo 6 Bytes para variables locales (1)PSHXTSX 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:
Stack y SubrutinasIntroducción a la Computación
50Ing. 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-NSP Reservo N Bytes en el Stack
PSHX Salvo el FP de la rutina que efectuó la llamada.TSX SP+1 X XGDX X <--> DSUBD #N D-N DXGDX X <--> DTXS 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
Stack y SubrutinasIntroducción a la Computación
51Ing. 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
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
Stack y SubrutinasIntroducción a la Computación
52Ing. Diego Figueyra
• Para liberar el área usada por las variables locales el procedimiento es el siguiente:
FP+KSP Libero K variables del Stack.
LDB #KABX FP+KFPTXS FP-1SPPULB recupero BPULX X=FP previoRTS
Libre
LOC(1) 0
LOC(2) 1
LOC(K) K-1
ACCB
XH:XL
PCH:PCL
SP
FP
Pasaje de Parámetros por stack:
Stack y SubrutinasIntroducción a la Computación
53Ing. 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 SUBPULY
Subrutina
PSHX Salvo FP0CLRXPSHX LOC1 y LOC2 = 0 (inicializo locales)TSX FP1-----------LDY RET,X PCH:PCL YLDX FP0,X Recupero el FP0 (previo)TXS Actualizo SPJMP 0,Y (RTS)
Libre
Libre
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 y SubrutinasIntroducción a la Computación
54Ing. Diego Figueyra
• Stack Frame después de dos llamadas sucesivas:
SP
FP1
Libre
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:
Stack y SubrutinasIntroducción a la Computación
55Ing. 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
Stack y SubrutinasIntroducción a la Computación
56Ing. 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.
Stack y SubrutinasIntroducción a la Computación
57Ing. 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
Stack y SubrutinasIntroducción a la Computación
58Ing. Diego Figueyra