29-10-2014

ESTRUCTURA
DE DATOS
ESD-115

APLICACIN Y USO DE PILAS EN LENGUAJE

ENSAMBLADOR

Estructuras de Datos | Grupo 8

Tabla de contenido
INTRODUCCION. ....................................................................................................................... ii
OBJETIVOS. ............................................................................................................................... ii
OBJETIVO GENERAL ............................................................................................................... ii
OBJETIVOS ESPECIFICOS ........................................................................................................ ii
Alcances del Proyecto. .............................................................................................................. 0
DESCRIPCION DEL TEMA. .......................................................................................................... 1
Lenguaje Ensamblador del Microprocesador. ........................................................................ 2
Instrucciones de Transferencia de Datos. .............................................................................. 3
Instrucciones de control de Bucles .................................................................................... 4
Instrucciones Aritmticas. ................................................................................................. 4
Formato de las Instrucciones. ............................................................................................ 5
Aplicacin de pilas en Lenguaje Ensamblador. ................................................................... 6
RESULTADOS ESPERADOS. ........................................................................................................ 9
PLANTEAMIENTO DEL PROBLEMA. .......................................................................................... 10
ANALISIS DEL PROBLEMA. ....................................................................................................... 11
DISEO. .................................................................................................................................. 14
Operacin Recorrido: .......................................................................................................... 14
Operacin Push: .................................................................................................................. 14
Operacin Pop: ................................................................................................................... 15
Operacin Bsqueda: .......................................................................................................... 15
Operacin Eliminar:............................................................................................................. 15
PRUEBAS. ................................................................................................................................ 17
MANUAL DE USUARIO............................................................................................................. 20
CONCLUSIONES....................................................................................................................... 30
BIBLIOGRAFIA. ........................................................................................................................ 31

INTRODUCCION.

El lenguaje ensamblador es la forma ms bsica de programar un microprocesador.

Con la aparicin de los computadores personales (PC) y la reduccin de los costos de
las mismas, el microprocesador se convirti en uno de los dispositivos electrnicos ms
importantes en la historia de la electrnica. Bsicamente un microprocesador es un
circuito electrnico de muy alta escala de integracin, capaza de realizar una infinidad
de tareas de forma repetitiva a velocidades muy altas. El lenguaje ensamblador
permite que este sea capaz de realizar las tareas o los clculos que se le requieren.
Aprender a programar en lenguaje ensamblador no es fcil, se requiere un cierto nivel
de conocimiento de la arquitectura y organizacin de las computadoras, adems del
conocimiento de programacin en algn otro lenguaje
Las pilas son un tipo de estructura de datos que es fcil desarrollar por los sistemas
microprocesadores y resulta de gran utilidad para trabajar con listas de datos y es
imprescindible para el trabajo interno del microprocesador en las subrutinas e
interrupciones. El nombre de PILA no es por otra cosa sino por su forma de uso, es
decir, el ultimo que entra es el primero que sale, comnmente tambin llamado Last
In First Out (LIFO).
Algunos microprocesadores pueden tener la pila en su interior, representado un
sistema muy rpido pero de tamao limitado, la mayora de microprocesadores
disponen la pila en la memoria externa, hecho que proporciona una gran capacidad de
almacenamiento y el control de su ubicacin, aunque el acceso sea ms lento.
Este proyecto est orientado a la aplicacin y uso de las pilas en el lenguaje
ensamblador, manipulando la entrada y salida de datos en una pila, utilizando las
instrucciones del manejo de pilas que son dos, una para apilar un operando fuente y
una para desapilar el valor que est en el tope de la pila y colocarlo en un operando
distinto.

OBJETIVOS.
OBJETIVO GENERAL

Implementar el uso de pilas en lenguaje ensamblador mediante el desarrollo de

estructuras de datos en una aplicacin en la que se muestre su uso en un
entorno real, aplicando todos los conocimientos adquiridos.

Desarrollar una simulacin del uso de pilas en una aplicacin basada en una
calculadora en lenguaje ensamblador, utilizando el compilador MASM32.

OBJETIVOS ESPECIFICOS

Aplicar los conocimientos tericos del uso de pilas en forma prctica para as
poder identificar un escenario en el cual se implemente el uso de estas en
lenguaje ensamblador.

Aprender a codificar de manera correcta en el compilador MASM32, para as

poder desarrollar del escenario elegido una aplicacin en un entorno real en la
cual se utilice el uso de pilas.

ii

Alcances del Proyecto.

El proyecto desarrollar una aplicacin programada en lenguaje ensamblador

en un periodo de 3 meses en los cuales espera emular la forma en que se
comportan las estructuras de datos de datos en entornos como
microprocesadores o micro controladores los cuales ocupan este tipo de
estructuras de datos para apilar las direcciones de datos en la arquitectura de
la maquina a cual estn aplicadas.
La aplicacin demostrara no solo el uso de las pilas si no cmo se comportan
en este nivel bajo de programacin para esto se usara un lenguaje del mismo
nivel como lo es el ensamblador el fin es ver como las pilas son una estructura
muy til en este tipo de entornos y como expertos programadores en lenguaje
ensamblador recuren a las pilas as como otro tipo de estructura de datos para
desarrollar programas que se ejecutaran ms fcil y que usaran menos
recursos de memoria.

En resumen el alcance principal es montar una aplicacin en lenguaje

ensamblador que emula cmo se comportan la estructura de datos pilas las
cuales son usadas comn mente a niveles de arquitectura de hardware en la
asignacin de memoria y como esta estructura de dato es altamente til a la
hora de desarrollar arquitectura de maquina como un Kernel o
Microcontroladores.

iii

DESCRIPCION DEL TEMA.

Una pila (stack en ingls) es una lista ordenada o estructura de datos en la que el
modo de acceso a sus elementos es de tipo LIFO (del ingls Last In First Out, ltimo
en entrar, primero en salir) que permite almacenar y recuperar datos. Esta estructura
se aplica en multitud de ocasiones en el rea de informtica debido a su simplicidad y
ordenacin implcita de la propia estructura.
Para el manejo de los datos se cuenta con dos
operaciones bsicas: apilar (push), que coloca
un objeto en la pila, y su operacin
inversa, retirar ( desapilar, pop), que retira el
ltimo elemento apilado.
En cada momento slo se tiene acceso a la
parte superior de la pila, es decir, al ltimo
objeto apilado (denominado TOS, Top of
Stack en ingls). La operacin retirar permite
la obtencin de este elemento, que es retirado de la pila permitiendo el acceso al
siguiente (apilado con anterioridad), que pasa a ser el nuevo TOS.
Por analoga con objetos cotidianos, una
operacin apilar equivaldra a colocar un
plato sobre una pila de platos, y una
operacin retirar a retirarlo.

Operaciones.
Una pila cuenta con 2 operaciones
imprescindibles: apilar y desapilar, a las que en las implementaciones modernas de las
pilas se suelen aadir ms de uso habitual.

Crear: se crea la pila vaca. (constructor)

Tamao: regresa el nmero de elementos de la pila. (size)

Apilar: se aade un elemento a la pila.(push)

Desapilar: se elimina el elemento frontal de la pila.(pop)

Cima: devuelve el elemento que est en la cima de la pila. (top o peek)

1

Vaca: devuelve cierto si la pila est sin elementos o falso en caso de que
contenga uno. (empty).

Lenguaje Ensamblador del Microprocesador.

La Unidad Central de Proceso (CPU, por sus siglas en ingls) tiene 14 registros internos
cada uno de 16 bits. Los primeros cuatro, AX, BX, CX, y DX, son de uso general y se
pueden usar tambin como registros de 8 bits. Es decir, AX se puede dividir en AH y AL
(AH es el byte alto, high, y AL es el byte bajo, low). Lo mismo es aplicable a los otros
tres (BX en BH y BL, CX en CH y CL y DX en DH y DL)
Estos son los nicos registros que pueden usarse de modo dual (en 8 o 16 bits). Los
registros de la CPU son conocidos por sus nombres propios, que son:
AX

(acumulador)

BX

(registro base)

CX

(registro contador)

DX

(registro de datos)

DS

(registro de segmentos de datos)

ES

(registro del segmento extra)

SS

(registro del segmento pila)

CS

(registro del segmento de cdigo)

BP

(registro de apuntadores base)

SI

(registro de ndice fuente)

DI

(registro ndice destino)

SP

(registro del apuntador pila)

IP

(registro del apuntador de siguiente instruccin)

(registro de banderas)

El registro AX se usa para almacenar resultados, lecturas o escrituras desde o hacia los
puertos- el BX sirve como apuntador base, o ndice. El CX se utiliza en operaciones de
iteracin, como un contador que automticamente se incrementa o decrementa de
acuerdo con el tipo de instruccin usada. El DX se usa como puente para el acceso de
datos.
2

El DS es un registro de segmento cuya funcin es actuar como polica donde se

encuentran los datos. Cualquier dato, ya sea una variable inicializada o no, debe estar
dentro de este segmento. El registro ES tiene el propsito general de permitir
operaciones sobre cadenas, pero tambin puede ser una extensin del DS.
El SS tiene la tarea exclusiva de manejar la posicin de memoria donde se encuentra la
pila (stack). Esta es una estructura usada para almacenar datos en forma temporal,
tanto de un programa como de las operaciones internas de la computadora personal
(PC, por sus siglas en ingles). En trminos de operacin interna, la CPU usa este
segmento para almacenar las direcciones de retorno de las llamadas a rutinas. El
registro de segmentos ms importante es el CS o segmento de cdigo. Es aqu donde
se encuentra el cdigo ejecutable de cada programa, el cual est directamente ligado a
los diferentes modelos de memoria.
El registro BP (base pointer) se usan para manipular la pila sin afectar al registro de
segmentos SS. Es til cuando se usa una interfaz entre lenguajes de alto nivel y el
ensamblador. Puesto que dicha se basa en el concepto de la pila BP, nos permite
acceder parmetros pasados sin alterar el registro de segmento SS. Los registros SI y DI
son tiles para manejar bloques de cadenas en memoria, siendo el primero el ndice
fuente y el segundo el ndice destino. En otras palabras, SI representa la direccin
donde se encuentra la cadena y Di la direccin donde ser copiada.
El registro SP apunta a un rea especfica de memoria que sirve para almacenar datos
bajo la estructura LIFO (ultimo en entrar, primero en salir), conocida como pila (stack).
El registro de IP (intruction pointer) apunta a la siguiente instruccin que ser
ejecutada en memoria.
Instrucciones de Transferencia de Datos.
Estas instrucciones mueven datos de una parte a otra del sistema; desde y hacia la
memoria principal, de y a los registros de datos, puertos E/S y registros de
segmentacin.
Las instrucciones de transferencias de datos son las siguientes:
MOV

transfiere

XCHG

intercambia

IN

entrada

OUT

salida

XLAT

traduce usando una tabla

LEA

carga la direccin efectiva

 LDS

carga el segmento de datos

LES

carga el segmento extra

LAHF

carga los indicadores en AH

SAHF

guarda AH en los indicadores

PUSH FUENTE

(sp) < fuente

POP DESTINO

destino < (sp)

Instrucciones de control de Bucles

INC

incrementar

DEC

decrementar

LOOP

realizar un bucle

LOOPZ, LOOPE

realizar un bucle si es cero

LOOPNZ, LOOPNE

realizar un bucle si no es cero

JCXZ

salta si CX es cero.

Instrucciones Aritmticas.

A. Grupo de adicin:
ADD

suma

ADC

suma con acarreo

AAA

ajuste ASCII para la suma

DAA

ajuste decimal para la suma

B. Grupo de sustraccin:
SUB

resta

SBB

resta con acarreo negativo

ASS

ajuste ASCII para la resta

DAS

ajuste decimal para la resta

C. Grupo de multiplicacin:
MUL

multiplicacin

IMUL

multiplicacin entera

AAM

ajuste ASCII para la multiplicacin

D. Grupo de divisin
DIV

divisin

IDIV

divisin entera

AAD

ajuste ASCII para la divisin

Formato de las Instrucciones.

Cada instruccin en lenguaje ensamblador est compuesta por cuatro campos:
Etiquetas/operacin/operando/comentario
El campo comentario se utiliza para propsitos de documentacin y es opcional.
Campo etiqueta: una etiqueta debe comenzar con un carcter alfabtico y puede
contener hasta 31 caracteres, incluyendo:
Letras de la A , a la Z
Nmeros del 0 al 9
Los smbolos especiales: $. @ %
No se puede utilizar un nombre que coincida con una palabra reservada o directiva del
ensamblador. Si el nombre incluye un punto, entonces el puno debe ser el primer
carcter.
Campo operacin: contiene el nemotcnico de la instruccin, que es de 2 a 6
caracteres.
Campo operando: Contiene la posicin o posiciones donde estn los datos que van a
ser manipulados por la instruccinCampo comentario: Se utiliza para documentar el cdigo fuente del ensamblador.
Debe separarse del ultimo capo por al menos un espacio e iniciar con ;.
Cuando inicia un comentario en una lnea esta deber tener en la primera columna el
carcter ;.
5

La siguiente tabla muestra el cdigo de seleccin del registro:

REG REGISTRO DE 16 BITS REGISTRO DE 8 BITS
000

AX

AL

001

CX

CL

010

DX

DL

011

BX

BL

100

SP

AH

101

BP

CH

110

SI

DH

Aplicacin de pilas en Lenguaje Ensamblador.

El lenguaje Ensamblador es un lenguaje traductor que permite tener un control total

sobre cada instruccin generada por una mquina en particular mediante el programa
traductor es llamado Ensamblador. Compiladores como Pascal o C++, realizan una
multitud de invisibles e inalterables procesos acerca de cmo una dada declaracin del
lenguaje ser traducida en instrucciones de mquina.
Un ensamblador tiene al menos una lnea en el archivo de cdigo fuente por cada
instruccin de mquina generada. Tiene ms lneas para manejar muchas otras cosas,
pero cada instruccin de maquina en el archivo de cdigo objeto final es controlada
por su correspondiente lnea en el archivo de cdigo fuente. Cada una de las muchas
instrucciones de maquina en el CPU tiene un mnemnico correspondiente en lenguaje
ensamblador.
Es necesario conocer la estructura bsica de un programa escrito en lenguaje
ensamblador. Bsicamente nuestros programas podran estar englobados en cuatro
bloques fundamentales:

Declaraciones y definiciones.

Segmento de datos.

Segmento de pila.

Segmento de cdigo.

Declaraciones y definiciones

Definicin de constantes, importacin de cdigo o informacin al compilador.

Segmento de datos

Reserva de espacio para las variables que usa el programa.

Para la creacin de un segmento, se utiliza la directiva SEGMENT, la cual indica el
comienzo del mismo.
El segmento, en el cdigo fuente, define un bloque de sentencias fuente, ya sean
directivas o instrucciones.
El final del segmento viene dado por la directiva ENDS (END Segment).

Segmento de pila

Todos los programas han de llevar pila, con el fin de depositar la informacin necesaria
para las llamadas a funciones, o bien almacenar datos temporalmente. En este bloque
se define un tamao para la pila.
El segmento de pila se define como cualquier otro segmento, pero especificando la
palabra reservada STACK.
En este segmento reservamos nicamente espacio para la pila, es decir, definimos su
tamao.

Segmento de cdigo

Definicin de todos los procedimientos e instrucciones del programa.

Un procedimiento es un conjunto de sentencias, las cuales se engloban entre la
directiva PROC (PROCedure) y la directiva ENDP (END Procedure).
Instrucciones bsicas de una pila en ensamblador.
Instruccin POP
Propsito: Recupera un dato de la pila
Sintaxis: POP destino
Esta instruccin transfiere el ltimo valor almacenado en la pila al operando destino,
despus incrementa en dos el registro SP.
Este incremento se debe a que la pila va creciendo desde la direccin ms alta de
memoria del segmento hacia la ms baja, y la pila solo trabaja con palabras (2 bytes),
7

entonces al incrementar en dos el registro SP realmente se le est restando dos al

tamao real de la pila.

Instruccin PUSH
Propsito: Coloca una palabra en la pila.
Sintaxis: PUSH fuente
La instruccin PUSH decrementa en dos el valor de SP y luego transfiere el contenido
del operando fuente a la nueva direccin resultante en el registro recin modificado.
El decremento en la direccin se debe a que al agregar valores a la pila sta crece de la
direccin mayor a la direccin menor del segmento, por lo tanto al restarle 2 al valor
del registro SP lo que hacemos es aumentar el tamao de la pila en dos bytes, que es la
nica cantidad de informacin que puede manejar la pila en cada entrada y salida de
datos.

RESULTADOS ESPERADOS.

Tras haber realizado la pequea aplicacin enfocada en las funciones de la

pila en un lenguaje ensamblador se espera:

Tener un manejo de los conceptos de pilas.

Conocer y manejar el proceso de una pila en el lenguaje ensamblador.

PLANTEAMIENTO DEL PROBLEMA.

Manejo de pilas: Push y Pop.

La pila es un contenedor de nodos y tiene dos operaciones bsicas: push (apilar) y pop
(desapilar). Push aade un nodo a la parte superior de la pila, dejando por debajo el
resto de los nodos. Pop elimina y devuelve el actual nodo superior de la pila.
Una pila tiene muchas utilidades en programacin, uno de sus usos conocidos es en la
resolucin de problemas algebraicos. Sin embargo, dado el nivel que los presentes
tenemos del lenguaje ensamblador, hemos de plantear nuestro caso demostrar la
utilidad de las pilas a nivel de lenguaje de maquina por medio del lenguaje
ensamblador. Hemos de plantear la estructura con sus funciones ms conocidas que
mencionamos ya: push y pop.

Cada pila tiene un lugar fijo en la memoria en la que comienza, en nuestro caso hemos
de aadir los datos a la pila, el puntero de pila ser desplazado para indicar el estado
actual de la pila, apuntando a la prxima celda, y copia el nuevo elemento de la cima
en rea de la pila. Desapilando es simplemente la inversa de apilar. El primer elemento
es eliminado y el puntero de la pila se actualiza, en el orden opuesto de la utilizada en
la operacin de apilar. Tomando en cuenta lo que ya sabemos de la estructura, hemos
de aplicar la pila en lenguaje ensamblador, enfocndonos en estas dos operaciones
que son tan bsicas en una pila, apilar y desapilar, as el programa comenzara en
incluyendo unos datos en la pila y luego retirando los datos de la pila.
El segundo problema sera derivar las funciones que ya conocemos de la pila, y su
ejecucin aplicndolo a una operacin como es la de sumar.

10

ANALISIS DEL PROBLEMA.

Cuando es fabricado el microcontrolador, no contiene datos en la memoria ROM. Para

que pueda controlar algn proceso es necesario generar o crear y luego grabar en
la EEPROM o equivalente del microcontrolador algn programa, el cual puede ser
escrito en lenguaje ensamblador u otro lenguaje para microcontroladores; sin
embargo, para que el programa pueda ser grabado en la memoria del
microcontrolador, debe ser codificado en sistema numrico hexadecimal que es
finalmente el sistema que hace trabajar al microcontrolador cuando ste es
alimentado con el voltaje adecuado y asociado a dispositivos analgicos y discretos a
su funcionamiento.
Los datos de entrada al programa ensamblador es un fichero de texto plano que
contiene un programa o secuencia de instrucciones a ejecutar por el procesador tal y
como muestra la figura.

El lenguaje en el que se escribe es que ya conocemos como ensamblador. El

ensamblador no solo permite utilizar los nombres de las instrucciones, operandos y
modos de direccionamiento, sino tambin permite especificar etiquetas y definir
porciones de memoria para almacenar datos. En la siguiente imagen se mostrara un
fragmento del fichero que contiene uno de nuestros programas escrito en
ensamblador: Los archivos deben terminar con la extensin ASM. Las letras
minsculas trabajan igual que las maysculas.

11

Enfoqumonos en los movimientos que hacen las funciones descritas en nuestro

programa:
Una H despus de cada nmero indica al ensamblador que los nmeros son
hexadecimales. El ensamblador puede confundir nmeros con etiquetas, para evitar
esto coloque un 0 (cero) antes de un nmero hexadecimal que inicie con una letra.

mov

ah

02h

02h es un nmero hexadecimal.

Instruccin MOV
Transfiere un byte desde el operando fuente al operando destino.
Es decir, teniendo el siguiente formato:

12

MOV
MOV

Destino
CX

Fuente
03h

El operando fuente aparece en la instruccin, es el que mueve un valor constante a un

registro interno. El direccionamiento al registro implica que el operando a ser usa est
contenido en uno de los registros internos de propsito general del CPU.
La instruccin anterior indica mover inmediatamente al registro CX el valor 03h. El
registro interno puede ser de 1 byte o de una palabra.

13

DISEO.
Pseudocdigo:
________________________________________

Operacin Recorrido:
Apuntador toma el Top, despus ve si la condicin cumple para efectuar un Ciclo
mientras Apuntador sea diferente de Nulo, si cumple lo que hace es que despliega el
contenido de la Pila(Pila[Apuntador]), despus Apuntador se le resta 1. Este proceso se
repite hasta que Apuntador sea igual Nulo(Cuando llega a este punto la Pila ya fue
Recorrida).
Recorrido(Pila, Top)
Apuntador - Top
Repetir mientras Apuntador &ne; Nulo
Imprimir Pila[Apuntador]
Apuntador - Apuntador - 1
Fin del ciclo

Operacin Push:
Compara en un principio el Top con Max, si la condicin no cumple es imposible
insertar mas datos a la Pila, de otra forma lo que hace es Incrementar el valor de Top, y
copia el valor de Elemento en Pila[Top]. De esta forma el dato ya esta insertado.
Push(Pila, Top, Max, Elemento)
Si Top &ne; Max
Top - Top + 1
Pila[Top] - Elemento
Si no:
Imprimir Pila Llena
Salir

14

Operacin Pop:
Compara para determinar si la pila esta vaco, de otra forma lo que hace es Imprimir el
valor de Pila[Top] (Que es el dato que est apunto de Eliminar) y enseguida a Top le
resta 1, de esta forma el dato ya no existe.
Pop(Pila, Top)
Si Top &ne; Nulo
Imprimir Pila[Top]
Top - Top - 1
Si no:
Imprimir Pila Vaca
Salir

Operacin Bsqueda:
Busqueda(Pila, Top, Elemento)
Si Top &ne; Nulo
Apuntador - Top
Repetir mientras Apuntador &ne; Nulo
Si Pila [Apuntador] = Elemento
Imprimir El Dato fue encontrado y Salir
Apuntador - Apuntador - 1
Fin del ciclo
Imprimir El Dato no se encontr
Si no:
Imprimir Pila Vaca
Salir

Operacin Eliminar:
El algoritmo compara para determinar si la Pila tiene algn dato, sino simplemente
desplegara Pila Vaca y saldr. De otra manera har un Recorrido y comparara con cada
uno de los Datos de la Pila hasta encontrar el dato que desea eliminar, mientras hace
15

esto copia cada uno de los datos a un arreglo Temp para cuando encuentre el Dato
regresar esos valores a la Pila. Si lo encuentra desplegara Eliminado el Dato y le
restara 1 a Top, de otra manera El Dato no encontrado.
Borrar (Pila, Temp, Top, Elemento)
Si Top &ne; Nulo
Apuntador1 - Top
Repetir mientras Apuntador1 &ne; Nulo
Si Pila[Apuntador1] = Elemento
Imprimir Eliminando el Dato
Repetir mientras Apuntador2 &ne; Nulo
Pila [Apuntador1]=Temp [Apuntador2]
Fin del ciclo
Top - Top - 1 y Salir
Si No:
Temp [Apuntador2] - Pila [Apuntador1]
Apuntador1 - Apuntador1 - 1
Apuntador2 - Apuntador2 + 1
Fin del ciclo
Imprimir Dato no encontrado
Si no:
Imprimir Pila Vaca
Salir

16

PRUEBAS.
Para crear el cdigo del programa en ensamblador, ingresamos a un editor de texto,
en este caso al Bloc de notas.
Despus de escribir el cdigo del programa guardamos este archivo en el disco local,
en la carpeta donde est MASM y le pondremos la extensin asm, en nuestro caso
p.asm
Iniciamos la ejecucin de nuestro programa ingresando al smbolo del sistema.
Al ingresar al smbolo del sistema buscamos el directorio en el disco local donde est
guardado el MASM, utilizando el comando cd.
Cuando estamos en el directorio utilizamos el comando ml que es el que nos permite
acceder al compilador y luego ponemos el nombre de nuestro archivo creado en el
block de notas, en este caso p.asm
Este nos genera la informacin del programa, y los errores si los tiene, adems nos
muestra dos archivos que crea, el archivo.obj y el archivo.exe.
Luego escribimos el nombre de nuestro archivo creado con extensin .exe, en nuestro
caso p.exe, y este nos muestra la ejecucin del programa.

17

18

MANUAL DE USUARIO.

Compilacin en ensamblador.
Especificaciones del sistema:
Este manual est diseado
especificaciones:

para usar en una maquina con las siguientes

Sistema operativo Windows 7 de 32 bits.

El compilador debe ser MASM6.11(previamente instalado)

Debe contar con blog de notas.

20

Pasos:
Abrimos un blog de notas:

En blog de notas nos servir para poder redactar nuestro cdigo en leguaje ensamblador
deber de verse de esta manera.

Una vez redactado el cdigo que deseamos compilar en lenguaje ensamblador pasamos a
guardar nuestro cdigo seleccionando la pestaa archivo seguido la opcin guardar como
21

y lo nombramos de la siguiente forma NOMBRE.asm, importante no olvidar el .asm la que

este es tipo de archivos que reconoce el compilador MASM6.11.

Luego cortamos o copiamos nuestro archivo resultante que deber verse de la siguiente
forma.

Lo pegamos en la siguiente ruta:

Primero abrimos equipo y damos doble clic sobre disco local C:

22

Luego buscamos la carpeta con el nombre MASM6.11 y damos doble clic sobre esta

Dentro de esta carpeta nuevamente buscamos otra carpeta pero esta ves con el nombre BIN y
damos doble clic sobre esta.

23

Una vez dentro de esta carpeta pegamos nuestro archivo .asm

Una vez terminado esto cerramos la venta y presionamos el botn de inicio en el campo de
bsqueda digitamos cmd y seleccionamos el resultado que nos da la bsqueda con el
mismo nombre cmd.

24

Al dar doble clic debera emerger una venta de la siguiente forma y digitamos el comando
cd.. y damos ENTER.

El comando cd.. nos permite retroceder en la ruta que nos da por defecto el cmd, luego
repetimos el comando una vez mas y deber quedar esta forma C:\> una ves aqu digitamos
cd pero sin .. y luego damos espacio y escribimos MASM6.11 debe quedar de la siguiente
forma.

25

Damos ENTER y luego digitamos nuevamente cd y esta vez damos espacio y escribimos BIN
y damos ENTER como notaran estamos creando la ruta de donde esta guardado nuestro
documento con nuestro cdigo .asm

Luego usaremos otro comando llamado ml, entonces digitamos ml damos espacio y
digitamos el nombre de nuestro cdigo que sera asa ml NOMBRE.asm que como ven la
imagen es ml PILA.asm.
26

Damos ENTER y es aqu donde MASM6.11 compila nuestro cdigo y debera mostrar el
siguiente mensaje.

Como podemos ver nuestro cdigo ha sido compilado y este nos muestra que a creada un File
para la corrida del programa que es terminacin .exe.

27

Ser este .exe ser este el File que nos permitir finalmente correr nuestro programa de la
siguiente manera simplemente digitamos el nombre de nuestro programa con la terminacin
.exe como lo vimos en la imagen anterior.

Ahora simplemente damos ENTER y nuestro programa se debera ejecutar sin problemas de
dar error debe ser debido a errores en el cdigo del programa, como podemos ver la corrida
de nuestro programa en este caso una pila.

28

29

CONCLUSIONES.

Hemos comprendido mejor el funcionamiento de las estructuras de una pila,

as como tambin como se manejan en lenguaje ensamblador.

La Implementacin de una pila en un lenguaje ensamblador es un bajo nivel

que muchos programadores usan para programar en muchas ocasiones, ms
que todo en los microprocesadores que operan bajo este lenguaje.

Dada la versatilidad del compilador de MASM32 se logra una mejor

compilacin del uso de pilas en lenguaje ensamblador y as poder ejecutarlo en
la
consola
de
la
mquina.

30

BIBLIOGRAFIA.
Los sitios que hemos utilizado para realizar este trabajo son los siguientes:

http://es.wikipedia.org/wiki/M%C3%A1quina_de_pila

http://www.it.uc3m.es/ttao/Hw02/index.html

http://www.dea.icai.upco.es/sadot/EyTC/Manual80x86.pdf
http://der-nick.com/lenguaje-ensamblador-manejo-de-pilas.html

Y tambin los libros:

Lenguaje ensamblador del microprocesador, de LUIS URIETA PREZ Y PABLO
FUENTES RAMOS.

31