Continue ASM course

This commit is contained in:
Yorick Barbanneau 2023-02-08 23:53:04 +01:00
parent 167a2d3d75
commit 3c2301f8b6

View file

@ -174,7 +174,7 @@ rol $0x2 %eax # 00001010 -> 00101000 = 0x28
affecté mais les drapeaux OF, ZF AF, CF PF son positionné en fonction du
résultat.
#### Instruction de saut
#### Instruction de branchement
Certaines de ces instructions on plusieurs notations possibles.
@ -188,3 +188,97 @@ Certaines de ces instructions on plusieurs notations possibles.
aussi `jng` (not greater)
* `jz <addr>` : saut vers l'adresse `<addr>` si la comparaison au dessus donne
comme résultat *égal à*
#### Instruction diverses
* `loop <addr>`: décrémente `%ecx` et effectue un saut vers `<addr>` si `%ecx`
et supérieur à 0.
* `loope <addr>`: décrémente `%ecx` et effectue un saut vers `<addr>` si `%ecx`
et supérieur à 0 et `ZF` = 1. Peut aussi être nommé `loopz`
* `loopne <addr>`: décrémente `%ecx` et effectue un saut vers `<addr>` si `%ecx`
et supérieur à 0 et `ZF` = 0. Peut aussi être nommé `loopnz`
* `noop`: ne fait rien...
### Gestion de la Mémoire
Nous avons différents types d'opérandes pour la mémoire. que se soit sur les
registres :
```asm
# affecter le contenu de %eax dans %ebx
movl %eax %ebx
```
Pour les immediats:
```asm
# Affecter 1 à %ebx
movl $1 %ebx
# Affecter 0xa à %ebx
movl $0xa %ebx
# Affecter l'adresse `a` à %ebx
movl $a %ebx
```
Et pour l'acces direct à la mémoire
```asm
# Erreur !!
movl a %ebx
# Référence à l'adresse `a`
movl $a %ebx
```
Et enfin les accès indirects à la mémoire. Le principe ici est base + index *
type + déplacement. Si le type est omit alors il vaut 1 si le déplacement est
omis il vaut 0. Concrètement l'adresse est organisée comme suit:
`<deplacement>(<base>, <index>, <type>)`
```asm
# Copie le contenu de la case mémoire pointé par le contenu de %ebx dans %eax
movl (%ebx) %eax
# Copie le contenu à l'adresse %ebx + 4 octets dans %eax
movl 4(%ebx) %eax
# Cette fois c'est le contenu à l'adresse %ebx - 4
movl -4(%ebx) %eax
# le contenu à l'adresse %ecx + %ebx
movl (%ebx, %ecx) %eax
# contenu à l'adresse %ebx +t
movl t(%ebx) %eax
# contenu à l'adresse t + %ebx + %ecx * 4
movl t(%ebx, %ecx, 4) %eax
```
#### Move, xchg, lea
Ces instructions servent à copier une valeur d'un endroit (registre, mémoire ) à
un autre.
* `movl <src> <dst>` : copie le contenu de `<src>` vers `<dst>`, `<src>` peut
être une constante, un registre ou un adresse (label) et `<dst>` une adresse
ou un registre.
* `xchg <a> <b>` : ;echange le contenu de `<a>` et de `<b>`
* `leal <src> <dst>` : calcule l'adresse source (`<src>`) et place le résultat
dans `<dst>`. Contrairement à `movl`, `leal` ne traite pas la valeur mais
bien **l'adresse**
Il est possible d'utiliser `leal` pour effectuer des calculs arithmétiques non
signé. Ainsi on peut bénéficier d'un avantage : **les drapeaux ne sont pas
impactés**.
* `cmov<cmp> <src> <dst>`: copie `<src>` vers `<dst>` en fonction de
l'instruction de comparaison précédente et de l'instruction donnée par
`<cmp>`.
```asm
cmpl %eax %ebx # %ebx - %eax
cmovgel $1 %edx # si %ebx > ebx (res > 0) alors %edx = 1
```