Utente:LukeP00/Sandbox
Assembly x86 è una famiglia di linguaggi assembly retrocompatibili, che rimane in parte compatibile con il processore Intel 8008, introdotto nell'aprile del 1972. Assembly x86 è utilizzato per produrre codice macchina per i processori con architettura x86. Come tutti i linguaggi assembly utilizza corte mnemoniche (per esempio: mov, jmp, cmp, test) che rappresentano le operazioni fondamentali che il processore può eseguire.
Storia[modifica | modifica wikitesto]
I processori Intel 8086 e 8088 sono stati i primi ad avere un set di istruzioni che viene comunemente chiamato x86. Questi processori a 16 bit ereditarono molte caratteristiche dai precedenti processori a 8 bit, ma vennero aggiornati ricevendo molte più istruzioni e funzionalità.
Assembly x86 permette di scrivere codice macchina per tutti i processori Intel seguenti all'8086, inoltre altri produttori come AMD utilizzano l'architettura x86 e assembly x86.
Registri[modifica | modifica wikitesto]
Complessivamente i registri di uso generale utilizzati nell'assembly x86 sono otto di cui: quattro vengono utilizzati per la memorizzazione temporanea, due vengono utilizzati sia per la memorizzazione temporanea (solo a 16 bit) e sia nelle istruzioni in cui si manipolano stringhe, due (dedicati allo stack) vengono utilizzati per l'indirizzamento in memoria, gli ultimi due non sono modificabili poiché vengono costantemente aggiornati dal processore.[1]
- AX, registro accumulatore, è il registro utilizzato per le istruzioni matematiche quali somme, sottrazioni, moltiplicazioni e divisioni.
- BX, registro base, è il registro che può specificare un indirizzo di memoria.
- CX, registro contatore, è il registro utilizzato nelle istruzioni di conteggio dei cicli o di operazioni matematiche.
- DX, registro di I/O, è il registro che utilizza le porte di Input/Output, può essere utilizzato anche in istruzioni matematiche come moltiplicazioni e divisioni.
- SI, registro indice sorgente, è il registro in cui viene specificato l'indirizzo da cui leggere l'array.
- DI, registro indice destinazione, è il registro in cui viene specificato l'indirizzo in cui scrivere l'array.
- BP, registro base pointer, è il registro che contiene il primo indirizzo di memoria della pila di stack.
- SP, registro stack pointer, è il registro che contiene l'ultimo indirizzo di memoria della pila di stack.
- IP, registro instruction pointer, è il registro che contiene la parte meno significativa dell'istruzione successiva da eseguire. Non viene mai modificato dal programmatore.
- Flag, registro dei flags, è il registro dove ogni bit ha un significato diverso e, dopo l'esecuzione di un istruzione, descrive lo stato attuale del processore.
Oltre ai registri di uso generale vi sono quattro registri di segmento che vengono utilizzati per contenere i 16 bit più significativi di un qualsiasi indirizzo di memoria.[2]
- CS, registro code segment, è il registro che contiene la parte più significativa del program counter ed è associato al registro IP.
- DS, registro data segment, è il registro che contiene la parte più significativa di una memoria dati ed è associato ai registri BX, SI e DI.
- ES, registro extra segment, è uguale al registro DS ma associato ad una seconda memoria dati.
- SS, registro stack segment, è il registro che contiene la parte più significativa della memoria in cui è assegnato lo stack ed è associato ai registri BP e SP
Istruzioni[modifica | modifica wikitesto]
MOV[modifica | modifica wikitesto]
mov a, b
L'istruzione mov copia il contenuto di a (che può essere un valore costante, un contenuto del registro o della memoria) in b.[3]
PUSH[modifica | modifica wikitesto]
push a
L'istruzione push inserisce all'inizio dello stack a all'indirizzo inserito nel registro SP il quale a sua volta viene decrementato di due unità.[4]
POP[modifica | modifica wikitesto]
pop b
L'istruzione pop preleva un elemento dallo stack, dall'indirizzo inserito nel registro SP, e lo sposta in b. Il registro SP viene incrementato di due unità.[5]
NOP[modifica | modifica wikitesto]
nop
L'istruzione nop non fa niente, ma viene usata per esempio se si vuole rallentare l'esecuzione del programma oppure se si vuole aumentare l'indirizzo del codice di una unità.[6]
CMP[modifica | modifica wikitesto]
cmp a - b
L'istruzione cmp confronta i valori contenuti in a e b effettuando una sottrazione. Successivamente vengono impostati i flag in base al risultato dell'istruzione.[7]
JMP[modifica | modifica wikitesto]
jmp a
L'istruzione jmp (salto incondizionato) trasferisce nell'indirizzo a il flusso del programma eseguito.[8]
LOOP[modifica | modifica wikitesto]
loop a
L'istruzione loop, quando viene eseguita, controlla il registro CX. Se è diverso da zero viene decrementato di una unità il suo valore, altrimenti il programma riprende normalmente l'esecuzione. [9]
Operazioni matematiche[10][modifica | modifica wikitesto]
add a, b
sub a, b
mul a
div a
L'istruzione add esegue la somma tra a e b, il risultato viene inserito in a.
L'istruzione sub esegue la sottrazione tra a e b, il risultato viene inserito in a.
L'istruzione mul esegue la moltiplicazione tra il valore del registro AX e a, il risultato viene inserito in AX.
L'istruzione div esegue la divisione tra il valore del registro AX e a, il risultato viene inserito in AX.
Interruzioni[11][modifica | modifica wikitesto]
Nell'assembly x86 le interruzioni (o interrupt) vengono gestite attraverso delle istruzioni molto importanti se si vuole scrivere un programma, poiché servono per poter accedere allo schermo e alla tastiera.
Gestione dell'input[modifica | modifica wikitesto]
Le istruzioni int 10 e int 21 sono le istruzioni necessarie per poter stampare sullo schermo un carattere, questo dovrà essere sempre indicato in codifica ASCII anche se sono delle cifre decimali.
Nell'esempio sotto viene mostrato come si stampa il carattere "A".
; variante int 10
mov al, 41 ; 41h = 'A'
mov ah, 0e
int 10
;variante int 21
mov al, 41 ; 41H = 'A'
mov ah, 02
int 21
Gestione dell'output[modifica | modifica wikitesto]
Le istruzioni int 16 e int 21 sono le istruzioni necessarie per l'input di un carattere da tastiera. Quando viene invocata l'interruzione, l'esecuzione del programma viene bloccata in attesa che l'utente digiti un carattere da tastiera. Alla fine dell'esecuzione viene visualizzato in ASCII il carattere premuto dall'utente.
; variante int 16
mov ah, 00
int 16
; visualizzazione del carattere premuto
; variante int 21
mov ah, 01
int 21
; visualizzazione del carattere premuto
Chiusura di un programma[modifica | modifica wikitesto]
Per chiudere un programma COM si usa l'istruzione int 20, il DOS non viene informato sullo stato della chiusura. Per chiudere un programma EXE si usa l'istruzione int 21, il DOS viene informato sullo stato della chiusura e può essere utilizzata anche per chiudere un programma COM.
; per chiudere un programma COM
int 20
; per chiudere un programma EXE
mov al, 00
mov ah, 4c
int 21
Ora corrente[modifica | modifica wikitesto]
L'istruzione int 21h restituisce l'ora corrente, inclusi i minuti, i secondi e i centesimi di secondo.[12]
mov ah, 2ch
int 21h
Debug[modifica | modifica wikitesto]
Per poter scrivere e compilare programmi in assembly x86 viene utilizzato il programma debug.exe (eseguibile tramite il comando debug nel prompt di Windows e di MS-DOS), presente in MS-DOS e nelle versioni a 16 bit e 32 bit di Windows. Nelle versioni a 64 bit il programma non è presente, tuttavia per questi sistemi è possibile utilizzare emulatori gratuiti scaricabili in rete come DOSBox[13]. La notazione utilizzata è quella esadecimale. Nel debug.exe i comandi sono molto comprensibili dall'utente, e sono anche case sensitive. Sotto vengono riassunti i comandi principali:
| Comando | Che cosa fa |
|---|---|
| A | Inizia la scrittura del programma. |
| D | Permette di visualizzare la memoria. |
| L | Carica il programma. |
| N | Rinomina il programma. |
| Q | Esce da debug.exe. |
| R | Permette di visualizzare e/o impostare i registri. |
| U | Permette di modificare il programma. |
| W | Salva il programma. |
Note[modifica | modifica wikitesto]
- ^ P.Ollari, pp.26-27, 2013.
- ^ P.Ollari, pp.27-28, 2013.
- ^ P.Ollari, p.36, 2013.
- ^ P.Ollari, p.86, 2013.
- ^ P.Ollari, pp.86-87, 2013.
- ^ P.Ollari, p.52, 2013.
- ^ P.Ollari, p.54, 2013.
- ^ P.Ollari, p.55, 2013.
- ^ P.Ollari, p.57, 2013.
- ^ P.Ollari, pp.76-77, 2013.
- ^ P.Ollari, pp.43-45, 2013.
- ^ P.Ollari, p.87, 2013.
- ^ P.Ollari, p.48, 2013.
Bibliografia[modifica | modifica wikitesto]
- Paolo Ollari, Corso di sistemi e reti. Volume 1. Architetture e network, Bologna, Zanichelli, 2013, ISBN 978-88-08-14169-9.