Les procédures

Appel de sous-programmes : pour éviter la répétition d’une même séquence

d’instructions plusieurs fois dans un programme, on rédige la séquence une seule fois

en lui attribuant un nom et on l’appelle lorsqu’on en a besoin. Le programme appelant

est le programme principal. La séquence appelée est un sous-programme ou procédure.

Ecriture d’un sous-programme :

Remarque : une procédure peut être de type NEAR si elle se trouve dans le même

segment ou de type FAR si elle se trouve dans un autre segment.

Exemple :

Appel d’un sous-programme par le programme principal : CALL procédure

Cours Architecture & µprocesseur

Lors de l’exécution de l’instruction CALL, le pointeur d’instruction IP est chargé avec

l’adresse de la première instruction du sous-programme. Lors du retour au programme

appelant, l’instruction suivant le CALL doit être exécutée, càd que IP doit être rechargé

avec l’adresse de cette instruction.

Avant de charger IP avec l’adresse du sous-programme, l’adresse de retour au

programme principal, càd le contenu de IP, est sauvegardée dans une zone mémoire

particulière appelée pile.

Lors de l’exécution de l’instruction RET, cette adresse est récupérée à partir de la pile et

rechargée dans IP, ainsi le programme appelant peut se poursuivre.

Cours Architecture & µprocesseur

La pile

Fonctionnement de la pile : la pile est une zone mémoire fonctionnant en mode LIFO

(Last In First Out : dernier entré, premier sorti). Deux opérations sont possibles sur la

pile :

 empiler une donnée : placer la donnée au sommet de la pile ;

 dépiler une donnée : lire la donnée se trouvant au sommet de la pile.

Le sommet de la pile est repéré par un registre appelé pointeur de pile (SP : Stack

Pointer) qui contient l’adresse de la dernière donnée empilée.

La pile est définie dans le segment de pile dont l’adresse de départ est contenue dans le

registre SS (Stack Segment, registre de segment de pile).

Cours Architecture & µprocesseur

Remarque : la pile et le programme croissent en sens inverse pour diminuer le risque de

collision entre le code et la pile dans le cas où celle-ci est placée dans le même segment

que le code (SS = CS).

Lors de l’appel à un sous-programme, l’adresse de retour au programme appelant

(contenu de IP) est empilée et le pointeur de pile SP est automatiquement décrémenté.

Au retour du sous-programme, le pointeur d’instruction IP est rechargé avec la valeur

contenue sommet de la pile et SP est incrémenté.

Cours Architecture & µprocesseur

La pile peut également servir à sauvegarder le contenu de registres qui ne sont pas

automatiquement sauvegardés lors de l’appel à un sous programme :

 instruction d’empilage : PUSH opérande

 instruction de dépilage : POP opérande

où opérande est un registre ou une donnée sur 2 octets (on ne peut empiler que des

mots de 16 bits).

Exemple :

Remarque : la valeur du pointeur de pile (SP) doit être initialisée par le programme

principal avant de pouvoir utiliser la pile.

Utilisation de la pile pour le passage de paramètres : pour transmettre des paramètres à une

procédure, on peut les placer sur la pile avant l’appel de la procédure, puis celle-ci les

récupère en effectuant un adressage basé de la pile en utilisant le registre BP.

Cours Architecture & µprocesseur

Exemple : soit une procédure effectuant la somme de deux nombres et retournant le

résultat dans le registre AX .

 programme principal :

 procédure somme :

Cours Architecture & µprocesseur

L’instruction ret 4 permet de retourner au programme principal et d’incrémenter le

pointeur de pile de 4 unités pour dépiler les paramètres afin de remettre la pile dans son

état initial.

 Etat de la pile :

Cours Architecture & µprocesseur

Méthodes de programmation

Etapes de la réalisation d’un programme :

 Définir le problème à résoudre : que faut-il faire exactement ?

 Déterminer des algorithmes, des organigrammes : comment faire? Par quoi

commencer, puis poursuivre ?

 Rédiger le programme (code source) :

utilisation du jeu d’instructions (mnémoniques) ;

création de documents explicatifs (documentation).

 Tester le programme en réel ;

 Corriger les erreurs (bugs) éventuelles : déboguer le programme puis refaire des

tests jusqu’à obtention d’un programme fonctionnant de manière satisfaisante.

Langage machine et assembleur :

 Langage machine : codes binaires correspondant aux instructions ;

 Assembleur : logiciel de traduction du code source écrit en langage assembleur

(mnémoniques).

Cours Architecture & µprocesseur

Réalisation pratique d’un programme :

 Rédaction du code source en assembleur à l’aide d’un éditeur (logiciel de

traitement de texte ASCII) :

edit sous MS-DOS,

notepad (bloc-note) sous Windows,

 Assemblage du code source (traduction des instructions en codes binaires) avec

un assembleur :

MASM de Microsoft,

TASM de Borland,

A86 disponible en shareware sur Internet, ...

pour obtenir le code objet : code machine exécutable par le microprocesseur ;

 Chargement en mémoire centrale et exécution : rôle du système d’exploitation ou

d’un moniteur (carte de développement à base de microprocesseur).

Pour la mise au point (débogage) du programme, on peut utiliser un programme d’aide

À la mise au point (comme DEBUG sous MS-DOS) permettant :

l’exécution pas à pas;

la visualisation du contenu des registres et de la mémoire ;

la pose de points d’arret …

Cours Architecture & µprocesseur

Structure d’un fichier source en assembleur :

Pour faciliter la lisibilité du code source en assembleur, on le rédige sous la forme

Cours Architecture & µprocesseur

Exercice 1

Déterminer le contenu des registres AX, BX, CX et DX dans chaque ligne de

la séquence d’instructions ci-dessous sachant que ces registres contiennent

initialement les valeurs suivantes :

DX=4532H

CX=1BCEH

AX=9897H BX=5678H

La pile contient une seule valeur = 1F8BH

OR BX,FFFFH

BX=FFFFH

PUSH BX

SS=FFFFH

XOR AX,AX

AX=0

AND DX,0000H

DX=0

MOV AX,000EH

AX=000Eh

MUL BL

AX=0DF2h

POP CX

CX=FFFFh

PUSH AX

SS=0DF2h

POP DX

DX=0DF2h

OR BX,0100H

BX=FFFFh

Cours Architecture & µprocesseur

Exercice 2

Soit la table TAB1 définit par (9A, 82, 30, F5, 54, C0, 65, 71, 80,

93) :

Ecrire un programme faisant appel à :

•Une procédure RECHERCHE qui permet de chercher la

valeur 54 dans TAB1 si elle existe et de la supprimer.

•Une procédure INVERSION qui permet l’inversion des

quartets de chaque valeur de la table TAB1 et de les

stocker en ordre inverse dans une autre table TAB2, (39,

08, 17, 57 0C, 45, 5F, 03, 28, A9).

•Une procédure PARITE qui permet de partager TAB1

en deux tables TAB3 et TAB4. La première doit contenir

les éléments pairs. La deuxième doit contenir les éléments

impairs.

Cours Architecture & µprocesseur

Solution

Recherche proc near

Mov ax,0

Mov si,0

Mov bx,offset tab1

L2: mov al,[bx+si]

Cmp al,54h

Jne l1

Mov al,[bx+si+1]

Mov [bx+si],al

L1: inc si

Cmp si,10

Jne l2

Ret

Recherche endp

inversion proc near

Mov ax,0

Mov si,0

Mov di,10

Mov cl,4

Lea bx,tab1

Lea bp,tab2

L1: mov al,[bx+si]

Ror al,cl

Mov [bp+di],al

Inc si

Dec di

Cmp si,10

Jne l1

ret

inversion endp

Cours Architecture & µprocesseur

Solution

Parité proc near

Mov ax,0

Mov si,0

Mov di,offset tab3

Mov bp, offset tab4

Mov bx,offset tab1

Mov cl,2

L3: mov al,[bx+si]

Div cl

Cmp ah,0

Jne l1

Mov [bp],al

Inc bp

Jmp l2

L1: mov [di],al

Inc di

L2: Inc si

Cmp si,10

Jne l3

Ret

Parité endp

Cours Architecture & µprocesseur

Exercice 3

Soit la table TAB1 contenant les valeurs suivantes (62, FF,

2D,4C,3F,F3,15,50,7D) :

Ecrire un programme principal faisant appel à :

•une procédure CHAINE qui permet d’afficher la chaine

de caractères suivante : « la somme des termes est : »

•une procédure SOMME qui permet de calculer la somme

des éléments de TAB1.

•une procédure DIVISION qui permet de mettre ce

résultat dans une table TAB2.

•une procédure AFFICHAGE qui permet l’affichage

caractère par caractère le résultat de la somme.

Cours Architecture & µprocesseur

Solution: Version 1 : Procédures sans pile

Cours Architecture & µprocesseur

Solution: Version 1 : Procédures sans pile

Cours Architecture & µprocesseur

Solution: Version 2 : sans procédures mais avec pile

Cours Architecture & µprocesseur

Solution: Version 3 : procédures ET pile

Cours Architecture & µprocesseur

Solution: Version 3 : procédures ET pile

Cours Architecture & µprocesseur

Exercice 4

Ecrire un programme qui affiche sur écran trois messages :

Mess1 « il s’agit d’une lettre :… » si le caractère tapé est une lettre

(minuscule ou majuscule)

Mess2 « il s’agit d’un chiffre :… »si le caractère tapé est un chiffre

(0….9)

Mess 3 »il s’agit d’un symbole :… » pour le reste des caractère

N.B :

*Le nombre de fois n de taper un caractère n’est pas imposé c’est à eux

de choisir le n

*dans ce programme, ils manipulent int 21 avec les fonctions 06, 02 et

09.

Cours Architecture & µprocesseur

Solution

Cours Architecture & µprocesseur