Posts tagged ‘ia-32’

julio 29, 2010

Saludando al mundo con Ensamblador

por Josue Ortega

La semana pasada me dejaron una tarea introductoria al lenguaje ensamblador que consistía en explicar como se hace el famoso programa de “hola mundo”. Asi que decidí subir el “how to” por que me gusto como quedo :P.
El “how” to esta escrito para ser compilado con GAS en la arquitectura IA-32 bueno aquí les va:

Para poder programar en lenguaje ensamblador en nuestro sistema operativo
gnu/linux necesitamos tener instalados GNU Binutils, en el cual estan contenidos
el compilador de ensamblador:as y el linker: ld.
Ya que tenemos instalado el binutils, ya podemos trabajar y hacer nuestros
programas en lenguaje ensamblador.
A continuación imprimiremos en pantalla “Hola Mundo” en ensamblador y lo
compilaremos con GAS.
El código es :

.text
.global _start
_start:
movl $len,%edx
movl $msg,%ecx
movl $1,%ebx
movl $4,%eax
int $0x80
movl $0,%ebx
movl $1,%eax
int $0x80
.data
msg:.ascii"hola mundo"
len=15

A continuación una breve explicacion de cada linea del codigo anterior:
Como se puede notar las directivas van antecedidas por un punto “.”.
Directiva text:
Esta directiva indica donde es el inicio de codigo en el arhivo .as
Directiva global:
Con esta directiva se indica que la etiqueta “_start” es visible para todas las
partes del programa.
Directiva data:
En esta sección se declaran las variables inicializadas, como en este caso la
variable msg que se especifica que es de tipo ascii y su contenido es la cadena
“hola mundo”.
También la variable len que se le asigna el numero 15.
_start: indica donde inicia el programa
A continuación detallare la acción de las lineas de código

movl $len,%edx # mueve el contenido de len al registro edx
movl $msg,%ecx #mueve el contenido de msg a el registro ecx
movl $1,%ebx #coloca el valor de 1 al registro ebx
movl $4,%eax #coloca el valor de 4 al registro eax
int $0x80 #hace la llamada al sistema para kernel mode
movl $0,%ebx #coloca el valor de 0 en el registro ebx
movl $1,%eax #coloca el valor de 1 en el registro eax
int $0x80# llamada al sistema para kernel mode

Básicamente lo que el código anterior hace es mandar de parámetros al kernel el
contenido de los registros para que las acciones correspondientes sean
ejecutadas.
En el registro eax se debe posicionar el codigo de la llamada al sistema que
deseamos ejecutar, en este caso para write, es el numero 4.
En el registro ebx se coloca el codigo de la llamada al sistema para la accion
que se debe realizar despues de imprimir en pantalla, en este caso 1 para que
salga.
En el registro ecx se coloca el valor del mensaje y en el edx el tamaño de la
cadena. El write en un HLL se veria: write(salir, mensaje, len)
Para salir del programa se coloca 0 en el registro ebx y 1 en el eax, y de
ultimo se hace la llamada al sistema.
Compilar el Archivo:
Para compilar el archivo se utiliza el comando as con el parametro -o que genera
una salida con extension .o que contiene codigo objeto.

    as -o hola.o hola.as

Linkear el archivo:
Una vez compilado y con nuestro archivo con codigo objeto necesitamos linkear
nuestro archivo para crear un ejecutable con todas las librerias necesarias

ld -s -o hola hola.o

Una vez creado el ejectable, nuestro programa ya esta listo para correr:

./hola

Y finalmente el output

josue@desktop:~/assembler$ ./hola
hola mundo
Seguir

Recibe cada nueva publicación en tu buzón de correo electrónico.

Únete a otros 501 seguidores