Langage assembleur procédures et programmation structurée

Langage assembleur

Procédures et programmation structurée

Pour pouvoir utiliser les procédures en assembleur, nous utiliserons
CALL maProcedure
maProcedure PROC
..
RET
maProcedure ENDP
Langage assembleur – 1ère – PBT
Remarque
Il est clair que ceci est un raccourci !
Nous vous donnons ici uniquement la base afin de pouvoir utiliser les procédures dans vos projets de laboratoires. Les explications plus détaillées suivent dans le cours.

La pile du 80×86

• Une PILE est une structure de données permettant de mémoriser des informations.
• LIFO versus FIFO
– LIFO (Last In First Out) Peut être simulée par une pile d ’assiettes; on empile et on désempile une assiette.
– FIFO (First In First Out) Peut être simulée par une file d ’attente au guichet. « Premier arrivé, premier servi » !
Remarque
La notion de structure de données sera pleinement développée dans d ’autres cours. Ce qu’il faut savoir c’est que, lorsque l ’on veut écrire un programme, il faut s ’attacher à deux choses:
– La structure des données.
– L ’algorithme permettant de traiter ces données.
Tout l ’art (!) de la programmation consiste à regrouper ces deux points. La structuration des données sert, quant à elle, à faire le lien entre les données abstraites d ’un problème et leur représentation « binaire ».
L ’objet de ce cours n ’est pas de traiter des piles, files et autres types abstraits, sachez seulement que le type abstrait pile permet notamment l’écriture de programmes récurcifs.
• Le 80×86 possède une pile LIFO
– SS:SP sont les registres de segment (SS) et d ’offset (SP) permettant d ’accéder aux éléments de la pile.
– .STACK est la directive permettant de fixer la taille de la pile.
– PUSH op et POP op sont les instructions permettant d ’empiler et désempiler un opérande.

Directive .STACK et adresse de la pile

Cette directive précise la taille de la pile: .STACK 100h, réserve une pile de 100h=256d bytes.
La pile est initialisée par le compilateur. Le système fournit donc l ’adresse SS:SP qui est l ’adresse du dernier élément empilé.
• SS est une valeur attribuée par le SE lorsqu’il charge le programme en mémoire.
• SP contient, lors de l’initialisation, la taille de la pile (100h par exemple). Les éléments sont donc empilés « à l ’envers » sur la pile.
Lorsque j ’empile un premier élément d ’un word, SP=0FEh.
(Je décrémente de 2 le pointeur de pile1)
A l ’inverse, lorsque je désempile un word, j ’incrémente le pointeur de pile de deux.
____________________
1 Pointeur de pile = Stack Pointeur = SP
Instruction PUSH
• Syntaxe : PUSH op
• But : empile op. Place le contenu de op sur la pile.
op doit être au WORD ou DWORD
• Opérande : op peut-être :
– Registre : PUSH AX
PUSH EBX
– Mémoire : PUSH word ptr [BX+SI]
– Flags : PUSHF – PUSHFD (386)
– Tout (286) : PUSHA – PUSHAD
Remarque
• L ’opérande doit être au minium un word. Je peux donc, si je défini une pile de 256 bytes empiler 128 mots … ou 54 doubles ou …
• PUSHa
L ’instruction PUSHa (all) empile les registres : AX, BX, CX, DX ainsi que les registres SP, BP, SI, et DI.
Dans le cas de l ’instruction PUSHad, ce sont les registres étendus correspondants qui sont empilés.
• Lorsqu’une instruction (ou une caractéristique) est disponible à partir d ’un processeur particulier, il faut le signaler au compilateur à l ’aide de la directive appropriée; .286, .386 ou .486.
Instruction POP
• Syntaxe : POP op
• But : dépile op. Place le contenu du sommet de la pile dans op.
• Opérande : op peut-être :
– Registre : POP AX
POP EBX
– Mémoire : POP word ptr [BX+SI]
– Flags : POPF – POPFD (386)
– Tout (286) : POPA – POPAD
PUSH CS est autorisé … mais pas POP CS … normal !
Exemples
• PUSH BX
• PUSH word ptr[DI]
• POP EAX
• La pile du 80×86 est de type LIFO. Quel est le résultat des opérations suivantes ?
PUSH AX
PUSH BX
POP AX
POP BX
Les contenus des registres AX et BX sont échangés, ceci est équivalent à :
MOV CX,AX
MOV AX,BX
MOV BX,CX
dans le premier cas, je fais l’économie d ’un registre.

Complément tableaux

Vecteur – Tableau à une dimension • Déclaration
v1 DB a,b,c,d,e,f
v2 DB 10 DUP (?)
• Exemples d ’utilisation
MOV AL,v1[0] AL <- a
MOV BX,offset v1
MOV AL,[BX+2] AL <- c
MOV SI,2
MOV AL,[BX+SI-1] AL <- b

Utilisation

Lorsque l ’on travaille en mode graphique, les vecteurs sont utilisés, par exemple, pour stocker des coordonnées de points. Exemple; supposons que l ’on veuille dessiner 6 carrés de coté 20 pixels à l ’écran (en mode vidéo 12h) aux positions (0,0), (0,20),(0,40),(20,0),(20,20) et (20,40). Si l ’on suppose l ’existence d ’une procédure carré dessinant un carré de coté 20 à l ’écran à la position DX,DL, on peut écrire le morceau de code suivant :
.data
COTE EQU 20
NOMBRE EQU 6
positions DB 0,0,0,20,0,40,20,0,20,20,20,40
…
.code
…
MOV SI,0
repeter:
MOV DX,word ptr positions[SI]
CALL carre
ADD SI,2
frepeter:
CMP SI,2*NOMBRE
JB repeter
…
Tableau à deux dimensions
• Pour représenter un tableau de taille nxm, je réserve n*m bytes (ou word ..).
N EQU 12
M EQU 32
tableau DB N*M DUP (?)
• J ’accède à l ’élément (i,j) :
MOV SI,i
MOV DI,j
MOV AL,tableau[SI*M+DI]

Procédures

Vue minimaliste
Le 80×86 permet la gestion des procédures …
dans une vue minimaliste, cela se résume en deux instructions :
CALL label
RET
Langage assembleur – 1ère – PBT
Rappel
En logique de programmation, une approche top down d ’un problème demande de modulariser l ’algorithme. On aura par exemple :
ACTION
instructions
maFonction() ; appel de la fonction
instructions
maFonction() ; appel de la fonction
instructions
FIN ACTION
; définition de la fonction maFonction MODULE maFonction ()
instructions
FIN MODULE

L ’instruction CALL label

Cette instruction est un branchement à l ’adresse marquée par label.
Traitement de l ’instruction :
– PUSH CS:IP, l ’adresse de l ’instruction suivante est placée sur la pile.
– CS:IP reçoit l’adresse marquée par label.
L ’instruction exécutée après le ‘call’ est celle en position label. (saut)
Exemple
Je place dans l ’exemple des numéros de lignes pour faciliter l ’explication.
Cet exemple ne contient que la partie du code qui nous intéresse.
(1) ; Exemple de « procédure » servant à l ’affichage d ’une
(2) ; chaîne de caractères
(3) MOV DX,offset texte1
(4) CALL affiche
(5) MOV DX,offset texte2
(6) CALL affiche
(7) ; ——– Epilogue ———-
(8) MOV AX,4C00h
(9) INT 21h
(10) affiche:
(11) MOV AH,09h
(12) INT 21h
(13) RET
18

L ’instruction RET

Cette instruction permet le retour à l ’instruction suivant l ’instruction CALL.
Traitement de l ’instruction :
– POP CS:IP, l ’adresse de l ’instruction suivant le CALL est récupérée et placée dans CS:IP. L ’instruction exécutée après le RET est donc celle qui suivait le CALL label.
LASEx04.asm
« Exécution » de l ’exemple précédent
Ligne 3 :
Ligne 4 : CS:IP est placé sur la pile
CS:IP reçoit la valeur du label affiche,
il s ’ensuit un saut au label
Ligne 11 : Exécution de la routine jusqu’à la ligne13
Ligne 13: RET : Récupère dans CS:IP le sommet de la pile,
il s ’ensuit un saut à l ’instruction suivant l ’appel …
Ligne 5:
Ligne 6 : CS:IP est placé sur la pile
CS:IP reçoit la valeur du label affiche,
il s ’ensuit un saut au label
Ligne 11 : Exécution de la routine jusqu’à la ligne13
Ligne 13: RET : Récupère dans CS:IP le sommet de la pile,
il s ’ensuit un saut à l ’instruction suivant l ’appel …
Ligne 8 :
Ligne 9 : Fin du programme
Partage de la pile
• Le 80×86 ne possède qu’une seule pile, attention donc aux conflits entre les instructions PUSH-POP et CALL label – RET.
• Conséquences
– Dans une procédure, autant de PUSH que de POP.
– Le nombre d ’appels de procédures imbriqués est limité par la directive .STACK
• Un « PUSH » sans « POP » dans une procédure …
MOV DX,100
CALL procedure
…
procedure:
PUSH DX
MOV DX,SI
RET
Lors de la rencontre avec l ’instruction RET, IP reçoit la valeur 100 (le sommet de la pile) qui n ’est pas l ’adresse de retour de la procédure … erreur.
• La directive .stack 100h.
S ’il y a x niveaux d ’appel d ’une procédure, cela entraîne x sauvegardes d ’adresse de retour sur la pile. Il faudra veiller à choisir une pile assez grande en cas d ’appels récurcifs d ’une procédure
Vue plus complète …
• Tasm fournit deux pseudo-instructions, permettant de gérer proprement les procédures.

PROC et ENDP

• Avantages
– Ecrire proprement les procédures
– Permet les labels locaux
– Permet de définir un point d ’entrée dans le programme, pseudo-instruction END
Exemples
• La procédure suivante sera appelée par l ’instruction CALL procedure1
procedure1 PROC
PUSHa
… Corps de la procédure …
POPa
RET
procedure1 ENDP
• Définition d ’un point d ’entrée. Dans l ’extrait de code suivant;
main PROC
…
main ENDP
principale PROC
…
principale ENDP
END principale
Ce code commencera par la procédure « principale » avant la procédure « main » grâce à la pseudo-instruction END.
Les commentaires sont absents dans cet exemple … ils viendront plus tard.

• Techniques de programmation et exemples
• Procédures et programmation structurée (1)
• La pile du 80×86
• Compléments sur les tableaux
• Procédures et programmation structurée (2)
– Passage de paramètres par valeur
– Passage de paramètres par adresse
– Variables globales / variables locales
• Récursivité
• Compléments sur les interruptions
• Segmentation mémoire
– Segments logiques
– Directives de segmentation simplifiées
– Directives de segmentation standard
• Le co-processeur mathématique, le 80×87
• Macros
• Les chaînes de caractères
• Manipulation de bits