Premiers pas avec l'assemblage

Assemblée est un langage de bas niveau dont la fonction est de fournir tous les éléments nécessaires à la programmation de l'architecture des PC de bureau ou portables. Sa courbe d'apprentissage est un peu raide et très peu de concepts peuvent être appliqués à partir de langages de haut niveau tels que Python, Ruby ou JavaCependant, c'est le langage le plus puissant pour la programmation d'architectures basées sur x64.
Bien qu'il s'agisse d'un langage complexe, dans ses versions les plus récentes, il laisse de côté l'utilisation d'hexadécimaux et les remplace par des conventions de nommage plus faciles à mémoriser et à lire, en plus d'avoir des caractéristiques plus élevées telles que l'utilisation de macros et l'inclusion définie par l'utilisateur Types de données.
Lorsque le processus de développement se termine, ces lignes de code sont lues par le programme assembleur puis traduites en code machine par un processus similaire à celui de compilation dans les langages de haut niveau mais ici ça s'appelle rejoindre.
Pour les besoins de ce tutoriel, nous verrons en premier lieu à quoi ressemble le processus de codage dans 32 bits, car il s'agit d'une étape fondamentale pour parvenir à une meilleure compréhension de la langue et du processus de codage dans les applications de 64 bits, ceci en partageant de nombreuses caractéristiques avec l'architecture x86 64 bits.
Il y a plusieurs façons de commencer à coder Assemblée pour les applications 32 bits, mais l'un des moyens les plus simples et les plus pratiques de le faire est de Visual Studio puisqu'il a quelque chose qui s'appelle assemblé en ligne où le code de Assemblée est intégré dans C++ normal et courant, cela peut être fait en une seule ligne ou en blocs de code avec le mot réservé __asm.
ImportantLe mot-clé __asm ​​​​peut être utilisé avec un seul trait de soulignement. Il s'agit d'une ancienne directive utilisée pour assurer la compatibilité dans les applications moins modernes.
Ceci étant clarifié, la première chose que nous devons faire est d'obtenir Visual Studio, pour ce tutoriel nous avons utilisé la version Express cependant le code est valable dans les deux versions du IDS. Nous téléchargeons dans le lien suivant notre IDS et on lance dans l'installeur :

Une fois le processus d'installation terminé, nous pouvons commencer à coder dans Assemblée, pour cela nous allons faire un petit exemple où nous montrerons comment nous pouvons intégrer le code de Assemblée dans C++ avec le mot réservé __asm, où tout segment de code à côté de ce mot sera traité comme du code natif de Assemblée par le compilateur C++.
Nous ouvrons notre Visual Studio et créons un nouveau projet de type Application console Win32, nous poussons D'accord et l'assistant de création de projet s'affichera, qui nous demandera quel type de projet nous voulons et si nous voulons un projet vide, nous vous recommandons de laisser toutes les options par défaut et d'appuyer sur Finaliser:

AGRANDIR

L'assistant va créer un code de base pour notre projet, qui contiendra une bibliothèque et la méthode principale, il devrait ressembler à ceci :

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

Ayant maintenant le code de base, nous devons ajouter notre ligne de Assemblée, en plus il faut ajouter la librairie pour pouvoir imprimer par console et le espace de noms pour que tout fonctionne correctement, voyons le code final :

 #include "stdafx.h" #include en utilisant l'espace de noms std; int _tmain (int argc, _TCHAR * argv []) {int x = 0; _asm mov x, 25 cout << "La valeur de x est :" <<>

Ce que nous avons fait ici, c'est définir une variable appelée x puis par le code Assemblée on lui attribue la valeur 25, pour l'imprimer enfin avec cout, comme nous pouvons le voir, c'est un processus assez simple pour intégrer le Code d'assemblage, il ne nous reste plus qu'à lancer notre petit programme, pour cela nous pouvons appuyer sur Ctrl + F5 où notre programme sera compilé et exécuté, voyons à quoi ressemble cette opération :

AGRANDIR

De plus, nous pouvons inclure plusieurs lignes de code de Assemblée dans notre code C++, ce que l'on peut obtenir en plaçant le mot réservé __asm et en ouvrant un bloc de code, voyons comment nous y parvenons :

 float Sqrt (float f) {__asm ​​​​{fld f // Mettre f sur la pile des opérations fsqrt // Calculer sqrt}}

Avantages de l'assemblage en ligneIl y a de nombreux avantages à utiliser l'assemblage en ligne au lieu d'une application native de 32 bits de Assemblée, par exemple l'envoi de paramètres aux fonctions est entièrement géré par le compilateur de C++ et il injectera la quantité exacte de code machine afin que nous n'ayons pas à nous soucier d'un débordement de mémoire ou de quelque chose comme ça.
Mais tout comme nous avons des avantages, nous trouvons également des inconvénients dans cette façon de coder, l'un d'eux est que le développeur perd un peu le contrôle sur l'application, comme par exemple manipuler la pile ou même définir ses propres conventions.
L'assemblage en ligne offre beaucoup de flexibilité et nous permet d'entrer dans ce monde rapidement et facilement, mais cette méthode de codage empêche les développeurs d'accéder à certains éléments d'assemblage, c'est pourquoi il est courant d'ajouter du code natif et séparé à notre projet.
Pour cela, nous devons créer nos fichiers séparément, puis inclure les méthodes dont nous avons besoin. Pour atteindre notre objectif, nous allons suivre les étapes suivantes :
1- On crée d'abord un nouveau projet, il peut s'agir d'un projet de type C++ ou de application Windows, les deux fonctionnent pour ajouter les fichiers de Assemblée.
2- Nous ajoutons un fichier C++ à notre projet que nous appellerons principal.cpp qui se chargera d'appeler une procédure de notre dossier Assemblée en lui envoyant un tableau de valeurs numériques puis en imprimant ce que renvoie cette procédure, voyons le contenu de notre fichier principal.cpp:

 #include en utilisant l'espace de noms std; extern "C" int findMinorNum (int * i, int count); int main () {int arr [] = {4, 2, 6, 4, 5, 1, 8, 9, 5, -5} ; cout << "Le plus petit nombre est :" << findMinorNum (arr, 10) << endl; cin.get (); renvoie 0 ;}

3- Ensuite on fait un clic droit sur notre projet, il se trouve sur la partie droite de notre interface, dans la rubrique de Explorateur de solution. Nous sélectionnons le Créer des dépendances et après Construire des personnalisations. Nous faisons cela pour établir comment Visual Studio gérera les fichiers avec l'extension .asmPuisque nous ne voulons pas que le compilateur C ++ compile ces fichiers, notre objectif est que VS fournisse ces fichiers à PLUS M pour que je les assemble et ensuite ces fichiers liés à notre C++ se chargeront de former l'exécutable final.
4- Pour finir avec les dépendances, nous sélectionnons l'option de plus M comme on peut le voir sur l'image suivante :

AGRANDIR

Il est important d'effectuer cette étape avant d'ajouter des fichiers avec le code d'assemblage comme Visual Studio assigne ce qu'un fichier doit faire quand il est créé et non quand il est construit.
5- Ensuite, nous devons ajouter un autre fichier C++, mais cette fois avec l'extension .asm, pour ce tutoriel je l'ai appelé assembleur.asm. De la même manière, nous pouvons lui donner n'importe quel nom, à l'exception de main.asm, car le compilateur peut avoir des problèmes pour localiser votre méthode principale.
6- Nos archives assembleur.asm Il sera chargé de calculer à partir d'une série de valeurs numériques quelle est la plus petite valeur parmi celles-ci puis C++ Il se chargera de recevoir la valeur pour la traiter via cout, voyons le contenu de notre fichier :

; 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 Terminé MainLoop : cmp dword ptr [edx], eax; cmovl eax, dword ptr [edx]; add edx, 4 ; dec ecx ; jnz MainLoop ; Terminé : ret; findNumMinor endpend

Cela nous permet de séparer nos fichiers ainsi que notre logique. La réalisation de ce type de procédures basées sur 32 bits est très peu utilisée mais il est important d'en connaître toutes ses implications, voyons maintenant comment nous modifions notre code pour une application de 64 bits ainsi que les mesures que nous devons prendre pour adapter notre environnement de Visual Studio.
Visual Studio inclut tous les outils nécessaires pour ajouter l'assembly natif à notre projet dans C++, mais pour travailler sur la base 64 bits nous devons apporter des configurations supplémentaires à notre projet, voyons :
1- Les étapes pour réaliser ce type de codage sont similaires à notre exemple précédent, mais à adapter VS on passe à l'option Construire et nous sélectionnons Panneau de configuration:

2- Dans l'écran du gestionnaire de configuration, nous allons sélectionner l'option Nouvelle ou nouveau dans la colonne plate-forme, qui affichera un deuxième écran pour sélectionner la plate-forme du projet, nous sélectionnons x64 et en option Copier les paramètres de nous avons laissé sélectionné l'option de Win32. Cela fera VS changer les chemins de version de 32 bits de PLUS M pour lequel 64, donc tout le travail sera fait par l'IDE.

AGRANDIR

3- Une fois cela fait, nous pouvons compiler notre code et l'exécuter, cependant nous devons modifier notre fichier Assemblée puisque nous travaillons sur des architectures différentes, voyons le nouveau code de notre fichier :

; Liste : assembleur.asm .code ; int findMinorNum (int * arr, int count) FindSmallest proc; mov eax, 7ffffffffh; cmp edx, 0 ; jle Fini ; MainLoop : cmp dword ptr [rcx], eax ; cmovl eax, dword ptr [rcx] ; ajouter rcx, 4; dec edx; jnz MainLoop; Terminé : ret; FindSmallest endp; finir;

Avec cela, nous terminons ce tutoriel, nous avons déjà jeté un premier coup d'œil à la programmation avec Assemblée, cela peut sembler un peu complexe au premier abord mais avec une bonne maîtrise de C++ et les notions de base du langage machine, nous pouvons réaliser des choses intéressantes et utiles dans nos développements.Avez-vous aimé et aidé ce tutoriel ?Vous pouvez récompenser l'auteur en appuyant sur ce bouton pour lui donner un point positif