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

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

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

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

Stack y SubrutinasIntroducción a la Computación

1Ing. Diego Figueyra

Stack y Subrutinas

Page 2: Stack y Subrutinas Introducción a la Computación 1 Ing. 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)

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

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

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

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

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

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.

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

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.

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

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

Page 8: Stack y Subrutinas Introducción a la Computación 1 Ing. Diego Figueyra Stack y 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

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

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

Page 10: Stack y Subrutinas Introducción a la Computación 1 Ing. Diego Figueyra Stack y 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

Page 11: Stack y Subrutinas Introducción a la Computación 1 Ing. Diego Figueyra Stack y 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

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

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.

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

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.

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

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.

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

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

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

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.

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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.

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

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

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

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

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

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

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

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.

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

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.

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

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.

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

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:

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

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

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

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.

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

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

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

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.

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

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.

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

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:

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

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:

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

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:

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

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:

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

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:

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

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:

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

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:

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

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:

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

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

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

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

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

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:

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

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:

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

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:

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

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

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

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.

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

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

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

Stack y SubrutinasIntroducción a la Computación

58Ing. Diego Figueyra