Organisation des ordinateurs

Dimension: px

Commencer à balayer dès la page:

Download "Organisation des ordinateurs"

Fabrice Briand
il y a 6 ans
Total affichages :

1 Organisation des ordinateurs Répétition 7 18 mai 2016 Université de Liège

2 Exercice 1

3 Exercice 1 Les instructions suivantes effectuent des transferts de 16 bits de données. On demande de décomposer chacune de ces instructions en deux instructions mov réalisant la même opération, mais avec des opérandes de 8 bits. (a) mov ax, 1234h mov al, 34h mov ah, 12h (b) mov ax, [1234h] mov al, [1234h] mov ah, [1235h] (c) mov bx, cx mov bh, ch mov bl, cl (d) mov [bx], cx mov [bx], cl mov [bx + 1], ch 3

4 Exercice 1 (e) mov word [bp + si - 6], 32h mov byte [bp + si - 6], 32h mov byte [bp + si - 5], 00h 4

5 Exercice 2

6 Exercice 2 Après l exécution de la séquence d instructions suivante, quel sera le contenu du registre ax? move ax, 100h mov bx, ax mov [bx + 1], ax mov [100h], ax mov si, [bx + 1] mov al, [si] mov ah, [bx + si - 101h] 6

7 Exercice 2 move ax, 100h mov bx, ax al ah mov [bx + 1], ax mov [100h], ax mov si, [bx + 1] mov al, [si] mov ah, [bx + si - 101h] Le contenu final de ax est 0001h. 7

8 Exercice 2 move ax, 100h mov bx, ax mov [bx + 1], ax mov [100h], ax al ah bl bh mov si, [bx + 1] mov al, [si] mov ah, [bx + si - 101h] Le contenu final de ax est 0001h. 7

9 Exercice 2 move ax, 100h mov bx, ax mov [bx + 1], ax mov [100h], ax mov si, [bx + 1] mov al, [si] al ah bl bh ?? mov ah, [bx + si - 101h] Le contenu final de ax est 0001h. 7

10 Exercice 2 move ax, 100h mov bx, ax mov [bx + 1], ax mov [100h], ax mov si, [bx + 1] mov al, [si] al ah bl bh mov ah, [bx + si - 101h] Le contenu final de ax est 0001h. 7

11 Exercice 2 move ax, 100h mov bx, ax mov [bx + 1], ax mov [100h], ax mov si, [bx + 1] mov al, [si] mov ah, [bx + si - 101h] Le contenu final de ax est 0001h. al ah bl bh si

12 Exercice 2 move ax, 100h mov bx, ax mov [bx + 1], ax mov [100h], ax mov si, [bx + 1] mov al, [si] mov ah, [bx + si - 101h] Le contenu final de ax est 0001h. al ah bl bh si

13 Exercice 2 move ax, 100h mov bx, ax mov [bx + 1], ax mov [100h], ax mov si, [bx + 1] mov al, [si] mov ah, [bx + si - 101h] Le contenu final de ax est 0001h. al ah bl bh si

14 Exercice 2 move ax, 100h mov bx, ax mov [bx + 1], ax mov [100h], ax mov si, [bx + 1] mov al, [si] mov ah, [bx + si - 101h] Le contenu final de ax est 0001h. al ah bl bh si

15 Exercice 3

16 Exercice 3 Pourquoi les instructions suivantes sont-elles incorrectes? (a) mov ax, cl Les opérandes n ont pas la même taille. (b) mov [ax], cl ax ne peut pas être utilisé pour l adressage indirect. (c) mov [bp + si], 99h On ne sait pas le nombre de bits des opérandes. Il faudrait mettre byte (8 bits) ou word (16 bits) devant mov pour le préciser. (d) mov 1234h, ax On ne peut pas écrire une valeur dans une constante. (e) move dx, [bp + bx] Les registres bp et bx ne peuvent pas être utilisés ensembles dans l adressage indirect indexé. 9

17 Exercice 3 (f) mov dx, bp + si La seconde opérande ne correspond à aucun mode d adressage. Pour calculer la somme des contenus de bp et si, il faudrait utiliser add. (g) mov dx, [bp - si - 9] On ne peut utiliser que la somme de deux registres dans l adressage indirect indexé, pas leur différence. 10

18 Exercice 4

19 Exercice 4 Écrire un programme assembleur 80x86 destiné à compter le nombre d octets non nuls contenus dans une suite d octets consécutifs du segment de données. L offset du premier octet est initialement contenu dans le registre BX et le nombre d octets de la suite se trouve dans le registre CX. On peut supposer que la suite contient au moins un octet. Le nombre d octets non nuls devra être contenu dans le registre AX en fin d exécution. 12

20 Exercice 4 BX : l offset du premier octet CX : le nombre d octets AX : sera le nombre d octets non nuls 13

21 Exercice 4 BX : l offset du premier octet CX : le nombre d octets AX : sera le nombre d octets non nuls Début et fin du programme SECTION.text ret 13

22 Exercice 4 BX : l offset du premier octet CX : le nombre d octets AX : sera le nombre d octets non nuls Début et fin du programme Initialiser ax SECTION.text mov ax, 0 ret 13

23 Exercice 4 BX : l offset du premier octet CX : le nombre d octets AX : sera le nombre d octets non nuls Début et fin du programme Initialiser ax Boucler sur les élements de la suite boucle: SECTION.text mov ax, 0 inc bx loop boucle ret 13

24 Exercice 4 BX : l offset du premier octet CX : le nombre d octets AX : sera le nombre d octets non nuls Début et fin du programme Initialiser ax Boucler sur les élements de la suite Si un octet n est pas nul, incrémenter ax SECTION.text mov ax, 0 boucle: cmp byte [bx], 0 je suivant inc ax suivant: inc bx loop boucle ret 13

25 Exercice 5

26 Exercice 5 Ecrire un programme assembleur 80x86 capable de calculer le produit scalaire de deux vecteurs de nombres entiers. Les composantes des vecteurs sont non signées et encodées sur 8 bits ; chaque vecteur correspond donc à une suite d octets consécutifs du segment de données. Les deux vecteurs à multiplier sont initialement pointés par les registres AX et BX. Le registre CX contient le nombre de composants de chaque vecteur (ils ont tous deux la même dimension, supposée non nulle). En fin d exécution, le registre DX doit contenir le produit scalaire de ces deux vecteurs. 15

27 Exercice 5 AX : le premier vecteur à multiplier BX : le deuxième vecteur à multiplier CX : le nombre de composants de chaque vecteur DX : sera le produit scalaire de ces deux vecteurs 16

28 Exercice 5 17

29 Exercice 5 Début et fin du programme SECTION.text ret 17

30 Exercice 5 Début et fin du programme Mettre la valeur de ax dans bp pour pouvoir utiliser l adressage indexé. SECTION.text mov bp, ax ret 17

31 Exercice 5 Début et fin du programme Mettre la valeur de ax dans bp pour pouvoir utiliser l adressage indexé. Initialiser dx et si SECTION.text mov bp, ax mov dx, 0 mov si, 0 ret 17

32 Exercice 5 Début et fin du programme Mettre la valeur de ax dans bp pour pouvoir utiliser l adressage indexé. Initialiser dx et si Boucler sur les vecteurs boucle: SECTION.text mov bp, ax mov dx, 0 mov si, 0 inc si loop boucle ret 17

33 Exercice 5 Début et fin du programme Mettre la valeur de ax dans bp pour pouvoir utiliser l adressage indexé. Initialiser dx et si Boucler sur les vecteurs Mettre la valeur de [bp + si] dans al pour préparer la multiplication. boucle: SECTION.text mov bp, ax mov dx, 0 mov si, 0 mov al, [bp + si] inc si loop boucle ret 17

34 Exercice 5 Début et fin du programme Mettre la valeur de ax dans bp pour pouvoir utiliser l adressage indexé. Initialiser dx et si Boucler sur les vecteurs Mettre la valeur de [bp + si] dans al pour préparer la multiplication. Multiplier [bx + si] avec al et mettre le résultat dans ax. boucle: SECTION.text mov bp, ax mov dx, 0 mov si, 0 mov al, [bp + si] mul byte [bx + si] inc si loop boucle ret 17

35 Exercice 5 Début et fin du programme Mettre la valeur de ax dans bp pour pouvoir utiliser l adressage indexé. Initialiser dx et si Boucler sur les vecteurs Mettre la valeur de [bp + si] dans al pour préparer la multiplication. Multiplier [bx + si] avec al et mettre le résultat dans ax. Ajouter le résultat à dx boucle: SECTION.text mov bp, ax mov dx, 0 mov si, 0 mov al, [bp + si] mul byte [bx + si] add dx, ax inc si loop boucle ret 17

36 Des questions? 18

37 Theme Get the source of this theme and the demo presentation from github.com/matze/mtheme The theme itself is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License. cba 19

Documents pareils

Assembleur i8086. Philippe Preux IUT Informatique du Littoral. Année universitaire 95 96

Assembleur i8086. Philippe Preux IUT Informatique du Littoral. Année universitaire 95 96 Assembleur i8086 Philippe Preux IUT Informatique du Littoral Année universitaire 95 96 1 Avertissement Ce document décrit le langage d assemblage étudié et utilisé dans le cadre des TP d architecture.