Affichage d'un int (4 octets = 32 bits)

**AKteko** · 08/10/2014, 22h01

Bonjour à tous !

Quelqu'un pourrait me dire comment afficher un entier en assembleur 8086 ?
En fait, je le fais assez aisément avec les chaînes de caractères avec l'interruption int 0x80 et ses paramètres.
Merci !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
                print_string:
			push ebp
			mov ebp,esp
			mov eax , 4
			mov ebx , 1
			mov ecx , [ebp + 8] # je dépile l addresse de ma chaine
			mov edx, [ebp + 12] # je depile sa longueur
			int 0x80 # j appelle l iterruption
			pop esp
		ret

Invité · 09/10/2014, 06h38

Envoyé par AKteko

Bonjour à tous !

Quelqu'un pourrait me dire comment
afficher un entier en assembleur 8086
En fait je le fait assez aisément avec les chaines
de caractère avec l'interruption int 0x80 et ses paramètres
Merci !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
                print_string:
 
			push ebp
 
			mov ebp,esp
 
			mov eax , 4
 
			mov ebx , 1
 
			mov ecx , [ebp + 8] # je dépile l addresse de ma chaine
 
			mov edx, [ebp + 12] # je depile sa longueur
 
			int 0x80 # j appelle l iterruption
 
			pop esp
 
		ret

Votre code n'est pas de l'assembleur 8086, car sur les 8086 il n-y a pas de registres 32 bits.

Invité · 09/10/2014, 07h13

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
    co_int_to_str:; eax = entier sur 32 bits, edi = destination str ( 10 caractères maximum)
        push eax
        push ebx
        push ecx
        push edx
        push edi
        add edi, 9
             mov ecx, 10
             mov ebx, ecx
             .label0:
                  xor edx, edx
                  div ebx
                  add dl, '0'
                  mov [edi], dl
                  dec edi
             loop .label0
        pop edi
        pop edx
        pop ecx
        pop ebx
        pop eax
   ret

Programme non testé !

**AKteko** · 14/10/2014, 00h57

j'aurai du écrire qu'il est en 80x86 merci!
Mais quoi qu'il en soit j'ai résolu mon problème j'ai trouvé
une façon assez cool de le faire. je le met là ça
pourra aider un autre débutant comme moi !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
scanf_int:
          push ebp
          mov ebp, esp
          pusha
          push [ebp+8]
          push offset desc_int
          call scanf
          add esp,8
          popa
          pop ebp
          ret
 
print_int:
          push ebp
          mov ebp, esp
          pusha
          push [ebp+8]
          push offset desc_int
          call printf
          add esp,8
          popa
          pop ebp
          ret

**MIG86** · 03/07/2015, 17h04

Il s'agit de code 32 bits (microprocesseur 80386 et suivants). La fonction printf ne fait-elle pas partie du langage C ?
Dans la discussion [MASM]Petite demande d'aide, j'avais exposé une méthode pour assembleur 8086. Voici à nouveau le contenu du fichier source dont l'intérêt se trouve dans les procédures :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
                        PAGE    64,132
; Demande l'entrée d'un nombre entier décimal pouvant être stocké dans un
; double-mot signé de 32 bits.
; Assemblage :
;       MASM    DEC2HEX;
;       LINK    DEC2HEX;
;       EXE2BIN DEC2HEX DEC2HEX.COM
 
 
CGROUP  GROUP   CODE, DATA?
 
 
LgNombre        equ     11
 
 
CODE    SEGMENT
        ASSUME  CS:CODE, DS:CGROUP
        ORG     100h
 
Depart:
        mov     Somme,0                 ; Initialise le double-mot Somme
        mov     Somme+2,0
        mov     ah,9                    ; Affiche message
        mov     dx,offset MsgEntree
        int     21h
        mov     ah,0Ah                  ; Attend entrée
        mov     dx,offset TeteTampon
        int     21h
        call    LireDecimalSgn
        jnc     Sortie                  ; Si pas d'erreur, sortie hexa
 
        cmp     ax,1                    ; Erreur de frappe ?
        jne     Err2
        mov     ah,9
        mov     dx,offset MsgTypo
        int     21h
        jmp     Depart                  ; Recommencez entrée
Err2:
        cmp     ax,2                    ; Erreur de débordement ?
        jne     fin                     ; Si inégal, erreur inconnue
        mov     ah,9
        mov     dx,offset MsgDebord
        int     21h
        jmp     Depart                  ; Recommencez entrée
Sortie:
        mov     ah,9
        mov     dx,offset MsgSortie
        int     21h
        std                             ; Direction : décrémentation
        mov     cx,4                    ; Double-mot (4 octets)
        mov     si,offset ds:Somme+3    ; Octet de poids fort
Affiche_octet:
        lodsb                           ; AL = DS:[SI]  et  DEC SI
        call    AfficheHexa             ; Affiche les 2 chiffres hexa
        loop    Affiche_octet
Fin:
        ret                             ; Fin
                        PAGE
LireDecimalSgn  PROC
; Lit le nombre décimal signé dans la chaîne Tampon avant de le traduire dans
; le double-mot Somme.
; Entrée :      DS:SI   pointe la chaîne dont le 1er octet donne le nb de car.
; Sortie :      Si succès, bit de retenue effacé et AX = 0
;               Si échec, bit de retenue positionné, AX = code d'erreur
;               Code d'erreur : 1, erreur de frappe
;                               2, erreur de débordement
; Lit :         Tampon
;               [1er car. : nb de car. (éventuel sgn "-" puis chiffres)]
; Ecrit :       Somme (double-mot)
; Procédure utilisée :  PuissDix
        push    bx
        push    cx
        push    dx
        push    si
        pushf                           ; sauve le registre d'état car CLD
 
        cld                             ; Direction : incrémentation
        xor     ch,ch                   ; CH = 0
        mov     cl,Tampon               ; Nb de caractères
        mov     si,offset ds:Tampon+1   ; DS:SI pointe le premier caractère
        cmp     byte ptr [si],'-'       ; Négatif ?
        jne     Boucle
        dec     cx                      ; Nombres de chiffres si négatif
        inc     si                      ; Pointe le premier chiffre
Boucle:
        lodsb                           ; AL = DS:[SI]  et  INC SI
        cmp     al,'0'
        jb      Err_typo
        cmp     al,'9'
        ja      Err_typo
        sub     al,'0'                  ; Valeur du chiffre dans AL
 
        xor     ah,ah                   ; AH = 0
        xor     dx,dx                   ; DX = 0
        dec     cx                      ; Exposant = compteur - 1
        call    PuissDix                ; DX:AX = (DX:AX).10^CX
        jc      Err_debord1             ; Erreur ?
        or      dx,dx
        js      Err_debord1             ; Nb négatif ?
        inc     cx
 
        add     Somme,ax                ; Addition des mots de poids faible
        adc     Somme+2,dx              ; Add. avec retenue des mots de pds fort
        jc      Err_debord1             ; Retenue ?
        jo      Err_debord2             ; Débordement ?
        loop    Boucle                  ; Déc. CX et recommence si non nul
                        PAGE 
        cmp     Tampon+1,'-'            ; Rendre négatif ?
        jne     Retour_bon
        neg     Somme                   ; Complément à 2 du mot de poids faible
        jnz     Non_reversible          ; Si poids faible nul,
        dec     Somme+2                 ; décrémentation du poids fort
Non_reversible:
        not     Somme+2                 ; Complément à 1 du mot de poids fort
Retour_bon:
        xor     ax,ax
        popf
        clc                             ; CF = 0
Retour_mauvais:
        pop     si
        pop     dx
        pop     cx
        pop     bx
        ret
Err_typo:
        mov     ax,1
        jmp     short Erreur
Err_debord2:
        cmp     word ptr Somme,0
        jne     Err_debord1
        cmp     word ptr Somme+2,8000h
        jne     Err_debord1
        cmp     Tampon+1,'-'
        je      Retour_bon              ; Plus petit nombre possible
Err_debord1:
        mov     ax,2
Erreur:
        popf
        stc                             ; CF = 1
        jmp     Retour_mauvais
LireDecimalSgn  ENDP
                        PAGE
PuissDix        PROC
; Stocke (DX:AX).10^CX dans l'entier non signé DX:AX
; Entrée :      DX:AX   multiple non signé
;               CX      exposant non signé
; Sortie :      Si bit de retenue effacé,
;               DX:AX   résultat après facteur 10 puissance CX
;               sinon débordement.
        push    bx
        push    cx
        push    si
        push    di
 
        jcxz    Ret_PuissDix            ; Si CX nul, retour
        mov     bx,10                   ; BX : multiplicateur 10
        mov     si,dx                   ; SI <- poids fort
FoisDix:
        xchg    di,ax                   ; DI <- poids faible
        xchg    ax,si                   ; AX <- poids fort
        mul     bx                      ; DX:AX (poids fort) = AX x 10
        or      dx,dx                   ; DX nul ?
        jnz     Debordement             ; Si non, erreur (32 bits insuff.)
        xchg    si,ax                   ; SI <- poids fort
        xchg    ax,di                   ; AX <- poids faible
        mul     bx
        add     si,dx                   ; Retenue dans le poids fort
        loop    FoisDix
 
        mov     dx,si                   ; DX <- poids fort
        clc                             ; CF = 0
Ret_PuissDix:
        pop     di
        pop     si
        pop     cx
        pop     bx
        ret
Debordement:
        stc                             ; CF = 1
        jmp     Ret_PuissDix
PuissDix        ENDP
                        PAGE
AfficheHexa     PROC
; Affiche l'octet an AL sous forme de 2 chiffres hexa.
; Entrée :      AL      octet à afficher
; Procédure utilisée :  SortChiffreHexa
        push    ax
        push    cx
 
        mov     ah,al                   ; Sauve AL dans AH
        mov     cl,4
        shr     al,cl                   ; AL : quartet de poids fort
        call    SortChiffreHexa
        mov     al,ah                   ; Restitue AL
        and     al,0Fh                  ; AL : quartet de poids faible
        call    SortChiffreHexa
 
        pop     cx
        pop     ax
        ret
AfficheHexa     ENDP
 
SortChiffreHexa PROC
; Affiche un chiffre hexa stocké dans AL.
; Entrée :      AL      chiffre hexa
        push    ax
        push    dx
                                        ; Ex. : 0Ah        |    00h 
        add     al,90h                  ;       9Ah        |    90h
        daa                             ;    (1)00h        |    90h
        adc     al,40h                  ;       41h        |    D0h
        daa                             ;       41h -> 'A' | (1)30h -> '0'
        xchg    dx,ax                   ; DL <- AL
        mov     ah,2                    ; Affiche caractère
        int     21h
 
        pop     dx
        pop     ax
        ret
SortChiffreHexa ENDP
 
; Données -------------------------------------------------------------------
 
MsgEntree       db      13,10,'Entier décimal à convertir :',13,10,'$'
MsgTypo         db      13,10,'Caractères autres que les chiffres et le signe '
                db      '"-" refusés. Recommencez.$'
MsgDebord       db      13,10,'Nombre hors limites. Recommencez.$'
MsgSortie       db      13,10,"L'équivalent hexadécimal est :",13,10,'$'
 
; Donne le nombre d'octets nécessaire à l'entrée du nombre pour DOS
TeteTampon      db      LgNombre+1      ; Précède Tampon
 
CODE    ENDS
 
 
DATA?   SEGMENT BYTE
 
; Prend en compte l'enregistrement de la touche Entrée (car. 13)
Tampon          db      LgNombre+2 dup(?) ; Suit TeteTampon
 
Somme           dw      2 dup(?)
 
DATA?   ENDS
 
 
        END     Depart

Des instructions 32 bits auraient bien sûr facilité la chose. Ainsi, une instruction aurait suffi pour rendre la variable somme négative (complément à deux). Cependant, c'est intéressant de voir comment manipuler un nombre 32 bits avec des mots de 16 bits :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
        neg     Somme                   ; Complément à 2 du mot de poids faible
        jnz     Non_reversible          ; Si poids faible nul,
        dec     Somme+2                 ; décrémentation du poids fort
Non_reversible:
        not     Somme+2                 ; Complément à 1 du mot de poids fort

Quant à l'astuce de l'instruction DAA (ajustement décimal après addition) pour obtenir la valeur ASCII d'un chiffre hexadécimal, je la dois au scan du premier numéro du magazine DEBUG, je crois.

**chrtophe** · 03/07/2015, 18h50

Il s'agit de code 32 bits (microprocesseur 80386 et suivants). La fonction printf ne fait-elle pas partie du langage C ?

Oui,printf fait partie de la libc. Il est tout à fait possible d'appeler des bibliothèques C en assembleur.

Pour que le code fonctionne, il faut donc linker avec la biblio avec par exemple avec NASM :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
nasm -f elf code.asm
gcc code.o -o code

Dans le fichier .asm, il faudra mettre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
GLOBAL main
main:
...
...

de façon à ce que le compilateur trouve le point d'entrée. Et bien sûr une section .text

Affichage d'un int (4 octets = 32 bits)

x86 16-bits Assembleur

Discussions similaires

Partager

Partager