Scarica il file
zippato con tutti gli appunti z80
LD dd, (nn)
Con questa istruzione, il registro a 16 bit
dd è caricato con il contenuto della coppia di locazioni di memoria di
indirizzo nn ed nn+1.
La parte bassa del registro è caricata con
il contenuto della locazione nn mentre la parte alta è caricata con il
contenuto della locazione di indirizzo nn+1.
L’istruzione non ha alcun effetto sul
registro dei flag
Esempio:
LD
BC, (1B00h)
Prima
Dopo
IL registro dd può essere uno dei seguenti
BC
DE
HL
SP
IX
IY
LD (nn), dd
Con questa istruzione, la coppia di
locazioni di memoria di indirizzo nn ed nn+1 è caricato con il contenuto del
registro a 16 bit dd.
La locazione di indirizzo nn è caricata con
la parte bassa del registro dd e la locazione di indirizzo nn+1 è caricata con
il contenuto della parte alta del registro.
L’istruzione non ha alcun effetto sul
registro dei flag
Esempio:
LD
(1B00h), BC
Prima
Dopo
IL registro dd può essere uno dei seguenti
BC
DE
HL
SP
IX
IY
LD dd, nn
La coppia di registri a 16 bit viene
caricata con il dato immediato a 16 bit presente nell’istruzione.
L’istruzione non ha alcun effetto sul
registro dei flag
Esempio:
LD SP, 3C20h
Prima
Dopo
LD r, n
IL registro ad otto bit r viene caricato con
il dato ad otto bit immediatamente espresso nell’istruzione.
L’istruzione non ha alcun effetto sul
registro dei flag.
Esempio
LD
B, 23h
Prima
Dopo
IL registro r può essere uno dei
seguenti: A, B, C, D, E, H, L
Ld r, r’
Carica il registro ad otto bit r con il
contenuto del registro ad otto bit r’.
L’istruzione non ha alcun effetto sul
registro dei flag.
Esempio
LD
H, A
Prima
Dopo
IL registro r ed il registro r’ possono
essere uno dei seguenti: A, B, C, D, E,
H, L
LD (BC), A
IL contenuto dell’accumulatore viene
caricato in una locazione di memoria indirizzata in modo indiretto poiché il
suo indirizzo è contenuto nel registro BC. Da notare che il registro BC si può
usare per realizzare l’indirizzamento indiretto soltanto nei LOAD.
L’istruzione non ha alcun effetto sul
registro dei flag.
Esempio:
LD
(BC), A
Prima
Dopo
LD A, (BC)
L’accumulatore viene caricato con il
contenuto di una locazione di memoria indirizzata in modo indiretto poiché il
suo indirizzo è contenuto nel registro BC. Da notare che il registro BC si può
usare per realizzare l’indirizzamento indiretto soltanto nei LOAD.
L’istruzione non ha alcun effetto sul
registro dei flag.
Esempio:
LD
A, (BC)
Prima
Dopo
LD (DE), A
IL contenuto dell’accumulatore viene
caricato in una locazione di memoria indirizzata in modo indiretto poiché il
suo indirizzo è contenuto nel registro DE. Da notare che il registro DE si può
usare per realizzare l’indirizzamento indiretto soltanto nei LOAD.
L’istruzione non ha alcun effetto sul
registro dei flag.
Esempio:
LD
(DE), A
Prima
Dopo
LD A, (DE)
L’accumulatore viene caricato con il
contenuto di una locazione di memoria indirizzata in modo indiretto poiché il
suo indirizzo è contenuto nel registro DE. Da notare che il registro DE si può
usare per realizzare l’indirizzamento indiretto soltanto nei LOAD.
L’istruzione non ha alcun effetto sul
registro dei flag.
Esempio:
LD
A, (DE)
Prima
Dopo
LD (HL), n
La locazione di memoria il cui indirizzo è
contenuto nel registro HL (indirizzamento indiretto) viene caricata con il dato
ad otto bit n espresso direttamente nell’istruzione.
Esempio: LD
(HL), 18h
Prima
Dopo
LD (HL), r
La locazione di memoria il cui indirizzo è
contenuto nel registro HL (indirizzamento indiretto) viene caricata con il dato
ad otto bit contenuto nel registro r.
Esempio:LD
(HL), B
Prima
Dopo
LD r, (HL)
Il registro ad otto bit r viene caricato con
la locazione di memoria il cui indirizzo è contenuto nel registro HL
(indirizzamento indiretto).
Esempio:LD
B, (HL)
Prima
Dopo
LD r, (IX+d)
Il registro ad otto bit r viene caricato con
la locazione di memoria il cui indirizzo si ottiene sommando il contenuto nel
registro IX con lo piazzamento d
(indirizzamento indicizzato).
Esempio:LD
B, (IX+2)
Prima
Dopo
LD (IX+d), r
La locazione di memoria il cui indirizzo si
ottiene sommando il contenuto del registro IX e lo spiazzamento d
(indirizzamento indicizzato) viene caricata con il contenuto del registro ad
otto bit r
Esempio:LD
(IX+2), B
Prima
Dopo
LD r, (IY+d)
Il registro ad otto bit r viene caricato con
la locazione di memoria il cui indirizzo si ottiene sommando il contenuto nel
registro IY con lo piazzamento d
(indirizzamento indicizzato).
Esempio:LD
B, (IY+2)
Prima
Dopo
LD (IY+d), r
La locazione di memoria il cui indirizzo si
ottiene sommando il contenuto del registro IY e lo spiazzamento d
(indirizzamento indicizzato) viene caricata con il contenuto del registro ad
otto bit r
Esempio:LD
(IY+2), B
Prima
Dopo
LD (IX+d), n
La locazione di memoria il cui indirizzo si
ottiene sommando il contenuto nel registro IX con lo piazzamento d (indirizzamento indicizzato) viene caricata
con il dato ad otto bit espresso immediatamente nell’istruzione.
Esempio:LD (IX+2), 20h
Prima
Dopo
LD (IY+d), n
La locazione di memoria il cui indirizzo si
ottiene sommando il contenuto nel registro IY con lo piazzamento d (indirizzamento indicizzato) viene caricata
con il dato ad otto bit espresso immediatamente nell’istruzione.
Esempio:LD (IY+2), 20h
Prima
Dopo
LD A, (nn)
L’accumulatore viene caricato con il
contenuto della locazione di memoria il cui indirizzo è espresso direttamente
nell’istruzione (indirizzamento diretto).
Esempio:LD
A, (1A00)
Prima
Dopo
LD
(nn), A
La locazione di memoria il cui indirizzo è
espresso direttamente nell’istruzione (indirizzamento diretto), viene caricata
con il contenuto dell’accumulatore.
Esempio:LD
(1A00), A
Prima
Dopo
LD A, I
L’accumulatore viene caricato con il
contenuto del registro I
Prima
Dopo
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
O |
|
X |
O |
|
Il flag S viene settato a seconda del segno
del dato trasferito.
IL flag Z viene settato ad uno se il dato
trasferito è nullo, altrimenti viene posto a zero.
I flag H ed N vengono posti sempre a zero
IL falg P/V assume il valore del registro
IFF2
Gli altri flag non vengono modificati
LD I, A
IL registro I viene caricato con il
contenuto dell’accumulatore
Prima
Dopo
Modifiche al registro dei flag
Il registro dei flag non viene modificato
LD A, R
L’accumulatore viene caricato con il
contenuto del registro R
Prima
Dopo
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
O |
|
X |
O |
|
Il flag S viene settato a seconda del segno
del dato trasferito.
IL flag Z viene settato ad uno se il dato
trasferito è nullo, altrimenti viene posto a zero.
I flag H ed N vengono posti sempre a zero
IL falg P/V assume il valore del registro
IFF2
Gli altri flag non vengono modificati
LD R, A
IL registro R viene caricato con il
contenuto dell’accumulatore
Prima
Dopo
Modifiche al registro dei flag
Il registro dei flag non viene modificato
LD SP, dd
Lo Stack Pointer viene caricato con il
contenuto del registro a sedici bit dd.
Il registro dd può essere uno dei seguenti:
HL, IX, IY.
Non viene modificato il registro dei flag.
Esempio:LD
SP, IX
Prima
Dopo
LDD
Questa istruzione viene utilizzata quando si
vuole trasferire un blocco di dati da una zona all’altra della memoria
In questo caso occorrono
un
puntatore alla zona di memoria sorgente dei dati, cioè un registro a 16 bit
contenente l’indirizzo della locazione da cui prelevare il dato che è il
registro HL,
un
puntatore alla zona di memoria destinazione dei dati, cioè un registro a 16 bit
contenente l’indirizzo della locazione in cui spostare il dato, che è il
registro DE
un
registro che faccia da contatore per conoscere quando sarà stato terminato il
processo di trasferimento dei dati, che è il registro BC
In questa istruzione si parte dalle
locazioni di indirizzo più elevato e si prosegue verso le locazioni di
indirizzo più basso.
Ogni volta che viene eseguita
l’istruzione viene letto il dato
contenuto nella locazione puntata da HL, viene trasferito nella locazione puntata
da DE, vengono decrementati Hl, DE ed il contatore BC.
(DE)ß (HL)
DE=DE-1
HL=HL-1
BC=BC-1
Esempio
Prima
Dopo
Effetto sul registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
O |
|
X |
O |
|
IL
flag H ed il flag N sono posti a zero
IL
flag P/V viene utilizzato per sapere se si è completato il trasferimento dei
dati, cioè se il contatore BC è arrivato a zero. Infatti se BC è diverso da
zero dopo l’esecuzione dell’istruzione, il flag è posto ad uno, se BC è
arrivato a zero , il flag viene posto a zero.
LDDR
Con l’istruzione LDD viene trasferito
soltanto un dato. Per effettuare il trasferimento di tutto il blocco di dati
occorre inserire l’istruzione in un ciclo, in modo da farne ripetere
l’esecuzione fino a che il contatore BC non giunga a zero.
Esempio
LD HL , 1A63 ; limite blocco sorgente
LD DE, 1B63 ; limite blocco destinazione
LD BC, 0004 ; caricamento contatore
ET:
LDD
JP PE, ET ; PE =effettua il
salto se P/V=1
Alternativamente si può utilizzare
l’istruzione LDDR. Quest’istruzione esegue tutte le funzioni dell’istruzione
LDD (trasferimento di un dato dal blocco sorgente al blocco destinazione,
decremento dei puntatori DE ed Hl e del contatore BC) non una sola volta ma
iterativamente fino a che il contatore non si sia azzerato.
Esempio: trasferimento di un blocco di
quattro byte; blocco sorgente dall’indirizzo 1A60h all’indirizzo 1A63h; blocco
destinazione dall’indirizzo 1B60h all’indirizzo 1B63h
Prima
Dopo
Effetto sul registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
O |
|
O |
O |
|
IL
flag H, il flag PV ed il flag N sono posti a zero
LDI
Questa istruzione viene utilizzata quando si
vuole trasferire un blocco di dati da una zona all’altra della memoria
In questo caso occorrono
un
puntatore alla zona di memoria sorgente dei dati, cioè un registro a 16 bit
contenente l’indirizzo della locazione da cui prelevare il dato che è il
registro HL,
un
puntatore alla zona di memoria destinazione dei dati, cioè un registro a 16 bit
contenente l’indirizzo della locazione in cui spostare il dato, che è il
registro DE
un
registro che faccia da contatore per conoscere quando sarà stato terminato il
processo di trasferimento dei dati, che è il registro BC
In questa istruzione si parte dalle
locazioni di indirizzo più basso e si prosegue verso le locazioni di indirizzo
più elevato.
Ogni volta che viene eseguita
l’istruzione viene letto il dato
contenuto nella locazione puntata da HL, viene trasferito nella locazione
puntata da DE, vengono incrementati Hl, DE e decrementato il contatore BC.
(DE) ß
(HL)
DE=DE+1
HL=HL+1
BC=BC-1
Esempio
Prima
Dopo
Effetto sul registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
O |
|
X |
O |
|
IL
flag H ed il flag N sono posti a zero
IL
flag P/V viene utilizzato per sapere se si è completato il trasferimento dei
dati, cioè se il contatore BC è arrivato a zero. Infatti se BC è diverso da
zero dopo l’esecuzione dell’istruzione, il flag è posto ad uno, se BC è
arrivato a zero , il flag viene posto a zero.
LDIR
Con l’istruzione LDI viene trasferito
soltanto un dato. Per effettuare il trasferimento di tutto il blocco di dati
occorre inserire l’istruzione in un ciclo, in modo da farne ripetere
l’esecuzione fino a che il contatore BC non giunga a zero.
Esempio
LD HL , 1A60 ; limite inferiore blocco
sorgente
LD DE, 1B60 ; limite blocco destinazione
LD BC, 0004 ; caricamento contatore
ET:
LDI
JP PE, ET ; PE =effettua il
salto se P/V=1
Alternativamente si può utilizzare
l’istruzione LDIR. Quest’istruzione esegue tutte le funzioni dell’istruzione
LDD (trasferimento di un dato dal blocco sorgente al blocco destinazione,
incremento dei puntatori DE ed Hl e decremento del contatore BC) non una sola
volta ma iterativamente fino a che il contatore non si sia azzerato.
Esempio: trasferimento di un blocco di
quattro byte; blocco sorgente dall’indirizzo 1A60h all’indirizzo 1A63h; blocco
destinazione dall’indirizzo 1B60h all’indirizzo 1B63h
Prima
Dopo
Effetto sul registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
O |
|
O |
O |
|
IL
flag H, il flag PV ed il flag N sono posti a zero
PUSH qq
Con quest’istruzione la coppia di registri o
registro a 16 bit qq viene spinta in cima allo stack. Ricordiamo che lo Stack
Pointer punta all’ultima locazione riempita dello stack e che questo cresce
occupando le locazioni di memoria che hanno indirizzo via via decrescente.
Allora la parte alta del registro qq va
nella prima locazione libera, quindi nella locazione il cui indirizzo si
ottiene dall’indirizzo contenuto in SP meno uno, mentre la parte bassa di qq va
nella locazione successiva, quindi nella locazione il cui indirizzo si ottiene
dall’indirizzo contenuto in SP meno due. Poiché lo stack cresce di due
locazioni, lo Stack Pointer va decrementato di due unità
Non si ha alcun effetto sul registro dei
flag.
Esempio: PUSH
DE
Prima
Dopo
qq può essere uno dei seguenti registri: BC;
DE; HL; AF; IX; IY
POP qq
Con quest’istruzione la coppia di registri o
registro a 16 bit qq viene riempita con il contenuto delle due locazioni di
memoria in cima allo. Ricordiamo che lo Stack Pointer punta all’ultima
locazione riempita dello stack e che questo cresce occupando le locazioni di
memoria che hanno indirizzo via via decrescente.
Allora la parte alta del registro qq viene
riempita con il contenuto della penultima locazione occupata, quindi nella
locazione il cui indirizzo si ottiene dall’indirizzo contenuto in SP più uno,
mentre la parte bassa di qq viene riempita con il contenuto della locazione
successiva, quindi nella locazione il cui indirizzo si ottiene dall’indirizzo
contenuto in SP. Poiché lo stack decresce di due locazioni, lo Stack Pointer va
incrementato di due unità
Non si ha alcun effetto sul registro dei
flag.
Esempio: POP
DE
Prima
Dopo
qq può essere uno dei seguenti registri: BC;
DE; HL; AF; IX; IY
EX AF, AF’
L'istruzione scambia il contenuto dei registri A ed F
con A' ed F'
Esempio:
Contenuto dei registri prima
dell'esecuzione dell'operazione EX
Contenuto dei registri dopo
l'esecuzione dell'istruzione EX
EXX
L'istruzione EXX consente di
scambiare il contenuto dei registri BC, DE, HL e dei registri BC', DE', HL'.
Esempio.
Prima
Dopo
EX DE, HL
Questa istruzione scambia il contenuto dei
registri DE ed HL
Esempio Prima
Dopo
EX (SP), dd
Il contenuto del registro a 16 bit dd viene
scambiato con le due locazioni di memoria che stanno in cima allo stack
La parte bassa del registro viene scambiata
con la locazione puntata dallo SP, la parte alta del registro viene scambiata
con la locazione il cui indirizzo è dato da SP+1. Il registro dd può essere:
HL, IX, IY. Poiché l’ampiezza dello stack non viene modificata in quanto non si
aggiungono dati nelle locazioni vuote, né si prelevano dati svuotando
locazioni, lo SP rimane inalterato.
L’istruzione non ha alcun effetto sul
registro dei flag.
Esempio:EX
(SP), IY
Prima
Dopo
CP A, s
Con quest’istruzione viene confrontato il
contenuto dell’accumulatore con l’operando s. L’istruzione serve, ad esempio,
se si vuole ricercare un dato in una zona di memoria, allora si pone
nell’accumulatore il dato da cercare mentre come operatore s considereremo le
varie locazioni della zona di memoria in cui stiamo effettuando la ricerca. Se
l’operazione di confronto da un esito positivo vuol dire che vi è una locazione
il cui contenuto coincide con quello dell’accumulatore, cioè in quella
locazione esiste il dato cercato.
L’operazione di confronto viene effettuata
dallo Z80 con un’operazione di sottrazione di cui, però, non viene memorizzato
il risultato. La sottrazione viene effettuato soltanto perché in questomodo
verrà modificato il registro dei flag. Se il flag Z sarà settato ad 1 vorrà
dire che la sottrazione avrà dato un risultato nullo e quindi il contenuto
dell’accumulatore sarà identico al contenuto dell’operando s. Controllando il
flag S potremo invece sapere se il contenuto dell’accumulatore è maggiore o
minore di quello dell’operando s. Infatti, se S= 0, la sottrazione ha dato un
risultato positivo per cui il contenuto dell’accumulatore è maggiore di quello
dell’operando s, se S= 1 l’operazione ha dato risultato negativo il che vuol
dire che il contenuto dell’accumulatore è minore di quello dell’operando s.
L’operando s può essere uno dei seguenti:
|
CP r |
Indirizzamento a registro |
Si sottrae all’accumulatore il contenuto
del registro ad otto bir r (A, B, C, D, E, H, L) |
|
CP n |
Indirizzamento immediato |
Si sottrae all’accumulatore il contenuto
del dato ad otto bit immediatamente espresso nell’istruzione |
|
CP (HL) |
Indirizzamento indiretto |
Si sottrae all’accumulatore il contenuto
della locazione di memoria il cui indirizzo è dato dal contenuto del registro
HL |
|
CP
(IX+d) |
Indirizzamento indicizzato |
Si sottrae all’accumulatore il contenuto
della locazione di memoria il cui indirizzo è dato dal contenuto del registro
IX sommato allo spiazzamento d espresso nell’istruzione |
|
CP
(IY+d) |
Indirizzamento indicizzato |
Si sottrae all’accumulatore il contenuto
della locazione di memoria il cui indirizzo è dato dal contenuto del registro
IY sommato allo spiazzamento d espresso nell’istruzione |
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
|
|
|
1 |
|
IL flag N è posto sempre ad uno, gli altri
flag dipendono dal risultato della sottrazione.
Esempio: CP B
Prima
Dopo
Per capire l’esempio ricordiamo che
96|16
= 10010110|2
quindi rappresenta un numero negativo
essendo l’MSB pari ad 1 mentre
42|16
= 01000010|2
per cui il dato contenuto nell’accumulatore
è minore di quello contenuto nel registro B.
Esempio CP (HL)
Prima
Dopo
Esempio CP
(IX+1)
Prima
Dopo
Per capire l’esempio ricordiamo che
96|16
= 10010110|2
quindi rappresenta un numero negativo
essendo l’MSB pari ad 1 mentre
3A|16
= 00111010|2
quindi il risultato sarà negativo (S=1) e vi
sarà un prestito dal nibble superiore al nibble inferiore (H=1)
Esempio CP
3A
Prima
Dopo
CPD
Questa istruzione è molto utile quando si
vuole ricercare un dato in un blocco di memoria. In A si pone il dato da
cercare, l’accumulatore viene poi confrontato con le locazioni di memoria , il
registro HL funge da puntatore poiché contiene di volta in volta l’indirizzo
della locazione il cui contenuto si vuole confrontare con l’accumulatore,
occorre poi un contatore in modo da sapere quando si è completato il confronto
con tutte le locazioni di memoria appartenenti al blocco, il contatore è il
registro BC. Con questa istruzione il confronto avviene partendo dalle
locazioni di indirizzo più alto a decrescere.
Quando viene eseguita quest’istruzione
l’accumulatore viene confrontato con il contenuto della locazione il cui indirizzo
è contenuto nel registro HL. Poi vengono decrementati il puntatore HL ed il
contatore BC.
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
x |
|
|
|
x |
1 |
|
Il flag Z ad uno indica che si è trovata una
locazione il cui contenuto è uguale a quello dell’accumulatore. Il flag PV
posto a zero indica che il contatore BC si è azzerato ed è quindi terminato il
controllo del blocco di dati.
Esempio
Prima
Dopo
Z va a uno poiché il dato contenuto nell’accumulatore
coincide con il contenuto della locazione di memoria puntata da HL, PV è 1
poiché il registro BC non si è azzerato.
CPDR
L’istruzione precedente necessita di essere
inserita all’interno di un ciclo per poter essere eseguita su tutto il blocco
di memoria in cui si vuole ricercare il dato. Alternativamente si può
utilizzare l’istruzione CPDR, questa istruzione esegue tutte le azioni di CPD,
ma a differenza di essa, le ripete fino a che si azzera il contatore oppure
appena trova una locazione contenente lo stesso dato dell’accumulatore.
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
x |
|
|
|
x |
1 |
|
Il flag Z è posto ad 1 se A=(HL)
IL flag PV è posto a 0 se BC=0 dopo
l’esecuzione, altrimenti è posto ad 1
CPI
Questa istruzione è molto utile quando si
vuole ricercare un dato in un blocco di memoria. In A si pone il dato da
cercare, l’accumulatore viene poi confrontato con le locazioni di memoria , il
registro HL funge da puntatore poiché contiene di volta in volta l’indirizzo della
locazione il cui contenuto si vuole confrontare con l’accumulatore, occorre poi
un contatore in modo da sapere quando si è completato il confronto con tutte le
locazioni di memoria appartenenti al blocco, il contatore è il registro BC. Con
questa istruzione il confronto avviene partendo dalle locazioni di indirizzo
più basso a crescere.
Quando viene eseguita quest’istruzione
l’accumulatore viene confrontato con il contenuto della locazione il cui
indirizzo è contenuto nel registro HL. Poi viene incrementato il puntatore HL e
decrementato il contatore BC.
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
x |
|
|
|
x |
1 |
|
Il flag Z ad uno indica che si è trovata una
locazione il cui contenuto è uguale a quello dell’accumulatore. Il flag PV
posto a zero indica che il contatore BC si è azzerato ed è quindi terminato il
controllo del blocco di dati.
Esempio
Prima
Dopo
Z va a uno poiché il dato contenuto
nell’accumulatore coincide con il contenuto della locazione di memoria puntata
da HL, PV è 1 poiché il registro BC non si è azzerato.
CPIR
L’istruzione precedente necessita di essere
inserita all’interno di un ciclo per poter essere eseguita su tutto il blocco
di memoria in cui si vuole ricercare il dato. Alternativamente si può
utilizzare l’istruzione CPIR, questa istruzione esegue tutte le azioni di CPD,
ma a differenza di essa, le ripete fino a che si azzera il contatore oppure
appena trova una locazione contenente lo stesso dato dell’accumulatore.
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
x |
|
|
|
x |
1 |
|
Il flag Z è posto ad 1 se A=(HL)
IL flag PV è posto a 0 se BC=0 dopo
l’esecuzione, altrimenti è posto ad 1
ADC A, s
Quest’istruzione esegue la somma fra il
contenuto dell’accumulatore, il secondo operando s ed il flag di carry
|
ADC A, r |
Indirizzamento a registro |
Si somma all’accumulatore il contenuto del
registro ad otto bit r (A, B, C, D, E, H, L) |
|
ADC A, n |
Indirizzamento immediato |
Si somma all’accumulatore il contenuto del
dato ad otto bit immediatamente espresso nell’istruzione |
|
ADC A, (HL) |
Indirizzamento indiretto |
Si somma all’accumulatore il contenuto
della locazione di memoria il cui indirizzo è dato dal contenuto del registro
HL |
|
ADC A, (IX+d) |
Indirizzamento indicizzato |
Si somma all’accumulatore il contenuto
della locazione di memoria il cui indirizzo è dato dal contenuto del registro
IX sommato allo spiazzamento d espresso nell’istruzione |
|
ADC A,(IY+d) |
Indirizzamento indicizzato |
Si somma all’accumulatore il contenuto
della locazione di memoria il cui indirizzo è dato dal contenuto del registro
IY sommato allo spiazzamento d espresso nell’istruzione |
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
|
|
|
0 |
|
Il
flag S verrà settato a seconda del segno del risultato
Il
flag Z verrà settato se il risultato è nullo
Il
flag H verrà settato se vi sarà un riporto fra il quarto e il quinto bit
Il
flag PV verrà settato se vi sarà un errore di overflow
Il
flag N è a zero trattandosi di una somma
Il
flag c verrà settato se vi è un riporto sull’ottavo bit
Esempio: ADC
A, 1A
Prima
Il contenuto del registro dei flag è
dispari. Ciò vuol dire che il bit meno significativo (il flag di carry) è pari
ad uno.
|
0 |
0 |
0 |
0 |
0 |
1 |
1 |
0 |
+
|
0 |
0 |
0 |
1 |
1 |
0 |
1 |
0 |
+
|
|
|
|
|
|
|
|
1 |
=
|
0 |
0 |
1 |
0 |
0 |
0 |
0 |
1 |
Abbiamo il riporto fra il primo ed il
secondo nibble, per cui H=1, il risultato è positivo per cui S=0, il risultato
è non nullo per cui Z=0, non vi è un riporto sull’ottavo bit per cui C=0, il
risultato rientra nel range –128/+127 per cui PV=0.
Dopo
ADC HL, ss
Quest’istruzione esegue la somma fra il
contenuto del registro a 16 bit HL, il secondo operando ss ed il flag di carry.
Il secondo operando può essere soltanto un registro a 16 bit: BC, DE, HL, SP.
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
|
|
|
0 |
|
Il
flag S verrà settato a seconda del segno del risultato
Il
flag Z verrà settato se il risultato è nullo
Il
flag H verrà settato se vi sarà un riporto fra l’undicesimo ed il dodicesimo
bit
Il
flag PV verrà settato se vi sarà un errore di overflow
Il
flag N è a zero trattandosi di una somma
Il
flag C verrà settato se vi è un riporto sul sedicesimo bit
Esempio: ADC
HL, DE
Prima
Dopo
ADD A, s
Quest’istruzione esegue la somma fra il
contenuto dell’accumulatore e il secondo operando s.
|
ADD A, r |
Indirizzamento a registro |
Si somma all’accumulatore il contenuto del
registro ad otto bit r (A, B, C, D, E, H, L) |
|
ADD A, n |
Indirizzamento immediato |
Si somma all’accumulatore il contenuto del
dato ad otto bit immediatamente espresso nell’istruzione |
|
ADD A, (HL) |
Indirizzamento indiretto |
Si somma all’accumulatore il contenuto
della locazione di memoria il cui indirizzo è dato dal contenuto del registro
HL |
|
ADD A,(IX+d) |
Indirizzamento indicizzato |
Si somma all’accumulatore il contenuto
della locazione di memoria il cui indirizzo è dato dal contenuto del registro
IX sommato allo spiazzamento d espresso nell’istruzione |
|
ADD A,(IY+d) |
Indirizzamento indicizzato |
Si somma all’accumulatore il contenuto
della locazione di memoria il cui indirizzo è dato dal contenuto del registro
IY sommato allo spiazzamento d espresso nell’istruzione |
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
|
|
|
0 |
|
Il
flag S verrà settato a seconda del segno del risultato
Il
flag Z verrà settato se il risultato è nullo
Il
flag H verrà settato se vi sarà un riporto fra il quarto e il quinto bit
Il
flag PV verrà settato se vi sarà un errore di overflow
Il
flag N è a zero trattandosi di una somma
Il
flag C verrà settato se vi è un riporto sull’ottavo bit
Esempio ADD
A, (HL)
Prima
Dopo
E’ stata effettuata la somma fra il
contenuto dell’accumulatore pari a 02h ed il contenuto della
locazione d’indirizzo 9620h (contenuto in HL) pari a B1h
02|16 = 00000010|10 +
B1|16= 10110001|10 =
B3|16= 10110011|10
Il risultato è negativo (S=1), diverso da
zero (Z=0), non vi è stato un riporto fra il nibble inferiore ed il nibble
superiore (H=0), senza overflow (PV=0), sena riporto (C=0). Essendo
un’addizione N=0.
ADD HL, ss
Quest’istruzione esegue la somma fra il
contenuto del registro a 16 bit HL ed il secondo operando ss. Il secondo
operando può essere soltanto un registro a 16 bit: BC, DE, HL, SP.
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
|
|
|
0 |
|
Il
flag S verrà settato a seconda del segno del risultato
Il
flag Z verrà settato se il risultato è nullo
Il
flag H verrà settato se vi sarà un riporto fra l’undicesimo ed il dodicesimo
bit
Il
flag PV verrà settato se vi sarà un errore di overflow
Il
flag N è a zero trattandosi di una somma
Il
flag C verrà settato se vi è un riporto sul sedicesimo bit
Esempio: ADD
HL, DE
Prima
Dopo
ADD IX, rr
Quest’istruzione esegue la somma fra il
contenuto del registro a 16 bit IX ed il secondo operando ss. Il secondo
operando può essere soltanto un registro a 16 bit: BC, DE, HL, SP.
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
|
|
|
0 |
|
Il
flag S non viene modificato
Il
flag Z non viene modificato
Il
flag H verrà settato se vi sarà un riporto fra l’undicesimo ed il dodicesimo
bit
Il
flag PV non viene modificato
Il
flag N è a zero trattandosi di una somma
Il
flag C verrà settato se vi è un riporto sul sedicesimo bit
Esempio: ADD
IX, SP
Prima
Dopo
ADD IY, rr
Quest’istruzione esegue la somma fra il
contenuto del registro a 16 bit IY ed il secondo operando ss. Il secondo operando
può essere soltanto un registro a 16 bit: BC, DE, HL, SP.
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
|
|
|
0 |
|
Il
flag S non viene modificato
Il
flag Z non viene modificato
Il
flag H verrà settato se vi sarà un riporto fra l’undicesimo ed il dodicesimo
bit
Il
flag PV non viene modificato
Il
flag N è a zero trattandosi di una somma
Il
flag C verrà settato se vi è un riporto sul sedicesimo bit
Esempio: ADD
IY, SP
Prima
Dopo
INC
s
Quest’istruzione esegue l’incremento di
un’unità del contenuto dell’ operando s.
|
INC r |
Indirizzamento a registro |
Si incrementa il contenuto del registro ad
otto bit r (A, B, C, D, E, H, L) |
|
INC (HL) |
Indirizzamento indiretto |
Si incrementa il contenuto della locazione
di memoria il cui indirizzo è dato dal contenuto del registro HL |
|
INC (IX+d) |
Indirizzamento indicizzato |
Si incrementa il contenuto della locazione
di memoria il cui indirizzo è dato dal contenuto del registro IX sommato allo
spiazzamento d espresso nell’istruzione |
|
INC (IY+d) |
Indirizzamento indicizzato |
Si incrementa il contenuto della locazione
di memoria il cui indirizzo è dato dal contenuto del registro IY sommato allo
spiazzamento d espresso nell’istruzione |
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
|
|
|
0 |
|
Il
flag S verrà settato a seconda del segno del risultato
Il
flag Z verrà settato se il risultato è nullo
Il
flag H verrà settato se vi sarà un riporto fra il quarto e il quinto bit
Il
flag PV verrà settato se vi sarà un errore di overflow
Il
flag N è a zero trattandosi di una somma
Il
flag C non viene modificato
INC rr
Quest’istruzione esegue l’incremento di
un’unità del contenuto del registro a 16 bit rr. Esso può essere BC, DE, HL,
SP, IX, IY
Non ha effetto sul registro dei flag
SBC A, s
Quest’istruzione esegue la sottrazione fra
il contenuto dell’accumulatore, il secondo operando s ed il flag di carry
|
SBC A, r |
Indirizzamento a registro |
Si sottrae all’accumulatore il contenuto
del registro ad otto bit r (A, B, C, D, E, H, L) |
|
SBC A, n |
Indirizzamento immediato |
Si sottrae all’accumulatore il contenuto
del dato ad otto bit immediatamente espresso nell’istruzione |
|
SBC A, (HL) |
Indirizzamento indiretto |
Si sottrae all’accumulatore il contenuto
della locazione di memoria il cui indirizzo è dato dal contenuto del registro
HL |
|
SBC A, (IX+d) |
Indirizzamento indicizzato |
Si sottrae all’accumulatore il contenuto
della locazione di memoria il cui indirizzo è dato dal contenuto del registro
IX sommato allo spiazzamento d espresso nell’istruzione |
|
SBC A,(IY+d) |
Indirizzamento indicizzato |
Si sottrae all’accumulatore il contenuto
della locazione di memoria il cui indirizzo è dato dal contenuto del registro
IY sommato allo spiazzamento d espresso nell’istruzione |
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
|
|
|
1 |
|
Il
flag S verrà settato a seconda del segno del risultato
Il
flag Z verrà settato se il risultato è nullo
Il
flag H verrà settato se vi sarà un prestito fra il quinto e il quarto bit
Il
flag PV verrà settato se vi sarà un errore di overflow
Il
flag N è a uno trattandosi di una sottrazione
Il
flag C verrà settato se vi è un prestito sull’ottavo bit
Esempio: SBC
A, (HL)
Prima
Dopo
Infatti viene effettuata la sottrazione
B2-
0F-
1=
A2
Questa sottrazione comporta un prestito dal nibble superiore al nibble
inferiore per cui sarà H=1, inoltre il risultato sarà negativo (infatti A2|16=10100010
quindi l’MSB è pari ad uno per cui è la rappresentazione di un numero negativo)
SUB A, s
Quest’istruzione esegue la sottrazione fra
il contenuto dell’accumulatore ed il secondo operando s
|
SUB A, r |
Indirizzamento a registro |
Si sottrae all’accumulatore il contenuto
del registro ad otto bit r (A, B, C, D, E, H, L) |
|
SUB A, n |
Indirizzamento immediato |
Si sottrae all’accumulatore il contenuto
del dato ad otto bit immediatamente espresso nell’istruzione |
|
SUB A, (HL) |
Indirizzamento indiretto |
Si sottrae all’accumulatore il contenuto
della locazione di memoria il cui indirizzo è dato dal contenuto del registro
HL |
|
SUB A, (IX+d) |
Indirizzamento indicizzato |
Si sottrae all’accumulatore il contenuto
della locazione di memoria il cui indirizzo è dato dal contenuto del registro
IX sommato allo spiazzamento d espresso nell’istruzione |
|
SUB A,(IY+d) |
Indirizzamento indicizzato |
Si sottrae all’accumulatore il contenuto
della locazione di memoria il cui indirizzo è dato dal contenuto del registro
IY sommato allo spiazzamento d espresso nell’istruzione |
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
|
|
|
1 |
|
Il
flag S verrà settato a seconda del segno del risultato
Il
flag Z verrà settato se il risultato è nullo
Il
flag H verrà settato se vi sarà un prestito fra il quinto e il quarto bit
Il
flag PV verrà settato se vi sarà un errore di overflow
Il
flag N è a uno trattandosi di una sottrazione
Il
flag C verrà settato se vi è un prestito sull’ottavo bit
Esempio: SUB
A, (HL)
Prima
Dopo
Infatti viene effettuata la sottrazione
B2-
0F=
A3
Questa sottrazione comporta un prestito dal nibble superiore al nibble
inferiore per cui sarà H=1, inoltre il risultato sarà negativo (infatti A3|16=10100011
quindi l’MSB è pari ad uno per cui è la rappresentazione di un numero negativo)
SBC HL, ss
Questa istruzione esegue la sottrazione fra
il contenuto del registro Hl, il contenuto del regiastro a 16 bit ss ed il flag
di Carry. Il risultato viene memorizzato in HL
HL ßHL-ss-FC
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
|
|
|
1 |
|
Il
flag S verrà settato a seconda del segno del risultato
Il
flag Z verrà settato se il risultato è nullo
Il
flag H verrà settato se vi sarà un prestito fra il terdicesimo e il dodicesimo
bit
Il
flag PV verrà settato se vi sarà un errore di overflow
Il
flag N è a uno trattandosi di una sottrazione
Il
flag C verrà settato se vi è un prestito sul sedicesimo bit
Esempio: SBC
HL, DE
Prima
Dopo
Poiché inizialmente nel registro dei flag vi
è un numero pari (66) vuol dire che l’LSB corrispondente al flag di carry è
pari a zero. Il risultato è un numero positivo (S=0, Z=0), vi è un prestito dal
quarto al terzo nibble (H=1), N=1 poiché è una sottrazione.
DEC
s
Quest’istruzione esegue il decremento di
un’unità del contenuto dell’ operando s.
|
DEC r |
Indirizzamento a registro |
Si decrementa il contenuto del registro ad
otto bit r (A, B, C, D, E, H, L) |
|
DEC (HL) |
Indirizzamento indiretto |
Si decrementa il contenuto della locazione
di memoria il cui indirizzo è dato dal contenuto del registro HL |
|
DEC (IX+d) |
Indirizzamento indicizzato |
Si decrementa il contenuto della locazione
di memoria il cui indirizzo è dato dal contenuto del registro IX sommato allo
spiazzamento d espresso nell’istruzione |
|
DEC (IY+d) |
Indirizzamento indicizzato |
Si decrementa il contenuto della locazione
di memoria il cui indirizzo è dato dal contenuto del registro IY sommato allo
spiazzamento d espresso nell’istruzione |
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
|
|
|
1 |
|
Il
flag S verrà settato a seconda del segno del risultato
Il
flag Z verrà settato se il risultato è nullo
Il
flag H verrà settato se vi sarà un prestito fra il quarto e il quinto bit
Il
flag PV verrà settato se vi sarà un errore di overflow
Il
flag N è a 1 trattandosi di una sottrazione
Il
flag C non viene modificato
DEC rr
Quest’istruzione esegue il decremento di
un’unità del contenuto del registro a 16 bit rr. Esso può essere BC, DE, HL,
SP, IX, IY
Non ha effetto sul registro dei flag
DAA
E’ l’istruzione di aggiustamento decimale
dell’accumulatore. Il suo scopo è quello di trasformare il contenuto binario
dell’accumulatore in un numero BCD.
Per comprendere quest’operazione ricordiamo
che il codice BCD si differenzia da quello binario poiché un nibble di quattro
bit , pur potendo costituire teoricamente 16 combinazioni diverse, ne sfrutta
soltanto le prime 10 per rappresentare soltanto le cifre decimali da 0 a 9. A
differenza del codice binario, quindi, non sono consentite le combinazioni
corrispondenti alle cifre da A ad F.
AND s
Viene effettuato l’And logico fra
accumulatore ed operando s ed il risultato viene immagazzinato
nell’accumulatore. And logico significa che ogni bit dell’accumulatore viene
sostituito dall’and fra esso ed il suo corrispondente nell’operando s
|
AND A, r |
Indirizzamento a registro |
L’operando s è il contenuto del registro
ad otto bit r (A, B, C, D, E, H, L) |
|
AND A, n |
Indirizzamento immediato |
L’operando s è il contenuto del dato ad
otto bit immediatamente espresso nell’istruzione |
|
AND A, (HL) |
Indirizzamento indiretto |
L’operando s è il contenuto della locazione
di memoria il cui indirizzo è dato dal contenuto del registro HL |
|
AND A,(IX+d) |
Indirizzamento indicizzato |
L’operando s è il contenuto della locazione
di memoria il cui indirizzo è dato dal contenuto del registro IX sommato allo
spiazzamento d espresso nell’istruzione |
|
AND A,(IY+d) |
Indirizzamento indicizzato |
L’operando s è il contenuto della locazione
di memoria il cui indirizzo è dato dal contenuto del registro IY sommato allo
spiazzamento d espresso nell’istruzione |
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
1 |
|
|
0 |
0 |
Il
flag S verrà settato a seconda del segno del risultato
Il
flag Z verrà settato se il risultato è nullo
Il
flag H verrà settato sempre ad uno
Il
flag PV verrà settato ad uno se il numero di bit ad 1 nel risultato è pari
altrimenti è a zero
Il
flag N è sempre a zero
Il
flag C è sempre a zero
Esempio: AND
4B
Prima
36|16=00110110|2
AND
4B|16=01001011|2
=
02|16=00000010|2
Dopo
OR s
Viene effettuato l’or logico fra
accumulatore ed operando s ed il risultato viene immagazzinato
nell’accumulatore. Or logico significa che ogni bit dell’accumulatore viene
sostituito dall’or fra esso ed il suo corrispondente nell’operando s
|
OR A, r |
Indirizzamento a registro |
L’operando s è il contenuto del registro
ad otto bit r (A, B, C, D, E, H, L) |
|
OR A, n |
Indirizzamento immediato |
L’operando s è il contenuto del dato ad
otto bit immediatamente espresso nell’istruzione |
|
OR A, (HL) |
Indirizzamento indiretto |
L’operando s è il contenuto della locazione
di memoria il cui indirizzo è dato dal contenuto del registro HL |
|
OR A,(IX+d) |
Indirizzamento indicizzato |
L’operando s è il contenuto della locazione
di memoria il cui indirizzo è dato dal contenuto del registro IX sommato allo
spiazzamento d espresso nell’istruzione |
|
OR A,(IY+d) |
Indirizzamento indicizzato |
L’operando s è il contenuto della locazione
di memoria il cui indirizzo è dato dal contenuto del registro IY sommato allo
spiazzamento d espresso nell’istruzione |
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
0 |
|
|
0 |
0 |
Il
flag S verrà settato a seconda del segno del risultato
Il
flag Z verrà settato se il risultato è nullo
Il
flag H verrà posto sempre a zero
Il
flag PV verrà settato ad uno se il numero di bit ad 1 nel risultato è pari
altrimenti è a zero
Il
flag N è sempre a zero
Il
flag C è sempre a zero
Esempio: OR
4B
Prima
36|16=00110110|2
OR
4B|16=01001011|2
=
02|16=01111111|2
Dopo
XOR s
Viene effettuato l’or esclusivo logico fra
accumulatore ed operando s ed il risultato viene immagazzinato
nell’accumulatore. XOr logico significa che ogni bit dell’accumulatore viene
sostituito dall’or esclusivo fra esso ed il suo corrispondente nell’operando s
|
XOR A, r |
Indirizzamento a registro |
L’operando s è il contenuto del registro
ad otto bit r (A, B, C, D, E, H, L) |
|
XOR A, n |
Indirizzamento immediato |
L’operando s è il contenuto del dato ad
otto bit immediatamente espresso nell’istruzione |
|
XOR A, (HL) |
Indirizzamento indiretto |
L’operando s è il contenuto della locazione
di memoria il cui indirizzo è dato dal contenuto del registro HL |
|
XOR A,(IX+d) |
Indirizzamento indicizzato |
L’operando s è il contenuto della locazione
di memoria il cui indirizzo è dato dal contenuto del registro IX sommato allo
spiazzamento d espresso nell’istruzione |
|
XOR A,(IY+d) |
Indirizzamento indicizzato |
L’operando s è il contenuto della locazione
di memoria il cui indirizzo è dato dal contenuto del registro IY sommato allo
spiazzamento d espresso nell’istruzione |
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
0 |
|
|
0 |
0 |
Il
flag S verrà settato a seconda del segno del risultato
Il
flag Z verrà settato se il risultato è nullo
Il
flag H verrà posto sempre a zero
Il
flag PV verrà settato ad uno se il numero di bit ad 1 nel risultato è pari
altrimenti è a zero
Il
flag N è sempre a zero
Il
flag C è sempre a zero
Esempio: XOR
4B
Prima
36|16=00110110|2
XOR
4B|16=01001011|2
=
02|16=01111101|2
Dopo
CPL
L’accumulatore viene complementato ad uno,
cioè ogni suo singolo bit viene invertito.
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
1 |
|
|
1 |
|
Esempio
Prima
36|16=00110110|2
COMPLEMENTA
C9|16=11001001|2
NEG
L’accumulatore viene complementato a due,
poiché viene sottratto a zero
Modifiche al registro dei flag
|
S |
Z |
|
H |
|
P/V |
N |
C |
|
|
|
|
|
|
|
1 |
|
Il
flag S verrà settato a seconda del segno del risultato
Il
flag Z verrà settato se il risultato è nullo
Il
flag H verrà settato se vi sarà un prestito fra il quarto e il quinto bit
Il
flag PV verrà settato se A era 80h prima dell’esecuzione dell’istruzione.
Infatti 80|16=-128, ma 0-(-128)=+128 > +127 quindi si va in
overflow
Il
flag N è a 1
Il
flag C sarà posto ad 1 se A era nullo prima dell’esecuzione dell’istruzione.
Infatti proviamo ad effettuare l’esecuzione del complemento a due : 00000000|2à (complemento ad uno)11111111|2à 00000000|2 con un riporto
sull’ottavo bit
Esempio
Prima
32|16=00110010|2 à( COMPLEMENTA AD UNO CD)|16=11001101|2
à
(COMPLEMENTA A DUE) 11001101|2 + 1= 11001110|2=CE|16
Dopo