Strutture di controllo in assembly ARM

Salti e condizioni

• B etichetta: salto incondizionato (relativo al PC, ±32 MB).
• B{cond} etichetta: salta solo se la condizione sui flag è vera. I flag si impostano con CMP o con un'istruzione con suffisso S (vedi Istruzioni ARM di elaborazione datiIstruzioni aritmetiche (ADD, SUB, RSB, ADC), logiche (AND, ORR, EOR, BIC, MVN), di spostamento (MOV), moltiplicazione (MUL, MLA); secondo operando immediato o registro scalato con LSL, LSR, ASR, ROR; aggiornamento dei flag con S, CMP e TST; esempi di traduzione di espressioni C.Istruzioni ARM di elaborazione dati →).

Perché servono due famiglie: con r0 = 0xFFFFFFFF e r1 = 1, CMP r0, r1 → con segno $-1 < 1$ (LT vera), senza segno $4\,294\,967\,295 > 1$ (HI vera). Vedi Aritmetica binariaSomma e sottrazione in binario, overflow per senza segno (riporto) e per complemento a 2 (segni), flag del processore, moltiplicazione per somme e scorrimenti, algoritmo di Booth, divisione, shift logici e aritmetici.Aritmetica binaria →.

if e if-else

if (a == b) c = c + 1; else c = c - 1;      // a, b, c in r0, r1, r2

        CMP  r0, r1
        BNE  altrimenti         @ condizione negata: salta al ramo else
        ADD  r2, r2, #1
        B    fine
altrimenti:
        SUB  r2, r2, #1
fine:

Stessa cosa senza salti, con l'esecuzione condizionata:

        CMP   r0, r1
        ADDEQ r2, r2, #1
        SUBNE r2, r2, #1

Conviene per rami di poche istruzioni: niente salti, quindi niente svuotamento della PipelineIdea della catena di montaggio; pipeline a 5 stadi IF, ID, EX, MEM, WB; tempo di ciclo, tempo per n istruzioni in una pipeline a k stadi e speedup con esempi svolti; registri di pipeline; scrittura e lettura dei registri nello stesso ciclo; limiti (stadi sbilanciati, hazard).Pipeline →.

Cicli

while (while (i < n) { s += i; i++; }, i, n, s in r0, r1, r2, con segno):

ciclo:  CMP  r0, r1
        BGE  fuori              @ esce se i >= n
        ADD  r2, r2, r0
        ADD  r0, r0, #1
        B    ciclo
fuori:

for con contatore all'indietro: for (i = 10; i != 0; i--) s += i; diventa

        MOV  r0, #10
        MOV  r2, #0
ciclo:  ADD  r2, r2, r0
        SUBS r0, r0, #1         @ decrementa e aggiorna Z
        BNE  ciclo

Alla fine r2 = 10 + 9 + … + 1 = 55. Contare verso zero risparmia il CMP.

do-while: il test va in fondo, come nell'esempio precedente.

Massimo di due numeri, valore assoluto

        CMP   r0, r1
        MOVLT r0, r1            @ r0 = max(r0, r1) con segno

        CMP   r0, #0
        RSBLT r0, r0, #0        @ r0 = |r0|

switch con tabella di salto

Se i casi sono 0, 1, …, $k-1$ si usa una tabella di indirizzi:

        CMP   r0, #3
        BHS   default           @ senza segno: copre anche r0 < 0
        ADR   r1, tabella
        LDR   pc, [r1, r0, LSL #2]   @ salta a tabella[r0]
tabella:
        .word caso0, caso1, caso2

Errori tipici

• Usare BGT/BLT per confrontare indirizzi o unsigned: servono BHI/BLO.
• Dimenticare il B fine alla fine del ramo "then": si esegue anche il ramo "else".
• Mettere un'istruzione con S tra il CMP e il salto: i flag vengono sovrascritti.