Langage d’assemblage

En programmation informatique , le langage d’assemblage (ou langage assembleur ), ^[1] est tout langage de programmation de bas niveau dans lequel il existe une très forte correspondance entre les instructions du langage et les instructions du code machine de l’architecture . ^[2] Le langage d’assemblage a généralement une déclaration par instruction machine (1:1), mais des constantes, des commentaires , des directives d’ assembleur , ^[3] des étiquettes symboliques , par exemple, des emplacements de mémoire , des registres et des macros ^{[4] [1]} sont généralement également pris en charge.

Sortie secondaire typique d’un assembleur – montrant le langage d’assemblage d’origine (à droite) pour le Motorola MC6800 et la forme assemblée
Paradigme	Impératif , non structuré
Première apparition	1949 ; il y a 73 ans ( 1949 )

Le code assembleur est converti en code machine exécutable par un programme utilitaire appelé assembleur . Le terme “assembleur” est généralement attribué à Wilkes , Wheeler et Gill dans leur livre de 1951 The Preparation of Programs for an Electronic Digital Computer , ^[5] qui, cependant, ont utilisé le terme pour signifier “un programme qui assemble un autre programme composé de plusieurs sections en un seul programme”. ^[6] Le processus de conversion est appelé assemblage , comme dans l’ assemblage du code source . L’étape de calcul lorsqu’un assembleur traite un programme s’appelletemps de montage . Le langage d’assemblage peut également être appelé code machine symbolique . ^{[7] [8]}

Parce que l’assemblage dépend des instructions du code machine, chaque langage d’assemblage ^{[nb 1]} est spécifique à une architecture informatique particulière . ^[9]

Parfois, il existe plusieurs assembleurs pour la même architecture, et parfois un assembleur est spécifique à un système d’exploitation ou à des systèmes d’exploitation particuliers. La plupart des langages d’assemblage ne fournissent pas de syntaxe spécifique pour les appels au système d’exploitation, et la plupart des langages d’assemblage ^{[nb 2]} peuvent être utilisés universellement avec n’importe quel système d’exploitation, car le langage donne accès à toutes les capacités réelles du processeur , sur lesquelles reposent tous les mécanismes d’appel système. repose finalement. Contrairement aux langages d’assemblage, la plupart des langages de programmation de haut niveau sont généralement portables sur plusieurs architectures mais nécessitent une interprétation oucompiler , une tâche beaucoup plus compliquée que l’assemblage.

Au cours des premières décennies de l’informatique, il était courant que la programmation système et la programmation d’application se déroulent entièrement en langage d’assemblage. Bien qu’elle soit toujours irremplaçable à certaines fins, la majorité de la programmation est désormais effectuée dans des langages interprétés et compilés de niveau supérieur. Dans No Silver Bullet , Fred Brooks a résumé les effets de l’abandon de la programmation en langage assembleur : “Le coup le plus puissant pour la productivité, la fiabilité et la simplicité des logiciels a certainement été l’utilisation progressive de langages de haut niveau pour la programmation. La plupart des observateurs reconnaissent que développement avec au moins un facteur cinq de productivité, et avec des gains concomitants de fiabilité, de simplicité et d’intelligibilité.”^[dix]

Aujourd’hui, il est courant d’utiliser de petites quantités de code en langage assembleur dans des systèmes plus grands implémentés dans un langage de niveau supérieur, pour des raisons de performances ou pour interagir directement avec le matériel d’une manière non prise en charge par le langage de niveau supérieur. Par exemple, un peu moins de 2 % du code source de la version 4.9 du noyau Linux est écrit en assembleur ; plus de 97% est écrit en C . ^[11]

Syntaxe du langage d’assemblage

Le langage d’assemblage utilise un mnémonique pour représenter, par exemple, chaque instruction machine ou opcode de bas niveau , chaque directive , généralement aussi chaque registre architectural , drapeau , etc. Certains des mnémoniques peuvent être intégrés et d’autres définis par l’utilisateur. De nombreuses opérations nécessitent un ou plusieurs opérandes pour former une instruction complète. La plupart des assembleurs autorisent les constantes, les registres et les étiquettes nommés pour les emplacements de programme et de mémoire, et peuvent calculer des expressionspour les opérandes. Ainsi, les programmeurs sont libérés des calculs répétitifs fastidieux et les programmes assembleur sont beaucoup plus lisibles que le code machine. Selon l’architecture, ces éléments peuvent également être combinés pour des instructions spécifiques ou des modes d’adressage utilisant des décalages ou d’autres données ainsi que des adresses fixes. De nombreux assembleurs proposent des mécanismes supplémentaires pour faciliter le développement de programmes, contrôler le processus d’assemblage et faciliter le débogage .

Certains sont orientés colonnes, avec des champs spécifiques dans des colonnes spécifiques ; c’était très courant pour les machines utilisant des Cartes perforées dans les années 1950 et au début des années 1960. Certains assembleurs ont une syntaxe libre, avec des champs séparés par des délimiteurs, par exemple ponctuation, espace blanc . Certains assembleurs sont hybrides, avec, par exemple, des étiquettes, dans une colonne spécifique et d’autres champs séparés par des délimiteurs ; cela est devenu plus courant que la syntaxe orientée colonne dans les années 1960.

Système IBM/360

Tous les assembleurs IBM pour System/360 , par défaut, ont une étiquette dans la colonne 1, des champs séparés par des délimiteurs dans les colonnes 2-71, un indicateur de continuation dans la colonne 72 et un numéro de séquence dans les colonnes 73-80. Le délimiteur pour l’étiquette, l’opcode, les opérandes et les commentaires est un espace, tandis que les opérandes individuels sont séparés par des virgules et des parenthèses.

Terminologie

Un assembleur de macros est un assembleur qui inclut une fonction d’ instructions de macros afin que le texte en langage d’assemblage (paramétré) puisse être représenté par un nom, et que ce nom puisse être utilisé pour insérer le texte développé dans un autre code.
- Le code ouvert fait référence à toute entrée d’assembleur en dehors d’une définition de macro.
Un assembleur croisé (voir aussi compilateur croisé ) est un assembleur exécuté sur un ordinateur ou un système d’exploitation (le système hôte ) d’un type différent du système sur lequel le code résultant doit s’exécuter (le système cible ). L’assemblage croisé facilite le développement de programmes pour des systèmes qui ne disposent pas des ressources nécessaires pour prendre en charge le développement de logiciels, tels qu’un système embarqué ou un microcontrôleur . Dans un tel cas, le code objet résultant doit être transféré vers le système cible, via une mémoire morte (ROM, EPROM , etc.), un programmeur(lorsque la mémoire morte est intégrée dans l’appareil, comme dans les microcontrôleurs), ou une liaison de données utilisant soit une copie exacte bit par bit du code objet, soit une représentation textuelle de ce code (comme Intel hex ou Motorola S-record ).
Un assembleur de haut niveau est un programme qui fournit des abstractions de langage plus souvent associées à des langages de haut niveau, telles que des structures de contrôle avancées ( IF/THEN/ELSE , DO CASE, etc.) et des types de données abstraits de haut niveau, notamment des structures/ enregistrements, unions, classes et ensembles.
Un microassembleur est un programme qui aide à préparer un microprogramme , appelé firmware , pour contrôler le fonctionnement de bas niveau d’un ordinateur.
Un méta-assembleur est “un programme qui accepte la description syntaxique et sémantique d’un langage d’assemblage, et génère un assembleur pour ce langage”, ^[12] ou qui accepte un fichier source assembleur avec une telle description et assemble le fichier source dans conformément à cette description. Les assembleurs “Meta-Symbol” pour les séries d’ordinateurs SDS 9 et SDS Sigma sont des méta-assembleurs. ^{[13] [nb 3]} Sperry Univac a également fourni un méta-assembleur pour la série UNIVAC 1100/2200 . ^[14]
L’assembleur inline (ou assembleur embarqué ) est un code assembleur contenu dans un programme de langage de haut niveau. ^[15] Ceci est le plus souvent utilisé dans les programmes système qui ont besoin d’un accès direct au matériel.

Concepts clés

Assembleur

Un programme assembleur crée un code objet en traduisant des combinaisons de mnémoniques et de syntaxe pour les opérations et les modes d’adressage en leurs équivalents numériques. Cette représentation comprend typiquement un code d’opération (« opcode ») ainsi que d’autres bits et données de contrôle. L’assembleur calcule également des expressions constantes et résout les noms symboliques des emplacements de mémoire et d’autres entités. ^[16] L’utilisation de références symboliques est une caractéristique clé des assembleurs, épargnant des calculs fastidieux et des mises à jour d’adresses manuelles après des modifications de programme. La plupart des assembleurs incluent égalementfonctionnalités de macro pour effectuer une substitution textuelle – par exemple, pour générer de courtes séquences d’instructions communes en ligne , au lieu d’ appeler des sous- routines .

Certains assembleurs peuvent également être en mesure d’effectuer certains types simples d’ optimisations spécifiques au jeu d’instructions . Un exemple concret de cela peut être les assembleurs x86 omniprésents de divers fournisseurs. Appelés jump-sizing ^[16] , la plupart d’entre eux sont capables d’effectuer des remplacements d’instructions de saut (sauts longs remplacés par des sauts courts ou relatifs) en un nombre quelconque de passes, sur demande. D’autres peuvent même faire de simples réarrangements ou insertions d’instructions, comme certains assembleurs pour les architectures RISC qui peuvent aider à optimiser une planification d’instructions sensée pour exploiter le pipeline CPU aussi efficacement que possible. ^[ ^{citation nécessaire ]}

Les assembleurs sont disponibles depuis les années 1950, comme première étape au-dessus du langage machine et avant les langages de programmation de haut niveau tels que Fortran , Algol , COBOL et Lisp . Il existe également plusieurs classes de traducteurs et de générateurs de code semi-automatiques avec des propriétés similaires aux langages d’assemblage et de haut niveau, Speedcode étant peut-être l’un des exemples les plus connus.

Il peut y avoir plusieurs assembleurs avec une syntaxe différente pour une architecture de processeur ou de jeu d’instructions particulière . Par exemple, une instruction pour ajouter des données mémoire à un registre dans un processeur de la famille x86 pourrait être add eax,[ebx], dans la syntaxe Intel d’origine , alors que cela serait écrit addl (%ebx),%eaxdans la syntaxe AT&T utilisée par l’ assembleur GNU . Malgré des apparences différentes, différentes formes syntaxiques génèrent généralement le même code machine numérique . Un même assembleur peut également avoir différents modes afin de prendre en charge les variations de formes syntaxiques ainsi que leurs interprétations sémantiques exactes (telles que FASM -syntaxe,TASM -syntaxe, mode idéal, etc., dans le cas particulier de la programmation en assembleur x86 ).

Nombre de passes

Il existe deux types d’assembleurs en fonction du nombre de passages à travers la source nécessaires (combien de fois l’assembleur lit la source) pour produire le fichier objet.

Les assembleurs en un seul passage parcourent le code source une fois. Tout symbole utilisé avant d’être défini nécessitera des “errata” à la fin du code objet (ou, au moins, pas avant le point où le symbole est défini) indiquant à l’ éditeur de liens ou au chargeur de “revenir en arrière” et d’écraser un espace réservé qui avait été laissé là où le symbole encore indéfini était utilisé.
Les assembleurs multi-passes créent une table avec tous les symboles et leurs valeurs lors des premières passes, puis utilisent la table lors des passes ultérieures pour générer du code.

Dans les deux cas, l’assembleur doit pouvoir déterminer la taille de chaque instruction sur les passes initiales afin de calculer les adresses des symboles suivants. Cela signifie que si la taille d’une opération faisant référence à un opérande défini plus tard dépend du type ou de la distance de l’opérande, l’assembleur fera une estimation pessimiste lors de la première rencontre avec l’opération, et si nécessaire, la remplira avec un ou plusieurs ” non -opération ” instructions dans une passe ultérieure ou les errata. Dans un assembleur avec optimisation de judas , les adresses peuvent être recalculées entre les passes pour permettre de remplacer le code pessimiste par un code adapté à la distance exacte de la cible.

La raison initiale de l’utilisation d’assembleurs en une passe était la taille de la mémoire et la vitesse d’assemblage – souvent une deuxième passe nécessiterait de stocker la table de symboles en mémoire (pour gérer les références directes), de rembobiner et de relire la source du programme sur bande ou de relire un jeu de cartes ou ruban de papier perforé . Les ordinateurs ultérieurs dotés de mémoires beaucoup plus volumineuses (en particulier le stockage sur disque) disposaient de l’espace nécessaire pour effectuer tous les traitements nécessaires sans une telle relecture. L’avantage de l’assembleur multi-passes est que l’absence d’errata accélère le processus de liaison (ou le chargement du programme si l’assembleur produit directement du code exécutable). ^[17]

Exemple : dans l’extrait de code suivant, un assembleur en une passe serait en mesure de déterminer l’adresse de la référence arrière BKWD lors de l’assemblage de l’instruction S2 , mais ne serait pas en mesure de déterminer l’adresse de la référence avant FWD lors de l’assemblage de l’instruction de branche S1 ; en effet, FWD peut être indéfini. Un assembleur à deux passes déterminerait les deux adresses dans la passe 1, de sorte qu’elles seraient connues lors de la génération de code dans la passe 2.

S1 B TA … FWD EQU * … BKWD EQU * … S2 B BKWD Assembleurs de haut niveau

Des assembleurs de haut niveau plus sophistiqués fournissent des abstractions de langage telles que :

Déclarations et invocations de procédures/fonctions de haut niveau
Structures de contrôle avancées (IF/THEN/ELSE, SWITCH)
Types de données abstraits de haut niveau, y compris les structures/enregistrements, les unions, les classes et les ensembles
Traitement de macros sophistiqué (bien que disponible sur les assembleurs ordinaires depuis la fin des années 1950 pour, par exemple, les séries IBM 700 et IBM 7000 , et depuis les années 1960 pour IBM System/360 (S/360), entre autres machines)
Fonctionnalités de programmation orientée objet telles que les classes , les objets , l’abstraction , le polymorphisme et l’ héritage ^[18]

Voir la conception de la langue ci-dessous pour plus de détails.

Langage d’assemblage

Un programme écrit en langage d’assemblage se compose d’une série d’ instructions de processeur mnémotechniques et de méta-instructions (connues sous le nom d’opérations déclaratives, de directives, de pseudo-instructions, de pseudo-opérations et de pseudo-ops), de commentaires et de données. Les instructions en langage d’assemblage consistent généralement en un mnémonique d’ opcode suivi d’un opérande , qui peut être une liste de données, d’arguments ou de paramètres. ^[19] Certaines instructions peuvent être “implicites”, ce qui signifie que les données sur lesquelles l’instruction opère sont implicitement définies par l’instruction elle-même – une telle instruction ne prend pas d’opérande. L’instruction résultante est traduite par un assembleur en langage machineinstructions pouvant être chargées en mémoire et exécutées.

Par exemple, l’instruction ci-dessous indique à un processeur x86 / IA-32 de déplacer une valeur immédiate de 8 bits dans un registre . Le code binaire de cette instruction est 10110 suivi d’un identifiant de 3 bits pour quel registre utiliser. L’identifiant du registre AL est 000, donc le code machine suivant charge le registre AL avec les données 01100001. ^[19]

10110000 01100001

Ce code informatique binaire peut être rendu plus lisible par l’homme en l’exprimant en hexadécimal comme suit.

B0 61

Ici, B0signifie ‘Déplacer une copie de la valeur suivante dans AL , et 61est une représentation hexadécimale de la valeur 01100001, qui est 97 en décimal . Le langage d’assemblage pour la famille 8086 fournit le mnémonique MOV (une abréviation de move ) pour des instructions telles que celle-ci, de sorte que le code machine ci-dessus peut être écrit comme suit en langage d’assemblage, avec un commentaire explicatif si nécessaire, après le point-virgule. C’est beaucoup plus facile à lire et à retenir.

MOUV AL , 61h ; Charger AL avec 97 décimal (61 hex)

Dans certains langages d’assemblage (y compris celui-ci), le même mnémonique, tel que MOV, peut être utilisé pour une famille d’instructions associées pour charger, copier et déplacer des données, qu’il s’agisse de valeurs immédiates, de valeurs dans des registres ou d’emplacements mémoire pointés par valeurs dans des registres ou par des adresses immédiates (c’est-à-dire directes). D’autres assembleurs peuvent utiliser des mnémoniques d’opcode séparés tels que L pour “déplacer la mémoire vers le registre”, ST pour “déplacer le registre vers la mémoire”, LR pour “déplacer le registre vers le registre”, MVI pour “déplacer l’opérande immédiat vers la mémoire”, etc.

Si le même mnémonique est utilisé pour différentes instructions, cela signifie que le mnémonique correspond à plusieurs codes d’instructions binaires différents, hors données (par exemple le 61hdans cet exemple), selon les opérandes qui suivent le mnémonique. Par exemple, pour les processeurs x86/IA-32, la syntaxe du langage d’assemblage Intel MOV AL, AHreprésente une instruction qui déplace le contenu du registre AH dans le registre AL . La forme hexadécimale ^{[nb 4]} de cette instruction est :

88 E0

Le premier octet, 88h, identifie un déplacement entre un registre de la taille d’un octet et un autre registre ou mémoire, et le deuxième octet, E0h, est codé (avec trois champs de bits) pour spécifier que les deux opérandes sont des registres, la source est AH , et la destination est AL .

Dans un cas comme celui-ci où le même mnémonique peut représenter plus d’une instruction binaire, l’assembleur détermine quelle instruction générer en examinant les opérandes. Dans le premier exemple, l’opérande 61hest une constante numérique hexadécimale valide et n’est pas un nom de registre valide, donc seule l’ B0instruction peut être applicable. Dans le deuxième exemple, l’opérande AHest un nom de registre valide et non une constante numérique valide (hexadécimal, décimal, octal ou binaire), donc seule l’ 88instruction peut être applicable.

Les langages d’assemblage sont toujours conçus de manière à ce que ce type d’ambiguïté soit universellement appliqué par leur syntaxe. Par exemple, dans le langage d’assemblage Intel x86, une constante hexadécimale doit commencer par un chiffre, de sorte que le nombre hexadécimal ‘A’ (égal à décimal dix) s’écrit 0Ahou 0AH, non AH, spécifiquement pour qu’il ne puisse pas apparaître comme le nom du registre AH . (La même règle évite également l’ambiguïté avec les noms des registres BH , CH et DH , ainsi qu’avec tout symbole défini par l’utilisateur qui se termine par la lettre H et ne contient autrement que des caractères hexadécimaux, tels que le mot “BEACH “.)

En revenant à l’exemple d’origine, alors que l’opcode x86 10110000 ( B0) copie une valeur de 8 bits dans le registre AL , 10110001 ( B1) la déplace dans CL et 10110010 ( B2) le fait dans DL . Voici des exemples de langage d’assemblage pour ceux-ci. ^[19]

MOV AL , 1h ; Charger AL avec la valeur immédiate 1 MOV CL , 2h ; Charger CL avec la valeur immédiate 2 MOV DL , 3h ; Charger DL avec la valeur immédiate 3

La syntaxe de MOV peut également être plus complexe comme le montrent les exemples suivants. ^[20]

MOV EAX , [ EBX ] ; Déplacer les 4 octets en mémoire à l’adresse contenue dans EBX dans EAX MOV [ ESI + EAX ], CL ; Déplace le contenu de CL dans l’octet à l’adresse ESI+EAX MOV DS , DX ; Déplacer le contenu de DX dans le registre de segment DS

Dans chaque cas, le mnémonique MOV est traduit directement dans l’un des opcodes 88-8C, 8E, A0-A3, B0-BF, C6 ou C7 par un assembleur, et le programmeur n’a normalement pas besoin de savoir ou de se souvenir lequel. ^[19]

Transformer le langage assembleur en code machine est le travail d’un assembleur, et l’inverse peut au moins partiellement être réalisé par un désassembleur . Contrairement aux langages de haut niveau , il existe une correspondance biunivoque entre de nombreuses instructions d’assemblage simples et des instructions en langage machine. Cependant, dans certains cas, un assembleur peut fournir des pseudo -instructions(essentiellement des macros) qui se développent en plusieurs instructions en langage machine pour fournir les fonctionnalités couramment nécessaires. Par exemple, pour une machine qui n’a pas d’instruction “brancher si supérieur ou égal”, un assembleur peut fournir une pseudo-instruction qui se développe en “set si inférieur à” et “branche si zéro (sur le résultat de l’instruction set)” de la machine . La plupart des assembleurs complets fournissent également une macro richelangage (discuté ci-dessous) qui est utilisé par les fournisseurs et les programmeurs pour générer des séquences de code et de données plus complexes. Étant donné que les informations sur les pseudo-instructions et les macros définies dans l’environnement de l’assembleur ne sont pas présentes dans le programme objet, un désassembleur ne peut pas reconstruire les invocations de macro et de pseudo-instruction, mais ne peut désassembler que les instructions machine réelles que l’assembleur a générées à partir de ces entités abstraites du langage d’assemblage. De même, puisque les commentaires dans le fichier source du langage assembleur sont ignorés par l’assembleur et n’ont aucun effet sur le code objet qu’il génère, un désassembleur est toujours complètement incapable de récupérer les commentaires source.

Chaque architecture informatique possède son propre langage machine. Les ordinateurs diffèrent par le nombre et le type d’opérations qu’ils prennent en charge, par les différentes tailles et nombres de registres et par les représentations des données stockées. Alors que la plupart des ordinateurs à usage général sont capables d’exécuter essentiellement la même fonctionnalité, la manière dont ils le font diffère; les langages d’assemblage correspondants reflètent ces différences.

Plusieurs ensembles de mnémoniques ou de syntaxe de langage d’assemblage peuvent exister pour un seul jeu d’instructions, généralement instancié dans différents programmes d’assembleur. Dans ces cas, le plus populaire est généralement celui fourni par le fabricant du processeur et utilisé dans sa documentation.

Deux exemples de processeurs qui ont deux ensembles différents de mnémoniques sont la famille Intel 8080 et l’Intel 8086/8088. Parce qu’Intel a revendiqué le droit d’auteur sur ses mnémoniques en langage d’assemblage (sur chaque page de leur documentation publiée dans les années 1970 et au début des années 1980, au moins), certaines entreprises qui ont produit indépendamment des processeurs compatibles avec les jeux d’instructions Intel ont inventé leurs propres mnémoniques. Le processeur Zilog Z80 , une amélioration de l’ Intel 8080A , prend en charge toutes les instructions 8080A et bien d’autres ; Zilog a inventé un tout nouveau langage d’assemblage, non seulement pour les nouvelles instructions mais aussi pour toutes les instructions 8080A. Par exemple, là où Intel utilise les mnémoniques MOV , MVI , LDA , STA ,LXI , LDAX , STAX , LHLD et SHLD pour diverses instructions de transfert de données, le langage d’assemblage Z80 utilise le mnémonique LD pour chacun d’eux. Un cas similaire est celui des processeurs NEC V20 et V30 , des copies améliorées des processeurs Intel 8086 et 8088, respectivement. Comme Zilog avec le Z80, NEC a inventé de nouveaux mnémoniques pour toutes les instructions 8086 et 8088, pour éviter les accusations de violation des droits d’auteur d’Intel. (On peut se demander si de tels droits d’auteur peuvent être valides, et plus tard des sociétés de processeurs telles qu’AMD ^{[nb 5]} et Cyrixrepublié les mnémoniques d’instruction x86 / IA-32 d’Intel exactement sans autorisation ni sanction légale.) Il est douteux que, dans la pratique, de nombreuses personnes qui ont programmé les V20 et V30 aient réellement écrit dans le langage d’assemblage de NEC plutôt que dans celui d’Intel; étant donné que deux langages d’assemblage pour la même architecture de jeu d’instructions sont isomorphes (un peu comme l’ anglais et le latin cochon ), il n’est pas nécessaire d’utiliser le langage d’assemblage publié par un fabricant avec les produits de ce fabricant.

Conception de la langue

Éléments basiques

Il existe une grande diversité dans la manière dont les auteurs d’assembleurs catégorisent les énoncés et dans la nomenclature qu’ils utilisent. En particulier, certains décrivent tout autre chose qu’un mnémonique machine ou un mnémonique étendu comme une pseudo-opération (pseudo-op). Un langage d’assemblage typique se compose de 3 types d’instructions utilisées pour définir les opérations du programme :

Mnémoniques d’ opcode
Définitions des données
Directives de montage

Mnémoniques d’opcode et mnémoniques étendus

Les instructions (instructions) en langage assembleur sont généralement très simples, contrairement à celles des langages de haut niveau . Généralement, un mnémonique est un nom symbolique pour une seule instruction exécutable en langage machine (un opcode ), et il existe au moins un mnémonique d’opcode défini pour chaque instruction en langage machine. Chaque instruction se compose généralement d’une opération ou d’un opcode plus zéro ou plusieurs opérandes. La plupart des instructions font référence à une seule valeur ou à une paire de valeurs. Les opérandes peuvent être immédiats (valeur codée dans l’instruction elle-même), des registres spécifiés dans l’instruction ou implicites, ou les adresses de données situées ailleurs dans le stockage. Ceci est déterminé par l’architecture sous-jacente du processeur : l’assembleur reflète simplement le fonctionnement de cette architecture. Les mnémoniques étendus sont souvent utilisés pour spécifier une combinaison d’un opcode avec un opérande spécifique, par exemple, les assembleurs System / 360 utilisent Bcomme mnémonique étendu pour BCavec un masque de 15 et NOP(“NO OPeration” – ne rien faire pour une étape) pour BCavec un masque de 0.

Les mnémoniques étendus sont souvent utilisés pour prendre en charge des utilisations spécialisées d’instructions, souvent à des fins non évidentes d’après le nom de l’instruction. Par exemple, de nombreux processeurs n’ont pas d’instruction NOP explicite, mais ont des instructions qui peuvent être utilisées à cette fin. Dans les processeurs 8086, l’instruction est utilisée pour , étant un pseudo-opcode pour coder l’instruction . Certains désassembleurs le reconnaissent et décoderont l’ instruction en tant que . De même, les assembleurs IBM pour System/360 et System/370 utilisent les mnémoniques étendus et pour et avec zéro masques. Pour l’architecture SPARC, il s’agit d’ instructions synthétiques .xchg ax,axnopnopxchg ax,axxchg ax,axnopNOPNOPRBCBCR^[21]

Certains assembleurs prennent également en charge de simples macro-instructions intégrées qui génèrent deux instructions machine ou plus. Par exemple, avec certains assembleurs Z80, l’instruction ld hl,bcest reconnue pour générer ld l,csuivie de ld h,b. ^[22] Ceux-ci sont parfois connus sous le nom de pseudo-opcodes .

Learn more.

Le Lisp

Jul 14, 2022

Trident (programme nucléaire britannique)

Jul 14, 2022

L’universite de Wisconsin-Madison

Jul 14, 2022

Phil McGraw

Jul 14, 2022

Les mnémoniques sont des symboles arbitraires ; en 1985, l’ IEEE a publié la norme 694 pour un ensemble uniforme de mnémoniques à utiliser par tous les assembleurs. La norme a depuis été retirée.

Directives sur les données

Il existe des instructions utilisées pour définir des éléments de données pour contenir des données et des variables. Ils définissent le type de données, la longueur et l’ alignement des données. Ces instructions peuvent également définir si les données sont disponibles pour des programmes extérieurs (programmes assemblés séparément) ou uniquement pour le programme dans lequel la section de données est définie. Certains assembleurs les classent comme des pseudo-opérations.

Directives de montage

Les directives d’assemblage, également appelées pseudo-opcodes, pseudo-opérations ou pseudo-ops, sont des commandes données à un assembleur “lui ordonnant d’effectuer des opérations autres que des instructions d’assemblage”. ^[16] Les directives affectent la façon dont l’assembleur fonctionne et “peuvent affecter le code objet, la table des symboles, le fichier de liste et les valeurs des paramètres internes de l’assembleur”. Parfois, le terme pseudo-opcode est réservé aux directives qui génèrent du code objet, comme celles qui génèrent des données. ^[23]

Les noms des pseudo-opérations commencent souvent par un point pour les distinguer des instructions machine. Les pseudo-opérations peuvent rendre l’assemblage du programme dépendant des paramètres entrés par un programmeur, de sorte qu’un programme peut être assemblé de différentes manières, peut-être pour différentes applications. Ou, un pseudo-op peut être utilisé pour manipuler la présentation d’un programme afin de faciliter sa lecture et sa maintenance. Une autre utilisation courante des pseudo-opérations consiste à réserver des zones de stockage pour les données d’exécution et éventuellement à initialiser leur contenu à des valeurs connues.

Les assembleurs symboliques permettent aux programmeurs d’associer des noms arbitraires ( étiquettes ou symboles ) à des emplacements de mémoire et à diverses constantes. Habituellement, chaque constante et variable reçoit un nom afin que les instructions puissent référencer ces emplacements par leur nom, favorisant ainsi le code auto-documenté . Dans le code exécutable, le nom de chaque sous-programme est associé à son point d’entrée, de sorte que tout appel à un sous-programme peut utiliser son nom. Dans les sous-programmes, les destinations GOTO reçoivent des étiquettes. Certains assembleurs prennent en charge les symboles locaux qui sont souvent lexicalement distincts des symboles normaux (par exemple, l’utilisation de “10$” comme destination GOTO).

Certains assembleurs, tels que NASM , offrent une gestion flexible des symboles, permettant aux programmeurs de gérer différents espaces de noms , de calculer automatiquement les décalages dans les structures de données et d’attribuer des étiquettes faisant référence à des valeurs littérales ou au résultat de calculs simples effectués par l’assembleur. Les étiquettes peuvent également être utilisées pour initialiser des constantes et des variables avec des adresses relocalisables.

Les langages d’assemblage, comme la plupart des autres langages informatiques, permettent d’ajouter des commentaires au code source du programme qui seront ignorés lors de l’assemblage. Des commentaires judicieux sont essentiels dans les programmes en langage assembleur, car la signification et le but d’une séquence d’instructions machine binaires peuvent être difficiles à déterminer. Le langage d’assemblage “brut” (non commenté) généré par les compilateurs ou les désassembleurs est assez difficile à lire lorsque des modifications doivent être apportées.

Macros

De nombreux assembleurs prennent en charge les macros prédéfinies , et d’autres prennent en charge les macros définies par le programmeur (et redéfinissables à plusieurs reprises) impliquant des séquences de lignes de texte dans lesquelles des variables et des constantes sont intégrées. La définition de la macro est le plus souvent ^{[nb 6]}un mélange d’instructions assembleur, par exemple, des directives, des instructions machine symboliques et des modèles d’instructions assembleur. Cette séquence de lignes de texte peut inclure des opcodes ou des directives. Une fois qu’une macro a été définie, son nom peut être utilisé à la place d’un mnémonique. Lorsque l’assembleur traite une telle instruction, il remplace l’instruction par les lignes de texte associées à cette macro, puis les traite comme si elles existaient dans le fichier de code source (y compris, dans certains assembleurs, l’expansion de toutes les macros existantes dans le texte de remplacement) . Les macros en ce sens datent des autocodeurs IBM des années 1950. ^{[24] [n° 7]}

Les assembleurs de macros ont généralement des directives pour, par exemple, définir des macros, définir des variables, définir des variables sur le résultat d’une expression arithmétique, logique ou de chaîne, itérer, générer conditionnellement du code. Certaines de ces directives peuvent être limitées à une utilisation dans une définition de macro, par exemple, MEXIT dans HLASM , tandis que d’autres peuvent être autorisées dans le code ouvert (en dehors des définitions de macro), par exemple, AIF et COPY dans HLASM.

En langage d’assemblage, le terme “macro” représente un concept plus complet que dans certains autres contextes, tels que le préprocesseur dans le Langage de programmation C , où sa directive #define est généralement utilisée pour créer de courtes macros sur une seule ligne. Les instructions de macro d’assembleur, comme les macros en PL/I et certains autres langages, peuvent être de longs “programmes” en eux-mêmes, exécutés par interprétation par l’assembleur lors de l’assemblage.

Étant donné que les macros peuvent avoir des noms “courts” mais s’étendre à plusieurs voire plusieurs lignes de code, elles peuvent être utilisées pour faire apparaître les programmes en langage assembleur comme beaucoup plus courts, nécessitant moins de lignes de code source, comme avec les langages de niveau supérieur. Ils peuvent également être utilisés pour ajouter des niveaux de structure plus élevés aux programmes d’assemblage, introduire éventuellement du code de débogage intégré via des paramètres et d’autres fonctionnalités similaires.

Les assembleurs de macros permettent souvent aux macros de prendre des paramètres . Certains assembleurs incluent des langages de macro assez sophistiqués, incorporant des éléments de langage de haut niveau tels que des paramètres optionnels, des variables symboliques, des conditions, la manipulation de chaînes et des opérations arithmétiques, tous utilisables lors de l’exécution d’une macro donnée, et permettant aux macros de sauvegarder le contexte ou d’échanger des informations. . Ainsi, une macro peut générer de nombreuses instructions en langage assembleur ou définitions de données, basées sur les arguments de la macro. Cela pourrait être utilisé pour générer des structures de données de style enregistrement ou ” déroulé”, par exemple, ou pourrait générer des algorithmes entiers basés sur des paramètres complexes. Par exemple, une macro “sort” pourrait accepter la spécification d’une clé de tri complexe et générer du code conçu pour cette clé spécifique, sans avoir besoin des tests d’exécution qui serait nécessaire pour une procédure générale interprétant la spécification. Une organisation utilisant un langage d’assemblage qui a été fortement étendu à l’aide d’une telle suite de macros peut être considérée comme travaillant dans un langage de niveau supérieur puisque ces programmeurs ne travaillent pas avec le niveau le plus bas d’un ordinateur. Éléments conceptuels Soulignant ce point, des macros ont été utilisées pour implémenter une première machine virtuelle dans SNOBOL4(1967), qui a été écrit dans le langage d’implémentation SNOBOL (SIL), un langage d’assemblage pour une machine virtuelle. La machine cible traduirait cela dans son code natif à l’aide d’un assembleur de macros . ^[25] Cela a permis un degré élevé de portabilité pour l’époque.

Les macros étaient utilisées pour personnaliser des systèmes logiciels à grande échelle pour des clients spécifiques à l’ère du mainframe et étaient également utilisées par le personnel des clients pour satisfaire les besoins de leurs employeurs en créant des versions spécifiques des systèmes d’exploitation du fabricant. Cela a été fait, par exemple, par des programmeurs système travaillant avec le Conversational Monitor System / Virtual Machine ( VM/CMS ) d’ IBM et avec les modules complémentaires de « traitement des transactions en temps réel » d’ IBM , le système de contrôle des informations client CICS et ACP / TPF , le système aérien / financier qui a commencé dans les années 1970 et qui gère encore aujourd’hui de nombreux grands systèmes de réservation informatisés (CRS) et systèmes de cartes de crédit.

Il est également possible d’utiliser uniquement les capacités de traitement de macros d’un assembleur pour générer du code écrit dans des langages complètement différents, par exemple, pour générer une version d’un programme en COBOL à l’aide d’un programme de macro assembleur pur contenant des lignes de code COBOL à l’intérieur d’opérateurs de temps d’assemblage. ordonnant à l’assembleur de générer du code arbitraire. IBM OS/360 utilise des macros pour effectuer la génération du système . L’utilisateur spécifie les options en codant une série de macros assembleur. L’assemblage de ces macros génère un flot de travaux pour construire le système, y compris le langage de contrôle des travaux et les instructions de contrôle des utilitaires .

En effet, comme on s’en est rendu compte dans les années 1960, le concept de “macro-traitement” est indépendant du concept d'”assemblage”, le premier étant en termes modernes plus de traitement de texte, de traitement de texte, que de génération de code objet. Le concept de macro-traitement est apparu, et apparaît, dans le Langage de programmation C, qui prend en charge les “instructions de préprocesseur” pour définir des variables et effectuer des tests conditionnels sur leurs valeurs. Contrairement à certains processeurs de macros précédents à l’intérieur des assembleurs, le préprocesseur C n’est pas complet de Turing car il n’a pas la capacité de boucler ou “d’aller à”, ce dernier permettant aux programmes de boucler.

Malgré la puissance du traitement des macros, il est tombé en désuétude dans de nombreux langages de haut niveau (les principales exceptions étant C , C++ et PL/I) tout en restant un éternel pour les assembleurs.

La substitution de paramètre de macro est strictement nominative : au moment du traitement de la macro, la valeur d’un paramètre est textuellement substituée à son nom. La classe de bogues la plus célèbre qui en résultait était l’utilisation d’un paramètre qui était lui-même une expression et non un simple nom lorsque l’auteur de la macro attendait un nom. Dans la macro :

toto : macro a charger a*b

l’intention était que l’appelant fournisse le nom d’une variable, et la variable “globale” ou la constante b serait utilisée pour multiplier “a”. Si foo est appelé avec le paramètre a-c, le développement de la macro de load a-c*bse produit. Pour éviter toute ambiguïté possible, les utilisateurs de processeurs de macros peuvent mettre entre parenthèses les paramètres formels à l’intérieur des définitions de macros, ou les appelants peuvent mettre entre parenthèses les paramètres d’entrée. ^[26]

Prise en charge de la programmation structurée

Des packages de macros ont été écrits fournissant des éléments de programmation structurés pour coder le flux d’exécution. Le premier exemple de cette approche était dans l’ ensemble de macros Concept-14 , ^[27] proposé à l’origine par Harlan Mills (mars 1970) et mis en œuvre par Marvin Kessler à la division des systèmes fédéraux d’IBM, qui fournissait IF/ELSE/ENDIF et un flux de contrôle similaire. blocs pour les programmes assembleur OS/360. C’était un moyen de réduire ou d’éliminer l’utilisation des opérations GOTO dans le code assembleur, l’un des principaux facteurs à l’ origine du code spaghetti en langage assembleur. Cette approche a été largement acceptée au début des années 1980 (les derniers jours de l’utilisation à grande échelle du langage d’assemblage). Boîte à outils d’assemblage de haut niveau d’IBM^[28] inclut un tel package de macros.

Une conception curieuse était A-natural , un assembleur “orienté flux” pour 8080/ Z80 , des processeurs ^{[ citation nécessaire ]} de Whitesmiths Ltd. (développeurs du système d’exploitation Idris de type Unix , et ce qui a été signalé comme le premier C compilateur ). Le langage a été classé comme assembleur car il fonctionnait avec des éléments bruts de la machine tels que les opcodes , les registres , et références de mémoire ; mais il incorporait une syntaxe d’expression pour indiquer l’ordre d’exécution. Les parenthèses et autres symboles spéciaux, ainsi que les constructions de programmation structurées orientées blocs, contrôlaient la séquence des instructions générées. A-natural a été conçu comme le langage objet d’un compilateur C, plutôt que pour le codage manuel, mais sa syntaxe logique a séduit certains fans.

Il y a eu peu de demande apparente pour des assembleurs plus sophistiqués depuis le déclin du développement du langage d’assemblage à grande échelle. ^[29] Malgré cela, ils sont toujours développés et appliqués dans les cas où les contraintes de ressources ou les particularités de l’architecture du système cible empêchent l’utilisation efficace des langages de niveau supérieur. ^[30]

Les assembleurs avec un puissant moteur de macros permettent une programmation structurée via des macros, comme la macro switch fournie avec le package Masm32 (ce code est un programme complet) :

inclure masm32 inclure masm32rt.inc ; utiliser la bibliothèque Masm32 .code demomain: REPEAT 20 switch rv ( nrandom , 9 ) ; génère un nombre entre 0 et 8 mov ecx , 7 case 0 print “case 0” case ecx ; contrairement à la plupart des autres langages de programmation, imprime “case 7” ; le commutateur Masm32 autorise les “cas variables” case 1 .. 3 .if eax == 1 print “case 1” .elseif eax == 2 print “case 2” .else print “cases 1 to 3: other” .endif case 4 , 6 , 8 print “cases 4, 6 or 8” default mov ebx , 19 ; imprimez 20 étoiles .Répétez l’ impression “*” déc ebx .Jusqu’à la signature ? ; boucle jusqu’à ce que le drapeau de signe soit défini endsw print ch r$ ( 13 , 10 ) ENDM exit end demomain

Utilisation du langage assembleur

Perspective historique

Les langages d’assemblage n’étaient pas disponibles au moment de l’ introduction de l’ordinateur à programme enregistré . Kathleen Booth “est créditée d’avoir inventé le langage d’assemblage” ^{[31] [32]} sur la base d’un travail théorique qu’elle a commencé en 1947, alors qu’elle travaillait sur l’ ARC2 à Birkbeck, Université de Londres après consultation d’ Andrew Booth (plus tard son mari) avec le mathématicien John von Neumann et le physicien Herman Goldstine à l’ Institute for Advanced Study . ^{[32] [33]}

À la fin de 1948, le calculateur automatique de stockage de retard électronique (EDSAC) avait un assembleur (appelé «commandes initiales») intégré dans son programme d’ amorçage . Il utilisait des mnémoniques à une lettre développés par David Wheeler , qui est crédité par l’IEEE Computer Society comme le créateur du premier “assembleur”. ^{[16] [34] [35]} Les rapports sur l’EDSAC ont introduit le terme “assemblage” pour le processus de combinaison des champs dans un mot d’instruction. ^[36] SOAP ( Symbolic Optimal Assembly Program ) était un langage d’assemblage pour l’ ordinateur IBM 650 écrit par Stan Poley en 1955. ^[37]

Les langages d’assemblage éliminent une grande partie de la programmation de première génération sujette aux erreurs, fastidieuse et chronophage nécessaire avec les premiers ordinateurs, libérant les programmeurs de l’ennui comme la mémorisation des codes numériques et le calcul des adresses. Ils étaient autrefois largement utilisés pour toutes sortes de programmes. Cependant, à la fin des années 1950, ^{leur utilisation avait été}^{largement supplantée par des langages de niveau supérieur, dans la recherche} d’une productivité de programmation améliorée . Aujourd’hui, le langage d’assemblage est toujours utilisé pour la manipulation directe du matériel, l’accès à des instructions de processeur spécialisées ou pour résoudre des problèmes de performances critiques. ^[38] Les utilisations typiques sont les pilotes de périphériques , lesles systèmes embarqués , et les systèmes temps réel (voir § Usages actuels ).

Historiquement, de nombreux programmes ont été entièrement écrits en langage assembleur. Le Burroughs MCP (1961) a été le premier ordinateur pour lequel un système d’exploitation n’a pas été entièrement développé en langage d’assemblage ; il a été écrit en Executive Systems Problem Oriented Language (ESPOL), un dialecte Algol. De nombreuses applications commerciales ont également été écrites en langage d’assemblage, y compris une grande partie du logiciel mainframe IBM écrit par de grandes entreprises. COBOL , FORTRAN et certains PL/I ont finalement déplacé une grande partie de ce travail, bien qu’un certain nombre de grandes organisations aient conservé des infrastructures d’application en langage assembleur jusque dans les années 1990.

La plupart des premiers micro-ordinateurs reposaient sur un langage d’assemblage codé à la main, y compris la plupart des systèmes d’exploitation et des applications volumineuses. En effet, ces systèmes avaient des contraintes de ressources sévères, imposaient des architectures de mémoire et d’affichage idiosyncrasiques et fournissaient des services système limités et bogués. Le plus important était peut-être le manque de compilateurs de langage de haut niveau de première classe adaptés à une utilisation sur micro-ordinateur. Un facteur psychologique a peut-être également joué un rôle : la première génération de programmeurs de micro-ordinateurs a conservé une attitude d’amateur, de “fils et pinces”.

Dans un contexte plus commercial, les principales raisons d’utiliser le langage d’assemblage étaient un gonflement minimal (taille), une surcharge minimale, une plus grande vitesse et une fiabilité.

Des exemples typiques de grands programmes en langage d’assemblage de cette époque sont les systèmes d’exploitation IBM PC DOS , le compilateur Turbo Pascal et les premières applications telles que le tableur Lotus 1-2-3 . Le langage d’assemblage a été utilisé pour obtenir les meilleures performances de la Sega Saturn , une console pour laquelle il était notoirement difficile de développer et de programmer des jeux. ^[39] Le jeu d’arcade de 1993 NBA Jam est un autre exemple.

Le langage d’assemblage a longtemps été le principal langage de développement pour de nombreux ordinateurs domestiques populaires des années 1980 et 1990 (tels que le MSX , le Sinclair ZX Spectrum , le Commodore 64 , le Commodore Amiga et l’ Atari ST ). Cela était en grande partie dû au fait que les dialectes BASIC interprétés sur ces systèmes offraient une vitesse d’exécution insuffisante, ainsi que des installations insuffisantes pour tirer pleinement parti du matériel disponible sur ces systèmes. Certains systèmes ont même un environnement de développement intégré (IDE) avec des fonctionnalités de débogage et de macros très avancées. Quelques compilateurs disponibles pour le Radio Shack TRS-80et ses successeurs avaient la capacité de combiner la source d’assemblage en ligne avec des instructions de programme de haut niveau. Lors de la compilation, un assembleur intégré a produit du code machine en ligne.

Utilisation actuelle

Il y a toujours eu ^[40] des débats sur l’utilité et les performances du langage d’assemblage par rapport aux langages de haut niveau.

Bien que le langage d’assemblage ait des utilisations de niche spécifiques où il est important (voir ci-dessous), il existe d’autres outils d’optimisation. ^[41]

Depuis juillet 2017 ^{[mettre à jour]}, l’ indice TIOBE de popularité des langages de programmation classe le langage d’assemblage au 11e rang, devant Visual Basic , par exemple. ^[42] L’assembleur peut être utilisé pour optimiser la vitesse ou optimiser la taille. Dans le cas de l’optimisation de la vitesse, les compilateurs d’optimisation modernes sont censés ^rendre les langages de haut niveau en code qui peut s’exécuter aussi rapidement que l’assemblage écrit à la main, malgré les contre-exemples qui peuvent être trouvés. ^{[44] [45] [46]} La complexité des processeurs modernes et des sous-systèmes de mémoire rend l’optimisation efficace de plus en plus difficile pour les compilateurs, ainsi que pour les programmeurs d’assemblage. ^{[47] [48]}De plus, l’augmentation des performances du processeur signifie que la plupart des processeurs restent inactifs la plupart du temps, ^[49] avec des retards causés par des goulots d’étranglement prévisibles tels que les échecs de cache, les opérations d’ E/S et la pagination . Cela a fait de la vitesse d’exécution du code brut un problème pour de nombreux programmeurs.

Il existe certaines situations dans lesquelles les développeurs peuvent choisir d’utiliser le langage d’assemblage :

Écriture de code pour les systèmes avec des processeurs plus anciens ^{[ clarification nécessaire ]} qui ont des options de langage de haut niveau limitées telles que l’ Atari 2600 , le Commodore 64 et les calculatrices graphiques . ^[50] Les programmes pour ces ordinateurs des années 1970 et 1980 sont souvent écrits dans le contexte des sous-cultures demoscene ou retrogaming .
Code qui doit interagir directement avec le matériel, par exemple dans les pilotes de périphériques et les gestionnaires d’interruptions .
Dans un processeur embarqué ou un DSP, les interruptions à répétition élevée nécessitent le plus petit nombre de cycles par interruption, comme une interruption qui se produit 1000 ou 10000 fois par seconde.
Programmes qui doivent utiliser des instructions spécifiques au processeur non implémentées dans un compilateur. Un exemple courant est l’ instruction de rotation au niveau du bit au cœur de nombreux algorithmes de chiffrement, ainsi que l’interrogation de la parité d’un octet ou de la retenue 4 bits d’une addition.
Un exécutable autonome de taille compacte est requis qui doit s’exécuter sans recourir aux composants d’ exécution ou aux bibliothèques associées à un langage de haut niveau. Les exemples incluent des micrologiciels pour les téléphones, les systèmes de carburant et d’allumage automobiles, les systèmes de contrôle de la climatisation, les systèmes de sécurité et les capteurs.
Programmes avec des boucles internes sensibles aux performances, où le langage d’assemblage offre des opportunités d’optimisation difficiles à réaliser dans un langage de haut niveau. Par exemple, l’algèbre linéaire avec BLAS ^{[44] [51]} ou la transformation cosinus discrète (par exemple la version d’assemblage SIMD de x264 ^[52] ).
Programmes qui créent des fonctions vectorisées pour les programmes dans des langages de niveau supérieur tels que C. Dans le langage de niveau supérieur, cela est parfois facilité par des fonctions intrinsèques du compilateur qui correspondent directement aux mnémoniques SIMD, mais entraînent néanmoins une conversion d’assemblage un à un spécifique pour le processeur vectoriel donné.
Des programmes en temps réel tels que des simulations, des systèmes de navigation aérienne et des équipements médicaux. Par exemple, dans un système fly-by-wire , la télémétrie doit être interprétée et traitée dans des contraintes de temps strictes. De tels systèmes doivent éliminer les sources de retards imprévisibles, qui peuvent être créés par (certains) langages interprétés, le ramasse-miettes automatique , les opérations de pagination ou le multitâche préemptif . Cependant, certains langages de niveau supérieur intègrent des composants d’exécution et des interfaces de système d’exploitation qui peuvent introduire de tels retards. Le choix de langages d’assemblage ou de niveau inférieur pour de tels systèmes donne aux programmeurs une plus grande visibilité et un meilleur contrôle sur les détails de traitement.
Algorithmes cryptographiques qui doivent toujours prendre strictement le même temps pour s’exécuter, empêchant les attaques temporelles .
Modifiez et étendez le code hérité écrit pour les ordinateurs centraux IBM. ^{[53] [54]}
Des situations où un contrôle total de l’environnement est requis, dans des situations de très haute sécurité où rien n’est acquis .
Virus informatiques , chargeurs de démarrage , certains pilotes de périphériques ou autres éléments très proches du matériel ou du système d’exploitation de bas niveau.
Simulateurs de jeu d’instructions pour la surveillance, le traçage et le débogage où la surcharge supplémentaire est réduite au minimum.
Situations où aucun langage de haut niveau n’existe, sur un processeur nouveau ou spécialisé pour lequel aucun compilateur croisé n’est disponible.
Ingénierie inverse et modification de fichiers de programme tels que :
- les binaires existants qui peuvent ou non avoir été écrits à l’origine dans un langage de haut niveau, par exemple lorsque vous essayez de recréer des programmes pour lesquels le code source n’est pas disponible ou a été perdu, ou de casser la protection contre la copie d’un logiciel propriétaire.
- Jeux vidéo (également appelés piratage de ROM ), qui est possible via plusieurs méthodes. La méthode la plus largement utilisée consiste à modifier le code du programme au niveau du langage d’assemblage.

Le langage d’assemblage est encore enseigné dans la plupart des programmes d’informatique et d’ingénierie électronique . Bien que peu de programmeurs travaillent aujourd’hui régulièrement avec le langage assembleur comme outil, les concepts sous-jacents restent importants. Des sujets fondamentaux tels que l’arithmétique binaire , l’allocation de mémoire , le traitement de la pile , l’ encodage du jeu de caractères, le traitement des interruptions et le compilateurla conception serait difficile à étudier en détail sans comprendre comment un ordinateur fonctionne au niveau matériel. Étant donné que le comportement d’un ordinateur est fondamentalement défini par son jeu d’instructions, la manière logique d’apprendre de tels concepts est d’étudier un langage d’assemblage. La plupart des ordinateurs modernes ont des jeux d’instructions similaires. Par conséquent, l’étude d’un seul langage d’assemblage est suffisante pour apprendre : I) les concepts de base ; II) reconnaître les situations où l’utilisation du langage assembleur pourrait être appropriée ; et III) pour voir comment un code exécutable efficace peut être créé à partir de langages de haut niveau. ^[18]

Applications typiques

Le langage d’assemblage est généralement utilisé dans le code de démarrage d’un système, le code de bas niveau qui initialise et teste le matériel du système avant de démarrer le système d’exploitation et est souvent stocké dans la ROM . ( Le BIOS sur les systèmes PC compatibles IBM et CP/M est un exemple.)
Le langage d’assemblage est souvent utilisé pour le code de bas niveau, par exemple pour les noyaux de système d’exploitation , qui ne peuvent pas compter sur la disponibilité d’appels système préexistants et doivent en effet les implémenter pour l’architecture de processeur particulière sur laquelle le système sera exécuté.
Certains compilateurs traduisent d’abord les langages de haut niveau en assembleur avant de compiler entièrement, ce qui permet de visualiser le code d’assemblage à des fins de débogage et d’optimisation.
Certains compilateurs pour des langages de relativement bas niveau, tels que Pascal ou C , permettent au programmeur d’intégrer le langage d’assemblage directement dans le code source (appelé assemblage en ligne ). Les programmes utilisant de telles fonctionnalités peuvent alors construire des abstractions en utilisant un langage d’assemblage différent sur chaque plate-forme matérielle. Le code portable du système peut alors utiliser ces composants spécifiques au processeur via une interface uniforme.
Le langage d’assemblage est utile dans la rétro-ingénierie . De nombreux programmes sont distribués uniquement sous forme de code machine, ce qui est simple à traduire en langage assembleur par un désassembleur , mais plus difficile à traduire dans un langage de niveau supérieur via un décompilateur . Des outils tels que le désassembleur interactif utilisent largement le désassemblage à cette fin. Cette technique est utilisée par les pirates pour cracker des logiciels commerciaux, et les concurrents pour produire des logiciels avec des résultats similaires provenant d’entreprises concurrentes.
Le langage d’assemblage est utilisé pour améliorer la vitesse d’exécution, en particulier dans les premiers ordinateurs personnels avec une puissance de traitement et une RAM limitées.
Les assembleurs peuvent être utilisés pour générer des blocs de données, sans surcharge de langage de haut niveau, à partir de code source formaté et commenté, à utiliser par un autre code. ^{[55] [56]}

Voir également

Portail de programmation informatique

Compilateur
Comparaison des assembleurs
Désassembleur
Hexadécimal
Architecture d’ensemble d’instructions
Ordinateur petit homme – un modèle informatique éducatif avec un langage d’assemblage de base 10
Grignoter
Langage d’assemblage typé

Remarques

^ Autre que les méta-assembleurs
^ Cependant, cela ne signifie pas que les programmes assembleurs implémentant ces langages sont universels.
^ “Utilisé comme méta-assembleur, il permet à l’utilisateur de concevoir ses propres langages de programmation et de générer des processeurs pour ces langages avec un minimum d’effort.”
^ C’est l’une des deux formes redondantes de cette instruction qui fonctionnent de manière identique. Le 8086 et plusieurs autres processeurs de la fin des années 1970/début des années 1980 ont des redondances dans leurs jeux d’instructions, car il était plus simple pour les ingénieurs de concevoir ces processeurs (pour s’adapter à des puces en silicium de tailles limitées) avec les codes redondants que de les éliminer (voir termes indifférents ). Chaque assembleur générera généralement un seul des deux codages d’instructions redondants ou plus, mais un désassembleur reconnaîtra généralement l’un d’entre eux.
^ AMD a fabriqué des processeurs Intel 8086, 8088 et 80286 de deuxième source, et peut-être des processeurs 8080A et / ou 8085A, sous licence d’Intel, mais à partir du 80386, Intel a refusé de partager leurs conceptions de processeur x86 avec qui que ce soit – AMD a poursuivi à ce sujet pour rupture de contrat – et AMD a conçu, fabriqué et vendu des processeurs 32 bits et 64 bits de la famille x86 sans l’aide ou l’approbation d’Intel.
^ Dans 7070 Autocoder, une définition de macro est un programme générateur de macro 7070 que l’assembleur appelle ; Autocoder fournit des macros spéciales pour les générateurs de macros à utiliser.
^ “La restriction ou limitation mineure suivante est en vigueur en ce qui concerne l’utilisation de 1401 Autocoder lors du codage des instructions de macro …”

Références

^ ^un ^b “Langage d’assembleur” . Assembleur de haut niveau pour z/OS & z/VM & z/VSE Language Reference Version 1 Release 6 . IBM . 2014 [1990]. SC26-4940-06.
^ Saxon, James A.; En lignePlette, William S. (1962). Programmation de l’IBM 1401, un manuel programmé d’auto-instruction . Falaises d’Englewood, New Jersey, États-Unis : Prentice-Hall . RCAC 62-20615 . (NB. Utilisation du terme programme d’assemblage .)
^ Kornelis, AF (2010) [2003]. “Assembleur de haut niveau – Vue d’ensemble des opcodes, directives de l’assembleur” . Archivé de l’original le 2020-03-24 . Récupéré le 24/03/2020 .
^ “Instructions macro” . Assembleur de haut niveau pour z/OS & z/VM & z/VSE Language Reference Version 1 Release 6 . IBM . 2014 [1990]. SC26-4940-06.
^ Wilkes, Maurice Vincent ; Wheeler, David John ; Gill, Stanley J. (1951). La préparation de programmes pour un ordinateur numérique électronique (réimpression 1982 éd.). Éditeurs Tomash . ISBN 978-0-93822803-5. OCLC 313593586 .
^ Fairhead, Harry (2017-11-16). “Histoire des langages informatiques – La décennie classique, années 1950” . Je Programmeur . Archivé de l’original le 2020-01-02 . Récupéré le 06/03/2020 .
^ “Assemblée: Révision” (PDF) . Informatique et Ingénierie. Collège d’ingénierie, Université d’État de l’Ohio . 2016. Archivé (PDF) de l’original le 2020-03-24 . Récupéré le 24/03/2020 .
^ Archer, Benjamin (novembre 2016). Langage d’assemblage pour les étudiants . North Charleston, Caroline du Sud, États-Unis : CreateSpace Independent Publishing . ISBN 978-1-5403-7071-6. Le langage d’assemblage peut également être appelé code machine symbolique.
^ “Comment les langages d’assemblage dépendent-ils des systèmes d’exploitation ?” . Échange de pile . Stack Exchange Inc. 2011-07-28. Archivé de l’original le 2020-03-24 . Récupéré le 24/03/2020 . (NB. Les appels système varient souvent, par exemple pour MVS vs VSE vs VM/CMS ; les formats binaires/exécutables pour différents systèmes d’exploitation peuvent également varier.)
^ Brooks, Frederick P. (1986). “Pas de Silver Bullet—Essence et Accident dans le Génie Logiciel”. Actes de la dixième conférence mondiale sur l’informatique de l’IFIP : 1069–1076.
^ Anguiano, Ricardo. “ligne principale du noyau Linux 4.9 sloccount.txt” . L’essentiel . Récupéré le 04/05/2022 .
^ Daintith, John, éd. (2019). “méta-assembleur” . Dictionnaire de l’informatique . Archivé de l’original le 2020-03-24 . Récupéré le 24/03/2020 .
^ Systèmes de données Xerox (octobre 1975). Manuel de référence du langage et des opérations des ordinateurs Xerox Meta-Symbol Sigma 5-9 (PDF) . p. vi . Récupéré le 07/06/2020 .
^ Systèmes informatiques Sperry Univac (1977). Sperry Univac Computer Systems Meta-Assembler (MASM) Programmer Reference (PDF) . Récupéré le 07/06/2020 .
^ “Comment utiliser le langage d’assemblage en ligne dans le code C” . gnu.org . Récupéré le 05/11/2020 .
^ ^un ^bcd ^{Salomon ,} ^David (février 1993) [1992]. Écrit à la California State University, Northridge, Californie, États-Unis. Chivers, Ian D. (éd.). Assembleurs et chargeurs (PDF) . Série Ellis Horwood sur les ordinateurs et leurs applications (1 éd.). Chicester, West Sussex, Royaume-Uni : Ellis Horwood Limited / Simon & Schuster International Group . p. 7, 237–238. ISBN 0-13-052564-2. Archivé (PDF) de l’original le 2020-03-23 . Récupéré le 01/10/2008 .(xiv+294+4 pages)
^ Beck, Leland L. (1996). “2”. Logiciel système : une introduction à la programmation système . Addison Wesley .
^ ^un ^b Hyde, Randall (le septembre de 2003) [1996-09-30]. “Avant-propos (“Pourquoi quelqu’un apprendrait-il ce genre de choses?”) / Chapitre 12 – Classes et objets”. L’art du langage d’assemblage (2 éd.). Aucune presse d’amidon . ISBN 1-886411-97-2. Archivé de l’original le 2010-05-06 . Récupéré le 22/06/2020 .Errata : [1] (928 pages) [2] [3]
^ ^un ^bcd ^{Manuel du développeur de logiciels} ^d’ architecture Intel, Volume 2: Référence du jeu d’instructions (PDF) . Vol. 2. Intel Corporation . 1999. Archivé de l’original (PDF) le 11/06/2009 . Récupéré le 18/11/2010 .
^ Ferrari, Adam; Batson, Alan; Manque, Mike ; Jones, Anita (2018-11-19) [printemps 2006]. Evans, David (éd.). “Guide d’assemblage x86” . Informatique CS216 : Représentation de programmes et de données. Université de Virginie . Archivé de l’original le 2020-03-24 . Récupéré le 18/11/2010 .
^ “Le manuel d’architecture SPARC, version 8” (PDF) . SPARC International . 1992. Archivé de l’original (PDF) le 2011-12-10 . Récupéré le 10/12/2011 .
^ Moxham, James (1996). “Interprète ZINT Z80” . Codes d’opération Z80 pour ZINT . Archivé de l’original le 2020-03-24 . Récupéré le 21/07/2013 .
^ Hyde, Randall . “Chapitre 8. MASM : directives et pseudo-opcodes” (PDF) . L’art de la programmation informatique . Archivé (PDF) de l’original le 2020-03-24 . Récupéré le 19/03/2011 .
^ Utilisateurs de 1401 Autocoder . Archivé de l’original le 2020-03-24 . Récupéré le 24/03/2020 .
^ Griswold, Ralph E. (1972). “Chapitre 1”. La macro implémentation de SNOBOL4 . San Francisco, Californie, États-Unis : WH Freeman and Company . ISBN 0-7167-0447-1.
^ “Macros (C/C++), Bibliothèque MSDN pour Visual Studio 2008” . Microsoft Corp. 2012-11-16. Archivé de l’original le 2020-03-24 . Récupéré le 22/06/2010 .
^ Kessler, Marvin M. (1970-12-18). “*Concept* Report 14 – Implémentation de macros pour permettre la programmation structurée dans OS / 360” . Logiciel MVS : Concept 14 Macros . Gaithersburg, Maryland, États-Unis : International Business Machines Corporation . Archivé de l’original le 2020-03-24 . Récupéré le 25/05/2009 .
^ “La fonctionnalité de la boîte à outils de l’assembleur de haut niveau augmente la productivité du programmeur” . IBM. 1995-12-12. Numéro de la lettre d’annonce : A95-1432.
^ “langage d’assemblage : définition et bien plus encore sur Answers.com” . réponses.com . Archivé de l’original le 2009-06-08 . Récupéré le 19/06/2008 .
^ Provinciano, Brian (2005-04-17). “NESHLA: L’assembleur de haut niveau, Open Source, 6502 pour le système de divertissement Nintendo” . Archivé de l’original le 2020-03-24 . Récupéré le 24/03/2020 .
^ Dufresne, Steven (2018-08-21). “Kathleen Booth : assembler les premiers ordinateurs tout en inventant l’assemblage” . Archivé de l’original le 2020-03-24 . Récupéré le 10/02/2019 .
^ ^un stand ^b , Andrew Donald ; Britten, Kathleen Hylda Valerie (septembre 1947) [août 1947]. Considérations générales dans la conception d’un ordinateur numérique électronique tout usage (PDF) (2 éd.). L’Institute for Advanced Study, Princeton, New Jersey, États-Unis : Birkbeck College, Londres . Archivé (PDF) de l’original le 2020-03-24 . Récupéré le 10/02/2019 . Les idées non originales, contenues dans le texte suivant, ont été dérivées d’un certain nombre de sources, … Il est cependant estimé que la reconnaissance doit être faite au professeur John von Neumann et au Dr Herman Goldstein pour de nombreuses fructueuses discussions…
^ Campbell-Kelly, Martin (avril 1982). “Le développement de la programmation informatique en Grande-Bretagne (1945 à 1955)”. Annales IEEE de l’histoire de l’informatique . 4 (2): 121–139. doi : 10.1109/MAHC.1982.10016 . S2CID 14861159 .
^ Campbell-Kelly, Martin (1980). “Programmation de l’EDSAC”. Annales IEEE de l’histoire de l’informatique . 2 (1): 7–36. doi : 10.1109/MAHC.1980.10009 .
^ “1985 Computer Pioneer Award ‘Pour la programmation en langage d’assemblage’ David Wheeler” .
^ Wilkes, Maurice Vincent (1949). “L’EDSAC – une machine à calculer électronique”. Journal des instruments scientifiques . 26 (12): 385–391. Bibcode : 1949JScI…26..385W . doi : 10.1088/0950-7671/26/12/301 .
^ da Cruz, Frank (2019-05-17). “Le calculateur de tambour magnétique IBM 650” . Histoire de l’informatique – Une chronologie de l’informatique. Université de Colombie . Archivé de l’original le 2020-02-15 . Récupéré le 17/01/2012 .
^ Collen, Morris F. (mars-avril 1994). “Les origines de l’informatique” . Journal de l’Association américaine d’informatique médicale . 1 (2): 96–97. doi : 10.1136/jamia.1994.95236152 . PMC 116189 . PMID 7719803 .
^ Pettus, Sam (2008-01-10). “SegaBase Volume 6 – Saturne” . Archivé de l’original le 13/07/2008 . Récupéré le 25/07/2008 .
^ Kauler, Barry (1997-01-09). Langage d’assemblage Windows et programmation système : programmation de bas niveau 16 et 32 bits pour PC et Windows . CRC Appuyez sur . ISBN 978-1-48227572-8. Récupéré le 24/03/2020 . Toujours le débat fait rage sur l’applicabilité du langage d’assemblage dans notre monde de programmation moderne.
^ Hsieh, Paul (2020-03-24) [2016, 1996]. « Optimisation de la programmation » . Archivé de l’original le 2020-03-24 . Récupéré le 24/03/2020 . … les modifications de conception ont tendance à affecter les performances plus que … il ne faut pas passer directement au langage d’assemblage jusqu’à ce que …
^ “Index TIOBE” . Logiciel TIOBE . Archivé de l’original le 2020-03-24 . Récupéré le 24/03/2020 .
^ Rusling, David A. (1999) [1996]. “Chapitre 2 Bases du logiciel” . Le noyau Linux . Archivé de l’original le 2020-03-24 . Récupéré le 11/03/2012 .
^ ^un ^b Markoff, John Gregory (2005-11-28). “Écrire le code le plus rapide, à la main, pour le plaisir : un ordinateur humain continue d’accélérer les puces” . Le New York Times . Seattle, Washington, États-Unis. Archivé de l’original le 2020-03-23 . Récupéré le 04/03/2010 .
^ “Bit-champ-méchanceté” . hardwarebug.org . 2010-01-30. Archivé de l’original le 2010-02-05 . Récupéré le 04/03/2010 .
^ “GCC fait un gâchis” . hardwarebug.org . 2009-05-13. Archivé de l’original le 16/03/2010 . Récupéré le 04/03/2010 .
^ Hyde, Randall . “Le Grand Débat” . Archivé de l’original le 16/06/2008 . Récupéré le 03/07/2008 .
^ “Le code source échoue à nouveau” . hardwarebug.org . 2010-01-30. Archivé de l’original le 2010-04-02 . Récupéré le 04/03/2010 .
^ Cliquez, Cliff; Goetz, Brian. “Un cours intensif sur le matériel moderne” . Archivé de l’original le 2020-03-24 . Récupéré le 01/05/2014 .
^ “Programmation 68K dans Fargo II” . Archivé de l’original le 2008-07-02 . Récupéré le 03/07/2008 .
^ “BLAS Benchmark-Août 2008” . eigen.tuxfamily.org. 2008-08-01. Archivé de l’original le 2020-03-24 . Récupéré le 04/03/2010 .
^ “x264.git/common/x86/dct-32.asm” . git.videolan.org. 2010-09-29. Archivé de l’original le 2012-03-04 . Récupéré le 29/09/2010 .
^ Bosworth, Edouard (2016). “Chapitre 1 – Pourquoi étudier le langage d’assemblage” . www.edwardbosworth.com . Archivé de l’original le 2020-03-24 . Récupéré le 01/06/2016 .
^ “Instructions de macro DFSMS de la version 2 de la version 3 de z / OS pour les ensembles de données” (PDF) . IBM. 2019-02-15. Archivé (PDF) de l’original le 2021-06-25 . Récupéré le 14/09/2021 .
^ Paul, Matthias R. (2001) [1996], “Spécification et documentation de référence pour NECPINW” , NECPINW.CPI – Pilote de commutation de page de code DOS pour NEC Pinwriters (2.08 éd.), FILESPEC.TXT, NECPINW.ASM, EUROFONT. INC de NECPI208.ZIP, archivé de l’original le 10/09/2017 , récupéré le 22/04/2013
^ Paul, Matthias R. (2002-05-13). “[fd-dev] mkeyb” . freedos-dev . Archivé de l’original le 2018-09-10 . Récupéré le 10/09/2018 .

Lectures complémentaires

Bartlett, Jonathan (2004). Programmation à partir de zéro – Une introduction à la programmation à l’aide du langage d’assemblage Linux . Éditions Bartlett . ISBN 0-9752838-4-7. Archivé de l’original le 2020-03-24 . Récupéré le 24/03/2020 . [4]
Britton, Robert (2003). Programmation en langage d’assemblage MIPS . Salle des apprentis . ISBN 0-13-142044-5.
Calingaert, Peter (1979) [1978-11-05]. Écrit à l’Université de Caroline du Nord à Chapel Hill . Horowitz, Ellis (éd.). Assembleurs, compilateurs et traduction de programmes . Série de génie logiciel informatique (1ère impression, 1ère éd.). Potomac, Maryland, États-Unis: Computer Science Press, Inc. ISBN 0-914894-23-4. ISSN 0888-2088 . RCAC 78-21905 . Récupéré le 20/03/2020 .(2+xiv+270+6 pages)
Duntemann, Jeff (2000). Langage d’assemblage pas à pas . Wiley . ISBN 0-471-37523-3.
En ligneKann, Charles W. (2015). “Introduction à la programmation en langage d’assemblage MIPS” . Archivé de l’original le 2020-03-24 . Récupéré le 24/03/2020 .
Kann, Charles W. (2021). ” Introduction à la programmation en langage d’assemblage : de la soupe aux noix : édition ARM “
Norton, Peter ; Socha, John (1986). Livre de langage d’assemblage de Peter Norton pour IBM PC . New York, États-Unis : Brady Books.
Chanteur, Michael (1980). PDP-11. Programmation en langage assembleur et organisation de la machine . New York, États-Unis : John Wiley & Sons .
Sweetman, Dominique (1999). Voir Exécution MIPS . Éditions Morgan Kaufmann . ISBN 1-55860-410-3.
Waldron, John (1998). Introduction à la programmation en langage d’assemblage RISC . Addison Wesley . ISBN 0-201-39828-1.
Yurichev, Dennis (2020-03-04) [2013]. “Comprendre le langage d’assemblage (ingénierie inverse pour les débutants)” (PDF) . Archivé (PDF) de l’original le 2020-03-24 . Récupéré le 24/03/2020 .
“Livre communautaire ASM” . 2009. Archivé de l’original le 2013-05-30 . Récupéré le 30/05/2013 .(“Un livre en ligne plein d’informations ASM utiles, de tutoriels et d’exemples de code” par la communauté ASM, archivé dans les archives Internet.)