1.3.1 Lecture en mémoire

La syntaxe générale pour lire la mémoire à l’adresse adr et enregistrer la valeur dans le registre reg est la suivante (les crochets font partie de la syntaxe) :

mov reg, [adr]

Le nombre d’octets lus dépend de la taille de reg. Par exemple, 1 octet sera lu pour al ou ah, 2 octets seront lus pour ax et 4 pour eax. Un autre exemple :

mov al, [0x00000003]    ; al recoit l'octet stocke a l'adresse 3
                        ; dans l'exemple, al = 10 = 0x0a;
mov al, [3]             ; Instruction equivalente a la precedente.

Quand on lit plus d’un octet, il faut adopter une convention sur l’ordre dans lequel les octets sont rangés dans le registre. Il existe deux conventions little-endian (petit boutisme) et big-endian (grand boutisme). La convention employée dépend du processeur. Pour nous se sera toujours little-endian.

Considérons par exemple l’instruction suivante, avec la mémoire dans l’état représenté par la table 2 :

mov eax, [0x00000000]

Le nombre d’octets lus dépend de la taille du registre. Ici on va lire les 4 octets situés aux adresses 0, 1, 2 et 3. Dans l’exemple de mémoire, ces octets valent respectivement 3 (= 0x03), 30 (= 0x1e), 90 (= 0x5a) et 10 (= 0x0a). Les deux choix possibles pour les ranger dans eax sont

• eax = 0x0a5a1e03 en convention little-endian ;

• eax = 0x031e5a0a en convention big-endian.

Au lieu de donner explicitement l’adresse où lire les données, on peut lire l’adresse depuis un registre. Ce registre doit nécessairement faire \(4\) octets. Par exemple,

mov eax, 0      ; eax = 0
mov al, [eax]   ; al recoit l'octet situe a l'adresse contenue dans eax
                ; dans l'exemple, al = 0x03.

mov eax, 5
sub eax, 1
mov al, [eax]
mov ah, [eax]

1.3.2 Écriture en mémoire

La syntaxe générale pour écrire en mémoire à l’adresse adr la valeur du registre reg est la suivante (les crochets font partie de la syntaxe) :

mov [adr], reg

L’écriture suit la même convention que la lecture (little-endian en ce qui nous concerne).

mov eax, 0x04030201
mov [0], eax
mov [2], ax
mov [3], al

On peut aussi directement affecter une valeur en mémoire sans la stocker dans un registre. Il faut alors préciser la taille des données avec les mots-clés byte (\(1\) octet), word (\(2\) octets) et dword (\(4\) octets).

mov dword [0], 0x020001
mov byte [1], 0x21
mov word [2], 0x1

mov ax, 0x0001
mov [0], ax
mov eax, 0
mov al, [0]

2.2.1 Structure du programme

Le programme est composé de deux sections :

Section .data (lignes 3 – 6)

contient les données du programme, dans cet exemple, la chaîne de caractères à afficher.

Section .text (lignes 8 – 23)

contient le code du programme.

Lors de son exécution, le programme est chargé en mémoire comme décrit dans la figure suivante.

L’adresse à laquelle débute le code est toujours la même : 0x08048080. En revanche, l’adresse à laquelle commence les données dépend de la taille du code (plus le code est long, plus l’adresse de la case à laquelle commence les données est élevée).

2.2.2 Section .data

La primitive db permet de déclarer une suite d’octets. La chaîne de caractères donnée entre guillemets correspond simplement à la suite des octets ayant pour valeur le code des caractères. Par exemple, le code de 'H' est \(72\) et celui de 'e' est \(101\). On aurait pu écrire, de manière équivalente,

msg : db 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 10

ou bien encore

msg : db 0x48,0x65,0x6c,0x6c,0x6f,0x20,0x57,0x6f,0x72,0x6c,0x64,0x0a

Par ailleurs, contrairement à la plupart des langages de programmation de plus haut niveau, le programmeur est ici chargé de placer le marqueur de fin de chaîne à la fin des chaînes de caractères qu’il définit. Nous ne le faisons pas dans ce TP mais il sera impératif de prendre cette habitude pour les suivants. Par exemple, nous aurions dû écrire

msg : db "Hello World", 10, 0

où le 0 final code le caractère communément noté '\0'.

2.2.3 Section .text

La section .text contient le code. L’instruction de la ligne 9 permet de rendre visible l’étiquette main, et en particulier, dans Hello.o. On peut ainsi y faire référence dans la commande ld -o Hello -melf_i386 -e main Hello.o pour signaler que le point d’entrée du programme est cette étiquette.

Le premier bloc, allant de la ligne 11 à la ligne 19, permet d’afficher la chaîne de caractères et le deuxième bloc, allant de la ligne 20 à la ligne 22 permet de quitter le programme.

Il n’y a pas dans le jeu d’instructions du processeur d’instruction spécifique pour afficher un message. Pour afficher un message à l’écran, il faut faire appel au système d’exploitation (dans notre cas, le noyau Linux). C’est le rôle de l’instruction int 0x80. Cette opération va passer la main au noyau pour réaliser une tâche. Une fois cette tâche réalisée, le noyau reprend l’exécution du programme à la ligne suivant l’interruption. Ce procédé est appelé un appel système. L’instruction int 0x80 peut servir à faire toutes sortes de tâches : quitter le programme, supprimer un fichier, agrandir la taille du tas, exécuter un autre programme. Le noyau détermine la tâche à accomplir en regardant la valeur des registres eax, ebx, etc., qui jouent alors le rôle de paramètres. En particulier, la valeur du registre eax correspond au numéro de la tâche à accomplir. Par exemple, 1 correspond à exit et 4 correspond à write. Pour connaître le numéro de chacun des appels systèmes, il faut regarder dans les sources du noyau. Par exemple pour le noyau 2.6, on le trouve dans le fichier unistd_32.h qui commence comme indiqué par la les lignes suivantes :

#define __NR_restart_syscall    0
#define __NR_exit               1
#define __NR_fork               2
#define __NR_read               3
#define __NR_write              4
#define __NR_open               5
#define __NR_close              6
#define __NR_waitpid            7
#define __NR_creat              8
#define __NR_link               9
#define __NR_unlink            10
#define __NR_execve            11
#define __NR_chdir             12
#define __NR_time              13
#define __NR_mknod             14
#define __NR_chmod             15
#define __NR_lchown            16
#define __NR_break             17

Pour l’appel système write, les registres ebx, ecx, edx sont utilisés comme suit :

• ebx contient le numéro de la sortie sur laquelle écrire. La valeur 1 correspond à la sortie standard ;

• ecx contient l’adresse mémoire du premier caractère à afficher ;

• edx contient le nombre total de caractères à afficher.

Si l’on revient sur le premier bloc du code (lignes 11 – 19), on demande au système d’afficher (car eax = 4) sur la sortie standard (car ebx = 1) les 12 caractères (car ecx = 12) commençant à l’adresse msg. Le deuxième bloc (ligne 20 – 22) quitte le programme avec l’appel système exit qui a pour code 1. Le code de retour est donné dans ebx. La valeur 0 signifiant qu’il n’y a pas eu d’erreur.

Pour connaître les paramètres attendus par un appel système, il est possible d’utiliser la section 2 des pages de man. Par exemple, il faut taper man 2 write pour l’appel système write. La documentation donne le prototype de l’appel système pour le langage C. On peut l’adapter à l’assembleur en sachant que le premier argument va dans ebx, le second ecx, et ainsi de suite.