Différences

Ci-dessous, les différences entre deux révisions de la page.

--- nsi:premiere:architecture:langage_assembleur [2023/09/13 14:31] – créée goupillwiki
+++ nsi:premiere:architecture:langage_assembleur [2024/01/04 12:19] (Version actuelle) – goupillwiki
@@ Ligne 1: / Ligne 1: @@
 ====== Langage Assembleur ======
-Dans ce cours, on présente le langage **Assembleur** dans le cadre d'un exemple.
+Bien que certains standards se soient mis en place, le langage assembleur est le langage d'un processeur particulier et donc, suivant les technologies mis en œuvre dans un processeur donné, l'assembleur sera différent.
+Le langage proposé dans ce cours n'est qu'un exemple correspondant à un processeur fictif que j'ai inventé pour les besoins du cours. Mais il est suffisamment proche des cas réels pour vous être utile.
 ===== Compilation / Interprétation =====
@@ Ligne 13: / Ligne 15: @@
 À mesure de l'évolution de la technologie et des **théories sur les langages** de nouveaux langages plus évolués, plus faciles à comprendre pour l'humain sont apparus.
+C est un langage qui reste assez difficile parce qu'il nécessite une bonne compréhension de ce qui se passe dans la machine. Python est au contraire très proche de l'humain et donc beaucoup plus facile à apprendre.
 </WRAP>
@@ Ligne 30: / Ligne 34: @@
 Le travail de traduction peut ajouter des erreurs, il peut faire perdre quelque chose... Autrefois, les programmes écrits directement en Assembleur étaient toujours plus performants que ceux compilés/interprétés. On a donc longtemps continué à faire des choses en assembleur.
-Aujourd'hui, les langages sont devenus beaucoup plus performants. Il n'est plus utile de programmer en Assembleur.
+Aujourd'hui, les compilateurs et interpréteurs sont devenus beaucoup plus performants. Il n'est plus utile de programmer en Assembleur.
 Apprendre l'Assembleur sert seulement à mieux comprendre comment ça marche.
@@ Ligne 56: / Ligne 60: @@
 </WRAP>
-===== Un exemple de langage assembleur =====
+===== Assembleur et architecture du microprocesseur =====
-Bien que certain standard se soient mis en place, le langage assembleur est le langage d'un processeur particulier et donc, suivant les technologies mis en œuvre dans un processeur donné, l'assembleur sera différent.
+L'assembleur est très proche du matériel. Il faut donc connaître au moins un peu l'organisation d'un processeur pour comprendre ce que peut faire l'assembleur.
-Le langage proposé ci-dessous n'est qu'un exemple correspondant à un processeur fictif que j'ai inventé pour les besoins du cours.
+{{ :nsi:premiere:architecture:archiseq-5.png?direct&400 | Structure de Von Neumann}}
-==== Jeu d'instructions ====
+La plupart des processeurs adoptent la structure dite de **Von Neumann**.
-=== Une instruction est un mot binaire ===
+  * L'unité de séquencement est le chef d'orchestre, il dirige les autres ;
+  * l'unité arithmétique et logique (UAL) fait les calculs (+, *, etc.) ;
+  * la mémoire contient toutes les données utiles : résultats de calculs mais aussi le programme lui-même ;
+  * entrées / sorties car le processeur doit servir à quelque chose, il agit sur l'extérieur.
-Un programme est toujours composé dune liste d'instructions exécutées l'une après l'autre.
+==== Registre ====
-Pour le processeur, une instruction est toujours un mot binaire. Dans notre exemple, une instruction est toujours **un mot de 16 bits**.
+On utilisera souvent le mot **registre**. On peut considérer que c'est une case mémoire. Elle contient une donnée, un mot binaire.
-<WRAP tip>
+Un registre est une mémoire très rapide utilisée au cœur du microprocesseur. Un microprocesseur contient généralement une mémoire interne constituée de registres. On trouve d'autres registres comme le registre qui mémorise la ligne d programme à laquelle on se trouve ou bien les registres utilisés par l'unité de calcul.
-Dans certains processeurs, on choisit de n'avoir que des instructions avec un format de taille fixe, ce qui conduit à un jeu d'instruction plus simple. On parle de **RISC = Reduced Instruction Set Computer**.
-D'autres font le choix d'instructions de format variable ce qui donne accès à un jeu d'instruction plus riche, mais l'exécution s'en trouve complexifiée. On parle de **CISC = Complex Instruction Set Computer**.
+==== UAL ====
-Il y a eu un temps une mode pour le CISC. Mais c'est aujourd'hui plutôt le RISC qui domine, y compris pour les ordinateurs de bureau.
+L'**U**nité **A**rithmétique et **L**ogique fait les calculs. Ce sont des calculs simples mais ils sont à la base de tout ce que fera le microprocesseur. Ces un composant essentiel qui peut faire une grande différence d'un microprocesseur à un autre :
-</WRAP>
+  * certains microprocesseurs disposent des circuits pour faire des opérations compliquées comme des //cosinus//, //racines carrées//, des opérations sur les flottants...
+  * d'autres ne savent faire que des PLUS et des MOINS avec des entiers.
+  * dans certains cas, l'UAL dispose d'une trentaine de registres pour faire ses calculs,
+  * dans d'autres cas il ne dispose que du registre contenant le résultat, le **registre de travail**.
+**Dans notre cas, l'UAL n'aura qu'un registre de travail.** On appelle parfois ce registre **W** pour **W**ork.
+==== Exemple ====
-Notre exemple sera donc de type RISC.
+<code:asm>
+MOV #4
+ADD #8
+STR @x
+</code>
-=== Format ===
+Chaque ligne est une instruction simple que le processeur est capable d'exécuter. Dans cet exemple, voici ce que fait le programme :
+  * charger la valeur 4 dans le registre de travail,
+  * additionner 8 au contenu du registre de travail,
+  * écrire le contenu du registre de travail dans la mémoire étiqueté x -- //STR signifie STORE, c'est à dire stocker.//
-Sur les 16 bits disponibles pour écrire coder une instruction, on choisit de :
+==== Premiers enseignements ====
-  * attribuer 6 bits pour indiquer le nom de l'instruction -- on appelle cela un **opcode**,
-  * les 10 bits restants permettent de préciser un argument. C'est à dire 2 bits pour préciser un type d'argument et 8 bits pour l'argument lui-même.
-C'est encore abstrait, voyons un exemple : ''%%ADD @x%%'' signifie que l'on veut additionner au registre de travail le contenu de la mémoire étiquetée ''%%@x%%''. On supposera ici que la mémoire ''%%@x%%'' a été placée à l'adresse 12.
+Les instructions sont peu variées et elles correspondent aux différents organes du processeur.
-Le mot d'instruction s'écriera :
+Voici le genre de chose qu'une instruction peut faire :
-  * ''1000 00'' c'est à dire 32 en binaire. C'est l'opcode pour ADD.
-  * ''10'' c'est le code binaire pour indiquer que l'argument à suivre est une adresse,
-  * ''0000 1100'' c'est à dire 12 en binaire, c'est l'adresse de la case mémoire.
-L'instruction ''%%ADD @x%%'' est alors codée ''1000 0010 0000 1100''.
+  * copier une donnée d'une case mémoire à une autre,
+  * exécuter un calcul avec l'UAL,
+  * lire en entrée / écrire en sortie,
+  * changer le flux d'instruction : instructions de saut.
-<WRAP important>Le codage est univoque. Un code correspond à une instruction et réciproquement. La machine voit le code en binaire -- par ex. ici ''1000 0010 0000 1100''. L'humain qui code en assembleur préfère l'écriture en texte -- par ex. ici ''%%ADD @x%%''. Mais les deux sont équivalents.</WRAP>
+==== Flux d'instructions ====
+Détaillons le dernier item qui est le moins évident. Un programme s'exécute une ligne après l'autre, dans l'ordre. L'unité de séquencement dispose donc d'un **compteur de ligne** -- on dit aussi **pointeur de ligne** -- qui après chaque instruction se contente de passer à la ligne suivante.
+Mais parfois on a besoin de recommencer un bloc d'instructions (boucle) ou bien de ne pas exécuter un bloc d'instruction (alternative comme //if//). Dans ces cas là, on ne veut pas simplement passer à la ligne suivante. On veut passer (on dit souvent //sauter// = //jump//) à une certaine ligne du programme. Certaines instructions sont là pour cela.
+Voyons un exemple avec un branchement.
+<code:asm>
+    MOV @x    // contenu de x dans travail
+    CMP #0    // on va comparer à 0
+    BGE L     // si plus grand ou égal, sauter à ligne étiquetée "L"
+    MULT #-1  // multiplier travail par -1
+    STR @x    // stocker travail dans x
+L   HALT      // fin
+</code>
+Vous noterez que l'on a ajouté une marge pour permettre l'ajout d'une étiquette en tête de ligne. On pourrait aussi numéroter les lignes mais l'usage est plutôt de mettre une étiquette pour indiquer les lignes où l'on est susceptible de sauter.
+Vous pouvez constater que dans ce programme, suivant la valeur de ''x'', on ne fait pas la même chose. On pourrait le traduire en Python :
-===== Le langage de la machine : Assembleur =====
+<code python>
+if x < 0:
+    x *= -1
+</code>
-On appelle **Assembleur** le langage de la machine. Pour bien comprendre, rappelons comment la machine exécute le programme.
+Le code assembleur est toujours très long comparé à l'équivalent dans un langage évolué.
-Pour comprendre comment fonctionne l'assembleur, il est préférable d'avoir quelques idées sur le fonctionnement d'une machine. Pour cela, faites d'abord le [[machine_von_neumann|TD fonctionnement d'une machine de Von Neumann]].
+==== Littéral et adresse ====
+Dans le morceau de programme, vous pouvez voir ''%%#4%%'' et ''%%#8%%''. Dans les deux cas on parle de **littéral**. Quand on écrit ''%%#4%%'', il faut comprendre : le **nombre 4**.
+On aurait pu voir ''%%@4%%''. Le symbole ''%%@%%'' indique que l'on parle d'une adresse.
+  * ''%%ADD @4%%'' : on additionne au registre de travail le contenu de **la mémoire à l'adresse 4**.
+  * ''%%ADD #4%%'' : on additionne au registre de travail **le nombre 4**.
+Souvent, on ne veut pas spécifier une adresse explicitement. Il est donc rare que l'on note quelque chose comme ''%%@4%%''. On écrit plutôt quelque chose comme ''%%@x%%'' et on laisse le système décider dans quel case mémoire il placera ''x''.
+==== Programme et données ====
+Il faut comprendre que la mémoire contiendra à la fois le programme et les données du programme. Reprenons le programme précédent.
+<code:asm>
+    MOV @x
+    CMP #0
+    BGE L
+    MULT #-1
+    STR @x
+L   HALT
+</code>
+Ce programme comporte 6 lignes et utilise une variable ''x''. Dans le microprocesseur, les 6 lignes de programme occuperont les lignes 0 à 5. On pourra placer ''x'' en ligne 6. Si on veut explicitement placer ''x'' à la suite du programme, on peut écrire :
+<code:asm>
+    MOV @x
+    CMP #0
+    BGE L
+    MULT #-1
+    STR @x
+L   HALT
+x   DATA
+</code>
+ce qui permet d'indiquer que la ligne mémoire après la ligne contenant ''HALT'' devra contenir la mémoire ''x''.