2.4  Chaîne de compilation 4/5

• Production du code assembleur :
  • sélection des instructions du CPU cible ;
  • gestion mémoire : globale, tas et pile ;
  • éléments d’assembleur x86 :
    • w mot (word) de 16 bits, l long mot de 32 bits, q quadruple mot de 64 bits;
    • e pour étendu en 32 bits, r pour registre en 64 bits;
    • eip est le compteur ordinal (rip en 64 bits);
    • esp est le pointeur de pile (rsp en 64 bits);
    • l’instruction push empile ;
    • l’instruction pop dépile ;
    • call <adresse> empile eip (rip en 64 bits) puis le modifie avec <adresse> ;
    • ret dépile et modifie eip (rip en 64 bits) avec la valeur dépilée ;
    • ebp conserve le sommet de la trame (rbp en 64 bits);
    • registres généraux en 32 bits : eax, ebx, ecx, edx, esi, edi ;
    • registres généraux en 64 bits : rax, rbx, rcx, rdx, rsi, rdi ;
    • registres supplémentaires en 64 bits : r8 à r15.
  • le schéma de compilation Linux place le résultat dans eax (rax).
  • placement des paramètres des fonctions sur la pile :
    • en 32 bits, paramètres empilés par l’appelant ;
    • en 64 bits, paramètres parfois empilés par la fonction ;
    • en 64 bits, l’appelant peut stocker les paramètres dans rdi, rsi, rdx, rcx, r8 et r9.
  • schéma de la pile pour une fonction C :

    schéma d’appel Linux 32 bits		schéma d’appel Linux 64 bits, paramètres entiers
    Paramètre entrant n adresses hautes ...   Paramètre entrant 2   Paramètre entrant 1   EIP sauvegarde   EBP sauvegarde EBP Variable 1   Variable 2   ...   Variable m   Paramètre sortant n’   ...   Paramètre sortant 2   Paramètre sortant 1 ESP   adresses basses		RIP sauvegarde adresses hautes RBP sauvegarde RBP Variable 1   Variable 2   ...   Variable m   ...   Paramètre entrant 1 <= RDI   Paramètre entrant 2 <= RSI   ...   Paramètre entrant n <= ...     adresses basses

  • notre programme simple compilé :

    version 32 bits		version 64 bits
    $ gcc -Wall -fno-asynchronous-unwind-tables -S prog.c -o prog.s $ cat prog.s .file "prog.c" .section .rodata .LC0: .string "%d\n" .text .globl main .type main, @function main: pushl %ebp movl %esp, %ebp andl $-16, %esp # $-16 -> $0xfffffff0 subl $32, %esp movl $0, 28(%esp) movl $1, 28(%esp) jmp .L2 .L3: movl $.LC0, %eax movl 28(%esp), %edx movl %edx, 4(%esp) movl %eax, (%esp) call printf addl $1, 28(%esp) .L2: cmpl $10, 28(%esp) jle .L3 movl $0, %eax leave ret		$ gcc -Wall -fno-asynchronous-unwind-tables -S prog.c -o prog.s64 $ cat prog.s64 .file "prog.c" .section .rodata .LC0: .string "%d\n" .text .globl main .type main, @function main: pushq %rbp movq %rsp, %rbp subq $16, %rsp movl $0, -4(%rbp) movl $1, -4(%rbp) jmp .L2 .L3: movl -4(%rbp), %eax movl %eax, %esi movl $.LC0, %edi movl $0, %eax call printf addl $1, -4(%rbp) .L2: cmpl $10, -4(%rbp) jle .L3 movl $0, %eax leave ret

  • le programme avec ecrire_entier en tant que fonction :

    version 32 bits		version 64 bits
    .file "prog2.c" .section .rodata .LC0: .string "%d\n" .text .globl ecrire_entier .type ecrire_entier, @function ecrire_entier: pushl %ebp movl %esp, %ebp subl $40, %esp movl $.LC0, %eax movl 8(%ebp), %edx movl %edx, 4(%esp) movl %eax, (%esp) call printf movl %eax, -12(%ebp) movl -12(%ebp), %eax leave ret .globl main .type main, @function main: pushl %ebp movl %esp, %ebp andl $-16, %esp subl $32, %esp movl $0, 28(%esp) movl $1, 28(%esp) jmp .L3 .L4: movl 28(%esp), %eax movl %eax, (%esp) call ecrire_entier addl $1, 28(%esp) .L3: cmpl $10, 28(%esp) jle .L4 movl $0, %eax leave ret		.file "prog2.c" .section .rodata .LC0: .string "%d\n" .text .globl ecrire_entier .type ecrire_entier, @function ecrire_entier: pushq %rbp movq %rsp, %rbp subq $32, %rsp movl %edi, -20(%rbp) movl -20(%rbp), %eax movl %eax, %esi movl $.LC0, %edi movl $0, %eax call printf movl %eax, -4(%rbp) movl -4(%rbp), %eax leave ret .size ecrire_entier, .-ecrire_entier .globl main .type main, @function main: pushq %rbp movq %rsp, %rbp subq $16, %rsp movl $0, -4(%rbp) movl $1, -4(%rbp) jmp .L4 .L5: movl -4(%rbp), %eax movl %eax, %edi movl $0, %eax call ecrire_entier addl $1, -4(%rbp) .L4: cmpl $10, -4(%rbp) jle .L5 movl $0, %eax leave ret

  • exercice "trame de pile" :
    • traduisez, via gcc, en assembleur ce programme :

       
      #include <stdio.h>
      void addition(int a,int b){
      int c=a+b;
      printf("a+b=%d\n",c);
      }
      int main(void){
      addition(1,1);
      return 0;
      }
      

    • dessinez la trame de pile de addition en 32 bits ;
    • dessinez la trame de pile de addition en 64 bits.
  • exercice "compilation manuelle" :
    • partez du programme C suivant :

       
      #include <stdio.h>
      unsigned int multiplier(unsigned int a,unsigned int b){
      unsigned int resultat;
      if(a==0) resultat=0;
      else if(a==1) resultat=b;
      else resultat=b+multiplier(a-1,b); 
      return resultat;
      }
      int main(void){
      unsigned int nombre;
      unsigned int a=10,b=20;
      nombre=multiplier(a,b);
      printf("resultat=%u\n",nombre);
      return 0;
      }
      

    • transformez le code :
      • n’utilisez que affectations et if(...) goto label; ;
      • normalisez les variables
        • pour le schéma 32 bits :
          • renommez les variables locales en ebp_moins_XX
          • renommez les paramètres entrants en ebp_plus_YY ;
          • créez des variables intermédiaires esp_plus_ZZ pour les paramètres sortants ;
          • créez une variable intermédiaire eax pour la valeur de retour.
        • pour le schéma 64 bits avec paramètres entiers :
          • renommez les paramètres entrants en rdi, rsi, ... ;
          • sauvez les paramètres dans des variables rbp_moins_XX
          • renommez les variables locales aussi en rbp_moins_XX
          • renommez les paramètres sortants en rdi, rsi, ... ;
          • créez une variable intermédiaire rax pour la valeur de retour.
    • écrivez le code assembleur en partant de :

       
       .section .rodata
      # ...
       .text
       .globl multiplier
       .type multiplier, @function
      multiplier:
      # ...
       .globl main
       .type main, @function
      main:
      # ...