Het is waarschijnlijk veel nuttiger om een ‘high-level’ programeertaal te leren dan architectuurspecifieke assembler, maar het geeft wel een zeer goed idee in wat er in de processor gebeurt.

ARM op de RPI

ARM is een 32-bit architectuur dat als doel flexibiliteit heeft. Het is handig voor mensen die de vrijheid willen in het ontwerpen van hun eigen hardware, maar niet voor systeemontwikkelaars, die met de verschillen van ARM moeten werken.

Ik gebruik een RPI3B. Er zijn een aantal verschillen met ARM op de raspberrypi en de ‘standaard’ ARM assember. Dit word beter uitgelegd op de ARM website!

Assembler schrijven

Assembler is (voor alle architectuuren) een dunne laag boven de binaire code. binaire code is waarnaartoe je een programma compiled.

Als je assembler schrijft (ARM assembler) kan je computer dat niet uitvoeren. Hiervoor moet je daar de binaire code voor hebben. Dit kunnen we doen met een compiler (voor assembler ook wel assembler genoemd, omdat die de assembler ‘assembleerd’). Die binaire code, wat ook wel een executable wordt genoemd kan dan worden uitgevoerd op een computer (de rpi in dit geval).

Hiervoor kunnen we de GNU assembler gebruiken die in de GCC (Gnu Compiler Colection) zit die standaard op een raspberrypi is geinstaleerd.

Als je een text-editor opent (nano, emacs of vim in een terminal, leafpad of geany in een Desktop omgeving) kan je de bronbestanden (sourcefiles) openen. Deze hebben de extentie ‘.s’ Dat is de standaard voor ARM assembler

Het eerste programma

We moeten ergens beginnen, dus laat ons beginnen met een programmatje dat niets meer doet dan een error-code weergeven. Ik gebruik meestal engelstaalige comments. (die beginnen met /* en eindigen met */ in assembler)

/* -- first.s */
/* This is a comment */
.global main /* 'main' is our entry point and must be global */

main:          /* This is main */
    mov r0, #2 /* Put a 2 inside the register r0 */
    bx lr      /* Return from main */

sla dit op als ‘first.s’

om het te ‘assembleeren’ kun je:

as -o first.o first.s

gebruiken. Nu moet je het nog linken om een executable te krijgen:

gcc -o first first.o

nu kan je het uitvoeren

./first ; echo $?

Je zult normaal error code 2 moeten zien (of gewoon 2). Dat is die #2 die in de op de voorlaatste regel staat.

Alleen is code compilen met zo veel stappen niet echt handig dus kan je hiervoor een makefile gebruiken

# Makefile
all: first
 
first: first.o
    gcc -o $@ $+
 
first.o : first.s
    as -o $@ $<
 
clean:
    rm -vf first *.o

Uitleg bij wat er net gebeurd is

de eerste 2 regels zijn comments. deze worden gebruikt om weer te geven wat een stukje code doet, en worden niet uitgevoerd (de compiler negeert deze)

.global main /* 'main' is our entry point and must be global */

dit is iets wat de compiler vertelt dat het iets speciaals is. Het begint met een punt (.) en word gevolgd door de naam van de functie. .global moet wel, omdat de C runtime de main functie anders niet aanroept.

main:

Dit is een label. Elk label is opgemaakt als: ‘label: instructie’ Dit kan gesplitst worden over 2 regels (zoals hier)

mov r0, #2 /* Put a 2 inside the register r0 */

Dit is de instructie de 2 in register 0 zet. Dit overschrijft wat er in register 0 staat op dat moment.

bx lr      /* Return from main */

Dit betekend Branch Exchange. Dit beindigd ons programma

De error code is wat in r0 is opgeslagen. dit moet r0 zijn.

Dit was alles voor deel 1.