Menu
Programación

Programación

Cómo programar ensamblador ARM de forma libre SIN MORIR EN EL INTENTO

Cómo programar ensamblador ARM de forma libre SIN MORIR EN EL INTENTO

¡Buenas noches, tardes o mañanas a todos los que nos leeis!

Soy Pedro Javier (@pedro-javierf) y hoy me estreno en el blog de LibreLabUCM. Finalmente, vamos a ver cómo poder programar para la asignatura de Fundamentos de los Computadores (aka FC 1) en ensamblador de ARM, desde Linux.

Cómo muchos sabréis, en la FDI se nos provee de unas herramientas anticuadas, desfasadas, y solo funcionales en WIndows de 32 bits!. Vamos a ver como poder programar con un ensamblador (y linker) moderno para ARM y desde nuestra distro favorita.

El proceso se resume en 4 sencillos pasos:

  • 1. Instalar las toolchains
  • 2. Instalar Eclipse
  • 3. Crear un proyecto, ¡que compila!
  • 4. Notas y avisos finales

1. Instalar Las Toolchains

Nos dirigimos a la siguiente URL

Y descargamos la última versión disponible. En este caso yo usaré la siguiente, a fecha de 2019.

gnu-mcu-eclipse-arm-none-eabi-gcc-8.2.1-1.3-20190202-1016-centos64.tgz

NOTA: Las toolchains se compilan en centos, de ahí el nombre, pero funcionan en cualquier distro.

Una vez descargado, preferiblemente la versión de 64 bits, ejecutamos los siguientes comandos:

sudo mv archivo.tgz /opt/  --> Movemos el archivo comprimido a la carpeta /opt/ (programas externos que se instalan en linux)

cd /opt/

sudo tar -xvzf archivo.tgz  --> Desempaquetamos el archivo

Debemos tener finalmente una carpeta llamada gnu-mcu-eclipse en opt. La ruta quedaría de la siguiente forma: /opt/gnu-mcu-eclipse.

Vamos a probar si las toolchains funcionan. Podemos ejecutar el siguiente comando en la terminal: 

/opt/gnu-mcu-eclipse/arm-none-eabi-gcc/8.2.1-1.3-20190202-1016/bin/arm-none-eabi-gcc --version

NOTA: Los números de versión del comando cambiarán. Es decir, en vez de 8.2.1-1.3-20190202vosotros tendréis un número diferente. 

Si el resultado del comando anterior es:

arm-none-eabi-gcc (GNU MCU Eclipse ARM Embedded GCC, 64-bit)

Vamos por el buen camino!

Es muy importante que la carpeta que tengamos finalmente en /opt/ se llame gnu-mcu-eclipse y nada más. De esta forma, en el paso posterior, eclipse podrá detectarla automaticamente.

2. Instalar Eclipse

A continuación instalaremos una versión especial de eclipse, con los plugins para ARM, que detectará automaticamente las toolchains que hemos instalado anteriormente.

Nos dirigimos a la siguiente URL

Y descargamos el archivo comprimido tar. En mi caso: 20190101-2023-gnumcueclipse-4.5.1-2018-12-R-linux.gtk.x86_64.tar.gz

De nuevo, lo moveremos a /opt/ , donde habíamos instalado las toolchains.

sudo mv archivo2.tgz /opt/  --> Movemos el archivo comprimido a la carpeta /opt/ 

cd /opt/

sudo tar -xvzf archivo2.tgz  --> Desempaquetamos el archivo

Debemos obtener una carpeta llamada eclipse.

Dentro de esta carpeta, se encuentra el binario eclipse, que podremos ejecutar con ./ eclipse

 

3. Crear un proyecto, ¡que compila!

Para crear proyectos y compilar fácilmente, haremos lo siguiente.

New > Project > C Project    y Hacemos click en Next.

Después nos servirá

Empty Project > ARM Cross GCC  e Introducimos el nombre de nuestro proyecto. Por ejemplo HelloWorld.

Hacemos click en next hasta llegar a la siguiente pestaña.

Como podéis ver, si hemos instalado las toolchains correctamente en el paso anterior, se nos mostrará el PATH de las toolchains automáticamente. Hacemos click en Finish, y listo!

A continuación, crearemos un archivo de código ensamblador. Hay que usar la extensión *.s , no *.asm.

File > New > Source File 

De nombre pondremos: main.s

Finalente, y este paso solo tendremos que hacerlo una sola vez (es una configuración general para todos los proyectos) tendremos que hacer que eclipse reconozca los archivos .s como archivos de código.

Project Properties > C/C++ General > File Types > Use project settings > New >
E introducimos lo siguiente:
Pattern: *.s,
Type: Assembly Source File y hacemos click en OK.

Listo! eclipse compila y está listo. Os dejo un código de prueba para que comprobeis que funciona:

.global main
.global _exit
.equ ONE, 0x01
.dataMYVAR: 
.word 0x02
.bss
RES: 
.space 4
.text
main:
MOV R0, #ONE
LDR R1, =MYVAR
LDR R2, [R1]
ADD R3, R0, R2
LDR R4, =RES
STR R3, [R4]
END:
B ._exit:
exit:
.end



Haremos click sobre el icono del martillo. Si todo transcurre sin problemas, todo ha ido de forma correcta.

4. Notas y avisos finales

Si habréis leido el (simple) código anterior, habréis notado algo: hay un par de declaraciones globales nuevas: 

.global main

.global _exit

En resumen. Los ARM que se utilizan en la FDI son muy muy antiguos (2006 aprox) y no eran muy estrictos a la hora de como debía estar formateado el código. El punto de entrada (donde el código empieza) siempre ha sido start pero en este caso o he renombrado a main, que es lo que espera por defecto las toolchains de GNU. Aunque seguro seguro que hay una forma de que empieze en start, pronto investigaré sobre ello. De momento, lo dejamos así. También he añadido una "label" nueva, llamada :_exit, que al igual que :end, apunta al final del programa. De igual manera es necesaria por las herramientas de GNU, pero no afecta al programa como podréis comprobar.

Esto es todo! pronto aprenderemos a debuggear los programas creados ;)

Un saludo!

pedro-javierf

Leer más
email: librelab@ucm.es
Facultad de Informática de la UCM
Calle del Profesor José García Santesmases 9, Despacho 120
28040, Madrid
×
Probando acceso a TOR... Web disponible en TOR! ;) La web está disponible en TOR, pero el navegador no tiene acceso a TOR