Fondamenti Informatica - Calcolatore e istruzioni assembler

31/01/2014
Fondamenti di Informatica
CdL Ingegneria Meccanica
A.A. 2013/14
Docente:
Ing. Ivan Bruno
Calcolatore e istruzioni assembler
1.
2.
3.
Architettura del Calcolatore
Assembler e Linguaggio macchina
Esecuzione istruzioni
1
31/01/2014
L’elaboratore
DATI
RISULTATI
DATI
RISULTATI
Programma
Architettura generale di un calcolatore
2
31/01/2014
Alcuni Cenni alle periferiche

I/O, Input/Output, Ingressi/Uscita



Memory, Memoria



Input: keyboard (tastiera), mouse, scanner
Output: monitor, printer
Di base: RAM, ROM, stato solido….
Di Massa: dischi (HD, FD), nastri,
CPU, microprocessore




ALU (Unità Logico Matematica)
Unità di Controllo
Registri
etc.
La Struttura del BUS di Sistema
3
31/01/2014
Direzione dei Segnali sul BUS
CPU
RAM
ROM
IN
OUT
BUS ADDress
BUS DATI
READ/WRITE
M/IO
BUS Controlli
La Memoria e l’elaboratore







Composta da celle o locazioni
Ad ogni cella corrisponde un
indirizzo
Bus Indirizzi: N Bit di
Indirizzamento, es: 32 bit
Bus Dati: M bit
Bus Controlli: Segnali di
Controllo, Read, Write, Select….
Tempo di lettura: tempo di
accesso
Si ha una capacita di M*2N bit
4
31/01/2014
Big-endian e little-endian



Due metodi differenti usati dai calcolatori per immagazzinare in
memoria dati di dimensione superiore al byte (es. word, dword,
qword).

Ad esempio, Intel e Digital usano il formato little endian mentre
Motorola, IBM e Sun usano il formato big endian.

Il big-endian, dato che è stato scelto come ordine standard in
molti protocolli utilizzati in Internet, viene anche chiamato network
byte order. Per contro viene chiamato host byte order l'ordine
nativo dell'host in uso.
big-endian: i byte più significativi sono memorizzati all'indirizzo
di memoria più piccolo ed i byte successivi negli indirizzi più
grandi
little-endian: i byte meno significativi sono memorizzati
all'indirizzo di memoria più piccolo ed i byte successivi ad
indirizzi via via crescenti.
Big-endian e little-endian

Nel caso di una WORD (16 bit), il numero esadecimale 0x0123 verrà
immagazzinato come:
byte:

Little endian
+----+----+
|0x23|0x01|
+----+----+
0
1
Big endian
+----+----+
|0x01|0x23|
+----+----+
0
1
Nel caso di una DWORD (32 bit), il numero esadecimale 0x01234567 verrà
immagazzinato come:
byte:
Little endian
+----+----+----+----+
|0x67|0x45|0x23|0x01|
+----+----+----+----+
0
1
2
3
Big endian
+----+----+----+----+
|0x01|0x23|0x45|0x67|
+----+----+----+----+
0
1
2
3
5
31/01/2014
Transazioni sul bus, Ciclo macchina
T1
T2
T3
CPU effettua un ciclo di lettura in 3
cicli di clock
T1: CPU: asserisce l’indirizzo di
memoria, disasserisce i comandi di
lettura READ e M
T2: la memoria pilota il bus dati
con il contenuto della cella
T3: CPU legge dal bus dati
Ta
Ta = Tempo di
Accesso
Lettura dalla memoria
Transazioni sul bus, Ciclo macchina
Scrittura in memoria
T1
T2
T3
CPU effettua un ciclo di scrittura in 3
cicli di clock
T1: CPU: asserisce l’indirizzo di
memoria, il dato da scrivere e
disasserisce il comando di lettura
WRITE e M
T2: L’operazione id scrittura è in
corso
T3: scrittura completata
Tempo di scrittura
6
31/01/2014
Selezione, Memoria/IO R/W
M/IO
READ
WRITE
Action
0
0
0
----none
0
0
1
Read Memory
0
1
0
Write Memory
0
1
1
----imp
1
0
0
----none
1
0
1
Read IO
1
1
0
Write IO
1
1
1
----imp
Architettura di Von Neuman

Memoria indifferenziata per dati o istruzioni, solo
l'interpretazione da parte della CPU stabilisce se
una data configurazione di bit è da vedersi come un
dato o come un'istruzione
7
31/01/2014
Architettura Harward


Due memorie distinte: la memoria istruzioni e la
memoria dati.
Il comando di lettura della memoria istruzioni è
superfluo, in quanto si può immaginare che questa
memoria sia sempre e soltanto letta
Confronto

Von Neuman





Accesso a istruzioni e dati nella stessa memoria
Flessibilità nello sfruttamento della memoria
Rischio di manipolazione del codice
Minore costi di realizzazione
Harward




Robustezza alla manipolazione del codice
Accesso contemporaneo a codice e dati
Costi maggiori di realizzazione
Minore flessibilità
8
31/01/2014
CPU – Funzioni & Architettura

Funzioni principali di una CPU sono:




Trasferimento Dati
Controllo di Flusso
Elaborazioni Aritmetiche e Logiche (Addizioni e Sottrazioni,
AND, OR, XOR, NOT, Incrementi, Decrementi, Shift, Clear,
ecc… )
Ogni CPU ha un array register con almeno:




Un Registro ACCUMULATORE (W o Acc o R0)
Il PROGRAM COUNTER (PCL)
L’INSTRUCTION REGISTER (IR)
Lo STACK POINTER (SP)
CPU - Architettura
9
31/01/2014
Elementi delle CPU

UC: Unità di Controllo, Control
Unit





Decodifica le istruzioni contenute
nell’IR e genera i segnali di controllo
Controlla le altre unità al fine di
completare l’istruzione data in IR
Produce i segnali che escono dalla
CPU
Legge alcuni segnali che entrano
nella CPU, per esempio il Clock…..
UO: Unità operativa


Contiene i registri
Contiene la ALU
Registri di CPU

MAR: Memory Address Register



DTR: Data Transfer Register



contiene l'indirizzo della locazione di
memoria da leggere o scrivere.
La dimensione di MAR determina
l'ampiezza dello spazio di memoria fisica
essendo legato al bus indirizzi (es: a 32
bit)
registro attraverso il quale viene
scambiata l'informazione tra la memoria e
la CPU
Tradizionalmente dà la misura del grado
di parallelismo della macchina (8, 16, 32,
64 bit)
R0, R1,...Rn: registri di uso
generale



Registri di uso generale (general purpose
registers),
elevata velocità,
memorizzazione temporanea dei dati
10
31/01/2014
Registri di CPU

IR: Instruction Register





PC: Program Counter




Usato per contenere l'istruzione in corso
di esecuzione.
Caricato in fase di fetch dalla memoria.
Rappresenta l'ingresso che determina le
azioni svolte durante la fase di
esecuzione.
Dall’IR viene decodificata l’istruzione
Tiene traccia dell'esecuzione del
programma
Contiene l’indirizzo di memoria della
prossima istruzione
Viene aggiornato per indirizzare
l’istruzione successiva o parti di questa
I Registri T0 e TI sono registri
temporanei in appoggio alla ALU
CPU - Esecuzione istruzioni
L’esecuzione di un’istruzione
da parte della CPU è divisa
in MICROISTRUZIONI ed
eseguite in 2 fasi:
-Fase di FETCH
-Fase di EXECUTE
Le Microistruzioni sono la
sequenza dei comandi di
attivazione dei segnali che
controllano e attivano i
dispositivi interni alla CPU
11
31/01/2014
CPU - Esecuzione istruzioni
Fase di FETCH
La CPU carica sull’address bus l’indirizzo
dell’istruzione da eseguire (MAR)
-
L’indirizzo caricato è fornito dal Program
Counter (PC), registro allocato nella
Control Unit della CPU
-
-
Sul control bus ci sono le informazioni
(comandi attivi) per leggere la locazione di
memoria il cui indirizzo è sull’address bus,
mentre sul data bus vengono caricati i dati
dalla locazione di memoria contenuta
nell’instruction register (IR)
-
Il PC viene aggiornato ed ora punta alla
prossima istruzione del programma da
eseguire
CPU - Esecuzione istruzioni

Fase di EXECUTE

L’istruzione caricata nell’IR viene decodificata

Vengono eseguiti i trasferimenti di dati necessari e
le operazioni logiche e/o aritmetiche derivate dalla
decodifica dell’op code

Il risultato, a seconda del tipo di operazione
eseguita è riscritto in un registro o in una
locazione di memoria o su un dispositivo di I/O
Normalmente, quindi, un istruzione per essere eseguita RICHIEDE
ALMENO 2 CICLI MACCHINA (almeno 2 ACCESSI IN MEMORIA, uno in
LETTURA e uno in SCRITTURA)

12
31/01/2014
CISC vs RISC

Esistono 2 grandi famiglie di CPU: CISC e RISC.

CISC (Complex Instruction Set Computer)






In genere le CPU commerciali sono CISC
Normalmente utilizzano architetture Von Neumann classiche
Molte istruzioni (>100)
Molti metodi di indirizzamento
Più di 1 ciclo macchina per eseguire un’istruzione
RISC (Reduced Instruction Set Computer)



Poche istruzioni (<50)
Pochi metodi di indirizzamento (solo diretto e indiretto)
1 ciclo macchina per eseguire un’istruzione (a parte salti e call)
Linguaggio Macchina e Assembly

Ogni processore e' in grado di eseguire un certo numero di istruzioni,
cioè può eseguire un numero più o meno grande di operazioni
elementari.

Un programma è costituito da una sequenza di tali istruzioni che permette
al microprocessore di assolvere ad un determinato compito di calcolo e/o
di controllo.

Le istruzioni che il microprocessore deve leggere ed eseguire sono
immagazzinate nella memoria in forma di codice binario ovvero sono
espresse in quello che si chiama "LINGUAGGIO MACCHINA".

L'uso del linguaggio Assembly permette di adottare una forma simbolica
testuale (codice mnemonico) che richiama con una notazione sintetica il
modo di operare di ogni istruzione.
13
31/01/2014
Linguaggio Macchina e Assembly

Il linguaggio Assembly è pertanto più agevole e conserva tutti i vantaggi di
sintesi e di capacità di esecuzione, in quanto a ogni istruzione in linguaggio
Assembly corrisponde una sola istruzione in linguaggio macchina.

La corrispondenza uno a uno fra istruzione di linguaggio Assembly e istruzione
in linguaggio macchina vieta la possibilità di un unico linguaggio Assembly che,
pertanto, è diverso da microprocessore a microprocessore.

Per essere eseguito, un programma in linguaggio Assembly deve essere
tradotto in linguaggio macchina da uno specifico programma chiamato
Assembler.
ASSEMBLY
ASSEMBLER
CODICE OGGETTO
Linguaggio Macchina e Assembly



Il codice sorgente di un programma in Assembly è un file di testo, cioè
un insieme di caratteri ASCII.
Successivamente l’Assembler (assemblatore) si occupa di tradurre il
file sorgente in un file oggetto, ovvero in un file espresso/codificato in
linguaggio macchina.
Il file prodotto dall'assemblatore viene poi trattato dal programma detto
Linker che fornisce un file effettivamente eseguibile dalla CPU. L'ultimo
passo del processo consiste nel caricare e far eseguire il file creato dal
linker.
Librerie (codici oggetto
precedentemente generati)
ASSEMBLY
ASSEMBLER
CODICE OGGETTO
LINKER
Exe
14
31/01/2014
Assembly : Tipi di Istruzioni
Istruzioni aritmetico-logiche


Sono le istruzioni aritmetiche, logiche o in generale tutte le istruzioni che effettuano
manipolazioni sui dati . Esse devono specificare i dati su cui devono essere compiute
le operazioni e dove depositare il risultato.
Istruzioni di ingresso-uscita (READ,WRITE)


Adempiono la funzione di trasferimento dati all'interno o all'esterno dell'elaboratore.
Esse indicano sia l'unità periferica che deve essere utilizzata sia dove si trova il dato
che deve essere emesso all'esterno (oppure dove deve essere depositato il dato
immesso all'interno).
Istruzioni di salto e controllo di flusso (JMP)


Servono per alterare l'esecuzione sequenziale di un programma. Il salto può essere
incondizionato o condizionato. Nel primo caso è specificato l'indirizzo di memoria in
cui si trova la successiva istruzione da eseguire. Nel secondo caso è specificato
anche una condizione necessaria perché il salto avvenga.
Istruzioni per il controllo del contesto:


permettono di gestire le interruzioni e di salvare e ripristinare il contesto del
microprocessore
Istruzioni aritmetico-logiche

add, addI
Problema: a=b+c
add a, b, c
Somma b con c e memorizza il risultato in a.
Quindi:



b!=0 e c==0, a assume il valore di b
b==0 e c!=0, a assume il valore di c
b!=0 e c!=0, a assume il valore di b+c
Problema: x=a+b+c
add tmp, a, b
add x, tmp, c
Occorre una variabile di appoggio tmp.
15
31/01/2014
Istruzioni aritmetico-logiche

add, addI
Problema: a=b+10
addI a, b, 10

Somma b con il valore costante 10 e memorizza il risultato in a.

add immediate opera quindi addizioni nelle situazioni in cui il
secondo operando è un valore costante

La differenza con add (come vedremo) è nella definizione in termini
di linguaggio macchina
Istruzioni aritmetico-logiche

OSSERVAZIONE: gli operandi a, b, c, tmp…. non
sono riferimenti a variabili “di memoria”, in quanto
operazioni che coinvolgono la memoria avrebbero il
difetto di essere costose dal punto di vista del tempo
di esecuzione in quanto il tempo di accesso alla
memoria sarebbe dominante (msec).

Pertanto le operazioni aritmetiche e logiche
vengono eseguite internamente alla CPU e i dati
devono trovarsi già all’interno

gli operandi sono quindi legati ai registri interni alla CPU
che hanno tempi di accesso molto più veloci rispetto alla
memoria (nsec).
16
31/01/2014
Istruzioni aritmetico-logiche
In virtù di quanto detto, la definizione delle istruzioni add e addi
diventano:
add $x, $y, $z;
addi $x, $y, value;
Con:

$x: registro destinazione
$y e $z: registri sorgente

value: il valore della costante (considerata col segno)

In modo analogo si definisco le istruzioni: sub (sottrazione), mult
(moltiplicazione), and (operatore logico AND bit a bit),…

Istruzioni aritmetico-logiche
Comparazione valori: set on less than
slt $x, $y, $z;
Con:
 $x: registro destinazione
 $y e $z: registri oggetto della comparazione

$x=1 se $y<$z, $x=0 altrimenti
17
31/01/2014
Istruzioni di ingresso-uscita (READ,WRITE)
Istruzioni per il trasferimento dati dalla memoria ai registri.
Load-word (Read)
lw $x, Base[$y];


Carica il registro $x col valore prelevato all’indirizzo dato dalla
somma del numero Base con il contenuto del registro $y
Il valore letto è a 4 byte
Store-word (Write)
sw $x, Base[$y];

Scrive il valore contenuto nel registro $x all’indirizzo dato dalla
somma del numero Base con il contenuto del registro $y
Indirizzamento Base+offset

Nelle istruzioni lw e sw l’indirizzamento in
memoria prende il nome di Base + offset
word
Base = 100 +
Indirizzi crescenti
Offset = 4
Indirizzo = 104
100
101
102
103
104
105
0E01
AAFF
111A
0000
C0C0
D1CA
ACCA
2345
18
31/01/2014
Istruzioni di salto e controllo di flusso

Consentono di cambiare il regolare flusso di esecuzione sequenziale
operando dei “salti”

Consentono:





Esecuzione di porzioni di istruzioni assembly in modo ciclico fino al verificarsi
di particolari condizioni logico-matematico
Saltare ad un porzione di codice al verificarsi di particolari condizioni logicomatematico
Sono necessari un “test” e un riferimento, detto “label”, all’istruzione cui
saltare
Istruzioni che integrano “test+label” si definisco istruzioni di conditional
brach
Istruzioni che eseguono un salto senza un test si definiscono istruzioni
di salto incondizionato
Istruzioni di salto e controllo di flusso

Salto condizionato con l’istruzione beq (brach if equal)
beq $x,$y,label
I valori in $x, $y sono comparati e se:
$x==$y  si salta ad eseguire l’istruzione indicata da label e
da lì continua l’esecuzione
$x!=$y  si esegue l’istruzione successiva (eseguendo il
regolare flusso di istruzioni)
 Si tratta quindi di un test di uguaglianza
 In abbinamento all’istruzione slt si possono realizzare test
basati su condizioni di >, >=, <, <=
19
31/01/2014
Istruzioni di salto e controllo di flusso

Esempio: assumendo $x=0, label = pippo
pippo:
add $a,$b,$c
………………………………
slt $y,$t,$s
beq $x,$y,pippo
add $x,$y,$t
Si salterà all’istruzione identificata da “pippo” quando $t>=$s
( $y=0)
Si continua a saltare fintanto che si verifica la condizione
$t>=$s
Istruzioni di salto e controllo di flusso

Salto incondizionato con l’istruzione j (jump)
j label
Si salta ad eseguire l’istruzione indicata da
label e da lì continua l’esecuzione
20
31/01/2014
I registri dell’R4000



Sono 32 e denotati come $0, $1,…,$31
All’inizio dell’esecuzione di ogni istruzione il registro $0 contiene il valore 0
x=a+b+c l’avevamo scritta come
add tmp, a, b;
add x, tmp, c;
Se si considerano pre-caricati i registri:

$2 con il valore di a

$3 con il valore di b

$4 con il valore di c
e:

$5 il registro d’appoggio col ruolo di tmp

$6 il registro finale con il risultato finale

L’espressione precedente diventa:
add $5, $2, $3;
add $6, $5, $4;
Esempio di codice assembly

a=b+15-c[2]-c[3]
Supponendo che a, b e c siano
rispettivamente agli indirizzi
100, 104 e 108, $5 contiene il
risultato e $0 ad ogni
istruzione contiene lo 0
lw
addi
addi
lw
sub
addi
lw
sub
sw
$5,
$5,
$6,
$7,
$5,
$6,
$7,
$5,
$5,
104[$0];
$5,15;
$0, 2;
108[$6];
$5, $7;
$6, 1;
108[$6];
$5, $7;
100[$0];
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
word
0004
0101
1100
0110
00AF
0000
00A1
01AB
0000
1111
00A1
000F
0003
0041
0100
00FF
21
31/01/2014
Memoria organizzata a 32 bit

a=b+15-c[2]-c[3]
Supponendo che a, b e c siano
rispettivamente agli indirizzi
100, 104 e 108, $5 contiene il
risultato e $0 ad ogni
istruzione contiene lo 0
lw
addi
addi
lw
sub
addi
lw
sub
sw
$5,
$5,
$6,
$7,
$5,
$6,
$7,
$5,
$5,
104[$0];
$5,15;
$0, 2;
108[$6];
$5, $7;
$6, 1;
108[$6];
$5, $7;
100[$0];
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
dword
0000 0004
0000 0101
0000 1100
0000 0110
0000 00AF
0000 0000
0000 00A1
0000 01AB
0000 0000
0000 1111
0000 00A1
0000 000F
0000 0003
0000 0041
0000 0100
0000 00FF
Ciclo iterativo in assembly
start_loop:
end_loop:
addi $4, $0, 0;
addi $5, $0, 0;
addi $6, $0, 10;
slt $1, $5, $6;
beq $0,$1, end_loop;
lw $7, 100[$5];
add $4, $4, $7;
addi $5, $5, 1;
j
start_loop;
sw $4, 612[$0];
22
31/01/2014
Formato istruzioni in linguaggio macchina

Un'istruzione in linguaggio macchina può essere rappresentata
graficamente secondo questo schema generale:
CODICE OPERATIVO
OPERANDI

Il codice operativo specifica l'operazione da compiere. Se si hanno N
bit allora e’ possibile identificare diverse istruzioni.

Gli operandi specificano le locazioni delle celle di memoria cui
ciascuna operazione si riferisce.

Il codice operativo è sempre presente; mentre gli operandi possono
mancare.
La lunghezza di un'istruzione varia a seconda del tipo di elaboratore.
La lunghezza può variare anche da istruzione a istruzione.


Il repertorio delle istruzioni

Repertorio stile RISC (Mips) caso R4000



le istruzioni hanno tutte la stessa dimensione (4 byte)
il campo del codice di operazione (OP) occupa uno spazio
predefinito
esiste un numero estremamente limitato di formati
Formato R (Registri  operandi)
Formato I (Immediate  offset)
Formato J (Jump  INDirizzo)
23
31/01/2014
Formato istruzioni add, sub e addi




Codifica istruzioni add e sub usa il Formato R

rs
rt
rd
-
funct
6
5
5
5
5
6
bit
op = 0 per tutte le istruzioni aritmetico-logiche
funct definisce il codice dell’operazione
rs, rt, rd codificano i registri interessati nell’operazione


op
Con 5 bit a disposizione si hanno 32 registri numerati da 0 a 31
Per la somma (add) funct vale 32 e la codifica è: add $rd, $rs, $rt
op=0
rs
rt
rd
-
funct=32
000000
xxxxx
xxxxx
xxxxx
00000
100000
Per la sottrazione (sub) funct vale 34 e la codifica è: sub $rd, $rs, $rt
op=0
rs
rt
rd
-
funct=34
000000
xxxxx
xxxxx
xxxxx
00000
100010
Formato istruzioni addi

L’istruzione addi usa il Formato I
op
rs
rd
value
6
5
5
16

op = 8
value definisce il valore della costante
rs, rd codificano i registri interessati nell’operazione

Pertanto:


addi $rd, $rs, value

bit
op=8
rs
rd
value
001000
xxxxx
xxxxx
xxxxxxxxxxxxxxxx
La costante è codificata a 16 bit e consente 216=65536 valori
24
31/01/2014
Formato istruzione slt (set on less)

op
rs
rt
rd
-
funct
6
5
5
5
5
6
bit
slt




Usa il Formato R (è un’istuzione aritmentico logico)
op=0
Funct = 42
rs, rd, rt codificano i registri interessati nell’operazione


$rd=1 se $rs<$rt, $rd=0 altrimenti
Pertanto:
slt $rd, $rs, $rt
op=0
rs
rt
rd
-
funct=42
000000
xxxxx
xxxxx
xxxxx
00000
101010
Formato istruzioni load e store word


Le istruzioni lw e sw usano il Formato I
op
rs
rd
base
6
5
5
16
bit
lw



op = 35
base definisce il valore della costante come riferimento
dell’indirizzo di memoria ed è codificata a 16 bit
rs, rd codificano i registri interessati nell’operazione


$rd registro caricato col valore letto
Pertanto:
lw $rd,base[$rs]
op=35
rs
rd
base
100011
xxxxx
xxxxx
xxxxxxxxxxxxxxxx
25
31/01/2014
Formato istruzioni load e store word

op
rs
rd
base
6
5
5
16
bit
sw



op=43
base definisce il valore della costante come riferimento
dell’indirizzo di memoria ed è codificata a 16 bit
rs, rd codificano i registri interessati nell’operazione


$rd registro contenente il valore da scrivere in memoria
Pertanto:
sw $rd,base[$rs]
op=43
rs
rd
base
101011
xxxxx
xxxxx
xxxxxxxxxxxxxxxx
Formato istruzioni di salto beq e jump

op
rs
rd
label
6
5
5
16
bit
beq



Usa il Formato I
op=4
label definisce il valore della costante che esprime la distanza tra l’istruzione
corrente e quella a cui saltare (spiazzamento).




Si possono indirizzare 65536 locazioni, però considerando lo spazio occupato da
ciascuna istruzione (4byte), il range di salto effettivo è [-128KB,+128KB]
Si utilizza per salti “locali” ovvero le istruzioni sono “vicine”
rs, rd codificano i registri interessati nell’operazione di confronto
Pertanto:
beq $rd, $rs, label
op=4
rs
rd
label
000100
xxxxx
xxxxx
xxxxxxxxxxxxxxxx
26
31/01/2014
Formato istruzioni di salto beq e j

op
label
6
26
bit
j





Salto incondizionato
Usa il Formato J
op=2
label a 26 bit (ampiezza salto o spiazzamento) permette salti
>128KB
Pertanto:
j label
op=2
label
000010
xxxxxxxxxxxxxxxxxxxxxxxxxx
27
31/01/2014
Codifica assembly in forma numerica: linguaggo
macchina
addi $4, $0, 0;
addi $5, $0, 0;
addi $6, $0, 10;
start_loop: slt $1, $5, $6;
beq $0,$1, end_loop;
lw $7, 100[$5];
add $4, $4, $7;
addi $5, $5, 1;
j
start_loop;
end_loop:
sw $4, 612[$0];
8
0
4
0
8
0
5
0
8
0
6
10
0
5
6
4
0
1
+16
35
5
7
100
0
4
7
8
5
5
2
43
1
4
-
-
42
32
1
-24
0
4
612
28
31/01/2014
Esecuzione su un processore
Sommatore
Porta AND
Espansore di Bit
Multiplexer

Nota: non rappresenta il RISC4000 ma è un modello didattico semplificato
Alcuni elementi circuitali
Linea dati/indirizzi – Una linea di comunicazione a n bits
n
Segnale di Controllo - Abilitata/disabilita un dispositivo es. il
wr_enable verso la memoria
L1 L0
1/0
Multiplexer - Abilitata uno degli ingressi in base al valore del
segnale di controllo in ingresso, se 0 attiva la linea L0, se 1
attiva la linea L1.
Espansore di bit – Estende il numero di bit da 16 a 32,
riempendo con 0 la parte significativa a 16 bit.
Esempio: la sequenza 0101 0011 0011 0001 diventa
0000 0000 0000 0000 0101 0011 0011 0001
Porta AND – A due ingressi, con uscita asserita (1) se
entrambi gli ingressi sono asseriti (1), 0 altrimenti
29
31/01/2014
Alcuni elementi circuitali

Sommatore e PC
Sommatore – ALU semplificata e ridotta al solo calcolo delle
addizioni
PC (Program Counter) – Registro a 32 bit contenente
l’istruzione successiva da eseguire.
Nel modello utilizzato ogni istruzione occupa 32 bit, il sommatore abbinato al
PC ha un ingresso +4 che consente di eseguire l’operazione PC=PC+4
Istruzione add
data_wr: registro con il
risultato dell’operazione
addr_wr: indirizzo
interno del registro di
scrittura (rd)
$_rs e $_rt: valore
operandi in ingresso alla
ALU
ALU_out: risultato
dell’operazione
op=0
rs
rt
rd
-
funct=32
0:5
6:10
11:15
16:20
21:25
26:31
Codifica istruzione add
30
31/01/2014
Istruzione addI
op=8
rs
rd
value
0:5
6:10
11:15
16:31
Codifica istruzione addI
Istruzione sw
addr = base + $_rs
data_in = $_rt ($rd)
op=43
rs
rd
base
0:5
6:10
11:15
16:31
Codifica istruzione sw
31
31/01/2014
Istruzione lw
addr = base + $_rs
data_wr = data_out
addr_wr = data_wr ($rd)
op=35
rs
rd
base
0:5
6:10
11:15
16:31
Codifica istruzione lw
Istruzione beq
PC = PC+4
PC + label
rt
$_rt
L0
brach=1
zero_bit=1 se ($_rs-$_rt)=0
L1
branch AND zero_bit = 1 L1
op=4
rs
rt
label
0:5
6:10
11:15
16:31
Codifica istruzione beq
32