TP5 : un peu d'assembleur

info-201 : système d'exploitation

Hiver / printemps 2026

• Consignes

• Liens utiles

• Objectifs du TP

• 1. Préliminaires

• 2. Premiers programmes : registres et calculs simples

• 3. Contrôle du flot : boucle et conditionnelles

• 4. La pile

• 5. Fonctions

• 6. Pile et adresses : registre rsp

• 7. Pour aller plus loin

  • Appels système

  • Un "gros" programme

• Résumé des instructions x86

• Résumé des commandes GDB

Consignes

Pour ce TP, vous devrez rendre une archive zip contenant les fichiers assembleur question_??.s (pour les questions pertinentes) ainsi qu'un fichier texte README.

Ce fichier README n'est pas un compte-rendu "classique". Vous devez produire un document synthétique du style "fiche de révision" contenant un résumé des notions et concepts que vous aurez explorés pendant le TP.

L'objectif est que vous produisiez une synthèse contenant les choses qui peuvent vous servir, par exemple pour l'examen !

Tous vos fichiers contiendront obligatoirement une entête avec :

• votre nom, votre filière et votre groupe,

• le numéro de votre poste (si vous faites le TP sur un des ordinateurs de l'université).

N'envoyez pas les fichiers exécutables ou les fichiers *.o produits par la compilation. Vous pouvez facilement les supprimer avec la commande

$ make clean

Liens utiles

• email des enseignants (Chambéry) damien.decout@univ-smb.fr, david.telisson@univ-smb.fr, gerald.cavallini@univ-smb.fr, jean-yves.ramel@univ-smb.fr, pierre.hyvernat@univ-smb.fr

• email des enseignants (Annecy) Ammar.Mian@univ-smb.fr, andrew.mary-huet-de-barochez@univ-smb.fr, guillaume.ginolhac@univ-smb.fr, sebastien.monnet@univ-smb.fr

• TPLab

• le fichier Makefile utilisé pour compiler et lancer le débogueur

Objectifs du TP

L'objectif de ce TP est de se familiariser avec les concepts de base du langage d'assemblage Intel x86.

1. Préliminaires

$ sudo apt install binutils gdb strace

Un fichier complet en assembleur ressemble à

.intel_syntax noprefix          # <--- pour activer la syntaxe intel, plus simple que la syntaxe par défaut (AT&T)
.global  _start                 # <--- déclaration du début du code à exécuter

##############
.section .text                  # <--- le segment "text" contient les instructions
                                #      d'autres segments sont data, rodata et bss

    # ...

_start:                         # <--- point d'entrée du programme ("fonction principale")
    # instructions
    # ...
    # ...

# fin du programme              # <--- fin du programme
fin:                            # NE PAS MODIFIER LES LIGNES SUIVANTES
    mov     rax, 60
    mov     rdi, 0
    syscall

L'exécution d'un programme écrit en assembleur est plus complexe que celle d'un programme Python.

1. Il faut transformer le langage d'assemblage en langage machine, par exemple avec la commande as (comme assemble) :

   $ as -g question_00.s -o question_00.o

   (N'oubliez pas de remplacer question_00.s par le nom du fichier que vous souhaiter utiliser !)

2. La commande précédente produit question_00.o qui est un fichier binaire contenant des instructions machines. Le fichier n'est pas "complet" car il peut encore faire référence à des commande présentes dans d'autres fichiers / bibliothèques partagées. Pour le transformer en fichier exécutable complet, on utilise la commande ld :

   $ ld -g question_00.o -o question_00

3. On peut ensuite lancer le fichier exécutable avec

   $ ./question_00

   Comme faire des affichages (print en Python) en assembleur est assez complexe, nous ne pourrons en général pas observer ce qui se passe.

   Pour expérimenter, nous allons exécuter le programme dans un débogueur pour pouvoir exécuter les instructions une par une et observer l'état des registres à chaque étape. Pour éviter d'avoir à lancer ces commandes à chaque fois, vous pouvez télécharger le fichier Makefile et le mettre dans le même répertoire que votre fichier question_00.s. Vous pourrez ensuite utiliser

   $ make question_00.gdb

   pour compiler votre fichier question_00.s et le lancer directement dans le débogeur.

2. Premiers programmes : registres et calculs simples

L'assembleur x86 a plusieurs registres généraux que l'on peut utiliser pour les calculs: rax, rbx, rcx, rdx, rsi et rdi. Ces registres font chacun 8 octets, c'est à dire 64 bits.

Il est possible de faire une "affectation" de registre avec l'instruction mov:

• mov REG1, REG2 correspond à ce qu'on écrirait REG1 = REG2 en Python.

REG1 est un nom de registre, et REG2 est soit un nom de registre, soit un nombre entier.

Les opérations arithmétiques usuelles sont

• add REG1, REG2 qui permet de faire une addition et affectation, que l'on écrirait REG1 = REG1 + REG2 en Python ;

• sub REG1, REG2 qui permet de faire une soustraction et affectation, que l'on écrirait REG1 = REG1 - REG2 en Python.

Comme pour l'instruction mov, REG1 est un registre (rax, rbx, etc.) et REG2 est soit un registre, soit un nombre.

La multiplication est similaire, mais avec une difficulté supplémentaire : elle modifie 2 registres !

• imul REG1, REG2 fait une multiplication et affectation, que l'on écrirait REG1 = REG1 * REG2. Attention, cette instruction modifie également le registre rdx : ce registre contiendra les 64 bits de poids fort du résultat. (C'est utile car le produit de 2 nombres de 64 bits peut faire 128 bits.)

3. Contrôle du flot : boucle et conditionnelles

Les langage d'assemblage n'ont pas de boucles for ou while. Le programmeur doit gérer le flot d'exécution à la main. Par défaut, le processeur exécute les instructions dans l'ordre. Pour modifier ceci, il faut utiliser des instructions de saut.

• jmp LABEL pour aller directement à l'instruction annotée par LABEL

Pour faire en saut en fonction d'une comparaison, on utilise :

On peut aussi utiliser

1. une comparaison cmp REG1, REG2, où REG1 et REG2 sont des registres ou des valeurs,

2. suivie d'un saut

   • je LABEL pour aller à l'instruction annotée par LABEL si la comparaison précédente a renvoyé "égal" (e comme equal),

   • jne LABEL ... si la comparaison précédente à renvoyé "différent" (ne comme not equal),

   • jl LABEL ... si la comparaison précédente à renvoyé "plus petit" (l comme less),

   • jle LABEL ... si la comparaison précédente à renvoyé "plus petit ou égal" (le comme less or equal).

   • jg LABEL ... si la comparaison précédente à renvoyé "plus grand" (g comme greater),

   • jge LABEL ... si la comparaison précédente à renvoyé "plus grand ou égal" (ge comme greater or equal).

   Attention, il ne faut pas mettre d'autres instructions entre le cmp et le saut !

LABEL désigne une annotation que l'on peut mettre devant n'importe quelle instruction. Par exemple, _start: annote la première instruction du fichier question_00.s. Voici un exemple de saut :

.intel_syntax noprefix
.global  _start

##############
.section .text

_start:
    # ...
    # ...
    sub     rax, 1
    cmp     rax, 0
    je      fin         # si rax devient 0, on quitte le programme
    # ...
    # ...

# fin du programme
fin:                    # NE PAS MODIFIER LES LIGNES SUIVANTES
    mov     rax, 60
    mov     rdi
    syscall

def nb_chiffre(n: int) -> int:
    r = 0
    p = 1
    while p <= n:
        p = 10 * p
        r += 1
    return r

def nb_chiffre(n: int) -> int:
    r = 0
    while n > 0:
        n = n // 10
        r += 1
    return r

def signe(x: int) -> int:
    if x < 0:
        s = -1
    elif x > 0:
        s = +1
    else:
        s = 0
    return s

4. La pile

Même avec les 8 registres supplémentaires r8, ..., r15 disponibles en mode 64 bits, le nombre de registre devient vite une limite dans les programme écrits en assembleur x86.

La pile est une zone mémoire allouée pour chaque programme. On peut y sauvegarder la valeur d'un registre et la récuperer plus tard.

• push REG empile la valeur du registre REG dans la pile,

• pop REG dépile la dernière valeur et la copie dans le registre REG.

5. Fonctions

Pour appeler une "fonction" en assembleur, il suffit de faire un saut vers le code correspondant avec jmp. Par exemple :

    # ...

# calcul du nombre de chiffres en base 10 pour rdi
# le résultat est stocké dans rax
nb_chiffres:
    # ...
    # ...


# code principal
_start:
    # ...
    mov rdi, 12345
    jmp nb_chiffres     # pour faire les calculs avec la valeur 12345
    # ...

Il y a 2 problèmes.

1. il faut penser à restaurer les valeurs des registres auxiliaires utilisés par les instructions intermédiaires.

2. Il faut, à la fin de la fonction, faire un saut vers l'instruction qui suivait l'appel à la fonction, càd l'instruction qui vient juste après jmp ma_fonction.

Pour le premier problème, il suffit d'utiliser push et pop (cf question précédente). Pour le second problème, on utilise 2 instructions de saut spéciales :

• call LABEL empile l'adresse de la prochaine instruction avant de faire un saut vers la destination LABEL

• ret dépile la dernière valeur et fait un saut vers l'adresse correspondante.

6. Pile et adresses : registre rsp

L'assembleur x86 utilise une douzaine de registre "généraux": rax, rbx, rcx, rdx, rdi, rsi, r8, r9, r10, r11, r12, r13, r14 et r15. (Les registres r8 jusqu'à r15 n'existent pas en mode 32 bits.) Il n'est donc en général pas possible d'utiliser un registre pour chaque variable d'un programme.

La solution est de stocker les variables dans la pile: un morceau de mémoire RAM où l'on peut stocker des valeurs.

• push REG ajoute la valeur du registre REG dans la pile,

• pop REG enlève la dernière valeur de la pile et la met dans le registre REG.

Ces 2 instructions modifient le registre spécial rsp (sp comme stack pointer) :

• push va décrémenter rsp de 8, car un registre 64 bits contient 8 octets,

• pop va incrémenter rsp de 8, car un registre 64 bits contient 8 octets.

Visuellement, voici ce qui se passe pour l'instruction push rax:

Comme rsp donne toujours la dernière adresse de la pile, on peut récupérer

• la dernière valeur empilée par un push en regardant à l'adresse rsp,

• l'avant dernière valeur empilée en regardant à l'adresse rsp + 8,

• etc.

Les adresses sont notées entre crochets "[...]":

.intel_syntax noprefix
.global  _start

##############
.section .text

_start:
    push    123                 # empile 123
    push    456                 # empile 456
    # ...
    # ...
    mov     rax, [rsp]          # on récupère 123
    mov     rbx, [rsp + 8]      # on récupère 456
    imul    rax, rbx

# fin du programme
    mov     rax, 60
    mov     rdi, 0
    syscall

7. Pour aller plus loin

Appels système

L'affichage d'une chaine de caractère nécessite l'accès à un périphérique. C'est le système d'exploitation qui doit s'en charger. En assembleur, il faut explicitement faire une demande au système avec l'instruction syscall.

Chaque fonctionnalité offerte par le noyau (on parle d'appel système) a son propre numéro. Pour l'invoquer, on utilise l'instruction syscall en mettant le numéro correspondant dans le registre rax. Par exemple, pour le noyau Linux :

Pour afficher une chaine de caractères on utilise la sortie standard, qui est assimilée à un fichier et qui a automatiquement le numéro 1. Il faut donc

1. mettre l'entier 1 dans le registre rax (pour spécifier write),

2. mettre l'entier 1 dans rdi (pour spécifier stdout),

3. mettre des octets (ASCII) dans la mémoire et stocker l'adresse du premier octet dans rsi,

4. mettre le nombre d'octets que l'on souhaite afficher dans rdx,

5. utiliser l'instruction syscall.

L'étape 3 est la plus complexe. On peut

• ecrire la chaine explicitement dans une partie réservée de la mémoire : le segment data :

  .intel_syntax noprefix
  .global _start
  
  ##############
  .section .data
  chaine:    .ascii "une chaine de caractères"
  
  ##############
  .section .text
  _start:
      # instructions
      # ...
  

• recopier l'adresse de la chaine du segment data dans un registre avec l'instruction lea (comme load effective address)

      # ...
      lea     rax, [chaine]       # on met l'adresse de 'chaine' dans rax
      # ...
  

• et faire l'appel système comme décrit plus haut.

$ strace -n COMMANDE
...
... exécution de COMMANDE, en affichant les appels systèmes
... sur stderr lorqu'ils sont exécutés
...

Un "gros" programme

Pour finir, nous allons écrire un "vrai" programme en assembleur x86. Ce programme agira comme un filtre qui lit des données sur stdin, passe tous les caractères ASCII alphabétiques en majuscule, et écrit le résultat sur stdout :

$ ./question_15 < question_00.s
.INTEL_SYNTAX NOPREFIX
.GLOBAL  _START

##############
.SECTION .TEXT

_START:
    # INSTRUCTIONS
    MOV     RAX, 3735805103
    ADD     RAX, 123456
    NOP

# FIN DU PROGRAMME
    MOV     RAX, 60
    MOV     RDI, 0
    SYSCALL

Nous avons presque tous les outils pour écrire ce programme.

1. L'appel système read permet de lire des octets dans un fichier ou assimilé :

   • son numéro est 0, il faut donc mettre 0 dans le registre rax avant d'appeler l'instruction syscall ;

   • l'entrée standard est automatiquement ouverte, et son numéro est 0, il faut donc mettre 0 dans le registre rdi avant d'appeler l'instruction syscall ;

   • comme pour write, il faut donner une adresse dans rsi. C'est à cette adresse que les octets lus seronts copiés.

   • comme pour write, il faut donner un nombre d'octets dans rdx. Attention, la zone mémoire correspondant à rsi doit pouvoir contenir au moins ce nombre d'octets !

2. Un registre contient 8 octets. Pour travailler sur les caractères d'une chaine, il faut utiliser un seul octet. Il est possible de n'utiliser qu'un seul octet des registres traditionnels rax, rbx, rcx et rdx. Pour ceci, on utilise al au lieu de rax, bl au lieu de rbx, cl au lieu de rcx et dl au lieu de rdx. Cela permet en particulier de ne recopier qu'un seul octet lorsqu'on écrit

       mov al, [REG]       # on récupère l'octet à l'adresse REG
   

3. Les lettres ASCII minuscules vont de 97 (correspondant à la lettre a) à 122 (correspondant à la lettre z). La lettre A a le numéro 65. Pour passer une lettre minuscule en majuscule, il suffit donc de lui soustraire 32 (32 = 97-65).

   Vous pouvez écrire un caractère ASCII entre guillemets simples "'" pour dénoter son nombre en ASCII: cmp REG, 97 est équivalent à cmp REG, 'a'.

À la fin de l'appel système, le nombre d'octets lus et copiés à l'adresse rsi est stocké dans rax. Ce nombre peut être inférieur à rdx si le fichier (ou dans notre cas, l'entrée standard) contenait moins d'octets.

Résumé des instructions x86

Résumé des commandes GDB

Remarques sur la page (ou le sujet) : contact.

,

Dernière révision: le 13-04-2026 à 15:52.