Cours du 29 au 3 octobre

7 files changed, 283 insertions, 1 deletions

diff --git a/semestre 3/architecture des ordinateurs/2- Programmation en ASM Mips.md b/semestre 3/architecture des ordinateurs/2- Programmation en ASM Mips.md
index bbc1631..f49db8f 100644
--- a/semestre 3/architecture des ordinateurs/2- Programmation en ASM Mips.md
+++ b/semestre 3/architecture des ordinateurs/2- Programmation en ASM Mips.md
@@ -154,4 +154,101 @@ ori $2, $0, 10 # place 10 dans $2
 syscall # syscall dans $2, i.e. syscall 10, i.e. fin du programme
 ```
 
-On utilise le simulateur Mars pour écrire / exécuter des programmes
\ No newline at end of file
+On utilise le simulateur Mars pour écrire / exécuter des programmes
+## Lancer un programme
+Pour exécuter un programme, on a besoin de le lancer
+|> besoin de le charger en mémoire -> souvent, le *loader* s'en occupe
+|> chargé en RAM depuis l'adresse de base contenant le début du programme
+|> modifie PC pour contenir l'adresse du début (adresse en RAM)
+## System call
+Un appel système est une demande de service fourni par le système
+|> est un garde fou
+|> `syscall` appelle ces services
+|> chaque service possède son numéro en Mips
+|> on met le numéro du service dans `$2`
+|> pour passer des argument à `syscall`, on doit les mettre dans les registres `$4` à `$7`
+
+Pour afficher 125 :
+```asm
+ori $4, $0, 125
+ori $2, $0, 1
+syscall
+```
+
+`syscall` est un déroutement -> est gérer par l'OS
+## Données en mémoire
+Variables globales et partie `.data`
+
+On peut voir la mémoire en mode "mot" (32 bits) ou en "octet" (8 bits)
+|> représente la même mémoire
+|> "mot" est 4 fois plus grand qu'un octet
+
+Mips ne peut lire que 4 octets (ou un mot, ou 32 bits) à la fois
+|> adresse mémoire d'un mot est l'adresse la plus petite des 4 octets
+|> octet est l'unité adressable -> pas possible d'être plus petit que ça
+
+On utilise toujours les notations en Kio
+
+Mémoire non réinscriptible = ROM, lente d'accès, contient le code de démarrage ou l'ensemble du code dans certains systèmes embarqués
+Mémoire vive = RAM, volatile et rapide
+Mémoire flash (USB, SD Card) = non volatile, peut écrire (mais pas beaucoup)
+
+RAM garde les données en mémoire et ne les supprime pas jusqu'à ce qu'on écrit dessus
+|> lecture est non destructive (pas vraie partout !)
+
+Écriture RAM -> *store*
+Lecture RAM -> *load*
+
+Type de stockage en RAM :
+- Big Endian (grand boutien) -> l'octet de poids fort est rangé à l'adresse la plus petite
+- Little Endian (petit boutien) -> l'octet de poids faible est rangé à l'adresse la plus petite
+-> avec les mêmes bits en RAM, on n'obtient pas le même mot !
+
+Mips est en Little Endian
+
+Après avoir écrit `0xAABBCCDD` à `0x4`, on obtient
+
+| Adresse | `0x0` | `0x1` | `0x2` | `0x3` | `0x4`  | `0x5`  | `0x6`  | `0x7`  | `0x8` |
+| ------- | ----- | ----- | ----- | ----- | ------ | ------ | ------ | ------ | ----- |
+| Contenu | ?     | ?     | ?     | ?     | `0xDD` | `0xCC` | `0xBB` | `0xAA` | ?     |
+On peut écrire en mot, demi-mot ou octet
+
+Mémoire est structuré pour éviter d'avoir des problèmes des sécurités
+|> programme ne peut pas utiliser la RAM de l'OS par exemple
+-> elle est d'abord coupé en deux
+|> une partie utilisateur et une autre système
+|> est séparée par une adresse (tous ceux qui sont inférieures sont dans l'utilisateur en Mips)
+
+Mémoire utilisateur, c'est :
+1. segment de code (le code du programme)
+2. segment de données (données et variables globales)
+3. segment de pile (variables locales et contextes d'appels) -> stack
+4. (le tas dans la pile, mais on n'en a pas ici)
+
+**Besoin de lire le diapo 22/48** (et un peu avant)
+
+Le transfert RAM -> CPU en Mips doit être sur la même ligne !
+
+Les contraintes d'alignement sont respectées par défaut quand utilise les données globales
+|> quand utilise `.space`, on a besoin d'utiliser `.align` pour aligner correctement les zones libres
+
+Quand on utilise la mémoire, on a besoin de copier les valeurs dans les registres et d'après la mettre à jour
+
+Signature des instructions d'accès mémoire : `Codop Rt, Imm16(Rs)`
+|> `Rt` est la destination ou le registre source
+|> `Imm16(Rs)` est la zone mémoire avec `Rs` étant le décallage
+
+On se place tjs du côté du processeur pour les opcodes
+|> `l.` servent à *load*
+|> `s.` servent à *store*
+|> `.w` gèrent les mots (4 octets)
+|> `.h` gèrent les half-words (2 octets)
+|> `.b` gèrent les octets (1 octet)
+
+```asm
+lh $4, 4($3) # load le half-word contenu dans l'adresse 4 + $3 dans $4
+
+lw $4, -2(3) # load le word contenu dans l'adresse -2 + 3 dans $4
+```
+
+Par défaut, tout est signé, si on veut être en non signé, on rajoute `u`, i.e. `lhu` pour récupérer un `uint16`
\ No newline at end of file
diff --git a/semestre 3/architecture des ordinateurs/td/25-10-01.md b/semestre 3/architecture des ordinateurs/td/25-10-01.md
new file mode 100644
index 0000000..7ef3507
--- /dev/null
+++ b/semestre 3/architecture des ordinateurs/td/25-10-01.md
@@ -0,0 +1,78 @@
+---
+tags:
+  - sorbonne
+  - informatique
+  - architecture-des-ordinateurs
+  - td
+semestre: 3
+---
+## Exercice 1
+Deux sections :
+1. `.data` -> contient les variables globales (dites statiques)
+2. `.text` -> contient les données du programme
+
+Le point d'entrée est la première instruction de `.text`
+
+Se termine avec le syscall exit :
+```asm
+ori $2, $0, 10
+syscall
+```
+## Exercice 2
+### Arithmétique
+Les opcodes finissant par `u` sont pour les unsigned
+Les opcodes avec `i` indiquent qu'il utilisera des immédiats
+
+On préfère utiliser les versions unsigned
+
+Format R = tous ceux qui ne finissent pas par `i`
+|> travaillent avec les registres
+|> immédiat est sur 16 bits
+`mult`, `multu`, `div`, `divu` n'ont pas de registre de destination, ils vont toujours dans `HI` et `LO`
+
+Format I = tous ceux qui finissent par `i`
+|> travaillent avec les registres et un immédiat
+
+`addiu $12, $18, 15` -> `0b001001 10010 01100 0000 0000 0000 1111`
+`addu $12, $18, $4` -> `0b001001 10010 00100 01100 000 000 00000`
+### Logique
+`sra` et `srav` sont des opcodes logiques même s'il y a arithmétique dans leur nom
+|> ils étendent le signe
+
+Les opcodes *ne* finissant *pas* par `v` sont l'équivalent des `i` en arithmétique
+|> mais il n'y a que des format R
+|> pas d'immédiat, mais des `sh` (shifts)
+
+`sll $9, $8, 8` avec `0x0000000F` dans `$8` donne `0x00000F00`
+`srl $9, $8, 28` avec `0xF0000000` dans `$8` donne `0x0000 000F`
+`sra $9, $8, 28` avec `0xF0000000` dans `$8` donne `0xFFFF FFFF`
+`andi $9, $8, 0x000F` avec `0x0000 0036` donne `0x000 0006`
+|> immédiat est sur 8 bits en logique
+
+Pour mettre `8` dans `$8`, on fait : `ori $8, $0, 0x0000` ou `andi $8, $0, 0xFFFF`
+Pour copier `$10` dans `$8`, on fait : `or $8, $0, $10` ou `addu $8, $10, $0`
+## Exercice 3
+`ori $8, $0, 0x1234`
+
+```asm
+ori $8, $0, 0x1234
+sll $8, $8, 16
+ori $8, $8, 0x5678
+```
+on peut aussi faire
+```asm
+lui $8, 0x1234 # met 0x1234 dans les bits de poids forts
+ori $8, $8, 0x5678
+```
+
+```asm
+.data
+
+.text
+	ori $8, $0, 0x34
+	ori $9, $0, 34
+	addu $10, $8, $9
+	
+	ori $2, $0, 10
+	syscall
+```
diff --git a/semestre 3/architecture des ordinateurs/tme/tme3/exercice1.asm b/semestre 3/architecture des ordinateurs/tme/tme3/exercice1.asm
new file mode 100644
index 0000000..a4d60aa
--- /dev/null
+++ b/semestre 3/architecture des ordinateurs/tme/tme3/exercice1.asm
@@ -0,0 +1,7 @@
+.data
+.text
+	addi $12, $18, 33
+	addu $0, $18, 12
+
+	ori $2, $0, 10
+	syscall
diff --git a/semestre 3/architecture des ordinateurs/tme/tme3/exercice2.asm b/semestre 3/architecture des ordinateurs/tme/tme3/exercice2.asm
new file mode 100644
index 0000000..9b01763
--- /dev/null
+++ b/semestre 3/architecture des ordinateurs/tme/tme3/exercice2.asm
@@ -0,0 +1,11 @@
+.data
+.text
+	# dans la question 2, on remplace 137 par 65537 -> ça crash, car 65537 ne peut pas être écrit sur 16 bits
+	ori $8, $0, 137
+
+	or $4, $0, $8
+	ori $2, $0, 1
+	syscall
+
+	ori $2, $0, 10
+	syscall
diff --git a/semestre 3/architecture des ordinateurs/tme/tme3/exercice3.asm b/semestre 3/architecture des ordinateurs/tme/tme3/exercice3.asm
new file mode 100644
index 0000000..bb13955
--- /dev/null
+++ b/semestre 3/architecture des ordinateurs/tme/tme3/exercice3.asm
@@ -0,0 +1,34 @@
+.data
+.text
+	# on récupère les deux entiers
+	ori $2, $0, 5
+	syscall
+	or $9, $0, $2
+
+	ori $2, $0, 5
+	syscall
+	or $10, $0, $2
+
+	# on gère la division
+	div $9, $10
+	mflo $11
+	mfhi $12
+
+	or $4, $0, $11
+	ori $2, $0, 1
+	syscall
+
+	or $4, $0, $12
+	syscall
+
+	# on mult le quotient par $10 pour reconstruire le nombre
+	multu $11, $10
+	# on récupère la valeur et on y ajoute le reste
+	mflo $13
+	addu $13, $13, $12
+
+	or $4, $0, $13
+	syscall
+
+	ori $2, $0, 10
+	syscall
\ No newline at end of file
diff --git a/semestre 3/architecture des ordinateurs/tme/tme3/exercice4.asm b/semestre 3/architecture des ordinateurs/tme/tme3/exercice4.asm
new file mode 100644
index 0000000..4b18b69
--- /dev/null
+++ b/semestre 3/architecture des ordinateurs/tme/tme3/exercice4.asm
@@ -0,0 +1,31 @@
+.data
+.text
+	# Operations logiques
+	ori $8, $0, 0x00FF #  $8 = 0x0000 00FF
+	ori $9, $0, 0xFFF0 #  $9 = 0x0000 FFF0
+	and $10, $9, $8    # $10 = 0x0000 00F0
+	xor $11, $9, $8    # $11 = 0x0000 FF0F
+	xor $11, $11, $11  # $11 = 0x0000 0000
+	
+	# Decalages
+	ori $9, $0, 25 #  $9 = 0b0...0 0001 1001
+	sll $10, $9, 1 # $10 = 0b0...0 0011 0010
+	sll $11, $9, 2 # $11 = 0b0...0 0110 0100
+	sll $12, $9, 3 # $12 = 0b0...0 1100 1000
+	srl $10, $9, 1 # $10 = 0b0...0 0000 1100
+	srl $10, $9, 2 # $10 = 0b0...0 0000 0110
+	srl $10, $9, 3 # $10 = 0b0...0 0000 0011
+	addi $9, $0, -25 #$9 = 0b1111 1...1 1101 0111
+	srl $10, $9, 1 # $10 = 0b0111 1...1 1110 1011
+	srl $11, $9, 2 # $11 = 0b0011 1...1 1111 1101
+	sra $12, $9, 1 # $12 = 0b1111 1...1 1110 1011
+	sra $13, $9, 2 # $13 = 0b1111 1...1 1111 1101
+	sra $14, $9, 3 # $14 = 0b1111 1...1 1111 1110
+	
+	# Comparaisons
+	ori $9, $0, 2   #  $9 = 0b10
+	ori $8, $0, 4   #  $9 = 0b10
+	slt $11, $8, $9 # $11 = 0
+	slt $12, $9, $8 # $12 = 1
+	ori $2, $0, 10
+	syscall
\ No newline at end of file
diff --git a/semestre 3/architecture des ordinateurs/tme/tme3/exercice5.asm b/semestre 3/architecture des ordinateurs/tme/tme3/exercice5.asm
new file mode 100644
index 0000000..16cece8
--- /dev/null
+++ b/semestre 3/architecture des ordinateurs/tme/tme3/exercice5.asm
@@ -0,0 +1,24 @@
+.data
+.text
+	lui $3, 0xAABB
+	ori $3, $3, 0xCCDF
+	
+	# variable définissant le bit qu'on déplace
+	ori $4, $0, 3
+	# on génère le mask pour sélectionner le bit
+st:	ori $8, $0, 1 # est le mask
+	ori $9, $0, 3 # est le décallage pour le mask
+	subu $9, $9, $4 # le nombre de décallage du bit pour le mask
+	sllv $8, $8, $9 # on génére le mask
+	# on applique le mask
+	and $10, $3, $8 # on sélectionne le bon bit
+	srlv $10, $10, $4 # on décalle le bit
+	# on ajoute le résultat
+	or $5, $5, $10
+	# on boucle
+	ori $11, $0, 1
+	subu $4, $4, $11
+	bgez $4, st
+	
+	ori $2, $0, 10
+	syscall
\ No newline at end of file