Programación en Lenguaje Ensamblador

-El Verdadero Lenguaje de las Máquinas-

Ojos Que Ven Pueden Ser Engañados

–El Doble Filo de las Macros en el Ensamblador–

Este es un viejo proverbio chino que de hecho, ha sido representado en infinidad de películas que incluyen héroes ciegos. Algo similar pasa con la programación en ensamblador pues, luego de la horrorosa notación húngara, la segunda cosa que mas detiene a los principiantes a la hora de programar en Ensamblador son sin duda las macros.
¿Pero que demonios es una macro? Este es un concepto nada fácil de explicar sin hablar primero de como el compilador convierte el código fuente en lenguaje máquina. Y esto no es refrito de somníferos libros de computación pues yo mismo intenté hacer un compilador alguna vez. Algun día les platicaré porque no lo terminé. He aqui como trabajan los compiladores:
paso1.- Leen el código fuente. Este es el que es entendible (sin dificultad) por humanos.
Paso2.- Convierten ese código en bytes que la máquina entiende.
Fin
Esto en práctica se ve así

source code: push dword 0
opcode: 6Ah, 00h

Las macroinstrucciones no se convierten directamente en opcodes porque no son instrucciones de Ensamblador. En realidad una macroinstrucción es remplazada por mas código fuente. Se inventaron para que los programadores mas viejos con dedos artríticos y vista cansada pudieran seguir programando y sin lugar a dudas llegarán a usarlas si programan por el suficiente tiempo. Pero por ahora lo mejor es que las eviten tanto como sea posible. Ahora veamos el mismo ejemplo anterior con macros.

Macro: push NULL
source: push dword 0
opcode 6ah, 00h
Esta es la macro mas sencilla, el uso de constantes. En este caso, se supone que el programador es lo bastante bestia como para no poder distinguir ni el 0 por lo redondo. El uso de macroinstrucciones presupone un paso de precompilación que convierte todas las macros en código fuente de verdad. A este proceso se le conoce como “Desenrrollar una macro”.
Sin embargo, hay macros mas nefastas que cometen la blasfemia de hacer que el Ensamblador parezca código de lenguajes inferiores como C – -. Un ejemplo clásico es el uso del IF.

Macro: if variable = NULL proceso

source cmp [variable], 0
jne no_procesar
call proceso
no_procesar:

Pero de todas las macros, las mas infames y que parecen haber sido creadas con el propósito específico de fastidiar a los principiantes en Ensamblador son aquellas que se confunden con instrucciones. Hay solo dos maneras de que estas macros no lo fastidien a uno, la primera y mas sencilla es desensamblar el código y la mas dificil es conocer de antemano los opcodes. Veamos algunos de los ejemplos mas peligrosos:

macro: push eax ecx edx ebx
source: push ebx
push edx
push ecx
push eax
*esta macro es peligrosa porque la instrucción PUSH solo puede introducir a la pila un valor cada vez

macro mov [x],[y]

source push [y]
push [x]
pop [y]
pop [x]
*otra trampa deliverada, pues la instrucción MOV no puede mover valores entre 2 posiciones de memoria de una sola vez, y para colmo la macro convierte a código que no tiene nada que ver con la instrucción MOV.

Sin embargo, las macros existen con un propósito y bien usadas no solo aceleran el tiempo de desarrollo, sino que permiten que el código sea mucho mas legible y el mantenimiento mas óptimo. Otros ejemplos clásicos de macros que tienen sus pros y sus contras son los siguientes:

macro: invoke MessageBox addr [message], addr
source:
lea eax,
push eax
lea eax, [message]
push eax
call [MessageBox]
*Esta es una macro que llama una función de la API de Windows en un solo renglón. Además tiene anidada la macro ‘addr’ que obtiene en tiempo real la dirección de una posición relativa. (mas adelante explicaré este concepto en detalle.) Ahora veamos los pros y contras:
-pros: Mejor control de funciones con pocos parámetros
-contras: Funciones con muchos parámetros requieren literalmente anchos de pantalla enteros.

Además de que el uso de esta macro impedirá al principiante comprender como funciona el paso de parámetros por stack y como direccionar un Stack Frame.

Existen otro tipo de macros como las que definen variables locales, que simulan estructuras de control como el Do While y el FOR. (los lamers de java y c – – saben bien de que hablo). Solo recuerden que si bien una macro ayuda, en realidad no se puede convertir directamente en código, y es esta una de las razones por la que no es posible compilar código entre diferentes ensambladores aún a pesar de que ambos trabajen con el mismo conjunto de instrucciones. Un ejemplo célebre de esta incompatibilidad se da entre el MASM (Microsoft Macro Assembler) y FASM (Flat Assembler que es el que se usa en este blog). Si uno encuentra un código escrito en MASM es muy poco probable que puedan compilarlo en FASM, es necesario traducirlo. Y las macros hacen que esta labor sea un verdadero reto.
En resumen, cuando comiencen a programar en ensamblador no se confien de lo que les digan sus ojos, pues rara vez lo que vean será real. Lo único real es el código máquina que puede ser leído con el todopoderoso editor Hexadecimal y algunos desensambladores. Lo demás en realidad es solo un espejismo. Recuerden que ojos que ven pueden ser engañados.

Anuncios

enero 13, 2009 - Posted by | Uncategorized | , , ,

1 comentario »

  1. Uaauuuuh! Pasaba por ahí, buscando qué estudiar.. ningún lenguaje de alto nivel me terminó de enganchar, porque no se entiende un pomo qué pasa por debajo. Esto está buenísimo!!

    Comentario por Juan Pablo | agosto 16, 2015 | Responder


Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

A %d blogueros les gusta esto: