CALCOLATORI ELETTRONICI II
Roberto Palmieri
[email protected]
Orario
Mercoledì 10:15 – 11:45
PROGRAMMA PRELIMINARE
• Ripasso assembly PD32
• Integrazione PD32: Architettura e nuove
istruzioni I/0
• Implementazione di metodologie di I/O
• Progettazione Interfacce Input/Output
• Sviluppo driver
CALCOLATORI ELETTRONICI II
Ripasso Indirizzamenti CEI
dalle slide CEI Prof. Ciciani
Modi di indirizzamento
• Modi diretti
– Diretto con registro
– Immediato
– Assoluto
• Modi indiretti
–
–
–
–
–
Indiretto con registro
Indiretto con spiazzamento
Relativo
Indiretto con predecremento
Indiretto con postdecremento
dalle slide CEI Prof. Ciciani
Indirizzamento
a registro
Esempio: MOVL R1,R5 (significato: R1->R5)
dalle slide CEI Prof. Ciciani
Indirizzamento
immediato
• Il dato si trova in memoria immediatamente dopo l’istruzione
• Esempio: MOVL #0,R5 (significato: poni 0 in R5)
dalle slide CEI Prof. Ciciani
Indirizzamento
assoluto
• Esempio: MOVB R1,1280H (sposta il byte basso di R1 nella
cella di memoria di indirizzo 1280H.
• Tale valore, 1280H, è memorizzato dopo l’istruzione ed è
riferito da PC dopo che è stato incrementato)
• Effective address = 1280H
dalle slide CEI Prof. Ciciani
Indirizzamento
indiretto con registro
• Il registro contiene l’indirizzo dell’operando (corrisponde alla
nozione di puntatore nei linguaggi di programmazione)
• Esempio: MOVL (R5),R1 (significato: sposta in R1 in
contenuto della locazione il cui indirizzo è contenuto in R5)
Indirizzamento
dalle slide CEI Prof. Ciciani
indiretto con registro e
con predecremento
• Il registro, opportunamente decrementato, contiene
l’indirizzo dell’operando
• Esempio: MOVL R1,-(R7) (sposta nella locazione il cui
indirizzo è pari al contenuto in R7 meno 4 ciò che è
memorizzato in R1)
Indirizzamento
dalle slide CEI Prof. Ciciani
indiretto con registro e
con postincremento
• Il registro contiene l’indirizzo dell’operando, una volta
acceduto la memoria il registro viene opportunamente
incrementato
• Esempio: MOVL (R7)+,R1 (sposta in R1 quanto memorizzato
nella locazione il cui indirizzo è pari al contenuto in R7,
dopodiché incrementare di 4 ciò che è memorizzato in R7)
dalle slide CEI Prof. Ciciani
Indirizzamento
con spiazzamento
• L’indirizzo effettivo dell’operando è la somma di un valore
base (mem. in un reg.) con il valore di spiazzamento
• Esempio: MOVB D(R0),R1 (significato: sposta in R1 il
contenuto della cella con indirizzo D+R0)
Indirizzamento
dalle slide CEI Prof. Ciciani
relativo
• Usato nei salti, per consentire riferimenti relativi e caricare
il PC con valori differenti da quelli ottenuti con semplici
incrementi.
• Esempio: JMP LABEL(PC) (metti nel PC quanto ottenuto dalla
somma del contenuto della locazione il cui indirizzo è dato
dall’etichetta LABEL con il valore corrente del PC)
dalle slide CEI Prof. Ciciani
Indirizzamento
Riepilogo
org 400h
code
movl #20, r1
addl r1,r1
; r1=20, ind. immediato
; r1=40, ind. a registro
movb #0FFh, 800h
;mem[0x800]=0xFF, ind. assoluto
movl #800h,r2
;r2=0x800
movb #0EEh, (r2);mem[r2]=0xEE, ind. con registro
movb #0FFh, -(r2)
;r2=0x800-0x1=0x7FF, mem[0x7FF]=0xFF
;ind. con predecremento
movb #0AAh, (r2)+
;mem[0x7FF]=0xAA, r2=0x800
;ind. con postincremento
;mem[0x808]=0xFF, r2=0x800
;ind. con spiazzamento
movb #0FFh, 8(r2)
end
dalle slide CEI Prof. Ciciani
Confronto fra registri
Aritmetica non segnata
• CMPB R1,R2 (ipotesi: R1,R2>=0)
– Equivale ad eseguire R2-R1 senza aggiornare R2
CMPB R1,R2
Z=0
C=1
C=0
R2-R1<0
(R1>R2)
C=1 R1>R2
Z=1  R1=R2
C=0 and Z=0  R1<R2
Z=1
R2-R1>=0 R1=R2 R1<>R2
(R1<=R2)
Z=0
R1<R2
not
C=0 R1<=R2
Z=0  R1<>R2
Z=1 or C=1  R1>=R2
dalle slide CEI Prof. Ciciani
Confronto fra registri
Aritmetica segnata
R1,R2 rappresentati in complemento a 2
• CMPB R1,R2
Equivale ad eseguire R2-R1 senza aggiornare R2
N=V R1>=R2
N<>V  R1<=R2
CMPB R1,R2
Z=1
R2-R1=0
(R1=R2)
N=V
N<>V
Z=0
R2-R1>=0 R1<=R2 R1<>R2
(R2>=R1) Z=0
Z=0
R2>R1
R1<R2
Z=1  R1=R2
Z=0  R1<>R2
PD32 / 1 (esercizio)
Sintassi/Semantica Istruzioni:
MicroOpGen
Esercizio 1:
Sia dato un array formato da DIM longword, allocato in
memoria a partire dall’indirizzo 250H, costruire nella
posizione 278H l’array reverse.
PD32 / 1_1 (soluzione)
ORG 400H
;*********DichiarazioneCostanti*********
DIM EQU ?
ARRAY1 EQU 250H
ARRAY2 EQU 278H
; *********Corpo del Programma*********
CODE
PD32 / 1_2 (soluzione)
CODE
XORL R0,R0
XORL R1,R1
XORL R2,R2
MOVL #ARRAY1,R1
MOVL #ARRAY2,R2
MOVL #DIM,R0
ASLL #2,R0
ADDL R0,R2
MOVL #DIM,R0
REPEAT:
MOVL (R1)+,-(R2)
SUBL #1,R0
JNZ REPEAT
HALT
END
PD32 / 1_3 (soluzione)
CODE
XORL R0,R0
XORL R1,R1
XORL R2,R2
MOVL #ARRAY1,R1
MOVL #ARRAY2,R2
MOVL #DIM,R0
ASLL #2,R0
ADDL R0,R2
XORL R0,R0
REPEAT:
CMPL #DIM,R0
JZ FINE
MOVL (R1)+,-(R2)
ADDL #1,R0
JMP REPEAT
FINE:
HALT
END
PD32 / 1_4 (soluzione)
ATTEZIONE!!!!!
Se nella soluzione 2 non avessi spostato la
CMPL #DIM,R0 in testa al ciclo avrei
eseguito un ciclo ulteriore.......
QUALE SAREBBE STATO IL
RISULTATO?
(.....qualcuno si sarebbe arrabbiato)
PD32 / 1_5
Simulazione esercizio 1
DISSimulator......
PD32 / 2 (esercizio)
Sintassi/Semantica Istruzioni:
MicroOpGen
Esercizio 2:
Dato un vettore di 32 bytes unsigned memorizzato a
partire dalla locazione 0x20a0, calcolare la media
posizionandola nell’ultima posizione del vettore.
P.S. Si tenga sotto controllo l’eventuale overflow ed
in tal caso restituire il valore ff ff ff
PD32 / 2_1 (soluzione)
L’istruzione da controllare e’:
addb (R1)+, R2
Microcodice :
1.
MAR<-R1
2.
R1<-R1+1
3.
Temp1<-[MDR] 8 //gli 8 lsbs di MDR estesi in segno vanno in T1
4.
Temp2<-[R2] 8 //gli 8 lsbs di R2 estesi in segno vanno in T2
5.
ALU_OUT=Temp1+Temp2
Se (Temp1 + Temp2) >232-1 il CARRY bit viene settato per segnalare
l’overflow (…ricordate che i registri sono circolari). Quindi e’
sufficiente far seguire all’operazione di somma un salto condizionato
del tipo:
jc error
PD32 / 2_2 (soluzione)
org 400h
ARRAY
DIM
LOG2DIM
loop:
EQU 20a0h
EQU 32
EQU 5
; indirizzo base array
; num.elementi array
; log. base 2 di DIM
code
movl #DIM,R0
movl #ARRAY,R1
xorl R2,R2
;resetta R2, risultato parziale
addb (R1)+,R2
;somma i-esimo elem. i=0..DIM-1
jc error
;bit c settato =>Overflow
subl #1,R0
;decrementa contatore
jnz loop
;se contatore!=0 continua il cicla
lsrb #LOG2DIM, R2;dividi per il numero di elementi,
;usiamo LSRB poichè lavoriamo con unsigned
movb R2, -(R1)
;memorizza la media in ARRAY[DIM-1]
jmp fine
PD32 / 2_3 (soluzione)
error:
fine:
movl #DIM, R1
addl #ARRAY, R1
subl #1,r1
xorl R3,R3
notl R3,R3
movb R3,(R1)
halt
end
;gestione overflow, calcola in R1
; R1=ARRAY+DIM
; R3=111....111
; ARRAY[DIM]=11111111
PD32 / 3 (esercizio)
Sintassi/Semantica Istruzioni:
MicroOpGen
Esercizio 3:
Sia dato un array formato da DIM byte, allocato in memoria a
partire dall’indirizzo 250H e contenente numeri positivi e
negativi. Restituire:
– Min
– Max
P.S. I valori devo essere restituiti all’interno di variabili
PD32 / 3_1 (soluzione)
ORG 400H
;********* Dichiarazione Costanti *********
DIM EQU ?
IND_BASE EQU 250H
;********* Dichiarazione Variabili *********
CONT DL 0
MIN
DB 0
MAX
DB 0
PD32 / 3_2 (soluzione)
CODE
XORL R0,R0
XORL R1,R1
MOVB IND_BASE,MIN
MOVB IND_BASE,MAX
repeat:
MOVB IND_BASE(R0),R1
CMPB MAX,R1 ; R1 – MAX
JNC swapMax
CMPB MIN,R1 ;R1 – MIN
JNC swapMin
JMP agg
swapMax:
MOVB R1,MAX
JMP agg
swapMin:
MOVB R1,MIN
agg:
ADDL #1,R0
MOVL CONT,R2 ;!!!!
SUBL #1,R2
;!!!!
MOVL R2,CONT ;!!!!
JZ fine
JMP repeat
fine:
halt
end
PD32 / 4 (esercizio)
Sintassi/Semantica Istruzioni:
MicroOpGen
Esercizio 4:
dato un array di longword, ordinarlo in
maniera crescente implementando
l’algoritmo di ordinamento di selezione del
minino (Selection Sort)
PD32 / 4_1 (soluzione)
Algoritmo Pseudocodice Selection Sort
1. i=0
2. Min = V[m], m:{i,…,dim-1}
3. V[m] = V[i]; V[i] = Min
4. i++; Go To 2
PD32 / 4_2 (soluzione)
for (int i=0; i<DIM; i++) {
min = v[i];
posMin = i;
for (int j=i; j<DIM; j++)
if(v[j]<v[i]) {
min = v[j]
posMin = j
}
v[posMin] = v[i];
v[i] = min;
}
Algoritmo Java
PD32 / 4_3 (soluzione)
org 400h
ARRAY
DIM
EQU 200h
EQU ?
; indirizzo base array
; num.elementi array
code
XORL R0,R0 ;registro posizione di inizio della ricerca del minimo
XORL R1,R1 ;minimo temporaneo
XORL R4,R4 ;registro contenente il dato da nalizzare
iniziomin:
CMPB #DIM,R0 ;R0-DIM
JZ fine
XORL R3,R3 ;registro di spiazzamento
MOVL R0,R3 ;copio per usare R0 come spiazzamento
MOVB ARRAY(R3),R1 ;inizializzo il minimo parziale
PD32 / 4_4 (soluzione)
ciclomin:
CMPL #DIM,R3 ;R3-DIM
JZ finemin
MOVB ARRAY(R3) ,R4 ;R4 <= Valore corrente dell'array
ADDL #1,R3
CMPB R4,R1 ;R1-R4 se R4 < R1 allora Carry = 0 ed R4 è il nuovo minimo
JC ciclomin
MOVB R4,R1 ;swap minimo
MOVB R3,R5 ;mi salvo la posizione
JMP ciclomin
finemin:
SUBB #1,R5
MOVB ARRAY(R0),ARRAY(R5) ;swap con il valore da ordinare
MOVB R1,ARRAY(R0)
ADDL #1,R0 ;aumento la posizione del vettore
JMP iniziomin
fine:
halt
end