Architettura degli Elaboratori Dott. Franco Liberati
Istruzioni Spostamento o movimento Argomenti della lezione Logico Aritmetiche Salto Condizionato incondizionato a sub-routine (interruzioni software:trap) Istruzioni di sistema
Architettura degli Elaboratori Istruzioni generalità Dott. Franco Liberati
Generalità Le istruzioni del linguaggio assembly possono essere divise nelle seguenti categorie: Istruzioni Load and Store Spostano dati tra la memoria e i registri generali del processore (i valori non sono modificati, ma solo spostati) Istruzioni Load Immediate Caricano, nei registri, valori costanti Istruzioni Data Movement Spostano dati tra i registri del processore Istruzioni aritmetico/logiche Effettuano operazioni aritmetico, logiche o di scorrimento sui registri del processore (il valore risultante modifica i condition code della ALU) Istruzioni di confronto Effettuano il confronto tra i valori contenuti nei registri Istruzioni di salto condizionato Spostano l esecuzione da un punto ad un altro di un programma in presenza di certe condizioni Istruzioni di salto non condizionato Spostano l esecuzione da un punto ad un altro di un programma Istruzioni di sistema o comando Influenzano lo svolgimento del programma (HALT, NOP,BREAK, TRAP )
Architettura degli Elaboratori Istruzioni di spostamento
SPOSTAMENTO: LOAD/STORE L'architettura di MIPS è di tipo Load-and-Store In pratica, la maggioranza delle istruzioni di MIPS operano utilizzando i registri interni al processore e non direttamente con i valori presenti nelle celle di memoria Esempio add $t0, $t1, $t2 #Somma $t1+$t2 e mette il risultato in $t0 Per questo motivo LOAD: il dato è prelevato da una cella di memoria e immesso in un registro STORE: il valore di un registro è salvato in una cella di memoria
SPOSTAMENTO: LOAD/STORE lb rdest, address lbu rdest, address lh rdest, address lhu rdest, address lwrdest, address la rdest, address sbrsource, address shrsource, address swrsource, address Carica un byte sito all indirizzo address nel registro rdest Carica un unsigned-byte sito all indirizzo address nel registro rdest Carica un halfword sito all indirizzo address nel registro rdest Carica un unsigned-halfword sito all indirizzo address nel registro rdest Carica una word sita all indirizzo address nel registro rdest Carica un indirizzo address nel registro rdest Memorizza un byte all indirizzo address prelevandolo dal registro rsource Memorizza un halfword all indirizzo address prelevandolo dal registro rsource Memorizza una word all indirizzo address prelevandola dal registro rsource
SPOSTAMENTO: LOAD Indirizzo in memoria della variabile valore (262160) Contenuto (1.437.364.264) 00000000 00000100 00000000 00010000 01010101 10101100 01110000 00101000 lb rdest, address lh rdest, address lwrdest, address la rdest, address lb $t0,valore 00000000 00000000 00000000 00101000 lh $t0,valore 00000000 00000000 01110000 00101000 lw $t0,valore 0101010110101100 01110000 10101000 la $t0,valore 0000000000000100 00000000 00010000
SPOSTAMENTO: STORE Registro Contenuto $t0 11010001 10000001 11010101 10101010 sbrsource, address sb $t0,variabile1 shrsource, address sh $t0,variabile2 swrsource, address sw $t0,variabile3 Indirizzo Contenuto variabile1 00000000 00000000 0000000010101010 variabile2 00000000 000000001101010110101010 variabile3 11010001100000011101010110101010
SPOSTAMENTO: LOAD/STORE.text.globl main main: lb $t1, operanda #carica operando dalla memoria al registro lb $t2, operandb#carica operando dalla memoria al registro add $t0, $t1, $t2 #somma operandi sb $t0, risultato#sposta l operando in memoria.end 00000000 00000101 00000111 00000000 00001100.data operanda:.byte 5 operandb:.byte 7 risultato:.byte 0 $t0 $t1 $t2 ALU
SPOSTAMENTO: LOAD SINGNED/UNSIGNED lb $t0, address Carica il byte indirizzato da address nel byte meno significativo del registro Il bit di segno viene esteso lbu$t0, address Carica il byte indirizzato da address nel byte meno significativo del registro Gli altri tre byte vengono posti a zero BBBBBBBB BBBBBBBB BBBBBBBB BVVVVVVV 00000000 00000000 00000000 BVVVVVVV
SPOSTAMENTO: LOAD SINGNED/UNSIGNED lh$t0, address Carica 2 byte indirizzati da address nei 2 byte meno significativi del registro Il bit del segno viene esteso lhu$t0, address Carica i 2 byte indirizzati da address nei 2 byte meno significativi del registro Gli altri due byte vengono posti a zero BBBBBBBB BBBBBBBB BVVVVVVV VVVVVVVV 00000000 00000000 BVVVVVVV VVVVVVVV
SPOSTAMENTO: LOAD SINGNED/UNSIGNED lw$t0, address Carica 4 byte indirizzati da address nel registro Non c è alcuna estensione del bit del segno BVVVVVVV VVVVVVVV VVVVVVVV VVVVVVVV
SPOSTAMENTO: LOAD SIGNED/UNSIGNED Valore 01010101 10101100 11110000 10101000 lb $t0,valore 11111111 11111111 11111111 10101000 lbu $t0,valore 00000000 00000000 00000000 10101000 lh $t0,valore 11111111 11111111 11110000 10101000 lhu $t0,valore 00000000 00000000 11110000 10101000 lw $t0,valore 0101010110101100 11110000 10101000
RAPPRESENTAZIONI DIPAROLE: ENDIAN Definizione di endianness: disposizione di una parola (word, 32 bit) nei byte di memoria Little Endian: memorizza prima la little end (ovvero i bit meno significativi) della word Big Endian: memorizza prima la big end (ovvero i bit più significativi) della word Terminologia ripresa da I viaggi di Gulliver di Jonathan Swift, in cui due fazioni sono in lotta per decidere se le uova sode devono essere aperte a partire dalla "little end" o dal "big end" dell'uovo NB: I processori x86 sono little-endian MIPS può essere little endian o big endian (L endianness di SPIM dipende dal sistema in cui viene eseguito, quindi in generale è little endian) Quando bisogna affrontare i problemi di endianness? Quando si "mischiano" operazioni su 8, 16 e 32 bit Se si utilizzano operazioni uniformi, non vi sono problemi di sorta
RAPPRESENTAZIONI DIPAROLE: ENDIAN Little Endian: lh $t0,value Big Endian: lh $t0,value 00001100 00100010 00000000 00000000 00000000 00000000 00001100 00100010 00000000 00000000 00100010 00001100 00000000 00000000 00001100 00100010
SPOSTAMENTO: ACQUISIZIONE DELL INDIRIZZO DI UNA VARIABILE L istruzione lw$t0, address carica il contenuto della word indirizzata dall etichetta address in memoria L istruzione la $t0, address carica l'indirizzo della word indirizzata dall etichetta address in memoria (utile quando si vuole caricare in un registro l indirizzo di una particolare zona di memoria (es.: una variabile)).text lw $t0,val la $t1,val In $t0 si trova il dato numerico 250 In $t1 si trova l indirizzo di memoria dove risiede il valore.data val:.byte 250 #11111010(bin)FA(hex)
SPOSTAMENTO: ACQUISIZIONE DELL INDIRIZZO DI UNA VARIABILE L istruzione lw$t0, address carica il contenuto della word indirizzata dall etichetta address in memoria L istruzione la $t0, address carica l'indirizzo della word indirizzata dall etichetta address in memoria (utile quando si vuole caricare in un registro l indirizzo di una particolare zona di memoria (es.: una variabile)) 0x00400030 12 0x00400031 34 0x00400032 56 0x00400033 78 $t0=0x78563412 00101110 00111000 00100010 00001100 00000000 00101000 00000000 00011110 0x00400030 12 0x00400031 34 0x00400032 56 0x00400033 78 $t0=0x00400030
SPOSTAMENTO: CARICAMENTO DIRETTO DIUN VALORE Per caricare dei dati numerici nei registri si utilizzano le operazioni di load immediate Si evita di definire una valore in memoria il valore numerico è nella stessa istruzione Il valore numerico è anche detto IMMEDIATE VALUE Le istruzioni sono più lunghe Esempio li $t0, 234 #Mette nel registro $t0 il valore 234 li rdest, imm lui rdest, imm Muove il valore imm nel registro rdest Muove la halfwordimmnella parte più alta dell halfworddel registro rdest
SPOSTAMENTO TRA REGISTRI La maggioranza delle istruzioni di MIPS operano tramite i registri interni al processore Per spostare i valori tra registri si utilizzano le operazioni di data movement Esempio move $t0, $t1 #Copia il contenuto di $t1 in$t0 move rdest, rsource mfhi rdest mflo rdest mthi rsource mtlo rsource Muove il registro rsource nel registro rdest Muove il registro hi nel registro rdest Muove il registro lo nel registro rdest Muove il registro rsource nel registro hi Muove il registro rsource nel registro lo
ESEMPIO: SPOSTAMENTO Scambio dei valori contenuti in due registri Prima: $t0=5 e $t1=3 Dopo $t0=3 e $t1=5.text.globl main main: li $t0,5 li $t1,3 move $t2,$t1 move $t1,$t0 move $t0,$t2 xor $t2,$t2 li $v0,10 syscall SPOSTAMENTO.ASM #carico x #carico y #c=y #y=x #x=c #pulisco$t2
ESERCIO PROPOSTO Definiti due valori in memoria x,y scambiare la loro posizione.text.globl main SPOSTAMENTO2.ASM main: lw $t0,x #carico x lw $t1,y #carico y move $t2,$t1 #c=y move $t1,$t0 #y=x move $t0,$t2 #x=c xor $t2,$t2,$t2 #pulisco $t2 sw $t0,y sw $t1,x li $v0,10 syscall.data x :.word 5 y :.word 10
ESERCIO PROPOSTO Definiti due valori in memoria x,y scambiare la loro posizione.text.globl main main: lw $t0,x lw $t1,y sw$t1,x sw$t0,y li $v0,10 syscall.data x :.word 5 y :.word 10 SPOSTAMENTO2variante.ASM #carico x #carico y #caricoy in x #caricox in y
RELAZIONE CON I CONDITION CODE Codice C N Z W P LOAD X X X X X MOVE X X X X X STORE X X X X X
Architettura degli Elaboratori II Istruzioni logiche ed aritmetiche
ISTRUZIONI LOGICHE E ARITMETICHE: GENERALITÀ Gli elaboratori elettronici hanno come principale motivo di esistenza la possibilità di svolgere un gran numero di operazioni in tempi rapidissimi Esempio add $t2, $t0, $t1 #Somma il contenuto di $t1e $t0 e lo mette in $t2 xor $t2,$t2,$t2 #Inizializza il registro $t2 a zero NB: tipicamente le istruzioni aritmetiche operano sfruttando i registri. I registri vengono usati per tre motivi principali: Costruiti con ottima tecnologia Sono vicini alla CPU Consentono di trovare i dati su cui operare utilizzando pochi bit
ISTRUZIONI LOGICHE E ARITMETICHE: GENERALITÀ Gli elaboratori elettronici hanno come principale motivo di esistenza la possibilità di svolgere un gran numero di operazioni in tempi rapidissimi Esempio add $t2, $t0, $t1 #Somma il contenuto di $t1e $t0 e lo mette in $t2 xor $t2,$t2,$t2 #Inizializza il registro $t2 a zero NB: tipicamente le istruzioni aritmetiche operano sfruttando i registri. I registri vengono usati per tre motivi principali: Costruiti con ottima tecnologia Sono vicini alla CPU Consentono di trovare i dati su cui operare utilizzando pochi bit
ISTRUZIONI ARITMETICHE addrd, rs, rt addurd, rs, rt addird, rs, imm addiurd, rs, imm sub rd, rs, rt suburd, rs, rt negrd, rs negurd, rs absrd, rs rd = rs + rt (con overflow) rd = rs + rt (senza overflow) rd = rs + imm (con overflow) rd = rs + imm (senza overflow) rd = rs - rt (con overflow) rd = rs - rt (senza overflow) rd = - rs (con overflow) rd = - rs (senza overflow) rd = rs
ISTRUZIONI ARITMETICHE mult rs, rt multu rs, rt mulrd, rs, rt mulo rd, rs, rt mulourd, rs, rt div rs, rt divurs, rt div rd, rs, rt divu rd, rs, rt rem rd, rs, rt remu rd, rs, rt hi,lo = rs * rt (signed, overflow impossibile) hi,lo = rs * rt (unsigned, overflow impossibile) rd= rs* rt(senza overflow) rd= rs* rt(con overflow) rd= rs* rt(con overflow, unsigned)) hi,lo = resto e quoz. di rs/ rt(signedcon overflow) hi,lo = resto e quoz. di rs/ rt(unsigned, no overflow) rd= rs/ rt(signedcon overflow) rd= rs/ rt(unsigned) rd= resto di rs/ rt(signed) rd= resto di rs/ rt(unsigned)
ISTRUZIONI ARITMETICHE Overflow nella moltiplicazione 1 1 1 1 x (-1) 1 1 1 0 (-2) 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 1 0 (+2)
ISTRUZIONI ARITMETICHE Overflow nella moltiplicazione 0 1 1 1 x (+7) 0 1 1 1 (+7) 0 1 1 1 0 1 1 1 0 1 1 1 0 0 0 0 0 1 1 0 0 0 1 (+49)
ISTRUZIONI LOGICHE and rd, rs, rt andird, rs, imm or rd, rs, rt ori rd, rs, imm xor rd, rs, rt xori rd, rs, imm norrd, rs, rt not rd, rs rd = rs AND rt rd = rs AND imm rd= rsor rt rd= rsor imm rd= rsxor rt rd= rsxor imm rd = NOT (rs OR rt) rd= NOT rs
ISTRUZIONI LOGICHE- ARITMETICHE: CASI IMMEDIATE E UNSIGNED Versioni immediate (i) Le versioni immediate (i) delle istruzioni precedenti utilizzano un valore costante (risultato di un'espressione) al posto di uno degli operandi Non sempre è necessario specificare la i; l'assemblatore è in grado di riconoscere anche istruzioni. Esempio: add$t0, $t0, 1 Versioni unsigned(u) Le versioni unsigned delle istruzioni non gestiscono le problematiche relative all overflow Dettagli in seguito quando parleremo di eccezioni
ISTRUZIONI LOGICHE- ARITMETICHE Lo Shift (spostamento) perde i bit dalla parte della movimentazione; mentre è colmato con 0 nella direzione opposta Il Rotate (rotazione) mantiene i bit dalla parte della movimentazione riproponendo i bit spostati nella direzione opposta sllrd, rs, rt srl rd, rs, rt rolrd, rs, rt ror rd, rs, rt rd = rs è shiftato verso sinistra di rt mod 32 bits rd = rs s è shiftato verso destra di rt mod 32 bits rd= rsè ruotato verso sinistra di rtmod32 bits rd= rsè ruotato verso destra di rtmod32 bits Rotate inserisce da una parte i bit che escono dall altra
ISTRUZIONI LOGICHE- ARITMETICHE sll $t2, $t1,3 $t1 00000000000000000000000010011101 157 $t2 00000000000000000000010011101000 1256 $t1 00000000000000000000000000000100 $t2 00000000000000000000000000001000 8 4 ror $t2, $t1,3 $t1 00000000000000000000000010011101101 $t2 10100000000000000000000000010011 157 2684354579
ISTRUZIONI LOGICHE- ARITMETICHE: Esempio Realizzare un programma che in linguaggio SPIM prenda un valore residente in memoria (di tipo byte) e metta 0 o 1 se il numero è rispettivamente pari o dispari.text.globl main main: lb $t0,pippo li $t1,2 rem $t2,$t0,$t1 sb $t2,risb li $v0,10 syscall.data pippo:.byte 100 risb:.byte 0
ISTRUZIONI DI CONFRONTO Le istruzioni di confronto sono di solito usate dall assembler ( i programmatori usano direttamente le istruzioni di salto condizionato) sltrd, rs, rt slturd, rs, rt sltird, rs, imm sltiurd, rs, imm Setta il registro rd a1se rs < rt, 0 altrimenti (con overflow) Setta il registro rd a 1 se rs<rt, 0 altrimenti (no overflow) Setta registro rd a 1 se rs<imm, 0 altrimenti (con overflow) Setta registro rd a 1 se rs<imm, 0 altrimenti (no overflow) sle, sgt, sge, seq, sne Analoghe per testare <=, >, >=, = e <>
RELAZIONE CON I CONDITION CODE Codice C N Z W P ADD 1/0 1/0 1/0 1/0 1/0 CMP 1/0 1/0 1/0 1/0 1/0 NEG 1/0 1/0 1/0 1/0 1/0 SUB 1/0 1/0 1/0 1/0 1/0 AND 0 1/0 1/0 0 1/0 OR 0 1/0 1/0 0 1/0 XOR 0 1/0 1/0 0 1/0 NOT 0 1/0 1/0 0 1/0 SL 1/0 1/0 1/0 1/0 1/0 SR 1/0 1/0 1/0 1/0 1/0 ROL 1/0 0 0 0 1/0 ROR 1/0 0 0 0 1/0
ESEMPIO Si scriva un programma in linguaggio assembly che definito un valore intero in memoria riporti in $t0 l intero precedente, in $t1 il numero corrente e in $t2 il successivo PRESUC.ASM.text.globl main main:.data x :.word 5 lw $t1,x sub $t0,$t1,1 add $t2,$t1,1 li $v0,10 syscall #carico x #pre=x-1 #suc=x+1
ESEMPIO Si scriva un programma in linguaggio assembly che definiti due numeri in memoria x e y riporta la media (fra interi) in $t2 Es: x=5 y=8 media=(5+8)/2=6 MEDIA.ASM.text.globl main main:.data x :.word 5 y:.word 8 lw $t0,x lw $t1,y add $t2,$t0,$t1 div $t2,$t2,2 li $v0,10 syscall #carico x #carico y #m=x+y #media
ESERCIO PROPOSTO Scrivere un programma che definito in memoria il prezzo e lo sconto (interi) riporta in $t0 il prezzo reale in $t1 lo sconto (arrotondato all intero) e in $t2 il prezzo scontato SALDI.ASM.text.globl main main:.data prezzo :.word 133 sconto:.word 25 lw $t0,prezzo lw $t1,sconto mul $t2,$t0,$t1 div $t2,$t2,100 li $v0,10 syscall #carico prezzo #carico sconto #prezzo=prezzo*25 #sconto=prezzo/100
ESERCIZIO PROPOSTO PER CASA 1 Scrivere un programma che, definiti due numeri (word) in memoria spazio e tempo, che fanno riferimento ad un punto mobile nello spazio, determina : 1. La velocità del punto che si muove in modo rettilineo uniforme (risultato in $t0)
ESERCIZIO PROPOSTO PER CASA 2 Scrivere un programma che converta un valore da scala Celsius a scala Fahrenheit Definire in memoria una variabile intera (word) riportante il valore in scala Celsius Riportare il risultato in scala Fahrenheit in $t0 ES: gradoc=38 $t0=100 OSS: Utilizzare le operazione tra interi (il valore risultante può essere approssimato)
ESERCIZIO PROPOSTO PER CASA 3 Scrivere un programma che, definiti due numeri (word) in memoria X e Y, determina le seguenti informazioni: 1. $t0=0 se X è un numero positivo o $t0=1 se X è un numero negativo 2. $t1=0 se Y è pari $t1=1 se Y è dispari 3. $t2 riporta X+Y 4. $t3 riporta il valore massimo in valore assoluto tra (±X) + (±Y)
Architettura degli Elaboratori Istruzioni di salto
ISTRUZIONE DI SALTO CONDIZIONATO: GENERALITÀ Le istruzioni condizionate fanno riferimento a i flag o codici di condizione presenti nello STATUS REGISTER derivanti da operazione logico-aritmetiche Operando1 Operando2 funzione ALU Flag - Codici di condizione STATUS Z C W N Risultato
ISTRUZIONE DI SALTO CONDIZIONATO beq rs, rt, target bne rs, rt, target bgers, rt, target bgeu rs, rt, target bgt rs, rt, target bgtu rs, rt, target blers, rt, target bleu rs, rt, target blt rs, rt, target bltu rs, rt, target Salta all istruzione puntata da target se rs = rt Salta all istruzione puntata da target se rs!= rt Salta all istruzione puntata da target se rs >= rt Comparazione senza considerare il segno Salta all istruzione puntata da target se rs > rt Comparazione senza considerare il segno Salta all istruzione puntata da target se rs <= rt Comparazione senza considerare il segno Salta all istruzione puntata da target se rs < rt Comparazione senza considerare il segno
ISTRUZIONE DI SALTO CONDIZIONATO (riferimento registro ZERO, $0) bgez rs, target Salta all istruzione puntata da target se rs >= 0 bgtz rs, target Salta all istruzione puntata da target se rs > 0 blez rs, target Salta all istruzione puntata da target se rs <= 0 bltz rs, target Salta all istruzione puntata da target se rs < 0 beqz rs, target Salta all istruzione puntata da target se rs = 0 bnez rs, target Salta all istruzione puntata da target se rs!= 0
ISTRUZIONI DI SALTO CONDIZIONATO: esempio Realizzare un programma che valuta il massimo fra due numeri x,y (di tipo byte) definiti in memoria. Riportare il risultato in memoria Definisci x,y Acquisisci y max=x NO max=y x<y FINE SI
ISTRUZIONI DI SALTO CONDIZIONATO: esempio Realizzare un programma che valuta il massimo fra due numeri x,y definiti in memoria come byte.text max_y: lb $t0,x #prelievo di x lb $t1,y #prelievo di y move$t2,$t1 #Int2 conservo y come se fosse il massimo blt $t0,$t1,max_y#salto perché y è il massimo move $t2,$t0 #aggiorno il valore massimo mettendo x in $t2.data sb$t2, max #conservoil massimo in x:.byte 34 #memoria y:.byte 76 max:.byte 0
ISTRUZIONE DI SALTO INCONDIZIONATO Le istruzioni incondizionate spostano l esecuzione da un punto ad un altro di un programma j target Salto incondizionato all istruzione puntata da target
ISTRUZIONI DI SALTO CONDIZIONATO: esempio Realizzare un contatore da 0 a 100 contatore=0 NO contatore=100 SI contatore=contatore+1 FINE
ISTRUZIONI DI SALTO CONDIZIONATO: esempio Realizzare un contatore da 0 a 100.text.globl main main: li $t0,0 li $t1,100 ciclo: fine: beq $t0,$t1,fine add $t0,$t0,1 j ciclo li $v0,10 syscall
ESERCIZIO SUI SALTI Realizzare un programma che in linguaggio SPIM definisca un valore di tipo byte residente in memoria e metta in $t2 il valore 1 o 2 se il numero è rispettivamente multiplo di 7 o no.text.globl main main: lb $t0,valore li $t1,7 rem $t3,$t0,$t1 li $t2,1 beqz $t3,salta li $t2,2 salta: li $v0,10 syscall.data valore:.byte 100 risb:.byte 0
Architettura degli Elaboratori Progettazione di un quesito matematico Dott. Franco Liberati
Progettazione Diagramma di flusso Definisci temp,fattoriale Definisci n Leggi n Effettuare il fattoriale di un numero n (n 0 e n ) Il fattoriale di un numero N è definito come: N!=N N-1 N-2 3 2 1 NB: 0!=1 SI n>1 SI temp=1 n!=0 NO NO Temp=n*temp n=n-1 fattoriale=temp STOP
Progettazione Implementazione linguaggio ad alto livello SI n>1 SI temp=n*temp n=n-1 NO temp=1 n!=0 Definisci temp,fattoriale Definisci n Leggi n NO fattoriale=temp STOP main() { int n,temp, fattoriale; temp=1; if(n!=0){ while(n>1) { temp=temp*n; n=n-1; } } fattoriale=temp;
Progettazione Implementazione linguaggio assemblativo SI n>1 SI temp=n*temp n=n-1 NO temp=1 n!=0 Definisci temp,fattoriale Definisci n Leggi n NO fattoriale=temp STOP.text lw $t0,n lw $t1,temp li $t5,1 beqz $t0, fine ciclo: ble $t0,$t5, fine mul $t1,$t1,$t0 sub $t0,$t0,1 j ciclo fine: sw $t1, fattoriale.data fattoriale:.word 0 temp:.word 1 n:.word 35
Progettazione Assemblatore Indirizzo Etichetta Istruzione Commento 400 lw $t0,n 404 lw $t1,temp 408 li $t5,1 412 beqz $t0,fine 416 ciclo ble $t0,$t5,fine 420 mul $t1,$t1,$t0 424 sub $t0, $t0,1 428 j ciclo 432 fine: sw $t1,fattoriale
Progettazione Assemblatore 400: lw $t0,n 404: lw $t1,temp 408: li $t5,1 412: beqz $t0, fine 416:ciclo: ble $t0,$t5, fine 420: mul $t1,$t1,$t0 424: sub $t0,$t0,1 428: j ciclo 432: fine: sw $t1, fattoriale.data fattoriale:.word 0 temp:.word 1 n:.word Tabella Simboli Etichetta/variabile ciclo 416 fine 432 fattoriale 100 temp 104 n 108 Locazione
Progettazione Assemblatore (sostituzione etichette con indirizzi) 400: lw $t0,(108) 404: lw $t1,(104) 408: li $t5,1 412: beqz $t0, (432) 416:ciclo: ble $t0,$t5, (432) 420: mul $t1,$t1,$t0 424: sub $t0,$t0,1 428: j (416) 432: fine: sw$t1, (100).data fattoriale:.word 0 temp:.word 1 n:.word Tabella Simboli Etichetta/variabile ciclo 416 fine 432 fattoriale 100 temp 104 n 108 Locazione
Architettura degli Elaboratori Interazione con tastiera e console
Lettura di valori interi da tastiera.text.globl main main: li $v0,5 syscall move$t0,$v0 #servizio di lettura di un intero da tastiera #chiamata di sistema #spostamento del valore letto da tastiera add $t0,$t0,1 #incremento del valore immesso di una unità move $a0,$t0 li $v0,1 syscall #spostamento del valore intero da stampare #servizio di stampa di un intero #chiamata di sistema li $v0,10 syscall #chiusura programma
Architettura degli Elaboratori Esempi di programmi Dott. Franco Liberati
MARS Un primo programma Impostare $t0 ad 1 se il valore della variabile definita in memoria Batman è maggiore del valore della variabile definita in memoria Robin.text.globl main main: fine: li $v0,10 syscall.data batman:.word 5 robin:.word 7 lw $t1,batman #sposta il valore della variabile dalla memoria in $t1 lw $t2,robin #sposta il valore della variabile dalla memoria in $t2 li $t0,0 #inizializzazione t0 e caso Batman<Robin blt $t1,$t2, fine #confronta e se $t1<$t2 salta a fine li $t0,1 #settaggio $t0 caso Batman>Robin #fine programma #definizione variabili
MARS Un secondo programma Impostare $t0 ad 1 se il valore della variabile definita in memoria Batman ha alla terza posizione meno significativa un 1.text.globl main main: fine: li $v0,10 syscall.data batman:.word 5 li $t0,0 #inizializzazione $t0 e caso Batman ha terzo bit LSB uguale a 0 lw $t1,batman #sposta il valore della variabile dalla memoria in $t1 li $t2,4 #sposta il valore4 in $t2 and $t3, $t1,$t2 #and logico bne$t3,$t2, fine #confrontae se la terza cifra è diversa da 1 salta a fine li $t0,1 #settaggio $t0 caso Batman ha terzo LSB uguale a 1 #fine programma #definizione variabile
MARS Esercizio proposto Implementare un programma che dato un valore definito in memoria di tipo word stabilisca se questo è primo (valore 1 in $t2) o no (valore 2 in $t2) NB: un numero è primo se, oltre ad essere divisibile per 1, è divisibile solamente per se stesso ovvero: (n,x)=1 x -{0} con x=1 x=n cioè (n,1)=1 (n,n)=1
Architettura degli Elaboratori Fine Dott. Franco Liberati
MARS Numeri primo Diagramma a blocchi p=2 Leggi n NO n=p SI n%p=0 SI PRIMO NO p=p+1 NON PRIMO STOP
n%p=0 NO SI MARS Numeri primo Diagramma a blocchi p=2 Leggi n n=p SI PRIMO.text.globl main main: inizio: lw $t0,n lw $t1,p li $t2,1 beq $t0,$t1, primo NO p=p+1 NON PRIMO STOP non_primo: primo: rem $t3,$t0,$t1 beqz $t3,non_primo add $t1,$t1,1 j inizio li $t2,2 li $v0,10 syscall.data n:.word 13 p:.byte 2