Linguaggio assembly: differenze tra le versioni
Contenuto cancellato Contenuto aggiunto
Nessun oggetto della modifica Etichette: Sequenze di caratteri ripetuti da parte di un nuovo utente o IP Modifica visuale |
|||
Riga 21:
==Caratteristiche generali dell'assembly==
L'assembly ha lo scopo generale di consentire al programmatore di ignorare il formato [[bit (informatica)|binario]] del linguaggio macchina. Ogni [[codice operativo]] del linguaggio macchina viene sostituito, nell'assembly, da una sequenza di caratteri che lo rappresenta in forma ''mnemonica''; per esempio, il codice operativo per la [[addizione|somma]] potrebbe essere trascritto come<code>ADD</code>e quello per il [[GOTO|salto]] come<code>JMP</code>. In secondo luogo, i dati e gli [[indirizzi di memoria]] manipolati dal programma possono essere scritti, in assembly, nella [[sistema di numerazione|base numerica]] più consona al momento: [[Sistema numerico esadecimale|esadecimale]], [[Sistema numerico binario|binaria]], [[Sistema numerico decimale|decimale]], [[Sistema numerico ottale|ottale]] ma anche in forma simbolica, utilizzando stringhe di testo (identificatori). Il programma assembly risulta in questo modo relativamente più [[leggibilità|leggibile]] di quello in linguaggio macchina, con il quale mantiene però un totale (o quasi totale) [[isomorfismo]]. Il programma scritto in assembly non può essere eseguito direttamente dal processore; esso deve essere tradotto nel linguaggio macchina (binario) corrispondente, usando un programma [[compilatore]] detto [[assembler]].
==Non c'è un solo assembly==
A causa di questa "vicinanza" all'hardware, non esiste un unico linguaggio assembly. Al contrario, ogni [[CPU]] o famiglia di CPU ha un suo proprio assembly, diverso dagli altri. Ad esempio, sono linguaggi assembly ben diversi quelli per i processori [[Intel]] [[Architettura X86|x86]], per i [[Motorola 68000]] e per i [[Dec Alpha]]. Questo significa che conoscere un certo linguaggio assembly significa saper scrivere programmi solo su una determinata CPU o famiglia di CPU. Passare ad altre CPU però è relativamente facile, perché molti meccanismi sono analoghi o del tutto identici, quindi spesso il passaggio si limita all'apprendimento di nuovi codici mnemonici, nuove modalità di indirizzamento ed altre varie peculiarità del nuovo processore.
Molto meno facile è invece [[Portabilità|portare]] un programma scritto in assembly su macchine con processori diversi o con architetture diverse: quasi sempre significa dover riscrivere il programma da cima a fondo, perché i linguaggi assembly dipendono completamente dalla piattaforma per cui sono stati scritti. Molti compilatori assembly supportano sistemi di [[Macro (informatica)|macro]] che potrebbero essere impiegati per ovviare in parte a questo problema, ma si tratta di una soluzione poco efficace.
Inoltre l'assembly non offre alcun "[[Type checking|controllo sui tipi]]" (non esiste alcunché di vagamente simile al concetto di "[[Tipo di dato|tipo]]" nella programmazione ''low-level''), ma lascia al programmatore la responsabilità di occuparsi di ogni singolo dettaglio della gestione della macchina e richiede molta disciplina e un esteso lavoro di commento per non scrivere codice che risulti assolutamente illeggibile (ad altri programmatori come anche a se stessi dopo qualche tempo).
Riga 41 ⟶ 32:
A fronte di questi svantaggi l'assembly offre un'efficienza senza pari e il controllo completo e assoluto sull'hardware: i programmi in assembly sono, in linea di principio, i più piccoli e veloci che sia possibile scrivere su una data macchina.
Scrivere (buon) codice in assembly è dispendioso in termini di tempo, difficile e quindi molto costoso, soprattutto in prospettiva (future modifiche): per questo, raramente l'assembly è il solo linguaggio usato in un progetto mainstream, a meno che questo non sia di dimensioni e portata limitate. In genere si usa in combinazione con altri linguaggi: la maggior parte del codice viene scritta in un [[linguaggio di programmazione|linguaggio]] ad alto livello, mentre le parti più critiche (per motivi di performance, precisione del timing o affidabilità) si scrivono in assembly.
Tali problematiche sono riscontrabili principalmente su piattaforme come i ''personal computer'' attuali, dove la vastità quantitativa e l'enorme gamma qualitativa dell'hardware disponibile crea alle applicazioni low-level un oggettivo problema mai risolto (e presumibilmente non risolvibile) a livello di unificazione e standard. A ciò si aggiunga l'evoluzione costante verso una sempre maggiore stratificazione dei comuni sistemi operativi, caratterizzata da numerosi vincoli e virtualizzazioni delle periferiche fisiche e dei canali di comunicazione, che non rendono agevole lo sviluppo di un software che interagisca direttamente con l'hardware sottostante e ne gestisca direttamente le caratteristiche.
Si possono però citare due esempi, peraltro correlati, di totale inversione di questo paradigma generale:
Riga 56 ⟶ 45:
==RISC e CISC==
Il linguaggio assembly costituisce il cosiddetto [[instruction set|ISA]] (''Instruction Set Architecture'') di un processore.
I diversi ISA possono essere divisi in due grandi gruppi: i [[Reduced instruction set computer|RISC]] (''Reduced Instruction Set Computer'') e i [[Complex instruction set computer|CISC]] (''Complex Instruction Set Computer''). Il primo gruppo tende ad avere operazioni semplici e veloci, con grande abbondanza di [[registro (informatica)|registri]] per memorizzare i risultati intermedi. Il secondo mette a disposizione del programmatore istruzioni più complesse, che a volte mimano quelle dei linguaggi di livello più alto (ad esempio, la copia di stringhe nei processori x86). In entrambi i casi, i migliori set di istruzioni tendono ad essere quelli cosiddetti ''ortogonali'', dove i diversi [[metodo di indirizzamento|metodi di indirizzamento]] e i diversi registri possono essere usati indifferentemente in tutte le istruzioni. Famosi set di istruzioni ortogonali sono quelli del Motorola 68000 (CISC) e del [[Architettura MIPS|MIPS]] (RISC). L'ISA dei processori Intel x86 era originariamente ben poco ortogonale, ed è andata via via migliorando.
La distinzione tra ''set'' di istruzioni RISC e CISC è oggi un po' sfumata, perché la maggior parte dei processori consumer sono oggi dei [[CRISP]], cioè un misto fra i due. Inoltre, alcuni processori traducono l'ISA originale in un set di istruzioni interno, per ragioni diverse e con modalità diverse:
* nel caso dell'[[Intel]] [[Pentium 4]] e dell'[[Advanced Micro Devices|AMD]] [[Athlon]], è per liberarsi dalle limitazioni causate da un'ISA retrocompatibile ormai arcaica, e la conversione è eseguita direttamente da hardware dedicato che effettua la necessaria ''decodifica'';
* nel caso dei processori [[Transmeta]], è per poter "tradurre" ISA di altri processori esistenti come se fossero proprie, e la traduzione è fatta da qualcosa di concettualmente molto simile a ''routine'' firmware (denominate ''microcodice'') memorizzate in un'area [[Read only memory|ROM]] ricavata sul silicio del microprocessore.
Riga 158 ⟶ 141:
</source>
Su alcune architetture tali fasi risultano invece essere quattro (ad esempio, nei PIC Microchip, negli Intel 8051 e in numerosissimi core analoghi), da cui risulta anche l'effettivo rapporto tra velocità di clock ossia frequenza del quarzo esterno (es. 10 MHz) e numero di istruzioni effettivamente eseguite in un secondo. Per i PIC (famiglie ''baseline'' e ''midrange'' in particolare) tale rapporto è pari ad 1/4, poiché ad ogni ciclo di clock il core esegue effettivamente una singola fase Fetch-Decode-Execute-Write e dunque sono necessari quattro cicli del clock esterno per completare una singola istruzione. Su architetture di microcontroller e core più arcaiche o comunque di diversa concezione, sono necessari anche più cicli di clock per ciascuna fase (ad esempio tre o quattro), da cui il diverso rapporto tra clock e MIPS, che nel caso del design 8051 originale richiede ad esempio 12 cicli di clock per ciascuna singola istruzione. Si ricordi infine che talune istruzioni, tra le quali tipicamente i salti incondizionati, richiedono su un numero notevole di piattaforme (sia RISC che CISC, concepite in varie epoche) un numero di cicli superiore alle altre, a causa delle operazioni accessorie (non parallelizzabili) richieste dall'aggiornamento del registro IP e di eventuali code di prefetch interne.
==C-asm==
Talvolta, nella programmazione ad alto livello in ambienti come il DOS, c'è la necessità di effettuare alcune operazioni che sono molto più veloci usando delle istruzioni di linguaggi a basso livello (in Windows invece a causa delle protezioni della memoria si ricorre più frequentemente alle chiamate [[WINAPI]], le chiamate in L/M sono usate per lo più per procedure matematiche accelerate o dai [[driver]]). Tra i linguaggi ad alto livello che permettono questo vi sono il [[C (linguaggio)|C]] e il [[C++]], in cui possono essere inserite nei propri sorgenti parti scritte in assembly che, in fase di compilazione, verranno tradotte con un procedimento noto come [[assembler inline]]. Un esempio di codice scritto in C-asm (usando l'assembly Intel x86), che visualizza in binario un numero dato in input, è il seguente:
<source lang="asm">
#include <stdio.h>
Riga 208 ⟶ 189:
Il processore esegue le istruzioni così come si presentano, una dopo l'altra. Tuttavia, attraverso particolari strutture, si può controllare il flusso esecutivo in base ad una determinata condizione. In questo modo si può creare strutture di semplice selezione o di tipo iterativo (cicli). Le istruzioni assembly che vengono utilizzate per questo scopo sono principalmente di due tipo: salto e confronto.
I salti possono essere incondizionati o condizionati. JMP effettua un salto incondizionato. In genere l'indirizzo di riferimento è un'etichetta. La condizione del salto è sempre dettata dai valori del registro dei flag. I flag più usati per i salti sono:
* ZF (flag zero) indica se l'ultima istruzione ha generato come risultato 0
* SF (flag segno) indica se l'ultima istruzione ha generato un risultato di segno negativo
Riga 217 ⟶ 196:
'''Il costrutto di selezione (if, else)'''
La selezione è una struttura che permette di eseguire un blocco di istruzioni oppure un altro in base al verificarsi di una condizione.''<nowiki/>''
se
blocco istruzioni 1
Riga 224 ⟶ 202:
blocco istruzioni 2
fine se
''in assembly, attraverso la logica dei salti, viene rappresentato così:''▼
▲in assembly, attraverso la logica dei salti, viene rappresentato così:
se:
JNcondizione altrimenti
Riga 234 ⟶ 210:
blocco istruzioni 2
fine_se:
'''''Il ciclo a controllo in coda (do...while)'''▼
▲'''Il ciclo a controllo in coda (do...while)'''
L'iterazione è una struttura che permette di ripetere più volte un'istruzione sotto il controllo di una condizione.''
ripeti
istruzioni
finché condizione
''in assembly, attraverso la logica dei salti, viene rappresentato così:
inizio_ciclo:
istruzioni
Jcondizione inizio_ciclo
''esempio:
MOV AX, 0000h
inizio_ciclo:
Riga 254 ⟶ 226:
CMP AX, 000Ah ;confronta AX e il valore 0Ah (10d)
JNE inizio_ciclo ;salta all'inizio (e ripete il ciclo) se diverso
''Dato che il controllo della condizione viene eseguito alla fine del ciclo, le istruzioni in sequenza vengono eseguite comunque almeno una volta, anche se la condizione era già verificata in partenza. In pratica:''▼
▲Dato che il controllo della condizione viene eseguito alla fine del ciclo, le istruzioni in sequenza vengono eseguite comunque almeno una volta, anche se la condizione era già verificata in partenza. In pratica:
MOV AX, 000Ah
inizio_ciclo:
Riga 262 ⟶ 232:
CMP AX, 000Ah
JNE inizio_ciclo
''Questo spezzone di codice dovrebbe controllore se AX = 10d, e in caso contrario incrementare AX. In caso favorevole uscire dal ciclo. Vediamo però che AX vale già 10d, tuttavia tale registro viene comunque incrementato (alla fine varrà 000Bh). Inoltre, in questo particolare programma, il ciclo non finirà mai: AX varrà 11, poi 12, poi 13 e non diventerà mai uguale a 10. Sarebbe buona norma, nelle condizioni, evitare di esprimere un'uguaglianza:''▼
▲Questo spezzone di codice dovrebbe controllore se AX = 10d, e in caso contrario incrementare AX. In caso favorevole uscire dal ciclo. Vediamo però che AX vale già 10d, tuttavia tale registro viene comunque incrementato (alla fine varrà 000Bh). Inoltre, in questo particolare programma, il ciclo non finirà mai: AX varrà 11, poi 12, poi 13 e non diventerà mai uguale a 10. Sarebbe buona norma, nelle condizioni, evitare di esprimere un'uguaglianza:
MOV AX, 000Ah
inizio_ciclo:
Riga 274 ⟶ 242:
'''Il ciclo a controllo in testa (while)'''
Una struttura iterativa a controllo in testa si può descrivere, ad alto livello, così:''
mentre condizione
istruzioni
fine ciclo
''Equivale alla while (condizione) { sequenza } del C. in assembly:''
inizio_ciclo:
JNcondizione fine_ciclo
Riga 288 ⟶ 253:
fine_ciclo
''esempio:
inizio_ciclo:
CMP AX,0Ah ;confronta AX con 10d
Riga 299 ⟶ 263:
'''Il ciclo a contatore (for)'''
Il ciclo a contatore ha una struttura di questo tipo:''
CONTATORE = 0
mentre CONTATORE < N
Riga 306 ⟶ 269:
incrementa CONTATORE
fine ciclo
''Possiamo utilizzare un ciclo a contatore se vogliamo ripetere un blocco di istruzioni per un numero di volte noto a priori. i cicli in assembly sono in genere a decremento:''
CONTATORE = N
ripeti
Riga 315 ⟶ 276:
finché CONTATORE n > 0
''Come contatore si usa di solito il registro CX (registro contatore, appunto), perché esiste un'istruzione che esegue le ultime due istruzioni automaticamente: l'istruzione LOOP: decrementa CX e, se CX non è 0, salta all'etichetta specificata.''
MOV CX, 0
inizio_ciclo:
Riga 324 ⟶ 284:
fine_ciclo:
''Grazie all'istruzione LOOP diventa semplice scrivere un ciclo a contatore in assembly:''▼
▲Grazie all'istruzione LOOP diventa semplice scrivere un ciclo a contatore in assembly:
MOV CX, <N> ; dove N è il numero di ripetizioni da eseguire
inizio_ciclo:
Riga 332 ⟶ 290:
LOOP inizio_ciclo
''Va sottolineato che nel primo esempio si ha un ciclo a controllo in testa, mentre nel secondo uno a controllo in coda, e che, sebbene il secondo sia più compatto e veloce da scrivere, possa generare degli errori, come già detto sopra, se non si sta attenti a come lo si usa, infatti in esso le istruzioni vengono eseguite almeno una volta, per cui se non si è sicuri che il numero di ripetizioni non possa mai essere zero, è meno rischioso usare il primo.▼
▲Va sottolineato che nel primo esempio si ha un ciclo a controllo in testa, mentre nel secondo uno a controllo in coda, e che, sebbene il secondo sia più compatto e veloce da scrivere, possa generare degli errori, come già detto sopra, se non si sta attenti a come lo si usa, infatti in esso le istruzioni vengono eseguite almeno una volta, per cui se non si è sicuri che il numero di ripetizioni non possa mai essere zero, è meno rischioso usare il primo.
==L'input/output tramite l'INT 21h del DOS==
L'assembly, specialmente nel mondo dei PC, non prevede funzioni di input/output già pronte. Il programmatore deve quindi creare le proprie routine o appoggiarsi a quelle create da terze parti. Negli ambienti DOS è sufficiente porre il codice del servizio richiesto in AX ed usare l'istruzione INT 21h per richiamare il relativo [[software interrupt]], una delle caratteristiche più peculiari delle CPU Intel x86. Tra le funzioni più comuni per l'input/output da tastiera:
* servizio 01h==> Acquisizione di un carattere da tastiera con eco sul video. Attende la pressione di un tasto e restituisce il codice ASCII del tasto premuto
* servizio
* servizio
* servizio
* servizio 4Ch ==> Servizio di ritorno al sistema operativo. Consente di terminare il programma.
Quindi, per acquisire un carattere (con eco sul video):''
MOV AH, 01h ; servizio 01h
INT 21h ; se AX=0001h, allora in AL va il codice ASCII del tasto premuto
''E volendo poi stamparlo:
MOV DL,AL ; copio il codice ASCII del tasto letto il DL
MOV AH,02h ; servizio 02h
INT 21h ; se AX=0002h, allora stampa il carattere di codice ASCII in D
''Come si può vedere, sia le operazioni di acquisizione che di stampa fanno rifemento ai codici di carattere ASCII. Nel caso si voglia leggere in input una cifra numerica, per risalire al valore numerico basta sottrarre il valore 30h (48 in decimale) al suo codice ASCII. Infatti 30h in ASCII corrisponde al carattere "0", 31h (49 in decimale) all'"1" e così via...▼
▲Come si può vedere, sia le operazioni di acquisizione che di stampa fanno rifemento ai codici di carattere ASCII. Nel caso si voglia leggere in input una cifra numerica, per risalire al valore numerico basta sottrarre il valore 30h (48 in decimale) al suo codice ASCII. Infatti 30h in ASCII corrisponde al carattere "0", 31h (49 in decimale) all'"1" e così via...
Nel caso in cui si voglia stampare una stringa:''
stringa DB 13,10,"questa è una stringa","$" ;alloco una variabile da un byte che chiamo stringa e in cui ci salvo una sequenza di caratteri(una stringa appunto)
LEA DX,stringa ;copio l'indirizzo di memoria che punta alla stringa in DX
Riga 379 ⟶ 331:
* Guida Linguaggio Assembly MIPS/SPIM Architetture R2000/R3000, http://www.marcofb.net/main/guida_assembler.html
* Imparare l'Assembly con Visual C++ http://blogs.academicclub.org/leonardo/category/assembly/
* {{lingue|en|it|fr|es|de|zh}}
* Risorse Assembler, guide, sorgenti http://www.intel-assembler.it/
| |||