Sous-sections de Assembleur

Langage assembleur

Mach 04

Résumé du cours

Langage machine

Le processeur n’interprète que des signaux électriques représentés par:

  • 0 pas de courant électrique.
  • 1 passage de courant électrique.

On parle de langage binaire. Il est difficile pour l’Homme d’écrire un programme directement en binaire. On utilise alors des symboles mnémoniques qui représentent une instruction compréhensible par le CPU.

Langage assembleur

Le processeur peut:

  • additionner des nombres,
  • comparer des nombres,
  • charger une valeur depuis la mémoire,
  • stocker une valeur en mémoire.

Le code suivant ajoute $3+57$ et garde le résultat dans le registre R0.

ADD R0,#3,#57
HALT
À retenir

En informatique, une instruction:

  • s’écrit sur une ligne,
  • modifie l’état de la mémoire

Le processeur ne peut manipuler que des nombres situés dans les registres (mémoires très rapides, avec des fréquences de fonctionnement similaires au processeur). Pour manipuler des données dans la mémoire vive, il faut d’abord les placer dans les registres.

Pour charger la valeur située à l’emplacement 36 de la mémoire:

LDR R0,36
À retenir

Chaque processeur possède son propre jeu d’instructions. Il n’est pas possible de les connaître par cœur. La documentation est donc un outil indispensable pour le programmeur.

Constructions élémentaires

Mach 05

Résumé du cours

Information

Les instructions ne sont pas à connaître par cœur. Il faut par contre savoir lire la documentation.

Entrée / Sortie

Charger une entrée clavier (un nombre) dans R0

LDR R0, .InputNum

Afficher dans la console de sortie

STR R2, .WriteUnsignedNum

Variable

Référencer un mot mémoire avec une étiquette

LDR R0, monage
HALT
monage: 25

Effectuer un saut conditionnel

MOV R0, #10
MOV R1, #10
// Compare les valeurs de R0 et R1
CMP R0, R1
// Si les valeurs sont égales, saute à la ligne compegal
BEQ compegal 
MOV R2, R0
HALT 
labelegal: 
STR R0, mavaleur
HALT
mavaleur: 5

Répéter une instruction

    MOV R11,#0        //initialise compteur
boucle:
    ADD R11,R11,#1    //incrémente compteur
    CMP R11,#3       //vérifie fin de la boucle
    BNE boucle
    HALT            //sortie de la boucle

Exercices assembleur

Mach 06
Information
  • Ces exercices sont à réaliser en autonomie.
  • Écrire d’abord les programmes sur papier, puis utiliser le simulateur https://edurl.fr/simul
  • La correction est fournie.

Exercice 1

Écrire un programme qui:

  • stocke deux entiers dans la mémoire vive avec les labels val1 et val2,
  • échange ses deux valeurs.
      LDR R1, val1
      LDR R2, val2
      STR R1, val2
      STR R2, val1
      HALT
val1: 10
val2: 12

Exercice 2

Écrire un programme qui:

  • stocke dans la mémoire vive les coordonnées $x=5$ et $y=4$ d’un personnage.
  • modifie chaque coordonnée de 3 unités.
LDR R0, x
ADD R0, R0, #3
STR R0, x
LDR R1, y
ADD R1, R1, #3
STR R1, y
HALT
x: 5
y: 4

Exercice 3

  1. Décrire le rôle de ce programme. Il faudra décrire le déroulé des instructions, mais également donner le rôle général du programme.
  2. Tester le programme dans le simulateur. Proposer deux tests possibles afin de vérifier tous les cas de figure.
      MOV R2,#question 
      STR R2, .WriteString
      LDR R1,.InputNum
      CMP R1,#18
      BLT moins
      MOV R2,#texteplus
      STR R2, .WriteString
      HALT
moins:
      MOV R2,#textemoins
      STR R2, .WriteString
      HALT
question:.ASCIZ "Quel est votre âge?"
textemoins: .ASCIZ "Vous êtes mineur."
texteplus: .ASCIZ "Vous êtes majeur."

Le programme demande l’âge et vérifie si la personne est mineure ou majeure.

  • lignes 1-2: La question “Quel est votre âge?” est posée
  • ligne 3: Attente de l’âge et stockage dans R1
  • ligne 4: Comparaison entre l’âge et 18
  • ligne 5: Si l’âge est strictement inférieur à 18, sauter à la ligne 9
  • lignes 6-7: Afficher “Vous êtes majeur”.
  • lignes 10-11: Afficher “Vous êtes mineur.”

Exercice 4

  1. Stocker deux entiers dans la mémoire, avec les étiquettes val1, val2.
  2. Écrire un programme qui compare les valeurs dans val1 et val2 et stocke la plus grande valeur dans la variable resultat.
    LDR R1,val1
    LDR R2,val2
    CMP R1,R2
    BGT v1plusgrand //R1 est le plus grand
    // R2 est le plus grand
    STR R2,resultat
    HALT
v1plusgrand:
    STR R1,resultat
    HALT
val1: 13
val2: 5
resultat: 0

comparer comparer

Exercice 5

On souhaite écrire un programme qui implémente l’algorithme suivant:

  • Demander la largeur du rectangle.
  • Demander la longueur du rectangle.
  • Calculer le périmètre du rectangle.
  • Afficher le périmètre du rectangle.

Remettre les instructions suivantes dans l’ordre afin d’implémenter l’algorithme précédent.

largeur:.ASCIZ "Quelle est la largeur?"
      STR R1, .WriteString
      ADD R4,R2,R2
      HALT
longueur: .ASCIZ "Quelle est la longueur?"
      MOV R1,#perimetre 
      STR R4, .WriteUnsignedNum
      MOV R1,#largeur 
      MOV R1,#longueur 
      STR R1, .WriteString
      LDR R3,.InputNum
      ADD R4,R4,R3
      ADD R4,R4,R3
      STR R1, .WriteString
      LDR R2,.InputNum
perimetre: .ASCIZ "Le périmètre est: "
      MOV R1,#largeur 
      STR R1, .WriteString
      LDR R2,.InputNum
      MOV R1,#longueur 
      STR R1, .WriteString
      LDR R3,.InputNum
      ADD R4,R2,R2
      ADD R4,R4,R3
      ADD R4,R4,R3
      MOV R1,#perimetre 
      STR R1, .WriteString
      STR R4, .WriteUnsignedNum
      HALT
largeur:.ASCIZ "Quelle est la largeur?"
longueur: .ASCIZ "Quelle est la longueur?"
perimetre: .ASCIZ "Le périmètre est: "

Exercice 6

  1. Écrire et exécuter le code suivant:
MOV R0,#16
LSR R1, R0,#1
LSR R2, R0,#2
LSR R3, R0,#3
HALT
  1. Comprendre le fonctionnement de l’instruction LSR.

L’instruction LSR effectue des divisions successives par 2.

LSR R3, R0,#3

La valeur 3 indique le nombre de division par 2.

Exercice 7

Écrire un programme qui :

  • demande un nombre à l’utilisateur parmi les puissances de 2 (2, 4, 8, 16, 32, …),
  • compte le nombre de fois où on doit diviser ce nombre par 2 pour obtenir 1.
      MOV R12,#0        //nombre de divisions
      LDR R1,.InputNum  //choix du nombre
boucle:
      LSR R1,R1,#1      //divise par 2
      ADD R12,R12,#1    //incrémente compteur
      CMP R1,#1         //fin de boucle?
      BNE boucle
      STR R12, .WriteUnsignedNum //affiche la valeur
      HALT

Exercice 8

  • On souhaite écrire un programme qui demande à 10 élèves, leur durée du trajet lycée-maison (en minutes) et compte le nombre d’élèves dont le trajet dépasse 60 minutes.
  • À la fin le programme affichera ce nombre en sortie.
  • Ce nombre devra également être sauvegardé dans la mémoire vive de la machine.

Remettre les instructions dans l’ordre, afin de réaliser le programme.

      HALT
boucle:
      BNE boucle        
augmentecompteur:
      ADD R2,R2,#1      
      MOV R0,#0         //initialise le compteur
      LDR R1,.InputNum
      CMP R1,#60
      BLT augmentecompteur 
      ADD R0,R0,#1
      CMP R0,#10
      STR R2,.WriteUnsignedNum 
      MOV R2,#0         //initialise le nombre de durée
      STR R2,120       
      MOV R0,#0         //initialise le compteur
      MOV R2,#0         //initialise le nombre de durée
boucle:
      LDR R1,.InputNum
      CMP R1,#60
      BLT augmentecompteur // la valeur est <60: on ne la compte pas
      ADD R2,R2,#1      //compte la valeur
augmentecompteur:
      ADD R0,R0,#1
      CMP R0,#10
      BNE boucle        // tant qu'on n'a pas fait 10 tours
      STR R2,120        // stockage en mémoire
      STR R2,.WriteUnsignedNum // affichage
      HALT

Exercice 9

Pour faciliter le travail des enseignants, on se propose de construire un programme qui permet de calculer la moyenne des notes d’un élève.

Le programme devra:

  • demander à l’utilisateur de rentrer huit notes,
  • calculer la somme des notes,
  • calculer la moyenne,
  • afficher la moyenne.
    MOV R0,#0         //somme des notes
    MOV R12,#8        //nombre de notes
    MOV R11,#0        //compteur
bouclenote:
    LDR R1,.InputNum
    ADD R0,R0,R1      //ajoute note
    ADD R11,R11,#1    //incrémente compteur
    CMP R11,R12       //fin de boucle?
    BNE bouclenote
    LSR R0,R0,#3      //calcule moyenne
    STR R0,.WriteUnsignedNum
    HALT