From 3c2301f8b65583d9add48c8995469ef64988f21b Mon Sep 17 00:00:00 2001
From: Yorick Barbanneau <ephase@xieme-art.org>
Date: Wed, 8 Feb 2023 23:53:04 +0100
Subject: [PATCH] Continue ASM course

---
 .../3_assembleur_approfondissement/index.md   | 96 ++++++++++++++++++-
 1 file changed, 95 insertions(+), 1 deletion(-)

diff --git a/content/secu_logicielle/3_assembleur_approfondissement/index.md b/content/secu_logicielle/3_assembleur_approfondissement/index.md
index d030a9c..762b3e7 100644
--- a/content/secu_logicielle/3_assembleur_approfondissement/index.md
+++ b/content/secu_logicielle/3_assembleur_approfondissement/index.md
@@ -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
+   ```