Les procédures

Ce document couvre les notions fondamentales des procédures en langage assembleur, leur appel, la gestion de la pile, ainsi que des méthodes de programmation et des exemples pratiques. Il s'adresse aux étudiants en architecture des microprocesseurs et en programmation bas niveau souhaitant comprendre la structure, l'exécution et la gestion des sous-programmes.

Les procédures et l’appel de sous-programmes

Pour éviter la répétition d’une même séquence d’instructions dans un programme, on utilise des sous-programmes ou procédures. Une procédure est une séquence d’instructions nommée, appelée par le programme principal lorsqu’elle est nécessaire.

Une procédure peut être de type NEAR si elle se trouve dans le même segment que le programme principal, ou de type FAR si elle est dans un autre segment.

L’appel d’une procédure se fait par l’instruction :

CALL procédure

Lors de l’exécution de CALL, le pointeur d’instruction IP est chargé avec l’adresse de la première instruction du sous-programme. Avant cela, l’adresse de retour (l’adresse de l’instruction suivant le CALL) est sauvegardée dans la pile. À la fin de la procédure, l’instruction RET récupère cette adresse dans la pile et la recharge dans IP pour reprendre l’exécution du programme principal.

La pile

La pile est une zone mémoire fonctionnant en mode LIFO (Last In First Out : dernier entré, premier sorti). Elle permet de sauvegarder temporairement des données, notamment l’adresse de retour lors d’un appel de procédure.

• Empiler : placer une donnée au sommet de la pile.
• Dépiler : lire la donnée au sommet de la pile.

Le sommet de la pile est repéré par le registre SP (Stack Pointer), qui contient l’adresse de la dernière donnée empilée. La pile est située dans un segment dont l’adresse est contenue dans le registre SS (Stack Segment).

Remarque importante : la pile et le programme croissent en sens inverse pour réduire le risque de collision, notamment si la pile est dans le même segment que le code (SS = CS).

Lors d’un appel de procédure, l’adresse de retour est empilée et SP est décrémenté automatiquement. À la fin de la procédure, RET dépile cette adresse pour la recharger dans IP, et SP est incrémenté.

Utilisation de la pile pour sauvegarder des registres

La pile peut aussi servir à sauvegarder le contenu de registres non sauvegardés automatiquement lors d’un appel :

• PUSH opérande : empile un registre ou une donnée de 16 bits.
• POP opérande : dépile dans un registre ou une donnée de 16 bits.

Le pointeur de pile SP doit être initialisé par le programme principal avant toute utilisation de la pile.

Passage de paramètres via la pile

Pour transmettre des paramètres à une procédure, on place ces paramètres sur la pile avant l’appel. La procédure les récupère ensuite en utilisant un adressage basé sur la pile avec le registre BP (Base Pointer).

Exemple de procédure somme

Voici un exemple simple d’une procédure qui calcule la somme de deux nombres passés en paramètres sur la pile et retourne le résultat dans AX :

; Programme principal
PUSH param1
PUSH param2
CALL somme

; Procédure somme
somme PROC NEAR
  MOV AX, [BP+4]  ; premier paramètre
  ADD AX, [BP+6]  ; deuxième paramètre
  RET 4           ; retourne et dépile 4 octets (2 paramètres de 2 octets chacun)
somme ENDP

L’instruction RET 4 permet de retourner au programme principal et d’incrémenter SP de 4 pour dépiler les paramètres, remettant la pile dans son état initial.

Méthodes de programmation

La réalisation d’un programme suit plusieurs étapes :

• Définir précisément le problème à résoudre.
• Élaborer des algorithmes ou organigrammes pour planifier la solution.
• Rédiger le code source en utilisant le jeu d’instructions (mnémoniques) et documenter le programme.
• Tester le programme en conditions réelles.
• Corriger les erreurs (déboguer) et répéter les tests jusqu’à obtenir un programme fonctionnel.

Le langage machine est constitué de codes binaires correspondant aux instructions, tandis que l’assembleur est un logiciel qui traduit le code source en langage assembleur (mnémoniques) en langage machine.

Réalisation pratique

• Rédaction du code source avec un éditeur de texte ASCII (ex. : edit sous MS-DOS, notepad sous Windows).
• Assemblage du code source avec un assembleur (ex. : MASM, TASM, A86) pour obtenir le code objet exécutable.
• Chargement en mémoire centrale et exécution par le système d’exploitation ou un moniteur.

Pour le débogage, on peut utiliser des outils comme DEBUG sous MS-DOS, qui permettent :

• L’exécution pas à pas.
• La visualisation des registres et de la mémoire.
• La pose de points d’arrêt.

Structure d’un fichier source en assembleur

Pour faciliter la lisibilité, le code source est organisé clairement avec des sections distinctes, des commentaires et une indentation adaptée.

Exemples d’exercices et solutions

Exercice 1 : Évolution des registres

Déterminer le contenu des registres AX, BX, CX et DX après chaque instruction, sachant les valeurs initiales :

• DX = 4532H
• CX = 1BCEH
• AX = 9897H
• BX = 5678H
• La pile contient 1F8BH

Instructions :

OR BX,FFFFH      ; BX = FFFFH
PUSH BX          ; empile BX
XOR AX,AX        ; AX = 0
AND DX,0000H     ; DX = 0
MOV AX,000EH     ; AX = 000EH
MUL BL           ; AX = AX * BL (BL partie basse de BX)
POP CX           ; dépile dans CX
PUSH AX          ; empile AX
POP DX           ; dépile dans DX
OR BX,0100H      ; BX = FFFFH (reste inchangé)

Exercice 2 : Manipulation de tables

Soit la table TAB1 définie par (9A, 82, 30, F5, 54, C0, 65, 71, 80, 93). Écrire des procédures :

• RECHERCHE : chercher la valeur 54 dans TAB1 et la supprimer si elle existe.
• INVERSION : inverser les quartets de chaque valeur de TAB1 et stocker en ordre inverse dans TAB2 (39, 08, 17, 57, 0C, 45, 5F, 03, 28, A9).
• PARITE : séparer TAB1 en deux tables TAB3 (éléments pairs) et TAB4 (éléments impairs).

Solution RECHERCHE

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

Solution INVERSION

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

Solution PARITE

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

Exercice 3 : Affichage et calcul

Soit TAB1 contenant (62, FF, 2D, 4C, 3F, F3, 15, 50, 7D). Écrire un programme principal appelant :

• Une procédure CHAINE affichant la chaîne « la somme des termes est : »
• Une procédure SOMME calculant la somme des éléments de TAB1.
• Une procédure DIVISION mettant ce résultat dans TAB2.
• Une procédure AFFICHAGE affichant caractère par caractère le résultat.

Trois versions sont proposées : sans pile, sans procédures, et avec procédures et pile.

Exercice 4 : Affichage conditionnel selon le caractère tapé

Écrire un programme affichant :

• « il s’agit d’une lettre : … » si le caractère est une lettre (minuscule ou majuscule)
• « il s’agit d’un chiffre : … » si le caractère est un chiffre (0 à 9)
• « il s’agit d’un symbole : … » pour les autres caractères

Le nombre de caractères tapés n’est pas imposé. Le programme utilise les interruptions DOS int 21 avec les fonctions 06, 02 et 09.

Glossaire des termes clés

• Procédure / Sous-programme : séquence d’instructions nommée appelée par le programme principal pour éviter la répétition.
• CALL : instruction d’appel d’une procédure.
• RET : instruction de retour d’une procédure, récupérant l’adresse de retour dans la pile.
• Pile (Stack) : zone mémoire fonctionnant en LIFO, utilisée pour sauvegarder les adresses de retour et données temporaires.
• SP (Stack Pointer) : registre contenant l’adresse du sommet de la pile.
• SS (Stack Segment) : registre contenant l’adresse du segment de la pile.
• PUSH : instruction pour empiler une donnée ou un registre sur la pile.
• POP : instruction pour dépiler une donnée ou un registre de la pile.
• BP (Base Pointer) : registre utilisé pour accéder aux paramètres passés via la pile.
• Langage machine : code binaire directement interprété par le microprocesseur.
• Assembleur : logiciel traduisant le code source en langage assembleur en langage machine.
• Débogage : processus de recherche et correction des erreurs dans un programme.

Points clés à retenir

• Les procédures permettent de structurer un programme et d’éviter la répétition de code.
• L’appel d’une procédure sauvegarde l’adresse de retour dans la pile, assurant la reprise correcte du programme principal.
• La pile fonctionne en LIFO et est gérée par les registres SP et SS.
• Les instructions PUSH et POP permettent de sauvegarder et restaurer des registres ou données sur la pile.
• Le passage de paramètres aux procédures se fait souvent via la pile, avec un adressage basé sur BP.
• Le développement en assembleur nécessite une rédaction claire du code source, un assemblage, un chargement en mémoire et un débogage rigoureux.
• Les exercices pratiques illustrent la manipulation des registres, des piles, des tables et la gestion des procédures en assembleur.