Esercitazione D.R. C. Raibulet - e-Learning

Esercitazione 4
Eccezioni & Interruzioni
in MIPS 32
Claudia Raibulet
[email protected]
Eccezioni
¾
¾
¾
Le eccezioni = variazioni delle condizioni normali di
funzionamento della CPU
Conseguenze delle eccezioni => cambiamento del
normale fflusso di esecuzione di un pprogramma
g
La CPU “solleva” una eccezione e quindi cambia il
flusso di esecuzione a seguito di:
• errore del programma (non voluto dal programmatore)
• richiesta del programma (voluta dal programmatore)
• evento esterno (indipendente dal programma in esecuzione)
¾
In tutti i casi
casi, il flusso di esecuzione passa ad una
locazione prefissata, dove si trova il gestore delle
eccezioni (exception handler)
Tipi di eccezioni
¾
Tre categorie:
• sincrone “involontarie”
involontarie (impreviste,
(impreviste causate da elaborazioni
con valori non-ammissibili o indirizzi di memoria non
accessibili o fuori range)
o accessi scorretti a locazioni di memoria (non allineati o
fuori dallo spazio del processo)
o overflow aritmetico
• sincrone “volontarie” (previste e richieste dal programmatore)
o syscall, break
• asincrone (indipendenti dall’esecuzione del programma in
corso)
o provocate dalle periferiche di I/O
Gestione delle eccezioni in MIPS
¾
¾
Il processore risponde ad una eccezione salvando l’indirizzo
dell’istruzione
dell
istruzione che ha causato ll’eccezione
eccezione, ed eseguendo una
procedura detta “gestore delle eccezioni” (in PCSPIM –
Exceptions.s)
p
) collocata nello spazio
p
kernel text a ppartire dalla
locazione 0x80000180
Il compito
p dell’Exceptions.s
p
è di:
• salvare lo stato corrente dei registri (Salvataggio)
• svolgere
g le operazioni
p
necessarie ad affrontare e risolvere
l’eccezione (Trattamento)
• ripristinare lo stato della macchina al momento dell’eccezione
(Ripristino)
Tipi di registri
¾
Per determinare la causa dell’eccezione l’Exception.s osserva i
registri del co-processore 0 relativi alla gestione delle eccezioni:
Registro
Numero Significato
BadVAddr
8
Indirizzo di memoria il cui riferimento ha
provocato l’eccezione
Status
12
Maschera delle interruzioni e bit di abilitazione
Cause
13
Tipo di eccezione e interrupt in attesa di servizio
EPC
14
Indirizzo dell’istruzione che ha causato
l’eccezione
¾
Si usano le istruzioni
• mtc0 – move to c0
• mfc0 – move from c0
per accedere ai valori di tali registri
Schema del processore MIPS
Memory
CPU
Coprocessor 1 (FPU)
Registers
Registers
$0
$0
$31
$31
Arithmetic
unit
Multiply
py
divide
Lo
Arithmetic
unit
Hi
Coprocessor 0 (traps and memory)
Registers
BadVAddr
Cause
Status
EPC
Registro Cause
¾
¾
8 bit pper interrupt
p pendenti
p
5 bit per il codice dell’eccezione
31
Branch
d l
delay
15
interrupt
pendenti
8
6
2
codice
eccezione
Tabella delle eccezioni
Numero Nome
Descrizione
0
INT
Interrupt esterno (periferica)
4
AdEL
Load da indirizzo di memoria non allineato
5
AdES
Store ad indirizzo di memoria non allineato
6
IBE
Bus errore durante l’istruzione fetch
7
DBE
Bus error durante load o store
8
Sys
Invocazione syscall
9
B
Bp
E
Eccezione
i
causata
t da
d breakpoint
b k i t
10
RI
Eccezione causata dall’istruzione riservata
11
CpU
Co-processore non utilizzabile
12
Ov
Overflow aritmetico
15
FPE
g ppoint
Eccezione causata da floating
Esempio – overflow aritmetico
.text
main:
# Genera un overflow aritmetico addizionando "con segno" due numeri
# positivi la cui somma NON e' rappresentabile in complemento a 2
li $t0, 0x7fffffff # massimo positivo in complemento a 2
li $t1, 2
# aggiungo abbastanza per superare il massimo positivo
add $a0, $t0, $t1 # cosa succede dopo aver eseguito questa istruzione?
li $v0,, 1
syscall
# stampa
p il risultato dell'operazione
p
aritmetica
jr $ra
# fine
Esempio – Overflow Aritmetico
¾
Il contenuto dei registri quanto si solleva l’eccezione:
PC = 80000180
Status = 3000ff12
¾
EPC = 00400030
HI = 00000000
Cause = 00000030
LO = 00000000
BadVAddr= 00000000
Il messaggio scritto nel Messagge Window:
[0x0040002c]
0x34090002 ori $9, $0, 2
abbastanza per superare il massimo positivo
[0 00400030]
[0x00400030]
0 01092020 add
0x01092020
dd $4
$4, $8
$8, $9
succede dopo aver eseguito questa istruzione ?
Exception occurred at PC=0x00400030
Arithmetic overflow
; 13: li $t1, 2
# aggiungo
; 14
14: add
dd $$a0,
0 $t0
$t0, $t1 # cosa
Osservazioni
¾
Si noti che quando avviene l’eccezione:
• appare un messaggio sulla Messagge Window “Exception
occured ...”; tale stampa è effetuata internamente dal
simulatore
i l
e NON ddall E
Exceptions.s
i
che
h non ha
h ancora
iniziato l’esecuzione
• PC assume il valore
l
0x80000180,
0 80000180 l’i
l’indirizzo
di i
iniziale
i i i l
dell’Exceptions.s
• EPC assume il valore 0x00400030,
0x00400030 l’indirizzo
l indirizzo della
istruzione che ha provocato l’eccezione
• Il registro Cause assume il valore 0x00000030
Registri EPC e BadVAddr
¾
EPC
• Dopo che è avvenuta una eccezione il registro EPC
contiene l’indirizzo dell’istruzione in corso di
esecuzione (PC) quando è avvenuta l’eccezione
¾
BadVAddr
• Se avviene una eccezione a seguito di un accesso
g alla memoria, qquesto registro
g
contiene
illegale
l’indirizzo della locazione alla quale il programma ha
tentato di accedere
Esercizio 1
¾
Si consideri il seguente esercizio:
.data
d t
dato:
.word 42
.text
main:
la
lw
lw
jr
¾
$t0, dato
$t1, 0($t0)
( )
$t2, 3($t0)
$ra
# indirizzo in data segment
# lettura da locazione
# lettura da locazione nop
# fine
Considerando che il programma è memorizzato partendo
dall’indirizzo 0x00400024 e i dati dall’indirizzo
0x10010000 si chiede:
• Quale istruzione genera l’eccezione?
g
Cause?
• Cosa indica il registro
• Quali valori assumono i registri EPC e BadVAddr?
Registro
g
Status
¾
Interrupt enable:
• 1 – interruzioni sono abilitate
• 0 –interruzioni non sono abilitate
¾
Exception level:
• 1 – settato a 1 dopo
p che una eccezione è sollevata
• 0 – il valore di default
¾
User mode:
• 1 – se il pprocessore è in user mode (come
(
sempre
p in PC SPIM))
• 0 – se il processore è in kernel mode
¾
Interrupt mask esprime gli interrupt abilitati
1
15
iinterrupt
t
t
mask
8
4
1 0
user
mode
interrupt
enable
exception
level
Break
¾
¾
Interrompe con una eccezione l’esecuzione di un
programma e avvia ll’esecuzione
esecuzione dell
dell’Exceptions
Exceptions.ss
Utilizzata principalmente dai debugger che
assistono
it
il programmatore
t
nella
ll correzione
i
dei
d i
programmi permettendone l’arresto in punti
arbitrari l’ispe
arbitrari,
l’ispezione
ione delle variabili
ariabili e della
memoria, la eventuale modifica del codice, e la
prosecuzione dell’esecuzione
break code
0
6 bit
# causa l’eccezione code (1 – riservata al debugger)
code su 20 bit
0xD
6 bit
Esempio
p - Break
.text
main:
break 5
jjr $ra
¾
# genera break (parametro 5)
# fine
Il contenuto dei registri quanto si solleva l’eccezione:
PC = 80000180 EPC = 00400024
Status = 3000ff12 HI = 00000000
¾
Cause = 00000024 BadVAddr= 00000000
LO = 00000000
Il messaggio scritto nel Messagge Window:
[0x00400024] 0x0000280d break $5
Exception occurred at PC=0x00400024
; 8: break 5
# genera break (parametro 5)
Osservazioni - Break
¾
¾
¾
La descrizione di break fa erroneamente intendere che
genera una eccezione arbitraria, specificata dal
parametro
In realtà, sia su un vero sistema che sul simulatore,
l’eccezione ggenerata è sempre
p la stessa: con Exception
p
Code 9
La codifica dell
dell’istruzione
istruzione non è conforme alla
specifica: considera solo i primi 5 bit del parametro e
li colloca a partire dal bit 11 su 5 bit (quindi 16
16-11)
11)
Exceptions.s
¾
¾
¾
¾
¾
Contiene il codice che gestisce le eccezioni
Si trova alla locazione fissa 0x80000180 in area ktext
riservata al sistema operativo
Dal momento che viene eseguito
g
dopo
p l’interruzione
di un programma utente in un punto qualsiasi, è tenuto
a preservare TUTTI i registri macchina
Ad esso sono riservati due registri $k0, $k1 che può
utilizzare senza doverne preservare i contenuti
Al termine del trattamento dell’eccezione
Exceptions.s ritorna al programma interrotto o
termina
i il programma
Exceptions s
Exceptions.s
¾
MIPS e quindi anche PCSPIM rileva e tratta le
eccezioni
i i PRIMA dell’esecuzione
d ll’
i
della
d ll istruzione
i
i
corrente:
• se l’eccezione corrente era una interruzione, l’esecuzione del
programma deve riprendere dall’istruzione corrente (salvata
nel registro EPC)
• se si tratta di un altro tipo di eccezione ed è possibile
proseguire (se non è avvenuto un errore irreparabile o si
tratta di un break), l’esecuzione deve riprendere
(
)
dall’istruzione successiva (EPC+4)
Esempio
p Exceptions.s
p
.kdata
save0: word 0
save1: word 0
.ktext 0x80000180
move $k1, $at
sw
sw
# kernel text segment
# used in pseudo-instructions
# iin the
th handler
h dl code
d
$v0, save0
$a0
$a0, save1
Salvataggio: salva lo stato
corrente dei
d i registri
i i
Esempio
p Exceptions.s
p
mfc0 $k0,
$k0 $13
# moves coprocessor 00’ss
# register 13 (Cause register)
# into CPU register $k0
Come si puo’ sapere se si tratta di una
eccezione o di una interruzione?
Esempio Exceptions.s
# Riconosce e distingue tra le eccezioni e gli interrupt
andi $a0, $k0, 0x007c
# Excp
E
mask:
k
0x007c
0 007 = 0000 0000 0111 1100
bgtz $a0, Excp_ret
# salta se ee' una eccezione (XXXX XXXX X000 00XX)
# Stampa
p Interrupt
p rilevato
li $v0, 4
la $a0, __m3_
syscall
ll
# print
i " IInterrupt “
# Gestione dell
dell'Interrupt
Interrupt da XXXX non trattata in questo esempio
IntXXXX:
...
EndIntXXXX:
Esempio Exceptions.s
Come si finisce di trattare una
interruzione?
Esempio Exceptions.s
# Rientro dalla gestione degli interrupt
# Si resetta il Cause register
mtc0 $0, $13
# Ripristino registri salvati
lw
$v0, save0
lw
$a0, save1
move $at, $k1
# Si preleva l'indirizzo di ritorno
# e salta all'indirizzo di ritorno
eret
# Return from exception handler
Esempio
p Exceptions.s
p
# Gestione delle eccezioni
Excp_ret:
# Stampa le info sulla eccezione
li
$v0,
$ 0 4
la $a0, __m1_
syscall
y
# pprint " Exception
p
"
li
$v0, 1
srl $a0,
$a0 $k0,
$k0 2
andi $a0, $a0, 0x1f
syscall
# shift right logical - estrae il Codice eccezione
# print Codice eccezione
li $v0, 4
lw $a0,
$a0 __excp($k0)
excp($k0)
syscall
# print stringa def eccezione
srl
$k0, $k0, 2
# estrae il Codice eccezione perche’
# era in $a0 che e’ stato sovracritto
E
Esempio
i Exceptions.s
E
ti
Excp_Break:
E
B k
bne $k0, 0x9, End_Excp_Break
li $v0,
$v0 4
la $a0, _brk_msg
y
syscall
j
# non è break
# syscall 4 (print
(print_str)
str)
# eccezione break!
End_Excp_Hnd
End_Excp_Break:
# Fine gestione break
Esempio
p Exceptions.s
p
# Gestione dell'eccezione "Bad address"
Excp_Bad_addr:
# Salta se non e' l'eccezione “Load from Bad address"
bne $k0, 0x4, End_Excp_Bad_addr
mfc0 $a0,
$a0 $8
# carica BadVAddr
andi $a0, $a0, 0x3 # E’ allineato alla word?
# Uno dei 2 bit è a 1?
beq $a0, $0, End_Excp_Hnd
li
$v0, 10
# Exit nel caso di "Bad address"
syscall
#10 – codice di EXIT
j
End_Excp_Hnd
End Excp Hnd
End Excp Bad addr:
End_Excp_Bad_addr:
# Fine gestione "Bad
Bad address"
address
Esempio Exceptions.s
End_Excp_Hnd:
mtc0 $0, $13
lw
$v0, save0
l
lw
$a0,
$a0 save1
sa e1
move $at, $k1
# Epilogo del gestore delle Eccezioni
# Si resetta il Cause register
# Si ripristina i registri salvati
# Si preleva l'indirizzo di ritorno e salta all'indirizzo di ritorno
mfc0 $k0, $14
# carica EPC in $k0
addi $k0, $k0, 4 # Ritorna alla istruzione successiva
mtc0 $k0, $14
eret
# Return from exception handler
Istruzioni di accesso ai registri del
co--processore 0
co
¾
¾
¾
mfc0 – move from coprocessor 0
mtc0 – move to coprocessor 0
eret – return from Exceptions.s
Exceptions s
Osservazione
¾
¾
eret – ritorna alla istruzione specificata in EPC
Eccezioni:
• si
s deve incrementare
c e e a e EPC
C di
d 4 e salvare
sa va e il nuovo
uovo valore
va o e
in EPC nel coprocessore
¾
Interruzioni:
• non si deve eseguire nessuna modifica
Esercizio 2
¾
Si chiede di modificare il codice
dell’Exceptions.s
p
in modo tale da stampare
p a
console il parametro dell’istruzione break
Bibliografia
¾
Appendice A – Sezione A.7
Interruzioni in PCSPIM
Input/Output
Interrupt
p
¾
¾
¾
Sono tipicamente causati da dispositivi hardware
esterni e collegati al processore attraverso delle linee di
esterni,
controllo di bus, come ad esempio le periferiche I/0
Q d lle periferiche
Quando
if i h sono pronte
t add effettuare
ff tt
operazioni impostano una linea di interruzione collegata
alla CPU
Quando viene attivata una linea di interruzione, se il
sistema
i
ha
h abilitato
bili
le
l interruzioni
i
i i della
d ll CPU, il
normale flusso di esecuzione viene interrotto, e la CPU
passa a gestire
i l’interrupt
l’i
Interrupt
p abilitati
¾
All’interno dell’interrupt mask (del Status Register)
ciascun bit corrisponde all
all’abilitazione
abilitazione di una differente
linea di interruzione collegata ad una o piu’ periferiche
• Se il bit è impostato a 1 il corrispondente interrupt è abilitato
e la periferica può generare una eccezione
• Se il bit è impostato
p
a 0 il corrispondente
p
interrupt
p NON è
abilitato e anche se la linea di interruzione è attivata dalla
periferica, la CPU non genera l’eccezione
¾
Quando
Q
d viene
i
sollevata
ll
una eccezione
i
a seguito
i di un
interruzione abilitata, nel registro Cause viene
impostato a 1 il bit corrispondente all
all’interruzione
interruzione
Interrupt
I t
t abilitati
bilit ti
Registro Cause
15
6
8
Interruzione
i
interrupt
pendenti
Registro Status
1
15
iinterrupt
t
t
mask
8
2
codice
eccezione
4
1 0
user
mode
interrupt
enable
exception
level
Input/Output
p
p
¾
¾
PCSPIM simula un terminale/console (una periferica
di I/O) che permette di visualizzare caratteri sul video
e leggere caratteri dalla tastiera
Il terminale è composto da due dispositivi distinti e
indipendenti:
• Transmitter: visualizza caratteri ASCII sulla Console
• Receiver: accetta caratteri ASCII dalla tastiera
¾
Osservazione: essendo indipendenti
indipendenti, un tasto premuto
sulla tastiera non viene automaticamente mostrato
sulla console;; un programma
p g
deve esplicitamente
p
fare
l’eco di un carattere letto dal Receiver inviandolo al
Transmitter
Input/Output
p
p
¾
In PCSPIM i dispositivi Receiver e Transmitter
sono controllati tramite 4 registri i cui contenuti
appaiano a specifici indirizzi di memoria:
•
•
•
•
¾
Receiver
R
i
Control
C
l
Receiver Data
T
Transmitter
C
Controll
Transmitter Data
00xFFFF0000
FFFF0000
0xFFFF0004
0 FFFF0008
0xFFFF0008
0xFFFF000c
Per utilizzare i dispositivi di I/O memory-mapped è
necessario abilitare l’opzione relativa nel Settings
di PCSPIM
Il Receiver: Receiver Control
Ready:
1 – carattere ricevuto dal Receiver
0 – nessun carattere ricevuto dal Receiver
1 0
Receiver Control
IInterrupt
t
t Enable:
E bl
1 – Interrupt Receiver Abilitati
0 – Interrupt Receiver Disabilitati
¾
¾
Il bit di Readyy è in sola lettura ((le scritture vengono
g
ignorate)
g
)
Il bit di Ready passa da 0 a 1 quando un carattere è arrivato
dalla tastiera, ma non è stato ancora pprelevato dal Receiver
Data
Il Receiver: Receiver Data
Receiver Data
7
0
Codice ASCII
del tasto premuto
¾
Il codice ASCII del tasto ppremuto è valido soltanto se
Ready = 1 (nel Receiver Control)
Il Transmitter:
s
e : Transmitter
s
e Control
Co o
Ready:
1 – Transmitter pronto ad inviare il prossimo carattere
0 – Transmitter occupato a scrivere il precedente carattere
1 0
Trasmitter Control
¾
¾
Interrupt Enable:
1 – Interrupt Transmitter Abilitati
0 – Interrupt Transmitter Disabilitati
Il bit di Ready è in sola lettura (le scritture vengono ignorate)
R d = 1 se il Transmitter
Ready
T
itt è pronto
t a scrivere
i
un nuovo
carattere, e “0” se è occupato a scrivere il carattere precedente
Il Transmitter: Transmitter Data
Transmitter Data
7
0
Codice ASCII
del carattere da stampare
¾
¾
È possibile stampare un carattere solo scrivendolo nel
T
Transmitter
itt Data
D t quando
d il bit di Ready
R d del
d l Transmitter
T
itt
Control è 1;
Altrimenti se il bit di Ready è zero il carattere non sarà
Altrimenti,
visualizzato e andrà perso
Tastiera
¾
¾
¾
È collegata alla linea di interruzione che fa capo
al bit 8 dei registri Status e Cause
Per abilitare le interruzioni dalla tastiera si abilita
il bit 8 del registro Status
Per scoprire se ll’interruzione
interruzione è stata provocata
dalla tastiera si verifica il valore del bit 8 nel
registro Cause
Esempio di uso Exceptions.s
# Il programma scrive una successione infinita di 0
# Alla pressione di un tasto stampa una stringa di avviso
# “ Interrupt “
.globl __start
.data
car0:
0 .asciiz
ii “0”
.text
__start:
start:
# Abilita gli interrupt in generale
mfc0 $t0, $12
# Leggi Status Register (12)
ori
$t0, $t0, 1
# Abilita in generale gli INT
ori
$t0, $t0, 0x100 # Abilita gli INT da Tastiera
mtc0
t 0 $t0,
$t0 $12
# Scrivi
S i i il nuovo Status
St t Register
R it
Esempio di uso Exceptions
Exceptions.ss
# Abilita gli interrupt dalla periferica I/O,
I/O dal Receiver
lw
$t1, 0xFFFF0000
# Leggi attuale Receiver Control
$$t1,, $$t1,, 2
# Abilita ggli INT da Receiver
ori
sw
$t1, 0xFFFF0000
# Scrivi il nuovo Receiver Control
Ready:
1 – carattere ricevuto dal Receiver
0 – nessun carattere
tt ricevuto
i
t dal
d l Receiver
R i
1 0
Receiver Control
Interrupt Enable:
1 – Interrupt Receiver Abilitati
0 – Interrupt Receiver Disabilitati
Esempio di uso Exceptions
Exceptions.ss
# Stampa in un ciclo infinito il carattere 0
ciclo:
la $a0, car0
# stringa “0"
li
$v0, 4
# print string
syscall
li $t0, 0x00000fff
perdi tempo:
perdi_tempo:
addi $t0, $t0, -1
bnez $t0, perdi_tempo
b
ciclo
# costante grande
# decrementa
# gira a vuoto
# ciclo infinito
Esempio di uso Exceptions
Exceptions.ss
# DISABILITA Interruzioni dal Receiver (tastiera)
lw $a0, 0xffff0000
# Leggi attuale Receiver Control
andi $a0, $a0, 0xfffd
# Azzera bit 1 = INT enable
sw $a0
$a0, 0xffff0000
# Scrivi nuovo Receiver Control
# DISABILITA Interrupt dalla tastiera nella CPU
mfc0 $a0, $12
# Leggi il CPU Status Reg.
andi $a0, $a0, 0xfeff
# Azzera il bit INT della tastiera
mtc0 $a0, $12
# Scrivi il nuovo CPU Status Reg.
Esercizio
¾
Si chiede di utilizzare il Receiver Control and
Data per leggere i caratteri inseriti dalla tastiera.
Si chiede di stampare il carattere inserito
utilizzando una syscall.
E
Esercizio
i i - Soluzione
S l i
.data
data
Fine: .ascii "q"
# carattere da premere per finire
Messaggio:
.ascii "Il tasto premuto e':"
# nota:
t questa
t stringa
ti
non e'' terminata
t
i t con byte
b t 0!
Carattere:
.asciiz "\n\n"
\n\n
# due a capo (il primo verra' sovrascritto)
.text
main:
Esercizio - Soluzione
li $t0, 0xFFFF0000
# Receiver Control
li $t2, 0xFFFF0004
# Receiver Data
lb $$t4,
4 Fi
Fine
# carattere per finire
fi i
BusyWaitRead:
# "busy wait"
lw $t1,
$t1 0($t0)
# Receiver Control Register
andi $t1, $t1, 0x1
# tiene solo il bit 0
q $t1, BusyWaitRead
y
# se e' 0, non e' ancora arrivato nulla
beqz
# Ready = 1, e' arrivato un carattere
lb $t3, 0($t2)
# legge byte dal Receiver Data
b
beq
$ 3 $t4,
$t3,
$ 4 fine
fi
# se e'' il tasto di fine,
fi escii
sb $t3, Carattere
# e lo salva in memoria
li $v0,
$v0 4
# Stampa il carattere con la syscall
la $a0, Messaggio
# il carattere e' incorporato !
syscall
# stampa con syscall
b BusyWaitRead
fine:
Esercizio
¾
Si chiede di modificare l’esercizio precedente
utilizzando gli interrupt per evitare di fare “busy wait”.
# Da inserire nel Exceptions.s nella gestione degli interrupt
IntKbd:
andi $a0, $k0, 0x0100
# Receiver
ece ve mask:
s : 00x0100
0 00 = 0000 000
0001 0000 0000
beq $a0, $0, EndIntKbd
# branch se e' interrupt ma non di Receiver
# E' interrupt del Receiver, quindi ...
# Stampa le info sull
sull'interrupt
interrupt
li
$v0, 4
la
$$a0,, __m5_
syscall
# print " by Receiver "
Exceptions.s
p
- Interrupt
p dalla tastiera
# DISABILITA Interruzioni dal Receiver (tastiera)
gg attuale Receiver Control
lw $a0, 0xFFFF0000
# Leggi
andi $a0, $a0, 0xfffd
# Azzera bit 1 = INT enable
sw $a0, 0xFFFF0000
# Scrivi nuovo Receiver Control
# DISABILITA Interrupt Receiver nella CPU
mfc0 $a0,
$a0 $12
# Leggi il CPU Status Reg.
Reg
andi $a0, $a0, 0xfeff
# Azzera il bit INT del Receiver
mtc0 $a0, $12
# Scrivi il nuovo CPU Status Reg.
g
# Gestione del char digitato
l
lw
$a0,
$ 0 0xFFFF0004
0 FFFF0004
# prelevo
l
il carattere
tt dal
d l Data
D t Reg.
R
sw $a0, BuffKbd
# e lo metto nel buffer comune
EndIntKbd:
Esempio uso Exceptions
Exceptions.ss
# Abilita interrupt della CPU
mfc0 $t0, $12
# Leggi il CPU Status Reg.
ori $t0,
$t0 $t0,
$t0 1
# abilita in generale gli INT
ori $t0, $t0, 0x100
# abilita il bit INT del Receiver
# Scrivi il nuovo CPU Status Reg.
g
mtc0 $$t0,, $$12
# Abilitazione Interrupt dal Receiver (tastiera)
lw $t1, 0xFFFF0000 # Leggi attuale Receiver Control Reg.
ori $t1, $t1, 2
# bit 1 = INT enable
sw $t1
$t1, 0xFFFF0000 # scrivi nuovo Receiver Control Reg.
Reg
Esercizi
Esercizio 1
¾
Dato il seguente frammento di codice, in quale punto
avviene
i
un'eccezione
'
i
di Overflow
O fl (considerando
(
id
d che
h
i numeri sono interi positivi in CA2)?
li $t0,
$ 0x7FFFFFFD
li $t1, 1
add $t0,
$t0 $t0,
$t0 $t1
add $t0, $t0, $t1
add $t0, $t0, $t1
add $t0, $t0, $t1
lw $t2, 0($t0)
b
break
k2
# riga 1
# riga 2
# riga 3
# riga 4
# riga 5
# riga
i 6
1.
2.
3.
4.
5.
6
6.
7.
Alla riga 1
Alla riga 2
Alla riga 3
Alla riga 4
Alla riga 5
Alla riga 6
Non avviene nessuna
eccezione
8. Nessuna delle altre
Esercizio 2
¾
Se il registro Cause assume il valore 0x0000 0024,
quale eccezione si è verificata?
1.
2.
3.
4
4.
5.
6
6.
7.
Break Exception
Syscall Exception
AdES (scrittura non allineata in memoria)
Ad (l
AdEL
(lettura non allineata
lli
da
d memoria)
i )
Interrupt Exception
O fl E
Overflow
Exception
ti
Nessuna delle altre
Esercizio 3
¾
Dato il seguente frammento di codice di un
Exceptions s specificare quale riga riconosce
Exceptions.s,
correttamente un'eccezione di tipo Interrupt.
...
mfc0 $k0, $13
# Cause register
srl $k0, $k0, 2
andi $k0,
$k0 $k0
$k0, 0x1f
Riga 1: bnez $k0, is_irq # riga 1
Riga 2: bgtz $k0, is_irq
# riga 2
Riga 3: bltz $k0, is_irq
# riga 3
Riga 4: beqz $k0, is_irq # riga 4
...
is_irq: # gestione Interrupt
1.
2.
3.
4.
5.
Alla riga
g 1
Alla riga 2
Alla riga 3
Alla riga 4
Nessuna delle altre
Esercizio 4
¾
Considerando che il programma è memorizzato partendo
dall’indirizzo 0x00400024 e i dati dall’indirizzo
0x10010000 si chiede:
• Quale istruzione genera l’eccezione?
• Cosa
C
i di il registro
indica
i t Cause?
C
?
• Quali valori assumono i registri EPC e BadVAddr?
.data
dato:
.word 33
.text
main:
la
$t0, dato
lw
$t1
$t1, 0($t0)
li
$t2, 1
add $t2, $t2, $t0
sw $t2
$t2, 0($t2)
jr
$ra