|
 |
Il Processore e il Debugger |
DEBUG 18/22
[46 di 60] |
|
 |
|
Aggiornato
24 settembre 2003 e 17 febbraio 2005 |
 |
|
Comando A - Crea un programma eseguibile |
|
 | Il comando A
(ASSEMBLY, assembla) permette la creazione
di programmi eseguibili anche in ambiente debug; si tratta di
un esercizio senza futuro, al limite della paranoia,
poco pratico e piuttosto complesso;
la logica dei debugger (per esempio quella di richiedere numeri esadecimali
senza la H finale) rende questo esercizio addirittura controproducente. |
| La precedente ...esplosione di ottimismo per
sottolineare di evitare l'uso proprio di
questo comando. |
| Anche l'uso per effettuare piccole correzioni
locali è assurdo: si fa prima a tornare
in editor, correggere,
ricompilare
e rientrare in debug con la nuova versione dell'eseguibile. |
| Volendo trovare per forza una occasione utile
possiamo pensare all'uso in una esercitazione
sulla scrittura di istruzioni: poiché l'assemblatore del
debug (cioè il comando A) è in grado
di riconoscere gli errori, se la stringa digitata non è corretta viene
segnalato errore. |
| Vediamo dunque come si usa Assembly:
non appena si conferma con Invio
la lettera A, sulla riga successiva appare l'indirizzo puntato da CS:IP. La dove sta lampeggiando il cursore dovremo scrivere
il codice mnemonico di una istruzione, confermando ogni volta
con Invio. |
| Solo quando riteniamo di aver finito bisogna
premere Invio 2 volte di fila:
si torna così al prompt del debug (il segno meno, a sinistra). |
| Vediamo l'effetto di questo esercizio; sulla
sinistra abbiamo scritto alcune istruzioni, decisamente a caso. Il debug,
senza mostrarlo esplicitamente le ha compilate: l'unico segno del fatto sta
nell'indirizzo successivo, effettivamente incrementato del numero
presumibile di bytes associati a ciascuna istruzione. |
| La verifica con il comando
U (a destra) dimostra che
in memoria sono stati effettivamente allocati i bytes corrispondenti alle
istruzioni che abbiamo digitato: |
 |
Se fai click sull'icona a
sinistra si apre l'Ambiente Assembly
e puoi
provare DEBUG
on-line.
Scegli
il pulsante di opzione "Aprire il file" o "Esegui
l'applicazione"
e conferma
con
OK.
NB: alcuni gestori di protezione (per esempio SP2 di WinXP) non ti consentono questa operazione:
in questo caso scrivi c:\arch-lab\bin\sys\assembler.pif direttamente nel campo indirizzo del Browser |
-a
11A0:0100 mov ax,1234
11A0:0103 mov dx,5678
11A0:0106 add ax,dx
11A0:0108 call 5432
11A0:010B jmp abcd
11A0:010E
- |
-u 100
11A0:0100 B83412 MOV AX,1234
11A0:0103 BA7856 MOV DX,5678
11A0:0106 01D0 ADD AX,DX
11A0:0108 E82753 CALL 5432
11A0:010B E9BFAA JMP ABCD
11A0:010E 0000 ADD [BX+SI],AL |
| Ecco la cosa utile: abbiamo imparato che il codice
operativo di call 5432 è
E8, quello di
jmp abcd
è
E9;
e così via. |
| Come detto tutti i valori numerici devono
essere intesi esadecimali (cioè non è necessario aggiungere la H finale,
anzi è un errore!); in linea di massima tutte le istruzioni sono
sostanzialmente identiche, con qualche distinguo. Per esempio:
 | debug riconosce DW e
DB come fossero
appartenenti al set dell'80x86 (in realtà sono macroistruzioni) |
| riconosce i salti in modo automatico, in
funzione della distanza del punto d'arrivo, e li codifica di conseguenza
corti (short, con 2 bytes) o vicini (near, con 3 bytes); da notare
che, comunque, l'operando è un numero positivo
relativo (al punto
d'arrivo) e non assoluto |
|
-a 100
1192:0100 jmp 110
1192:0102 jmp 1002
1192:0105 jmp 100 |
-u 100
1192:0100 EB0E JMP 0110
1192:0102 E9FD0E JMP 1002
1192:0105 EBF9 JMP 0100 |
| in particolare il
numero relativo codificato a fianco
del codice operativo (EB o
E9) è da ritenersi
numero con segno:
| positivo,
se il salto si riferisce a locazioni successive
a quella in cui viene richiesto (cioè in
avanti); in questo caso si calcola
escludendo i bytes delle istruzioni
di partenza (certamente JMP ..) e di arrivo, cioè contando
solo i bytes che vengono saltati; per esempio,
se all'indirizzo
0100
troviamo l'istruzione
JMP
0110 (codificata: EB0E)
salta i bytes da
0102 a
010F
compresi, cioè 14, appunto
0EH.
|
Addr |
|
|
Sequenza Bytes |
|
Istruzione |
|
0100
0102
0105
0108
010B
010E
0110 |
|
|
EB 0E
B8 22 11
BB 44 33
B9 66 55
BA 88 77
01 D8
01 D1 |
|
LabelNear: |
JMP SHORT LabelNear
MOV AX,1122
MOV BX,3344
MOV CX,5566
MOV DX,7788
ADD AX,BX
ADD CX,DX |
|
|
| negativo,
se il salto si riferisce a locazioni prededenti
a quella in cui viene richiesto (cioè indietro);
in questo caso si calcola contando anche i bytes dell'istruzione di salto
(2 o 3) e quelli dell'istruzione presente
all'indirizzo in cui si salta; per
esempio, se all'indirizzo
0105
troviamo l'istruzione
JMP
0100
(codificata: EBF9)
salta i bytes da
0106 a
0100
compresi,
cioè 7 che, essendo
negativo si esprime con il complemento
a 2, per cui 00000111binario
diventa 11111001, appunto
F9H (in
dettaglio: da 00000111binario
>> 11111000complemento
a 1 >> 11111001complemento
a 2 =
F9H)
|
Addr |
|
|
Sequenza Bytes |
|
Istruzione |
|
0100
0101
0103
0105 |
|
|
90
B0 55
B4 AA
EB
F9 |
|
LabelNear; |
NOP
MOV AL,55H
MOV AH,0AAH
JMP SHORT LabelNear |
|
|
|
| da notare che, se il
numero relativo è a 2 bytes, viene scritto in memoria
con la solita tecnica Lo-Hi
(prima la sua parte bassa e poi la
parte alta); per esempio il salto in avanti
JMP
1002,
proposto nel riquadro iniziale all'indirizzo
0102,
salta i bytes da
0105 a
1001
compresi, cioè una quantità espressa dal numero decimale
positivo 3837,
appunto 0EFDH,
codificata quindi da E9FD0E. |
©
2001-2010 - Studio Tecnico
ing. Giorgio OBER
Tutti i diritti sono riservati
|
