Assembleur 8086+ : exercice 3

Table des matières

Comme d'habitude, je ne détaillerai rien concernant la compilation/l'édition des liens encore cette fois-ci. Reportez-vous au premier billet pour plus d'informations.

Exercice 3 : énoncé

  1. Déclarez un tableau d'octets dans le segment de données. Celui-ci contiendra 10 nombres entiers entre 0 et 255 inclus, que vous choisirez. Déclarez ensuite un mot, que vous appellerez, par exemple, somme. Sans utiliser l'instruction loop, et en utilisant les sauts, faites la somme des entiers du tableau puis affichez cette somme avec les chiffres décimaux.
  2. Afficher cette somme en binaire

Note : Comme d'habitude, cet énoncé n’est pas de moi : je l’ai repris à T.M. / E.R. et je l’ai modifié.

Aides

Il faut :

  • Se renseigner sur les différents sauts conditionnels disponibles et réfléchir sur la manière de construire une boucle en les utilisant.
  • Se souvenir que l'on a déjà écrit un bout de code permettant d'afficher un nombre < 1000. Il suffit de l'adapter pour traiter les nombres < 10000. Pour cela, il suffit d'ajouter une "itération" à la division successive.
  • Pour afficher le contenu d'un registre ou d'une adresse mémoire en binaire, il suffit de faire une boucle (dont le nombre d'itération dépend la taille du registre ou de la taille de l'espace mémoire. Exemple : pour un registre 16 bits => 16 itérations), à l'intérieur de laquelle on effectue un décalage logique vers la gauche (instruction SHL) puis de tester le Carry Flag (drapeau de retenue), si le drapeau est levé, alors on affiche le caractère 1, sinon on affiche le caractère 0. Pour tester cela, il existe le saut JC.
  • Pour les contraintes liées aux primitives système de GNU/Linux (sauvegarder les registres avant, la fonction write veut une adresse mémoire, etc.), vous savez déjà tout si vous avez suivi les billets précédent.
 DOSSEG

.MODEL SMALL
 
.STACK
 
.DATA
    message db 'Somme des entiers contenus dans le tableau : $'

    message2 db 13,10,'Somme, en binaire, des entiers contenus dans le tableau : $'
 
    tableau db 255, 234, 185, 164, 18, 15, 16, 32, 64, 91

    somme dw 0
 
.CODE
    mov ax, @DATA

    mov ds, ax
 
    mov ax, 0

    mov bx, 0
    bcl: 
        cmp bx, 9

        ja fin
 
        mov al, [tableau+bx]
        add [somme], ax

 
    inc bx
    jmp bcl
 
    fin:
        mov ah, 09h

        mov dx, offset message
        int 21h
 
        mov dx, 0

        mov ax, [somme]
        mov bx, 1000
        div bx

 
        mov cx, ax
        mov bx, dx

        mov ah, 02h
        mov dl, cl
        add dl, 30h

        int 21h
 
        mov ax, bx
        mov bl, 100

        div bl
 
        mov cx, ax
        mov ah, 02h

        mov dl, cl
        add dl, 30h
        int 21h

 
        mov ax, 0000h
        mov bl, 10

        mov al, ch
        div bl
 
        mov cx, ax

        mov ah, 02h
        mov dl, cl
        add dl, 30h

        int 21h
 
        mov ah, 02h
        mov dl, ch

        add dl, 30h
        int 21h
 
        mov ah, 09h

        mov dx, offset message2
        int 21h
 
        mov bx, [somme]

        mov cx, 16
        bcl0 :    
            debut_si :     shl bx, 1

                        jc aff1                
 
                        mov ah, 02h            
                        mov dl, '0'

                        int 21h
                        jmp fin_si
 
            aff1 :         mov ah, 02h

                        mov dl, '1'
                        int 21h
 
            fin_si : 
        loop bcl0

 
        ; FIN
        mov ax, 4C00h
        int 21h

END

Exercice 3 : sous Windows, avec Nasm et le linker Val

segment .data
    message db 'Somme des entiers contenus dans le tableau : $'
    message2 db 13,10,'Somme, en binaire, des entiers contenus dans le tableau : $'

 
    tableau db 255, 234, 185, 164, 18, 15, 16, 32, 64, 91

    somme dw 0
 
segment stack stack
    resb 64

    stackstop:
 
segment .code
..start:
    mov ax, data

    mov ds, ax
 
    mov ax, stack

    mov ss, ax
    mov sp, stackstop
 
    mov ax, 0

    mov bx, 0
    bcl: 
        cmp bx, 9

        ja finbcl
 
        mov al, [tableau+bx]
        add [somme], ax

 
    inc bx
    jmp bcl
 
    finbcl:
        mov ah, 09h

        mov dx, message
        int 21h
 
        mov dx, 0

        mov ax, [somme]
        mov bx, 1000
        div bx

 
        mov cx, ax
        mov bx, dx

        mov ah, 02h
        mov dl, cl
        add dl, 30h

        int 21h
 
        mov ax, bx
        mov bl, 100

        div bl
 
        mov cx, ax
        mov ah, 02h

        mov dl, cl
        add dl, 30h
        int 21h

 
        mov ax, 0000h
        mov bl, 10

        mov al, ch
        div bl
 
        mov cx, ax

        mov ah, 02h
        mov dl, cl
        add dl, 30h

        int 21h
 
        mov ah, 02h
        mov dl, ch

        add dl, 30h
        int 21h
 
        mov ah, 09h

        mov dx, message2
        int 21h
 
        mov bx, [somme]

        mov cx, 16
        bcl0 :    
            debut_si :     shl bx, 1

                        jc aff1                
 
                        mov ah, 02h            
                        mov dl, '0'

                        int 21h
                        jmp fin_si
 
            aff1 :         mov ah, 02h

                        mov dl, '1'
                        int 21h
 
            fin_si : 
        loop bcl0

 
        ; FIN
        mov ax, 4C00h
        int 21h

Exercice 3 : sous GNU/Linux, avec Nasm et ld

section .data
    message db 'Somme des entiers contenus dans le tableau : '
    lenMessage equ $-message

 
    message2 db 13,10,'Somme, en binaire, des entiers contenus dans le tableau : '
    lenMessage2 equ $-message2

 
    fin db 10,'FIN',10
    lenFin equ $-fin 

 
    tableau db 255, 234, 185, 164, 18, 15, 16, 32, 64, 91

 
    zero db '0'
    lenZero equ $-zero
    un db '1'

    lenUn equ $-un
 
section .bss
    chiffre1 resb 1

    chiffre2 resb 1
    chiffre3 resb 1
    chiffre4 resb 1

    save: resb 1
    somme: resw 1
 

section .text
global _start
_start:
    mov word [somme], 0

    mov ax, 0
    mov ebx, 0
    bcl: 
        cmp ebx, 9

        ja finbcl
 
        mov al, [tableau+ebx]
        add [somme], ax

 
        inc ebx
    jmp bcl
 
    finbcl:
        mov eax, 4

        mov ebx, 1
        mov ecx, message
        mov edx, lenMessage
        int 80h

 
        mov dx, 0
        mov ax, [somme]

        mov bx, 1000
        div bx
 
        add ax, 30h

        mov [chiffre1], ax
 
        mov ax, dx

        mov bl, 100
        div bl
 
        add al, 30h

        mov [chiffre2], al
 
        mov bl, 10

        mov al, ah
        mov ah, 0
        div bl

 
        add al, 30h
        mov [chiffre3], al

 
        add ah, 30h
        mov [chiffre4], ah

 
        mov eax, 4
        mov ebx, 1

        mov ecx, chiffre1
        mov edx, 1
        int 80h

 
        mov eax, 4
        mov ebx, 1

        mov ecx, chiffre2
        mov edx, 1
        int 80h

 
        mov eax, 4
        mov ebx, 1

        mov ecx, chiffre3
        mov edx, 1
        int 80h

 
        mov eax, 4
        mov ebx, 1

        mov ecx, chiffre4
        mov edx, 1
        int 80h

 
        mov eax, 4
        mov ebx, 1

        mov ecx, message2
        mov edx, lenMessage2
        int 80h

 
        mov ebx, 0
        mov si, [somme]

        mov cx, 16
        bcl0 :    
            debut_si :     mov [save], cx

 
                    shl si, 1
                    jc aff1                
 
                    mov eax, 4

                    mov ebx, 1
                    mov ecx, zero
                    mov edx, lenZero
                    int 80h

                    jmp fin_si
 
            aff1 :         mov eax, 4
                    mov ebx, 1

                    mov ecx, un
                    mov edx, lenUn
                    int 80h

 
            fin_si :     mov ecx, 0
                    mov cx, [save]

        loop bcl0
 
        ; FIN
        mov eax, 4
        mov ebx, 1

        mov ecx, fin
        mov edx, lenFin
        int 80h

 
        mov eax, 1
        mov ebx, 0

        int 80h

Aucun commentaire.

Ajoutez votre commentaire