Section courante

A propos

Section administrative du site

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 :

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 :

  1.        .MODEL LARGE, PASCAL
  2.        .CODE
  3. MyProc PROC FAR I:BYTE, J:BYTE RETURNS Result:DWORD
  4.        PUBLIC MyProc
  5.        LES DI, Result
  6.        MOV AL,I
  7.        MOV BL,J
  8.         ; :
  9.         ; :
  10.        RET

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 :

  1. Unit Stringer;
  2.  
  3. INTERFACE
  4.  
  5. Function UpperCase(S:String):String;
  6. Function StringOf(Ch:Char;Count:Byte):String;
  7.  
  8. IMPLEMENTATION
  9.  
  10. {$L STRS}
  11. Function UpperCase;External;
  12. Function StringOf;External;
  13.  
  14. END.

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 :

  1. CODE       SEGMENT BYTE PUBLIC
  2.            ASSUME CS:CODE
  3.            PUBLIC UpperCase, StringOf
  4.  
  5. ; Function UpperCase(S:String):String
  6. UpperRes   EQU DWORD PTR [BP + 10]
  7. UpperStr   EQU DWORD PTR [BP + 6]
  8. UpperCase  PROC FAR
  9.            PUSH BP 
  10.             MOV BP,SP
  11.             PUSH DS 
  12.              LDS SI,Upperstr 
  13.              LES DI,Upperres
  14.              CLD  
  15.              LODSB 
  16.              STOSB
  17.              MOV CL,AL
  18.              XOR CH,CH
  19.              JCXZ U3
  20. U1:          LODSB
  21.              CMP AL,'a'
  22.              JB U2
  23.              CMP AL,'z'
  24.              JA U2
  25.              SUB AL,'a'-'A'
  26. U2:          STOSB
  27.              LOOP U1
  28. U3:         POP DS
  29.            POP BP
  30.            RET
  31. UpperCase  ENDP
  32.  
  33. ; Procedure StringOf(Var S:String;Ch:Char;Count:Byte);
  34. StrOfS     EQU DWORD PTR [BP + 10]
  35. StrOfChar  EQU BYTE PTR [BP + 8]
  36. StrOfCount EQU BYTE PTR [BP + 6]
  37. StringOf   PROC FAR
  38.            PUSH BP 
  39.             MOV BP,SP
  40.             LES DI,StrOfRes
  41.             MOV AL,StrOfCount
  42.             CLD
  43.             STOSB
  44.             MOV CL,AL 
  45.             XOR CH,CH
  46.             MOV AL,StrOfChar 
  47.             REP STOSB
  48.           POP BP
  49.           RET 8 
  50. StringOf  ENDP
  51. CODE      ENDS
  52.           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.

  1. Procedure FillWord(var Dest; Count, Data: Word);Begin
  2.  Inline($C4/$BE/Dest/   { LES DI,Dest[BP] }
  3.         $8B/$8E/Count/  { MOV CX,Count[BP] }
  4.         $8B/$86/Data/   { MOV AX,Data[BP] }
  5.         $FC/            { CLD }
  6.         $F3/$AB);       { REP STOSW } 
  7. End; 

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 :

  1. Function LongMul(X,Y:Integer):LongInt;
  2.  Inline($5A/      { POP AX ; POP X }
  3.         $58/      { POP DX ; POP Y }
  4.         $F7/$EA); { MUL DX ; DX : AX = X * Y }

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.



Dernière mise à jour : Dimanche, le 15 novembre 2020