UDA 1 — Registri, istruzioni e indirizzamenti

6 ore (2 di teoria + 4 di laboratorio) · Settimane 2-3

Obiettivi

Al termine di questa unità:

• conosci i registri del G80 e sai scegliere quello giusto per ogni dato;
• sai scrivere istruzioni di trasferimento (LD), aritmetiche (ADD, SUB, INC, DEC) e logiche (AND, OR, XOR, CPL, CP);
• sai leggere i flag e prevedere il loro valore prima di premere Esegui;
• riconosci i modi di indirizzamento in un listato;
• usi etichette, costanti e le direttive di base (.org, .db, .dw, .ds, .ascii);
• hai completato l’Esercizio 1 e la scheda di traccia dell’esecuzione.

Piano delle due settimane — Incontro 1 (3 h): registri, LD, aritmetica, flag. Incontro 2 (3 h): logica, indirizzamenti, etichette/direttive, laboratorio e verifica formativa.

---

1. I registri

Il G80 ha pochi registri, tutti dentro la CPU, velocissimi:

Registro	Dimensione	Uso tipico
A	8 bit	accumulatore: risultati, operazioni aritmetiche/logiche, I/O
F	8 bit	flag: S Z 5 H 3 V N C (li studiamo al §5)
B C D E H L	8 bit	registri generici; a coppie formano BC, DE, HL (16 bit)
HL	16 bit	coppia “preferita” per puntare la memoria ((HL))
PC	16 bit	program counter: indirizzo della prossima istruzione
SP	16 bit	stack pointer: punta alla cima dello stack (UDA 3)
IX IY	16 bit	registri indice: indirizzamento con spiazzamento (IX+3)

Regola d’oro: i dati a 8 bit si mettono in un registro a 8 bit; gli indirizzi (16 bit) in una coppia. Il registro A è il protagonista di quasi tutte le operazioni.

Nel simulatore apri il pannello Registri e flag e tieni d’occhio A e PC mentre esegui con Passo: è il modo più veloce per capire cosa fa ogni istruzione.

---

2. Il formato delle istruzioni

Una riga di assembly ha questa forma:

etichetta:   mnemonico   operando1, operando2    ; commento

• l’etichetta è opzionale e indica un indirizzo (per salti e dati);
• il mnemonico (LD, ADD, JP…) è l’operazione;
• gli operandi sono registri, numeri o indirizzi;
• il commento inizia con ; e serve a te e ai tuoi compagni (scrivilo!).

Dall’assembly al codice macchina: ogni istruzione diventa 1, 2 o 3 byte. Ecco coppie reali (puoi verificarle con il disassemblaggio nel simulatore):

Assembly	Byte	Note
LD A, 0x55	3E 55	il valore segue il codice
LD C, 0x10	0E 10
ADD A, B	80	registro: un solo byte
SUB 0x04	D6 04
LD (0x8000), A	32 00 80	indirizzo a 16 bit, prima il byte basso
HALT	76	ferma la CPU

---

3. Trasferimento dati: la famiglia LD

        ld  a, 0x55       ; immediata: A = 0x55
        ld  b, a          ; registro:  B = A
        ld  hl, 0x1234    ; 16 bit: HL = 0x1234
        ld  (0x0010), a   ; diretta: scrive A nella cella 0x0010
        ld  a, (0x0010)   ; diretta: legge la cella 0x0010 in A
        ld  (hl), a       ; indiretta: scrive nella cella puntata da HL
        ld  a, (hl)       ; indiretta: legge dalla cella puntata da HL
        ld  (ix+3), 0xAB  ; indicizzata: cella IX+3

Attenzione a due cose:

1. le parentesi significano “il contenuto della cella”: ld a, 0x0010 mette in A il numero 0x0010, ld a, (0x0010) mette in A il contenuto della cella 0x0010 — è l’errore classico!
2. LD è un semplice trasferimento: non modifica i flag.

---

4. Aritmetica

        ld  a, 0x15
        add a, 0x0B       ; A = 0x20
        sub 0x04          ; A = 0x1C
        inc a             ; A = 0x1D
        dec b             ; B = B - 1

Istruzione	Significato	Flag modificati
ADD A, n / ADD A, r	A = A + operando	Z S H V N C
SUB n / SUB r	A = A - operando	Z S H V N C
INC r / DEC r	+1 / −1	Z S H V N — non C
ADC / SBC	somma/sottrazione con carry	tutti

Esempi da prevedere prima di eseguire (poi verifica col simulatore):

Operazione	A	C	Z	H	V	N
0x15 + 0x0B	0x20	0	0	1	0	0
0xFF + 0x01	0x00	1	1	1	0	0
0x7F + 0x01	0x80	0	0	1	1	0
0x08 − 0x04	0x04	0	0	0	0	1

Il half-carry H è il “riporto dal 4° bit”: serve per l’aritmetica in decimale. Il V in aritmetica indica overflow con segno (es. 0x7F + 1 = 0x80: +127 +1 “sfora” il massimo rappresentabile). Attenzione: il G80 non ha l’istruzione DAA dello Z80: se la incontri in esempi Z80, qui è illegale.

---

5. Logica, maschere e confronti

        and 0x0F          ; tiene solo i 4 bit bassi di A  (maschera)
        or  0x80          ; accende il bit 7
        xor 0xFF          ; inverte tutti i bit di A
        cpl               ; come xor 0xFF, ma su A sola
        cp  0x20          ; confronta A con 0x20 (senza salvare)

Istruzione	Effetto su A	Uso tipico
AND n	bit a bit “e”	spegnere i bit (mascherina di 0)
OR n	bit a bit “o”	accendere i bit (mascherina di 1)
XOR n	bit a bit “xor”	invertire i bit scelti
CPL	A = ~A	invertire tutti i bit
CP n	nessuno	confrontare: è una sottrazione che non salva

Dopo le istruzioni logiche: C = 0 e N = 0; V diventa la parità (1 se il numero di bit a 1 è pari). CP invece imposta i flag come una sottrazione: è così che si decide “minore / uguale / maggiore” (lo useremo nei salti, UDA 2).

Esempio di maschera sui LED: mostra sui LED solo i bit pari degli interruttori.

        in  a, (0x90)     ; leggi gli interruttori
        and 0x55          ; 0101 0101: tiene i bit 0, 2, 4, 6
        out (0x20), a     ; mostrali sui LED

---

6. I flag

Dopo ogni operazione i flag raccontano com’è andata. Nel simulatore sono il gruppo verde/nero accanto a F (S Z 5 H 3 V N C; i bit “5” e “3” sono interni e si ignorano).

Flag	Nome	Vale 1 quando…
S	segno	il bit 7 del risultato è 1 (risultato “negativo”)
Z	zero	il risultato è zero
H	half-carry	c’è riporto/borrow dal 4° bit
V	overflow / parità	overflow con segno / parità pari (logica)
N	sottrazione	l’ultima operazione era una sottrazione
C	carry	c’è riporto/borrow “in uscita”

Perché ci interessano? Perché i salti condizionati (UDA 2) leggono proprio i flag: “salta se zero”, “salta se carry”, “salta se minore”… Un programmatore assembly pensa in flag.

---

7. I modi di indirizzamento

Riconoscerli è metà del lavoro di lettura di un listato:

Modo	Esempio	Dove sta il dato
implicita	inc a, cpl	nel registro sottinteso (A)
immediata	ld a, 0x0F	dentro l’istruzione
registro	ld b, a	in un altro registro
indiretta	ld (hl), a	nella cella puntata da HL
diretta	ld (0x0010), hl	nella cella indicata dall’istruzione
relativa	jr salta	a un indirizzo vicino (spiazzamento)
indicizzata	ld (ix+3), 0xAB	a IX + spiazzamento

---

8. Etichette, costanti e direttive

VAL1    = 0x15            ; costante (equate): non occupa memoria
        .org 0x0100       ; il codice inizia qui (facoltativo)

inizio:
        ld  a, VAL1       ; usa la costante
        halt

        .org 0x0010       ; dati in una zona a parte
dati:   .db 0x0F, 0x80    ; due byte di dati
punto:  .dw 0x1234        ; una parola (16 bit): 34 12
spazio: .ds 6             ; riserva 6 byte
testo:  .ascii /Ciao/     ; i caratteri "Ciao" in memoria

Direttiva	Cosa fa
.org	fissa l’indirizzo di partenza (il “punto”)
.db	inserisce uno o più byte
.dw	inserisce parole a 16 bit (indirizzi)
.ds	riserva N byte
.ascii	inserisce una stringa (delimitata da /…/ o "…")

Le etichette sono indirizzi con un nome; le costanti (NOME = valore) sono comodità del programmatore. Trucco tipico: ld b, fine - inizio per calcolare una lunghezza, perché la differenza di due etichette è un numero.

---

9. Laboratorio guidato

Attività A — L’esempio 01-indirizzamenti.asm

Apri l’esempio nella raccolta (o incollalo dall’editor degli esempi) ed esegui Passo per passo con la memoria aperta. Verifica queste affermazioni:

1. dopo ld hl, 0x1234 e ld (0x0010), hl, nelle celle 0x0010 e 0x0011 ci sono 34 e 12 (prima il byte basso);
2. ld a, (0x0010) mette in A il valore 0x34; con inc a diventa 0x35;
3. ld (hl), a scrive 0x35 nella cella 0x1234;
4. ld (ix+3), 0xAB scrive 0xAB nella cella 0x0203.

Consegna: per ogni riga dell’esempio, indica il modo di indirizzamento.

Attività B — L’esempio 02-somma-e-flag.asm

1. esegui con Passo fino a dopo add a, b: A vale 0x20, C = 0, H = 1 (riporto dal 4° bit: 5 + 11 = 16!). Chiediti: perché H è 1 anche se il risultato “sta in un byte”?
2. prosegui: sub c → A = 0x1B con C = 0 e N = 1;
3. cp d con D = 0x20 → C = 1 (0x1B < 0x20) e il jr c salta a minore: A = 1.

Consegna: cambia i valori (B, C, D) e prevedi su carta flag e salto, poi verifica.

Attività C — Esercizio 1 (Somma)

Apri esercizi/01-somma.asm: manca una riga (il TODO). Completa, assembla ed esegui.

• Verifica: con VAL1 = 0x15 e VAL2 = 0x0B → A = 0x20.
• Poi cambia VAL1/VAL2 (es. 0xFF e 0x02) e spiega cosa cambia nei flag.
• Confronta con la soluzione solo dopo aver provato.

Attività D — Modificare i dati in memoria

1. scrivi ed esegui questo programma (la cella 0x0010 è usata come “interruttore”):

        .org 0x0100
        ld  a, (0x0010)   ; legge un byte dalla memoria
        out (0x20), a     ; lo mostra sui LED
        halt

2. premi Assembla & Carica, poi fermati prima di eseguire;
3. apri la memoria, vai a 0x0010, clicca il byte e inserisci 0x0F;
4. ora premi Esegui (senza Reset): i LED si accendono secondo il valore che hai scritto;
5. ripeti con 0xAA e 0x55.

Consegna: spiega perché la modifica va fatta dopo il caricamento e prima dell’esecuzione.

---

10. Verifica formativa — Traccia l’esecuzione

Completa le tabelle senza eseguire (poi controlla col simulatore o con la soluzione).

Listato A

        ld  a, 0x05
        ld  b, 0x03
        add a, b
        sub 0x04
        halt

Istruzione	A dopo	C	Z	S	H	V	N
ld a, 0x05
ld b, 0x03
add a, b
sub 0x04

Listato B

        ld  a, 0xFF
        add a, 0x01
        halt

Istruzione	A dopo	C	Z	S	H	V	N
ld a, 0xFF
add a, 0x01

Mostra la soluzione

Listato A — A = 0x05 → 0x08 → 0x04. add a, b: C=0 Z=0 S=0 H=0 V=0 N=0 (5+3=8, nessun riporto di nibble); sub 0x04: C=0 Z=0 S=0 H=0 V=0 N=1.

Listato B — A = 0x00. add a, 0x01: C=1 (riporto), Z=1 (risultato zero), S=0, H=1 (0xF+0x1 → riporto dal nibble), V=0 (−1+1=0, nessun overflow con segno), N=0.

---

11. Sfida

“Solo i bit pari” — leggi gli interruttori e mostra sui LED solo i bit in posizione pari (0, 2, 4, 6). Suggerimento: serve una maschera con AND.

Poi la variante: inverti i bit pari e lascia invariati i dispari (quale operazione serve?).

---

12. Autoverifica

1. Quale registro contiene l’esito delle operazioni? Dove stanno i flag?
2. Che differenza c’è tra ld a, 0x0010 e ld a, (0x0010)?
3. Perché è utile che LD non modifichi i flag?
4. Che differenza c’è tra sub b e cp b?
5. Dopo ld a, 0xF0 + add a, 0x20: quanto vale A? Quali flag si attivano?

---

13. Compiti e materiali

📎 I file .asm di esempi ed esercizi si scaricano dalla pagina Materiali.

• Compito: completa l’Esercizio 1 e le due tabelle di traccia; riscrivi l’esempio 02 con valori scelti da te e prevedi i flag prima di eseguire.
• Pre-lettura: manuale, sezioni Sintassi e Registri e flag.
• Materiali: esempi 01-indirizzamenti.asm, 02-somma-e-flag.asm; esercizio esercizi/01-somma.asm (+ soluzione).
• Prossima unità: il controllo del flusso — salti, confronti e cicli (UDA 2).