Examen d'Architecture des ordinateurs SMI (S4) Juin 2022

Examen PDF

Questions de cours

1. Citez et classez les différents registres que vous connaissez :
Correction
• Registres généraux : AX, BX, CX, DX
• Registres Segments : DS, CS, SS, ES
• Registres offset : IP, BP, SP
• Registres d'état : Les indicateurs OF, CF, ZF, NF, ...
2. Donner et expliquez les instructions qui permettent la manipulation de la pile :
Correction
• Il existe deux instructions qui permettent la manipulation de la pile :
  PUSH registre : Empiler le contenu de la registre sur le sommet de la pile. POP registre : Retire le valeur en haut de la pile et la place dans le registre spécifié.
3. A qoui sert le registre IP? Expliquez la changement de son état lors d'un appel de procédure :
Correction
• Le registre IP conserve l'adresse de l'instruction prochaine à exécuter.
• Aprés l'appel, la procédure empile la valeur de IP qui pointe sur l'instruction qui suit le CALL, puis placer dans IP l'adresse de la première instruction de la procédure. Ensuite, l'instruction RET dépile la valeur initiale de IP.
4. Quel est le rôle du registre d'état ?
Correction
• Le registre d'état est un ensemble des indicateurs qui stocke certaines informations particulières concernant les opérations effectuées.

Exercice 1

• Avec la commande debug "u" on a eu le code suivant correspondant á un programme assembleur exécutable

-u cs:0000 
0D31:0000 B8320D                MOV             AX, 0D32
0D31:0003 8ED8                  MOV             DS, AX
0D31:0005 BA0000                MOV             DX, 0000
0D31:0008 B409                  MOV             AH, 09
0D31:000A CD21                  INT             21
0D31:000C B44C                  MOV             AH, 4C 
0D31:000E CD21                  INT             21

1. Que fait ce programme ?
Correction
• Ce programme affiche le chaine qui se trouve dans l'offset 0000 puis retour en DOS.
2. Donnez l'adresse complète de la donnée manipulée
Correction
• À partir de 0D31:0000 on a l'instruction MOV AX, 0D32 qui charge le segment de données dans le registre AX et d'après 0D31:0005, on a l'instruction MOV DX, 0000 qui charge l'offset 0000 dans le registre DX donc, l'adresse complète de la donnée manipulée est: 0D32:0000
3. Donnez l'adresse du segment code.
Correction
• À partir de le code au-dessus, l'adresse du segment code est 0D31.

Exercice 2

• Écrire les codes assembleur correspondants aux pseudo-codes suivants :

1. bx = 1
   For cx = 0 to 9 
   bx = bx + cx
   endfor
   

   Correction

   data SEGMENT
       ; Pas de déclarations
   data ENDS
   
   code SEGMENT
       ASSUME DS: data, CS: code
   
       debut:
           MOV AX, data
           MOV DS, AX
   
           MOV BX, 1
           MOV CX, 0
   
       Boucle:
           ADD BX, CX
           INC CX
           CMP CX, 9
       JLE Boucle
   
           MOV AH, 4CH
           INT 21H
   code ENDS
   END debut
   

2. mov bx, 30 
   while bx > 0 do 
   bx = bx - 1
   endwhile
   

   Correction

   data SEGMENT
       ; Pas de déclarations
   data ENDS
   
   code SEGMENT
       ASSUME DS: data, CS: code
   
       debut:
           MOV AX, data
           MOV DS, AX
           MOV BX, 30
   
       condition:
           CMP BX, 0
       JG Boucle
   
           MOV AH, 4CH
           INT 21H
   
       Boucle:
           DEC BX
       JMP condition
   
   code ENDS
   END debut
   

Exercice 3

1. Écrire un programme assembleur qui permet de lire des chaînes de caractères autant de fois qu'on veut. Le nombre de chaînes lues est retourné finalement dans le registre CX.
Correction

data SEGMENT
    msg_entrer DB "Veuillez vous entrer une chaine? 'O' si oui: ",'$'
    chaine DB 20 dup('?'), '$'
data ENDS

code SEGMENT
    ASSUME DS: data, CS: code
    
    debut:
        ; Initialiser le segment de données
        MOV AX, data
        MOV DS, AX
        
        MOV CX, 0

    boucle:
        ; Afficher le message pour demander une entrée
        MOV DX, offset msg_entrer
        MOV AH, 09h
        INT 21h

        ; Lire un caractère de l'utilisateur
        MOV AH, 01h
        INT 21h

        ; Vérifier si le caractère est 'O'
        CMP AL, 'O'
        JNE fin

        ; Ajouter un saut de ligne
        MOV DL, 0Ah
        MOV AH, 02h
        INT 21h

        ; Lire une chaîne
        MOV DX, offset chaine
        MOV AH, 0Ah
        INT 21h

        ; Incrémenter le compteur
        INC CX

        ; Ajouter un saut de ligne
        MOV DL, 0Ah
        MOV AH, 02h
        INT 21h

        JMP boucle

    fin:
        ; Terminer le programme
        MOV AH, 4Ch
        INT 21h

code ENDS
END debut

2. Donner le programme assembleur qui calcule la longueur d'une chaîne de caractères et qui renvoie de résultat dans le registre AX. La Chaîne de caractères doit être lue.
Correction

data SEGMENT
    msg_entrer DB "Entrer une chaine: ",'$'
    chaine DB 20 dup('?'), '$'
data ENDS

code SEGMENT
    ASSUME DS: data, CS: code
    
    debut:
        ; Initialisation du segment de données
        MOV AX, data
        MOV DS, AX

        ; Afficher le message d'invite
        MOV DX, offset msg_entrer
        MOV AH, 09H
        INT 21H
        
        ; Lire une chaîne de l'utilisateur
        MOV DX, offset chaine
        MOV AH, 0Ah
        INT 21H

        ; Initialisation des registres pour le parcours de la chaîne
        MOV BX, offset chaine
        MOV CX, 0
        
    boucle:
        ; Lire un caractère à l'adresse courante
        MOV AL, [BX]
        ; Vérifier si le caractère est '$'
        CMP AL, '$'
        JE fin

        ; Incrémenter le compteur et passer au caractère suivant
        INC CX
        INC BX
        JMP boucle
    
    fin:
        ; Stocker le résultat dans AX
        MOV AX, CX
        
        ; Terminer le programme
        MOV AH, 4Ch
        INT 21H

code ENDS
END debut

Exercice 4

• Écrire un programme assembleur qui lit autant de caractères majuscule qu'on veut. Chaque caractère lu est converti en miniscule et affiché.
  Utiliser deux procédures "lire_caractere" et "converti_caractere" qui permettent respectivement de lire un caractere et convertir en caractere majuscule en miniscule.
Correction
data SEGMENT
    msg_entrer DB "Veuillez vous saisir un caractere ? 'O' si oui: ",'$'
    msg_min DB "Caractere minuscule : ",'$'
    msg_maj DB "Caractere majuscule : ",'$'
data ENDS

code SEGMENT
    ASSUME DS: data, CS: code
    
    debut:
        ; Initialiser le segment de données
        MOV AX, data
        MOV DS, AX

    boucle:
        ; Afficher le message d'invite
        MOV DX, offset msg_entrer
        MOV AH, 09h
        INT 21h
        
        ; Lire un caractère
        CALL lire_caractere
        
        ; Vérifier si le caractère est 'O'
        CMP AL, 'O'
        JNE fin

        ; Ajouter un saut de ligne
        MOV DL, 0Ah
        MOV AH, 02h
        INT 21H

        ; Afficher le message "Caractere majuscule"
        MOV DX, offset msg_maj
        MOV AH, 09h
        INT 21h

        ; Lire un autre caractère
        CALL lire_caractere

        ; Sauvegarder le caractère dans BL
        MOV BL, AL

        ; Ajouter un saut de ligne
        MOV DL, 0Ah
        MOV AH, 02h
        INT 21h

        ; Convertir en minuscule
        CALL converti_caractere
        
        ; Afficher le message "Caractere minuscule"
        MOV DX, offset msg_min
        MOV AH, 09H
        INT 21H

        ; Afficher le caractère converti
        MOV DL, BL
        MOV AH, 02H
        INT 21H

        ; Ajouter un saut de ligne
        MOV DL, 0AH
        MOV AH, 02H
        INT 21H
        
        JMP boucle
    
    fin:
        ; Terminer le programme
        MOV AH, 4CH
        INT 21H

    lire_caractere PROC NEAR
        MOV AH, 01H
        INT 21H
        RET
    lire_caractere ENDP

    converti_caractere PROC NEAR
        OR BL, 00100000b
        RET
    converti_caractere ENDP
code ENDS
END debut