ARM-arkitekturen

ARM er en RISC-arkitektur med 16 registre á 32 bits: $R0$–$R12$ (generelle), $R13$ (SP – stackpeker), $R14$ (LR – link register, returadresse), $R15$ (PC – programteller). ARM er en load/store-arkitektur: ALU-operasjoner opererer utelukkende på registre, aldri direkte på minne. Minneaksess skjer kun via LDR/STR-instruksjoner.

Instruksjonstyper

De viktigste instruksjonstypene i ARM:

Data processing: ADD R0, R1, R2 ($R0 = R1 + R2$), SUB, AND, ORR, EOR, MOV, MVN, CMP (setter bare flagg)
Umiddelbar verdi: ADD R0, R1, #5 ($R0 = R1 + 5$).
Load/Store: LDR R0, [R1] (last 32-bits ord fra adressen i R1), STR R0, [R1] (lagre). Variasjoner: LDR R0, [R1, #4] (offset), LDR R0, [R1, #4]! (pre-increment), LDR R0, [R1], #4 (post-increment).
Forgreining: B label (ubetinget hopp), BEQ label (hopp hvis Z-flagg = 1), BNE, BGT, BLT, BGE, BLE.
Branch and Link: BL subroutine – hopper og lagrer returadresse i LR ($R14$).

Betingelseskoder og CPSR

CPSR (Current Program Status Register) inneholder flaggene N (negative), Z (zero), C (carry), V (overflow). Instruksjoner som setter flagg krever S-suffiks: ADDS, SUBS. CMP R0, R1 beregner $R0 - R1$ og setter flagg uten å lagre resultat.

Stack og subrutinekall

ARM-stacken er et nedadgående LIFO-minneområde ($R13$ = SP). Typisk prolog/epilog for en subrutine: PUSH {R4-R7, LR} (lagre callee-saved registre og LR), gjør arbeid, POP {R4-R7, PC} (gjenopprett registre og hopp tilbake ved å laste LR inn i PC).

Eksempel: Sum av array

Beregn summen av et array lagret på adresse 0x1000 med 5 elementer (32-bits heltall):

  MOV R0, #0         ; sum = 0
  LDR R1, =0x1000    ; adresse til array[0]
  MOV R2, #5         ; teller = 5
loop:
  LDR R3, [R1], #4   ; last array[i], inkrementer peker
  ADD R0, R0, R3     ; sum += array[i]
  SUBS R2, R2, #1    ; teller--, sett flagg
  BNE loop           ; hopp hvis teller != 0
  ; R0 inneholder nå sum

Eksempel: Branch Target Address (imm24)

En fast flervalgsoppgave: finn $imm24$-feltet til en hoppinstruksjon. ARM bruker $PC$-relativt hopp der $PC$ peker to instruksjoner foran ($PC+8$) når hoppet utføres: $\text{mål} = (PC+8) + (imm24 \ll 2)$. Siden adresser er byte-adressert og instruksjoner er 4 byte, gir $\ll 2$ at $imm24$ teller i instruksjoner.

Praktisk regel: $imm24 = (\text{måladresse} - \text{adressen til hoppet} - 8)/4$, dvs. antall instruksjoner fra hoppet til målet minus 2.

Hopp på $\text{0x8004}$ til LABEL på $\text{0x8018}$: $imm24 = (\text{0x8018} - \text{0x8004} - 8)/4 = (20 - 8)/4 = 3$. Et bakoverhopp gir negativt $imm24$ (f.eks. fra $\text{0x8014}$ til $\text{0x8004}$: $(-16-8)/4 = -6$).

Eksempel: Dekode maskinkode og oversette C ↔ assembly

To gjengangere: (1) dekode en binær instruksjon til mnemonic + registre via instruksjonsformatet (cond-felt, opcode, $R_d$, $R_n$, Src2, I-bit for immediate, S-bit for flagg), og (2) fylle inn manglende assembly-instruksjoner som tilsvarer en C-løkke.

C-modulo $a\%b$ for positive heltall ($a$ i R0, $b$ i R1):

MODULO: CMP R0, R1      ; sammenlign a og b
        BLT END        ; hvis a < b, ferdig
        SUB R0, R0, R1 ; a = a - b
        B   MODULO      ; gjenta
END:    MOV PC, LR     ; returner (a i R0)

Merk: betinget hopp etter CMP bruker fortegnsmnemonics (BLT: $N \neq V$). Returnering skjer ved å laste LR inn i PC.

Studieguide: ARM assembly-programmering