Waar de 8086 met een CISC-architectuur een enorme hoeveelheid heel krachtige commando's kent, met verschillende lengtes, een variatie aan aantal ingebakken stappen en allerlei adresseringsmethodes, is de ARM met een RISC-architectuur een stukje simpeler. Maar daarmee niet minder krachtig en ook niet makkelijker om te leren programmeren. Veel van het denkwerk dat Intel deed en in de instructieset verwerkte, zal een ARM-programmeur zelf moeten doen. Maar laten we gewoon eens beginnen. De registers kennen we al, nu de basisinstructieset:

Verplaatsingen van data gaan met

LDR X1, [X2]: laadt de waarde op adres X2 in register X1
LDR X1, [X2, #8]: laadt de waarde op adres X2+8 in register X1
LDR X1, [X2, X3]: laadt de waarde op adres X2+X3 in register X1
LDR X1, [X2, #8]!: X2 := X2 + 8 en laadt dan de waarde op X2 in X1
LDR X1, [X2], #8: X1 := [X2], daarna X2 := X2 + 8
(Nog enkele specialistische adresseringsmethodes)
STR X1, [X2]: sla de waarde van register X1 op adres X2 op
MOV X1, 0xFF: sla de hexadecimale waar FF op in X1
MOV X1, X2: sla de waarde van X2 op in X1

Basis rekenwerk:

ADD X1, X2, X3: X1 = X2 + X3
SUB X1, X2, X3: X1 = X2 - X3
MUL X1, X2, X3: X1 = X2 * X3
UDIV X1, X2, X3: X1 = X2 / X3 (unsigned)
SDIV X1, X2, X3: X1 = X2 / X3 (signed)

Op precies dezelfde wijze zijn logische operaties mogelijk met AND, ORR, EOR en bitgewijze shifts naar links en rechts met LSL, LSR.

Er zijn vergelijkingen te maken met CMP en selectieve selecties (denk aan a?b in C) met CSEL.

Springen doe je met B als je gewoon wil springen, of BL als je een terugkeeradres wil, dus een call in plaats van een jump. Je keert dan terug met een RET.

Dan zijn er nog stack-operaties, maar anders dan bij de 8080 en 8086-familie hebben we hier geen aparte instructies voor nodig. Immers, met STR X1, [SP, #-8]! bereik je precies hetzelfde als wanneer je een aparte PUSH instructie had gehad. Een item van de stack halen werkt vergelijkbaar in omgekeerde richting.

Tenslotte is van belang de systemcall, of in ARM termen de SuperVisorCall: SVC 0.

Waarom 0? Omdat Linux altijd 0 gebruikt. Technisch kan dit ook een ander nummer zijn, maar niet in Linux.

Hiermee hebben we in essentie alle belangrijke ARM commando's gezien. Er is meer, maar dat is meteen nogal gespecialiseerd. Ook de verschillende adresseringsmethodes hebben we nu gezien. We zouden dus aan de slag moeten kunnen, ware het niet dat nog één kwestie van belang is.

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.