diff options
Diffstat (limited to 'semestre 3/architecture des ordinateurs')
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 |