Primi passi con l'Assemblea

Assemblea è un linguaggio di basso livello la cui funzione è quella di fornire tutti gli elementi necessari per programmare l'architettura di PC desktop o laptop. La sua curva di apprendimento è un po' ripida e pochissimi concetti possono essere applicati da linguaggi di alto livello come Python, Ruby o JavaTuttavia, è il linguaggio più potente per programmare architetture basate su x64.
Nonostante sia un linguaggio complesso, nelle sue versioni più attuali lascia da parte l'uso degli esadecimali e li sostituisce con convenzioni di denominazione più facili da ricordare e leggere, oltre ad avere caratteristiche più elevate come consentire l'uso di macro e l'inclusione definita dall'utente tipi di dati.
Al termine del processo di sviluppo, queste righe di codice vengono lette dal programma assembly e quindi tradotte in codice macchina mediante un processo simile a quello di compilazione in linguaggi di alto livello ma qui si chiama aderire.
Ai fini di questo tutorial vedremo in primo luogo com'è il processo di codifica in 32 bit, poiché è un passaggio fondamentale per raggiungere una maggiore comprensione del linguaggio e del processo di codifica nelle applicazioni di 64 bit, questo condividendo molte caratteristiche con l'architettura x86 64 bit.
Ci sono molti modi per iniziare a programmare Assemblea per applicazioni a 32 bit, ma uno dei modi più semplici e pratici per farlo è tramite Studio visivo dal momento che ha qualcosa chiamato assemblato online dove il codice di Assemblea è incorporato in C++ normale e attuale, questo può essere fatto in una singola riga o in blocchi di codice con la parola riservata __asm.
ImportanteLa parola chiave __asm ​​​​può essere utilizzata con un singolo carattere di sottolineatura. Questa è una vecchia direttiva utilizzata per garantire la compatibilità in applicazioni meno moderne.
Chiarito questo, la prima cosa che dobbiamo fare è ottenere Studio visivo, per questo tutorial abbiamo usato la versione Esprimere tuttavia il codice è valido in entrambe le versioni del SDI. Scarichiamo nel seguente link il nostro SDI ed eseguiamo nell'installer:

Al termine del processo di installazione, possiamo iniziare a codificare in Assemblea, per questo faremo un piccolo esempio in cui dimostreremo come possiamo incorporare il codice di Assemblea in C++ con la parola riservata __asm, dove ogni segmento di codice vicino a questa parola sarà trattato come codice nativo da Assemblea dal compilatore C++.
Apriamo il nostro Visual Studio e creiamo un nuovo progetto di tipo Applicazione console Win32, noi spingiamo Va bene e verrà visualizzata la procedura guidata di creazione del progetto, che ci chiederà che tipo di progetto vogliamo e se ne vogliamo uno vuoto, consigliamo di lasciare tutte le opzioni predefinite e premere finalizzare:

INGRANDIRE

La procedura guidata creerà un codice di base per il nostro progetto, che conterrà una libreria e il metodo principale, dovrebbe assomigliare a questo:

 #include "stdafx.h" int _tmain (int argc, _TCHAR * argv []) {return 0;}

Avendo il codice base ora dobbiamo aggiungere la nostra linea di Assemblea, inoltre dobbiamo aggiungere la libreria per poter stampare da console e il spazio dei nomi affinché tutto funzioni correttamente, vediamo il codice finale:

 #include "stdafx.h" #include using namespace std; int _tmain (int argc, _TCHAR * argv []) {int x = 0; _asm mov x, 25 cout << "Il valore per x è:" <<>

Quello che abbiamo fatto qui è definire una variabile chiamata x e poi attraverso il codice Assemblea gli assegniamo il valore 25, per stamparlo infine con cout, come possiamo vedere, è un processo abbastanza semplice per incorporare il Codice montaggio, ora dobbiamo solo eseguire il nostro programmino, per questo possiamo premere Ctrl + F5 dove verrà compilato ed eseguito il nostro programma, vediamo come si presenta questa operazione:

INGRANDIRE

Inoltre possiamo includere più righe di codice da Assemblea nel nostro codice C++, che possiamo ottenere inserendo la parola riservata __asm e aprendo un blocco di codice, vediamo come otteniamo questo:

 float Sqrt (float f) {__asm ​​​​{fld f // Metti f nello stack delle operazioni fsqrt // Calcola sqrt}}

Vantaggi dell'assemblaggio in lineaCi sono molti vantaggi nell'usare l'assieme in linea invece di un'applicazione nativa di 32 bit di Assemblea, ad esempio l'invio dei parametri alle funzioni è completamente gestito dal compilatore di C++ e inietterà l'esatta quantità di codice macchina, quindi non dobbiamo preoccuparci di un overflow di memoria o qualcosa del genere.
Ma proprio come abbiamo dei vantaggi, troviamo anche degli svantaggi in questo modo di codificare, uno di questi è che lo sviluppatore perde un po' di controllo sull'applicazione, come manipolare lo stack o persino definire le proprie convenzioni.
L'assembly online offre molta flessibilità e ci consente di entrare in questo mondo in modo rapido e semplice, ma questo metodo di codifica impedisce agli sviluppatori di accedere ad alcuni elementi dell'assembly, per questo motivo è comune aggiungere codice nativo e separato al nostro progetto.
Per questo dobbiamo creare i nostri file separatamente e quindi includere i metodi di cui abbiamo bisogno, per raggiungere il nostro obiettivo seguiremo i seguenti passaggi:
1- Per prima cosa creiamo un nuovo progetto, può essere un progetto di tipo C++ o da app di Windows, entrambi funzionano per aggiungere i file da Assemblea.
2- Aggiungiamo un file C++ al nostro progetto che chiameremo principal.cpp che si occuperà di richiamare una procedura dal nostro archivio Assemblea inviandogli un array di valori numerici e poi stampando cosa restituisce questa procedura, vediamo il contenuto del nostro file principal.cpp:

 #include using namespace std; extern "C" int findMinorNum (int * i, int count); int main () {int arr [] = {4, 2, 6, 4, 5, 1, 8, 9, 5, -5}; cout << "Il numero più piccolo è:" << findMinorNum (arr, 10) << endl; cin.get (); restituisce 0;}

3- Quindi facciamo clic con il pulsante destro del mouse sul nostro progetto, che si trova sul lato destro della nostra interfaccia, nella sezione di Esploratore di soluzioni. Selezioniamo il Crea dipendenze e più tardi Crea personalizzazioni. Lo facciamo per stabilire come Visual Studio gestirà i file con l'estensione .asmPoiché non vogliamo che il compilatore C ++ compili questi file, il nostro obiettivo è che VS fornisca questi file a PI M in modo che io li assembli e quindi questi file collegati al nostro C ++ saranno responsabili della formazione dell'eseguibile finale.
4- Per finire con le dipendenze selezioniamo l'opzione di più M come possiamo vedere nell'immagine seguente:

INGRANDIRE

È importante eseguire questo passaggio prima di aggiungere qualsiasi file con codice Assembly come Studio visivo assegna ciò che un file deve fare quando viene creato e non quando viene compilato.
5- Quindi dobbiamo aggiungere un altro file C ++, ma questa volta con l'estensione .asm, per questo tutorial l'ho chiamato assembler.asm. Allo stesso modo possiamo dargli qualsiasi nome eccetto main.asm poiché il compilatore può avere problemi a localizzare dove si trova il tuo metodo principale.
6- Il nostro archivio assembler.asm Si occuperà di calcolare da una serie di valori numerici quale è il valore più piccolo tra questi e poi C++ Si occuperà di ricevere il valore per elaborarlo tramite cout, vediamo il contenuto del nostro file:

; assembler.asm.xmm.model flat, c.data.code findNumMenor proc exportmov edx, dword ptr [esp + 4]; mov ecx, dword ptr [esp + 8]; mov eax, 7fffffffh; cmp ecx, 0; jle Finito MainLoop: cmp dword ptr [edx], eax; cmovl eax, dword ptr [edx]; add edx, 4; dec ecx; jnz MainLoop; Finished: ret; findNumMinor endpend

Questo ci permette di separare i nostri file così come la nostra logica. La realizzazione di questo tipo di procedure basate su 32 bit è molto poco utilizzata ma è importante conoscerne tutte le implicazioni, vediamo ora come modifichiamo il nostro codice per un'applicazione di 64 bit così come i passi che dobbiamo compiere per adattare il nostro ambiente di Studio visivo.
Visual Studio include tutti gli strumenti necessari per aggiungere l'assembly nativo al nostro progetto in C++, ma per lavorare in base a 64 bit dobbiamo fare alcune configurazioni aggiuntive al nostro progetto, vediamo:
1- I passaggi per eseguire questo tipo di codifica sono simili al nostro esempio precedente, ma per adattarsi VS andiamo all'opzione Costruire e selezioniamo Gestore configurazione:

2- Nella schermata del gestore della configurazione selezioneremo l'opzione Nuovo o nuovo nella colonna piattaforma, che visualizzerà una seconda schermata per selezionare la piattaforma del progetto, selezioniamo x64 e nell'opzione Copia impostazioni da abbiamo lasciato selezionato l'opzione di Win32. Questo renderà VS cambia i percorsi della versione da 32 bit di PI M a quello di 64, quindi tutto il lavoro sarà svolto dall'IDE.

INGRANDIRE

3- Fatto ciò, possiamo compilare il nostro codice ed eseguirlo, tuttavia dobbiamo modificare il nostro file Assemblea visto che stiamo lavorando su architetture diverse, vediamo il nuovo codice per il nostro file:

; Listato: assembler.asm .code; int findMinorNum (int * arr, int count) FindSmallest proc; mov eax, 7ffffffh; cmp edx, 0;jle Finito; MainLoop: cmp dword ptr [rcx], eax; cmovl eax, dword ptr [rcx]; aggiungi rcx, 4; dicembre edx; jnz MainLoop; Finito: ret; TrovaEndp più piccolo; fine;

Con questo finiamo questo tutorial, abbiamo già dato una prima occhiata alla programmazione con Assemblea, può sembrare un po' complesso all'inizio ma con una corretta padronanza di C++ e nozioni di base del linguaggio macchina possiamo ottenere cose interessanti e utili nei nostri sviluppi.Ti è piaciuto e hai aiutato questo Tutorial?Puoi premiare l'autore premendo questo pulsante per dargli un punto positivo