Assembleur Exercices

PDF pour impression #

Tous les exercices utilisent l’assembleur présenté en cours et rappelé ci-dessous.

Déplacements #

Opérations arithmétiques #

Rupture de séquence #

Exercice 1 #

Remplacer chaque instruction suivante par son mnemonique puis dérouler le programme pas à pas.

    Charger la valeur 2 dans le registre 3
    Charger la valeur 5 dans le registre 1
    Ajouter les registres 3 et 1 et enregistrer dans le registre 2
    Soustraire 25 du registre 2 et enregistrer dans le registre 1
    Comparer les registres 3 et 1
    Si la comparaison est différente, sauter à FIN
    Charger la valeur 1 dans le registre 2
FIN:
    arrêter le programme

Quels sont les états des registres ?

Exercice 2 #

Dérouler le programme suivant, noter les états finaux des variables x, y, z puis le traduire en assembleur et recommencer.

x = 8
y = 12
z = x + y
if z == x:
  x = y
else:
  x = z

Exercice 3 #

Traduire le programme suivant en langage naturel et le dérouler ligne par ligne.

    MOV R1, #10
    MOV R2, #12
    ADD R3, R2, R1
    CMP R1, R2
    BNE Different
    SUB R3, R2, R1
    B Fin
Different:
    SUB R2, R1, R3
Fin:
    HALT

Exercice 4 #

La mémoire contient aux adresses 200 à 210 les entiers entre 0 et 10 :

    LDR R1, 202
    LDR R2, 203
    ADD R3, R2, R1
    STR R3, 200
    LDR R1, 200
    LDR R2, 204
    SUB R3, R2, R1
    STR R3, 203

Dérouler le programme suivant, on notera l’état final de la mémoire et des registres.

Exercice 5 - Boucle #

Il existe de nombreuses manières d’écrire une boucle en assembleur.

Le principe consiste à renvoyer à la même adresse tant qu’une condition n’est pas remplie.

    MOV R1, #0
    MOV R2, #1
    MOV R3, #4
Boucle:
    CMP R1, R3
    BEQ Fin
    ADD R1, R1, R2
    B Boucle
Fin:
    HALT

1. Dérouler le programme précédent pas à pas. Combien de les instructions entre Boucle: et Fin: seront-elles exécutées ?
2. Modifier le programme afin que 10 tours de boucle soient réalisés.
3. Modifier le programme afin que la boucle soit infinie.

Exercice 6 - Boucle en Python #

Voici un programme Python qui utilise une boucle pour calculer un montant après 10 ans sur un compte rapportant 150€ d’intérêts annuels.

capital = 2000
for annee in range(10);
  capital += 150

1. Quel est le montant de capital après l’exécution du programme ?
2. Traduire ce programme en assembleur.

Exercice 7 - Compteur #

Voici un programme qui compte le nombre d’années nécessaires pour doubler un capital.

capital = 3000
double = 2 * capital
annee = 0
while capital < double:
  capital += 150
  annee += 1

1. Combien d’années sont nécessaires ? Résoudre mathématiquement la question.
2. Faire tourner en Python en le programmant sur votre calculatrice. Ajouter les instructions nécessaires pour consulter le solde final et le nombre d’années.
3. Traduire ce programme en assembleur.

Exercice 8 - Multiplication #

L’assembleur dont nous disposons ne contient aucune instruction permettant de multiplier deux entiers.

Afin de réaliser une multiplication, il faut la programmer avec des additions.

Par exemple le produit de 3 par 12 peut être calculé par des additions de deux manières :

$3 \times 12 = 12 + 12 + 12$ ou $12 \times 3 = 3 + 3 + 3 + 3 + 3 + 3 + 3 + 3 + 3 + 3 + 3 + 3$

De toute évidence, une approche est meilleure que l’autre…

1. Sans se soucier d’optimiser.

Compléter le programme suivant afin qu’il réalise le produit $3 \times 12$

R1: 3, R2: 12, R3: résultat de la multiplication, R4: nombre d’additions déjà réalisées.

    MOV R1, #3
    MOV R2, #12
    MOV R3, #0
    MOV R4, #0
  Produit:
    CMP R4, R2
    BEQ Fin
    ADD R3, R3, R1
    ...
    B Produit
Fin:
    HALT

2. En cherchant à minimiser le nombre d’instruction

Il est préférable de réaliser $12 + 12 + 12$ que $3+ 3 + \cdots + 3$.

Afin d’améliorer le temps de calcul, nous allons comparer les nombres et utiliser deux registres supplémentaires.

1. On charge dans R5 le plus petit de R1 et R2,
2. On charge dans R6 le plus grand de R1 et R2,
3. On réalise R5 * R6

Mémoire :

    LDR R1, 200
    LDR R2, 201
    MOV R3, #0
    MOV R4, #0
    CMP R1, R2
    BLT Petit
    MOV R5, R2
    MOV R6, R1
    B Produit
  Petit:
      ...
      ...
  Produit:
    CMP R4, R5
    BEQ Fin
    ...
    ...
    B Produit
Fin:
    HALT

Compléter le programme suivant. Vérifier qu’il exécute bien l’opération optimale.

Exercice 9 - Division Euclidienne #

Nous allons réaliser la division Euclidienne pour calculer le quotient et le reste d’une division.

$20 = 7 \times 2 + 6$

La division Euclidienne de $20$ par $7$ a pour quotient $2$ et reste $6$.

Voici l’algorithme de la division Euclidienne de $a$ par $b$ utilisant des soustractions successives :

Diviser(a: entier, b: entier)
  a et b deux entiers.
  q = 0

  Tant que a >= b faire
    a = a - b
    q = q + 1

  r = a

  renvoyer q et r

1. Traduire ce programme en assembleur.
2. Vérifier qu’il renvoie le résultat correct pour les divisions de $7$ par $2$ et de $21$ par $4$