.: CALCOLATORI - dit.unitn.itpalopoli/courses/Calc/ARM.pdf · CMP: sottrae un operando all’altro,...

.: CALCOLATORI

7 MAGGIO 2015

.: AGENDA

.: MIPS, X86, ARM

.: CARATTERISTICHE DI ARM

( CONFRONTO A MIPS )

.: ESEMPIO COPIA_STRINGA SU

ARCHITETTURA ARM

.: ESEMPIO FATTORIALE SU

MIPS, ARM

ADVANCED RISC MACHINE .: Architettura più diffusa nel settore sistemi embedded ..:: nel 2011 equipaggiava circa 9’000’000’000 di dispositivi .: Lanciata sul mercato nel 1985 (stesso anno del MIPS), progettata seguendo la stessa filosofia, ma adotta meno registri e piu modalita’ di indirizzamento

.: caratteristiche di basso consumo

.: design concesso su licenza (ARM Ltd. e’ fabless)

.: big.LITTLE (always on + demanding)

ARM / MIPS SOMIGLIANZE

ARM MIPS Introduzione 1985 1985 Dimensione istruzioni 32 bit 32 bit Spazio di indirizzamento

32 bit 32 bit

Modalita’ di indirizzamento

9 modalita’ 3 modalita’

Registri interni 16 32 Tipo RISC RISC Input/output Memory mapped Memory mapped

ARM: COMPARAZIONI MIPS: utilizza il contenuto di due registri per valutare un confronto associato ai salti condizionati ARM: prevede quattro possibili risultati di un confronto che vengono impostati nella variabile di stato:

negativo, zero, riporto, overflow

Questi risultati possono essere impostati in seguito all’esecuzione di una qualsiasi istruzione aritmetica/logica, ma l’impostazione della parola e’ facoltativa (ad esempio la ADDS lo imposta, mentre ADD non aggiorna il campo)

ARM: COMPARAZIONI CMP: sottrae un operando all’altro, e setta la parola di stato valutando il risultato della sottrazione CMN (compare negative): Somma i due operandi TST (test): Esegue un AND tra i due operandi

TEQ (test equal): Esegue un XOR

L’esito di un Compare o di Test Logici viene usato per aggiornare il Current Program Status Register (CPSR)

ARM: SALTI CONDIZIONATI Ciascuna istruzione puo essere eseguita in modo condizionato: vale a dire che viene o non viene eseguita a seconda del risultato di una confronto. Questo e’ possibile perche’ ogni istruzione inizia con un campo (grande 4 bit) che indica se l’istruzione deve essere eseguita o in alternativa se essa deve essere trattata come una NOP

Pertanto, le istruzioni di salto condizionali possono essere considerate formalmente delle istruzioni di salto INCONDIZIONATO che possono essere eseguite in modo condizionato

ARM: BRANCHES/ COMPARE&BRANCH BRANCH

B <label> PC <= label

BRANCH WITH LINK

BL <label> LR <= indirizzo della prossima istruzione

PC <= label

BRANCH AND EXCHANGE

BX Rm PC <= Rm

COMPARE, AND BRANCH IF ZERO

CBZ Rn, <label> Se Rn == 0 allora PC <= label

COMPARE, AND BRANCH IF NOT ZERO

CBZN Rn, <label> Se Rn != 0 allora PC <= label

ARM: DIFFERENZE ARM non prevede un registro dedicato per lo 0 (esistono dei codici operativi separati per eseguire quelle operazioni che nel MIPS vengono usate con il registro $zero) ARM supporta operazioni aritmetiche su piu parole, un esempio: In un unica istruzione ARM:

ADD Ra, Ra, Rj, LSL #2Si puo svolgere in un singolo ciclo l’equivalente in C dello statement:

a += ( j << 2 );Ne consegue che la pipeline e’ utilizzata in modo piu efficace

ARM: DIFFERENZE Data la presenza del campo da 4 bit usati per rendere condizionali le istruzioni, sugli ARM il campo immediato e’ stato ridotto a 12 bit Ma viene utilizzato in un modo originale: gli 8 bit meno significativi sono estesi a 32 inserendo degli zeri, poi vengono ruotati a destra un numero di volte pari a quanto specificato nei primi 4 bit e il risultato puo’ esser moltiplicato per 2, cosi facendo si puo’ rappresentare tutte le potenze di 2 presenti in una word a 32 bit

ARM: DIFFERENZE

ARM: DIFFERENZE Il contenuto del secondo registro di una qualsiasi istruzione artimetico/logica puo’ essere shiftato. Gli shift permessi sono:

Shift logico a sinistra, shift logico a destra, shift aritmetico a destra, rotazione a destra

ARM consente inoltre di fare block loads and store tramite un unica istruzione si possono salvare o ripristinare il contenuto di un insieme qualsiasi dei 16 registri del microprocessore (vantaggioso in fase di chiamata/termine di una procedura)

ARM: MODALITA` DI INDIRIZZAMENTO MIPS -> 3 modalita di indirizzamento supportate:

1. Operandi nei Registri 2. Operandi Immediati 3. Registro + Offset ( base, spiazzamento )

ARM -> Supporta le modalita’ di MIPS e le estende con: 4. Registro + Registro 5. Registro + Registro Scalato 6. Registro + Offset e Registro di aggiornamento 7. Registro + Registro generico + Registro di aggiornamento 8. incremento/decremento automatico 9. Dati relativi al program counter (PC)

ARM: MODALITA` DI INDIRIZZAMENTO MIPS -> 3 modalita di indirizzamento supportate:

1. operandi nei registri 2. operandi immediati 3. registro + offset (base, spiazzamento)

ARM -> Supporta le modalita’ di MIPS e le estende con: 4. Registro + Registro 5. Registro + Registro scalato 6. Registro + Offset e registro di aggiornamento 7. Registro + Registro generico + Registro di aggiornamento 8. incremento/decremento automatico 9. Dati relativi al program counter (PC)

ESEMPIO: Si puo spostare il contenuto di un registro di un numero di posizioni arbitrarie, per poi sommarlo a quello di un altro registro, per formare un indirizzo, ed aggiornare il contenuto di un terzo registro con il risultato del calcolo.

ARM: MODALITA` DI INDIRIZZAMENTO

[Rn, #±imm] Immediate offsetAccedo all’indirizzo +\- una quantita immediata rispetto all’indirizzo puntato Rn. Rn non cambia.

[Rn] RegisterAccedo al valore trovato in Rn. Come a dire [Rn, 0].

[Rn, ±Rm, shift] Scaled register offsetL’indirizzo cui accedo e’ il risultato della somma/differenza del valore in Rn e il valore in Rm shiftato tanto quanto specificato. Rn e Rm non cambiano il loro valore.


[Rn, ±Rm] Register offsetAccedo l’indirizzo somma/differenza tra il valore in Rn e il valore in Rm. Rn and Rm non cambiano il loro valore. Come a dire [Rn, ±Rm, LSL #0].

[Rn, #±imm]! Immediate pre-indexedAccedo all’indirizzo che ha un offset immediato, MA aggiorno il contenuto di Rn con il valore dell’indirizzo cui accedo.

[Rn, ±Rm, shift]! Scaled register pre-indexedAccedo all’indirizzo scalando uno shift ad Rm, MA in seguito Rn puntera’ all’indirizzo cui accedo.


[Rn, ±Rm]! Register pre-indexedAccedo l’indirizzo come offset tra Rn +/- Rm, MA in seguito Rn conterra’ l’indirizzo di dove ho effettuato accesso.

[Rn], #±imm Immediate post-indexedAccedo al valore trovato in Rn, in seguito Rn verra’ incrementato/decrementato di un valore immediate. [Rn], ±Rm, shift Scaled register post-indexed

Accedo ad Rn, in seguito Rn conterra’ il valore Rn incrementato/decrementato di Rm e shiftato secondo il valore shift.


[Rn], ±Rm Register post-indexedL’indirizzo cui accedo e’ quello trovato alla locazione Rn, in seguito il valore di Rn sara’ incrementato/decrementato di Rm. E’ l’equivalente a

[Rn], ±Rm, LSL #0.

ARM: OPERAZIONI REGISTRO-REGISTRO Istruzione ARM MIPS Addizione ADD ADDU, ADDIU Sottrazion SUB SUBU Moltiplicazione MUL MULT, MULTU Divisione - DIV, DIVU And AND AND Or ORR OR Xor EOR XOR Scor. Logico a SX LSL SLLV, SLL Scor. Artim. A DX ASR SRAV, SRA

Sugli ARM esiste anche ADDS, SUBS: la S specifica che va aggiornato il campo di controllo (per fare il trap dell’overflow)

ARM: LETTURA/SCRITTURA IN MEMORIA LETTURA DI UN VALORE LDSRB lettura di un Byte con Segno LDRB lettura di un Byte senza Segno LDRSH lettura di una mezza parola con Segno LDRH lettura di una mezza parola senza Segno LDR Lettura di una parola SCRITTURA IN MEMORIA STRB per un Byte STRH per una mezza parola (Half word) STR scrittura in memoria di una parola (Word)

ARM INTEL MIPS Arm Intel Mips

Bits 32/64 64 32/64 Max. # operandi 3 3 1-3 Design RISC CISC RISC Type Reg-reg Mem-reg Reg-reg Branch evaluation

Condition code Condition code Condition register

Endianess Bi-endian Little endian Bi-endian

RECENTI APPLICAZIONI MIPS

Imagination technologies MIPS Warrior P-Class P5600 Multiprocessor Core

RECENTI APPLICAZIONI INTEL

RECENTI APPLICAZIONI ARM

ESEMPIO ASSEMBLY COPIA STRINGA La procedura copia_stringa copia la stringa y nella stringa x, utilizzando il byte NULL come carattere di fine stringa !void copia_stringa(char x[], char y[]){ int i = 0;

while ( ( x[i] = y[i] ) != ‘\0’ ) { i += 1; }}

ESEMPIO ASSEMBLY Cosa otteniamo se usiamo il compilatore per ottenere il codice Assembly MIPS ! strcpy.s Anziche riferirci ai registri con il numero, rinominiamoli secondo con O32 ! strcpy_regs.s Togliamo le direttive generate e le NOP instructions ! strcpy_simplified.s Ora usiamo il sorgente come presentato da Patterson/Hennessy (cioe’ semplificato, senza istruzioni fuori ordine, usando nomi e non numeri per riferirci ai registri) !

ABI O32

ESEMPIO ASSEMBLY Cosa otteniamo se usiamo il compilatore per ottenere il codice Assembly MIPS ! strcpy.s Anziche riferirci ai registri con il numero, rinominiamoli secondo con O32 ! strcpy_regs.s Togliamo le direttive generate e le NOP instructions ! strcpy_simplified.s Ora usiamo il sorgente come presentato da Patterson/Hennessy (cioe’ semplificato, senza istruzioni fuori ordine, usando nomi e non numeri per riferirci ai registri) !

ABI O32

Il compilatore puo’ usare un registro temporaneo piuttosto che salvare $s0. $t0…$t7 sono registri che le procedure usano a loro piacimento fino ad esaurimento prima di usare quelli di cui deve salvare il contenuto

1.  I registri che contengono il riferimento a y[0] e x[0] son rispettivamente $a0 e $a1

2.  L’istruzione ADDi aggiorna lo stack per inserire UN elemento (di quattro byte) e muove quindi lo stack pointer

3.  Salva il registro da preservare $s0 nello stack, questo registro conterra` s0

.text

.globl copia_stringacopia_stringa:

addi $sp, $sp, -4sw $s0, 0($sp)add $s0, $zero, $zero

L1:add $t1, $s0, $a1lb $t2, 0($t1)add $t3, $s0, $a0sb $t2, 0($t3)beq $t2, $zero, L2addi $s0, $s0, 1j L1

L2:lw $s0, 0($sp)addi $sp, $sp, 4jr $ra

MIPS:COPIA STRINGA

1.  Per inizializzare i a 0 l’istruzione imposta il registro $s0 a 0 tramite un ADD

.text





MIPS:COPIA STRINGA

1.  L1 e’ la label che identifica l’inizio del while loop

2.  Come prima cosa carichiamo l’indirizzo di y[0] nel registro $t1 aggiungendo

3.  Non serve moltiplicare i per 4 perche’ y e’ un vettore di byte a differenza dello stack pointer

.text





MIPS:COPIA STRINGA

1.  Ora carico in $t2 il valore corrispondente all’indirizzo di y[i] tramite una LOADBYTE

2.  Carico in $t3 l’indirizzo di x[i]

.text





MIPS:COPIA STRINGA

1.  Poniamo ora in $t2 il carattere che si trova nell’indirizzo di memoria puntato da $t2, ossia effettuiamo la copia del byte contenuto in y[i] nell’array x in posizione i

.text





MIPS:COPIA STRINGA

1.  Con questa operazione di confronto possiamo capire se il carattere letto sia il carattere di fine stringa (zero)

2.  Se cosi fosse faro’ un JUMP all’etichetta L2

3.  In caso contrario continuo a seguire la sequenza di istruzioni

.text





MIPS:COPIA STRINGA

1.  Addi serve ad incrementare il nostro iteratore i contenuto in $s0

2.  Jump incondizionato ci riporta alla prima istruzione contenuta nel while-loop

.text





MIPS:COPIA STRINGA

1.  Se l’esecuzione e’ arrivata qui significa che la procedura e’ terminata (la copia e’ stata portata a termine)

2.  Bisogna innanzitutto ripristinare il valore di $s0 nello stack pointer

.text





MIPS:COPIA STRINGA

1.  Se l’esecuzione e’ arrivata qui significa che la procedura e’ terminata (la copia e’ stata portata a termine)

2.  Bisogna innanzitutto ripristinare il valore di $s0 nello stack pointer, reciprocamente a quanto fatto all’inizio della procedura

.text





MIPS:COPIA STRINGA

1.  Lo stack-pointer va poi aggiornato rimuovendo un elemento in modo da ripristinare quanto conteneva prima di eseguire la procedura di copia, ossia aggiungendovi quattro

.text





MIPS:COPIA STRINGA

1.  A questo punto si puo’ restituire l’esecuzione al chiamante

.text





MIPS:COPIA STRINGA

1.  LDR{B}: Load Byte Carica in R3 il valore contenuto in R1, usa la modalita’ immediate offset: R3 <= R1[spiazzamento 0]

2.  STR{B}: SToRe Byte Salva il valore utilizzando la modalita’ usata sopra R0[spiazzamento 0] <= R3

3.  CBZ:Compare and Branch if Zero, se R3 contiene 0 la prossima istruzione e’ .L1, altrimenti procede sequenzialmente

copia_stringa:@ args = 0, pretend =

0, frame = 0@ frame_needed = 0,

uses_anonymous_args = 0

@ link register save eliminated.

ldrb r3, [r1, #0]@ zero_extendqisi2strb r3, [r0, #0]

cbz r3, .L1

.L3:

ldrb r3, [r1, #1]!@ zero_extendqisi2

strb r3, [r0, #1]!

cmp r3, #0bne .L3

.L1:

bx lr

ARM:COPIA STRINGA

1.  Carica in R3 il valore contenuto in R1[1] (x) e lo carica in R0[1] (y)

2.  Il punto escalamativo indica che il contenuto del registro di indirizzo (R1 o R0) sara’ alterato dallo spiazzamento imposto. Questa modalita’ e detta immediate offset con pre-indexing

3.  Poi confronta con lo 0 per capire se si tratta del carattere di fine stringa, il risultato viene impostato nella parola di stato settando opportunamente le flags del registro CPSR (current program status register)






cbz r3, .L1

.L3:


strb r3, [r0, #1]!

cmp r3, #0bne .L3

.L1:

bx lr

ARM:COPIA STRINGA

1.  BNE: Branch if Not Equal riporta all’inizio del while-loop nel caso la flag sia stata settata Al contrario si prosegue sequenzialmente

2.  Per prendere una decisione sul salto ci si basa sul contenuto del CPSR che era stato configurato dall’ultimo compare

3.  Restituisce l’esecuzione (BX:Branch and eXchange) al chiamante e chiude passando il Link Register che e’ un registro special-purpose dedicato a salvare l’indirizzo da ritornare quando una chiamata a funzione termina






cbz r3, .L1

.L3:


strb r3, [r0, #1]!

cmp r3, #0bne .L3

.L1:

bx lr

ARM:COPIA STRINGA

1.  R3 e’ gestito come una locazione temporanea, R1 indirizza la stringa da copiare (sorgente) mentre R0 indirizza la destinazione della copia

2.  Pre-indexing permette di rinunciare all’uso dell’iteratore (‘i’ nel sorgente C) che scandisce la locazione di memoria in esame, in quanto le istruzioni di load/store permettono di includere lo spiazzamento/aggiornamento della locazione puntata in modo immediato ad ogni loop






cbz r3, .L1

.L3:


strb r3, [r0, #1]!

cmp r3, #0bne .L3

.L1:

bx lr

ARM:COPIA STRINGA

copia_stringa:

.LFB0:

pushl %ebx

movl 8(%esp), %ecx

movl 12(%esp), %ebx

movzbl (%ebx), %eax

movb %al, (%ecx)

testb %al, %al

je .L1

movl $0, %eax

.L3:

addl $1, %eax

movzbl (%ebx,%eax), %edx

movb %dl, (%ecx,%eax)

testb %dl, %dl

jne .L3

.L1:

popl %ebx

ret

X86:COPIA STRINGA

ESEMPIO ASSEMBLY FATTORIALE La procedura fattoriale calcola (ricorsivamente) il fattoriale di un intero!int fattoriale(int n){ if ( n < 1 ) return ( 1 ); else return ( n * fattoriale( n - 1 ) );}

1.  Le prime istruzioni servono per fare spazio nello stack pointer per 2 elementi, salvare l’indirizzo di ritorno (ra) e il registro di argomento $a0 (che contiene il parametro n

2.  La prima volta che viene chiamata la procedura l’istruzione SW salva in stack l’indirizzo del programma chiamante.

fattoriale:addi $sp,$sp,-8

sw $ra,4($sp)

sw $a0,0($sp)slti $t0, $a0,1

beq $t0, $zero, L1

addi $v0, $zero, 1addi $sp, $sp, 8

jr $ra

L1:

addi $a0, $a0, -1jal fattoriale

lw $a0, 0($sp)

lw $ra, 4($sp)addi $sp, $sp, 8

mul $v0, $a0, $v0

jr $ra

FATTORIALE:MIPS

Queste 2 istruzioni verificano se n e’ minore di 1, se così non fosse la sequenza di istruzioni proseguirà con L1 Se n e’ minore di uno invece la sequenza prosegue ordinatamente: la funzione salva il valore 1 mettendolo in un registro (sommando 0 a 1) e memorizza il risultato in $v0. Elimina i dati dallo stack rilasciando i due registri e salta all’indirizzo di ritorno Prima di eliminare i due elementi dallo stack avremmo potuto caricare $a0 e $ra. tuttavia dato che $a0 e $ra non cambiano quando n e’ minore di 1 possiamo evitare di scrivere queste due istruzioni


sw $ra,4($sp)

sw $a0,0($sp)slti $t0, $a0,1

beq $t0, $zero, L1


jr $ra

L1:


lw $a0, 0($sp)


mul $v0, $a0, $v0

jr $ra

FATTORIALE:MIPS

Se n non e’ minore di 1 il parametro (n) viene decrementato di 1 e viene nuovamente invocata la procedura fattoriale passandole il nuovo valore (ricorsivita`) l’istruzione successiva e’ quella a cui la procedura fattoriale ritornera` al termine della sua esecuzione. Occorre quindi ripristinare il vecchio indirizzo di ritorno e il vecchio valore del parametro, poi e’ possibile aggiornare lo stack pointer.


sw $ra,4($sp)

sw $a0,0($sp)slti $t0, $a0,1

beq $t0, $zero, L1


jr $ra

L1:


lw $a0, 0($sp)


mul $v0, $a0, $v0

jr $ra

FATTORIALE:MIPS

successivamente, nel registro $v0 viene memorizzato il prodotto del valore corrente in $v0 con il valore $a0 ossia il fattoriale! tramite moltiplicazione Infine la procedura salva nuovamente all’indirizzo di ritorno per tornare al chiamante


sw $ra,4($sp)

sw $a0,0($sp)slti $t0, $a0,1

beq $t0, $zero, L1


jr $ra

L1:


lw $a0, 0($sp)


mul $v0, $a0, $v0

jr $ra

FATTORIALE:MIPS

1.  Push <lista di registri> equivale a scrivere: STMDB SP!, <lista di registri> STM: store multiple DB: data blocks SP ossia copia e salva la lista di registri nello stack pointer usando pre-indexing (Ricorda: ! Significa che il base-register viene aggiornato dopo che il dato e’ stato trasferito)

2.  LR e’ il Link Register 3.  R0 contiene il riferimento dove

scrivere il valore che verra restituito dalla funzione fattoriale (risultato)

4.  R4 e’ il valore del quale vogliamo sapere il fattoriale (parametro)

fattoriale:push {r4, lr}subs r4, r0, #0

ble .L3subs r0, r4, #1bl fattorialemul r0, r4, r0pop {r4, pc}

.L3:

movs r0, #1pop {r4, pc}

FATTORIALE:ARM

1.  SUB sottrazione S: aggiorna la condition-flag S r4 <= r0 - operando(=0)

2.  BL: branch with link E: equal salta a .L3 se I precedenti sono uguali, conosce l’esito del compare perche’ la SUBS ha settato il condition field corrispondente ( Z )

3.  SE effettua il salto (r4 < 1) 4.  MOV: muovi

S: aggiorna la condition-flag S R0 <= 1

5.  POP <lista di registri> equivale a dire LDM SP! <lista di registri> ossia Load Multiple Data blocks carica quindi una lista di registri nello stackpointer ( nota il ! )



.L3:


FATTORIALE:ARM

1.  SUBS R0 <= r4 – 1 e setta cond.flag

2.  BL branch with link al .fattoriale, quindi mi rappresenta la ricorsivita’ mentre r0 il parametro del quale vogliamo calcolare il fattoriale (aggiorna PC & LR)

3.  MUL moltiplicazione reg-reg R0 <= R0 * R4

4.  POP come da precedente slide, restituisce R4 e il PC con aggiornamento PC, LR

NOTA: Branch and Link modifica sia il PC che il LR



.L3:


FATTORIALE:ARM

fattoriale:.LFB0:

pushl %ebx

subl $24, %espmovl 32(%esp), %ebxmovl $1, %eaxtestl %ebx, %ebxjle .L2leal -1(%ebx), %eax

movl %eax, (%esp)call fattorialeimull %ebx, %eax

.L2:addl $24, %esppopl %ebx

ret

FATTORIALE:X86

.: CALCOLATORI - dit.unitn.itpalopoli/courses/Calc/ARM.pdf · CMP: sottrae un operando all’altro,...

Documents

Transcript of .: CALCOLATORI - dit.unitn.itpalopoli/courses/Calc/ARM.pdf · CMP: sottrae un operando all’altro,...