Définition du langage d'assemblage

Qu'est-ce qu'un langage d'assemblage ?

Un langage d'assemblage est un type de langage de programmation de bas niveau destiné à communiquer directement avec le matériel d'un ordinateur.Contrairement au langage machine, qui se compose de caractères binaires et hexadécimaux, les langages d'assemblage sont conçus pour être lisibles par les humains.

Les langages de programmation de bas niveau tels que le langage d'assemblage sont un pont nécessaire entre le matériel sous-jacent d'un ordinateur et les langages de programmation de niveau supérieur, tels que Python ou JavaScript, dans lesquels les programmes logiciels modernes sont écrits.

Points clés à retenir

  • Un langage d'assemblage est un type de langage de programmation qui traduit des langages de haut niveau en langage machine.
  • C'est un pont nécessaire entre les programmes logiciels et leurs plates-formes matérielles sous-jacentes.
  • Le langage d'assemblage s'appuie sur la syntaxe du langage, les étiquettes, les opérateurs et les directives pour convertir le code en instruction machine utilisable.
  • Le langage d'assemblage peut passer par des assembleurs à passage unique ou à passages multiples, chacun ayant des utilisations et des avantages spécifiques.
  • Aujourd'hui, les langages d'assemblage sont rarement écrits directement, bien qu'ils soient encore utilisés dans certaines applications de niche, par exemple lorsque les exigences de performances sont particulièrement élevées.

Comment fonctionnent les langages d'assemblage

Fondamentalement, les instructions les plus élémentaires exécutées par un ordinateur sont des codes binaires, composés de uns et de zéros.Ces codes sont directement traduits dans les états "on" et "off" de l'électricité circulant dans les circuits physiques de l'ordinateur.Essentiellement, ces codes simples constituent la base du "langage machine", la variété la plus fondamentale du langage de programmation.

Bien sûr, aucun humain ne serait capable de construire des logiciels modernes en programmant explicitement des uns et des zéros.Au lieu de cela, les programmeurs humains doivent s'appuyer sur diverses couches d'abstraction qui peuvent se permettre d'articuler leurs commandes dans un format plus intuitif pour les humains.

Plus précisément, les programmeurs modernes émettent des commandes dans des "langages de haut niveau", qui utilisent une syntaxe intuitive telle que des mots et des phrases entiers en anglais, ainsi que des opérateurs logiques tels que "et", "ou" et "sinon" qui sont familier à l'usage quotidien.

En fin de compte, cependant, ces commandes de haut niveau doivent être traduites en langage machine.Plutôt que de le faire manuellement, les programmeurs s'appuient sur des langages d'assemblage dont le but est de traduire automatiquement entre ces langages de haut niveau et de bas niveau.Les premiers langages d'assemblage ont été développés dans les années 1940, et bien que les programmeurs modernes et les processeurs de langage naturel modernes passent très peu de temps à s'occuper des langages d'assemblage, ils restent néanmoins essentiels au fonctionnement global d'un ordinateur.

Au début de l'informatique, la programmation système et la programmation d'applications se déroulaient toutes deux entièrement en langage assembleur.Sans les langages d'assemblage, de nombreux ordinateurs modernes et langages de niveau supérieur que nous utilisons aujourd'hui n'auraient pas été possibles.

Composants du langage d'assemblage

Syntaxe

Lors de l'écriture de code dans n'importe quel langage de programme, il existe un ordre de règles spécifique observable qui doit être suivi pour permettre à un compilateur d'exécuter le code sans erreur.Ces règles sont définies comme la syntaxe et contiennent des critères tels que le nombre maximum de caractères autorisés, les caractères par lesquels les lignes de code doivent commencer ou la signification de certains symboles "c'est-à-dire un point-virgule".

Étiquette

Une étiquette est un symbole qui représente l'adresse où une instruction ou des données sont stockées.Son but est d'agir en tant que destination lorsqu'elle est référencée dans une instruction.Les étiquettes peuvent être utilisées partout où une adresse peut être utilisée dans les langages d'assemblage.Une étiquette symbolique se compose d'un identifiant suivi de deux-points, tandis que les étiquettes numériques se composent d'un seul chiffre suivi de deux-points.

Les opérateurs

Également appelés commandes, les opérateurs sont des expressions logiques apparaissant après le champ d'étiquette.De plus, il doit être précédé d'au moins un caractère d'espace blanc.Les opérateurs peuvent être des opcodes ou des directives.L'opcode correspond directement aux instructions de la machine et le code d'opération comprend tout nom de registre associé à l'instruction.En variante, les codes d'opération directifs sont des instructions connues de l'assembleur.

Directif

Les directives sont des instructions à l'assembleur qui indiquent quelles actions doivent avoir lieu pendant le processus d'assemblage.Les directives ont l'importance de déclarer ou de réserver de la mémoire pour les variables ; ces variables peuvent être rappelées ultérieurement dans les processus pour exécuter des fonctions plus dynamiques.Les directives sont également utilisées pour diviser les programmes en différentes sections.

Macro

Une macro de langage d'assemblage est un format de sabot de modèle qui présente une série ou un modèle d'instructions.Cette séquence d'instructions en langage assembleur peut être commune à plusieurs programmes différents.Une fonction de macro est utilisée pour interpréter les définitions de macro, tandis qu'un appel de macro est inséré dans le code source là où le code d'assemblage "normal" aurait été placé à la place de l'ensemble d'instructions de macro.

Mnémonique

Un mnémonique est une abréviation pour une opération.Un mnémonique est entré dans le code d'opération pour chaque instruction de programme d'assemblage pour spécifier un "opcode" raccourci qui représente un ensemble plus grand et complet de codes.Par exemple, le mnémonique "multiplier par deux" a un ensemble complet de code qui exécute le mnémonique.

Trading à haute fréquence

Aujourd'hui, les langages d'assemblage restent le sujet d'étude des étudiants en informatique, afin de les aider à comprendre comment les logiciels modernes sont liés à leurs plates-formes matérielles sous-jacentes.Dans certains cas, les programmeurs doivent continuer à écrire dans des langages d'assemblage, par exemple lorsque les exigences en matière de performances sont particulièrement élevées ou lorsque le matériel en question est incompatible avec les langages de haut niveau actuels.

Les plates-formes de trading à haute fréquence (HFT) utilisées par certaines sociétés financières en sont un exemple pertinent pour la finance.Sur ce marché, la rapidité et la précision des transactions sont d'une importance primordiale pour que les stratégies de trading HFT se révèlent rentables.Par conséquent, afin de gagner un avantage sur leurs concurrents, certaines entreprises HFT ont écrit leur logiciel de trading directement dans des langages d'assemblage, ce qui évite d'attendre que les commandes d'un langage de niveau supérieur soient traduites en langage machine.

Beaucoup pensent que les langages d'assemblage ont les courbes d'apprentissage les plus abruptes et sont les langages informatiques les plus difficiles à apprendre.

Avantages et inconvénients

Le langage d'assemblage peut généralement être exécuté plus rapidement que les langages de haut niveau.Il est relativement facile d'insérer ou de supprimer des composants de code en langage assembleur, et le langage assembleur nécessite généralement moins d'instructions pour effectuer une tâche par rapport à d'autres types de langages.

Les langages d'assemblage sont également souvent utilisés par les programmeurs souhaitant un meilleur contrôle sur leurs ordinateurs, car les langages d'assemblage vous permettent de manipuler directement votre matériel.En raison de sa rapidité et de son importance, certains programmes sont spécifiquement écrits en langage assembleur car le code peut généralement rester plus petit.

Les langages d'assemblage ont tendance à avoir plusieurs inconvénients.Les longs programmes écrits en langage d'assemblage nécessitent généralement une puissance de calcul plus lourde et ne peuvent pas être exécutés sur de petits ordinateurs.Certains peuvent trouver la syntaxe du langage assembleur plus difficile à retenir, et cela peut prendre plus de temps pour coder en utilisant le langage assembleur car il est plus complexe.De plus, le langage d'assemblage n'est généralement pas portable entre différentes marques d'ordinateurs différents ; De la même manière que les avantages sociaux sont perdus lors d'un changement d'entreprise, les langues ne peuvent pas être traduites de manière transparente sur différents ordinateurs.

Avantages
  • L'exécution peut être plus simple par rapport à d'autres langages

  • L'exécution est généralement plus rapide par rapport aux autres langages

  • Permet un contrôle direct sur le matériel

  • Le code peut rester plus petit par rapport à d'autres langages

Les inconvénients
  • La programmation peut être plus difficile à maîtriser par rapport aux langages de haut niveau

  • La syntaxe des langages d'assemblage est difficile

  • Non portable entre les machines

Types d'assembleurs

Le langage d'assemblage doit être traduit en langage machine à l'aide d'un assembleur.Il existe deux principaux types d'assembleurs.

Un assembleur en une seule passe analyse un programme une fois et crée un programme binaire équivalent.Ce type d'assembleur valide le code du langage assembleur en recherchant le code dans une table de code mnémonique.Un assembleur monopasse est souvent plus rapide qu'un assembleur multipasse, et il n'est généralement pas nécessaire de construire de code intermédiaire.

Un assembleur multi-passes signifie que l'assembleur utilise plus d'une passe.Les assembleurs multi-passes créent une table avec chaque symbole et chacune de leurs valeurs lors de la première passe, puis utilisent la table lors des prochaines passes pour générer un nouveau code.Chaque passe distincte gère généralement une tâche spécifique différente.Bien que généralement plus lents, les assembleurs multi-passes avec des structures modulaires peuvent souvent être réutilisés pour différentes machines.

Exemple de code de langage d'assemblage

Vous trouverez ci-dessous un exemple de code de langage d'assemblage Netwide Assembler (NASM).

Exemple de code de langage d'assemblage.

Université Loyola Marymount

Dans cet exemple, l'instruction SYSCALL vers la fin du code déclenche la partie de la mémoire où sont stockés les services du système d'exploitation.Ensuite, le code RAX est utilisé pour appeler du code à écrire, puis RDI pour sortir.La fonction SYSCALL est utilisée deux fois pour invoquer le système d'exploitation ainsi que pour indiquer au système quand le code est terminé et qu'il est temps de quitter.

Qu'est-ce qu'un exemple de langage d'assemblage ?

Les langages d'assemblage les plus couramment utilisés sont ARM, MIPS et x86.

C++ est-il un langage d'assemblage ?

C++ n'est pas composé de code assembleur.Le langage informatique C++ est constitué de code C++ qu'un compilateur traduit en un code machine exécutable.

Python est-il un langage d'assemblage ?

Python est plus avancé que les langages d'assemblage.Les langages d'assemblage sont considérés comme un langage de bas niveau, tandis que les langages de haut niveau tels que C, Java ou Python utilisent des 0 et des 1 au lieu de chiffres, de symboles et d'abréviations.

Comment les langages d'assemblage sont-ils utilisés aujourd'hui ?

Bien que considérés comme des langages de niveau inférieur par rapport aux langages plus avancés, les langages d'assemblage sont toujours utilisés.Le langage d'assemblage est utilisé pour manipuler directement le matériel, accéder aux instructions spécialisées du processeur ou évaluer les problèmes de performances critiques.Ces langages sont également utilisés pour tirer parti de leur avantage de vitesse par rapport aux langages de haut niveau pour des activités sensibles au facteur temps telles que le trading à haute fréquence.

L'essentiel

Le langage d'assemblage est un code de bas niveau qui repose sur une relation étroite entre les instructions saisies à l'aide du langage de codage et la façon dont une machine interprète les instructions de code.Le code est converti en actions exécutables à l'aide d'un assembleur qui convertit l'entrée en instructions reconnaissables pour la machine.Bien que répandus aux débuts de l'informatique, de nombreux systèmes plus importants utilisent des langages de niveau supérieur.