 | Il codice oggetto
prodotto è pero "a
rischio"; vediamo alcuni errori di tipo warning,
molto frequenti durante le nostre prime esperienze.
 | sempre a proposito della conoscenza delle istruzioni
del nostro processore si potrebbe essere indotti a pensare che l'acqua di un bicchiere possa stare dentro una bottiglia; ma l'assemblatore non
sembra d'accordo.. Se inseriamo l'istruzione MOV
AX,BL viene segnalato questo errore:
test04.ASM(5): warning A4031: Operand types must match
0 Warning Errors
1 Severe Errors |
Sebbene BL (8
bit) sia facilmente contenibile da AX (16
bit) l'operazione non è logica e il compilatore prima
ci avvisa che gli operandi devono essere dello stesso tipo e
poi di sua iniziativa
compila comunque l'istruzione, però come se fosse scritta MOV
AX,BX. Naturalmente il codice
macchina prodotto non è quello che noi avevamo pensato e il programma
potrebbe funzionare male! |
 |
Non
sottovalutare gli errori di tipo warning; l'assemblatore genera
comunque il codice oggetto, ma ciò che sarà
eseguito dal processore non sarà quello che volevamo... |
| Un caso simile al precedente, ma potenzialmente più
pericoloso, è quello suggerito da questo codice sorgente; sono definite
2 variabili, una da 8 bit (alfa) e una da 16 (beta), e si attuano
operazioni di scambio dati:
alfa
DB 10H
beta DW 0B800H
;------------------------------------
Main: MOV CS:[alfa],AX ;linea 6
MOV CS:[beta],AL ;linea
7
MOV AX,CS:[alfa] ;linea
8
MOV AL,CS:[beta] ;linea
9 |
I 4 messaggi d'errore sono gli
stessi di prima: avvisano che gli operandi non sono della stessa
dimensione, e la cosa sembra ragionevole...
test05.ASM(6): warning A4031: Operand types must match
test05.ASM(7): warning A4031: Operand types must match
test05.ASM(8): warning A4031: Operand types must match
test05.ASM(9): warning A4031: Operand types must match
4 Warning Errors
0 Severe Errors |
Ma ora il compilatore non prende iniziative: genera un codice
esattamente uguale a quello aspettato. Allora, dove sta' il problema?
Vediamo di capire:
 | l'istruzione
MOV
CS:[alfa],AX cerca di
inserire 16 bit (AX) in una variabile
da 8 bit (alfa): se non siamo ben certi
di quello che facciamo l'operazione sembra eretica. In effetti, al
di là delle differenti dimensioni dei 2 operandi, il compito
richiesto è sintatticamente possibile ma può produrre effetti
devastanti; con questa istruzione si caricano infatti 2 locazioni
consecutive: gli 8 bit di AL vanno a
finire in alfa e gli 8 bit di AH
in alfa+1, cioè praticamente in beta...
(cosa probabilmente non voluta):
Naturalmente se alfa fosse stata definita word (DW, 16 bit) non ci
sarebbe stato errore.
|
| l'istruzione
MOV CS:[beta],AL
cerca di inserire 8 bit (AL)
in una variabile da 16 bit (beta),
quindi non è a rischio: semplicemente viene eseguito metà del
compito possibile..
|
| l'istruzione
MOV AX,CS:[alfa]
è simile alla precedente: cerca di inserire 8 bit (il contenuto
della variabile alfa) in un registro a
16 bit (AX): è illogica, ma caricherà
solo la parte bassa (AL) di AX.
|
| decisamente inaccettabile invece
l'ultima istruzione, MOV
AL,CS:[beta]come possiamo
capire dalle precedenti spiegazioni
|
|
| Lo stesso tipo di problema si può presentare con
istruzioni che coinvolgono il caricamento di locazioni di memoria con
numeri (caricamento immediato); molto frequentemente l'istruzione MOV
CS:[alfa],00H può dare il solito errore (warning A4031: Operand types must match):
in questo caso la ragione sta nel fatto che il compilatore non può
sapere a priori la dimensione di quello 0;
in altre parole non c'è differenza
tra il valore 0 di un byte
e quello di una word, ma quando
bisogna generare il codice è necessario sapere se vogliamo azzerare
solo la variabile alfa (un byte a 0) o
anche le locazioni successive ad essa. Per questo lo 0 deve avere
dimensione e noi dobbiamo correttamente fissarla! Le istruzioni corrette
fanno riferimento all'operatore Ptr
(vedi
scheda),
cioè:
| MOV Byte Ptr
CS:[alfa],00H se desideriamo azzerare solo la variabile alfa. |
| MOV Word Ptr
CS:[alfa],00H se desideriamo azzerare la variabile alfa
e anche la successiva, alfa+1. |
| con questa tecnica esiste la possibilità di creare
codice in grado di caricare anche dieci locazioni consecutive.... |
|
|
