We hebben nu al wekenlang redelijk theoretisch bekeken hoe de CPU werkt waarop vrijwel alle moderne pc's zijn gebaseerd, hoe IBM met een BIOS en MicroSoft met MS-DOS een standaard hebben neergezet die van fundamentele betekenis was voor het succes van de huidige computermarkt. We gingen van BIOS-calls via interruptvector 21h naar syscalls.

Maar nu begint het toch tijd te worden om de handen vuil te gaan maken. Hoe mooi de 80x86 ook is, dat is toch een beetje oud nieuws. Dus we gaan de overstap maken van CISC naar RISC, van Intel naar Acorn. Kortom, we verlaten de 80x86-architectuur en beginnen aan de ARM-architectuur.

We vinden die ARM-architectuur in veel moderne systemen, die hoge prestaties vragen tegen een laag stroomverbruik. Mobiele telefoons en tablets zijn grootverbruikers en Apple heeft er tegenwoordig een hele eigen CPU-lijn voor laptops, tablets, telefoons en zelfs horloges op gebaseerd. Welk systeem je precies wilt gebruiken maakt weinig uit, maar het moet wel ARM zijn. Waar je met hogere talen als C en Rust vrijwel niets te maken hebt met welke CPU of zelfs welk operating system je gebruikt, voor assembly moet je beginnen bij de keuze van de CPU. Ik zal zelf werken met een Raspberry Pi 5, met de laatste versie van Pi OS. Een ander type Pi zou hetzelfde moeten werken en ook met een Apple-laptop verwacht ik geen grote verschillen. Maar: garantie tot de deur. Wat ik doe, hier bespreek en deel via GitHub, zal alleen zijn getest op mijn systeem. Gelukkig kan je tegenwoordig hooguit je lopende proces laten vastlopen, je zal er geen schade mee aan je computer aanrichten. Dus probeer het gewoon en werkt het niet, dan is dat een mooie kans om wat extra te klooien.

Wat je minimaal nodig hebt, en echt even moet controleren op aanwezigheid, zijn een teksteditor, zoals nano, vim of helix of als je wild wilt doen een IDE als Geanny, VSCode. Vervolgens een assembler, waarvoor ik as zal gebruiken, en een linker, zoals ld. Alles wat je nodig hebt zou al op je systeem moeten staan, zeker als je meegedaan hebt met C en Rust.

Nu dan, maak eerst een tekstbestand met de volgende inhoud:

.global _start             @ Entry point

.section .data
message: .asciz "Hello, World!\n"   @ De boodschap met newline

.section .text
_start:
    mov x0, 1              @ File descriptor (1 = STDOUT)
    ldr x1, =message       @ Adres van de boodschap
    mov x2, 14             @ Lengte van de boodschap (in bytes)
    mov x8, 64             @ Syscall nummer (64 = write)
    svc 0                  @ Systeemaanroep

    mov x8, 93             @ Syscall nummer (93 = exit)
    mov x0, 0              @ Exit code (0)
    svc 0                  @ Systeemaanroep

Als je dat bestand opslaat als hello.s dan geef je vervolgens in de terminal de opdracht

as -o hello.o hello.s

Hiermee vertaal je je sourcebestand naar een objectbestand. Hierna

ld -o hello hello.o

om je objectfile te linken tot een uitvoerbaar bestand. Met chmod +x hello vertel je Linux dat het bestand inderdaad uitvoerbaar mag zijn. En als je nu ./hello doet, zou je het resultaat van je eerste ARM-assemblyprogramma moeten zien.

Wie mee wil doen met #klooienmetcomputers kan dat doen via GitHub. Maak een account op github.com en zoek naar Abmvk/kmc. Het account Abmvk volgen kan ook. Lezers zijn vrij te gebruiken wat ze willen en om zelf zaken toe te voegen of aan te passen, vragen te stellen of commentaar te leveren.