Examen d'Architecture des ordinateurs SMI (S4) Juillet 2023

Examen PDF

Questions de cours

1. Quelles sont les différentes composantes d'un ordinateur? Expliquer leur fonctionnalités.
Correction
• Selon la modèle de Von Neumann, un ordinateur est composée de :
• Une mémoire principale : Permet de stocker les informations (programmes et données).
• Un microprocesseur : Chargé d'interpréter et d'exécuter les instructions d'un programme.
• Interfaces d'entrées et sorties E/S : Permet au microprocesseur de communiquer avec les périphériques externes.
• Bus d'adresses et données : Ensemble de fils conducteurs ou broches qui transporte des signaux binaires.
2. A quoi sert la segmentation de la mémoire ?
Correction
• La segmentation est une méthode qui permet de diviser la mémoire en segments (CS, DS, SS, EX).
3. Qu'est ce qu'un registre ?
Correction
• Un registre est une mémoire de petite taille rapide permet de stocker temporairement des données, instructions ou adresses.
4. Qu'est ce qu'une pile ?
Correction
• Une pile est une zone mémoire et une pointeur qui pointe sur le sommet de la pile.
5. Quels sont les registres utilisés pour manipuler une pile ?
Correction
• Registre SS (Stack Segment) segment pile : Registre qui conserve l'adresse de la pile.
• Registre SP (Stack Pointer) pointeur pile : Registre qui pointe sur le sommet de la pile.
6. Quelles sont les instructins utilisées pour manipuler une pile ?
Correction
• Il existe deux instructions pour manipuler une pile :
• PUSH registre : Empiler le contenu de registre sur le sommet de la pile.
• POP registre : Retire la valeur en haut de la pile et la place dans le registre spécifié.

Exercice 1

• Donner les commandes debug, avec la syntaxe complète qui permettent de faire les taches suivantes :

1. Afficher le contenu de la mémoire à l'adresse par défaut en tant que :

                   - Octets en hexadécimal 
                   - Octets en ASCII 
                   - Instructions
   

Correction

• Pour afficher le contenu de la mémoire à l'adresse par défaut en tant que octets en hexadécimal et octets en ASCII, il faut utiliser la commande:

d

• Pour afficher le contenu de la mémoire à l'adresse par défaut en tant que instructions, il faut utiliser la commande:

u

2. Remplir de 55 le premier Ko du segment N 073F.
Correction
• On a : 1Ko = 1024 octets, ce qui correspond à 400 en hexadécimal. Ainsi, pour remplir 1Ko, il faut remplir de l'offset de départ jusqu'à (départ + 400 - 1). Selon le professeur qui enseigne ce cours de 2022 à 2025, le segment commence à l'offset 0100. Par conséquent, pour remplir 1Ko, on remplit de 0100 à 400. Le segment de travail étant 073F, la commande pour remplir de 55 de 073F:0100 à 073F:0400 est :

f 073F:0100 0400 55

• Remarque : Cette réponse dépend de l'enseignant. Certains documents indiqueraient que le segment débute à 0000 (donc de 0000 à 03FF pour 1Ko), mais selon le professeur en charge de ce cours (2022-2025), le segment commence à 0100, ce qui modifie la plage de remplissage.
3. Placez les caractères "bonne chance" au début de segment N 073F.
Correction

• Le début de segment 073F est l'offset 0100, donc pour placez "bonne chance" il faut utiliser la commande :

e 073F:0100 "bonne chance"

4. Vérifier que ces caractères sont bien rangés en mémoire.
Correction

• Pour vérifier si ces caractères sont bien rangés en mémoire, il faut utiliser la commande :

d 073F:0000

5. Entrer le code B4 4C CD 21 à l'adresse 073F:0100h
Correction

• Pour entrer le code B4 4C CD 21, il faut utiliser la commande :

e 073F:0100 B4 4C CD 21 

6. Détérminer les instructions correspondant au code précédent.
Correction
• Pour détérminer les instructions correspondant au code, il faut utiliser la commande :

u 073F:0100

• Le code B4 4C correspondent a MOV AH, 4Ch et le code CD 21 correspondent a INT 21h.
• B4 4C se trouve dans l'adresse 073F:0100 et CD 21 se trouve dans l'adresse 073F:0102.

Exercice 2

• Ecrire un programme assembleur qui permet de :

1. Lire des chaînes de caractères autant de fois qu'on veut. Utiliser une procédure "lire_chaine" qui permet la lecture d'une chaîne de caractères.
2. Pour chaque chaine lue, calculer la longueur et déposer sa valeur dans le registre AX. Utiliser une procédure "longueur_chaine" qui calcule la longueur d'une chaine de caractères.
3. Afficher un par ligne les caractères de chaque chaine lue.
Correction
data SEGMENT
    msg_entrer DB "Veuillez vous entrer une chaine? 'O' si oui: ",'$'
    msg_lu DB "Chaine lu est: ",'$'
    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

    boucle:
        ; Afficher le message "Veuillez vous entrer une chaine?"
        MOV DX, offset msg_entrer
        MOV AH, 09H
        INT 21H

        ; Lire un caractère
        MOV AH, 01H
        INT 21H

        ; Comparer 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 et calculer sa longueur
        CALL lire_chaine
        CALL longueur_chaine

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

        ; Afficher le message "Chaine lu est:"
        MOV DX, offset msg_lu
        MOV AH, 09H
        INT 21H

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

        ; Afficher la chaîne entrée
        MOV BX, offset chaine
        boucle_afficher:
            MOV DL, [BX]
            CMP DL, '$'
            JE boucle
            MOV AH, 02H
            INT 21H
            ; Ajouter un saut de ligne
            MOV DL, 0AH
            MOV AH, 02H
            INT 21H
            INC BX
        JMP boucle_afficher

    fin:
        ; Fin du programme
        MOV AH, 4CH
        INT 21H

    lire_chaine PROC NEAR
        ; Lire une chaîne
        MOV DX, offset chaine
        MOV AH, 0AH
        INT 21H
        RET
    lire_chaine ENDP

    longueur_chaine PROC NEAR
        ; Calculer la longueur de la chaîne
        MOV BX, offset chaine
        MOV CX, 0

        boucle_proc:
            MOV AL, [BX]
            CMP AL, '$'
            JE fin_proc
            INC CX
            INC BX
            JMP boucle_proc

        fin_proc:
            MOV AX, CX
            RET
    longueur_chaine ENDP
code ENDS
END debut

Exercice 2

• Que fait le programme suivant :

        MOV bx, [0200]
        Mov ax, 15 
    Repeat: 
        SHL bx 
        Dec ax 
        JNE Repeat
        Mov [0140], bx 
        Mov ah, 4ch 
        Int 21h 

Correction
• Ce programme charge le registre bx avec la valeur existant à l'adresse 0200 et le registre ax par 15. Il boucle ensuite jusqu'à ce que ax devienne 0 (15 fois) et multiplie la valeur de BX par 2. Après la boucle, la valeur de BX devient (BX initial) x 2^15 et le programme se termine et retour au DOS