La programmation au niveau des instructions machine est le niveau minimum auquel la programmation est possible. Le système d'instructions machine doit être suffisant pour effectuer les actions requises en envoyant des instructions au matériel de l'ordinateur.

Chaque instruction machine se compose de deux parties :

• salle d'opération - déterminer « que faire » ;
• opérande - définition des objets de traitement, "que faire avec".

Une instruction machine à microprocesseur écrite en langage assembleur est une seule ligne avec la forme syntaxique suivante :

étiquette de commande / directive opérande(s) ; commentaires

Dans ce cas, le champ obligatoire de la ligne est une commande ou une directive.

L'étiquette, la commande/la directive et les opérandes (le cas échéant) sont séparés par au moins un espace ou un caractère de tabulation.

Si une commande ou une directive doit être poursuivie sur la ligne suivante, la barre oblique inverse est utilisée : \.

Par défaut, le langage assembleur ne fait pas la distinction entre les lettres majuscules et minuscules lors de l'écriture de commandes ou de directives.

Exemples de lignes de code :

Compter db 1 ; Nom, directive, un opérande
mov eax, 0 ; Commande, deux opérandes
cbw; Commander

Mots clés

Étiqueter en assembleur peut contenir les caractères suivants :

• toutes les lettres de l'alphabet latin ;
• nombres de 0 à 9 ;
• caractères spéciaux : _, @, $, ?.

Un point peut être utilisé comme premier caractère d'une étiquette, mais certains compilateurs ne recommandent pas ce caractère. Les noms d'assembleur réservés (directives, opérateurs, noms de commandes) ne peuvent pas être utilisés comme étiquettes.

Le premier caractère de l'étiquette doit être une lettre ou un caractère spécial (mais pas un chiffre). La longueur maximale de l'étiquette est de 31 caractères. Toutes les étiquettes écrites dans une ligne qui ne contient pas de directive assembleur doivent se terminer par deux points :.

Commandes

Commander indique au traducteur quelle action le microprocesseur doit entreprendre. Dans un segment de données, une commande (ou directive) définit un champ, une zone de travail ou une constante. Dans le segment de code, l'instruction définit l'action, comme le transfert (mov) ou l'ajout (add).

Directives

L'assembleur dispose d'un certain nombre d'opérateurs qui vous permettent de contrôler le processus d'assemblage et de génération d'une liste. Ces opérateurs sont appelés directives ... Ils n'agissent que dans le processus d'assemblage du programme et, contrairement aux instructions, ne génèrent pas de codes machine.

Opérandes

Opérande - un objet sur lequel s'exécute une instruction machine ou un opérateur d'un langage de programmation.
Une instruction peut avoir un ou deux opérandes, voire aucun opérande. Le nombre d'opérandes est implicitement spécifié par le code de commande.
Exemples:

• Pas d'opérandes ret ; Retour
• Un opérande inc ecx ; Augmenter ecx
• Deux opérandes ajoutent eax, 12 ; Ajouter 12 à eax

L'étiquette, la commande (directive) et l'opérande ne doivent pas nécessairement commencer à une position particulière dans la chaîne. Cependant, il est recommandé de les écrire dans une colonne pour une meilleure lisibilité du programme.

Les opérandes peuvent être

• identifiants;
• chaînes de caractères entre guillemets simples ou doubles ;
• entiers en notation binaire, octale, décimale ou hexadécimale.

Identifiants

Identifiants - séquences de caractères valides utilisées pour désigner les objets du programme tels que les opcodes, les noms de variables et les noms d'étiquettes.

Règles d'écriture des identifiants.

• L'identifiant peut être un ou plusieurs caractères.
• Les lettres de l'alphabet latin, les chiffres et certains caractères spéciaux peuvent être utilisés comme symboles : _,?, $, @.
• L'identifiant ne peut pas commencer par un caractère numérique.
• L'identifiant peut comporter jusqu'à 255 caractères.
• Le traducteur accepte les 32 premiers caractères de l'identifiant et ignore le reste.

Commentaires (1)

Les commentaires sont séparés de la ligne de l'exécutable par un ; ... Dans ce cas, tout ce qui est écrit après le point-virgule et jusqu'à la fin de la ligne est un commentaire. L'utilisation de commentaires dans le programme améliore sa clarté, en particulier lorsque le but du jeu d'instructions n'est pas clair. Le commentaire peut contenir n'importe quel caractère imprimable, y compris l'espace. Un commentaire peut s'étendre sur toute la ligne ou suivre une commande sur la même ligne.

Structure du programme d'assemblage

Un programme écrit en langage assembleur peut être composé de plusieurs parties, appelées modules ... Chaque module peut avoir un ou plusieurs segments de données, de pile et de code définis. Tout programme assembleur complet doit inclure un module principal, ou principal, à partir duquel commencer son exécution. Un module peut contenir des segments de code, des segments de données et des segments de pile, déclarés à l'aide des directives appropriées. Avant de déclarer des segments, vous devez spécifier le modèle de mémoire à l'aide de la directive .MODEL.

Un exemple de programme assembleur « ne rien faire » :

686P
.MODELE PLAT, STDCALL
.LES DONNÉES
.CODE
DÉBUT:

RET
FIN DEBUT

Ce programme ne contient qu'une seule commande du microprocesseur. Cette commande est RET. Il garantit la bonne fin du programme. En général, cette commande permet de sortir d'une procédure.
Le reste du programme est lié au travail du traducteur.
.686P - Les commandes en mode protégé Pentium 6 (Pentium II) sont autorisées. Cette directive sélectionne le jeu d'instructions assembleur pris en charge en spécifiant le modèle de processeur. La lettre P à la fin de la directive informe le traducteur que le processeur fonctionne en mode protégé.
.MODEL FLAT, stdcall est un modèle à mémoire plate. Ce modèle de mémoire est utilisé dans le système d'exploitation Windows. appel std
.DATA - segment de programme contenant des données.
.CODE - bloc du programme contenant le code.
START est une étiquette. En assembleur, les étiquettes jouent un grand rôle, ce qui n'est pas le cas dans les langages modernes de haut niveau.
END START - la fin du programme et un message au traducteur indiquant qu'il est nécessaire de démarrer l'exécution du programme à partir de l'étiquette START.
Chaque module doit contenir une directive END pour marquer la fin code source programmes. Toutes les lignes qui suivent la directive END sont ignorées. Si vous omettez la directive END, une erreur est générée.
L'étiquette spécifiée après la directive END indique au traducteur le nom du module principal à partir duquel l'exécution du programme démarre. Si le programme contient un module, l'étiquette après la directive END peut être omise.

Sujet 1.4 Mnémoniques de l'assembleur. Structure et formats des commandes. Types d'adressage. Jeu de commandes du microprocesseur

Plan:

1 Langage assembleur. Concepts de base

2 Symboles du langage assembleur

3 types d'instructions assembleur

4 Directives de montage

5 Jeu d'instructions du processeur

1 jelangage d'assemblage. Concepts de base

Langage d'assemblageest une représentation symbolique du langage machine. Tous les processus de la machine au niveau matériel le plus bas ne sont pilotés que par des commandes de langage machine (instructions). Par conséquent, il est clair que, malgré le nom général, le langage d'assemblage pour chaque type d'ordinateur est différent.

Un programme en assembleur est un ensemble de blocs de mémoire appelés segments de mémoire. Un programme peut consister en un ou plusieurs de ces blocs-segments. Chaque segment contient un ensemble de phrases de langage, dont chacune occupe une ligne distincte de code de programme.

Les phrases d'assemblage sont de quatre types :

1) commandes ou instructions, qui sont des analogues symboliques des instructions machine. Dans le processus de traduction, les instructions assembleur sont converties en les commandes correspondantes du jeu d'instructions du microprocesseur ;

2) macros -les phrases du texte du programme, formées d'une certaine manière, sont remplacées par d'autres phrases lors de la diffusion ;

3) directives,qui sont des instructions au traducteur assembleur pour effectuer certaines actions. Les directives n'ont pas d'analogue dans la représentation machine ;

4) lignes de commentaires contenant des symboles, y compris les lettres de l'alphabet russe. Les commentaires sont ignorés par le traducteur.

­ La structure d'un programme assembleur. Syntaxe d'assemblage.

Les phrases qui composent le programme peuvent être une construction syntaxique correspondant à une commande, une macro, une directive ou un commentaire. Pour que le traducteur assembleur les reconnaisse, ils doivent être formés selon certaines règles syntaxiques. La meilleure façon de le faire est d'utiliser une description formelle de la syntaxe du langage comme des règles de grammaire. Les manières les plus courantes de décrire un langage de programmation comme celui-ci - diagrammes de syntaxe et formes Backus-Naur étendues. Plus pratique pour une utilisation pratique diagrammes de syntaxe. Par exemple, la syntaxe des phrases en assembleur peut être décrite à l'aide des diagrammes de syntaxe illustrés dans les figures 10, 11, 12.

Figure 10 - Format de phrase d'assemblage

­ Figure 11 - Format des directives

­ Figure 12 - Format des commandes et des macros

Dans ces chiffres :

­ nom de l'étiquette- un identifiant dont la valeur est l'adresse du premier octet de la phrase du texte source du programme, qu'il désigne ;

­ Nom -identifiant qui distingue cette directive des autres directives du même nom. A la suite du traitement d'une directive spécifique par l'assembleur, certaines caractéristiques peuvent être affectées à ce nom ;

­ code opération (COP) et directive - ce sont des désignations mnémoniques de l'instruction machine, de la macro ou de la directive de traduction correspondantes ;

­ opérandes -parties d'une commande, d'une macro ou d'une directive d'assembleur qui désignent les objets à manipuler. Les opérandes assembleur sont décrits par des expressions avec des constantes numériques et textuelles, des étiquettes et des identificateurs de variables utilisant des signes d'opération et quelques mots réservés.

Aide des diagrammes de syntaxe trouver puis passer de l'entrée du schéma (à gauche) à sa sortie (à droite). Si un tel chemin existe, alors la phrase ou la construction est syntaxiquement correcte. S'il n'y a pas un tel chemin, alors le compilateur n'acceptera pas cette construction.

­ 2 Symboles du langage assembleur

Les caractères autorisés lors de l'écriture du texte du programme sont :

1) toutes les lettres latines : A-Z,a-z... Dans ce cas, les lettres majuscules et minuscules sont considérées comme équivalentes ;

2) nombres de 0 avant 9 ;

3) signes ? , @ , $ , _ , & ;

4) séparateurs , . () < > { } + / * % ! " " ? = # ^ .

Les phrases en assembleur sont formées à partir de jetons, qui sont des séquences syntaxiquement inséparables de caractères valides de la langue qui ont un sens pour le traducteur.

Lexèmes sommes:

1) identifiants - séquences de caractères valides utilisées pour désigner les objets du programme tels que les opcodes, les noms de variables et les noms d'étiquettes. La règle d'écriture des identifiants est la suivante : un identifiant peut être constitué d'un ou plusieurs caractères ;

2) chaînes de caractères - séquences de caractères entre guillemets simples ou doubles ;

3) nombres entiers de l'un des systèmes de nombres suivants : binaire, décimal, hexadécimal. L'identification des nombres lors de leur écriture dans des programmes en langage assembleur s'effectue selon certaines règles :

4) les nombres décimaux ne nécessitent aucun symbole supplémentaire pour leur identification, par exemple 25 ou 139. Pour l'identification dans le code source du programme nombres binaires après avoir écrit les zéros et les uns inclus dans leur composition, il faut mettre le latin " b”, Par exemple 10010101 b.

5) les nombres hexadécimaux ont plus de conventions lorsqu'ils s'écrivent :

Premièrement, ils sont constitués de nombres 0...9 , lettres minuscules et majuscules de l'alphabet latin une,b, c,ré,e,F ou UNE,B,C,ré,E,F.

Deuxièmement, le traducteur peut avoir des difficultés à reconnaître les nombres hexadécimaux du fait qu'ils peuvent être constitués soit uniquement de chiffres 0 ... 9 (par exemple, 190845), soit commencer par une lettre de l'alphabet latin (par exemple, ef15). Afin d'"expliquer" au traducteur qu'un jeton donné n'est pas un nombre décimal ou un identifiant, le programmeur doit sélectionner un nombre hexadécimal d'une manière spéciale. Pour ce faire, à la fin de la séquence de chiffres hexadécimaux qui composent un nombre hexadécimal, écrivez la lettre latine " h”. ce condition requise... Si un nombre hexadécimal commence par une lettre, alors un zéro non significatif est écrit devant : 0 ef15 h.

Presque chaque phrase contient une description de l'objet sur lequel ou à l'aide duquel une action est effectuée. Ces objets sont appelés opérandes... Ils peuvent être définis comme ceci : opérandes sont des objets (certaines valeurs, registres ou cellules de mémoire) sur lesquels agissent des instructions ou des directives, ou ce sont des objets qui définissent ou spécifient l'action d'instructions ou de directives.

Il est possible d'effectuer la classification suivante des opérandes :

­ opérandes constants ou immédiats;

­ opérandes d'adresse;

­ opérandes mobiles;

compteur d'adresses;

­ enregistrer l'opérande ;

­ opérandes de base et d'index ;

­ opérandes structurels;

enregistrements.

Les opérandes sont des composants élémentaires à partir desquels est formée une partie d'une instruction machine, désignant les objets sur lesquels une opération est effectuée. Dans un cas plus général, les opérandes peuvent être inclus en tant que composants dans des formations plus complexes, appelées expressions.

Expressions sont des combinaisons d'opérandes et d'opérateurs, traités comme un tout. Le résultat de l'évaluation d'une expression peut être une adresse d'une cellule de mémoire ou une valeur constante (absolue).

­ 3 types d'instructions assembleur

Listons les types possibles opérateurs assembleurs et des règles syntaxiques pour la formation des expressions assembleur :

­ opérateurs arithmétiques;

­ opérateurs postés;

­ opérateurs de comparaison ;

­ Opérateurs logiques;

­ opérateur d'indexation ;

­ opérateur de remplacement de type ;

­ opérateur de redéfinition de segment ;

­ opérateur de nommage du type de structure ;

­ opérateur pour obtenir le composant de segment de l'adresse d'expression ;

­ opérateur pour obtenir le décalage d'une expression.

1 Directives assembleur

­ Les directives de l'assembleur sont :

1) Directives de segmentation. Au cours de la discussion précédente, nous avons découvert toutes les règles de base pour écrire des commandes et des opérandes dans un programme assembleur. La question de savoir comment formuler correctement la séquence de commandes pour que le traducteur puisse les traiter et que le microprocesseur puisse les exécuter reste ouverte.

En considérant l'architecture du microprocesseur, nous avons appris qu'il dispose de six registres de segments, à travers lesquels il peut fonctionner simultanément :

­ avec un segment de code ;

­ avec un segment de pile ;

­ avec un segment de données ;

­ avec trois segments de données supplémentaires.

Physiquement, un segment est une zone mémoire occupée par des instructions et (ou) des données dont les adresses sont calculées par rapport à la valeur dans le registre de segment correspondant. La description syntaxique d'un segment en assemblage est la construction illustrée à la figure 13 :

­ Figure 13 - Description syntaxique d'un segment en assembleur

Il est important de noter que la fonctionnalité d'un segment est un peu plus large que la simple division d'un programme en blocs de code, de données et de pile. La segmentation fait partie de plus mécanisme commun associé à le concept de programmation modulaire. Il suppose l'unification de la conception des modules objets créés par le compilateur, y compris ceux issus des différents langages de programmation. Cela vous permet de combiner des programmes écrits dans différentes langues. Les opérandes de la directive SEGMENT sont destinés à implémenter diverses variantes d'une telle union.

2) Répertorier les directives de gestion. Les directives de contrôle de liste sont réparties dans les groupes suivants :

­ directives générales de contrôle des inscriptions;

­ directives pour la sortie vers la liste des fichiers inclus ;

­ directives pour la sortie des blocs d'assemblage conditionnels ;

­ directives pour lister les macros ;

­ des directives pour la sortie d'informations sur les références croisées à la liste ;

­ directives pour changer le format de la liste.

2 Jeu d'instructions du processeur

Le jeu d'instructions du processeur est illustré à la figure 14.

Considérons les principaux groupes de commandes.

­ Figure 14 - Classification des instructions assembleur

Les équipes sont :

1 Commandes de transfert de données. Ces commandes occupent une place très importante dans le jeu d'instructions de tout processeur. Ils remplissent les fonctions essentielles suivantes :

­ mémoriser le contenu des registres internes du processeur ;

­ copier du contenu d'une zone de mémoire à une autre ;

­ l'écriture sur les périphériques d'E/S et la lecture depuis les périphériques d'E/S.

Sur certains processeurs, toutes ces fonctions sont exécutées par une seule commande. mov (pour les transferts d'octets - MOVB ) mais avec différentes méthodes d'adressage des opérandes.

Sur d'autres processeurs en plus de la commande mov il existe plusieurs autres commandes pour exécuter les fonctions répertoriées. De plus, les commandes de transfert de données incluent les commandes d'échange d'informations (leur désignation est basée sur le motÉchanger ). L'échange d'informations entre registres internes, entre deux moitiés d'un registre (ÉCHANGER ) ou entre un registre et un emplacement mémoire.

2 Commandes arithmétiques... Les instructions arithmétiques traitent les codes d'opérandes comme des codes numériques binaires ou binaires décimaux. Ces commandes peuvent être divisées en cinq groupes principaux :

­ commandes d'opérations à virgule fixe (addition, soustraction, multiplication, division);

­ commandes à virgule flottante (addition, soustraction, multiplication, division);

­ commandes de nettoyage ;

­ commandes d'incrémentation et de décrémentation ;

­ commande de comparaison.

3 Les commandes pour les opérations à virgule fixe opèrent sur des codes dans les registres du processeur ou en mémoire comme des codes binaires normaux. Les instructions à virgule flottante (point) utilisent le format de représentation des nombres avec ordre et mantisse (généralement ces nombres occupent deux emplacements de mémoire consécutifs). En moderne processeurs puissants le jeu d'instructions en virgule flottante n'est pas limité à quatre opérations arithmétiques seulement, mais contient de nombreuses autres commandes plus complexes, par exemple, le calcul de fonctions trigonométriques, de fonctions logarithmiques, ainsi que de fonctions complexes nécessaires au traitement du son et des images.

4 Les instructions d'effacement sont conçues pour écrire un code zéro dans un registre ou une cellule de mémoire. Ces commandes peuvent être remplacées par des commandes de transfert zéro, mais équipes spéciales les nettoyages sont généralement plus rapides que les commandes de transfert.

5 commandes pour incrémenter (augmenter de un) et décrémenter

(décréments de un) sont également très pratiques. Ils peuvent en principe être remplacés par l'addition avec une ou la soustraction d'une commande, mais l'incrémentation et la décrémentation sont plus rapides que l'addition et la soustraction. Ces instructions nécessitent un opérande d'entrée, qui est également un opérande de sortie.

6 L'instruction de comparaison compare deux opérandes d'entrée. En fait, il calcule la différence entre ces deux opérandes, mais ne forme pas un opérande de sortie, mais modifie uniquement les bits dans le registre d'état du processeur en fonction du résultat de cette soustraction. L'instruction suivante suivant l'instruction de comparaison (généralement une instruction de branchement) analysera les bits dans le registre d'état du processeur et effectuera des actions en fonction de leurs valeurs. Certains processeurs fournissent des instructions pour connecter en guirlande deux séquences d'opérandes en mémoire.

7 Commandes logiques. Les instructions logiques effectuent des opérations logiques (au niveau du bit) sur les opérandes, c'est-à-dire qu'elles considèrent les codes d'opérande non pas comme un nombre unique, mais comme un ensemble de bits séparés. C'est en quoi elles diffèrent des commandes arithmétiques. Les commandes logiques effectuent les opérations de base suivantes :

­ ET logique, OU logique, addition modulo 2 (OU exclusif) ;

­ décalages logiques, arithmétiques et cycliques;

­ vérifier les bits et les opérandes ;

­ mise à 1 et effacement des bits (drapeaux) du registre d'état du processeur ( PSW).

Les instructions logiques vous permettent de calculer des fonctions logiques de base à partir de deux opérandes d'entrée bit par bit. De plus, l'opération AND est utilisée pour forcer l'effacement des bits spécifiés (un code de masque est utilisé comme l'un des opérandes, dans lequel les bits à effacer sont mis à zéro). L'opération OU est utilisée pour forcer la mise à 1 des bits spécifiés (comme l'un des opérandes, un code de masque est utilisé, dans lequel les bits nécessitant une mise à un sont égaux à un). L'opération "OU exclusif" est utilisée pour inverser les bits spécifiés (un code de masque est utilisé comme l'un des opérandes, dans lequel les bits à inverser sont mis à un). Les instructions nécessitent deux opérandes d'entrée et forment un opérande de sortie.

8 Les commandes Shift permettent de décaler au niveau du bit le code de l'opérande vers la droite (vers les bits de poids faible) ou vers la gauche (vers les bits de poids fort). Le type de décalage (logique, arithmétique ou cyclique) détermine quelle sera la nouvelle valeur du bit le plus significatif (lorsqu'il est décalé vers la droite) ou du bit le moins significatif (lorsqu'il est décalé vers la gauche) et détermine également si la valeur précédente du bit le plus significatif (lorsqu'il est décalé vers la gauche) sera enregistré quelque part ou le bit le moins significatif (lorsqu'il est décalé vers la droite). Les décalages cycliques permettent aux bits d'un opérande d'être décalés de manière circulaire (dans le sens des aiguilles d'une montre lorsqu'ils sont décalés vers la droite, ou dans le sens antihoraire lorsqu'ils sont décalés vers la gauche). Dans ce cas, le drapeau de retenue peut ou non être inclus dans la bague de changement de vitesse. Le bit d'indicateur de retenue (s'il est utilisé) stocke la valeur du bit le plus significatif lorsqu'il est cyclé vers la gauche et du bit le moins significatif lorsqu'il est cyclé vers la droite. En conséquence, la valeur du bit d'indicateur de retenue sera écrasée dans le bit le moins significatif lors d'un cycle vers la gauche et dans le bit le plus significatif lors d'un cycle vers la droite.

9 Commandes de transitions. Les instructions de saut sont conçues pour organiser toutes sortes de boucles, de branches, d'appels de sous-programmes, etc., c'est-à-dire qu'elles perturbent le flux séquentiel du programme. Ces commandes écrivent une nouvelle valeur dans le registre du compteur de commandes et font ainsi sauter le processeur non pas à la commande suivante dans l'ordre, mais à toute autre commande de la mémoire programme. Certaines commandes de transition fournissent un retour supplémentaire au point à partir duquel la transition a été effectuée, d'autres ne le permettent pas. Si return est fourni, les paramètres actuels du processeur sont enregistrés sur la pile. Si aucun retour n'est fourni, les paramètres actuels du processeur ne sont pas enregistrés.

Les commandes de transition sans retour en arrière sont divisées en deux groupes :

­ commandes de saut inconditionnel;

­ commandes de saut conditionnel.

Ces commandes utilisent les mots Branchez et sautez.

Les instructions de saut inconditionnel provoquent un saut vers nouvelle adresse peu importe ce que. Ils peuvent provoquer une transition vers la valeur spécifiée décalages (avant ou arrière) ou à l'adresse mémoire spécifiée. La valeur de décalage ou la nouvelle valeur d'adresse est spécifiée comme opérande d'entrée.

Les instructions de saut conditionnel ne provoquent pas toujours un saut, mais uniquement lorsque les conditions spécifiées sont remplies. Ces conditions sont généralement les valeurs des drapeaux dans le registre d'état du processeur ( PSW ). C'est-à-dire que la condition de transition est le résultat de l'opération précédente qui modifie les valeurs des drapeaux. Il peut y avoir de 4 à 16 conditions de saut au total.Plusieurs exemples de commandes de saut conditionnel :

­ transition si égale à zéro ;

­ transition s'il n'est pas égal à zéro ;

­ sauter s'il y a débordement;

­ sauter s'il n'y a pas de débordement ;

­ transition si supérieure à zéro ;

­ sauter si inférieur ou égal à zéro.

Si la condition de transition est remplie, la nouvelle valeur est chargée dans le registre de commande. Si la condition de saut n'est pas remplie, le compteur d'instructions est simplement incrémenté et le processeur sélectionne et exécute l'instruction suivante dans l'ordre.

La commande de comparaison (CMP) précédant la commande de branchement conditionnel (voire plusieurs commandes de branchement conditionnel) est utilisée spécifiquement pour vérifier les conditions de saut. Mais les drapeaux peuvent être définis par n'importe quelle autre commande, par exemple, une commande de transfert de données, n'importe quelle commande arithmétique ou logique. Notez que les commandes de saut elles-mêmes ne changent pas les drapeaux, ce qui vous permet simplement de mettre plusieurs commandes de saut les unes après les autres.

Les commandes d'interruption occupent une place particulière parmi les commandes de retour en arrière. Ces instructions nécessitent un numéro d'interruption (adresse vectorielle) comme opérande d'entrée.

Sortir:

Le langage assembleur est une représentation symbolique d'un langage machine. Le langage d'assemblage pour chaque type d'ordinateur est différent. Un programme en langage assembleur est un ensemble de blocs de mémoire appelés segments de mémoire. Chaque segment contient un ensemble de phrases de langage, dont chacune occupe une ligne distincte de code de programme. Les phrases d'assemblage sont de quatre types : commandes ou instructions, macros, directives, lignes de commentaires.

Toutes les lettres latines sont des caractères valides lors de l'écriture du texte du programme : A-Z,a-z... Dans ce cas, les lettres majuscules et minuscules sont considérées comme équivalentes ; chiffres de 0 avant 9 ; panneaux ? , @ , $ , _ , & ; séparateurs , . () < > { } + / * % ! " " ? = # ^ .

Les types suivants d'instructions d'assembleur et de règles syntaxiques pour la formation d'expressions d'assembleur s'appliquent. opérateurs arithmétiques, opérateurs de décalage, opérateurs de comparaison, opérateurs logiques, opérateur d'index, opérateur de substitution de type, opérateur de substitution de segment, opérateur de dénomination de type de structure, opérateur pour obtenir le composant de segment d'une adresse d'expression, opérateur pour obtenir le décalage d'une expression.

Le système de commandement est divisé en 8 groupes principaux.

­ Questions de contrôle :

1 Qu'est-ce que le langage assembleur ?

2 Quels symboles peuvent être utilisés pour écrire des commandes en langage assembleur ?

3 Que sont les labels et à quoi servent-ils ?

4 Expliquer la structure des commandes assembleur.

5 Citez 4 types de phrases en assembleur.

1. Architecture du PC ………………………………………………………… 5

1.1. Registres.

1.1.1 Registres usage général.

1.1.2. Registres de segments

1.1.3 Registre des drapeaux

1.2. Organisation de la mémoire.

1.3. Présentation des données.

1.3.1 Types de données

1.3.2 Représentation des caractères et des chaînes

2. Opérateurs du programme assembleur ……………………………………

1. Commandes en langage assembleur

2.2. Modes d'adressage et formats d'instructions machine

3. Pseudo-opérateurs ……………………………………………………….

3.1 Directives de définition des données

3.2 Structure d'un programme en langage assembleur

3.2.1 Segments de programme. Assumer la directive

3.2.3 Directive de segmentation simplifiée

4. Assemblage et liaison du programme ………………………….

5. Commandes d'envoi de données …………………………………………….

5.1 Commandes générales

5.2 Commandes pour travailler avec la pile

5.3 Commandes E/S

5.4 Commandes de transfert d'adresse

5.5 Commandes de transfert de drapeaux

6. Commandes arithmétiques …………………………………………….

6.1 Opérations arithmétiques sur les entiers binaires

6.1.1 Addition et soustraction

6.1.2 Commandes pour incrémenter et décrémenter le récepteur d'un

6.2 Multiplication et division

6.3 Changement de signe

7. Opérations logiques ………………………………………………….

8. Changements et changements cycliques …………………………………………

9. Opérations sur les chaînes ………………………………………………….

10. Logique et organisation des programmes ………………………………………

10.1 Sauts inconditionnels

10.2 Sauts conditionnels

10.4 Routines en langage assembleur

10.5 Interruptions INT

10.6 Logiciel système

10.6.1.1 Lecture du clavier.

10.6.1.2 Affichage des caractères à l'écran

10.6.1.3 Fin des programmes.

10.6.2.1 Sélection des modes d'affichage

11. Mémoire disque ……………………………………………………… ..

11.2 Tableau d'allocation des fichiers

11.3 E/S disque

11.3.1 Écrire un fichier sur le disque

11.3.1.1 Données au format ASCIIZ

11.3.1.2 Numéro de dossier

11.3.1.3 Créer un fichier disque

11.3.2 Lecture d'un fichier disque

introduction

Le langage assembleur est une représentation symbolique d'un langage machine. Tous les processus d'un ordinateur personnel (PC) au niveau matériel le plus bas ne sont pilotés que par des commandes en langage machine (instructions). Il est impossible de vraiment résoudre les problèmes liés au matériel (ou même les problèmes dépendants du matériel tels que l'amélioration des performances du programme) sans connaître l'assembleur.

L'assembleur est une forme pratique de commandes directement pour les composants PC et nécessite la connaissance des propriétés et des capacités du circuit intégré contenant ces composants, à savoir le microprocesseur du PC. Ainsi, le langage assembleur est directement lié à l'organisation interne du PC. Et ce n'est pas un hasard si presque tous les compilateurs de langages de haut niveau prennent en charge l'accès au niveau de programmation en langage assembleur.

Un élément de la formation d'un programmeur professionnel est nécessairement l'étude de l'assembleur. En effet, la programmation en langage assembleur nécessite une connaissance de l'architecture du PC, ce qui vous permet de créer des programmes plus efficaces dans d'autres langages et de les combiner avec des programmes en langage assembleur.

Le manuel traite des problèmes de programmation en langage assembleur pour les ordinateurs à base de microprocesseurs d'Intel.

Ce tutoriel s'adresse à toute personne intéressée par l'architecture des processeurs et les bases de la programmation en langage assembleur, principalement les développeurs de logiciels.

Architecture PC.

L'architecture informatique est une représentation abstraite d'un ordinateur qui reflète son organisation structurelle, ses circuits et sa logique.

Tous les ordinateurs modernes ont des propriétés d'architecture communes et individuelles. Les propriétés individuelles ne sont inhérentes qu'à un modèle informatique spécifique.

Le concept d'architecture informatique comprend :

schéma fonctionnel de l'ordinateur;

moyens et méthodes d'accès aux éléments schéma structurel ORDINATEUR;

ensemble et disponibilité des registres;

organisation et modalités d'adressage;

méthode de présentation et format des données informatiques;

ensemble d'instructions de machine informatique;

formats d'instructions machine;

interrompre la gestion.

Les principaux éléments du matériel informatique : l'unité centrale, le clavier, les périphériques d'affichage, les lecteurs de disque, les périphériques d'impression (imprimante) et diverses installations de communication. Unité système se compose d'une carte mère, d'une alimentation et d'emplacements d'extension pour des cartes supplémentaires. La carte système contient un microprocesseur, une mémoire morte (ROM), RAM(RAM) et coprocesseur.

Registres.

A l'intérieur du microprocesseur, les informations sont contenues dans un groupe de 32 registres (16 registres utilisateur, 16 registres système), dans une certaine mesure disponibles pour une utilisation par le programmeur. Étant donné que le tutoriel est consacré à la programmation du microprocesseur 8088-i486, il est plus logique de commencer ce sujet en abordant les registres internes du microprocesseur à la disposition de l'utilisateur.

Les registres utilisateur sont utilisés par le programmeur pour écrire des programmes. Ces registres comprennent :

huit registres 32 bits (registres à usage général) EAX/AX/AH/AL, EBX/BX/BH/BL, ECX/CX/CH/CL, EDX/DX/DLH/DL, EBP/BP, ESI/SI, EDI/DI, ESP/SP ;

six registres de segments de 16 bits : CS, DS, SS, ES, FS, GS ;

registres d'état et de contrôle : registre de drapeau EFLAGS / FLAGS et registre de pointeur d'instruction EIP / IP.

La barre oblique marque les parties d'un seul registre de 32 bits. Le préfixe E (étendu) indique l'utilisation d'un registre de 32 bits. Pour travailler avec des octets, des registres avec les préfixes L (bas) et H (haut) sont utilisés, par exemple AL, CH - désignant les octets bas et haut des parties 16 bits des registres.

Registres à usage général.

EAX / AX / AH / AL (Registre accumulateur) - batterie... Utilisé dans la multiplication et la division, dans les opérations d'E/S et dans certaines opérations sur les chaînes.

EBX / BX / BH / BL - registre de base(registre de base), souvent utilisé lors de l'adressage des données en mémoire.

ECX / CX / CH / CL - contrer(registre de comptage), utilisé comme compteur du nombre de répétitions de boucle.

EDX / DX / DH / DL - registre de données(registre de données), utilisé pour stocker des données intermédiaires. Il est obligatoire dans certaines commandes.

Tous les registres de ce groupe permettent l'accès à leurs parties "inférieures". Seules les parties inférieures de 16 et 8 bits de ces registres peuvent être utilisées pour l'auto-adressage. Les 16 bits supérieurs de ces registres ne sont pas disponibles en tant qu'objets indépendants.

Pour prendre en charge les commandes de traitement de ligne qui permettent le traitement séquentiel de chaînes d'éléments d'une longueur de 32, 16 ou 8 bits, utilisez :

ESI / SI (registre d'index source) - indice la source... Contient l'adresse de l'élément source actuel.

EDI / DI (registre d'index de destination) - indice destinataire(destinataire). Contient l'adresse actuelle dans la chaîne de réception.

Dans l'architecture du microprocesseur, une structure de données - une pile - est supportée au niveau matériel-logiciel. Il existe des commandes spéciales et des registres spéciaux pour travailler avec la pile. Il est à noter que la pile est remplie vers des adresses plus petites.

ESP / SP (registre de pointeur de pile) - S'inscrire aiguille empiler... Contient le pointeur vers le haut de la pile dans le segment de pile actuel.

EBP / BP (registre de pointeur de base) - registre de pointeur de base de pile... Conçu pour organiser l'accès aléatoire aux données à l'intérieur de la pile.

1.1.2. Registres de segments

Dans le modèle logiciel du microprocesseur, il y a six registres de segments : CS, SS, DS, ES, GS, FS. Leur existence est due aux spécificités de l'organisation et de l'utilisation de la RAM par les microprocesseurs Intel. Le matériel du microprocesseur prend en charge l'organisation structurelle du programme consistant en segments. Pour indiquer les segments disponibles dans ce moment les registres de segment sont prévus. Le microprocesseur prend en charge les types de segments suivants :

Segment de code. Contient des commandes de programme. Pour accéder à ce segment, utilisez le registre CS (code segment register) - registre de code de segment... Il contient l'adresse du segment d'instruction machine auquel le microprocesseur a accès.

Segment de données. Contient les données traitées par le programme. Pour accéder à ce segment, utilisez le registre DS (data segment register) - registre de données de segment qui stocke l'adresse du segment de données du programme en cours.

Segment de pile. Ce segment représente une zone de mémoire appelée la pile. Le microprocesseur organise la pile selon le principe : premier arrivé, premier parti. Le registre SS (stack segment register) est utilisé pour accéder à la pile - registre de segment de pile contenant l'adresse du segment de pile.

Segment de données supplémentaires. Les données traitées peuvent être dans trois segments de données supplémentaires. Par défaut, les données sont supposées se trouver dans le segment de données. Lors de l'utilisation de segments de données supplémentaires, leurs adresses doivent être spécifiées explicitement à l'aide de préfixes de remplacement de segment spéciaux dans la commande. Les adresses des segments de données supplémentaires doivent être contenues dans les registres ES, GS, FS (registres de segment de données d'extension).

Registres de contrôle et d'état

Le microprocesseur contient plusieurs registres qui contiennent des informations sur l'état du microprocesseur lui-même et du programme dont les commandes sont actuellement chargées dans le pipeline. Ce:

Registre de pointeur de commande EIP/IP ;

enregistrer les drapeaux EFLAGS / FLAGS.

En utilisant ces registres, vous pouvez obtenir des informations sur les résultats de l'exécution de la commande et influencer l'état du microprocesseur lui-même.

EIP / IP (registre de pointeurs d'instructions) - aiguille équipes... Le registre EIP/IP a une largeur de 32 ou 16 bits et contient le décalage de la prochaine instruction à exécuter par rapport au contenu du registre de segment CS dans le segment d'instruction en cours. Ce registre n'est pas directement accessible, mais il peut être modifié par des commandes de saut.

EFLAGS / FLAGS (Registre des drapeaux) - S'inscrire drapeaux... Profondeur de bits 32/16 bits. Les bits individuels de ce registre ont un objectif fonctionnel spécifique et sont appelés drapeaux. Un drapeau est un bit qui prend la valeur 1 ("le drapeau est activé") si une certaine condition est remplie, et la valeur 0 ("le drapeau est effacé") sinon. La partie inférieure de ce registre est complètement analogue au registre FLAGS pour i8086.

1.1.3 Registre des drapeaux

Le registre des drapeaux est de 32 bits et porte le nom EFLAGS (Figure 1). Les bits individuels du registre ont un objectif fonctionnel spécifique et sont appelés drapeaux. Chacun d'eux se voit attribuer un nom spécifique (ZF, CF, etc.). Les 16 bits inférieurs d'EFLAGS représentent le registre d'indicateurs FLAGS à 16 bits utilisé lors de l'exécution de programmes écrits pour les microprocesseurs i086 et i286.

Fig. 1 Registre des drapeaux

Certains indicateurs sont communément appelés indicateurs de condition ; ils changent automatiquement lorsque les commandes sont exécutées et fixent certaines propriétés de leur résultat (par exemple, s'il est égal à zéro). D'autres drapeaux sont appelés drapeaux d'état ; ils changent du programme et affectent le comportement ultérieur du processeur (par exemple, les interruptions de bloc).

Indicateurs de condition :

CF (porte drapeau) - porter le drapeau... Prend la valeur 1 si, lors de l'ajout de nombres entiers, une unité de césure apparaissait qui ne « rentrait » pas dans la grille de bits, ou si, lors de la soustraction de nombres non signés, le premier d'entre eux était inférieur au second. Dans les commandes de décalage, un bit qui a dépassé la grille de bits est défini dans CF. CF capture également les caractéristiques de la commande de multiplication.

OF (indicateur de débordement) - indicateur de débordement... Il est mis à 1 si, lors de l'addition ou de la soustraction d'entiers signés, on obtient un résultat supérieur en valeur absolue à la valeur admissible (la mantisse a débordé et elle "monte" dans le bit de signe).

ZF (drapeau zéro) - drapeau zéro... Il est mis à 1 si le résultat de la commande était égal à 0.

SF (Drapeau SIG) - drapeau signe... Il est mis à 1 si l'opération sur les nombres signés aboutit à un résultat négatif.

PF (drapeau de parité) - drapeau parité... Egal à 1 si le résultat de la commande suivante contient un nombre pair de uns binaires. Il n'est généralement pris en compte que pour les opérations d'E/S.

AF (drapeau de portage auxiliaire) - drapeau de transport supplémentaire... Corrige les particularités de l'exécution d'opérations sur des nombres décimaux binaires.

Indicateurs d'état :

DF (drapeau de direction) - drapeau de direction... Définit la direction de visualisation des lignes dans les commandes de chaîne : avec DF = 0, les lignes sont balayées "en avant" (du début à la fin), avec DF = 1 - dans la direction opposée.

IOPL (niveau de privilège d'entrée/sortie) - Niveau de privilège E/S. Il est utilisé dans le mode protégé du microprocesseur pour contrôler l'accès aux commandes d'E/S, en fonction du privilège de la tâche.

NT (tâche imbriquée) - indicateur d'imbrication de tâche. Il est utilisé dans le mode protégé du microprocesseur pour enregistrer le fait qu'une tâche est imbriquée dans une autre.

Indicateur système :

SI (indicateur d'interruption) - indicateur d'interruption... Si SI = 0, le processeur cesse de répondre aux interruptions entrantes ; si SI = 1, le verrou d'interruption est libéré.

TF (drapeau piège) - indicateur de trace... Si TF = 1, après l'exécution de chaque instruction, le processeur effectue une interruption (avec le numéro 1), qui peut être utilisée lors du débogage du programme pour le tracer.

RF (indicateur de reprise) - indicateur de reprise... Utilisé lors de la gestion des interruptions des registres de débogage.

VM (mode virtuel 8086) - drapeau virtuel 8086. 1-processeur fonctionne en mode virtuel 8086. 0-processeur fonctionne en mode réel ou protégé.

AC (contrôle d'alignement) - indicateur de contrôle d'alignement. Conçu pour permettre le contrôle de l'alignement lors de l'accès à la mémoire.

Organisation de la mémoire.

La mémoire physique à laquelle le microprocesseur a accès est appelée RAM ( ou mémoire vive - RAM). La RAM est une chaîne d'octets qui ont leur propre adresse unique (son numéro), appelée physique. La plage de valeurs pour les adresses physiques est de 0 à 4 Go. Le mécanisme de gestion de la mémoire est entièrement basé sur le matériel.

Le matériel du microprocesseur prend en charge plusieurs modèles d'utilisation de la RAM :

modèle segmenté... Dans ce modèle, la mémoire des programmes est divisée en zones de mémoire contiguës (segments), et le programme lui-même ne peut accéder qu'aux données qui se trouvent dans ces segments ;

modèle de page... Dans ce cas, la RAM est considérée comme un ensemble de blocs d'une taille fixe de 4 Ko. L'application principale de ce modèle est associée à l'organisation de la mémoire virtuelle, qui permet aux programmes d'utiliser un espace mémoire plus grand que le volume mémoire physique... Pour un microprocesseur Pentium, la mémoire virtuelle possible peut aller jusqu'à 4 To.

L'utilisation et la mise en œuvre de ces modèles dépendent du mode de fonctionnement du microprocesseur :

Mode adresse réelle (mode réel). Le mode est similaire au fonctionnement du processeur i8086. Il est nécessaire au fonctionnement des programmes développés pour les premiers modèles de processeurs.

Mode protégé. En mode protégé, il devient possible d'effectuer plusieurs tâches traitement d'informations, protection de la mémoire avec un mécanisme de privilège à quatre niveaux et sa pagination.

Mode virtuel 8086. Dans ce mode, il devient possible d'exécuter plusieurs programmes pour le i8086. Dans ce cas, le fonctionnement des programmes en mode réel est possible.

La segmentation est un mécanisme d'adressage qui permet à plusieurs espaces d'adressage indépendants d'exister. Un segment est un bloc de mémoire indépendant pris en charge par le matériel.

Chaque programme dans le cas général peut être constitué d'un nombre quelconque de segments, mais il a un accès direct à trois principaux : code, données et pile - et d'un à trois segments de données supplémentaires. Système opérateur place des segments de programme en RAM à des adresses physiques spécifiques, puis place les valeurs de ces adresses dans les registres correspondants. A l'intérieur d'un segment, le programme accède aux adresses relatives au début du segment de manière linéaire, c'est-à-dire en partant de l'adresse 0 et en se terminant par une adresse égale à la taille du segment. Adresse relative ou biais, que le microprocesseur utilise pour accéder aux données dans un segment est appelé efficace.

Formation d'une adresse physique en mode réel

En mode réel, la plage de changement de l'adresse physique est de 0 à 1 Mo. La taille maximale des segments est de 64 Ko. Lorsqu'on se réfère à un adresse physique La RAM est déterminée par l'adresse du début du segment et le décalage à l'intérieur du segment. L'adresse de début de segment est extraite du registre de segment correspondant. Dans ce cas, le registre de segment ne contient que les 16 bits supérieurs de l'adresse physique du début du segment. Les quatre bits manquants les moins significatifs d'une adresse de 20 bits sont obtenus en décalant la valeur du registre de segment vers la gauche de 4 bits. L'opération de décalage est effectuée dans le matériel. La valeur de 20 bits résultante est l'adresse physique réelle correspondant au début du segment. C'est-à-dire adresse physique est spécifié comme une paire : segment : offset, où segment est les 16 premiers bits de l'adresse de début du segment de mémoire auquel appartient la cellule, et offset est l'adresse de 16 bits de cette cellule, comptée à partir du début de cette mémoire segment (la valeur 16 * segment + offset donne l'adresse absolue de la cellule). Si par exemple le registre CS mémorise la valeur 1234h, alors le couple d'adresses 1234h : 507h définit une adresse absolue égale à 16 * 1234h + 507h = 12340h + 507h = 12847h. Une telle paire est écrite sous la forme d'un double mot et (comme pour les nombres) sous une forme "inversée": le premier mot contient un décalage et le second - un segment, et chacun de ces mots à son tour est présenté dans une forme "inversée". Par exemple, la paire 1234h : 5678h s'écrira comme ceci : | 78 | 56 | 34 | 12 |.

Ce mécanisme de formation d'une adresse physique permet de rendre le logiciel délocalisable, c'est-à-dire qu'il ne dépend pas des adresses spécifiques de son chargement en RAM.

Assembleur Structures

Les tableaux que nous avons considérés ci-dessus sont une collection d'éléments du même type. Mais souvent dans les applications, il devient nécessaire de considérer un certain ensemble de données. différents types comme un type unique.

Ceci est très important, par exemple, pour les programmes de base de données, où il est nécessaire d'associer une collection de données de différents types à un seul objet.

Par exemple, nous avons examiné le Listing 4 plus tôt, dans lequel nous avons travaillé avec un tableau d'éléments de trois octets. Chaque élément, à son tour, représentait deux éléments de types différents : un champ de compteur d'un octet et un champ de deux octets pouvant contenir d'autres informations nécessaires au stockage et au traitement. Si le lecteur est familier avec l'un des langages de haut niveau, alors il sait qu'un tel objet est généralement décrit à l'aide d'un type de données spécial - structure.

Afin d'améliorer la convivialité du langage assembleur, ce type de données y a également été introduit.

Un prieuré structure est un type de données composé d'un nombre fixe d'éléments de types différents.

Pour utiliser des structures dans un programme, vous devez effectuer trois étapes :

Interroger modèle de structure .

Par définition, cela signifie définir un nouveau type de données, qui peut ensuite être utilisé pour définir des variables de ce type.

Définir instance de structure .

Cette étape implique l'initialisation d'une variable spécifique avec une structure prédéfinie (à l'aide d'un modèle).

Organiser accès aux éléments de structure .

Il est très important que vous compreniez la différence entre la description structure dans le programme et ses définir.

Décris la structure dans le programme signifie uniquement pour indiquer son schéma ou son modèle ; aucune mémoire n'est allouée.

Ce modèle ne peut être considéré que comme une information pour le traducteur sur l'emplacement des champs et leurs valeurs par défaut.

Définir structure signifie demander au traducteur d'allouer de la mémoire et d'attribuer un nom symbolique à cette zone mémoire.

Vous ne pouvez décrire la structure d'un programme qu'une seule fois, mais vous pouvez la définir autant de fois que vous le souhaitez.

Description du modèle de structure

La description du modèle de structure a la syntaxe suivante :

nom_structure STRUC struct_name FIN

Ici est une séquence de directives décrivant des données db, dw, dd, dq et dt.

Leurs opérandes déterminent la taille des champs et, le cas échéant, les valeurs initiales. Ces valeurs seront probablement initialisées aux champs correspondants lors de la définition de la structure.

Comme nous l'avons noté lors de la description du modèle, aucune mémoire n'est allouée, car ce n'est qu'une information pour le traducteur.

Emplacement Le modèle dans le programme peut être arbitraire, mais, suivant la logique du traducteur à une passe, il doit être situé jusqu'à l'endroit où la variable avec le type de cette structure est définie. C'est-à-dire que lors de la description d'une variable avec le type d'une certaine structure dans un segment de données, son modèle doit être placé au début du segment de données ou avant celui-ci.

Envisageons de travailler avec des structures en utilisant l'exemple de la modélisation d'une base de données d'employés d'un certain département.

Pour simplifier, afin de s'affranchir des problèmes de conversion des informations lors de la saisie, on conviendra que tous les champs sont symboliques.

Définissons la structure d'enregistrement de cette base de données avec le modèle suivant :

Définir des données avec un type de structure

Pour utiliser la structure décrite à l'aide du modèle dans le programme, vous devez définir une variable avec le type de cette structure. Pour cela, la syntaxe suivante est utilisée :

[nom de la variable] nom_structure

Nom de variable- identifiant d'une variable de ce type structurel.

Le nom de la variable est facultatif. Si vous ne le précisez pas, une zone mémoire de la taille de la somme des longueurs de tous les éléments de la structure sera simplement allouée.

liste de valeurs- une liste séparée par des virgules des valeurs initiales des éléments de structure, entre crochets angulaires.

Son affectation est également facultative.

Si la liste est incomplète, tous les champs de structure de cette variable sont initialisés avec les valeurs du modèle, le cas échéant.

Il est permis d'initialiser des champs individuels, mais dans ce cas, les champs manquants doivent être séparés par des virgules. Les champs manquants seront initialisés avec les valeurs du modèle de structure. Si, lors de la définition d'une nouvelle variable avec le type de cette structure, nous sommes d'accord avec toutes les valeurs de champ de son modèle (c'est-à-dire définies par défaut), il vous suffit d'écrire des crochets angulaires.

Par exemple: travailleur victorieux.

Par exemple, définissons plusieurs variables avec le type de structure décrit ci-dessus.

Méthodes pour travailler avec la structure

L'idée d'introduire un type structuré dans n'importe quel langage de programmation est de combiner des variables de types différents en un seul objet.

Le langage doit disposer d'un moyen d'accéder à ces variables dans une instance spécifique de la structure. Afin de faire référence à un champ d'une certaine structure dans une commande, un opérateur spécial est utilisé - symbole ". " (point)... Il est utilisé dans la syntaxe suivante :

expression_adresse- l'identifiant d'une variable d'un certain type structurel ou d'une expression entre parenthèses conformément aux règles syntaxiques indiquées ci-dessous (Fig. 1);

nom_champ_structure- le nom du champ du modèle de structure.

Ceci, en fait, est aussi une adresse, ou plutôt, le décalage du champ depuis le début de la structure.

Ainsi, l'opérateur " . "(point) évalue l'expression

Riz. 5. La syntaxe d'une expression d'adresse dans un opérateur d'accès à un champ de structure

Démontrons en utilisant l'exemple de la structure que nous avons définie ouvrier quelques techniques pour travailler avec des structures.

Par exemple, extraire dans hache valeurs de champ avec l'âge. Puisqu'il est peu probable que l'âge d'une personne valide soit supérieur à 99 ans, alors après avoir placé le contenu de ce champ de caractère dans le registre hache il sera pratique de le convertir en représentation binaire avec la commande annonce.

Attention, en raison du principe de stockage des données "Octet le moins significatif au moins l'adresse significative" le chiffre d'âge le plus élevé sera placé dans Al, et le plus jeune - en euh.

Pour régler, il suffit d'utiliser la commande xchg al, ah:

mov hache, mot ptr sotr1.age; dans al age sotr1

ou tu peux faire ça :

Le travail ultérieur avec un tableau de structures est effectué de la même manière qu'avec un tableau unidimensionnel. Plusieurs questions se posent ici :

Qu'en est-il de la taille et comment organiser l'indexation des éléments du tableau ?

Comme pour les autres identifiants définis dans le programme, le traducteur affecte le nom du type de structure et le nom de la variable avec le type de structure à l'attribut type. La valeur de cet attribut est la taille en octets occupée par les champs de cette structure. Vous pouvez récupérer cette valeur à l'aide de l'opérateur taper.

Une fois que la taille d'une instance de structure est connue, il n'est pas difficile d'organiser l'indexation dans un tableau de structures.

Par exemple:

Comment copier un champ d'une structure vers le champ correspondant d'une autre structure ? Ou comment copier toute la structure ? copions le champ nom troisième employé sur le terrain nom cinquième employé :

mas_sotr travailleur 10 dup () mov bx, décalage mas_sotr mov si, (type travailleur) * 2 ; si = 77 * 2 mov di, (type travailleur) * 4 ; si = 77 * 4

Il me semble que le métier de programmeur, tôt ou tard, fait ressembler une personne à une bonne femme au foyer. Lui, comme elle, est constamment à la recherche d'où économiser quelque chose, réduire et faire un merveilleux dîner à partir d'un minimum de produits. Et si cela réussit, la satisfaction morale n'est pas moins, et peut-être plus, que d'un merveilleux dîner avec une femme au foyer. Le degré de cette satisfaction, me semble-t-il, dépend du degré d'amour pour son métier.

D'autre part, les succès dans le développement de logiciels et de matériel détendent quelque peu le programmeur, et assez souvent une situation similaire au proverbe bien connu sur une mouche et un éléphant est observée - pour résoudre un petit problème, des moyens lourds sont utilisés, dont l'efficacité, dans le cas général, n'est significative que lors de la mise en œuvre de projets relativement importants.

La présence des deux types de données suivants dans la langue s'explique probablement par la volonté de "l'hôtesse" d'utiliser le plus efficacement possible la zone de travail de la table (RAM) lors de la préparation des aliments ou pour le placement des produits (données du programme ).

Structure des instructions en langage assembleur La programmation au niveau des instructions machine est le niveau minimum auquel la programmation informatique est possible. Le jeu d'instructions de la machine doit être suffisant pour effectuer les actions requises en envoyant des instructions au matériel de la machine. Chaque instruction machine se compose de deux parties : une d'exploitation qui définit « que faire » et une opérande qui définit les objets de traitement, c'est-à-dire ce qu'il faut refaire. Une instruction machine à microprocesseur écrite en langage assembleur est une seule ligne de la forme suivante : étiquette instruction/directive opérande(s) ; commentaires L'étiquette, la commande / la directive et l'opérande sont séparés par au moins un espace ou un caractère de tabulation. Les opérandes de commande sont séparés par des virgules.

Structure d'instruction en langage assembleur Une instruction en langage assembleur indique au traducteur quelle action le microprocesseur doit entreprendre. Les directives d'assembleur sont des paramètres spécifiés dans le texte du programme qui affectent le processus d'assemblage ou les propriétés du fichier de sortie. L'opérande définit la valeur initiale des données (dans le segment de données) ou les éléments sur lesquels agira la commande (dans le segment de code). Une instruction peut avoir un ou deux opérandes, ou aucun opérande. Le nombre d'opérandes est implicitement spécifié par le code de commande. Si une commande ou une directive doit être poursuivie sur la ligne suivante, la barre oblique inverse est utilisée : "". Par défaut, l'assembleur ne fait pas la distinction entre les majuscules et les minuscules lors de l'écriture des commandes et des directives. Exemples de directive et de commande Count db 1; Nom, directive, un opérande mov eax, 0 ; Commande, deux opérandes

Les identificateurs sont des séquences de caractères valides utilisées pour désigner les noms de variables et les noms d'étiquettes. L'identifiant peut être constitué d'un ou plusieurs des caractères suivants : toutes les lettres de l'alphabet latin ; nombres de 0 à 9 ; caractères spéciaux : _, @, $, ? ... Un point peut être utilisé comme premier caractère de l'étiquette. Les noms d'assembleur réservés (directives, opérateurs, noms de commandes) ne peuvent pas être utilisés comme identifiants. Le premier caractère de l'identifiant doit être une lettre ou un caractère spécial. La longueur maximale de l'identifiant est de 255 caractères, mais le traducteur accepte les 32 premiers, ignore le reste. Toutes les étiquettes écrites dans une ligne qui ne contient pas de directive assembleur doivent se terminer par deux points ":". L'étiquette, la commande (directive) et l'opérande ne doivent pas nécessairement commencer à une position particulière dans la chaîne. Il est recommandé de les noter dans une colonne pour une meilleure lisibilité du programme.

Etiquettes Toutes les étiquettes qui sont écrites dans une ligne qui ne contient pas de directive assembleur doivent se terminer par un deux-points ":". L'étiquette, la commande (directive) et l'opérande ne doivent pas nécessairement commencer à une position particulière dans la chaîne. Il est recommandé de les noter dans une colonne pour une meilleure lisibilité du programme.

Commentaires L'utilisation de commentaires dans un programme améliore la clarté, en particulier lorsque l'intention du jeu d'instructions n'est pas claire. Les commentaires commencent sur n'importe quelle ligne du module source par un point-virgule (;). Tous les caractères à droite de « ; »À la fin de la ligne se trouve un commentaire. Le commentaire peut contenir n'importe quel caractère imprimable, y compris l'espace. Un commentaire peut s'étendre sur toute la ligne ou suivre une commande sur la même ligne.

La structure d'un programme en langage assembleur Un programme écrit en langage assembleur peut être constitué de plusieurs parties, appelées modules, dans chacune desquelles un ou plusieurs segments de données, de pile et de code peuvent être définis. Tout programme en langage assembleur complet doit inclure un module principal, ou principal, à partir duquel son exécution commence. Un module peut contenir des segments de programme, des segments de données et des segments de pile, déclarés à l'aide des directives appropriées.

Modèles de mémoire Avant de déclarer des segments, vous devez spécifier le modèle de mémoire à l'aide d'une directive. MODEL modificateur memory_model, call_convention, OS_type, stack_parameter Modèles de mémoire de base du langage assembleur : Modèle de mémoire Adressage de code Adressage de données Système d'exploitation Code et entrelacement de données PETIT PROCHE MS-DOS Autorisé PETIT PROCHE MS-DOS, Windows Non MOYEN LOIN PROCHE MS-DOS, Windows Non COMPACT NEAR FAR MS-DOS, Windows Non LARGE FAR MS-DOS, Windows Non ÉNORME FAR MS-DOS, Windows Non NEAR Windows 2000, Windows XP, Windows autorisé FLAT NEAR NT,

Modèles de mémoire Le petit modèle ne fonctionne que dans les applications MS-DOS 16 bits. Dans ce modèle, toutes les données et tous les codes sont situés dans un segment physique. La taille fichier de programme dans ce cas, il ne dépasse pas 64 Ko. Le petit modèle prend en charge un segment de code et un segment de données. Les données et le code sont adressés au plus près lors de l'utilisation de ce modèle. Le modèle moyen prend en charge plusieurs segments de code et un segment de données, avec tous les liens dans les segments de code considérés comme éloignés par défaut, et les liens dans un segment de données comme proches. Le modèle compact prend en charge plusieurs segments de données utilisant l'adressage de données éloignées et un segment de données proche. Le grand modèle prend en charge plusieurs segments de code et plusieurs segments de données. Par défaut, toutes les références de code et de données sont considérées comme distantes. Le modèle énorme est presque équivalent au modèle à grande mémoire.

Modèles de mémoire Le modèle plat suppose une configuration de programme non segmentée et n'est utilisé que sur les systèmes d'exploitation 32 bits. Ce modèle est similaire au modèle minuscule dans la mesure où les données et le code sont contenus dans un seul segment 32 bits. Développer un programme pour le modèle plat avant la directive. modèle plat l'une des directives doit être placé :. 386,. 486,. 586 ou. 686. Le choix de la directive de sélection du processeur détermine l'ensemble des commandes disponibles lors de l'écriture des programmes. La lettre p après la directive de sélection du processeur signifie un mode de fonctionnement protégé. L'adressage des données et du code est proche, toutes les adresses et tous les pointeurs étant de 32 bits.

Modèles de mémoire. MODEL modificateur memory_model, call_convention, OS_type, stack_parameter Le paramètre modifier permet de définir les types de segments et peut prendre les valeurs suivantes : use 16 (les segments du modèle sélectionné sont utilisés en 16 bits) use 32 (segments du modèle sélectionné sont utilisés en 32 bits). Le paramètre call_convention est utilisé pour déterminer comment les paramètres sont passés lors de l'appel d'une procédure à partir d'autres langages, y compris les langages de haut niveau (C++, Pascal). Le paramètre peut prendre les valeurs suivantes : C, BASIC, FORTRAN, PASCAL, SYSCALL, STDCALL.

Modèles de mémoire. MODEL modificateur memory_model, call_ convention, os_type, stack_parameter OS_type est l'OS_DOS par défaut et est actuellement la seule valeur prise en charge pour ce paramètre. Stack_parameter est défini sur : NEARSTACK (le registre SS est DS, les zones de données et de pile sont situées dans le même segment physique) FARSTACK (le registre SS n'est pas égal à DS, les zones de données et de pile sont situées dans des segments physiques différents). La valeur par défaut est NEARSTACK.

Un exemple de programme « ne rien faire ». 686 P. MODÈLE PLAT, STDCALL. LES DONNÉES. CODE DEBUT : RET FIN DEBUT RET - commande du microprocesseur. Il garantit la bonne fin du programme. Le reste du programme est lié au travail du traducteur. ... 686 P - Commandes en mode protégé Pentium 6 (Pentium II) autorisées. Cette directive sélectionne le jeu d'instructions assembleur pris en charge en spécifiant le modèle de processeur. ... MODÈLE FLAT, stdcall est un modèle à mémoire plate. Ce modèle de mémoire est utilisé dans le système d'exploitation Windows. stdcall est la convention d'appel de procédure utilisée.

Un exemple de programme « ne rien faire ». 686 P. MODÈLE PLAT, STDCALL. LES DONNÉES. CODE DEBUT : RET FIN DEBUT. DATA est un segment de programme contenant des données. Ce programme n'utilise pas la pile, donc segment. PILE est manquant. ... CODE est un segment du programme contenant le code. START est une étiquette. END START - la fin du programme et un message au compilateur indiquant que le programme doit être démarré à partir de l'étiquette START. Chaque programme doit contenir une directive END pour marquer la fin du code source du programme. Toutes les lignes suivant la directive END sont ignorées. L'étiquette spécifiée après la directive END indique au traducteur le nom du module principal à partir duquel le programme démarre. Si le programme contient un module, l'étiquette après la directive END peut être omise.

Traducteurs en langage assembleur Un traducteur est un programme ou moyens techniques qui convertit un programme dans l'un des langages de programmation en un programme dans le langage cible appelé code objet. En plus de prendre en charge les mnémoniques des instructions machine, chaque traducteur a son propre ensemble de directives et d'outils macro, qui sont souvent incompatibles avec quoi que ce soit. Les principaux types de traducteurs en assembleur : MASM (Microsoft Assembler), TASM (Borland Turbo Assembler), FASM (Flat Assembler) - un assembleur multi-passes gratuit écrit par Tomasz Grishtar (Polonais), NASM (Netwide Assembler) - un assembleur gratuit pour Architecture Intel x 86, a été créé par Simon Tatham en collaboration avec Julian Hall et est actuellement développé par une petite équipe de développement sur Source. Forger. rapporter.

Src = "https://present5.com/presentation/-29367016_63610977/image-15.jpg" alt = "(! LANG : Diffusez le programme à Microsoft Visual Studio 2005 1) Créez un projet en sélectionnant Fichier-> Nouveau-> Projet et "> Traduction de programme dans Microsoft Visual Studio 2005 1) Créez un projet en sélectionnant Fichier-> Nouveau-> Projet et en spécifiant le nom du projet (hello.prj) et le type de projet : Win 32 Project. options additionelles de l'assistant de projet spécifiez « Projet vide ».

Src = "https://present5.com/presentation/-29367016_63610977/image-16.jpg" alt = "(! LANG : Diffusion du programme vers Microsoft Visual Studio 2005 2) Dans l'arborescence du projet (Affichage-> Explorateur de solutions) ajouter"> Трансляция программы в Microsoft Visual Studio 2005 2) В дереве проекта (View->Solution Explorer) добавить файл, в котором будет содержаться текст программы: Source. Files->Add->New. Item.!}

Traduction du programme dans Microsoft Visual Studio 2005 3) Sélectionnez le type de fichier Code C ++, mais spécifiez le nom avec l'extension. asm :

Traduction du programme dans Microsoft Visual Studio 2005 5) Définissez les options du compilateur. Sélectionner par bouton de droite dans le fichier de projet du menu Custom Build Rules...

Traduction du programme en Microsoft Visual Studio 2005 et sélectionnez Microsoft Macro Assembler dans la fenêtre qui apparaît.

Traduction de programme dans Microsoft Visual Studio 2005 Vérifiez en cliquant avec le bouton droit sur le bonjour. asm de l'arborescence du projet du menu Propriétés et définissez Général-> Outil : Microsoft Macro Assembler.

Src = "https://present5.com/presentation/-29367016_63610977/image-22.jpg" alt = "(! LANG : Diffusion du programme vers Microsoft Visual Studio 2005 6) Compilez le fichier en choisissant Build-> Build hello. Prj."> Трансляция программы в Microsoft Visual Studio 2005 6) Откомпилировать файл, выбрав Build->Build hello. prj. 7) Запустить программу, нажав F 5 или выбрав меню Debug->Start Debugging.!}

Programmation sous Windows OS La programmation sous Windows OS est basée sur l'utilisation de fonctions API (Application Program Interface, c'est-à-dire application logicielle). Leur nombre atteint 2000. Le programme pour Windows se compose en grande partie de tels appels. Toutes les interactions avec les périphériques externes et les ressources du système d'exploitation se produisent, en règle générale, via de telles fonctions. Salle d'opération Système Windows utilise un modèle de mémoire plate. L'adresse de tout emplacement mémoire sera déterminée par le contenu d'un registre de 32 bits. Il existe 3 types de structures de programme pour Windows : dialogue (fenêtre principale - dialogue), structure console ou sans fenêtre, structure classique (fenêtre, filaire).

Appel Fonctions Windows API Dans le fichier d'aide, toute fonction API est représentée par le type nom_fonction (FA 1, FA 2, FA 3) Type - le type de la valeur de retour ; ФАх - une liste d'arguments formels dans l'ordre dans lequel ils apparaissent. Par exemple, int Message. Boîte (HWND h. Wnd, LPCTSTR lp. Texte, LPCTSTR lp. Légende, UINT u. Type); Cette fonction affiche une fenêtre avec un message et un bouton (ou des boutons) de sortie. Signification des paramètres : h. Wnd - handle vers la fenêtre dans laquelle la fenêtre de message apparaîtra, lp. Texte - le texte qui apparaîtra dans la fenêtre, lp. Légende - le texte dans la légende de la fenêtre, u. Type - le type de fenêtre, en particulier, vous pouvez définir le nombre de boutons de sortie.

Appel de fonctions API Windows int Message. Boîte (HWND h. Wnd, LPCTSTR lp. Texte, LPCTSTR lp. Légende, UINT u. Type); Presque tous les paramètres des fonctions API sont en fait des entiers 32 bits : HWND est un entier 32 bits, LPCTSTR est un pointeur 32 bits vers une chaîne, UINT est un entier 32 bits. Le suffixe « A » est souvent ajouté au nom de la fonction pour passer aux versions plus récentes des fonctions.

Appel de fonctions API Windows int Message. Boîte (HWND h. Wnd, LPCTSTR lp. Texte, LPCTSTR lp. Légende, UINT u. Type); Lorsque vous utilisez MASM, vous devez ajouter @N N à la fin du nom - le nombre d'octets que les arguments passés occupent sur la pile. Pour les fonctions API Win 32, ce nombre peut être défini comme le nombre d'arguments n fois 4 (octets dans chaque argument) : N = 4 * n. La commande assembleur CALL est utilisée pour appeler la fonction. Dans ce cas, tous les arguments de la fonction lui sont passés via la pile (commande PUSH). Sens de passage des arguments : DE GAUCHE À DROITE - DE BAS EN HAUT. Le premier argument à pousser sur la pile est u. Taper. Appel la fonction spécifiée ressemblera à ceci : CALL Message. Boîte. [email protégé]

Appel de fonctions API Windows int Message. Boîte (HWND h. Wnd, LPCTSTR lp. Texte, LPCTSTR lp. Légende, UINT u. Type); Le résultat de l'exécution de toute fonction API est, en règle générale, un entier qui est renvoyé dans le registre EAX. La directive OFFSET est un "décalage de segment" ou, en termes généraux, un "pointeur" vers le début d'une ligne. La directive EQU, comme #define en langage C, définit une constante. La directive EXTERN indique au traducteur que la fonction ou l'identifiant est externe au module donné.

Un exemple du programme "Bonjour tout le monde !" ... 686 P. MODÈLE PLAT, STDCALL. STACK 4096. DATA MB_OK EQU 0 STR 1 DB "Mon premier programme", 0 STR 2 DB "Bonjour tout le monde !", 0 HW DD ? Message EXTERNE. Boîte. [email protégé]: À PROXIMITÉ. CODE START : PUSH MB_OK PUSH OFFSET STR 1 PUSH OFFSET STR 2 PUSH HW CALL Message. Boîte. [email protégé] RET FIN DEBUT

La directive INVOKE Le traducteur de langage MASM permet également de simplifier l'appel de fonctions à l'aide de l'outil macro - la directive INVOKE : fonction INVOKE, paramètre1, paramètre2, ... Dans ce cas, il n'est pas nécessaire d'ajouter @ 16 à la appel de fonction ; les paramètres sont écrits exactement dans l'ordre dans lequel ils sont répertoriés dans la description de la fonction. les paramètres sont poussés sur la pile par les macros du compilateur. pour utiliser la directive INVOKE, vous devez avoir une description du prototype de fonction utilisant la directive PROTO sous la forme : Message. Boîte. A PROTO: DWORD,: DWORD Si le programme utilise de nombreuses fonctions API Win 32, il est conseillé d'utiliser la directive include C: masm 32includeuser 32. inc