Istruzioni ARM di accesso alla memoria

In un'architettura load/store (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 →) i dati si portano nei registri con una load, si elaborano, e si riportano in memoria con una store.

Load e store

Definizione (istruzioni LDR e STR)

Istruzione	Effetto
LDR Rd, [ind]	carica una parola (4 byte)
STR Rd, [ind]	salva una parola
LDRB / STRB	byte; LDRB estende con zeri a 32 bit
LDRSB	byte con segno, esteso con il segno
LDRH / STRH	mezza parola (16 bit), estesa con zeri
LDRSH	mezza parola con segno

Esempio. Se il byte in memoria è 0xF0: LDRB r0, [r1] dà r0=0x000000F0 e LDRSB r0, [r1] dà r0=0xFFFFFFF0.

Esempio: in memoria all'indirizzo r1 c'è il byte 0xF0. LDRB r0, [r1] → r0 = 0x000000F0 (240); LDRSB r0, [r1] → r0 = 0xFFFFFFF0 (−16). Vedi l'estensione del segno in Rappresentazione dei numeri interi con segnoInteri con segno su n bit: modulo e segno, complemento a 1, complemento a 2 ed eccesso K; intervalli rappresentabili, calcolo dell'opposto, estensione del segno.Rappresentazione dei numeri interi con segno →.

In STR r0, [r1] il primo registro è la sorgente (viene letto), non la destinazione.

Modalità di indirizzamento

Esempi con r1 = 0x1000, r2 = 3:

Definizione (modalità di indirizzamento di LDR e STR)

Sintassi	Indirizzo effettivo	r1 dopo
[r1]	0x1000	invariato
[r1, #8]	0x1008	invariato
[r1, #-4]	0x0FFC	invariato
[r1, r2]	0x1003	invariato
[r1, r2, LSL #2]	0x1000 + 12 = 0x100C	invariato
[r1, #4]! (pre-indicizzato con write-back)	0x1004	0x1004
[r1], #4 (post-indicizzato)	0x1000	0x1004

• L'offset immediato per LDR/STR di parola o byte è di 12 bit (±4095).
• Pre-indicizzato !: calcola l'indirizzo, accede, poi aggiorna la base.
• Post-indicizzato: accede all'indirizzo della base, poi la aggiorna. Comodo per scorrere un array: LDR r0, [r1], #4 legge l'elemento e fa avanzare il puntatore.
• LSL #2 sull'indice moltiplica per 4: indice di elemento → offset in byte per un array di parole.

Esempio. Con r1=0x1000: LDR r0, [r1, #4]! legge a 0x1004 e lascia r1=0x1004; LDR r0, [r1], #4 legge a 0x1000 e lascia r1=0x1004.

Indirizzi e costanti

• LDR r0, =etichetta carica l'indirizzo di una variabile (pseudo-istruzione: l'assemblatore mette l'indirizzo in una tabella di costanti vicina al codice e genera un LDR relativo al PC).
• ADR r0, etichetta calcola l'indirizzo come PC + offset (solo per etichette vicine).
• LDR r0, =1000000 carica una costante che non entra in un immediato.

Per leggere il contenuto di una variabile servono due passi:

        LDR r1, =conta      @ r1 = &conta
        LDR r0, [r1]        @ r0 = conta
        ADD r0, r0, #1
        STR r0, [r1]        @ conta = conta + 1
        .data
conta:  .word 0

Trasferimenti multipli

Definizione (trasferimenti multipli LDM e STM). LDM/STM caricano o salvano una lista di registri in posizioni consecutive. Suffissi: IA (increment after), IB, DA, DB (decrement before).

Esempio. STMDB sp!, {r4-r6, lr} salva $4$ registri e sottrae $4\cdot4=16$ da sp.

STMDB sp!, {r4-r6, lr}      @ = PUSH {r4-r6, lr}: sp -= 16, salva 4 registri
LDMIA sp!, {r4-r6, pc}      @ = POP  {r4-r6, pc}: ripristina e ritorna

I registri della lista vanno in memoria in ordine di numero: il più basso all'indirizzo più basso. Uso principale: salvare e ripristinare registri nelle funzioni (vedi Stack e chiamata di funzioni in ARMChiamata con BL e ritorno con BX LR; convenzione di chiamata AAPCS (argomenti in r0-r3, risultato in r0, registri da preservare r4-r11); stack discendente pieno con PUSH e POP; record di attivazione; funzioni foglia e non foglia; esempio ricorsivo del fattoriale con evoluzione dello stack.Stack e chiamata di funzioni in ARM →) e copiare blocchi di memoria.

Errori tipici

• Usare LDR r0, x pensando di ottenere l'indirizzo di x: si ottiene il contenuto (indirizzamento relativo al PC). L'indirizzo è LDR r0, =x.
• Scorrere un array di parole con passo 1 invece di 4.
• Leggere un byte con segno con LDRB.