.: CALCOLATORI 7 MAGGIO 2015

Transcript

1 .: CALCOLATORI 7 MAGGIO 2015

2 .: AGENDA.: MIPS, X86, ARM.: CARATTERISTICHE DI ARM ( CONFRONTO A MIPS ).: ESEMPIO COPIA_STRINGA SU ARCHITETTURA ARM.: ESEMPIO FATTORIALE SU MIPS, ARM

3 ADVANCED RISC MACHINE.: Architettura più diffusa nel settore sistemi embedded..:: nel 2011 equipaggiava circa 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)

4 ARM / MIPS SOMIGLIANZE ARM MIPS Introduzione Dimensione istruzioni 32 bit 32 bit Spazio di indirizzamento Modalita di indirizzamento 32 bit 32 bit 9 modalita 3 modalita Registri interni Tipo RISC RISC Input/output Memory mapped Memory mapped

5 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)

6 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)

7 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

8 ARM: BRANCHES/ COMPARE&BRANCH BRANCH B <label> BRANCH WITH LINK PC <= label 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

9 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 #2 Si 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

10 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

11 ARM: DIFFERENZE

12 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)

13 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)

14 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 ESEMPIO: Si puo spostare il contenuto di 6. Registro + Offset un registro e registro di un di aggiornamento numero di posizioni 7. Registro + Registro arbitrarie, generico per poi + sommarlo Registro di a quello aggiornamento di un 8. incremento/decremento altro registro, automatico per formare un indirizzo, ed aggiornare il contenuto di un terzo 9. Dati relativi al registro program con counter il risultato (PC) del calcolo.

15 ARM: MODALITA` DI INDIRIZZAMENTO [Rn, #±imm] Immediate offset Accedo all indirizzo +\- una quantita immediata rispetto all indirizzo puntato Rn. Rn non cambia. [Rn] Register Accedo al valore trovato in Rn. Come a dire [Rn, 0]. [Rn, ±Rm, shift] Scaled register offset L 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.

16 ARM: MODALITA` DI INDIRIZZAMENTO [Rn, ±Rm] Register offset Accedo 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-indexed Accedo 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-indexed Accedo all indirizzo scalando uno shift ad Rm, MA in seguito Rn puntera all indirizzo cui accedo.

17 ARM: MODALITA` DI INDIRIZZAMENTO [Rn, ±Rm]! Register pre-indexed Accedo l indirizzo come offset tra Rn +/- Rm, MA in seguito Rn conterra l indirizzo di dove ho effettuato accesso. [Rn], #±imm Immediate post-indexed Accedo 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.

18 ARM: MODALITA` DI INDIRIZZAMENTO [Rn], ±Rm Register post-indexed L 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.

19 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)

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

21 ARM INTEL MIPS Arm Intel Mips Bits 32/ /64 Max. # operandi 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

22 RECENTI APPLICAZIONI MIPS Imagination technologies MIPS Warrior P-Class P5600 Multiprocessor Core

23 RECENTI APPLICAZIONI INTEL

24 RECENTI APPLICAZIONI ARM

25 ! 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;

26 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)!

27 ABI O32

28 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)!

29 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

30 MIPS:COPIA STRINGA.text.globl copia_stringa copia_stringa: addi $sp, $sp, -4 sw $s0, 0($sp) add $s0, $zero, $zero L1: add $t1, $s0, $a1 lb $t2, 0($t1) add $t3, $s0, $a0 sb $t2, 0($t3) beq $t2, $zero, L2 addi $s0, $s0, 1 j L1 L2: lw $s0, 0($sp) addi $sp, $sp, 4 jr $ra 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

31 MIPS:COPIA STRINGA.text.globl copia_stringa copia_stringa: addi $sp, $sp, -4 sw $s0, 0($sp) add $s0, $zero, $zero L1: add $t1, $s0, $a1 lb $t2, 0($t1) add $t3, $s0, $a0 sb $t2, 0($t3) beq $t2, $zero, L2 addi $s0, $s0, 1 j L1 L2: lw $s0, 0($sp) addi $sp, $sp, 4 jr $ra 1. Per inizializzare i a 0 l istruzione imposta il registro $s0 a 0 tramite un ADD

32 MIPS:COPIA STRINGA.text.globl copia_stringa copia_stringa: addi $sp, $sp, -4 sw $s0, 0($sp) add $s0, $zero, $zero L1: add $t1, $s0, $a1 lb $t2, 0($t1) add $t3, $s0, $a0 sb $t2, 0($t3) beq $t2, $zero, L2 addi $s0, $s0, 1 j L1 L2: lw $s0, 0($sp) addi $sp, $sp, 4 jr $ra 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

33 MIPS:COPIA STRINGA.text.globl copia_stringa copia_stringa: addi $sp, $sp, -4 sw $s0, 0($sp) add $s0, $zero, $zero L1: add $t1, $s0, $a1 lb $t2, 0($t1) add $t3, $s0, $a0 sb $t2, 0($t3) beq $t2, $zero, L2 addi $s0, $s0, 1 j L1 L2: lw $s0, 0($sp) addi $sp, $sp, 4 jr $ra 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]

34 MIPS:COPIA STRINGA.text.globl copia_stringa copia_stringa: addi $sp, $sp, -4 sw $s0, 0($sp) add $s0, $zero, $zero L1: add $t1, $s0, $a1 lb $t2, 0($t1) add $t3, $s0, $a0 sb $t2, 0($t3) beq $t2, $zero, L2 addi $s0, $s0, 1 j L1 L2: lw $s0, 0($sp) addi $sp, $sp, 4 jr $ra 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

35 MIPS:COPIA STRINGA.text.globl copia_stringa copia_stringa: addi $sp, $sp, -4 sw $s0, 0($sp) add $s0, $zero, $zero L1: add $t1, $s0, $a1 lb $t2, 0($t1) add $t3, $s0, $a0 sb $t2, 0($t3) beq $t2, $zero, L2 addi $s0, $s0, 1 j L1 L2: lw $s0, 0($sp) addi $sp, $sp, 4 jr $ra 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

36 MIPS:COPIA STRINGA.text.globl copia_stringa copia_stringa: addi $sp, $sp, -4 sw $s0, 0($sp) add $s0, $zero, $zero L1: add $t1, $s0, $a1 lb $t2, 0($t1) add $t3, $s0, $a0 sb $t2, 0($t3) beq $t2, $zero, L2 addi $s0, $s0, 1 j L1 L2: lw $s0, 0($sp) addi $sp, $sp, 4 jr $ra 1. Addi serve ad incrementare il nostro iteratore i contenuto in $s0 2. Jump incondizionato ci riporta alla prima istruzione contenuta nel while-loop

37 MIPS:COPIA STRINGA.text.globl copia_stringa copia_stringa: addi $sp, $sp, -4 sw $s0, 0($sp) add $s0, $zero, $zero L1: add $t1, $s0, $a1 lb $t2, 0($t1) add $t3, $s0, $a0 sb $t2, 0($t3) beq $t2, $zero, L2 addi $s0, $s0, 1 j L1 L2: lw $s0, 0($sp) addi $sp, $sp, 4 jr $ra 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

38 MIPS:COPIA STRINGA.text.globl copia_stringa: L1: L2: copia_stringa addi $sp, $sp, -4 sw $s0, 0($sp) add $s0, $zero, $zero add $t1, $s0, $a1 lb $t2, 0($t1) add $t3, $s0, $a0 sb $t2, 0($t3) beq $t2, $zero, L2 addi $s0, $s0, 1 j L1 lw $s0, 0($sp) addi $sp, $sp, 4 jr $ra 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

39 MIPS:COPIA STRINGA.text.globl copia_stringa copia_stringa: addi $sp, $sp, -4 sw $s0, 0($sp) add $s0, $zero, $zero L1: add $t1, $s0, $a1 lb $t2, 0($t1) add $t3, $s0, $a0 sb $t2, 0($t3) beq $t2, $zero, L2 addi $s0, $s0, 1 j L1 L2: lw $s0, 0($sp) addi $sp, $sp, 4 jr $ra 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

40 MIPS:COPIA STRINGA.text.globl copia_stringa copia_stringa: addi $sp, $sp, -4 sw $s0, 0($sp) add $s0, $zero, $zero L1: add $t1, $s0, $a1 lb $t2, 0($t1) add $t3, $s0, $a0 sb $t2, 0($t3) beq $t2, $zero, L2 addi $s0, $s0, 1 j L1 L2: lw $s0, 0($sp) addi $sp, $sp, 4 jr $ra 1. A questo punto si puo restituire l esecuzione al chiamante

41 ARM:COPIA STRINGA args = 0, pretend = 0, frame = frame_needed = 0, uses_anonymous_args = link register save eliminated..l3: ldrb r3, [r1, zero_extendqisi2 strb r3, [r0, #0] cbz r3,.l1 ldrb r3, [r1, zero_extendqisi2 strb r3, [r0, #1]! cmp r3, #0 bne.l3 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.l1: bx lr

42 ARM:COPIA STRINGA args = 0, pretend = 0, frame = frame_needed = 0, uses_anonymous_args = link register save eliminated..l3:.l1: ldrb r3, [r1, zero_extendqisi2 strb r3, [r0, #0] cbz r3,.l1 ldrb r3, [r1, zero_extendqisi2 strb r3, [r0, #1]! cmp r3, #0 bne.l3 bx lr 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)

43 ARM:COPIA STRINGA args = 0, pretend = 0, frame = frame_needed = 0, uses_anonymous_args = link register save eliminated..l3:.l1: ldrb r3, [r1, zero_extendqisi2 strb r3, [r0, #0] cbz r3,.l1 ldrb r3, [r1, zero_extendqisi2 strb r3, [r0, #1]! cmp r3, #0 bne.l3 bx lr 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

44 ARM:COPIA STRINGA args = 0, pretend = 0, frame = frame_needed = 0, uses_anonymous_args = link register save eliminated..l3: ldrb r3, [r1, zero_extendqisi2 strb r3, [r0, #0] cbz r3,.l1 ldrb r3, [r1, zero_extendqisi2 strb r3, [r0, #1]! cmp r3, #0 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 bne.l3.l1: bx lr

45 X86:COPIA STRINGA copia_stringa:.lfb0: pushl movl movl movzbl movb testb %ebx 8(%esp), %ecx 12(%esp), %ebx (%ebx), %eax %al, (%ecx) %al, %al je.l1 movl $0, %eax.l3: addl movzbl movb testb $1, %eax (%ebx,%eax), %edx %dl, (%ecx,%eax) %dl, %dl jne.l3.l1: popl %ebx ret

46 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 ) );

47 FATTORIALE:MIPS fattoriale: addi $sp,$sp,-8 sw $ra,4($sp) sw $a0,0($sp) slti $t0, $a0,1 beq $t0, $zero, L1 addi $v0, $zero, 1 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal fattoriale 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. lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 mul $v0, $a0, $v0 jr $ra

48 FATTORIALE:MIPS fattoriale: addi $sp,$sp,-8 sw $ra,4($sp) sw $a0,0($sp) slti $t0, $a0,1 beq $t0, $zero, L1 addi $v0, $zero, 1 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal fattoriale lw $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 mul $v0, $a0, $v0 jr $ra 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

49 FATTORIALE:MIPS fattoriale: addi $sp,$sp,-8 sw $ra,4($sp) sw $a0,0($sp) slti $t0, $a0,1 beq $t0, $zero, L1 addi $v0, $zero, 1 addi $sp, $sp, 8 jr $ra L1: addi $a0, $a0, -1 jal fattoriale lw $a0, 0($sp) 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. lw $ra, 4($sp) addi $sp, $sp, 8 mul $v0, $a0, $v0 jr $ra

50 FATTORIALE:MIPS fattoriale: addi $sp,$sp,-8 sw $ra,4($sp) sw $a0,0($sp) slti $t0, $a0,1 beq $t0, $zero, L1 addi $v0, $zero, 1 addi $sp, $sp, 8 jr $ra 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 L1: addi $a0, $a0, -1 jal lw fattoriale $a0, 0($sp) lw $ra, 4($sp) addi $sp, $sp, 8 mul $v0, $a0, $v0 jr $ra

51 FATTORIALE:ARM fattoriale: push {r4, lr} subs r4, r0, #0 ble.l3 subs r0, r4, #1 bl fattoriale mul r0, r4, r0 pop {r4, pc}.l3: movs r0, #1 pop {r4, pc} 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 preindexing (Ricorda:! Significa che il baseregister 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)

52 FATTORIALE:ARM fattoriale: push {r4, lr} subs r4, r0, #0 ble.l3 subs r0, r4, #1 bl fattoriale mul r0, r4, r0 pop {r4, pc}.l3: movs r0, #1 pop {r4, pc} 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! )

53 FATTORIALE:ARM fattoriale: push {r4, lr} subs r4, r0, #0 ble.l3 subs r0, r4, #1 bl fattoriale mul r0, r4, r0 pop {r4, pc}.l3: movs r0, #1 pop {r4, pc} 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

54 FATTORIALE:X86 fattoriale:.lfb0: pushl %ebx subl $24, %esp movl 32(%esp), %ebx movl $1, %eax testl %ebx, %ebx jle.l2 leal -1(%ebx), %eax.l2: movl call imull addl popl ret %eax, (%esp) fattoriale %ebx, %eax $24, %esp %ebx

55