gas:reg

L'instruction mov en assembleur GNU GAS (GNU Assembler) est l'une des instructions les plus fondamentales. Elle est utilisée pour déplacer des données d'une source à une destination. Voici comment elle fonctionne :

Syntaxe Générale

mov source, destination

source : Le registre, l'emplacement mémoire ou la constante dont la valeur sera copiée.
destination : Le registre ou l'emplacement mémoire où la valeur sera copiée.

Principes de Base

Déplacement entre registres : Vous pouvez déplacer une valeur d'un registre à un autre. Par exemple :
```
mov eax, ebx
```
Cela copie la valeur du registre ebx dans le registre eax.
Déplacement d'une constante vers un registre : Vous pouvez charger une valeur immédiate (constante) dans un registre. Par exemple :
```
mov eax, 10
```
Cela charge la valeur 10 dans le registre eax.
Déplacement entre mémoire et registre : Vous pouvez copier des données de la mémoire à un registre et vice versa.
- Depuis la mémoire vers le registre :
```
mov eax, [var]
```
  Cela charge la valeur stockée à l'adresse de var dans le registre eax.
- Depuis un registre vers la mémoire :
```
mov [var], eax
```
  Cela stocke la valeur contenue dans le registre eax à l'adresse de var.

Variantes de `mov`

Le GNU Assembler supporte différentes variantes de l'instruction mov en fonction de la taille des données à déplacer :

movb : pour déplacer un octet (byte).
movw : pour déplacer un mot (word, 2 octets).
movl : pour déplacer un double mot (double word, 4 octets).
movq : pour déplacer un quad mot (quad word, 8 octets).

Par exemple :

movb al, [var]    ; Déplace un octet depuis [var] vers al
movw ax, [var]    ; Déplace un mot depuis [var] vers ax
movl eax, [var]   ; Déplace un double mot depuis [var] vers eax
movq rax, [var]   ; Déplace un quad mot depuis [var] vers rax

Quelques Points Clés :

Les opérations mov n'affectent généralement pas les drapeaux du processeur (flags).
Le déplacement entre deux emplacements mémoire est interdit, c'est-à-dire que la source ou la destination doit être un registre, mais pas les deux en mémoire simultanément.

Exemple Complet :

.section .data
var:    .long 5   ; Déclare une variable 'var' avec une valeur de 5 (32 bits)

.section .text
.globl _start
_start:
    mov eax, [var]    ; Charge la valeur de 'var' dans eax
    mov ebx, eax      ; Copie la valeur de eax dans ebx
    mov [var], ebx    ; Stocke la valeur de ebx dans 'var'
    mov eax, 1        ; Prépare l'appel système pour terminer le programme
    int 0x80          ; Interrompt pour faire l'appel système

Dans cet exemple, on charge d'abord la valeur de var dans eax, puis on la copie dans ebx, et enfin on stocke la valeur de ebx à l'adresse de var.

Conclusion

L'instruction mov est essentielle en assembleur, car elle permet de manipuler directement les données entre registres, constantes, et mémoire. Maîtriser son usage est fondamental pour toute programmation en assembleur.