PDF de programación - Ensamblador en Windows - Práctica de programación

UNIVERSIDAD DE LA LAGUNA

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA INFORM ÁTICA

Estructura de Computadores

Práctica de programación, curso 2010/11

Profesor: Juan Julian Merino Rubio

Ensamblador en Windows

En esta asignatura Estructura de Computadores del primer cuatrimestre nos iniciamos
en la programación en ensamblador. El objetivo principal es aprender el lenguaje, y el entorno
de la programación no debe distraernos de este objetivo por lo que vamos a tratar de mantenerlo
lo más simple posible, aunque se trate del entorno Windows.

Vamos a aprender a manejarnos con programas de 32 bits, con el procesador en modo prote-
gido, sin las limitaciones de los segmentos del modo MS-DOS. Vamos a comprobar que teniendo
una cierta destreza con el ensamblador los programas en entorno Windows no se diferencian
tanto de los de MS-DOS, al menos al nivel de dificultad que se va a exigir.

Naturalmente no se pretende desarrollar un enorme programa, complejo, con muchas ven-
tanas, con muchas opciones de interacción con él, no. Para eso están los lenguajes de alto nivel.
Nos vamos a limitar a desarrollar unos programas sencillos que van a permitirnos entender las
dificultades y limitaciones que los lenguajes de alto nivel tienen “por detrás”, bajo la superficie.
Las mejores referencias que he encontrado para programar en el entorno de Windows son
los libros de Kauler [1] y de Petzold [2] de la bibliografía, además de la siguiente página:
http://en.wikibooks.org/wiki/Windows_Programming/
y el sitio y foro del paquete MASM32 que vamos a emplear. Unas lecciones muy completas tiene
el famoso curso de Iczelion, que junto a grandes cantidades de información lo tienen en

y lo mejor de todo es que ese curso está traducido al español en

http://win32assembly.online.fr/

http://mipagina.cantv.net/numetorl869/tut_es.htm

El paquete MASM32

En el ftp de la asignatura (ftp://ftp.etsii.ull.es/asignas/EC/) en la carpeta MASM32/
he puesto el paquete comprimido m32v10r.zip que contiene, autoinstalable, la versión 10
—última por ahora— del paquete MASM32. También pueden bajárselo directamente de

que es recomendable visitar de todas maneras, sobre todo su foro:

http://www.masm32.com/,

1

Estructura de Computadores, curso 2010/11

2

http://www.masm32.com/board/index.php.

El MASM32 SDK (Software Development Kit), una vez instalado, contiene todo lo nece-
sario para desarrollar los programas en ensamblador, incluyendo un editor, el Quick Editor
(qeditor.exe) que tiene todo lo necesario para desarrollar los programas, aunque cada uno
puede usar el que mejor conozca, que esto es cuestión de gustos. Hay bastantes ejemplos resuel-
tos (carpeta examples) y algunas lecciones (carpeta tutorial).

Los primeros pasos

Básicamente hay dos tipos de programas de Windows, el de tipo consola y el estándar de

interfaz gráfico.

Un programa de tipo consola es muy parecido a los programas en entorno MSDOS en pantalla

de texto y nuestros primeros programas serán de este tipo, como veremos a continuación.

Para ensamblar el código fuente, por ejemplo el primero EC10p1.asm, escriben en la línea de

comamdo:

donde

\masm32\bin\ml /c /coff EC10p1.asm

/c

le dice al MASM que ensamble sólo, sin enlazar.

/coff le dice al MASM que cree el archivo .obj en formato COFF [Common Object File Format].

Una vez que ensamble con éxito obtendremos el archivo objeto, EC10p1.obj, que hay que

enlazar escribiendo:

\masm32\bin\link /SUBSYSTEM:CONSOLE /OPT:NOREF EC10p1.obj

y cuando la aplicación no sea de tipo consola sino GUI estándar cambiaremos la opción a

/SUBSYSTEM:WINDOWS.

Si están usando el Quick Editor pueden obtener el ejecutable desde el menú desplegable

Project, donde se distinguen un tipo u otro de aplicaciones con dos opciones distintas:

Build All

y

Console Build All.

El primer programa

Como primer ejemplo de programa vamos a escribir en la pantalla y a leer desde el teclado,
es decir interaccionar con el sistema. El Windows proporciona funciones para manejar todos
los dispositivos del sistema y estas se llaman pasándoles los parámetros por la pila. Cuando
las funciones son relativas a algún dispositivo, ya sea físico o virtual, o en general manejen al-
guno de los muchos objetos que el Windows utiliza (en el sentido de la programación orientada
a objetos, OOP, en la que se basa Windows), se impone la utilización de los “manipuladores”
[handles en inglés]. Por ejemplo, para emplear a la consola como dispositivo de salida se em-
plea al manipulador consoleOutputHandle, y para emplearla como dispositivo de entrada el
consoleInputHandle. Ambos manipuladores se le solicitan primero al Windows mediante la

Estructura de Computadores, curso 2010/11

3

función GetStdHandle y luego hay que pasárselos como parámetros a las funciones que emplean
dichos dispositivos, como WriteConsole, por ejemplo.

Precisamente es WriteConsole la principal rutina para escribir en la consola, y tiene el

siguiente prototipo:

WriteConsole PROTO,

hConsoleOutput:HANDLE,
lpBuffer:PTR BYTE,
nNumberOfCharsToWrite:DWORD,
lpNumberOfCharsWritten:PTR DWORD, ; puntero a no de bytes escritos
lpReserved:DWORD

; escribe en la consola una cadena
; manipulador de la salida
; puntero a la cadena
; tamaño de la cadena

; (no se usa)

y se usa de la siguiente forma: llamando primero a la función GetStdHandle para obtener un
manipulador, y pasándole la cadena de caracteres a escribir y la longitud de la misma, además
de un puntero a una variable donde se guardará el número efectivo de caracteres escritos, algo
así

BYTE
DWORD

.data
msg1
smsg1
consoleOutputHandle
bytesWritten
.code

DWORD

"Estructura de Computadores - Curso 2010/11",13,10
$ - msg1

HANDLE 0
?

; handle de salida de la consola
; número de bytes escritos

; Se obtiene primero el manipulador de salida por la consola:
INVOKE GetStdHandle, STD_OUTPUT_HANDLE
mov
INVOKE WriteConsole, consoleOutputHandle, ADDR msg1, smsg1,

consoleOutputHandle,eax

ADDR bytesWritten, 0

Los caracteres 13 y 10 con los que termina la cadena de caracteres msg1 hacen el salto de
línea en la consola y así el texto, si está formado por varias líneas, queda más legible. También
podemos escribir una macro que haga el salto de línea:

.data
cr
lf
crlf

EQU
EQU
BYTE

0Dh
0Ah
cr,lf

; vuelta de carro
; salto de línea
; carriage return/line feed

newline MACRO

INVOKE WriteConsole,

consoleOutputHandle, ADDR crlf, 2,
ADDR bytesWritten, 0

ENDM

Más adelante veremos otras funciones que permiten darle formatos a las salidas por la consola.
Para leer el teclado, o lo que es lo mismo, para introducir datos al programa mediante el
teclado, vamos a distinguir dos casos: la lectura de teclas aisladas y la introducción de cadenas
de caracteres que se aceptan al pulsar Enter.

Estructura de Computadores, curso 2010/11

4

La lectura de teclas aisladas, útiles para que la interacción con el programa sea más amigable,
parando el programa hasta que se pulse una tecla, por ejemplo, o respondiendo a menús sencillos
con la tecla adecuada (pulsar “S” para seguir, “ESC” para salir del programa), no es
sencillo de hacer en Windows, pero en el paquete MASM32 nos proporcionan la rutina ret_key
que lo hace muy bien. La rutina está encerrada en la macro getkey y devuelve en EAX el código
de la tecla.

Para introducir cadenas de caracteres desde el teclado tenemos a la rutina ReadConsole, con

un prototipo parecido al de WriteConsole:

ReadConsole PROTO,

hConsoleInput:HANDLE,
lpBuffer:PTR BYTE,
nNumberOfCharsToRead:DWORD,
lpNumberOfCharsRead:PTR DWORD, ; puntero al no real de bytes leídos
lpReserved:DWORD

; manipulador de entrada
; puntero a la cadena destino
; no máximo de caracteres a leer

; (no se usa)

y se usa de la siguiente manera: igual que antes, hay que conseguir un manipulador, que lo
proporciona el Sistema Operativo a través de la función GetStdHandle –estos manipuladores
se pueden usar a lo largo de todo el programa, no hay que pedir uno cada vez–, luego hay que
preveer un sitio (un buffer o cadena destino) donde se van a depositar los caracteres que se
introduzcan y a ReadConsole se le pasa su dirección y su tamaño; por último también hay que
pasarle la dirección de una variable donde quedará el número efectivo de caracteres introducido;
en el buffer se debe dejar sitio para los dos caracteres que forman el “final-de-línea”, y si se quiere
que el buffer contenga una cadena terminada en cero se reemplaza el byte que contiene 13 (cr)
con un byte nulo.

.data
anchobuffer
msg4
smsg4
msg5
bytesRead
.code

EQU
BYTE
DWORD
BYTE
DWORD

; buffer para escribir cadenas

80
"Escribe una frase: "
$ - msg4
anchobuffer DUP(?)
?

; número de bytes leídos

INVOKE GetStdHandle, STD_OUTPUT_HANDLE
mov
INVOKE WriteConsole,

consoleOutputHandle,eax

consoleOutputHandle, ADDR msg4, smsg4,
ADDR bytesWritten, 0

INVOKE ReadConsole,

consoleInputHandle, ADDR msg5, anchobuffer-2,
ADDR bytesRead, 0

En la pantalla (ventana consola) aparece escrito:

Escribe una frase: _

y el cursor se queda esperando a continuación; podemos teclear hasta 78 caracteres; la longitud
de la cadena introducida se devuelve en la variable bytesRead.

Estructura de Computadores, curso 2010/11

5

Las librerías de funciones

Las funciones GetStdHandle, WriteConsole y ReadConsole pertenecen a la librería de en-
laces dinámicos kernel32.dll del Windows, y están a disposición de todas las aplicaciones. Para
llegar hasta ellas disponemos de la librería estática kernel32.lib que contiene los enlaces ade-
cuados. Al montar el programa le debemos decir al linker que use la librería kernel32.lib para
resolver las referencias a las funciones. Además el ensamblador necesita los prototipos de las
funciones por lo que el paquete MASM32 proporciona el archivo include kernel32.inc.

Windows proporciona un abanico de recursos para los programas win32 (programas de 32
bits en modo protegido). En el centro de todos los recursos está la API de Win