Uso de PUSH y POP

Hay ocasiones en los que nuestros programas requieren muchos valores ya sea
ingresado desde teclado o varios resultados generados por algunas
operaciones, puede que en algn momento no tengamos abasto con los registros
y el uso de diversas variables puede complicar nuestros procesos, haciendo que
nuestro programa sea complejo, largo en cdigo y nada entendible. Para ello
podemos aplicar las operaciones de PUSH y POP, una de las mayores utilidades
es para el almacenamiento de resultados que posteriormente podemos
recuperar ya sea para una evaluacin o simplemente para mostrarlos en consola.
La operacin PUSH almacena en pila un valor WORD o DWORD (pueden ser
variables o registros que cumplan con dicha restriccin), cada vez que hacemos
un PUSH, el primer valor almacenado es empujado cada ms a la parte inferior
de la pila, en otras palabras el primero en almacenar en pila ser el ltimo en
salir.
Otro concepto es que los datos colocados en la parte superior son removidos y
ubicados en la parte inferior de la pila cada vez que utilizamos PUSH.




Observemos la figura, pensemos que realizamos un programa que introduzca en
pila los nmeros del 1 al 10 y que el primer valor ingresado fue 1, ahora, Qu
ocurre si ingresamos el nmero 2 a pila? Como hemos hablado anteriormente el
valor superior es ubicado en la parte inferior, haciendo que la posicin superior
sea ocupada por el nmero 2. En la figura el ltimo valor ingresado es el 10
haciendo que el primero que se ingres se encuentre en parte inferior de pila.
Para comprender un poco mejor la parte de pila y su almacenamiento,
consideremos la pila como un arreglo pero que es administrado directamente por
la CPU, ste es un arreglo que solo se puede agregar valores en la parte
superior, as tambin para obtenerlos. No se puede acceder ni a la parte de en
medio ni inferior directamente, para ello deberemos remover cada valor que
encuentre en posicin de la pila.
Restricciones de PUSH
PUSH reg32/reg16
PUSH mem32/mem16
PUSH inm
Push no trabaja con registro o variables de 8 bits, los nicos admitidos sern de
32, 16 bits o valores inmediatos que por defecto son considerados valores de 32
bits.
Sintaxis:
PUSH operador

Ejemplo de PUSH
Los registros utilizados son de 16 bits, en pila se han
almacenado los valores de la siguiente forma:


La parte superior est ocupado por el nmero 5 y la parte inferior por el nmero
8, recordemos el primer valor en ingresar ser el ltimo en salir.
Operador POP
Ahora que hemos entendido que PUSH se encarga de meter valores en pila,
ahora, Cmo recupero los valores almacenados?, para ello hacemos uso del
operador POP.
Retomemos la siguiente imagen:





Ahora con POP el ltimo valor ingresado en pila ser el primer en ser obtenido,
en el ejemplo en el que ingresamos los nmeros del 1 al 10, ahora deseamos
mostrar nuevamente esos valores Cmo lo hacemos?, utilizamos POP tal y
como lo hacemos con PUSH, el primer valor obtenido es 10 por estar en la parte
superior de la pila y el ltimo en ser obtenido ser el nmero 1 por encontrarse
en la parte inferior.
Restricciones:
POP reg32/reg16
POP mem32/mem16
Como PUSH solo admite registros o variables de 32 y 16 bits.
Sintaxis:
POP operador
El operador ser nuestra ubicacin donde se alojara el valor obtenido desde pila.

5
10
8
Ejemplo de POP
Nuevamente retomemos el ejemplo anterior de
PUSH, ahora obtendremos los valores que
habamos ingresado en pila. Realizamos el primer
POP y el valor que almacenamos en DX es 8, por
estar en la parte superior de la pila, como ven el
valor de DX ha sido modificado. Realizamos dos
veces ms POP y de esa manera obtenemos todos
los valores nuevamente que habamos
almacenado con PUSH.
El ltimo POP, lo realizamos con una variable que
hemos declarado en nuestra data, el tipo de dato
de la variable es WORD o de 16 bits. Algo muy
importante que se debe tener en cuenta y siempre
el tamao de nuestros operadores y de los valores almacenados.

Puede darse el caso de ingresar una combinacin de valores con diferentes
tamaos en el tipo de dato como lo siguiente:
Si observamos en el PUSH, el primer valor
ingresado es 34 y es un registro de tipo
DWORD as tambin el ltimo que es una
variable que almacena el valor de 50. En el
intermedio son valores de un tamao de 16
bits con los que hemos estado trabajando. Se
debe de tener el cuidado que cuando
obtengamos el valor nuevamente con POP el
tamao del valor almacenado debe coincidir
con el tamao del registro o variable destino.
Ejemplo:
PUSH reg16
PUSH reg32
POP mem32
POP reg16
Si se comete dicho es muy probable que el
no ocurra ninguna excepcin al momento de
compilar nuestro programa, si no durante la
ejecucin, dichos errores son ms difciles de
detectar que los de compilacin.


Ejemplo 1
Considere el siguiente arreglo:
Almacene en pila solamente las posiciones impares del arreglo (12, 4, 2, 2),
luego obtenga nuevamente los valores sumndolos y mostrando el total de la
suma en consola.
Cdigo:
Como hemos aprendido anteriormente
direccionamiento indirecto no me detendr
sobre ese tema, movemos la direccin de
memoria a ESI y accedemos al primer valor,
como vemos nuestro arreglo es de tipo WORD
significa que la distancia entre los elementos
son de 2 BYTES, significa que entre la primera
y tercera posicin hay 4 BYTES de separacin.
Almacenamos el elemento en BX y operamos
con PUSH, sumamos 4 BYTES para
colocarnos en la tercera posicin y realizamos
el mismo proceso.
Posteriormente operamos con POP
obteniendo en la lnea 23 el valor ltimo valor
ingresado que es 2, y lo sumamos a AX, y
repetimos el mismo proceso hasta obtener y
sumar todos los valores que almacenamos en
pila.
Este mismo ejercicio se puede realizar con
LOOP, el motivo de hacerlo de esta manera es
para demostrar de qu forma se almacena en
pila. NO olvidemos que el primero en entrar a
pila ser el ltimo en salir, esto se aplica para
PUSH, para POP el ltimo en ingresar ser el
primero en salir.


Resultado:




Ejemplo 1.2
Simplifique el ejercicio anterior con el uso de LOOP.
Cdigo:



















Resultado:








Uso de CMP
La comparacin de operandos es uno de los temas ms sencillos que se vern
durante el curso, pues el tan solo hecho de saber resolver un algoritmo son bases
suficientes para poder implementar saltos condicionales.
CMP compara el operando de la izquierda con el operando de la derecha.
Sintaxis:
CMP OpIzq, OpDer
Una vez realizada la comparacin podemos realizar saltos condicionales, los
saltos se describen:

Los saltos anteriores se utilizan cuando se comparan valores sin signo.
Tambin existen saltos condicionales para comparaciones con signo:

Estas comparaciones sern utilizadas cuando necesitemos comparar valores
negativos. Ambas comparaciones realizan lo mismo. Durante el curso
trabajaremos con los saltos condiciones de la primera tabla, comparando valores
sin signo.

NOTA: La segunda tabla ha sido colocada como un saber, se les solicita
que toda prctica realizada sea en base a los saltos condicionales
mostrados en clase, de esa manera evitamos confusiones, ha si tambin
durante la evaluacin.
Como ya conocemos el uso de estructuras de control en los lenguajes de alto
nivel, en assembler se utilizan saltos condicionales para realizar las mismas
estructuras, puede considerarse que esto es el verdadero assembler.
Tenemos la siguiente condicin:
En Java es una comparacin
sencilla, fcil de entender y de
hacer. Si el contenido de la variable
es mayor que 75 (que es un valor
inmediato) ingresa al primer
mensaje, caso contrario muestra el
mensaje en else.
Ahora, Cmo se realiza en assembler?
Primero debemos entender el algoritmo, que el valor es mayor me muestra el
primer mensaje, caso contrario el mensaje de menor. Sencillo no?
Una vez que comprendemos el algoritmo procedemos a desarrollarlo, primero lo
primero, comparamos.

Luego colocamos el salto condicional, recordemos si el nmero es mayor, me
muestre el primer mensaje, si no el segundo:
El salto condicional JA indica que si el VAL es mayor que 75 me lanza a la
etiqueta de cdigo MENSAJE1, si el valor es menor que 75 la condicin JA no
se cumple, pasando por alto el salto he imprime el segundo mensaje (MSG2) y
se realiza un salto no condicional a una etiqueta FIN, ste salto se realiza para
evitar que imprima el primer mensaje, esto sera aplicar lgica al programa.
Otra forma de realizar ste ejercicio sera:
Realmente es lo mismo, solamente aplicar sentido al
ejercicio y saber cmo desarrollar un algoritmo basta
para comprenderlo. Ahora es lo contrario, si el VAL es
menor (JB) saltar a la etiqueta de cdigo MENSAJE2, si
es falso, no realiza el salto he imprime el primer
mensaje.
Observemos detenidamente ste segundo ejemplo y
comparemos con la primera versin.
Una tercera versin:
En esta versin puede pensarse que no hay mayor
diferencia que la segunda versin, pero si nos fijamos en la
condicin ahora es SI no es mayor (JNA) que es lo
contrario de Si es menor (JB). Es muy importante tener
claras la diferencia entre cada salto condicional.
Tambin es importante comprender que la lgica de cada
uno de ustedes es diferente, ste ejercicio tiene alrededor
de 5 formas de hacerlo. Prueba!

Ejemplo 1
Realice las siguientes instrucciones en assembler:










Cdigo:


La explicacin es realmente corta, cuando
entramos en el LOOPEXTERNO evaluamos
si EAX es mayor que 3, si la comparacin es
verdadera saltara a la etiqueta SALIR para
finalizar el programa. Mientras sea menor
que 3 mostrara el mensaje, incrementamos
EAX y colocamos el valor de 1 a EBX que
realizara la comparacin en el segundo
bucle, al estar en LOOPINTERNO, se
compara EBX con 2 y si es mayor saltara a
la etiqueta LOOPEXTERNO donde se
repetir el proceso.