Travail de cours

Sujet "Programmation système"

Sujet numéro 4 : "Résoudre les problèmes pour les procédures"

Option 2

UNIVERSITÉ D'ÉTAT DE SIBÉRIE ORIENTALE

TECHNOLOGIE ET ​​GESTION

____________________________________________________________________

COLLEGE TECHNOLOGIQUE

EXERCER

pour une dissertation

Discipline:

Sujet : Résolution de problèmes pour les procédures

Artiste(s): Glavinskaya Arina Aleksandrovna

Responsable : Sesegma Viktorovna Dambaeva

Bref résumé du travail : l'étude des sous-programmes sur langage d'assemblage,

résolution de problèmes à l'aide de sous-programmes

1. Partie théorique : informations de base sur le langage assembleur (ensemble

commandes, etc.), Organisation des sous-programmes, Modes de passage des paramètres

dans les sous-programmes

2. Partie pratique : développer deux sous-programmes, dont l'un convertit une lettre donnée en majuscule (y compris pour les lettres russes) et l'autre convertit la lettre en minuscule.

convertit une lettre donnée en majuscule, et l'autre convertit la lettre en minuscule.

convertit une lettre en minuscule.

Échéanciers du projet selon le calendrier :

1. Partie théorique - 30 % à la semaine 7.

2. Partie pratique - 70% en 11 semaines.

3. Protection - 100 % en 14 semaines.

Exigences de conception :

1. Le règlement et la note explicative du projet de cours doivent être remis en

copies électroniques et papier.

2. Le volume du rapport doit être d'au moins 20 pages dactylographiées, hors annexes.

3. Le RPP est établi conformément à GOST 7.32-91 et signé par le responsable.

Chef de travaux __________________

Interprète __________________

Date d'émission " 26 " Septembre 2017 G.

Introduction. 2

1.1 Informations de base sur le langage d'assemblage. 3

1.1.1 Jeu de commandes. 4

1.2 Organisation des sous-programmes en langage assembleur. 4

1.3 Méthodes de passage des paramètres dans les sous-programmes. 6

1.3.1 Passage des paramètres dans les registres.. 6

1.3.2 Passer des paramètres à travers la pile. 7

2 PARTIE PRATIQUE.. 9

2.1 Énoncé du problème. 9

2.2 Description du problème solution. 9

2.3 Test du programme.. 7

Conclusion. 8

Références.. 9

Introduction

Il est bien connu que la programmation en langage assembleur est difficile. Comme vous le savez, il existe maintenant de nombreuses langues différentes haut niveau , ce qui vous permet de dépenser beaucoup moins d'efforts lors de l'écriture de programmes. Naturellement, la question se pose lorsqu'un programmeur peut avoir besoin d'utiliser Assembler lors de l'écriture de programmes. Actuellement, il existe deux domaines où l'utilisation du langage assembleur est justifiée, et souvent nécessaire.

Premièrement, ce sont les programmes système dits dépendants de la machine, ils contrôlent généralement divers appareils ordinateur (ces programmes sont appelés pilotes). Ces programmes système utilisent des instructions machine spéciales qui n'ont pas besoin d'être utilisées normalement (ou, comme on dit, appliqué) programmes. Ces commandes sont impossibles ou très difficiles à spécifier dans un langage de haut niveau.

Le deuxième domaine d'application d'Assembler est lié à l'optimisation de l'exécution du programme. Très souvent, les programmes de traduction (compilateurs) de langages de haut niveau produisent un programme en langage machine très inefficace. Cela s'applique généralement aux programmes de nature informatique, dans lesquels une très petite section (environ 3 à 5 %) du programme (la boucle principale) est exécutée la plupart du temps. Pour résoudre ce problème, on peut utiliser des systèmes de programmation dits multilingues, qui permettent d'écrire des parties du programme dans différentes langues. Habituellement, la partie principale du programme est écrite dans un langage de programmation de haut niveau (Fortran, Pascal, C, etc.), et les sections critiques du temps du programme sont écrites en Assembleur. Dans ce cas, la vitesse de l'ensemble du programme peut augmenter considérablement. C'est souvent le seul moyen d'obtenir qu'un programme produise des résultats dans un délai raisonnable.

Ce dissertation est d'acquérir des compétences pratiques en programmation en langage assembleur.

Tâches de travail:

1. Étudier les informations de base sur le langage Assembleur (la structure et les composants du programme en Assembleur, le format des commandes, l'organisation des sous-programmes, etc.) ;

2. Étudier les types d'opérations sur les bits, le format et la logique des commandes de la logique assembleur ;

3. Résoudre un problème individuel pour l'utilisation de sous-routines en Assembleur ;

4.. Formuler une conclusion sur le travail effectué.

1 PARTIE THÉORIQUE

Bases du langage d'assemblage

Assembleur - langage de programmation niveau faible, qui est un format d'écriture d'instructions machine adapté à la perception humaine.

Les commandes du langage d'assemblage correspondent une à une aux commandes du processeur et, en fait, représentent une forme symbolique pratique de notation (code mnémonique) des commandes et de leurs arguments. Le langage d'assemblage fournit également des abstractions de programmation de base : relier des parties d'un programme et des données via des étiquettes avec des noms symboliques et des directives.

Les directives d'assemblage vous permettent d'inclure des blocs de données (décrits explicitement ou lus à partir d'un fichier) dans le programme ; répéter un certain fragment un certain nombre de fois ; compiler le fragment selon la condition ; définir l'adresse d'exécution du fragment, modifier les valeurs d'étiquette lors de la compilation ; utiliser des définitions de macro avec des paramètres, etc.

Avantages et inconvénients

La quantité minimale de code redondant (l'utilisation de moins de commandes et d'accès à la mémoire). En conséquence, une vitesse plus élevée et taille plus petite programmes;

de grandes quantités de code, un grand nombre de petites tâches supplémentaires ;

Mauvaise lisibilité du code, difficulté de support (débogage, ajout de fonctionnalités) ;

· la difficulté de mettre en œuvre des paradigmes de programmation et toute autre convention quelque peu complexe, la complexité du développement conjoint ;

Moins de bibliothèques disponibles, leur faible compatibilité ;

· accès direct au matériel : ports d'entrée-sortie, registres spéciaux du processeur ;

maximum "fitting" pour la plate-forme souhaitée (utilisation d'instructions spéciales, caractéristiques techniques"glande");

· non-portabilité vers d'autres plates-formes (à l'exception de celles compatibles binaires).

En plus des instructions, le programme peut contenir des directives : des commandes qui ne sont pas traduites directement en instructions machine, mais contrôlent le fonctionnement du compilateur. Leur ensemble et leur syntaxe varient considérablement et ne dépendent pas de la plate-forme matérielle, mais du compilateur utilisé (donnant naissance à des dialectes de langages au sein d'une même famille d'architectures). En tant qu'ensemble de directives, nous pouvons distinguer :

Définition des données (constantes et variables) ;

gestion de l'organisation du programme en mémoire et des paramètres du fichier de sortie ;

définir le mode compilateur ;

Toutes sortes d'abstractions (c'est-à-dire des éléments de langages de haut niveau) - de la conception de procédures et de fonctions (pour simplifier la mise en œuvre du paradigme de programmation procédurale) aux structures et boucles conditionnelles (pour le paradigme programmation structurée);

macros.

Jeu de commandes

Les instructions typiques du langage d'assemblage sont :

Commandes de transfert de données (mov, etc.)

Les commandes arithmétiques (add, sub, imul, etc.)

Opérations logiques et au niveau du bit (ou, et, xor, shr, etc.)

Commandes de gestion de l'exécution du programme (jmp, loop, ret, etc.)

Commandes d'appel d'interruption (parfois appelées commandes de contrôle) : int

Commandes d'E/S vers les ports (in, out)

Les microcontrôleurs et les micro-ordinateurs sont également caractérisés par des commandes qui effectuent des vérifications et des transitions par condition, par exemple :

· jne - sauter s'il n'est pas égal;

· jge - jump si supérieur ou égal à .

informations généralesà propos du langage d'assemblage

Le langage d'assemblage symbolique permet d'éliminer en grande partie les lacunes de la programmation en langage machine.

Son principal avantage est qu'en langage assembleur tous les éléments du programme sont représentés sous forme symbolique. Convertir les noms de commandes symboliques en leurs codes binaires sont affectés à programme spécial- assembleur, qui libère le programmeur d'un travail laborieux et élimine les erreurs inévitables.

Les noms symboliques introduits lors de la programmation en langage d'assemblage reflètent généralement la sémantique du programme et l'abréviation des commandes - leur fonction principale. Par exemple : PARAM - paramètre, TABLE - table, MASK - masque, ADD - addition, SUB - soustraction, etc. n. De tels noms sont facilement mémorisés par le programmeur.

Pour programmer en langage assembleur, vous devez avoir des outils que lors de la programmation en langage machine : vous avez besoin de systèmes informatiques basés sur des micro-ordinateurs ou des PC avec un ensemble périphériques(clavier alphanumérique, afficheur de caractères, lecteur de disquette et imprimante), ainsi que des systèmes de programmation résidente ou croisée pour les types de microprocesseurs requis. Le langage d'assemblage vous permet d'écrire et de déboguer efficacement des programmes beaucoup plus complexes que le langage machine (jusqu'à 1 à 4 Ko).

Les langages d'assemblage sont orientés machine, c'est-à-dire dépendants du langage machine et de la structure du microprocesseur correspondant, puisqu'ils attribuent un nom symbolique spécifique à chaque instruction du microprocesseur.

Les langages d'assemblage offrent une augmentation significative de la productivité des programmeurs par rapport aux langages machine et conservent en même temps la possibilité d'utiliser toutes les ressources matérielles accessibles par logiciel du microprocesseur. Cela permet aux programmeurs expérimentés d'écrire des programmes qui s'exécutent plus rapidement et occupent moins de mémoire que les programmes écrits dans un langage de haut niveau.

À cet égard, presque tous les programmes de contrôle de périphériques d'E / S (pilotes) sont écrits en langage d'assemblage, malgré la présence d'une gamme assez large de langages de haut niveau.

En utilisant le langage assembleur, le programmeur peut définir les paramètres suivants :

mnémonique (nom symbolique) de chaque commande du langage machine du microprocesseur ;

format standard des lignes d'un programme décrit en assembleur ;

format de spécification différentes manières options d'adressage et de commande ;

format pour spécifier les constantes de caractères et les constantes de type entier dans divers systèmes compte;

pseudo-commandes qui contrôlent le processus d'assemblage (traduction) du programme.

En langage assembleur, le programme est écrit ligne par ligne, c'est-à-dire qu'une ligne est allouée à chaque instruction.

Pour les micro-ordinateurs construits sur la base des types de microprocesseurs les plus courants, il peut exister plusieurs variantes de langage d'assemblage, cependant, on a généralement une distribution pratique - c'est ce qu'on appelle le langage d'assemblage standard

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 mettre en œuvre les actions requises en envoyant des instructions au matériel informatique.

Chaque instruction machine se compose de deux parties :

fonctionnement - déterminer "que faire" ;

· opérande - définissant les objets de traitement, "que faire avec".

L'instruction machine du microprocesseur, écrite en langage assembleur, est une seule ligne avec la forme syntaxique suivante :

label commande/directive opérande(s) ; commentaires

Dans ce cas, un champ obligatoire dans une ligne est une commande ou une directive.

L'étiquette, la commande/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, le caractère barre oblique inverse est utilisé : \.

Par défaut, le langage d'assemblage ne fait pas la distinction entre les lettres majuscules et minuscules dans les commandes ou les directives.

Adressage direct: L'adresse effective est déterminée directement par le champ de décalage d'instruction machine, qui peut avoir une taille de 8, 16 ou 32 bits.

mov eax, somme ; eax = somme

L'assembleur remplace sum par l'adresse correspondante stockée dans le segment de données (par défaut, adressée par le registre ds) et place la valeur stockée à l'adresse sum dans le registre eax.

adressage indirectà son tour a les types suivants:

Adressage de base indirect (registre);

Adressage de base indirect (registre) avec décalage ;

· adressage d'index indirect ;

· adressage indirect d'index de base.

Adressage de base indirect (registre). Avec cet adressage, l'adresse effective de l'opérande peut être dans n'importe lequel des registres usage général, sauf pour sp/esp et bp/ebp (ce sont des registres spécifiques pour travailler avec un segment de pile). Syntaxiquement dans une instruction, ce mode d'adressage s'exprime en mettant le nom du registre entre crochets.

déplacer eax, ; eax = *esi; *valeur esi à l'adresse esi

Structures en langage assembleur

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 est nécessaire de prendre en compte un certain ensemble de données type différent comme un seul type.

Ceci est très pertinent, 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 objet.

Par exemple, nous avons précédemment examiné le Listing 4, qui fonctionnait avec un tableau d'éléments de trois octets. Chaque élément, à son tour, était constitué de deux éléments de types différents : un champ de compteur d'un octet et un champ de deux octets pouvant contenir des informations supplémentaires 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 - structures.

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

A-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 faire trois choses :

Demander modèle de structure .

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

Définir exemple 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éder aux membres de la structure .

Il est très important que vous compreniez dès le début quelle est la différence entre description structures du programme et ses définition.

décrire la structure dans un programme signifie uniquement indiquer son schéma ou son modèle ; la mémoire n'est pas allouée.

Ce modèle ne peut être considéré que comme une information pour le traducteur sur l'emplacement des champs et leur valeur 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 dans le programme qu'une seule fois et la définir autant de fois que vous le souhaitez.

Description du modèle de structure

La déclaration du modèle de structure a la syntaxe suivante :

nom_structure STRUC nom_structure FIN

Ici est une séquence de directives de description de données db, dw, jj, dq Et dt.

Leurs opérandes déterminent la taille des champs et éventuellement des valeurs initiales. Ces valeurs vont éventuellement initialiser les champs correspondants lors de la définition de la structure.

Comme nous l'avons déjà noté lors de la description du modèle, aucune mémoire n'est allouée, car il ne s'agit que d'informations pour le traducteur.

Emplacement modèle dans le programme peut être arbitraire, mais, suivant la logique du traducteur à une passe, il doit être situé avant l'endroit où la variable avec le type de cette structure est définie. Autrement dit, lors de la description d'une variable avec le type d'une 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.

Envisagez 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 d'informations lors de la saisie, nous conviendrons 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, il est nécessaire de définir une variable avec le type de cette structure. La syntaxe suivante est utilisée pour cela :

[nom de variable] nom_structure

Nom de variable- identificateur de variable du type structurel donné.

La spécification d'un nom de variable est facultative. S'il n'est pas spécifié, 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.

Sa tâche est également facultative.

Si la liste est incomplète, tous les champs de la structure de la variable donnée 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 ​​​​dans son modèle (c'est-à-dire défini par défaut), alors il vous suffit d'écrire des crochets angulaires.

Par exemple: ouvrier vainqueur.

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

Méthodes structurées

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

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

adresse_expression- un identificateur de variable d'un certain type structurel ou une expression entre parenthèses conformément aux règles de syntaxe indiquées ci-dessous (Fig. 1) ;

structure_field_name- nom de 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.

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

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

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

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

Attention, car en raison du principe de stockage des données "octet bas à l'adresse basse" le chiffre le plus élevé de l'âge sera placé dans Al, et le plus jeune de Ah.

Pour le corriger, il suffit d'utiliser la commande xchg al, ah:

mov hache,mot ptr sotr1.age ;à tout âge sotr1

et c'est possible comme ça :

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

Comment gérer la taille et comment organiser l'indexation des éléments du tableau ?

Comme les autres identificateurs définis dans le programme, le traducteur attribue au nom du type de structure et au nom de la variable avec le type de structure un attribut de type. La valeur de cet attribut est la taille en octets occupée par les champs de cette structure. Vous pouvez extraire cette valeur en utilisant l'opérateur taper.

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

Par exemple:

Comment copier un champ d'une structure vers le champ correspondant d'une autre structure ? Ou comment copier la structure entière? 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 worker)*2 ;si=77*2 mov di,(type worker)*4 ;si=77*4

Il me semble que le métier de programmeur fait tôt ou tard 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 avec un minimum de nourriture. Et si cela réussit, alors la satisfaction morale n'est pas moindre, et peut-être plus, qu'un merveilleux dîner chez la 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 progrès dans le développement de logiciels et de matériel détendent quelque peu le programmeur, et il se produit assez souvent une situation similaire au proverbe bien connu sur la mouche et l'éléphant - pour résoudre un petit problème, des outils lourds sont impliqué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 dans le langage des deux types de données suivants est probablement due au désir 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 du placement des produits (données du programme ).

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. Représentation des données.

1.3.1 Types de données

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

2. Énoncés du programme de l'Assemblée ……………………………………………

1. Commandes en langage d'assemblage

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

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

3.1 Directives de définition des données

3.2 Structure du programme de montage

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 de transfert de données…………………………………………….

5.1 Commandes générales

5.2 Commandes de pile

5.3 Commandes E/S

5.4 Commandes de renvoi d'adresse

5.5 Commandes de transfert de drapeau

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

6.1 Opérations arithmétiques sur des 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. Quarts de travail et quarts de travail cycliques …………………………………………

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

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

10.1 Sauts inconditionnels

10.2 Sauts conditionnels

10.4 Procédures 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'attribution des fichiers

11.3 E/S disque

11.3.1 Ecriture d'un fichier sur disque

11.3.1.1 Données ASCIIZ

11.3.1.2 Numéro de dossier

11.3.1.3 Création d'un fichier disque

11.3.2 Lecture d'un fichier disque

Introduction

Le langage assembleur est une représentation symbolique du langage machine. Tous les processus d'un ordinateur personnel (PC) au niveau matériel le plus bas sont pilotés uniquement par des commandes en langage machine (instructions). Il est impossible de résoudre réellement des problèmes liés au matériel (ou même, d'ailleurs, des problèmes liés au matériel, comme l'amélioration de la vitesse d'un programme), sans connaissances en assembleur.

L'assembleur est une forme pratique de commandes directement destinées aux 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 assembleur.

Un élément de la préparation 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 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 de la programmation en langage assembleur pour les ordinateurs basés sur des microprocesseurs Intel.

Ce tutoriel s'adresse à tous ceux qui s'intéressent à l'architecture du processeur et aux bases de la programmation en langage assembleur, en premier lieu aux développeurs d'un produit logiciel.

Architecture PC.

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

Tous les ordinateurs modernes ont des propriétés architecturales 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 d'un ordinateur ;

moyens et méthodes d'accès aux éléments diagramme ORDINATEUR;

ensemble et disponibilité des registres ;

organisation et méthodes d'adressage;

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

un jeu d'instructions machine informatique;

formats d'instructions machine ;

interrompre la manipulation.

Les principaux éléments du matériel informatique: unité centrale, clavier, périphériques d'affichage, lecteurs de disque, périphériques d'impression (imprimante) et divers moyens de communication. Unité système se compose d'une carte mère, d'une alimentation et de cellules d'extension pour planches supplémentaires. La carte mère contient le microprocesseur, la 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 utilisateur, 16 système), plus ou moins disponibles à l'usage du programmeur. Étant donné que le manuel est consacré à la programmation du microprocesseur 8088-i486, il est plus logique de commencer ce sujet en discutant des 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 segment de 16 bits : CS, DS, SS, ES, FS, GS ;

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

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

Registres généraux.

EAX/AX/AH/AL (registre d'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 de données en mémoire.

ECX/CX/CH/CL - comptoir(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. Certaines commandes l'exigent.

Tous les registres de ce groupe permettent d'accéder à 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 chaîne qui permettent le traitement séquentiel de chaînes d'éléments d'une longueur de 32, 16 ou 8 bits, les éléments suivants sont utilisés :

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

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

L'architecture du microprocesseur au niveau matériel et logiciel prend en charge la structure des données - la pile. Pour travailler avec la pile, il existe des commandes spéciales et des registres spéciaux. Il convient de noter que la pile est remplie vers des adresses plus petites.

ESP/SP (registre de pointeur de pile) - enregistrer aiguille empiler. Contient un 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 un accès aléatoire aux données à l'intérieur de la pile.

1.1.2. registres de segments

Le modèle logiciel du microprocesseur comporte 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 spécifier les segments disponibles dans ce moment registres de segments. 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 (registre de segment de code) - registre de code de segment. Il contient l'adresse du segment d'instruction machine auquel le microprocesseur a accès.

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

Segment de pile. Ce segment est une région de mémoire appelée la pile. Le microprocesseur organise la pile selon le principe - le premier "venu", le premier "parti". Pour accéder à la pile, le registre SS (registre de segment de pile) est utilisé - registre de segment de pile A contenant l'adresse du segment de pile.

Segment de données supplémentaire. Les données à traiter peuvent se trouver 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 spéciaux de redéfinition de segment dans la commande. Les adresses des segments de données supplémentaires doivent être contenues dans les registres ES, GS, FS (registres de segments de données d'extension).

Registres de contrôle et d'état

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

Registre de pointeur de commande EIP/IP ;

Registre d'indicateurs EFLAGS/FLAGS.

À l'aide de 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 pointeur d'instruction) - aiguille commandes. 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 courant. Ce registre n'est pas directement accessible, mais il est modifié par des instructions de saut.

EFLAGS/FLAGS (Registre des drapeaux) - enregistrer 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 indicateur est un bit qui est défini sur 1 ("l'indicateur est défini") si une condition est remplie et sur 0 ("l'indicateur est effacé") dans le cas contraire. La partie inférieure de ce registre est complètement analogue au registre FLAGS du i8086.

1.1.3 Registre des drapeaux

Le registre de drapeau est de 32 bits et porte le nom EFLAGS (Fig. 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 de EFLAGS représentent le registre FLAGS 16 bits utilisé lors de l'exécution de programmes écrits pour les microprocesseurs i086 et i286.

Fig.1 Registre des drapeaux

Certains drapeaux sont appelés drapeaux 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 influencent le comportement ultérieur du processeur (par exemple, ils bloquent les interruptions).

Indicateurs d'état :

CF (porte drapeau) - porter le drapeau. Il prend la valeur 1 si, lors de l'addition d'entiers, une unité de retenue est apparue qui ne "rentrée" 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, le bit qui est hors réseau est entré dans le CF. CF corrige également les caractéristiques de l'instruction de multiplication.

OF (drapeau de débordement) indicateur de débordement. Il est mis à 1 si, lors de l'addition ou de la soustraction d'entiers avec un signe, le résultat a été obtenu, modulo dépassant la valeur autorisée (la mantisse a débordé et elle est "montée" dans le bit de signe).

ZF (drapeau zéro) drapeau zéro. Mis à 1 si le résultat de la commande est 0.

SF (drapeau de signe) - drapeau signe. Mis à 1 si l'opération sur les nombres signés donne un résultat négatif.

PF (drapeau de parité) - drapeau parité. Il est égal à 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 lors des opérations d'E/S.

AF (drapeau de portage auxiliaire) - drapeau de portage supplémentaire. Corrige les fonctionnalités d'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 balayage des lignes dans les commandes de chaîne : avec DF=0, les lignes sont balayées "vers l'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 d'E/S. 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âches. 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. Avec IF=0, le processeur cesse de répondre aux interruptions qui lui parviennent, avec IF=1, le blocage des interruptions est supprimé.

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

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

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

AC (vérification de l'alignement) - drapeau 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 mémoire de travail ( 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 d'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 microprocesseur prend en charge plusieurs modèles d'utilisation de la RAM dans le matériel :

modèle segmenté. Dans ce modèle, la mémoire du programme 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 liée à l'organisation mémoire virtuelle, ce qui permet aux programmes d'utiliser plus d'espace mémoire que la quantité de mémoire physique. Pour un microprocesseur Pentium, la taille de 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. Requis pour le fonctionnement des programmes conçus pour les premiers modèles de processeur.

Mode protégé. Le mode protégé permet le multitâche traitement d'informations, la protection de la mémoire à l'aide d'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 i8086. Dans ce cas, les programmes en mode réel peuvent fonctionner.

La segmentation est un mécanisme d'adressage qui assure l'existence de plusieurs espaces d'adressage indépendants. 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 composé d'un nombre quelconque de segments, mais il a un accès direct aux trois principaux : code, données et pile - et de un à trois segments de données supplémentaires. système opérateur place des segments de programme dans la RAM à certaines adresses physiques, après quoi il place les valeurs de ces adresses dans les registres correspondants. A l'intérieur d'un segment, le programme accède linéairement aux adresses relatives au début du segment, c'est-à-dire en commençant à l'adresse 0 et en terminant à 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 d'adresses physiques est de 0 à 1 Mo. La taille de segment maximale est de 64 Ko. Lorsqu'on fait référence à un adresse physique La RAM est déterminée par l'adresse du début du segment et le décalage dans le 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 inférieurs manquants de l'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 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 16 bits de cette cellule, comptée à partir de le début de ce segment mémoire (la valeur 16*segment +offset donne l'adresse absolue de la cellule). Si, par exemple, la valeur 1234h est stockée dans le registre CS, 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 mot double et (comme pour les nombres) sous une forme "inversée": le premier mot contient le décalage et le second - le segment, chacun de ces mots est à son tour représenté sous la forme "inversée" former. Par exemple, la paire 1234h:5678h s'écrirait comme ceci :| 78 | 56| 34 | 12|.

Ce mécanisme de formation d'une adresse physique vous permet de rendre le logiciel relocalisable, c'est-à-dire non dépendant d'adresses de téléchargement spécifiques dans la RAM.

Structure des instructions du langage d'assemblage La programmation au niveau des instructions machine est le niveau minimum auquel la programmation informatique est possible. Le système d'instructions de la machine doit être suffisant pour mettre en œuvre les actions requises en donnant des instructions au matériel de la machine. Chaque instruction machine se compose de deux parties : une partie opératoire qui définit « quoi faire » et un opérande qui définit les objets de traitement, c'est-à-dire « quoi faire ». L'instruction machine du microprocesseur, écrite en langage assembleur, est une ligne unique, ayant la forme suivante : étiquette instruction/instruction(s) opérande(s) ; commentaires L'étiquette, la commande/directive et l'opérande sont séparés par au moins un espace ou un caractère de tabulation. Les opérandes d'instruction sont séparés par des virgules.

Structure d'une instruction en langage assembleur Une instruction en langage assembleur indique au compilateur quelle action le microprocesseur doit effectuer. Les directives d'assemblage 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 spécifie la valeur initiale des données (dans le segment de données) ou les éléments sur lesquels l'instruction doit agir (dans le segment de code). Une instruction peut avoir un ou deux opérandes, ou aucun opérande. Le nombre d'opérandes est spécifié implicitement par le code d'instruction. Si la commande ou la directive doit être poursuivie sur la ligne suivante, le caractère barre oblique inverse est utilisé : "" . Par défaut, l'assembleur ne fait pas la distinction entre les lettres majuscules et minuscules dans les commandes et les directives. Exemples de directives et de commandes 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és pour désigner des noms de variables et des noms d'étiquettes. L'identifiant peut être composé d'un ou plusieurs des caractères suivants : toutes les lettres de l'alphabet latin ; chiffres 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 commande) ne peuvent pas être utilisés comme identificateurs. 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 caractères et ignore le reste. Toutes les étiquettes écrites sur 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 commencer à une position particulière dans la chaîne. Il est recommandé de les écrire dans une colonne pour une plus grande lisibilité du programme.

Étiquettes Toutes les étiquettes écrites sur 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 commencer à une position particulière dans la chaîne. Il est recommandé de les écrire dans une colonne pour une plus grande lisibilité du programme.

Commentaires L'utilisation de commentaires dans un programme améliore sa clarté, en particulier lorsque le but d'un ensemble d'instructions n'est pas clair. Les commentaires commencent sur n'importe quelle ligne d'un module source par un point-virgule (;). Tous les caractères à droite de " ; ' à la fin de la ligne sont des commentaires. Le commentaire peut contenir n'importe quel caractère imprimable, y compris "l'espace". Le commentaire peut s'étendre sur toute la ligne ou suivre la commande sur la même ligne.

Structure d'un programme en langage assembleur Un programme en langage assembleur peut être composé de plusieurs parties, appelées modules, chacune pouvant définir un ou plusieurs segments de données, de pile et de code. Tout programme complet en langage assembleur doit inclure un module principal, ou principal, à partir duquel son exécution commence. Un module peut contenir des segments de programme, de données et de pile déclarés avec les 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 modifier memory_model, calling_convention, OS_type, stack_parameter Modèles de mémoire en langage assembleur de base : Modèle de mémoire Adressage de code Adressage de données Système d'exploitation Entrelacement de code et de données TINY NEAR MS-DOS Valid SMALL NEAR MS-DOS, Windows Non MEDIUM FAR NEAR MS-DOS, Windows Non COMPACT NEAR FAR MS-DOS, Windows Non LARGE FAR MS-DOS, Windows Non HUGE FAR MS-DOS, Windows Non NEAR Windows 2000, Windows XP, Windows Valid 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 le code résident dans un seul segment physique. La taille du fichier programme dans ce cas 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 lors de l'utilisation de ce modèle sont traités comme proches (near). 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 (loin) par défaut, et les liens dans le segment de données sont considérés comme proches (proche). Le modèle compact prend en charge plusieurs segments de données qui utilisent l'adressage des données distantes (far) et un segment de code qui utilise l'adressage des données proches (near). 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 loin. 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 petit modèle en ce sens que les données et le code résident dans le même segment 32 bits. Développer un programme pour le modèle plat avant la directive. appartement modèle doit placer l'une des directives : . 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 modifier memory_model, calling_convention, OS_type, stack_parameter Le paramètre modifier est utilisé pour définir les types de segment et peut prendre les valeurs suivantes : use 16 (les segments du modèle sélectionné sont utilisés en 16 bits) use 32 (les segments du modèle sélectionné sont utilisés comme 32 bits). Le paramètre calling_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. MODÈLE modificateur memory_model, calling_convention, OS_type, stack_parameter Le paramètre OS_type est OS_DOS par défaut et est actuellement la seule valeur prise en charge pour ce paramètre. Le paramètre stack_param est défini sur : NEARSTACK (le registre SS est égal à DS, les régions 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 régions 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. DONNÉES. CODE DEBUT : RET FIN DEBUT RET - commande du microprocesseur. Il assure la fin correcte du programme. Le reste du programme est lié au fonctionnement du traducteur. . 686 P - 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. . MODEL FLAT, stdcall - modèle de 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 à utiliser.

Un exemple de programme "ne rien faire". 686 P. MODÈLE PLAT, STDCALL. DONNÉES. CODE DEBUT : RET FIN DEBUT . DATA - segment de programme contenant des données. Ce programme n'utilise pas la pile, donc segment. STACK est manquant. . CODE - un segment du programme contenant le code. DÉMARRER - é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 qui marque la fin du code source du programme. Toutes les lignes qui suivent la directive END sont ignorées. L'étiquette après la directive END indique au compilateur le nom du module principal à partir duquel l'exécution du programme commence. 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 A 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 d'instructions machine, chaque traducteur possède son propre ensemble de directives et de macros, souvent incompatibles avec quoi que ce soit d'autre. Les principaux types de traducteurs de langage d'assemblage sont : MASM (Microsoft Assembler), TASM (Borland Turbo Assembler), FASM (Flat Assembler) - un assembleur multi-passes librement distribué écrit par Tomasz Gryshtar (polonais), NASM (Netwide Assembler) - un L'assembleur libre pour l'architecture Intel x 86 a été créé par Simon Tatham avec Julian Hall et est actuellement développé par une petite équipe de développement chez Source. Forger. filet.

Src="https://present5.com/presentation/-29367016_63610977/image-15.jpg" alt="Traduction du programme dans Microsoft Visual Studio 2005 1) Créez un projet en sélectionnant Fichier->Nouveau->Projet MenuEt"> Трансляция программы в Microsoft Visual Studio 2005 1) Создать проект, выбрав меню File->New->Project и указав имя проекта (hello. prj) и тип проекта: Win 32 Project. В дополнительных опциях мастера проекта указать “Empty Project”.!}

Src="https://present5.com/presentation/-29367016_63610977/image-16.jpg" alt="Program translation in Microsoft Visual Studio 2005 2) Dans l'arborescence du projet (View->Solution Explorer) 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éfinir les options du compilateur. Sélectionnez sur le bouton droit dans le menu du fichier de projet Custom Build Rules…

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

Traduction du programme en Microsoft Visual Studio 2005 Vérifier par le bouton droit dans le fichier bonjour. asm de l'arborescence du projet dans le 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="Program translation in Microsoft Visual Studio 2005 6) Compilez le fichier en sélectionnant 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 OS Windows repose 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 périphériques externes et les ressources du système d'exploitation se produit, en règle générale, à travers ces fonctions. salle d'opération Système Windows utilise un modèle de mémoire plate. L'adresse de n'importe quel emplacement de 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 : boîte de dialogue (la fenêtre principale est une boîte de dialogue), structure console ou sans fenêtre, structure classique (fenêtre, cadre).

Appel Fonctionnalités 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 – type de valeur de retour ; FAX – liste des arguments formels dans leur ordre. Par exemple, int Message. Boîte (HWND h. Wnd, LPCTSTR lp. Text, LPCTSTR lp. Caption, UINT u. Type); Cette fonction affiche une fenêtre avec un message et un ou plusieurs boutons de sortie. Signification des paramètres : h. Wnd - handle de 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 - texte dans le titre de la fenêtre, u. Type - type de fenêtre, en particulier, vous pouvez spécifier le nombre de boutons de sortie.

Appel des fonctions de l'API Windows dans Message. Boîte (HWND h. Wnd, LPCTSTR lp. Text, LPCTSTR lp. Caption, UINT u. Type); Presque tous les paramètres de la fonction API sont en fait des entiers 32 bits : HWND est un entier 32 bits, LPCTSTR est un pointeur de chaîne 32 bits, UINT est un entier 32 bits. Le suffixe "A" est souvent ajouté au nom des fonctions pour accéder aux versions plus récentes des fonctions.

Appel des fonctions de l'API Windows dans Message. Boîte (HWND h. Wnd, LPCTSTR lp. Text, LPCTSTR lp. Caption, 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. Pour appeler une fonction, l'instruction CALL de l'assembleur est utilisée. 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. L'argument u sera d'abord poussé sur la pile. taper. L'appel de la fonction spécifiée ressemblera à ceci : CALL Message. boîte. [courriel protégé]

Appel des fonctions de l'API Windows dans Message. Boîte (HWND h. Wnd, LPCTSTR lp. Text, LPCTSTR lp. Caption, UINT u. Type); Le résultat de l'exécution de toute fonction API est généralement un nombre entier, qui est renvoyé dans le registre EAX. La directive OFFSET est un "décalage de segment" ou, en termes de langage de haut niveau, un "pointeur" vers le début d'une chaîne. La directive EQU, comme #define en C, définit une constante. La directive EXTERN indique au compilateur qu'une fonction ou un identifiant est externe au module.

Un exemple du programme "Bonjour tout le monde!" . 686 P. MODÈLE PLAT, STDCALL. PILE 4096. DATA MB_OK EQU 0 STR 1 DB "Mon premier programme", 0 STR 2 DB "Bonjour à tous !", 0 HW DD ? Message EXTERNE. boîte. [courriel protégé]: PRÈS. CODE START : APPUYEZ SUR MB_OK APPUYEZ SUR OFFSET STR 1 APPUYEZ SUR OFFSET STR 2 APPUYEZ Message APPEL HW. boîte. [courriel protégé] RET FIN DEBUT

La directive INVOKE Le traducteur de langage MASM permet également de simplifier l'appel de fonction à l'aide d'un outil macro - la directive INVOKE : fonction INVOKE, paramètre1, paramètre2, ... Il n'est pas nécessaire d'ajouter @16 à l'appel de fonction ; les paramètres sont écrits exactement dans l'ordre où ils sont donnés dans la description de la fonction. les macros de traduction poussent les paramètres sur la pile. pour utiliser la directive INVOKE, vous devez avoir une description du prototype de la fonction utilisant la directive PROTO sous la forme : Message. boîte. UN PROTO : DWORD, : DWORD