CORSO DI
ARCHITETTURA
DEGLI ELABORATORI
Introduzione al Linguaggio Assembly per l’8086
Cosa sapreteCosa saprete
• Alcune semplici istruzioni dell’assembly per 8086
• Esempi di istruzioni sui registri Esempi di istruzioni sui registri generali AX BX CX DX
E i di d l i t fl• Esempio di uso del registro flag
• Il trace per controllare l’esecuzione Il trace per controllare l esecuzione dei programmi
I registri: i dati vengono processati molto velocementemolto velocemente
Pensiamo ad un registro come ad una calcolatrice tascabile
MOV AX,3 ;metti 3 nel registro AX
ADD AX,2 ;aggiungi 2 al contenuto del registro AX
O AX Il i lt t i AX Opera su AX e Il risultato in AX (come una calcolatrice)
-Il micorprocessore esegue tutto ciò che è a sinistra del “;”
- “;” è usato per i commentip
I registri: i dati vengono processati molto velocemente
I registri generali dell’8086: AX BX CX DX
molto velocemente
MOV BX,AX ;copia il contenuto di AX in BX
MOV CX,AX ;copia il contenuto di AX in CX
MOV DX,CX ;copia il contenuto di CX in DX
La MOV consente di trasferire dati tra registri
I registri: i dati vengono processati molto velocemente
Alcune operazioni sui registri
molto velocemente
MOV AX,5
MOV BX,4
SUB AX,2 ; sottrae 2 al registro AX
MUL BX ; moltiplica il numero “unsigned” a 16 bit in BX per quello ; contenuto in AX; contenuto in AX.
; mette il risultato a 32 bit in DX e AX
(5 2)*4 12 i d i l(5-2)*4 = 12 in decimale
= C in esadecimale
= 00000000 00000000 00000000 00001100 unsigned 32 bit
DX AX
Notate che AX non è menzionato come operando della MUL
I registri: i dati vengono processati molto velocemente
Rimuovere l’ambiguità delle notazioni
molto velocemente
MOV AX,26
26 è decimale o esadecimale?26 è decimale o esadecimale?
Scriviamo allora
MOV AX,26H ;esadecimale
MOV AX,26D ;decimale
Assunzione:
Se non specificato, il formato assunto è decimale
I registri: i dati vengono processati molto velocemente
La dimensione dei registri AX BX CX DX: 16 cifre binarie (una calcolatrice tascabile consente un numero massimo di cifre decimali - 9)
molto velocemente
MOV AX,n
La rappresentazione binaria del numero n non deve eccedere le 16 cifre:
Per nD non negativo (unsigned):
65 535 n<= 65 535 (216 possibili configurazioni di 0 e 1: da 0D a 65535D)
Altrimenti (signed)
-32 768<= n <= +32 768
(216 possibili configurazioni di 0 e 1: da -32768D a +32768D)
rappresentazione binaria del numero n deve essere a 16 cifre pp(sempre)
(diversamente da una calcolatrice tascabile)
MOV AX,7H MOV AX,0000000000000111BConversione automatica
Effettuare il trace con Emu8086Per tenere traccia anche dei contenuti dei registriPer tenere traccia anche dei contenuti dei registri
Codice macchina
I di i fi i E d i l D i l ASCII
disassemblato
Indirizzo fisico: Esadecimale Decimale ASCII
Memory List
Effettuare il trace con Emu8086
D bl Cli k l d i i iDouble-Click sul campo testo dei registri:
Valore del registro in tutte le conversioni possibili. Valori modificabili direttamente
Effettuare il trace con Emu8086
Double-Click sulla memory list:
Valore della locazione di memoria selezionata. Valori modificabili direttamente
I registri: i dati vengono processati molto velocemente
La dimensione dei registri AX BX CX DX: 16 cifre binarie
M l’8086 di di i i i
molto velocemente
Ma l’8086 consente di usare ognuno di questi registri come 2 registri ad 8 bit
MOV DH,98H
MOV DX,23ABHCosa contengono DH e DX?
98H = 1001 1000BADD DH,1
DX
98H = 1001 1000B
|
DH DL
I registri: i dati vengono processati molto velocemente
La dimensione dei registri AX BX CX DX: 16 cifre binarie
M l’8086 di di i i i
molto velocemente
Ma l’8086 consente di usare ognuno di questi registri come 2 registri ad 8 bit
MOV DH,98H
MOV DX,23ABHCosa contengono DH e DX?
98H = 1001 1000BADD DH,1
98H = 1001 1000B
DXMOV DH,98H
MOV DX 23ABH
10011000 | ????????
DH DL
MOV DX,23ABH
ADD DH 1ADD DH,1
I registri: i dati vengono processati molto velocemente
La dimensione dei registri AX BX CX DX: 16 cifre binarie
M l’8086 di di i i i
molto velocemente
Ma l’8086 consente di usare ognuno di questi registri come 2 registri ad 8 bit
MOV DH,98H
MOV DX,23ABHCosa contengono DH e DX?
98H = 1001 1000BADD DH,1
98H = 1001 1000B
DXMOV DH,98H
MOV DX 23ABH
10011000 | ????????
DH DLDX
MOV DX,23ABH
ADD DH 1
00100011 | 10101011
DH DL
ADD DH,1
I registri: i dati vengono processati molto velocemente
La dimensione dei registri AX BX CX DX: 16 cifre binarie
M l’8086 di di i i i
molto velocemente
Ma l’8086 consente di usare ognuno di questi registri come 2 registri ad 8 bit
MOV DH,98H
MOV DX,23ABHCosa contengono DH e DX?
98H = 1001 1000BADD DH,1
98H = 1001 1000B
DXMOV DH,98H
MOV DX 23ABH
10011000 | ????????
DH DLDX
MOV DX,23ABH
ADD DH 1
00100011 | 10101011
DH DL
00100100 | 10101011DX
24 ABHADD DH,1 00100100 | 10101011
DH DL
=24 ABH
I registri: i dati vengono processati molto velocemente
La dimensione dei registri AX BX CX DX: 16 cifre binariemolto velocemente
ATTENZIONE!!!!!!
MOV DL,AH Che significa?
AX
???????? |00000100DX
DH DL
00100011 | 10101011AX
AH ALoppureDH DL
???????? | 00100011DX
pp
DH DL
I registri: i dati vengono processati molto velocemente
La dimensione dei registri AX BX CX DX: 16 cifre binariemolto velocemente
ATTENZIONE!!!!!!
MOV DL,AH Che significa?
AX
???????? |00000100DX
DH DL
00100011 | 10101011AX
AH ALoppureDH DL
???????? | 00100011DX
pp
Convenzione
DH DLTutti i numeri decimali che cominciano con una lettere
devono essere preceduti da uno 0p
I registri: i dati vengono processati molto velocemente
La dimensione dei registri AX BX CX DX: 16 cifre binariemolto velocemente
ATTENZIONE!!!!!!
MOV DL,AH Che significa?
AX
???????? |00000100DX
DH DL
00100011 | 10101011AX
AH ALoppureDH DL
???????? | 00100011DX
pp
Convenzione
DH DLTutti i numeri decimali che cominciano con una lettere
devono essere preceduti da uno 0p
I registri: i dati vengono processati molto velocemente
Il registro flag: un esempio di uso
Il fl d l
molto velocemente
Il flag del carry
(usato per indicare il riporto 0 o 1 di una operazione aritmetica)
MOV AL 3H ????????| 00000011AX
MOV AL,3H ????????| 00000011
AH AL
MOV BL,0FFH
ADD AL,BLADD AL,BL
I registri: i dati vengono processati molto velocemente
Il registro flag: un esempio di uso
Il fl d l
molto velocemente
Il flag del carry
(usato per indicare il riporto 0 o 1 di una operazione aritmetica)
MOV AL 3H ????????| 00000011AX
MOV AL,3H ????????| 00000011
AH AL
BX+
MOV BL,0FFH ???????? | 11111111BX
BH BL
ADD AL,BL
= 1 00000010
ADD AL,BL
I registri: i dati vengono processati molto velocemente
Il registro flag: un esempio di uso
Il fl d l
molto velocemente
Il flag del carry
(usato per indicare il riporto 0 o 1 di una operazione aritmetica)
MOV AL 3H ????????| 00000011AX
MOV AL,3H ????????| 00000011
AH AL
BX+
MOV BL,0FFH ???????? | 11111111BX
BH BL
ADD AL,BL
= 1 00000010
????????| 00000010AX
Il flag del carry ad 1 per ADD AL,BL ????????| 00000010
AH ALindicare che il numero è
troppo grande
Il registro flag: un esempio di usoCon Emu8086Con Emu8086
Il registro flag: un esempio di usoCon Emu8086Con Emu8086
Il registro flag: un esempio di usoCon Emu8086Con Emu8086
Cosa dovreste sapreteCosa dovreste saprete
• Alcune semplici istruzioni dell’assembly per 8086
• Esempi di istruzioni sui registri Esempi di istruzioni sui registri generali AX BX CX DX
E i di d l i t fl• Esempio di uso del registro flag
• Il trace per controllare l’esecuzione Il trace per controllare l esecuzione dei programmi
Cosa sapretep
• Istruzione mov Istruzione mov (trasferimento dati da e in memoria – uso dei registri)
• Semplici istruzioni di salto per 8086 Semplici istruzioni di salto per 8086 (per creare cicli for, repeat, while)
• Registro BX • Registro BX (per accedere a locazioni di memoria)
• Registri di segmento CS DS • Registri di segmento CS DS (meccanismo di accesso a istruzioni e dati in memoria)
• Definizione dei segmenti in un • Definizione dei segmenti in un programma assembly
Memorizzare e Recuperare
dati dalla memoriadati dalla memoria
I dati possono essere trasferiti da memoria a registri p guno o due byte per volta
MOV AL,[10H] Copia il contenutod ll l 10H l L
,[ ]della locazione 10H nel registro AL
MOV AL,10H Copia il valore 10H nel registro AL
MOV BX,[20H] Copia il contenutodelle locazioni 20H e 21H nel registro BX
C i il t t d l i t CL ll MOV[20H],CL Copia il contenuto del registro CL nella locazione 20H
MOV [20H],DX Copia il contenuto del registro DX nelle MOV [ H],DX20H e 21H
Memorizzare e Recuperare
dati dalla memoria (cont )dati dalla memoria (cont.)
I dati possono essere trasferiti uno o due byte per voltap y p
MOV [20H],AX
AX 2A 8B
MOV AX, [20H]
AXAX 2A 8B AX
21H
22H
21H
22H
3E
20H 20HAF
Esempio MOV
Es i di st tt di ss blEsempio di estratto di un programma assembly
…..
MOV BX,200H;
MOV CX,3H;MOV CX,3H;
ALERT_NEXT: MOV AL,[BX];
INC AL;INC AL;
MOV [BX],AL;
INC BX;INC BX;
DEC CX;
N LER NEXJNZ ALERT_NEXT
……
Aggiunge 1 ad ogni numero ad 8-bit memorizzato nelle locazioni 200H-202H incluse
Esempio di MOV
Al d l Al cuore del programma
…..
MOV BX,200H;
MOV CX,3H; Muove in AL il contenuto MOV CX,3H;
ALERT_NEXT: MOV AL,[BX];
INC AL;
Muove in AL il contenuto della locazione il cui indirizzo è contenuto in BX
INC AL;
MOV [BX],AL;
INC BX;
Salva nella locazione il cui indirizzo è contenuto in BX, ciò che è nel registro
INC BX;
DEC CX;
N LER NEX
, gAL
JNZ ALERT_NEXT
……
Aggiunge 1 ad ogni numero ad 8-bit memorizzato nelle locazioni 200H-202H incluse
Esempio di MOVIl programma ripete lo stesso gruppo di istruzioni per ogni Il programma ripete lo stesso gruppo di istruzioni per ogni
locazione da 200H a 202H…..
MOV BX,200H;
MOV CX,3H;Il contatore di ripetizioni è inizializzato a 3MOV CX,3H;
ALERT_NEXT: MOV AL,[BX];
INC AL;
inizializzato a 3
INC AL;
MOV [BX],AL;
INC BX; Decrementa il contatore INC BX;
DEC CX;
N LER NEX
Decrementa il contatore ogni volta che il gruppo di istruzioni viene eseguito
JNZ ALERT_NEXT
……
Aggiunge 1 ad ogni numero ad 8-bit memorizzato nelle locazioni 200H-202H incluse
Esempio di MOVTraceTrace
Aggiunge 1 ad ogni numero ad 8-bit memorizzato nelle locazioni 200H-202H incluse
Esempio di MOVTraceTrace
Aggiunge 1 ad ogni numero ad 8-bit memorizzato nelle locazioni 200H-202H incluse
Esempio di MOVTraceTrace
Aggiunge 1 ad ogni numero ad 8-bit memorizzato nelle locazioni 200H-202H incluse
Esempio di MOVTraceTrace
Aggiunge 1 ad ogni numero ad 8-bit memorizzato nelle locazioni 200H-202H incluse
Esempio di MOVTraceTrace
Aggiunge 1 ad ogni numero ad 8-bit memorizzato nelle locazioni 200H-202H incluse
Esempio di MOVTraceTrace
Aggiunge 1 ad ogni numero ad 8-bit memorizzato nelle locazioni 200H-202H incluse
Esempio di MOVTraceTrace
Aggiunge 1 ad ogni numero ad 8-bit memorizzato nelle locazioni 200H-202H incluse
Esempio di MOVTraceTrace
Aggiunge 1 ad ogni numero ad 8-bit memorizzato nelle locazioni 200H-202H incluse
Considerazioni
…..
MOV BX,200H;
MOV CX,3H; Trasferisce un solo byte: MOV CX,3H;
ALERT_NEXT: MOV AL,[BX];
INC AL;
Trasferisce un solo byte: quello il cui indirizzo è in BX
INC AL;
MOV [BX],AL;
INC BX;Trasferisce due byte:
MOV AX [BX]INC BX;
DEC CX;
N LER NEX
MOV AX,[BX]
Quello il cui indirizzo è contenuto in BX
JNZ ALERT_NEXT
……e
quello dalla locazione successiva a questo
Considerazioni
è
…..
Il registro BX è diverso dai registri AX, CX, DX
MOV BX,200H;
MOV CX,3H; Non esiste un equivalente MOV CX,3H;
ALERT_NEXT: MOV AL,[BX];
INC AL;
Non esiste un equivalente della parte [BX] per istruzioni di questo tipo
INC AL;
MOV [BX],AL;
INC BX;
Per i registri AX BX CX
Per esempio:INC BX;
DEC CX;
N LER NEX
MOV CX,[DX]
Non è una operazione consentitaJNZ ALERT_NEXT
……
consentita
Solo il registro BX può essere usato per puntare essere usato per puntare alle locazioni di memoria
Considerazioni
…..
L’istruzione JNZ ALERT_NEXT
MOV BX,200H;
MOV CX,3H; Normalmente le istruzioni MOV CX,3H;
ALERT_NEXT: MOV AL,[BX];
INC AL;
Normalmente le istruzioni vengono eseguite in modo consecutivo:
INC AL;
MOV [BX],AL;
INC BX;
MOV BX, 200H
MOV CX, 3H
INC BX;
DEC CX;
N LER NEX
……
Le istruzioni di salto servono a far variare il
JNZ ALERT_NEXT
……
servono a far variare il normale flusso di istruzioni
Salta all’istruzione etichettata con ALERT_NEXT, se l’ultima istruzione aritmetica da valore diverso da zero, e continua il normale flusso di istruzioni
Considerazioni
JZ <etichetta> Salta ad <etichetta> se il risultato dell’ultima i i i è (ZF)
Altre istruzioni di Salto (per il momento)
JNZ <etichetta>
operazione aritmetica è stato zero (ZF)
Salta ad <etichetta> se il risultato dell’ultima JNZ etichetta
JMP <etichetta>
Salta ad <etichetta> se il risultato dell ultima operazione aritmetica è stato diverso da zero
S lt d ti h ttJMP <etichetta> Salta ad <etichetta>
…sulle <etichetta>Una istruzione di salto in assembly necessita la specifica dell’indirizzo di
memoria a cui saltare
l f l hDurante il processo di trasformazione assembly å codice macchina
All’<etichetta> viene rimpiazzato l’indirizzo dell’istruzione a cui saltare
L’ ti h tt d t l di L’<etichetta> deve contenere una qualunque sequenza di caratteri alphanumerici (incluso _) e deve cominciare per un carattere
Esempio di salti
MOV CX,AX;Effettua una copia del contenuto del registro AX, che in seguito viene ,
SUB AX,BX;
JZ MAKE1;
g gmodificato
JZ MAKE1;
MOV DX,0;
JMP RESET;JMP RESET;
MAKE1: MOV DX,1;
RESET: MOV AX CX; Ri i ti il t t d l i t AXRESET: MOV AX,CX; Ripristina il contenuto del registro AX
Confronta il contenuto dei registri AX e BX. Se è uguale mette 1 in DX. Altrimenti mette 0 in DX
Programmi che lavorano sulla Programmi che lavorano sulla memoriam m
Alcuni esempiAlcuni esempi
(provate ad emulare con EMU 8086)EMU 8086)
Esempio1Un programma che scambia il contenuto delle locazioni 20H e 21H
MOV AL, [20H]
Un programma che scambia il contenuto delle locazioni 20H e 21H
, [ ]
MOV BL,[21H]
MOV [20H],BLMOV [20H],BL
MOV [21H],AL
Il trasferimento dei dati Il trasferimento dei dati da memoria a memoria
non è consentitonon è consentito
Esempio2Un programma che memorizza il valore 0 nelle locazioni 200H 300H incluse
MOV BX,200H
Un programma che memorizza il valore 0 nelle locazioni 200H-300H incluse
BX contiene l’indirizzo della successiva locazione di memoria che ,
MOV CX,101H
DO ANOTHER: MOV [BX],0H
deve essere avvalorata
CX tiene il conto del numero di l c i ni d (101H) DO_ANOTHER: MOV [BX],0H
INC BX
DEC CX
locazioni da azzerare (101H)
DEC CX
JNZ DO_ANOTHER
Ripeti questo gruppo di istruzioni finchè l’operazione DEC p q g pp prestituisce un valore diverso da 0
Esempio3Un programma che memorizza i numeri naturali PARI (da 0H a 101H) a 16 bit
MOV BX,200H
Un programma che memorizza i numeri naturali PARI (da 0H a 101H) a 16 bit (a partire dalla locazione 200H)
BX contiene l’indirizzo della ,
MOV AX,0H
MOV CX,101H
successiva locazione di memoria che deve essere avvalorata
MOV CX,101H
DO_ANOTHER: MOV [BX],AX
INC BX
Scrvi in memoria alla locazione puntata da BX il numero attuale
INC BX
INC BX
INC AXINC AX
INC AX
DEC CXDEC CX
JNZ DO_ANOTHER
Ogni locazione è a 8 bit å due incrementi del puntatore superano lo spazio di un numero a 16 bit
Esempio4Un programma che somma numeri a 16 bit presenti in memoria
MOV AX,0
p g p(a partire dalla locazione 500H)
E EMOV AX,0
MOV BX, 500H
MOV CX,28H
OSSERVAZIONE
28H sono i numeri a 16 bit che somma
ADD_IN_NEXT: ADD AX,[BX]
INC BX
INC BX
che somma.
Dunque guarda nelle locazioni dalla 500H alla
INC BX
DEC CX
JNZ ADD IN NEXT
54FH
JNZ DD_IN_NEX
Ogni numero a 16 bit occupa due locazioni di memoria
å Passo al numero successivo con un doppio incremento del puntatore alla locazione di memoria contenete il numero appena sommato al totalenumero appena sommato al totale
Esempio4Un programma che somma numeri a 16 bit presenti in memoria
MOV AX,0
p g p(a partire dalla locazione 500H)
MOV AX,0
MOV BX, 500H
MOV CX,28H
ADD_IN_NEXT: ADD AX,[BX]
INC BX
INC BXINC BX
DEC CX
JNZ ADD IN NEXTJNZ DD_IN_NEX
Ricordate che la ADD AX,[BX] lascia il risultato in AX
Esempio4Un programma che somma numeri a 16 bit presenti in memoria
MOV AX,0
p g p(a partire dalla locazione 500H)
MOV AX,0
MOV BX, 500H
MOV CX,28H
ADD_IN_NEXT: ADD AX,[BX]
INC BX
INC BXINC BX
DEC CX
JNZ ADD IN NEXTJNZ DD_IN_NEX
Proviamo ad emulare!!!Proviamo ad emulare!!!
LOCAZIONE 500 501 502 503 504 505
CONTENUTO 00 01 00 01 E2 00
I registri di segmento dell’8086- a 16 bitSpecificano il segmento a cui un particolare oggetto (es. codice, dati) appartiene å
Offset per specificare l’indirizzo completo di un oggetto in memoria
Verione in .codice macchina
.
INC DX
MOV AX, [100H]
INC AX
.
.
Ricordate:CS:usato per accedere al segmento che contiene il codiceCS usato per accedere al segmento che cont ene l cod ce
DS: per accedere al segmento che contiene i dati
SS: usato per accedere al segmento che contiene la memoria di lavoro in SS: usato per accedere al segmento che contiene la memoria di lavoro in cui ci sono dati temporanei
CPU e Registri
Registri di segmento
Registri di sistema
Registri generali Registri puntatore
Accesso all’istruzione successiva nel segmento codice
Verione in codice .
.
INC DX
Verione in .codice macchina di
MOV AX, [100H]
INC AX
.
.
Ricordate:L’indirizzo di ogni
CS:3B12H IP:12EFH
L indirizzo di ogni istruzione assembly è specificato tramite
Indirizzo fisico å 3B120H
12EFH p
CS (segmento):IP (offset)------------
3C40FH
Accesso all’istruzione successiva nel segmento codice
.
.
INC DX
Verione in .codice macchina di
INC DX
MOV AX, [100H]
INC AX
.
.
Istruzioni diverse possono avere lunghezze diverse
INC AX å 1 byte
Mov AX,[100H] å 3 byte
Accesso all’istruzione successivaCio’ che occorre guardare con l’emulatore
Accesso ai dati in memoriaMOV AL, [200H]
Ogni indirizzo esplicito in una istruzione 8086
è relativo al contenuto del registro DSregistro DS
E i DS 500H (0000 0101 0000 0000B)
MOV AL, [200H]
Esempio con DS: 500H (0000 0101 0000 0000B)
Byte spostato in
AL preso dalla
l i
0000 0010 0000 0000
0000 0101 0000 0000 0000
200Håindirizzo dato
5000Håindirizzo DS shiftato
locazione0000 0101 0010 0000 0000 5200Håindirizzo fisico
Accesso ai dati in memoriaMOV AL, [20H]
Ogni indirizzo esplicito in una istruzione 8086
è relativo al contenuto del registro DSregistro DS
Attenzione!!!!
Il registro DS (ma in generale i registri segmento) g ( g g g )non può essere caricato direttamente
MOV BX [500H]MOV BX, [500H]
MOV DS,BXPer settare DS a 500H:
Esempio5Calcolo di locazoni di memoria effettivamente indirizzate
MOV BX,1275H
Calcolo di locazoni di memoria effettivamente indirizzate
MOV BX,1275H
MOV DS,BX
MOV AX,5H
MOV DX,17H
MOV BH,[100H] ;(12750 + 100 = 12850)
MOV BL [30H] (12750 30 12780)MOV BL,[30H] ;(12750 + 30 =12780)
MOV BX,DX
MOV CX,[BX] ;(12750 +17 = 12767 & 12750 +18 =12768)
CX å 16bit å in CX
contenuto di MOV X,[BX] ;( 750 7 767 & 750 8 768)
ADD BX,CX
ADD AX,BX
locazione puntata da BX e succ.
MOV [75H],AX ;(12750 +75 = 127C5 & 12750 +76 =127C6)
MOV [204H],BL ;(12750 + 204 = 12954)
MOV [31A5H] BH ;(12750 31A5 158F5)
AX å 16bit å 2 locazioni
ti MOV [31A5H],BH ;(12750 + 31A5 = 158F5) consecutive per il cont. Di
AX
Accesso ai datiCio’ che occorre guardare con l’emulatore
Edit bil l iEditabile per la ricerca
veloce
I registri CS e DS
Il sistema operativo si preoccupa di settare i valori di DS e CSDS e CS
Ma il programmatore potrebbe sovrascrivere questi valori (raro che accada)(raro che accada)
Programma Utente in assembly
In programma ci devono essere almeno 3 definizioni di segmento.
STACK ris rv sp zi p r l STACK ( r di l v r )- STACK riserva spazio per lo STACK (area di lavoro).- DATA contiene i dati del programma.- CODE contiene istruzioni del programma.
<nome segmento> SEGMENT Pseudo-ops:nome_segmento SEGMENT
.....
.....
<nome segmento> ENDS
Assistono l’assemblatore nella traduzione in codice macchina del prog. assembly<nome_segmento> ENDS p g y
Ci ’ h MIOPROGRAMMA SEGMENT
Cio’ che appartiene al segmento
MOV AX,4H
SUB AX,5H
.segmento .
MIOPROGRAMMA ENDS
Programma Utente in assembly
In programma ci devono essere almeno 3 definizioni di segmento.
STACK SEGMENT STACK
DW 100H DUP(? ) Pseudo-op
Per specificare lo Stack
……………….
STACK ENDS
DATA SEGMENT
VAR 3 DB
……………………….
DATA ENDS
CODE SEGMENTCODE SEGMENT
;istruzioni del programma
CODE ENDS
Gli indirizzi di memoria effettivi per lo stack sono calcolati tramite il registro SS
Programma Utente in assembly
Per poter utilizzare gli indirizzi “segmentati” nel programma, dobbiamo inizializzare i registri di segmento.
I registri di segmento DS, SS e CS vengono inizializzati all'inizio di un programma. g p g
Ecco i passi da seguire per inizializzare i segmenti:
1. Dire all'assemblatore quale segmento è associato con un determinato registro. (DEVE saperlo in fase di assemblamento) ål’uso della pseudo op ASSUMEl uso della pseudo-op ASSUME
2. Dire al processore quale segmento è associato con un determinato i t åregistro å
scrivendo il codice necessario per caricare il valore corretto del segmento nel registro di segmento nel processore.
Programma Utente in assembly
In programma ci devono essere almeno 3 definizioni di segmento.
STACK SEGMENT STACK
DB 1024 SUP ( 0FFH )
……………….
STACK ENDSSTACK ENDS
DATA SEGMENT
VAR 3 DB
……………………….
DATA ENDS
PSEUDO_OPS:
Specificano ll’ bl h
CODE SEGMENT
ASSUME DS:DATA
ASSUME SS:STACK
all’assemblatore che
DS usato nel calcolo degli indirizzi nel ASSUME SS:STACK
ASSUME CS:CODE
;istruzioni del programma
CODE ENDS
gsegmento DATA
SS, nel segmento STACK
CS, nel segmento CODE
Template exe emu8086
Def. Segmento DATI
Def. Segmento STACK
Def Segmento CODICE
Cosa dovreste saprete……a proposito delle istruzioni di salto
• Alterano il flusso di controllo durante Alterano il flusso di controllo durante l’esecuzione del programma
• JZ JNZ JMPJZ, JNZ, JMP
h S lt d < tich tt > s il isult t d ll’ultim JZ <etichetta> Salta ad <etichetta> se il risultato dell ultima operazione aritmetica è stato zero (ZF)
JNZ <etichetta> Salta ad <etichetta> se il risultato dell’ultima operazione aritmetica è stato diverso da zero
JMP <etichetta> Salta ad <etichetta>
Cosa dovreste saprete… it d ll i t i MOV …a proposito della istruzione MOV
• Consente il trasferimento dei dati tra Consente il trasferimento dei dati tra registri e memoria
– Formato:Formato:1. MOV NomeRegistro, [n]
2. MOV [n], NomeRegistro
• Con n, numero unsigned a 16 bit (äåoffset relativo al registro di segmento DS)
• NomeRegistro:• NomeRegistro:– Riferito a un registro ad 8 bit (?H-?L) åloc.effettiva
m calcolata a partire da n
– Riferito a un registro a 16 bitå loc,effettive m e m+1 calcolate a partire da n
Cosa dovreste saprete… it d ll i t i MOV …a proposito della istruzione MOV
– Formato:3. MOV NomeRegistro, [BX]
4. MOV [BX], NomeRegistro
C BX si d 16 bit (äå ffs t • Con BX, numero unsigned a 16 bit (äåoffset relativo al registro di segmento DS)
• NomeRegistro:g– Riferito a un registro ad 8 bit (?H-?L) åloc.effettiva
m calcolata a partire da valore in BX
– Riferito a un registro a 16 bitå loc effettive m e m+1 Riferito a un registro a 16 bitå loc,effettive m e m+1 calcolate a partire da valore in BX
BX è un registro speciale da usare per gli accessi in memoria
Non si può fare l’equivalente di 3 e 4 con i registri AX,CX,DX
Cosa dovreste saprete… it d i i t i di t CS DS SS…a proposito dei registri di segmento CS, DS, SS
• Determinano il segmento a cui Determinano il segmento a cui corrisponde un indirizzo usato in una istruzioneistruzione
• Valori in CS,DS,SS determinato dal DOS (S.O.) ma sovrascrivibile dal programmatore
• Non caricabili direttamente
MOV BX, [500H]Per settare DS a 500H:
• Registri associati (a carico del programmatore –pseudo-
MOV DS,BX
g ( p g pop ASSUME ) ad istruzioni e dati nel programma scritto in assembly
Esercizio11 Scrivere un frammento assembly per :1. Scrivere un frammento assembly per :
1. Riempire le locazioni 200H å300H con il numero 0FFH unsigned a 8 bit
2. Invertire il contenuto della locazione 200H con quello della locazione 300H. Quello della locazione 201H con quello della locazione 2FFH… e cosi’ viacosi via.
Locazione Contenuto Locazione Contenutoprima dopo200 2A
201 56
202
200 3F
201 AB
202202 …
2FF AB
202 …
2FF 56
3. contare il numero di locazioni che contengono il codice ASCII del ll l d ll ll
300 3F 300 2A
carattere X, nelle locazioni dalla 200H alla 300H
Esercizio21 Utilizzate Emu8086 e verificate come avviene l’accesso ai dati e alle 1. Utilizzate Emu8086 e verificate come avviene l accesso ai dati e alle
istruzioni utilizzando i frammenti di codice usati fino ad ora
"�D��D���A�A
( "��A�C�D�����A����DA��B�CA�����������A�CFA�D��������)�A���B���D�B�����ABBA�D�A���A�������
"��B�����B��CC�D���A��A��AD�B����A���DA��A����C��CA���
* "��A��BB�C��A�D���������A��������AB�DA��A����+E,��* "��A��CCAA�A���������A���������* "��A�D������A���)�A����BC��A�#��������AB�+-.�CF�����A����DDA��BA���
"��A��BB�C��A�D���������A�����
������AB�DA��A��������
EBB�C�����A�ABB���A�������������A�B�����C�B� DEF��E�
����������������
�A����������ABCDE
�������������BF����BCD
��������������F�D�BCD
�������������������E
/.01+-2-/. +03�40�
.�AC�#�C�����BB��DDA��B����A�CFA
+A)����ADDA�A��BB�C������B���B�������5�A�6������5������A��AC�����A
EBB�C�����A�ABB���A�������������A�B�����C�B� DEF��E��E���B�
���������������AB��CD�EF���������A����BAD���A����D���������� �����
������������������AB��CD�EF���������A����BAD���A����D������DAD��������D��A
��������� ���AB��CD�EF���������A����BAD���A����D�������������BA���� !!�����
�"��##$���������AB���C��EF���������A����
���##$��� %& '��()�*D��������E��+
���D������A�������������D��������D,�
��BAD��DC�A��������� '����������%&
����$#-#�&$#.�������AB��-�EF���������A���
���$#-#�&$#.���%//��$/-���()�*D�����0$�E��+
���D������A���������������D�������D,�����D,$����D,0
��BAD��DC�A������������-�������$/��������������/1
EBB�C�����A�ABB���A�������������A�B�����C�B� DEF��E���������������������DEF��E
����-�
�"��%%%����2%03'�
������
������
����4�
����4�
����5�
����%��������%%%��
4AB���AD� D����D,�����D,$���D,0���D,-���D,.�����D,����D,&���D,'���D,#
AD��DC�A �-����3'������%0�����-'������-.�����- ������- -/�����%������%%
������445�
EBB�C�����A�ABB���A�������������A�B�����C�B� D������
+7�&�8�+1/�9E�������:�BB�C��BA�D�CCADD�)A�&�8�B�C�������C���)�B��A�������BA�:E."�����E��
+;�&�8�+1/�<�������:�BB�C��BA�D�CCADD�)A�&�8�B�C�������C���)�B��A�������BA�:��A�A�������
+;�=�8�+1/�&��+���:��BB�C��BA�D�CCADD�)A�=�8�B�C�������C����� �8:�#�����D���A�& �����
/.01+-2-/. +1/�
.�AC�#�C�����BB��DDA��B����A�������B��������� ��B���BA��BB��D�ADD��)�B��A
EBB�C�����A�ABB���A�����������������������������A��A��������A����� �A����!"!#
+E,E�.0>�04,�?27?,0���������+7��@%8�?2+�>�,.�����+7��9@� 5��%�$$$
4ABB��DD�C���A�B��##DA��B��DDA��B����A�����A����A���
-33.0,�����?27?,0 ���������������������A�� �AB�DA��A����+E,�
-CC�������A�AB�����
@%8�A���&&���&�7������������������������1��D����B�����A�������A��
-�CC�������A ���?2+�>�,. �
+�A����A�C���A�A�����B�C��CA�E."��ABBA�C�#�A�9@� A�9%�
-))A��
��&&��&&7 A�@@8
��&&��&�7 A�@%8
-##DA�������-##DA�&�����-##DA�%�����-##DA�@
��&&��&������&&��&&������&&��&��������BBB$
&������A������&������A��������&����A���BB
�������AB�����DA��A��
3)��B���A�&$ "��D�A���A��B�DA��A��A����������9A#��A�
�A����$ D%����&'(�D���)�%�����D%����*�+�,$-�E../.0�1 D2���&33&4&3354&33'4&336D����D2���&7"(�D����8�
�9����$����D2�&7"(�D���8�%�����DD�&4&"4&""4&"""4&""""�
%$ ,�����A�B��D��ABB��9A#��A� D��������B���� ������������B�C�������CFA�D�AC�#�CF�������AD��ABB��������������A���C�BA�������������A
&$ �B����A�AB��ADA���D��A�B��D�ADD�����A��������A��A����������A����ADA�
%$ 1�����A�����D���A ���'����CFA������ADA�����B����A�������������AB��ADA
"��A��CCAA�A���������A�������������������������������
��A�������BB�C�����AB�DA��A��������
ECCADD������������ ���:
&$ .�AC�#�C��A��B�����������A��������AB�DA��A���������*B��D��ABBA�)������B�
%$ C�A���AD �������B��A��D����+.�
@$ "��DA����A��B�DA��A����C��CA�B����������A��� �B�DA��A����������A�����)����A�B�����������A�BA�AB�����
6����E��
EBB������ABB��A#�������A�ABB��)������BA5�D��A#���DC���( �B����A( B����A�D���A( �B������������C���A������A)A����B�A��A�( �B�)�B��A���������B��������A �A)A����B�A��A�$
.�������B�����A��A���A���#�C��A��������D����B�C�������������A������C���A�A��A����$
.�AC�#�C��A��B�����������A�������
.�AC�#�C��A��B�����������A������E�E;��/&
$��<�A���A����� �A �.A��A����+E,���������������������������������C�����A�A5�������A�
;E��$==�/C$FF D%�*��
;E��$==�/C�E= D%�*��
!��B������A��������A��A�DA��B�C�DD�����ADD���������A�����5�����9.� ��A��9.����A�94� ��A��94������������������������������������������������
�BB��DC���������B�����B��C��A�����������)�A�����������������
���A������A �A9����D��A��B���D�����E��F��
;/>�$�4;E��$==�/C$FF
/A��C���C��A����E���B�C��CA�E."���AB�C�����A�A�9.�
)������B�
;/>�$�473(;/>�;E��$==�/C$FF4$�
/A��D�)��DC��)A�A 9.��9.����C���9?� �9?AD��
E."�����9?�
"��)A�D���A����;E��$==�/C$FF �������� &5$%�3!?#
$��/.$
;/>�$�4@3!?#A
���B�1�B����*���D�����������������E�E;��/5
$��<�A���A����� �A����C�����A�A5�������A�
;E��$==�/�D%�*BA���A�����A�BA��AC�
!��B������A��������A�����ADD���������G B����������C�����A�A�����
C#�CC������������D�D�BB��DC���������B�����B��C��A�����������)�A�����������������
1����������A��A�A�A����� �A8
)������BA
.�AC�#�C��A��B�����������A������E�E;��/5
$��<�A���A����� �A����C�����A�A5�������A�
;E��$==�/�D%�*BA���A�����A�BA��AC�
!��B������A��������A�����ADD���������G B����������C�����A�A�����
C#�CC������������D�D�BB��DC���������B�����B��C��A�����������)�A�����������������
1����������A��A�A�A����� �A8
)������BA
EDD�C������A������B����A�ABB��)������BA��0..E>>�-
A�B��B�C�����A����A������CFA�C����A�A��B�C��CA�E."�����#
+E,E��.0>�04,��0..E>>�-2E33������+7�9.��0..E>>�-240>������+7�94��0..E>>�-���������������+7�9#�CC������������D�H�+E,E��04+.
"��A�CBA���AD �������B��A��D����+.�A�A#���������������#���A��D����B��9A#��A� D�����6��D��DA���A��
��DA���A��AB�DA��A�������
������� ������B��
.A��B�����������CFA�D������DC��)A�������������������������������B��C���)A�D���A����C��CA���CCF����D��I �AB�DA��A����"-+�"0���
�D�������A�����������AB�DA��A����A�����
"��A�#��A���#��B��D��A�A��BB��DDA��B����A<��C��DA����A�B����������A��� �B�DA��A���������AB�DA��A����C��CA�
!����C����A<���B �D A��A��������������� ��A���� '���B��������������D�����E
�����������������������
�A�������������� ����������!"#$�%����������
&&&&&&'
��������������������
��������������
(�)�*������������
&&&&&&&&&'�
���������������������
�+��������������
,�ECF-�B���D���.CB/C�00�
�+������������������
"��DA����A�B����������A��� �B�DA��A��������.A��B������������D�������A�����������AB�DA��A�����������������
�B��A��D����+.�A)A�ADDA�A�DA�������B�)�B��A�CFA�����������������B�+-.��)A)��DCAB����A��6�AB�DA��A�������
�B ��A��<��B���A�BA �� �����������������B �D A��A�
�-!�����EJ5+E,E�-!������+.5EJ
K�AD���DA6�A�������D�������������������������������������������A)A�ADDA�A�ADA�������������������������������������������������
������CFA��))A�������6��B��6�A������������������������������������D#A���A����������������������������������������������������
��A��A���B�DA��A��������A#���������+E,E
��6�A
�-!�������������������EJ5�+E,E��:��� .��D������EJ�B����������AB�DA��A����+���B�-!�������������������+.5�EJ�������������:���� .����B�DCA�B����������A��� B$$E..1�0������������+.���+E,E������:� B$�����BA AB�DA��A�������$
K�AD���DA6�A�������D�������������������������������������������A)A�ADDA�A�ADA�������������������������������������������������
������CFA��))A�������6��B��6�A������������������������������������D#A���A����������������������������������������������������
��A��A���B�DA��A��������A#���������+E,E
+.���D�����AB�C�BC�B��A�B������������AB�DA��A����+E,E��������0����� �
,A��B��A ALA A�����
+A# .A��A����"-+�"0
�D� �ACADD���A����0.�DA��A����AL����
���D��ABB���DA��'�� -33.0,ECCADD���BB���##A�A�������������������������������������������
��AB���)���B�DA��A��������
�-!�����7J5�-33.0,��0..E>>�-2E33�-!�����"J5�-33.0,��0..E>>�-240>
.���������
&�%E��%����������������0..E>>�-2E33
&�%E��%�&�������������0..E>>�-240>
EBB���
%%%%%%�%�7 %%%%%%%%�8
�����������������4
%%%%%%�%�7 %%%%%%%��8
�����������������4$%%� $%��
3)��B���A$&$ "��D�A���A��B�DA��A��A
.A�.,EM,2+E,E F���##DA��=�8��AB�DA��A�������5��D��A�0�1��� ��A��A��B��A��B�DA��A��A�#����A�����������������DDA��B� �DDA�)������)�B���������������A��D����A�ABBA�B�C����������A������C���)�B�A
�,$.,CD$,$���D%��54'474?4&&4&'4&3D%�&45464!4'54#64�&5!
,E�,CD$,$����D%��&&45&4'&46&47&4#&4?&4!&.E���,���������D%��!�D���8�
;/>�D-4/FF�E,�.E���,�;/>�1-4/FF�E,�,E�,CD$,$;/>�$(4!;/>�%-4"
�E-,�������$DD�%-4/FF�E,��,$.CD$,$;/>�$�4@%-A��%�%-4/FF�E,��,$.,CD$,$$DD�%-41-$DD�$�4@%-A��%�%-41-$DD�%-4D-;/>�@%-A4$���%�%-4D-��1�%-DE1�$(F�G��E-,
EBC��A��#��������AB�+-.�CF�����A����D�����������������������������DDA��B�
CBA�����������C�����A�A�����D��A��DB$
CD��������)�A�D
3��������AB�+-.�CF�����A����DDA��B� ��� ���A����� �%= �������)A�D��
BB�-!�E85&�4,�%&8BB
�B������BA�#B�DD��DA6�A����BA���ADAC�����A�ABBA��D���������AB#����A�����DDA��B� N ���A��������BB����������������������������������4,%&8��CF���������#������A�AB�+-.�
EB��A����A��B�C�����BB��AB�#B�DD���������B�����������CFA�F��C��D����B����A�������A
��4,�%&8�'O��D�������A��DDA��B� �A��CF�����A�#��������+-.��A��B������P�������
�D���������AB�.-������������������C��CA���CCF��������4,%&8
��&���&�&&&����������������������������&�������������������
BB
3��������AB�+-.�CF�����A����DDA��B� ��� .�AC�#�C��ABBA�#��������+-.��D������B���A���4,�%&8������������
�AB��A��D����E8
BB�-!�E85&�4,�%&8BB
0DA����&�� #������A��&
E��AD��AB�C�����A�A���DA���������D��A��
0##A���
�B�C��CA�E."�����6�AB�C�����A�A��������������������
�AB��A��D����E���D���B���A��A��A��B�C�����A�A�N
��D��������)�A�'ACF��
3��������AB�+-.�CF�����A����DDA��B� ��� .�AC�#�C��ABBA�#��������+-.��D������B���A���4,�%&8������������
�AB��A��D����E8
�-!�+�5�&8����:�E."����A��C�����A�A�E�-!�E85%�4,�%&8BB
0DA����%�� #������A��%
.��������)�A��AB�C�����A�A��B�C���C��CA�
E."���N C���A��������+�
0##A���
�B�C�����A�A�D����������)�A�����C�����6�ABB����ACAA��A�A��A�
D�������
3��������AB�+-.�CF�����A����DDA��B� ��� .�AC�#�C��ABBA�#��������+-.��D������B���A���4,�%&8������������
�AB��A��D����E8
�-!�+J5��##DA���AB���)����+.�������D��-!�E85Q�4,�%&8BB
0DA����@�� #������A��Q
.��������)�A������ADD�������B�C�������������AB���)����+.�N ���+J
��B��D� C����C����BB�������������+J�A�
�A��������R�
0##A���
�ADD������D����������)�A��DA����D��������R
3��������AB�+-.�CF�����A����DDA��B� ��� 0DA�����@���.������������ADD�������#������A��Q�ABB��4,%&8�
+E,E�.0>�04,�BB�.>�+;�C#�CC������������D�DB
+E,E�04+.
EBB����B��DA6�A������AB�DA��A����"-+�"0�
�-!�EJ5�+E,E�-!�+.5EJ
�-!�+J5�-33.0,��.>�-!�E85Q�4,�%&8BB
1������������� ���A�����A���D������D$,�
.��������)�A���B��ADD������C#�CC������������D�D
3��������AB�+-.�CF�����A����DDA��B� ��� 0DA��������
1������������CFA���CA)A�����D��A�������DA6�A������C�����A�������DC�B��������A��)�B���5������������������������������������������������B��D��������)�A�5����������������������������������������������
B��C��)A��A��ABB�A6��)�BA��A�����DC�B��������������������������������A�B��D���������)��A��A���)�A�
40J,2"8�����-!�E85&��������������:�#������A��&����4,�%&8��D� �������-!��4,�%&8��������:�L�����D��A���� L����E�:�ACF�
.17�E�5�%�8����������:�%�8�A�@%+��##A�A��������L�A�J����C� E."��
�-!�+�5�E�������������:�B��#������A��%����4,�%&8�D������:���)�A���B�C���A�������+��
�-!�E85%��������������:�#������A��%����4,�%&8��D� ��������4,�%&8S�/�40J,2"8
3��������AB�+-.�CF�����A����DDA��B� ��� 0DA��������
.��������)�A��E5�7�A�)�����C���5��������������������������������C)�����C������ DD��������)�A��B�E."������������������������������
��������C���ABB���-+8�'B��A��D�CCADD�)���E8��
�-!�E85%��������������:�#������A��%����4,�%&8��D� ��������-!�+�5�&8�����������:�E."�����E���������������������4,�%&8��������
�-!�+�5��%8����������:�E."�����7�4,�%&8������������
�-!�+�5��+8���������:�E."����A����������C���ABB���4,�%&8
�-!�+�5�E8 :�E."����A��B��A��D�CCADD�)��4,�%&8
M�������AB�C�����BB���B�+-.�4,�%&85�#������A��"8�������������������������������������������
1�������A��#����A������A���������������DDA��B�
�-!�E�5�"8�4,�%&8
T �A�A�������DA����A�E�����
,A��B��A ALA A�����
+A# .A��A����"-+�"0
�D� �ACADD���A����0.�DA��A����AL����
�����A��A�B �D A��A������� ���A�D/�
3)��B���A0.C��)A�A���������������DDA��B� CFA�C��DA������
0DA����A�������A�����A#��������)�B�A�BA�DA��A������A����������
&��+������A�����D��A������C�����A�A�E575BU
%����D����B����)�A��C����B�D���D�CCADD�)�:�
@��E���A�C���$��
0D���A��B�����������D��A���.5,5M5E545-
�����������)�A��N�
.,
,1
M.
E7
4�
-/���
3)��B���A�-.C��)A�A���������������DDA��B� CFA�C��DA������
0DA����A�������A�����A#��������)�B�A�BA�DA��A������A��������
&� ��DA���A�����D��A����A�C�#�A���5&5�%BQ�
%� .������A���)�A��.�DA�BA�C�#�A�D��������B��4�DA�D�����)A�DA
0D���A��B�����������D��A���%5@������A�%5%
�����������)�A��N�
%@4������A�%%.
3)��B���A�..C��)A�A���������������DDA��B� CFA�C��DA������
0DA����A�������A�����A#��������)�B�A�BA�DA��A������A��������
&� ��DA���A�����D��A���&5�%���@
%� .������A���)�A���B�C����D���A��A��ADD������
&�* 704!041,�
%�' EMM�!0+0M"�
@�' E++�-�
0D���A��B�����������D��A���&5@5%
�����������)�A��N�
&704!041,�
@E++�-
%EMM�!0+0M"�
"�D���)�AD�A�D���A�A
( "��A��BB�C��A�B���A������A��D��A��������BB�C������������������������������������������������������������1D����)������B���AB�DA��A����+E,���+.��* �ACC���D��������������A�����B�DA��A����+E,����+.��
( "A����D��B�����A������#��������AB�+-.�CF�����A����DDA��B� �A�������P�������* �4,%&8�C���#���������&5�%5�Q5�"�
( ,A��B��A $ALA ��A����� ���������������������������B��A�CFV ABBA��D���������
( "��A�C�D�����A����DA��B�CA�����������ACFA�D��������)�A���B���D�B�����ABBA�D�A���A�������
Cosa saprete
• Il registro flag:– Carry, overflow, sign, zero,parity
• Operazioni aritmetiche su numeri signed e unsigned– Addizione, sottrazione, moltiplicazione,
divisione– Operazioni correlate
Usare il registro flag per monitorare il risultato delle
oprazioni aritmetiche
Registro a 16 bit contenente:-6 flag di stato: vengono modificati dall'EU in base al risultato delle operazioni logiche e aritmetiche- 3 flag di controllo: settati o azzerati dal programma al fine di modificare il comportamento della CPU
I rimanenti bit non sono utilizzati– SF: segno (+ o -)– ZF: risultato Zero– OF: Overflow– CF: Carry– AF: Ausiliary carry– PF: Parità del risultato- IF: Abilitazione Interrupt - DF: Direction-TF: Trap
FLAGS (ricordate?)
Ogni volta che viene eseguita una operazione aritmetica alcuni flag
sono settati a 0 o a 1 per controllare l’effetto dell’operazione.
Ma non tutte le operazioni hanno effetto sui flag
MOV ADD/SUB INC
SF ZF OF CF AF SF ZF OF CF AF
– SF: segno (+ o -)– ZF: risultato Zero
– OF: Overflow– CF: Carry
– AF: Ausiliary carry
FLAGS (quali operazioni-quali flag…. Qualche esempio)
Il flag Carry (CF)- Addizione unsignedRicorda se una operazione aritmetica ha prodotto un numero unsigned
troppo grande/troppo piccolo in un registro/locazione di memoria
MOV AL, 0FFH
ADD AL,4H
???????? | 11111111AX
AH AL
Esempio1: addizione
Il flag Carry (CF)- Addizione unsignedRicorda se una operazione aritmetica ha prodotto un numero unsigned
troppo grande/troppo piccolo in un registro/locazione di memoria
MOV AL, 0FFH
ADD AL,4H
???????? | 11111111AX
AH AL
4H = 00000100B
+
100000011 (= 103H)
8 bit
Esempio1: addizione
Il flag Carry (CF)- Addizione unsignedRicorda se una operazione aritmetica ha prodotto un numero unsigned
troppo grande/troppo piccolo in un registro/locazione di memoria
MOV AL, 0FFH
ADD AL,4H
???????? | 11111111AX
AH AL
4H = 00000100B
???????? | 00000011AX
AH AL
+
100000011 (= 103H)
8 bit
Il numero è troppo grande per essere rappresentato ad 8 bit à bit del carry ad 1
Esempio1: addizione
Il flag Carry (CF) - SottrazioneRicorda se una operazione aritmetica ha prodotto un numero unsigned
troppo grande/troppo piccolo in un registro/locazione di memoria
00000010 | ????????DX
DH DL
Esempio2:sottrazione
MOV DH, 2H
SUB DH, 0FFH
Il flag Carry (CF) - SottrazioneRicorda se una operazione aritmetica ha prodotto un numero unsigned
troppo grande/troppo piccolo in un registro/locazione di memoria
MOV DH, 2H
SUB DH, 0FFH
00000010 | ????????DX
DH DL
Esempio2:sottrazione
0FFH = 11111111B=255D unsiged
Il flag Carry (CF) - SottrazioneRicorda se una operazione aritmetica ha prodotto un numero unsigned
troppo grande/troppo piccolo in un registro/locazione di memoria
MOV DH, 2H
SUB DH, 0FFH
00000010 | ????????DX
DH DL
Esempio2:sottrazione
0FFH = 11111111B=255D unsiged
x-y
x + (-y)
Con (–y) rappresentato in
complemento a due
Il flag Carry (CF) - SottrazioneRicorda se una operazione aritmetica ha prodotto un numero unsigned
troppo grande/troppo piccolo in un registro/locazione di memoria
MOV DH, 2H
SUB DH, 0FFH
00000010 | ????????DX
DH DL
Esempio2:sottrazione
0FFH = 11111111B=255D unsiged
x-y
x + (-y)
Con (–y) rappresentato in
complemento a due
2 - 0FF
2 + (- 0FF)
Con (- 0FF) in complemento a due:
00H +1H = 1H
Il flag Carry (CF) - SottrazioneRicorda se una operazione aritmetica ha prodotto un numero unsigned
troppo grande/troppo piccolo in un registro/locazione di memoria
MOV DH, 2H
SUB DH, 0FFH
00000010 | ????????DX
DH DL
Esempio2:sottrazione
0FFH = 11111111B=255D unsiged
x-y
x + (-y)
Con (–y) rappresentato in
complemento a due
2 - 0FF
2 + (- 0FF)
Con (- 0FF) in complemento a due:
00H +1H = 1H
2H + 1H = 3H
Il flag Carry (CF) - SottrazioneRicorda se una operazione aritmetica ha prodotto un numero unsigned
troppo grande/troppo piccolo in un registro/locazione di memoria
MOV DH, 2
SUB DH, 0FFH
00000010 | ????????DX
DH DL
Esempio2:sottrazione
0FFH = 11111111B=255D unsiged
x-y
x + (-y)
Con (–y) rappresentato in
complemento a due
2 - 0FF
2 + (- 0FF)
Con (- 0FF) in complemento a due:
00H +1H = 1H
2H + 1H = 3H
00000011 | ????????DX
DH DLbit del carry a 1
Il flag Carry (CF) - SottrazioneRicorda se una operazione aritmetica ha prodotto un numero unsigned
troppo grande/troppo piccolo in un registro/locazione di memoria
MOV DH, 2
SUB DH, 0FFH
00000010 | ????????DX
DH DL
Esempio2:sottrazione
0FFH = 11111111B=255D unsiged
x-y
x + (-y)
Con (–y) rappresentato in
complemento a due
2 - 0FF
2 + (- 0FF)
Con (- 0FF) in complemento a due:
00H +1H = 1H
2H + 1H = 3H
00000011 | ????????DX
DH DLbit del carry a 1
2H-0FFH = -0FDH
Risultato scomplementato non rappresentabile in 8 bit
Il flag Overflow (OF) – numeri positiviPer assicurarsi che il risultato di operazioni aritmetiche su numeri
signed sia nel range consentito
Il max signed consentito su 8 bit è +127D (01111111B = 7FH) (1 bit per il segno e 27 = 128 config.)
MOV BL, 4HADD BL, 7FH
Il flag Overflow (OF) – numeri positivi
MOV BL, 4HADD BL, 7FH
Per assicurarsi che il risultato di operazioni aritmetiche su numeri signed sia nel range consentito
00000100B = +4D (signed ad 8 bit)
01111111B = +127D(signed ad 8 bit)
Il max signed consentito su 8 bit è +127D (01111111B = 7FH) (1 bit per il segno e 27 = 128 config.)
Il flag Overflow (OF) – numeri positivi
MOV BL, 4HADD BL, 7FH
Per assicurarsi che il risultato di operazioni aritmetiche su numeri signed sia nel range consentito
00000100B = +4D (signed ad 8 bit)
01111111B = +127D(signed ad 8 bit)
10000011B
+
Il max signed consentito su 8 bit è +127D (01111111B = 7FH) (1 bit per il segno e 27 = 128 config.)
83H (131D unsigned)
???????? | 10000011BX
BH BL
Il flag Overflow (OF) – numeri positivi
MOV BL, 4HADD BL, 7FH
Per assicurarsi che il risultato di operazioni aritmetiche su numeri signed sia nel range consentito
00000100B = +4D (signed ad 8 bit)
01111111B = +127D(signed ad 8 bit)
10000011B (signed ad 8 bit = -7DH= -125D)
+
Il max signed consentito su 8 bit è +127D (01111111B = 7FH) (1 bit per il segno e 27 = 128 config.)
83H (131D unsigned)
???????? | 10000011BX
BH BL
bit di overflow ad 1 (risultato fuori range per rapp. signed-8bit)
Segno (-)
Diverso da
Numero da
scomplementare
Il flag Overflow (OF)Per assicurarsi che il risultato di operazioni aritmetiche su numeri
signed sia nel range consentito
+
Il flag Overflow (OF) – numeri negativiPer assicurarsi che il risultato di operazioni aritmetiche su numeri
signed sia nel range consentito
Il min signed consentito su 8 bit è -128D (10000000B = 80H) (1 bit per il segno e 27 = 128 config)
MOV BL, 0FEHSUB BL, 07FH
11111110B = -2D (signed ad 8 bit) = 254D (unsigned)
01111111B = +127D (signed ad 8 bit)
Il flag Overflow (OF) – numeri negativiPer assicurarsi che il risultato di operazioni aritmetiche su numeri
signed sia nel range consentito
Il min signed consentito su 8 bit è -128D (10000000B = 80H) (1 bit per il segno e 27 = 128 config)
MOV BL, 0FEHSUB BL, 07FH
11111110B = -2D (signed ad 8 bit) = 254D (unsigned)
01111111B = +127D (signed ad 8 bit) -
???????? | 01111111 BX
BH BL 7FH (127D unsigned )
101111111B
Il flag Overflow (OF) – numeri negativiPer assicurarsi che il risultato di operazioni aritmetiche su numeri
signed sia nel range consentito
Il min signed consentito su 8 bit è -128D (10000000B = 80H) (1 bit per il segno e 27 = 128 config)
MOV BL, 0FEHSUB BL, 07FH
11111110B = -2D (signed ad 8 bit) = 254D (unsigned)
01111111B = +127D (signed ad 8 bit) -
???????? | 01111111 BX
BH BL 7FH (127D unsigned )
101111111B
Corretto per sottrazione unsigned
254D - 127D =127D
Il flag Overflow (OF) – numeri negativiPer assicurarsi che il risultato di operazioni aritmetiche su numeri
signed sia nel range consentito
Il min signed consentito su 8 bit è -128D (10000000B = 80H) (1 bit per il segno e 27 = 128 config)
MOV BL, 0FEHSUB BL, 07FH
11111110B = -2D (signed ad 8 bit) = 254D (unsigned)
01111111B = +127D (signed ad 8 bit) -
???????? | 01111111 BX
BH BL 7FH (127D unsigned )
101111111B
Corretto per sottrazione unsigned
254D - 127D =127D
bit di overflow ad 1 (risultato fuori range per rapp. signed-8bit)Ma -2D-127D =-129
Il flag Overflow (OF) – numeri negativi
Il flag del Segno (SF)Indica se il risultato di una operazione aritmetica tra numeri signed è
positivo/negativo (flag settato a 0/1)
MOV AL,2SUB AL,5
00000010B = 2H = +2D (signed ad 8 bit)
00000101B = 5H= +5D (signed ad 8 bit)
11111101B = FDH = -3 (signed a 8 bit)
-
???????? | 11111101AX
AH AL
bit del segno ad 1 (risultato tra signed negativo)
Il flag del Segno (SF)
Il flag del Segno (SF)Indica se il risultato di una operazione aritmetica tra numeri signed è
positivo/negativo (flag settato a 0/1)
MOV AL,3SUB AL,0FFH
00000011B = 3H = +3D (signed ad 8 bit)
11111111B = FFH= -1 (signed ad 8 bit)
00000100B = 4H = 4D(signed a 8 bit)
-
???????? | 00000100AX
AH AL
bit del segno a 0 (risultato tra signed positivo)
Il flag del Segno (SF)
Il flag Zero (Z)Registra se una operazione aritmetica ha prodotto risultato zero
MOV AL,3SUB AL,3
-bit zero a 1
MOV AX,3SUB AX,2
bit zero a 0
Il flag di Parità (Z)Registra se il risultato di una operazione contiene un numero
pari (bit a 1) o dispari di 1 (bit a 0)
MOV AL,3ADD AL,7
00000011B = 3H
00000111B = 7H
00001010B =AH
bit di parità ad 1
+
MOV AH,8SUB AH,1
00001000B = 8H
00000001B = 1H
00000111B =7H
bit di parità a 0
+
FlagOgni istruzione influenza più flag simultaneamente
Istruzione Z-flag C-Flag S-flag O-flag
ADD Si Si Si Si
ADC Si Si Si Si
SUB Si Si Si Si
SBB Si Si Si Si
INC Si No Si Si
DEC Si No Si Si
NEG Si Si Si Si
CMP Si Si Si Si
MUL No Si No Si
IMUL No Si No Si
DIV No No No No
IDIV No No No No
CBW No No No No
CWD No No No No
FlagEsempio
C-flag O-flag S-Flag Z-flag P-flag
? ? ? ? ?
? ? ? ? ?
0 0 0 0 1
0 0 0 1 1
0 0 1 0 0
0 0 1 0 0
MOV BL,3
ADD BL,2
SUB BL,5
SUB BL,2
MOV DH,2
???????? | 00000011BX
BH BL
???????? | 00000101
BH BL
???????? | 00000000
BH BL
???????? | 11111110
BH BL
00000010 | ????????
DH DL
FlagEsempio
C-flag O-flag S-Flag Z-flag P-flag
0 0 1 0 0
1 0 0 0 0
1 0 0 0 0
1 1 1 0 0
ADD DH,0FFH
MOV AL,4H
ADD AL,7FH
00000001 | ????????
DH
DH DL
???????? | 00000100
AH AL
???????? |10000011
BH BL
00000010 | ????????
DH DL
Esercizi1. Verificare i valori del flag per i seguenti estratti
MOV DH,3ADD DH,2ADD DH,1SUB DH,73HADD DH,79HADD DH,2ADD DH,0FAHADD DH,3
MOV CL,1SUBB CL,65HSUB CL,21HSUB CL,86HSUB CL,33H
Addizione & sottrazione
INC ADD ADC
DEC SUB SBB CMP NEG
INC & DECAgiscono su tutti i flag aritmetici (eccetto CARRY)
INC incrementa di 1 il su operandoDEC decrementa di 1 il suo operando
Forma generale(no su registri di segmento)
INC registro DEC registroINC memoria DEC memoria
INC AX
00000011|10101011AX
AH AL
00000011|10101100AX
AH AL
= 03ABH
= 03ACH
ESEMPIO
INC & DEC su REGISTRI
Esempio1
INC AX
00000011|10101011AX
AH AL
00000011|10101100AX
AH AL
= 03ABH
= 03ACH
Esempio2
INC AX
11111111|11111111AX
AH AL
00000000|00000000AX
AH AL
= 0FFFFH
= 0000H
INC & DEC su MEMORIA(pseudo-op BYTE/WORD PTR
à (PTR PoinTeR))
erratoINC [BX]
È necessario comunicare chiaramente se INC o DEC su byte o word
INC BYTE PTR [BX] Per incrementare il byte all’indirizzo DS:BX
INC WORD PTR [BX] Per incrementare la word all’indirizzo DS:BX
INC & DEC(su memoria:)
Esempio: conta è DW à nessuna ambiguità
DATA SEGMENTCONTA DW 0FABCH......
DATA ENDS .......
CODE SEGMENT....
DEC CONTA ; CONTA=0FABBH..........
CODE ENDS
ADDAgiscono su tutti i flag aritmetici (ma l’effetto è su CARRY)
ADD somma
Forma generale(no su registri di segmento)
ADD registro,numeroADD memoria,numeroADD registro,registroADD registro,memoria ADD memoria,registro
Registro: AX BX CX DX Numero: signed/unsigned - 8/16 bit – espressione
Memoria: qualunque locazione indirizzaile
Aggiunge il contenuto del primo operando a quello del secondo e mette il risultato nel primo
ADDAgiscono su tutti i flag aritmetici (ma l’effetto è su CARRY)
esempi
ADD AL,BLADD CX,BXADD BX,BX
ADD AL,27HADD DH,00011011BADD CX,0ABCFHADD AL, ‘N’ ;ASCII 4EH
ADD AX,[BX]ADD AL,MYBYTEADD MYBYTE,CL
ADD registro,registro
ADD registro,numero
ADD registro,memoria
ADD memoria,registro
ADD su MEMORIA(pseudo-op BYTE/WORD PTR
à (PTR PoinTeR))
Errato (3 su 8 o 16 bit?)ADD [BX],3
È necessario comunicare chiaramente se ADD o ADC su byte o word
ADD BYTE PTR [BX], 3 Per aggiungere 3 al byte all’indirizzo DS:BX
ADD WORD PTR [BX],3 Per aggiungere 3 alla word all’indirizzo DS:BX
SUBAgiscono su tutti i flag aritmetici (ma l’effetto su AF è indeterminato)
SUB sottrazione
Forma generale(no su registri di segmento)
SUB registro,numeroSUB memoria,numeroSUB registro,registro SUB registro,memoria SUB memoria,registro
Registro: AX BX CX DX Numero: signed/unsigned - 8/16 bit – espressione
Memoria: qualunque locazione indirizzaile
Sottrae il contenuto del primo operando a quello del secondo e mette il risultato nel primo
SUBAgiscono su tutti i flag aritmetici (ma l’effetto su AF è indeterminato)
esempi
SUB TOTAL,AL
Se TOTAL = 37H e AL=21H
TOTAL= 16H e AL=21H
CMP (CoMPare)Influenza i flag in dipendenza del risultato della sottrazione
CMP confronto
Forma generale(no su registri di segmento)
CMP registro,numeroCMP memoria,numeroCMP registro,registroCMP registro,memoria CMP memoria,registro
Registro: AX BX CX DX Numero: signed/unsigned - 8/16 bit – espressione
Memoria: qualunque locazione indirizzaile
Confronta il contenuto del primo operando a quello del secondo (non cambia i valori dei registri)
CMP
esempi
CMP AL,38H
Se AL = 38H
AL=38H & Z-flag a 1
CMP AL,41H
Se AL=1AH
AL=1AH & S-flag a 1 C-flag a 1
Influenza i flag in dipendenza del risultato della sottrazione
NEGInfluenza tutti i flag & C-Flag ad 1 (se valore diverso da 0)NEG inverte il segno (trasforma in complemento a due)
Forma generale(no su registri di segmento)
NEG registroNEG memoria
Registro: AX BX CX DX Memoria: qualunque locazione indirizzaile
NEG
esempi
NEG CX
Se CX = 00000001 00011001 B = 25 D
CX = 11111110 11100111 B Rappresentazione in complemento a due di -25D
& C-flag ad 1
Influenza tutti i flag & C-Flag ad 1 (se valore diverso da 0)
NEG WORD PTR [BX]
Se DS:BX = 11111111 11110001 B àRappresentazione in complemento a due di -15D
DS:BX = 00000001 00001111 B Rappresentazione di 15 al 16 bit signed & C-flag ad 1
Moltiplicazione
Tra signed (IMUL – Integer MULtiplication)Tra unsigned (MUL)
IMULAgiscono su tutti i flag aritmeticiIMUL moltiplicazione tra signed
Forma generale(no su registri di segmento)
IMUL registroIMUL memoria
Se due numeri ad 8 bit:uno nel registro AL (altro operando della IMUL: memoria/registro)
Risultato in AXSe due numeri a 16 bit:
Uno nel registro AX (altro operando della IMUL: memoria/registro) Risultato in AX e DX
IMUL
esempi
IMUL CL
Se AL = 61H e CL= 4H
Influenza tutti i flag
AL 01100001 B(= 61H)CL 00000100 B(= 4H)
AX 0000000110000100 B(= 0184H)
MULAgiscono su tutti i flag aritmetici
MUL moltiplicazione tra unsigned
Forma generale(no su registri di segmento)
MUL registroMUL memoria
Se due numeri ad 8 bit:uno nel registro AL (altro operando della MUL: memoria/registro)
Risultato in AXSe due numeri a 16 bit:
Uno nel registro AX (altro operando della MUL: memoria/registro) Risultato in AX e DX
Esercizio11. Scrivi un frammento assembly che
1. Lasci in DX,AX il valore di (a*(b-c) *d) dove a, b, c, d denotano rispettivamente il contenuto di AL, BL, CL, e DL in formato signed ad 8 bit. (assumi che il risultato sia rappresentato come signed a 32 bit)
2. Lasci (a+b) * (a+b) *(c-d) in DX,AX dove a, b, c, d sono come in 1.
2. Scrivi un programma assembly che accetti come input da tastiera una cifra tra 0..9 e
1. stampi una nuova linea a video
2. Stampi il doppio della cifra in input a video seguito da nuova linea
3. Scrivi un programma assembly che accetti come input da tastiera due cifre tra 0..9 e
1. Stampi il loro prodotto seuito da nuova linea
Es: Prima cifra: 3
Seconda cifra:7
il loro prodotto è 21
Divisione
Tra signed (IDIV – Integer DIVision)Tra unsigned (DIV)
IDIVAgiscono su tutti i flag aritmetici
IDIV divisione tra signed
Forma generale(no su registri di segmento)
IDIV registroIDIV memoria
Divisione di un numero a 32 bit:Il numero deve essere nei registro DX e AX (altro operando della IDIV: memoria/registro)Quoziente in AX resto in DX
Divisione di un numero a 16 bit:Il numero deve essere nel registro AX (altro operando della IDIV: memoria/registro) Quoziente in AL e resto in AH
DX AX
Numero a 16 bit in Registro /memoria
AX=
AX
Numero a 8 bit in Registro /memoria
AL=
DX
resto
AH
resto
IDIV
esempi
IDIV CL
Se AX = 0056H e CL= 11H
Influenza tutti i flag
AL 00000101 B(= 5H) (risultato)AH 00000001 B(= 1H) (resto)
56H =(5*11H)+1
IDIV TOTAL
Se DX = 0002H AX = 44ACH e TOTAL = 3H (word)
AX 1100000110001011 B(= 5H) (risultato)DX 0000000000000001 B(= 1H) (resto)
000244ACH =(C18BH*3H)+1
DIVAgiscono su tutti i flag aritmetici
DIV divisione tra unsigned
Forma generale(no su registri di segmento)
DIV registroDIV memoria
Divisione di un numero a 32 bit:Il numero deve essere nei registro DX e AX (altro operando della IDIV: memoria/registro)Quoziente in AX resto in DX
Divisione di un numero a 16 bit:Il numero deve essere nel registro AX (altro operando della IDIV: memoria/registro) Quoziente in AL e resto in AH
DX AX
Numero a 16 bit in Registro /memoria
AX=
AX
Numero a 8 bit in Registro /memoria
AL=
DX
resto
AH
resto
DIVISIONE PER 0Probabilmente dovete rilanciare
il vostro programma!!!!
J
Esercizio21. Scrivi un frammento assembly che
1. Lasci in AX il valore di (a-b) / (c-d) dove a, b, c, d denotano il rispettivamente il contenuto di AX, BX, CX, e DX in formato signed a 16 bit. (assumi che c-d sia non zero)
2. Lasci (a+b+c)/3 in DX,AX dove a, b, c, d sono come in 1.
2. Scrivi un programma assembly che calcoli la media di 10 cifre (0..9) in input da tastiera. Il programma deve:
1. chiedere all’utente il numero di cifre su cui deve essere calcolata la media (ese. Stampare a video il msg “digita il numero di cifre:”)
2. Attendere l’input e la pressione del tasto ENTER
3. Stampare una nuova linea
4. Richiedere ogni cifra nella forma: “inserire cifra 1”
5. Attendere l’input della cifra e del tasto ENTER
6. Quando tutte le cifre sono state inserite
7. Stampare nuova linea
8. Calcolare la media e stampare il risultato
Esempio
Digita il numero di cifre: 3
Inserire cifra 1: 4
Inserire cifra 2: 2
Inserire cifra 3: 3
La media è: 3
Un esempio di programma su operazioni aritmetiche
Un programma che trova tutti i numeri interi a 3 cifre nell’intervallo 100D…999D,
il cui valore è pari alla somma dei cubi delle sue cifre
Es: 153 = 13 + 53 +33
EsempioMemorizziamo le tre cifre in tre word inizializzandole ad 1 0 0
PRIMA_CIFRA DW 1SECONDA_CIFRA DW 0TERZA_CIFRA DW 0
Ripeti• calcola il cubo di ogni cifra e aggiungi il valore in BX• metti la rappresentazione binaria del numero che le cifre rappresentano in AX• Confronta AX e BX. Se sono uguali:
• converti ogni cifra nel suo codice ASCII• stampa a video la cifra• vai a nuova linea
• incrementa il numeroFinchè non arrivi a 999
Esempio (in EMU8086)DATA SEGMENT
PRIMA_CIFRA DW 1SECONDA_CIFRA DW 0TERZA_CIFRA DW 0
DATA ENDS
STACK SEGMENT STACKDW 100H DUP(?)
STACK ENDS
CODE SEGMENTMOV AX,DATAMOV DS,AXMOV ES,AX
; calcola il cubo di ogni cifra e metti il risultato in BXNUOVO_NUMERO: MOV AX,PRIMA_CIFRA
MOV CX,AXMUL CX ; moltiplica cont. Di CX per AX à AX,DXMUL CX ; moltiplica cont. Di CX per AX à AX,DXMOV BX,AX
Esempio (cont.)MOV AX,SECONDA_CIFRAMOV CX,AXMUL CX ; moltiplica cont. Di CX per AX à AX,DXMUL CX ; moltiplica cont. Di CX per AX à AX,DXADD BX,AX
MOV AX,TERZA_CIFRAMOV CX,AXMUL CX ; moltiplica cont. Di CX per AX à AX,DXMUL CX ; moltiplica cont. Di CX per AX à AX,DXADD BX,AX
; rappresentazione binaria del numero che le cifre rappresentanoMOV AX,PRIMA_CIFRAMOV CX,10DMUL CXADD AX,SECONDA_CIFRAMUL CXADD AX,TERZA_CIFRA
; confrontoCMP AX,BX
; se sono uguali effettua la stampa a video delle cifre
Esempio (cont)MOV AX,SECONDA_CIFRAMOV CX,AXMUL CX ; moltiplica cont. Di CX per AX à AX,DXMUL CX ; moltiplica cont. Di CX per AX à AX,DXADD BX,AX
MOV AX,TERZA_CIFRAMOV CX,AXMUL CX ; moltiplica cont. Di CX per AX à AX,DXMUL CX ; moltiplica cont. Di CX per AX à AX,DXADD BX,AX
; rappresentazione binaria del numero che le cifre rappresentanoMOV AX,PRIMA_CIFRAMOV CX,10DMUL CXADD AX,SECONDA_CIFRAMUL CXADD AX,TERZA_CIFRA
; confrontoCMP AX,BX
; se sono diversi (Z-f a 1) prendi le successive tre cifre (va NUOVE_CIFRE)JNZ NUOVE_CIFRE
Esempio (cont.); altrimenti: converti in codice ASCII le tre cifre e stampa a video
MOV DX,PRIMA_CIFRAADD DL,30HMOV AH,2HINT 21H
MOV DX,SECONDA_CIFRAADD DL,30HMOV AH,2HINT 21H
MOV DX,TERZA_CIFRAADD DL,30HMOV AH,2HINT 21H
; stampa a video nuova lineaMOV DL,0DHINT 21HMOV DL,0AHINT 21H
Esempio (cont); prendi le successive tre cifre:
INC TERZA_CIFRACMP TERZA_CIFRA,10DJNZ NUOVO_NUMERO ;ricordate che il sistema è posizionaleMOV TERZA_CIFRA,0INC SECONDA_CIFRACMP SECONDA_CIFRA,10DJNZ NUOVO_NUMEROMOV SECONDA_CIFRA,0INC PRIMA_CIFRACMP PRIMA_CIFRA,10BJZ FINEJMP NUOVO_NUMERO
;ritorno a DOS (già incluso nel template)
FINE: MOV AX,4C00HINT 21H
CODE ENDS
Esercizio3 (cimentatevi)1. Scrivi un programma assembly per trovare tutti i numeri decimali a tre cifre per i
quali la somma delle cifre sia esatto divisore del prodotto delle cifre stesse.
Esempio: il numero 862
8+6+2 = 16 8*6*2 = 96 e 96/16=6 (resto 0)
Cosa saprete
• Ancora istruzioni di salto
• Cicli
• Scelte
Usare le istruzioni di salto per alterare il flusso sequenziale
del programma
Cosa dovreste saprete……a proposito delle istruzioni di salto
• Alterano il flusso di controllo durante l’esecuzione del programma
• JZ, JNZ, JMP
JZ <etichetta>
JNZ <etichetta>
JMP <etichetta>
Salta ad <etichetta> se il risultato dell’ultima operazione aritmetica è stato zero (ZF)
Salta ad <etichetta> se il risultato dell’ultima operazione aritmetica è stato diverso da zero
Salta ad <etichetta>
Ancora salti(kit essenziale L)
nome Salta se Fleg testati
JMP --- ----
JZ zero Zf = 1
JNZ Not zero Zf = 0
JA
(unsigned)
Above 0 (Cf & Zf)=0
JB
(arithmetic)
Below 0 CF=1
JG
(signed)
Greater then 0 Zf=0 & Sf=Of
JL
(arithmetic)
Less then 0 Sf<>Of
Implementazionedei cicli
Repeat-untilRipeti
azione 1
azione 2
….
azione n
Finchè <condizione>
START_REPEAT:
implementazione azione 1
implementazione azione 2
….
implementazione azione n
Se <condizione> non vera salta a START_REPEAT
Struttura equivalente in assembly
Repeat-until(esempio in pseudo-ling usando i registri)
Ripeti
AX:= AX -1;
BX:= BX+1;
CX:= AX-BX
Finchè <AX=0>
START_REPEAT:
DEC AX
INC BX
MOV CX,0
ADD CX,AX
SUB CX,BX
CMP AX,0
JNZ START_REPEAT
Struttura equivalente in assembly
While-doMentre <condizione> do begin
azione1
azione 2
….
azione n
Fine
START: if <condizione> non vera salta a STOPimplementazione azione 1
implementazione azione 2
….
implementazione azione n
STOP:
Struttura equivalente in assembly
While-do(esempio in pseudo-ling usando i registri)
Mentre AX < 100D do begin
AX:= AX +BX;
BX:= BX+1;
end
START: CMP AX,100D
JNB STOP ; salta se non minore
ADD AX,BX
INC BX
JMP START
STOP:
Struttura equivalente in assembly
Salta se è maggiore o uguale
For-doFor i := valore_iniz to i:= valore_fin do begin
azione1
azione 2
….
azione n
Fine
MOV CONTA_CICLI, valore_iniz
START: CMP CONTA_CICLI, valore_fin
JA STOP ; salta se è maggiore
implementazione azione 1
implementazione azione 2
….
implementazione azione n
INC CONTA_CICLI
JMP START
STOP:
Struttura equivalente in assembly
For-doFor i := 3 to i:= 25D do begin
AX := AX+BX
BX:= BX-1
Fine
MOV CONTA_CICLI, 3
START: CMP CONTA_CICLI, 25D
JA STOP
ADD AX,BX
DEC BX
INC CONTA_CICLI
JMP START
STOP:
Struttura equivalente in assembly
Esercizio11. Generare la una sequenza di numeri a partire da un numero n
applicando i seguenti passi
1. Se n=1 stop
2. Se n è pari, il successivo numero m è n/2
3. Se n è dispari, il successivo numero m è (3*n) +1
Quindi applica queste regole per generare il successivo numero nella sequenza a partire da m, ecc.
Es:
Se la sequenza parte da 5
å 5, 16, 8, 4, 2, 1
Scrivi un programma assembly che, dato un n iniziale in AX, 1<=n<=20D,
Genera la sequenza appropriata e la stampa a video.
Esercizio21. Una frase ben-formata è una il cui il numero di A non eccede mai il
numero di O
Es:
Evviva le vacanze di natale
å E’ un frase non ben-formata
Hoooooooo! Che rottura!!
å E’ un frase ben-formata
Scrivi un programma assembly che controlli se una frase data da tastiera è ben formata oppure no.
Il programma deve stampare a video
1) Bravo! La frase è ben formata
2) Ciucciarello!!!
A seconda della situazione
Istruzioni LOOP
(una ristretta cerchia di possibilità)LoopLoopzloopnz
Loop
For i := 3 to i:= 25D do begin AX := AX+BX
BX:= BX-1
Fine
MOV CX, 25D
START: ADD AX,BX
DEC BX
DEC CX
JNZ START
STOP:
Struttura equivalente in assembly
LOOP START
(ma nessun flag è influenzato)
MOV CX, 25D
START: ADD AX,BX
DEC BX
LOOP START
STOP:
Migliore implementazione
Decrementa il registro CX senza influenzare i flag
LOOP
Non agisce direttamente sui flag
Decrementa il registro CX e consente iterazioni in numero definito(senza condizioni aggiunte)
Forma generale(no su registri di segmento)
LOOP <etichetta>
Loop
MOV BX, OFFSET LETTERE
MOV CX,30H ; numero di byte che devono essere trasferiti dalla ;memoria per essere convertiti
LOC_SUCC: MOV AL,[BX]
ADD AL,20H ;32D=20H è la distanza tra ASCII di ‘X’ ed ASCII di ‘x’
MOV [BX],AL
INC BX
LOOP LOC_SUCC ; finchè il valore di CX = 0
Un programma che converte 30H (48D) lettere maiuscole memorizzate a partire dalla locazione individuata dalla variabile LETTERE,
nell’equivalente minuscolo
LOOPZ & LOOPNZ
Non agisce direttamente sui flag
LOOPZ Decrementa il registro CX e fa saltare ad <etichetta> se CX <> 0 & Z-flag=1
“Cicla mentre il risultato è 0 e CX è non 0 ”
Forma generale(no su registri di segmento)
LOOPZ <etichetta>LOOPNZ <etichetta>
Consente ripetizioni di gruppi di istruzioni con condizione
LOOPNZ Decrementa il registro CX e fa saltare ad <etichetta> se CX <> 0 & Z-flag=0
“Cicla mentre il risultato è 1 e CX è non 0 ”
LOOPZ
MOV BX, OFFSET LETTERE
MOV CX,30H ; numero di byte che devono essere trasferiti dalla ;memoria per essere convertiti
MOV AL,[BX] ; il primo byte da trasferire è sicuramente una X
LOC_SUCC:ADD AL,20H ;32D=20H è la distanza tra ASCII di ‘X’ ed ASCII di ‘x’
MOV [BX],AL
INC BX ; seleziona il byte successivo
MOV AL,[BX]
CMP AL,’X’
LOOPZ LOC_SUCC ; se è una ‘X’ ripeti se CX<>0
Un programma che guarda 30H (48D) locazioni di memoria a partire dalla locazione individuata dalla variabile LETTERE. e converte ogni occorrenza
maiuscola di X in minuscolo, fintanto che non viene letta una lettera diversa da X.
Si supponga che il testo memorizzato costituisca una sequenza di ‘X’ (almeno 1) seguita da altre lettere.
LOOPNZ
MOV BX, OFFSET LETTERE
MOV CX,30H ; numero di byte che devono essere trasferiti dalla ;memoria per essere convertiti
MOV AL,[BX] ; il primo byte da trasferire è sicuramente una X
LOC_SUCC:ADD AL,20H ;32D=20H è la distanza tra ASCII di ‘X’ ed ASCII di ‘x’
MOV [BX],AL
INC BX ; seleziona il byte successivo
MOV AL,[BX]
CMP AL,’W’
LOOPNZ LOC_SUCC ; se non è una ‘W’ ripeti se CX<>0
Un programma che guarda 30H (48D) locazioni di memoria a partire dalla locazione individuata dalla variabile LETTERE.
Converte in minuscolo la prima lettera (maiuscola) che trova. Converte in minuscolo tutte le altre lettere finchè non trova la letter ‘W’
JCXZ
Istruzione di salto condizionato
JCXZ non decrementa CX
Forma generale(no su registri di segmento)
JCXZ <etichetta>
Utile insieme ai LOOP: quando una condizione del LOOP deve essere testata all’inizio invece che alla fine
JCXZ
……
…… ; istruzioni per settare CX al numero di ripetizioni da ; effettuare
JCXZ FATTO ; controlla che CX sia diverso da 0
SUCC: ……
…..
LOOP SUCC
FATTO:
……
……
Supponete che CX venga settato da qualche parte nel programma e che le ripetizioni debbano terminare quando CX diventa minore di 0
Esercizio21. Scrivere un programma assembly che calcola i primi 20D valori della
serie di fibonacci che comincia con due 1 e prosegue con ogni numero che è la somma dei due precedenti:
Es: 1 1 2 3 5 8 13….
Usate l’istruzione LOOP e lasciate ogni valore in un gruppo di locazioni di memoria a partire da quella cui la variabile FIB_NOS si riferisce
2. 100D cifre decimali sono memorizzate in memoria, una per byte. Partendo dalla cifra memorizzata nell’indirizzo piu’ basso, sommate singolarmente le cifre (in AX) finchè il totale è un numero pari.
Es: Data la sequenza di cifre 1,2,6,8,2,6,7,8,9,3,2,1,….
la computazione termina dopo aver incontrato le prime 7 cifre con AX=25
Usate LOOP o LOOPZ o LOOPNZ
Implementazionedelle decisioni
If-then-else
If <condizione> then azione 1 else azione 2
Testa <condizione> se è falsa sata ad AZIONE_2
…… ; istruzioni per implementazione di azione1
……
JMP FATTO
AZIONE_2:
……… ; istruzioni per implementazione di azione2
………
FATTO:
Struttura equivalente in assembly
If-then-else
If AX=0 then
CX=CX-AX
INC AX
DX=DX+AX
else
CX = CX-23D
CMP AX,0
JNZ ACTION_2
SUB CX,AX
INC AX
ADD DX,AX
JMP FATTO
AZIONE_2: SUB CX,23D
FATTO:
Struttura equivalente in assembly
Case-of
case variabile of:
valore_1: azione_1
valore_2:azione_2
…
valore_n:azione_n
end
CMP valore,valore_1
JZ AZIONE1
CMP valore,valore_2
JZ AZIONE_2
……
CMP valore,valore_n
JZ AZIONE_N
AZIONE_1:….. ;implementazione azione1
…..
JMP FINE
AZIONE_2:…… ;implementazione azione2
…..
JMP FINE
………..
AZIONE_N:……. ;implementazione azione3
………..
FINE: …….
……
Struttura equivalente in assembly
Case-of
case AL of:
‘A’: CL:=‘c’; DL:=‘d’
‘B’: CL:=‘e’; DL:=‘f’
‘C’: CL:=‘g’; DL:=‘h’
end
CMP AL,’A’
JZ AZIONE1
CMP AL,’B’
JZ AZIONE_2
CMP AL, ‘’C’
JZ AZIONE_3
AZIONE_1:MOV CL,‘c’
MOV DL,’d’
JMP FINE
AZIONE_2:
…..
JMP FINE
………..
AZIONE_N:……. ;implementazione azione3
………..
FINE: …….
……
Struttura equivalente in assembly
Esercizio31. Scrivere un programma assembly che accetti in input una lettera
maiuscola (da tastiera) e mostri a video un messaggio secondo il seguente schema, e poi stampi una nuova linea:
Lettera messaggio
A messaggio1
B messaggio2
C messaggo3
D messaggio4
Tutte le altre lettere no-comment
Se l’utente digita qualunque altra lettera.
Un esempio di programma su cicli e decisioni
EsempioUn programma che proponga all’utente tre domande a cui rispondere e
fornisca consigli sul tipo di lavoro adatto a lui.
Domande:1) Hai dimestichezza con i computer?
2) Ti piace molto bere il caffè?3) Ti piacciono le feste?
Risposta 1 2 3 Consiglio
si ? ? segretaria
no si si Barista
no ? no Organizzatore di eventi
? Significa domanda non pertinente
EsempioL’utente può rispondere ad ogni domanda digitando “S” o “N” (da
tastiera)
Esempio di interazioneHai dimestichezza con i computer? NTi piace molto bere il caffè?STi piacciono le feste?S
Bene! Dovresti fare il barista!!
Il programma chiede se ci sono altri utenti che vogliono rispondere alle domande
Se il programma non riesce a dare un consiglio deve mostrare a video il messaggio:
“non so che dirti”
EsempioStruttura del programma
Ripeti• chiedi la prima domanda• memorizza la risposta• chiedi la seconda domanda• memorizza la risposta• chiedi la terza domanda • memorizza la risposta • stampa a video nuova linea • SE (risposta1 = si) ALLORA lavoro:= segretaria• ALTRIMENTI SE (risposta2 = si e risposta3 = si)
•ALLORA lavoro:= barista• ALTRIMENTI SE risposta3=no• ALLORA lavoro:= org.zatore di eventi • ALTRIMENTI lavoro:= nessuno
• Mostra a video il lavoro individuato.• Chiedi se esistono altri utenti• memorizza rispostaFinchè risposta=no
Esempio (in EMU8086)CR EQU 0DH ; EQU å costante “ritorno carrello”LF EQU 0AH ; nuova linea
DATA SEGMENTDOMANDA_1 DB CR,LF,’Hai dimestichezza con i computer?’,CR,LF,’$’DOMANDA_2 DB CR,LF,’Ti piace molto bere il caffè?’,CR,LF,’$’DOMANDA_3 DB CR,LF,’Ti piacciono e feste?’,cr,lf,’$’
RISPOSTA_1 DB ?RISPOSTA_2 DB ?RISPOSTA_3 DB ?
SEGRETARIA DB ‘ti consiglio di fare la segretaria’,CR,LF,$BARISTA DB ‘ti consiglio di fare il barista’,CR,LF,$ORGANIZZATORE DB ‘ti consiglio di fare l’organizzatore di eventi’,CR,LFSCONOSCIUTO DB ‘non so che dire’NUOV_UTENTE DB CR,LF,CR,LF,’altri utenti?’,CR,LF,$
DATA ENDS
STACK SEGMENT STACKDW 100H DUP(?)
STACK ENDS
Esercizio (in EMU8086)CODE SEGMENT
MOV AX,DATAMOV DS,AXMOV ES,AX
;includere codiceCODE ENDS
Cosa saprete
•!Strutturare un programma in linguaggio assembly
•!Subroutines
•! Lo stack e il suo ruolo nel meccanismo delle subroutines
•!CALL e RET (Intra segment)
•! Inter segment subourines
Programmi assembly strutturati
Partiamo da un esempio Sia dato un testo in lingua italiana. Si vuole scrivere
un programma assemby
•! memorizzi nel registro AX la lunghezza della frase del testo più lunga (in caratteri, spazi
inclusi)
•! memorizzi nel registro CX l’indirizzo (relativo a DS) di inizio di quella frase.
La lunghezza massima di ogni frase è 255 caratteri (spazi inclusi).
Il codice ASCII di $ indica la fine della frase
Partiamo da un esempio Una soluzione: quali variabili sono richieste
1.! Per memorizzare la lunghezza di frase maggiore corrente
2.! Per memorizzare l’indirizzo di partenza di quella frase
3.! Per memorizzare l’indirizzo del carattere in considerazione
4.! Per memorizzare il numero di caratteri della frase che si sta esamiando
5.! Per memorizzare un carattere della frase che si sta esaminando (per controllarlo con “.”)
Di che tipo sono queste variabili? Byte/word…
signed/unsigned
Partiamo da un esempio Una soluzione: quali variabili sono richieste
1.! Per memorizzare la lunghezza di frase maggiore corrente
2.! Per memorizzare l’indirizzo di partenza di quella frase
3.! Per memorizzare l’indirizzo del carattere in considerazione
4.! Per memorizzare il numero di caratteri della frase che si sta esamiando
5.! Per memorizzare un carattere della frase che si sta esaminando (per controllarlo con “.”)
Di che tipo sono queste variabili? Byte/word…
signed/unsigned
Per gli indirizzi
Unsigned a 16 bit (ricordate il meccanismo d calcolo
degli indirizzi?)
Partiamo da un esempio Una soluzione: quali variabili sono richieste
1.! Per memorizzare la lunghezza di frase maggiore corrente
2.! Per memorizzare l’indirizzo di partenza di quella frase
3.! Per memorizzare l’indirizzo del carattere in considerazione
4.! Per memorizzare il numero di caratteri della frase che si sta esamiando
5.! Per memorizzare un carattere della frase che si sta esaminando (per controllarlo con “.”)
Di che tipo sono queste variabili? Byte/word…
signed/unsigned
Max lunghezza 255
Unsigned a 8 bit
Partiamo da un esempio Una soluzione: quali variabili sono richieste
1.! Per memorizzare la lunghezza di frase maggiore corrente
2.! Per memorizzare l’indirizzo di partenza di quella frase
3.! Per memorizzare l’indirizzo del carattere in considerazione
4.! Per memorizzare il numero di caratteri della frase che si sta esamiando
5.! Per memorizzare un carattere della frase che si sta esaminando (per controllarlo con “.”)
Di che tipo sono queste variabili? Byte/word…
signed/unsigned
UN CARATTERE <-->
1 BYTE
Partiamo da un esempio Una soluzione: quali variabili sono richieste
USIAMO registri o memoria?
VARIABILE REGISTRO COMMENTO
maxLungh la lunghezza di frase maggiore corrente
maxIndirizzo l’indirizzo di partenza di quella frase
Indirizzo l’indirizzo del carattere in considerazione
contCarattere il numero di caratteri della frase che si sta esaminando
carattere un carattere della frase che si sta esaminando (per controllarlo con “.”)
Partiamo da un esempio Una soluzione: quali variabili sono richieste
USIAMO registri o memoria?
VARIABILE REGISTRO COMMENTO
maxLungh la lunghezza di frase maggiore corrente
maxIndirizzo l’indirizzo di partenza di quella frase
Indirizzo l’indirizzo del carattere in considerazione
contCarattere il numero di caratteri della frase che si sta esaminando
carattere un carattere della frase che si sta esaminando (per controllarlo con “.”)
•!nel registro AX: la lunghezza della frase del testo più lunga
•!nel registro CX l’indirizzo (relativo a DS) di inizio di quella frase.
La traccia diceva:
Partiamo da un esempio Una soluzione: quali variabili sono richieste
USIAMO registri o memoria?
VARIABILE REGISTRO COMMENTO
maxLungh AX (o AL?) la lunghezza di frase maggiore corrente
maxIndirizzo CX (o CL?) l’indirizzo di partenza di quella frase
Indirizzo l’indirizzo del carattere in considerazione
contCarattere il numero di caratteri della frase che si sta esaminando
carattere un carattere della frase che si sta esaminando (per controllarlo con “.”)
•!nel registro AX: la lunghezza della frase del testo più lunga
•!nel registro CX l’indirizzo (relativo a DS) di inizio di quella frase.
La traccia diceva:
Partiamo da un esempio Una soluzione: quali variabili sono richieste
USIAMO registri o memoria?
VARIABILE REGISTRO COMMENTO
maxLungh AL la lunghezza di frase maggiore corrente
maxIndirizzo CX l’indirizzo di partenza di quella frase
Indirizzo l’indirizzo del carattere in considerazione
contCarattere il numero di caratteri della frase che si sta esaminando
carattere un carattere della frase che si sta esaminando (per controllarlo con “.”)
•!nel registro AX: la lunghezza della frase del testo più lunga
•!nel registro CX l’indirizzo (relativo a DS) di inizio di quella frase.
La traccia diceva:
Partiamo da un esempio Una soluzione: quali variabili sono richieste
USIAMO registri o memoria?
Usiamo registri, ma non sempre sono sufficienti
VARIABILE REGISTRO COMMENTO
maxLungh AL la lunghezza di frase maggiore corrente
maxIndirizzo CX l’indirizzo di partenza di quella frase
Indirizzo BX l’indirizzo del carattere in considerazione
contCarattere DH il numero di caratteri della frase che si sta esaminando
carattere DL un carattere della frase che si sta esaminando (per controllarlo con “.”)
Partiamo da un esempio Una soluzione: in pseudo-pascal
Indirizzo:= indirizzo del primo carattere nel testo
maxLungh:=0; MaxIndirizzo:= Indirizzo; read(carattere);
While char<> “$” do
begin
*(conta fino alla fine della frase)*
contCarattere :=0;
while carattere <> “.” do
begin
contCarattere := contCarattere +1;
Indirizzo:= Indirizzo +1;
Read(carattere);
end;
Partiamo da un esempio Una soluzione: in pseudo-pascal
*(confornta la lunhezza di questa frase con la massima attuale)*
if contCarattere > maxLungh then
begin
maxLungh := contCarattere;
maxIndirizzo := indirizzo - contCarattere;
end;
*(inizio lettura nuova frase)
indirizzo:= indirizzo +1;
Read(carattere);
end;
Partiamo da un esempio Una soluzione: in assembly
DATA SEGMENT START_OF_TEXT DB ……… DATA ENDS
CODE SEGMENT
MOV BX, OFFSET START_OF_TEXT …………..
CODE ENDS
Lasciato a voi come esercizio!!! (attenzione alla corretta strutturazione dei cicli!!!)
Subroutines
Una tecnica valida per spezzettare un codice in pezzi
più piccoli
(… e renderlo più leggibile)
Partiamo da un esempio Un frammento di programma assembly che memorizzi la
somma numeri unsigned-16 bit in AX, BX,CX,DX
CODE SEGMENT
…….
…….
MOV SI,0
ADD SI,AX
ADD SI,BX
ADD SI,CX
ADD SI,DX
…………..
CODE ENDS
Partiamo da un esempio Un frammento di programma assembly che memorizzi la
somma numeri unsigned-16 bit in AX, BX,CX,DX
CODE SEGMENT
…….
…….
SOMMA_DI_REGISTRI: MOV SI,0
ADD SI,AX
ADD SI,BX
ADD SI,CX
ADD SI,DX
RET ………….. ……… CALL SOMMA_DI_REGISTRI …………
CODE ENDS
IN UNA SUBROUTINES
Definizione della subroutine
Chiamata alla subroutine
Esecuzione della subroutine Un frammento di programma assembly che memorizzi la
somma numeri unsigned-16 bit in AX, BX,CX,DX
CODE SEGMENT
…….
…….
SOMMA_DI_REGISTRI: MOV SI,0
ADD SI,AX
ADD SI,BX
ADD SI,CX
ADD SI,DX
RET ………….. ……… CALL SOMMA_DI_REGISTRI …………
CODE ENDS
IN UNA SUBROUTINES
INIZIO_PROGRAMMA
…….
CALL SOMMA_DI_REGISTRI
………….. ……… …………
CODE ENDS
MOV SI,0 ADD SI,AX ADD SI,BX ADD SI,CX ADD SI,DX RET
RETurn
Partiamo da un esempio Un frammento di programma assembly che memorizzi la
somma numeri unsigned-16 bit in AX, BX,CX,DX
CODE SEGMENT
SOMMA_DI_REGISTRI: MOV SI,0
ADD SI,AX
ADD SI,BX
ADD SI,CX
ADD SI,DX
RET MOV AX, 0 MOV BX, 0 MOV CX,0 MOV DX,1 CALL SOMMA_DI_REGISTRI MOV AX,2 CALL SOMMA_DI_REGISTRI MOV BX,3 MOV CX,4 CALL SOMMA_DI_REGISTRI CODE ENDS
Definizione della subroutine
chiamate
Esercizio1 1.! Scrivere una subroutine assembly chiamata CLAC_EURO_EQUIV, che
dato in AX un numero unsigned-16 bit che rappresenti un valore in dollari, memorizzi in nello stesso AX un unsigned 16-bit che rappresenti l’equivalente valore in EURO (solo parte intera)
Lo stack e il suo ruolo nel meccanismo delle subroutines
Allocazione di memoria con stack Assemblatore prepara lo stack appena prima che inizi l’esecuzione del nostro
programma
Fine spazio di memoria disponibile
Locazione 0
DATI
STACK
PROGRAMMA
E’ da specificare quanta memoria per lo stack
WORKING_STORAGE SEGMENT STACK
DW 100H DUP(?)
WORKING_STORAGE ENDS
PUSH & POP Per memorizzare e recuperare dati dallo stack
Forma generale (no su registri di segmento)
PUSH <16-bit registro> POP <16-bit registro>MUL memoria
Per un corretto uso (a carico di ASSEMBLATORE E S.O.)
•! settare il registro di segmento SS all’indirizzo di inizio del segmento
•!Settare il registro SP (stack pointer) all’indirizzo OFFSET del top dello stack
Esempio PUSH
………… STACK SEGMENT STACK DW 100H DUP(?) STACK ENDS
CODE SEGMENT MOV AX,DATA MOV DS,AX MOV ES,AX ………. PUSH BX …………. CODE ENDS
Si supponga che SP (stack pointer) = 201H &
Fine spazio di memoria disponibile
Locazione 0
DATI
STACK
PROGRAMMA
SP 0201H 0200H 01FFH 01FEH
BX 1A
BL
9E
BH
………… STACK SEGMENT STACK DW 100H DUP(?) STACK ENDS
CODE SEGMENT MOV AX,DATA MOV DS,AX MOV ES,AX ………. PUSH BX …………. CODE ENDS
Si supponga che SP (stack pointer) = 201H &
Locazione 0
Esempio PUSH
DATI
STACK
PROGRAMMA
SP
0201H 0200H 01FFH 01FEH
Fine spazio di memoria disponibile
BX 1A
BL
9E
BH
………… STACK SEGMENT STACK DW 100H DUP(?) STACK ENDS
CODE SEGMENT MOV AX,DATA MOV DS,AX MOV ES,AX ………. PUSH BX …………. CODE ENDS
Si supponga che SP (stack pointer) = 201H &
Locazione 0
Esempio PUSH
Locazione 0
DATI
STACK
PROGRAMMA
0201H 0200H 01FFH 01FEH
Fine spazio di memoria disponibile
1A
BX 1A
BL
9E
BH
SP
………… STACK SEGMENT STACK DW 100H DUP(?) STACK ENDS
CODE SEGMENT MOV AX,DATA MOV DS,AX MOV ES,AX ………. PUSH BX …………. CODE ENDS
Si supponga che SP (stack pointer) = 201H &
Fine spazio di memoria disponibile
Esempio PUSH
Locazione 0 Locazione 0
DATI
STACK
PROGRAMMA
0201H 0200H 01FFH 01FEH
1A
SP
BX 1A
BL
9E
BH
………… STACK SEGMENT STACK DW 100H DUP(?) STACK ENDS
CODE SEGMENT MOV AX,DATA MOV DS,AX MOV ES,AX ………. PUSH BX …………. CODE ENDS
Si supponga che SP (stack pointer) = 201H & BX 1A
BL
9E
BH Esempio PUSH
Fine spazio di memoria disponibile
Locazione 0 Locazione 0
DATI
STACK
PROGRAMMA
0201H 0200H 01FFH 01FEH
1A 9E SP
Ed SP punta al top dello stack
………… STACK SEGMENT STACK DW 100H DUP(?) STACK ENDS
CODE SEGMENT MOV AX,DATA MOV DS,AX MOV ES,AX ………. PUSH BX POP DX …………. CODE ENDS
Si supponga che SP (stack pointer) = 201H &
Esempio POP BX 1A
BL
9E
BH
Fine spazio di memoria disponibile
Locazione 0 Locazione 0
DATI
STACK
PROGRAMMA
0201H 0200H 01FFH 01FEH
1A 9E SP
DX
DL DH
………… STACK SEGMENT STACK DW 100H DUP(?) STACK ENDS
CODE SEGMENT MOV AX,DATA MOV DS,AX MOV ES,AX ………. PUSH BX POP DX …………. CODE ENDS
Si supponga che SP (stack pointer) = 201H &
Esempio POP BX 1A
BL
9E
BH
Fine spazio di memoria disponibile
Locazione 0 Locazione 0
DATI
STACK
PROGRAMMA
0201H 0200H 01FFH 01FEH
1A 9E SP
DX
DL DH
9E
………… STACK SEGMENT STACK DW 100H DUP(?) STACK ENDS
CODE SEGMENT MOV AX,DATA MOV DS,AX MOV ES,AX ………. PUSH BX POP DX …………. CODE ENDS
Si supponga che SP (stack pointer) = 201H &
Esempio POP BX 1A
BL
9E
BH
Fine spazio di memoria disponibile
Locazione 0 Locazione 0
DATI
STACK
PROGRAMMA
0201H 0200H 01FFH 01FEH
1A 9E
SP
DX
DL DH
9E
………… STACK SEGMENT STACK DW 100H DUP(?) STACK ENDS
CODE SEGMENT MOV AX,DATA MOV DS,AX MOV ES,AX ………. PUSH BX POP DX …………. CODE ENDS
Si supponga che SP (stack pointer) = 201H &
Esempio POP BX 1A
BL
9E
BH
Fine spazio di memoria disponibile
Locazione 0 Locazione 0
DATI
STACK
PROGRAMMA
0201H 0200H 01FFH 01FEH
1A 9E
SP
DX
DL DH
9E 1A
………… STACK SEGMENT STACK DW 100H DUP(?) STACK ENDS
CODE SEGMENT MOV AX,DATA MOV DS,AX MOV ES,AX ………. PUSH BX POP DX …………. CODE ENDS
Si supponga che SP (stack pointer) = 201H &
Esempio POP BX 1A
BL
9E
BH
Fine spazio di memoria disponibile
Locazione 0 Locazione 0
DATI
STACK
PROGRAMMA
0201H 0200H 01FFH 01FEH
1A 9E
SP
DX
DL DH
9E 1A
PUSH & POP Importante ricordare che:
1.! Ogni subroutine deve lasciare lo stack esattamente come era prima che la subroutine venisse chiamata
2.! Gestione LIFO (Last In First Out)
Esempio: Scambio del contenuto di due registri
CODE SEGMENT ………. PUSH AX PUSH BX POP AX POP BX …………. CODE ENDS
DATI
STACK
0201H 0200H 01FFH 01FEH
1A
AL
9E
AH
FF
BL
02
BH SP
PUSH & POP Importante ricordare che:
1.! Ogni subroutine deve lasciare lo stack esattamente come era prima che la subroutine venisse chiamata
2.! Gestione LIFO (Last In First Out)
Esempio: Scambio del contenuto di due registri
CODE SEGMENT ………. PUSH AX PUSH BX POP AX POP BX …………. CODE ENDS
DATI
STACK
0201H 0200H 01FFH 01FEH
1A
AL
9E
AH
FF
BL
02
BH
SP 1A 9E
PUSH & POP Importante ricordare che:
1.! Ogni subroutine deve lasciare lo stack esattamente come era prima che la subroutine venisse chiamata
2.! Gestione LIFO (Last In First Out)
Esempio: Scambio del contenuto di due registri
CODE SEGMENT ………. PUSH AX PUSH BX POP AX POP BX …………. CODE ENDS
DATI
STACK
0201H 0200H 01FFH 01FEH
1A
AL
9E
AH
FF
BL
02
BH
SP
1A 9E FF 02 01FDH
PUSH & POP Importante ricordare che:
1.! Ogni subroutine deve lasciare lo stack esattamente come era prima che la subroutine venisse chiamata
2.! Gestione LIFO (Last In First Out)
Esempio: Scambio del contenuto di due registri
CODE SEGMENT ………. PUSH AX PUSH BX POP AX POP BX …………. CODE ENDS
DATI
STACK
0201H 0200H 01FFH 01FEH
AL AH
FF
BL
02
BH
SP 1A 9E FF 02
FF 02
PUSH & POP Importante ricordare che:
1.! Ogni subroutine deve lasciare lo stack esattamente come era prima che la subroutine venisse chiamata
2.! Gestione LIFO (Last In First Out)
Esempio: Scambio del contenuto di due registri
CODE SEGMENT ………. PUSH AX PUSH BX POP AX POP BX …………. CODE ENDS
DATI
STACK
0201H 0200H 01FFH 01FEH
AL AH
1A
BL
9E
BH SP 1A 9E FF 02
FF 02
Esercizio2 1.! I registri AX,BX e CX contengono il codice ASCII di due lettere nel
seguente modo
Scrivere una subroutine di nome REARRANGE che lasci i registri nel seguente modo
AL AH
S O
BL BH
R T
CL CH
M E
AL AH
E M
BL BH
O R
CL CH
S T
CALL & RET (intra-segment)
0010 CODE SEGMENT
…….
…….
0020 SOMMA_DI_REGISTRI: MOV SI,0
0021 ADD SI,AX
0022 ADD SI,BX
0023 ADD SI,CX
0024 ADD SI,DX
0025 RET 0026 …………..
…………. ……… 00AF CALL SOMMA_DI_REGISTRI 00B0 …………
CODE ENDS
CALL <etichetta>
16 bit - unsigned Differenza tra
Indirizzo dell’ist. Succ. alla CALL
Indirizzo della 1° istr. della subroutine
EFFETTI DELLA CALL:
1)! CS:IP = 0020H
2)! PUSH 00B0 (in rel a CS)
Se la prima istruzione di una subroutine A_SUB dista massimo 0FFFFH locazioni dall’istruzione CALL A_SUB
EFFETTI DELLA RET:
1)! POP IP (00B0 in CS:IP)
CALL & RET (intra-segment)
0010 CODE SEGMENT
…….
…….
0020 SOMMA_DI_REGISTRI: MOV SI,0
0021 ADD SI,AX
0022 ADD SI,BX
0023 ADD SI,CX
0024 ADD SI,DX
0025 RET 0026 …………..
…………. ……… 00AF CALL SOMMA_DI_REGISTRI 00B0 …………
CODE ENDS
Se la prima istruzione di una subroutine A_SUB dista massimo 0FFFFH locazioni dall’istruzione CALL A_SUB
DATI
STACK
SP
IP
CS
0271H
00AE
CALL & RET (intra-segment)
0010 CODE SEGMENT
…….
…….
0020 SOMMA_DI_REGISTRI: MOV SI,0
0021 ADD SI,AX
0022 ADD SI,BX
0023 ADD SI,CX
0024 ADD SI,DX
0025 RET 0026 …………..
…………. ……… 00AF CALL <00B0 - 0020> 00B0 …………
CODE ENDS
Effetti della CALL
DATI
STACK
SP
IP
CS
0271H
00AF
Prox istruzione da
eseguire
CALL & RET (intra-segment)
0010 CODE SEGMENT
…….
…….
0020 SOMMA_DI_REGISTRI: MOV SI,0
0021 ADD SI,AX
0022 ADD SI,BX
0023 ADD SI,CX
0024 ADD SI,DX
0025 RET 0026 …………..
…………. ……… 00AF CALL <00B0 - 0020> 00B0 …………
CODE ENDS
Effetti della CALL
IP
CS
0271H
0020
Prox istruzione da
eseguire
DATI
STACK SP 00B0
CALL & RET (intra-segment)
0010 CODE SEGMENT
…….
…….
0020 SOMMA_DI_REGISTRI: MOV SI,0
0021 ADD SI,AX
0022 ADD SI,BX
0023 ADD SI,CX
0024 ADD SI,DX
0025 RET 0026 …………..
…………. ……… 00AF CALL <00B0 - 0020> 00B0 …………
CODE ENDS
Effetti della RET
IP
CS
0271H
0025
Prox istruzione da
eseguire
DATI
STACK SP 00B0
CALL & RET (intra-segment)
0010 CODE SEGMENT
…….
…….
0020 SOMMA_DI_REGISTRI: MOV SI,0
0021 ADD SI,AX
0022 ADD SI,BX
0023 ADD SI,CX
0024 ADD SI,DX
0025 RET 0026 …………..
…………. ……… 00AF CALL <00B0 - 0020> 00B0 …………
CODE ENDS
Effetti della RET
IP
CS
0271H
00B0
Prox istruzione da
eseguire
DATI
STACK SP 00B0
POP IP
Il meccanismo delle subroutine inter-segment
Se la prima istruzione di una subroutine A_SUB dista più di 0FFFFH locazioni dall’istruzione CALL A_SUB
…….
0020 SOMMA_DI_REGISTRI: MOV SI,0
0021 ADD SI,AX
0022 ADD SI,BX
0023 ADD SI,CX
0024 ADD SI,DX
0025 RET 0026 …………..
…………. ……… 00AF 00B0 …………
0F20 CALL SOMMA_DI_REGISTRI
…………..
…………. ………
CS(1)
0271H
CS(2)
FC71H
CALL <etichetta>
<indirizzo a 4-byte> della subroutine
2 byte per OFFSET della A_SUB da CS(1)
2 byte per il valore del CS che contiene la CALL alla
A_SUB (CS(2))
CALL & RET (inter-segment)
0271:0010
…….
…….
0020 SOMMA_DI_REGISTRI: MOV SI,0
0021 ADD SI,AX
0022 ADD SI,BX
0023 ADD SI,CX
0024 ADD SI,DX
0025 RET 0026 …………..
…………. ……… FC71:0F21 CALL SOMMA_DI_REGISTRI FC71:0F24 …………
Se la prima istruzione di una subroutine A_SUB dista massimo 0FFFFH locazioni dall’istruzione CALL A_SUB
DATI
STACK
SP
IP
CS
FC71H
0F21
Prox istruzione da
eseguire
CALL & RET (inter-segment)
0271:0010
…….
…….
0020 SOMMA_DI_REGISTRI: MOV SI,0
0021 ADD SI,AX
0022 ADD SI,BX
0023 ADD SI,CX
0024 ADD SI,DX
0025 RET 0026 …………..
…………. ……… FC71:0F21 CALL SOMMA_DI_REGISTRI FC71:0F24 …………
Effetti della CALL
DATI
STACK SP
IP
CS
FC71H
0F21
FC71
PUSH CS
CALL & RET (inter-segment)
0271:0010
…….
…….
0020 SOMMA_DI_REGISTRI: MOV SI,0
0021 ADD SI,AX
0022 ADD SI,BX
0023 ADD SI,CX
0024 ADD SI,DX
0025 RET 0026 …………..
…………. ……… FC71:0F21 CALL SOMMA_DI_REGISTRI FC71:0F24 …………
Effetti della CALL
DATI
STACK SP
IP
CS
FC71H
0F21
FC71 0F24
PUSH IP PUSH CS
CALL & RET (inter-segment)
0271:0010
…….
…….
0020 SOMMA_DI_REGISTRI: MOV SI,0
0021 ADD SI,AX
0022 ADD SI,BX
0023 ADD SI,CX
0024 ADD SI,DX
0025 RET 0026 …………..
…………. ……… FC71:0F21 CALL SOMMA_DI_REGISTRI FC71:0F24 …………
Effetti della CALL
DATI
STACK SP
IP
CS
0271H
0020
FC71 0F24
CALL & RET (inter-segment)
0271:0010
…….
…….
0020 SOMMA_DI_REGISTRI: MOV SI,0
0021 ADD SI,AX
0022 ADD SI,BX
0023 ADD SI,CX
0024 ADD SI,DX
0025 RET 0026 …………..
…………. ……… FC71:0F21 CALL SOMMA_DI_REGISTRI FC71:0F24 …………
Effetti della CALL
DATI
STACK SP
IP
CS
0271H
0020
Prox istruzione da
eseguire
FC71 0F24
CALL & RET (inter-segment)
0271:0010
…….
…….
0020 SOMMA_DI_REGISTRI: MOV SI,0
0021 ADD SI,AX
0022 ADD SI,BX
0023 ADD SI,CX
0024 ADD SI,DX
0025 RET 0026 …………..
…………. ……… FC71:0F21 CALL SOMMA_DI_REGISTRI FC71:0F24 …………
Effetti della RET
DATI
STACK SP
IP
CS
0271H
0020
Prox istruzione da
eseguire
FC71 0F24
CALL & RET (inter-segment)
0271:0010
…….
…….
0020 SOMMA_DI_REGISTRI: MOV SI,0
0021 ADD SI,AX
0022 ADD SI,BX
0023 ADD SI,CX
0024 ADD SI,DX
0025 RET 0026 …………..
…………. ……… FC71:0F21 CALL SOMMA_DI_REGISTRI FC71:0F24 …………
Effetti della RET
DATI
STACK SP
IP
CS
0271H
0020
FC71 0F24
CALL & RET (inter-segment)
0271:0010
…….
…….
0020 SOMMA_DI_REGISTRI: MOV SI,0
0021 ADD SI,AX
0022 ADD SI,BX
0023 ADD SI,CX
0024 ADD SI,DX
0025 RET 0026 …………..
…………. ……… FC71:0F21 CALL SOMMA_DI_REGISTRI FC71:0F24 …………
Effetti della CALL
DATI
STACK SP
IP
CS
0271H
0F24
FC71 0F24
POP IP
CALL & RET (inter-segment)
0271:0010
…….
…….
0020 SOMMA_DI_REGISTRI: MOV SI,0
0021 ADD SI,AX
0022 ADD SI,BX
0023 ADD SI,CX
0024 ADD SI,DX
0025 RET 0026 …………..
…………. ……… FC71:0F21 CALL SOMMA_DI_REGISTRI FC71:0F24 …………
Effetti della CALL
DATI
STACK
SP
IP
CS
FC71H
0F24
FC71
POP CS
Prox istruzione da
eseguire
CALL & RET INTRA SEGMENT oppure INTER SEGMENT??
Il programmatore deve fornire una CHIARA indicazione all’assemblatore (intra segment di default)
(1) MY_SUB: MOV AX,4
INC BX
RET
(2)! MY_SUB PROC NEAR
MOV AX,4
INC BX
RET
MY_SUB ENDP
(3)! MY_SUB PROC FAR
MOV AX,4
INC BX
RET
MY_SUB ENDP
PROCEDURE
Subrutine etichettate con
attributi
NEAR & FAR
Interpretato come Subroutine INTRA-segment
Interpretato come Subroutine INTER-segment
Anche se Stesso codice
macchina
Esercizio3 1.! Scrivere un programma assembly che stampi a video una scacchiera
5*3, con i quadrati neri composti da griglie di 4*3 “X” (come da esempio). Si faccia uso di CALL e RET near
XXXX XXXX XXXX
XXXX XXXX XXXX
XXXX XXXX XXXX
XXXX XXXX
XXXX XXXX
XXXX XXXX
XXXX XXXX XXXX
XXXX XXXX XXXX
XXXX XXXX XXXX
si faccia uso
Esercizio4 1. Scrivere un programma Assembley che ordini in maniera crescente un
vettore di 6 numeri interi (da 0 a 99) inseriti da tastiera e lo stampi a video .Fare uso delle seguenti subroutine da definire:
-inserimento -ordinamento -stampa
2. Scrivere un programma assembly che: a) legga da tastiera un numero compreso tra 0 e 9 ed un vettore di 5
interi positivi su due cifre (cioè compresi tra 00 e 99). b) moltiplichi il vettore per il numero c) stampi a video il massimo del vettore così ottenuto purchè sia
maggiore di 100, altrimenti stampi il carattere “#”.
Si faccia uso delle seguenti subroutine da definire: - Inserimento - Calcolo - RicercaMax - Stampa
Esercizio5
2. Scrivere un programma assembly che: a) legga da tastiera un vettore di 5 interi positivi su due cifre (cioè
compresi tra 00 e 99). b) lo ordini in maniera crescente c) lo stampi a video ordinato
Si faccia uso delle seguenti subroutine da definire: - Inserimento - Ordinamento - Stampa
Esercizio6 Scrivere una subroutine assembly (near) che calcoli la media di n INTERI (da
00 a 99) in input da tastiera. Scrivere il programma principale che chiami la subroutine, in modo che possa
essere testata.
Il programma deve: 1) chiedere all’utente il numero n di numeri su cui deve essere calcolata la
media (es. Stampare a video il msg “Digita il numero di elementi:”) 2) Attendere l’input 3)Stampare una nuova linea 4)Richiedere ogni numero nella forma: “Inserire numero i!""5)Attendere l’nput del numero 6)Quando tutti i numeri sono stati inseriti: a)Stampare nuova linea b)Calcolare la media c) stampare il risultato Si faccia uso delle seguenti subroutine:
-! Inserimento (1-2-3-4-5-6a) -! CalcoloMedia (6b) -! Stampa (6c)