Utilisation du langage de programmation assembleur

Le Free Pascal prend en charge l'insertion d'instructions assembleur entre le code Pascal. Le mécanisme pour cela est le même que sous Turbo Pascal et Delphi. Il existe cependant des différences substantielles, comme cela sera expliqué dans les sections suivantes.

Utiliser l'assembleur dans les sources

Il existe essentiellement 2 façons d'intégrer du code assembleur dans la source pascal. La première est la plus simple, en utilisant un bloc ASM :

Tout ce qui se trouve entre le bloc ASM et END est inséré en tant qu'assembleur dans le code généré. Selon le mode du lecteur assembleur, le compilateur effectue la substitution de certains noms par leurs adresses.

La deuxième méthode consiste à implémenter une procédure ou une fonction complète en assembleur. Cela se fait en ajoutant un modificateur assembleur à l'entête de la fonction ou de la procédure :

Il est toujours possible de déclarer des variables dans une procédure assembleur :

Le compilateur réservera de l'espace sur la pile pour ces variables, il insère des commandes pour cela. Notez que le nom d'assembleur d'une fonction assembleur sera toujours 'mangled' par le compilateur, c'est-à-dire que l'étiquette de cette fonction ne sera pas le nom de la fonction déclarée. Pour changer cela, un modificateur Alias peut être utilisé :

Pour rendre la fonction disponible en code assembleur en dehors de l'unité courante, le modificateur Public peut être ajouté :

Assembleur en ligne Intel 80x86

Syntaxe Intel

Le Free Pascal prend en charge la syntaxe Intel pour la famille Intel de microprocesseurs Ix86 dans ses blocs ASM.

La syntaxe Intel dans votre bloc ASM est convertie en syntaxe AT&T par le compilateur, après quoi elle est insérée dans la source compilée. Les constructions d'assembleur prises en charge sont un sous-ensemble de la syntaxe d'assemblage normale. Dans ce qui suit, nous spécifions quelles constructions ne sont pas prises en charge dans Free Pascal, mais existant dans Turbo Pascal :

• Le qualificateur TBYTE n'est pas pris en charge.
• Le remplacement de l'identificateur & n'est pas pris en charge.
• L'opérateur HIGH n'est pas pris en charge.
• L'opérateur LOW n'est pas pris en charge.
• Les opérateurs OFFSET et SEG ne sont pas pris en charge. Utilisez LEA et les différentes instructions Lxx à la place.
• Les expressions avec des chaînes de caractères constantes ne sont pas autorisées.
• L'accès aux champs d'enregistrement entre parenthèses n'est pas autorisé.
• Les conversions de type avec des types pascal normaux ne sont pas autorisées, seules les conversions de type assembleur reconnues sont autorisées. Exemple :
1. ASM
2.  MOV AL, Byte Ptr MyWord { Autorisé }
3.  MOV AL, Byte(MyWord)  { Autorisé }
4.  MOV AL, ShortInt(MyWord)  { Non autorisé }
5. END;


• Les transtypages de type Pascal sur les constantes ne sont pas autorisés. Exemple :
  1. Const s=10;
  2. Const t=32767;

  en Turbo Pascal :

  1. ASM
  2.  MOV AL, Byte(s) { Typage inutile. }
  3.  MOV AL, Byte(t) { Erreur de syntaxe ! }
  4. END;

  En Free Pascal, le compilateur émet une erreur de syntaxe et dans les deux cas donnera une erreur de syntaxe.

• Les expressions contenant uniquement des constantes ne sont pas autorisées (dans tous les cas, elles ne fonctionnent pas en mode protégé, par exemple sous LINUX i386). Exemples :
  1. ASM
  2.  MOV AL,Byte Ptr ['c'] { Non autorisé }
  3.  MOV AL,Byte Ptr [100h] { Non autorisé }
  4. END;

  (Cela est dû à la limitation du GNU assembler).

• Les parenthèses entre parenthèses ne sont pas autorisées.
• Les expressions avec des remplacements de segment entièrement entre parenthèses ne sont actuellement pas prises en charge, mais elles peuvent facilement être implémentées dans le compilateur si nécessaire. Exemple :
1. ASM
2.  MOV AL,[DS:BX] { Non autorisé }
3. END;

utiliser à la place :

1. ASM
2.  MOV AL,DS:[BX]
3. END;


• Les indexations possibles et autorisées sont les suivantes :
• Sreg:[REG+REG*SCALING+/-disp]
• SReg:[REG+/-disp]
• SReg:[REG]
• SReg:[REG+REG+/-disp]
• SReg:[REG+REG*SCALING]
• Où Sreg est facultatif et spécifie le remplacement du segment. Remarques :
• L'ordre des termes est important contrairement à Turbo Pascal.
• La valeur de mise à l'échelle doit être une valeur et non un identificateur de symbole. Exemples :


1. Const MyScale = 1;
2.  {... }
3. ASM
4.  MOV AL,Byte Ptr [ESI+EBX*MyScale] { Non autorisé }
5. END;

utiliser à la place :

1. ASM
2.   MOV AL,Byte Ptr [ESI+EBX*1]
3. END;


• La syntaxe de l'identificateur de variable possible est la suivante : (Id = identificateur de variable ou de constante typée.)
1. ID
2. [ID]
3. [ID+expr]
4. ID[expr]

Les champs possibles sont les suivants :

1. ID.subfield.subfield ...
2. [ref].ID.subfield.subfield ...
3. [ref].typename.subfield ...


• Étiquettes locaux : Contrairement à Turbo Pascal, les étiquettes locaux doivent contenir au moins un caractère après l'indicateur de symbole local. Exemple :
1. ASM
2.  @: { Non autorisé }
3. END;

utiliser à la place :

1. ASM
2.  @1: { Autorisé }
3. END; 


• Contrairement à Turbo Pascal, les références locales ne peuvent pas être utilisées comme références, uniquement comme déplacements. Exemple :
1. ASM
2.  LDS SI,@MyLabel { Non autorisé }
3. END.


• Contrairement à Turbo Pascal, les remplacements de segment SEGCS, SEGDS, SEGES et SEGSS ne sont actuellement pas pris en charge. (Il s'agit cependant d'un ajout prévu).
• Contrairement à Turbo Pascal où les spécificateurs de taille de mémoire peuvent être pratiquement n'importe où, l'assembleur en ligne Free Pascal Intel exige que les spécificateurs de taille de mémoire soient en dehors des parenthèses. Exemple :
1. ASM
2.  MOV AL,[Byte Ptr MyVar] { Non autorisé }
3. END;

utiliser à la place :

1. ASM
2.  MOV AL,Byte Ptr [MyVar] { Autorisé }
3. END;


• Les registres de base et d'index doivent être des registres 32 bits. (limitation de GNU assembler).
• XLAT est équivalent à XLATB.
• Seuls les opcodes Single et Double du FPU sont pris en charge.
• Les opcodes à virgule flottante ne sont actuellement pas pris en charge (sauf ceux n'impliquant que des registres à virgule flottante).

L'assembleur en ligne Intel prend en charge les macros suivantes :

• @Result représente la valeur de retour du résultat de la fonction.
• Self représente le pointeur de méthode objet dans les méthodes.

Syntaxe AT&T

Dans les versions anciennes, le Free Pascal n'utilisait que GNU comme assembleur pour générer ses fichiers objets pour les microprocesseurs Intel x86. Ce n'est qu'après un certain temps qu'un assembleur interne a été créé, ayant écrit directement dans un fichier objet.

Étant donné que l'assembleur du GNU assembler utilise la syntaxe d'assemblage AT&T, le code que vous écrivez doit utiliser la même syntaxe. Les différences entre la syntaxe AT&T et Intel telle qu'utilisée dans Turbo Pascal sont résumées ci-dessous :

• Les noms d'opcode incluent la taille de l'opérande. En général, on peut dire que le nom de l'opcode AT&T est le nom de l'opcode Intel, suffixé par un 'l', 'w' ou 'b' pour, respectivement, un entier long (32 bits), un mot (16 bits) et un octet (8 bit) des références de mémoire ou de registre. Par exemple, la construction Intel 'mov al, bl est équivalente à l'instruction AT&T style 'movb %bl,%al'.
• Les opérandes immédiats AT&T sont désignés par '$', tandis que la syntaxe Intel n'utilise pas de préfixe pour les opérandes immédiats. Ainsi, la construction Intel 'mov ax, 2' devient 'movb $2, %al' dans la syntaxe AT&T.
• Les noms de registre AT&T sont précédés du signe '%'. Ils ne sont pas délimités dans la syntaxe Intel.
• AT&T indique les opérandes de saut/appel absolus avec '*', la syntaxe Intel ne délimite pas ces adresses.
• L'ordre des opérandes source et destination est inversé. La syntaxe AT&T utilise 'Source, Dest', tandis que la syntaxe Intel comporte 'Dest, Source'. Ainsi, la construction Intel «add eax, 4» se transforme en «addl $4, %eax» dans le dialecte AT&T.
• Les sauts en longueur immédiats sont précédés du préfixe 'l'. Ainsi, Intel 'call/jmp section:offset' est transformé en 'lcall/ljmp $section,$offset'. De même, le retour long est «lret», au lieu du «ret far» d'Intel.
• Les références de mémoire sont spécifiées différemment dans l'assemblage AT&T et Intel. La référence de la mémoire indirecte Intel :
  1. Segment:[Base+Index*Scale+Offs]

  est écrit dans la syntaxe AT&T comme suit :

  1. Segment:Offs(Base,Index,Scale)

  Où Base et Index sont des registres de base et d'index 32 bits facultatifs, et Scale est utilisé pour multiplier Index. Il peut prendre les valeurs 1, 2, 4 et 8. Le Segment est utilisé pour spécifier un registre de segment optionnel pour l'opérande mémoire.

Vous trouverez plus d'informations sur la syntaxe AT&T dans le manuel as, bien que les différences suivantes avec l'assemblage AT&T normal doivent être prises en compte :

• Seules les directives suivantes sont actuellement prises en charge :

  .byte .word .long .ascii .asciz .globl

• Les directives suivantes sont reconnues mais ne sont pas prises en charge :

  .align .lcomm

  A terme, ils seront soutenus.

• Les directives sont sensibles à la casse, les autres identifiants ne sont pas sensibles à la casse.
• Contrairement au gaz, les étiquettes/symboles locaux doivent commencer par .L.
• L'opérateur not '!' n'est pas pris en charge.
• Les expressions de chaîne de caractères dans les opérandes ne sont pas prises en charge.
• CBTW, CWTL, CWTD et CLTD ne sont pas pris en charge, utilisez plutôt les équivalents Intel normaux.
• Les expressions constantes représentant des références mémoire ne sont pas autorisées, même si les expressions constantes à valeur immédiate sont prises en charge. Exemples :
1. Const MyId = 10;
2. ASM
3.  { ... }
4.  MOVL $MyId,%EAX { Autorisé }
5.  MOVL MyId(%ESI),%EAX { Non autorisé }
6. END;


• Lorsque la directive .globl est trouvée, le symbole la suivant immédiatement est rendu public et est immédiatement émis. Par conséquent, les noms d'étiquettes portant ce nom seront ignorés.
• Seuls les opcodes FPU simples et doubles sont pris en charge.

L'assembleur en ligne AT&T prend en charge les macros suivantes :

Assembleur en ligne Motorola 680x0

Le lecteur assembleur en ligne pour la famille de microprocesseurs Motorola 680x0 utilise la syntaxe Motorola Assembler (q.v). Quelques différences existent :

• Les étiquettes locales commencent par le caractère @, comme :
1. @MyLabel:


• La directive XDEF dans un bloc assembleur rendra le symbole accessible publiquement avec le nom spécifié (ce nom est sensible à la casse)
• Les directives DB, DW, DD ne peuvent être utilisées que pour déclarer des constantes qui seront stockées dans le segment de code.
• La directive Align n'est pas prise en charge.
• Les opérations arithmétiques sur une expression constante utilisent les mêmes opérandes que la version Intel, par exemple AND, XOR ...
• Les directives de segment ne sont pas prises en charge.
• Seuls les opcodes 68000 et un sous-ensemble d'opcodes 68020 sont actuellement pris en charge.

L'assembleur en ligne prend en charge les macros suivantes :

• @Result représente la valeur de retour du résultat de la fonction.
• Self représente le pointeur de méthode objet dans les méthodes.

Signalisation des registres modifiés

Lorsque le compilateur utilise des variables, il les entrepose parfois, ou le résultat de certains calculs, dans les registres du microprocesseur. Si vous insérez du code assembleur dans votre programme qui modifie les registres du processeur, cela peut interférer avec l'idée du compilateur sur les registres. Pour éviter ce problème, Free Pascal vous permet d'indiquer au compilateur quels registres ont changé dans un bloc ASM. Le compilateur va alors sauvegarder et recharger ces registres s'il les utilisait. Dire au compilateur quels registres ont changé se fait en spécifiant un ensemble de noms de registre derrière un bloc d'assemblage, comme suit :

Ici, R1 à Rn sont les noms des registres que vous modifiez dans votre code assembleur. Par exemple :

Cet exemple indique au compilateur que le registre EAX a été modifié.

Pour les routines assembleur, c'est-à-dire les routines entièrement écrites en assembleur, l'ABI du processeur et de la plate-forme doit être respectée, c'est-à-dire que la routine elle-même doit savoir quels registres sauvegarder et quoi ne pas, mais elle peut dire au compilateur en utilisant la même méthode ce que registres ont été modifiés ou non. Le compilateur enregistrera les registres spécifiés dans la pile à l'entrée et les restaurera à la sortie de la routine.

La seule chose que le compilateur fait normalement est de créer un cadre de pile minimal si nécessaire (par exemple, lorsque des variables sont déclarées). Tout le reste appartient au programmeur.