Istruzioni ARM di elaborazione dati

Forma generale: OP{cond}{S} Rd, Rn, Operando2. Lavorano solo su registri e costanti (vedi L'architettura ARMARM a 32 bit come caso di studio: registri r0-r15 con SP, LR e PC, registro di stato CPSR con flag NZCV, modi del processore, architettura load/store, istruzioni condizionate, secondo operando flessibile, Thumb; differenze principali con ARMv8 a 64 bit.L'architettura ARM →).

Aritmetiche e logiche

Definizione (istruzioni aritmetiche e logiche ARM)

Istruzione	Effetto
ADD Rd, Rn, Op2	$Rd = Rn + Op2$
ADC Rd, Rn, Op2	$Rd = Rn + Op2 + C$ (somma con riporto)
SUB Rd, Rn, Op2	$Rd = Rn - Op2$
SBC Rd, Rn, Op2	$Rd = Rn - Op2 - \overline{C}$
RSB Rd, Rn, Op2	$Rd = Op2 - Rn$ (sottrazione inversa)
AND Rd, Rn, Op2	AND bit a bit
ORR Rd, Rn, Op2	OR bit a bit
EOR Rd, Rn, Op2	XOR bit a bit
BIC Rd, Rn, Op2	$Rd = Rn \text{ AND NOT } Op2$ (azzera i bit indicati)
MOV Rd, Op2	$Rd = Op2$
MVN Rd, Op2	$Rd = \text{NOT } Op2$
MUL Rd, Rm, Rs	$Rd = Rm \cdot Rs$ (32 bit bassi del prodotto)
MLA Rd, Rm, Rs, Rn	$Rd = Rm \cdot Rs + Rn$

Esempio. Con r1=10 e r2=3: SUB r0, r1, r2 dà $7$, RSB r0, r1, r2 dà $-7$ (0xFFFFFFF9) e BIC r0, r1, #2 dà $8$.

UMULL/SMULL RdLo, RdHi, Rm, Rs danno il prodotto completo a 64 bit senza segno / con segno. La moltiplicazione non accetta costanti: gli operandi sono registri.

Secondo operando

Definizione (secondo operando delle istruzioni ARM)

• Immediato #n: 8 bit ruotati di un numero pari di posizioni (vedi Formato delle istruzioni e modalità di indirizzamentoModalità di indirizzamento (immediato, diretto, indiretto, a registro, indiretto a registro, con spiazzamento, relativo al PC, indicizzato e scalato, a pila) con indirizzo effettivo ed esempi; formati fissi e variabili; i formati R, I e J di MIPS e il formato a 32 bit di ARM con il calcolo dei campi.Formato delle istruzioni e modalità di indirizzamento →). Per costanti qualsiasi si usa la pseudo-istruzione LDR r0, =0x12345678, che l'assemblatore traduce in un caricamento da una tabella di costanti, oppure la coppia MOVW/MOVT (16 bit bassi e alti).
• Registro scalato: Rm, LSL #n (shift logico a sinistra), LSR #n (logico a destra), ASR #n (aritmetico a destra), ROR #n (rotazione); lo scorrimento può essere anche di un numero di posizioni contenuto in un registro (Rm, LSL Rs). Lo scorrimento è gratuito: avviene nello stesso ciclo, nel barrel shifter prima dell'ALU.

Esempio. Con r1=6, ADD r0, r1, r1, LSL #2 calcola $6+4\cdot6=30$ in una sola istruzione.

Moltiplicazioni per costanti senza MUL:

ADD r0, r1, r1, LSL #2      @ r0 = r1 + 4*r1 = 5*r1
RSB r0, r1, r1, LSL #3      @ r0 = 8*r1 - r1 = 7*r1
MOV r0, r1, ASR #1          @ r0 = r1 / 2 arrotondato verso -infinito (con segno)

Flag

Definizione (aggiornamento dei flag: S, CMP e TST)

• Con il suffisso S l'istruzione aggiorna N, Z, C, V: SUBS r0, r0, #1 decrementa e imposta Z quando arriva a 0.
• CMP Rn, Op2 calcola $Rn - Op2$ e aggiorna i flag senza salvare il risultato; CMN fa lo stesso con $Rn + Op2$.
• TST Rn, Op2 fa l'AND e aggiorna N e Z (verifica di bit); TEQ fa lo XOR (uguaglianza).

Esempio. Con r0=0x7FFFFFFF, ADDS r1, r0, #1 dà r1=0x80000000 con $N=1$, $Z=0$, $C=0$, $V=1$.

Esempio: r0 = 0x7FFFFFFF, ADDS r1, r0, #1 → $r1 = \text{0x80000000}$, N = 1, Z = 0, C = 0 (nessun riporto senza segno), V = 1 (due positivi danno un negativo).

Traduzione di espressioni

Variabili a–e in r0–r4.

a = (b + c) - (d - e);

ADD r5, r1, r2          @ r5 = b + c
SUB r6, r3, r4          @ r6 = d - e
SUB r0, r5, r6          @ a = r5 - r6

a = b * 10 + (c & 0xFF);

MOV r5, #10
MUL r5, r1, r5          @ r5 = b * 10
AND r6, r2, #0xFF       @ r6 = c & 0xFF
ADD r0, r5, r6

Proprietà (operazioni sui bit con ORR, BIC e EOR). Operazioni sui bit: impostare il bit 3 di r0 → ORR r0, r0, #8; azzerarlo → BIC r0, r0, #8; invertirlo → EOR r0, r0, #8; estrarre il byte 1 → AND r1, r0, #0xFF00 poi MOV r1, r1, LSR #8.

Esempio. Con r0=5 (0101) ORR r0, r0, #8 dà $13$; con r0=13 (1101) BIC r0, r0, #8 dà $5$ ed EOR r0, r0, #8 dà $5$.

Errori tipici

• Scrivere MUL r0, r1, #10: la moltiplicazione vuole registri.
• Dimenticare la S prima di un salto condizionato che deve guardare il risultato.
• Usare LSR per dividere un numero negativo: serve ASR.