J'apprends la programmation avec l'assembleur x86, partie 1

Voici un tout premier programme qui ne fait rien à part démarrer et appeler le service (l'interruption) du système d'exploitation MS-DOS pour s'arrêter.

Si vous n'avez pas encore installé les outils pour suivre ce tuto, c'est par ici.

Merci de ne pas m'interrompre

Pour appeler une interruption, on utilise les registres du CPU, le cerveau de notre ordinateur. Les registres sont les portes d'entrées pour envoyer ou recevoir des valeurs à notre CPU.
Tous les registres ont un petit nom, ce qui est bien pratique pour les utiliser, et peuvent stocker une certaine quantité de données, quantité exprimées en nombre de bits, ces fameux 0 et 1 qui font toute la beauté de l'informatique.

Le registre que nous allons utiliser ici est le registre ax, qui peut contenir 16 bits, soit 16 valeurs de 0 ou de 1 :

Pour faciliter son exploitation, il peut être divisé en deux registres de 8 bits :

• al : soit alow (bas), les bits de 0 à 7
• ah : ahigh (haut), les bits de 8 à 15

Pour appeler une interruption du MS-DOS, on place dans ah le numéro de la fonction demandée avec l'instruction mov qui permet de mettre une valeur dans un registre.

Ainsi

mov ah, 0x4c

place la valeur hexadécimale 0x4c, soit 76 en décimal, dans le registre ah. Il est à noter que l'on pourrait très bien utiliser la valeur décimale, mais les appels aux interruptions se font généralement en hexa, c'est nettement plus frime.

La syntaxe de l'instruction mov est toujours :

mov [nom_du_registre], [valeur]

Il faut respecter l'ordre et l'utilisation de la ','.

Après avoir stocké la valeur de retour du programme dans al, on appelle l'interruption MS-DOS numéro 0x21 en utilisant l'instruction int :

int 0x21

C'est quand commentaire ?

Comme vous pouvez le constater en lisant les extraits de code de cette page, l'assembleur peut vite devenir compliqué à déchiffrer.
Heureusement, on peut parsemer nos proses programmastiques (si, si ça existe...) d'autant de commentaires qu'on le souhaite.
Avec l'outil NASM, tout texte précédé du caractère ';' sera un commentaire :

; un commentaire
push cx      ; un autre commentaire après un intruction prise en compte par NASM
; mov ax, 1  une instruction non prise en compte par NASM

Allez hop, vous pouvez dès à présent vous munir de votre éditeur de texte de prédilection et saisir le code source ici-dessous.

Le nom du fichier est nothing.asm et il doit se trouver dans le dossier qui correspond au C: de votre DOSBox.

Le code source de nothing.asm

; ===========
; nothing.asm
; ===========
;
; C:\nasm -fbin nothing.asm -o nothing.com

org 0x100           ; un .COM commence à l'adresse 0x100

global main         ; le point de départ du programme est notre fonction main

section .text       ; cette partie du code source correspond aux instructions

main:
    mov ah, 0x4c    ; fonction 0x4c de l'interruption DOS 0x21 : mettre fin au programme
    mov al, 0x00    ; le code de retour est 0, pas d'erreur
    int 0x21

Une exécution non léthale

Afin de pouvoir exécuter un programme assembleur il faut d'abord le transformer en langage machine, le seul langage que comprend le processeur de votre PC. Pour celà on va compiler le programme et on obtiendra un fichier exécutable.

Il y a deux formats de fichiers exécutable sous MS-DOS :

• .EXE : qui permettent d'accéder à tout la mémoire du système, et qui sont un peu plus difficile à écrire,
• .COM : qui sont limités à 64 Ko de mémoire Pour nos tous premiers programmes, le format .COM sera suffisant.

Pour compiler notre fichier nothing.asm :

C:\nasm -fbin nothing.asm -o nothing.com

Pour exécuter :

C:\nothing,com

Et... il se passe rien ; c'était le but, non ?

En tout cas, bravo, vous avez écrit votre premier programme en assembleur !

Pour m'entrainer

Écrire le même programme en utilisant uniquement le registre ax.

org 0x100   

global main     

section .text   

main:
    mov ax, 0x4c00  
    int 0x21

Et après...

Rendez-vous pour la partie 2 dans laquelle on va écrire un texte !