Liaison de code assembleur
Les procédures et fonctions écrites en langage assembleur peuvent être liées aux programmes ou unités Turbo Pascal à l'aide de la directive du compilateur $L. Le fichier source du langage d'assemblage doit être assemblé dans un fichier objet (extension .OBJ) à l'aide d'un assembleur tel que Turbo Assembler. Plusieurs fichiers objets peuvent être liés à un programme ou à une unité via plusieurs directives $L. Les procédures et fonctions écrites en langage assembleur doivent être déclarées comme externes dans le programme ou l'unité Pascal. Par exemple :
Function LoCase(Ch:Char):Char; External;
Dans le fichier source du langage assembleur correspondant, toutes les procédures et fonctions doivent être placées dans un segment nommé CODE ou CSEG, ou dans un segment dont le nom se termine par _TEXT. Les noms des procédures et fonctions externes doivent apparaître dans les directives PUBLIC. Vous devez vous assurer qu'une procédure ou une fonction en langage assembleur correspond à sa définition Pascal en ce qui concerne le modèle d'appel (NEAR ou FAR), le nombre de paramètres, les types de paramètres et le type de résultat. Un fichier source en langage assembleur peut déclarer des variables initialisées dans un segment nommé CONST ou dans un segment dont le nom se termine par _DATA. Il peut déclarer des variables non initialisées dans un segment nommé DATA ou DSEG, ou dans un segment dont le nom se termine par _BSS. Ces variables sont privées du fichier source du langage d'assemblage et ne peuvent pas être référencées à partir du programme ou de l'unité Pascal. Cependant, ils résident dans le même segment que les globaux Pascal et sont accessibles via le registre de segment DS. Toutes les procédures, fonctions et variables déclarées dans le programme ou l'unité Pascal, ainsi que celles déclarées dans la section interface des unités utilisées, peuvent être référencées à partir du fichier source du langage assembleur via les directives EXTRN. Encore une fois, c'est à vous de fournir le type correct dans la définition EXTRN. Lorsqu'un fichier objet apparaît dans une directive $L, le Turbo Pascal convertit le fichier du format de module objet relocalisable Intel (.OBJ) en son propre format relocalisable interne. Cette conversion n'est possible que si certaines règles sont respectées :
- Toutes les procédures et fonctions doivent être placées dans un segment nommé CODE ou CSEG, ou dans un segment dont le nom se termine par _TEXT. Toutes les variables privées initialisées doivent être placées dans un segment nommé CONST ou dans un segment dont le nom se termine par _DATA. Toutes les variables privées non initialisées doivent être placées dans un segment nommé DATA ou DSEG, ou dans un segment dont le nom se termine par _BSS. Tous les autres segments sont ignorés, de même que les directives GROUP. Les définitions de segment peuvent spécifier l'alignement BYTE ou WORD, mais lorsqu'ils sont liés, les segments de code sont toujours alignés sur les octets et les segments de données sont toujours alignés sur les mots. Les définitions de segment peuvent éventuellement spécifier PUBLIC et un nom de classe, étant tous deux ignorés.
- Le Turbo Pascal ignore toutes les données des segments autres que le segment de code (CODE, CSEG ou xxxx_TEXT) et le segment de données initialisé (CONST ou xxxx_DATA). Ainsi, lors de la déclaration de variables dans le segment de données non initialisé (DATA, DSEG ou xxxx_BSS), utilisez toujours un point d'interrogation (?). Pour spécifier la valeur, par exemple :
- Les références de taille octet aux symboles EXTRN ne sont pas autorisées. Par exemple, cela signifie que les opérateurs HIGH et LOW du langage assembleur ne peuvent pas être utilisés avec les symboles EXTRN.
Compteur DW ?
Tampon DB 128 DUP(?)
Turbo Assembler et Turbo Pascal
Le Turbo Assembler (TASM) facilite la programmation de routines en langage d'assemblage et les interface dans vos programmes Turbo Pascal. Le Turbo Assembler fournit une segmentation simplifiée et une prise en charge du langage pour les programmeurs Pascal. La directive .MODEL spécifie le modèle de mémoire pour un module assembleur utilisant la segmentation simplifiée. Pour créer des liens avec des programmes Pascal, la syntaxe .MODEL ressemble à ceci :
| .MODEL xxxx, PASCAL |
Le xxxx est le modèle de mémoire (il est généralement volumineux). La spécification du langage PASCAL dans la directive .MODEL indique à Turbo Assembler que les paramètres ont été poussés sur la pile de gauche à droite, dans l'ordre où ils ont été rencontrés dans l'instruction source ayant appelé la procédure. La directive PROC vous permet de définir vos paramètres dans le même ordre qu'ils sont définis dans votre programme Pascal. Si vous définissez une fonction renvoyant une chaîne de caractères, notez que la directive PROC a une option RETURNS vous permettant d'accéder au pointeur de chaîne de caractères temporaire sur la pile sans affecter le nombre d'octets de paramètres ajoutés à l'instruction RET. Voici un exemple codé pour utiliser les directives .MODEL et PROC :
La définition de la fonction Pascal ressemblerait à ceci :
Function MyProc(I,J:Char):String; External;
Exemples de routines de langage d'assemblage
Le code suivant est un exemple d'unité mettant en oeuvre deux routines de gestion de chaînes de caractères en langage assembleur. La fonction UpperCase convertit tous les caractères d'une chaîne de caractères en majuscules et la fonction StringOf renvoie une chaîne de caractères d'une longueur spécifiée :
Le fichier de langage d'assemblage mettant en oeuvre les routines UpperCase et StringOf est illustré ci-dessous. Il doit être assemblé dans un fichier appelé STRS.OBJ avant que l'unité Stringer puisse être compilée. Notez que les routines utilisent le modèle d'appel à distance car elles sont déclarées dans la section INTERFACE de l'unité. Cet exemple utilise la segmentation standard :
- CODE SEGMENT BYTE PUBLIC
- ASSUME CS:CODE
- PUBLIC UpperCase, StringOf
-
- ; Function UpperCase(S:String):String
- UpperRes EQU DWORD PTR [BP + 10]
- UpperStr EQU DWORD PTR [BP + 6]
- UpperCase PROC FAR
- PUSH BP
- MOV BP,SP
- PUSH DS
- LDS SI,Upperstr
- LES DI,Upperres
- CLD
- LODSB
- STOSB
- MOV CL,AL
- XOR CH,CH
- JCXZ U3
- U1: LODSB
- CMP AL,'a'
- JB U2
- CMP AL,'z'
- JA U2
- SUB AL,'a'-'A'
- U2: STOSB
- LOOP U1
- U3: POP DS
- POP BP
- RET
- UpperCase ENDP
-
- ; Procedure StringOf(Var S:String;Ch:Char;Count:Byte);
- StrOfS EQU DWORD PTR [BP + 10]
- StrOfChar EQU BYTE PTR [BP + 8]
- StrOfCount EQU BYTE PTR [BP + 6]
- StringOf PROC FAR
- PUSH BP
- MOV BP,SP
- LES DI,StrOfRes
- MOV AL,StrOfCount
- CLD
- STOSB
- MOV CL,AL
- XOR CH,CH
- MOV AL,StrOfChar
- REP STOSB
- POP BP
- RET 8
- StringOf ENDP
- CODE ENDS
- END
Pour assembler l'exemple et compiler l'unité, utilisez les commandes suivantes :
|
TASM STRS TPC stringer |
Méthodes du langage d'assemblage
Les mise en oeuvre de méthodes écrites en langage assembleur peuvent être liées aux programmes Turbo Pascal à l'aide de la directive de compilation $L et du mot réservé EXTERNAL. La déclaration d'une méthode externe dans un type d'objet n'est pas différente de celle d'une méthode normale; cependant, la mise en oeuvre de la méthode ne répertorie que l'entête de méthode suivi du mot réservé EXTERNAL. Dans un texte source en langage assembleur, un @ est utilisé à la place d'un point (.) pour écrire des identificateurs qualifiés (le point a déjà une signification différente en langage assembleur et ne peut pas faire partie d'un identificateur). Par exemple, l'identificateur Pascal Rect.Init s'écrit Rect@Init en langage de programmation assembleur. La syntaxe @ peut être utilisée pour déclarer les identificateurs PUBLIC et EXTRN.
Code machine en ligne
Pour les sous-routines de langage d'assemblage très courtes, les instructions et directives INLINE de Turbo Pascal sont très pratiques. Ils vous permettent d'insérer des instructions de code machine directement dans le texte du programme ou de l'unité plutôt que via un fichier objet.
Instructions INLINE
Une instruction INLINE se compose du mot réservé INLINE suivi d'un ou plusieurs éléments en ligne, séparés par des barres obliques et entre parenthèses :
INLINE(10/$2345/Count + 1/Data - Offset);
Voici la syntaxe d'une instruction en ligne :
Chaque élément en ligne se compose d'un spécificateur de taille facultatif, < ou >, et d'une constante ou d'un identificateur de variable, suivi de zéro ou plusieurs spécificateurs de déplacement (voir la syntaxe suivante). Un spécificateur de déplacement se compose d'un + ou d'un - suivi d'une constante.
Chaque élément en ligne génère 1 octet ou 1 mot de code. La valeur est calculée à partir de la valeur de la première constante ou du déplacement de l'identificateur de variable, auquel est ajoutée ou soustraite la valeur de chacune des constantes la suivant. Un élément INLINE génère 1 octet de code s'il se compose uniquement de constantes et si sa valeur se situe dans l'intervalle de 8 bits (0..255). Si la valeur est en dehors de l'intervalle de 8 bits ou si l'élément en ligne fait référence à une variable, 1 mot de code est généré (octet le moins significatif en premier). Les opérateurs < et > peuvent être utilisés pour remplacer la sélection automatique de taille que nous avons décrite précédemment. Si un élément en ligne commence par un opérateur <, seul l'octet le moins significatif de la valeur est codé, même s'il s'agit d'une valeur de 16 bits. Si un élément en ligne commence par un opérateur >, un mot est toujours codé, même si l'octet le plus significatif est 0. Par exemple, l'instruction :
INLINE(<$1234/>$44);
génère 3 octets de code : $34, $44, $00. La valeur d'un identificateur de variable dans un élément en ligne est l'adresse de déplacement de la variable dans son segment de base. Le segment de base des variables globales-variables déclarées au niveau le plus externe dans un programme ou une unité et des constantes typées est le segment de données, étant accessible via le registre DS. Le segment de base des variables locales - variables déclarées dans le sous-programme courant - est le segment de pile. Dans ce cas, le déplacement de variable est relatif au registre BP, ce qui provoque automatiquement la sélection du segment de pile. L'exemple suivant d'une instruction en ligne génère un code machine pour entreposer un nombre spécifié de mots de données dans une variable spécifiée. Lorsqu'elle est appelée, la procédure FillWord entrepose Count mots de la valeur Data en mémoire, en commençant par le premier octet occupé par Dest.
Les instructions INLINE peuvent être librement mélangées avec d'autres instructions tout au long de la partie instruction d'un bloc.
Directives INLINE
Avec les directives INLINE, vous pouvez écrire des procédures et des fonctions se développant dans une séquence donnée d'instructions de code machine chaque fois qu'elles sont appelées. Celles-ci sont comparables aux macros en langage d'assemblage. La syntaxe d'une directive
est la même que celle d'une instruction en ligne :
Lorsqu'une procédure ou une fonction normale est appelée (y compris une contenant des instructions INLINE), le compilateur génère du code poussant les paramètres (le cas échéant) sur la pile, puis génère une instruction CALL pour appeler la procédure ou la fonction. Toutefois, lorsque vous appelez une procédure ou une fonction en ligne, le compilateur génère du code à partir de la directive en ligne au lieu de CALL. Voici un court exemple de deux procédures en ligne :
Procedure Disablelnterrupts; Inline($FA); { CLI }
Procedure Enablelnterrupts; Inline($FB); { STI }
Lorsque Disablelnterrupts est appelé, il génère 1 octet de code - une instruction CLI. Les procédures et fonctions déclarées avec des directives en ligne peuvent avoir des paramètres; cependant, les paramètres ne peuvent pas être référencés symboliquement dans la directive INLINE (d'autres variables peuvent, cependant). De plus, comme ces procédures et fonctions sont en fait des macros, il n'y a pas de code d'entrée et de sortie automatiques, ni aucune instruction de retour. La fonction suivante multiplie deux valeurs Integer, produisant un résultat Longint :
Notez l'absence de code d'entrée et de sortie et l'instruction de retour manquante. Ceux-ci ne sont pas obligatoires, car les 4 octets sont insérés dans le flux d'instructions lorsque LongMul est appelé. Utilisez les directives INLINE uniquement pour les procédures et fonctions très courtes (moins de 10 octets). En raison de la nature de type macro des procédures et des fonctions INLINE, elles ne peuvent pas être utilisées comme paramètres pour l'opérateur @ et les fonctions Addr, Ofs et Seg.