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

```asm
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

1. **Déplacement entre registres** :
   Vous pouvez déplacer une valeur d'un registre à un autre. Par exemple :

   ```asm
   mov eax, ebx
   ```

   Cela copie la valeur du registre `ebx` dans le registre `eax`.

2. **Déplacement d'une constante vers un registre** :
   Vous pouvez charger une valeur immédiate (constante) dans un registre. Par
   exemple :

   ```asm
   mov eax, 10
   ```

   Cela charge la valeur `10` dans le registre `eax`.

3. **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 :

     ```asm
     mov eax, [var]
     ```

     Cela charge la valeur stockée à l'adresse de `var` dans le registre `eax`.

   - Depuis un registre vers la mémoire :

     ```asm
     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 :

```asm
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 :

```asm
.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.