Multiplication et overflow [Résolu]

Messages postés
22
Date d'inscription
samedi 14 juin 2003
Statut
Membre
Dernière intervention
24 janvier 2006
- - Dernière réponse : cs_Nasman
Messages postés
202
Date d'inscription
mardi 17 mai 2005
Statut
Membre
Dernière intervention
29 septembre 2008
- 24 janv. 2006 à 08:24
Alors voilà, je dois faire une calculatrice en assembleur,
l'utilisateur peut rentrer 2 entiers nombres compris en 0 et 9999 mais
lorsque j'éxecute la multiplication, et que le résultat est supérieur
ou égal à 65536 (soit 2^16 bits), j'ai tout naturellement un overflow
et je n'arrive pas à résoudre mon problème.



Merci de votre aide



P.S.:J'ai remarqué que le résultat de la multiplication est le suivant 65536*DX + AX
Afficher la suite 

12 réponses

Meilleure réponse
Messages postés
22
Date d'inscription
samedi 14 juin 2003
Statut
Membre
Dernière intervention
24 janvier 2006
3
Merci
bon j'ai résolu mon problème mais pour le moment c'est très très barbare voici le code

multiplication:
CALL newline
CALL newline
MOV DX, 0
affichmes resmult
MOV AX, nb1
MUL nb2
CMP DX, 0
JNE multipover
CALL affichage
JMP division

multipover:
MOV nbdx, DX
MOV DX, 0
MOV mult, AX
MOV BX, 10
MOV retenu, 0

MOV AX, 6
MUL nbdx
MOV tempo1, AX
MOV AX, mult
DIV BX
MOV tempo2, AX
MOV AX, tempo1
ADD AX, DX
ADD AX, retenu
MOV DX, 0
DIV BX
MOV retenu, AX
MOV AX, DX
PUSH DX

MOV AX, 3
MUL nbdx
MOV tempo1, AX
MOV AX, tempo2
MOV DX, 0
DIV BX
MOV tempo2, AX
MOV AX, tempo1
ADD AX, DX
ADD AX, retenu
MOV DX, 0
DIV BX
MOV retenu, AX
PUSH DX

MOV AX, 5
MUL nbdx
MOV tempo1, AX
MOV AX, tempo2
MOV DX, 0
DIV BX
MOV tempo2, AX
MOV AX, tempo1
ADD AX, DX
ADD AX, retenu
MOV DX, 0
DIV BX
MOV retenu, AX
PUSH DX

MOV AX, 5
MUL nbdx
MOV tempo1, AX
MOV AX, tempo2
MOV DX, 0
DIV BX
MOV tempo2, AX
MOV AX, tempo1
ADD AX, DX
ADD AX, retenu
MOV DX, 0
DIV BX
MOV retenu, AX
PUSH DX

MOV AX, 6
MUL nbdx
MOV tempo1, AX
MOV AX, tempo2
MOV DX, 0
DIV BX
MOV tempo2, AX
MOV AX, tempo1
ADD AX, DX
ADD AX, retenu


CALL affichage
POP AX
CALL affichage
POP AX
CALL affichage
POP AX
CALL affichage
POP AX
CALL affichage

Dire « Merci » 3

Quelques mots de remerciements seront grandement appréciés. Ajouter un commentaire

Codes Sources 201 internautes nous ont dit merci ce mois-ci

Commenter la réponse de piopium
Messages postés
202
Date d'inscription
mardi 17 mai 2005
Statut
Membre
Dernière intervention
29 septembre 2008
0
Merci
Bonjour piopium,



Effectivement les instructions de multiplication mul et imul,
multiplient le contenu de al, ax ou eax par un nombre de même capacité
(octet, word, Dword) et mettent le résultat dans:

- ax si l'octet multiplié est al

- dx:ax (soit 65536*dx+ax) pour ax

- edx:eax (soit 4294967296*edx+eax) pour eax



Tu dispose de deux instructions, mul et imul.

mul effectue la multiplication d'entiers non signés soit si al=128
(10000000b ou 80h) et l'autre octet vaut 4 (00000100b) tu auras ax=512
(0000001000000000b ou 200h).

Avec l'instruction imul (pour les entiers signés), al=10000000b sera
considéré comme négatif et vaudra -128. Le résultat sera -512 soit
ax=1111111000000000b ou FE00h.



Daus le cas qui te concerne, tu effectue probablement une conversion
décimal/hexa lors de la saisie de tes nombres. Tu mets alors un entier
dans ax (de 0 à 270Fh), l'autre (16bits) ou bon te semble, le résultat
sera dans dx:ax. dx:ax constitue un "registre 32 bits" qui sera signé
si tu utilise imul et non signé si tu utilise mul.

Dans les deux cas l'ensemble dx:ax représentera un nombre positif
puisqu'il sera inférieur ou égal à 5F592E1h (99980001), la limite étant
7FFFFFFFh.

Nota: ax pourra sembler négatif mais l'ensemble dx:ax sera positif (bit 15 de dx=0)



A+
Commenter la réponse de cs_Nasman
Messages postés
22
Date d'inscription
samedi 14 juin 2003
Statut
Membre
Dernière intervention
24 janvier 2006
0
Merci
je ne peux pas utilisé les registres de 32bits car, je tourne en dos et donc 16bits maximum mais merci quand même
Commenter la réponse de piopium
Messages postés
22
Date d'inscription
samedi 14 juin 2003
Statut
Membre
Dernière intervention
24 janvier 2006
0
Merci
je me suis trompé, en rajoutant .386 j'ai accès à ces registre mais ça ne marche toujours pas
Commenter la réponse de piopium
Messages postés
202
Date d'inscription
mardi 17 mai 2005
Statut
Membre
Dernière intervention
29 septembre 2008
0
Merci
Quel est ton problème exactement ? C'est normal que tu ais un overflow
mais ce n'est pas dramatique. Le résultat de 65536*dx+ax est-il correct
? Es tu sur que les nombres saisis soient convertis correctement avant
traitement de la multiplication ? Comment est restitué le résultat.



Le calcul de la multiplication n'est pas le plus délicat (si les
calculs sont effectués en hexa), je pense plutôt que le problème est au
niveau des conversions hexa/décimal et la conversion en caractères
ascii.



Pour t'aider il faudrait que tu en dise plus (en mettant le code en question). Bon courage
Commenter la réponse de cs_Nasman
Messages postés
22
Date d'inscription
samedi 14 juin 2003
Statut
Membre
Dernière intervention
24 janvier 2006
0
Merci
oui le résultat est correcte et la conversion aussi, j'ai vérifié les valeurs des registres en cas d'overflow.
Pour l'affichage, j'ai une fonction qui décompose le registre AX et affiche ce qu'il y a dedans caractère par caractère et si je fais 5000*5000 il va me mettre le contenu de AX soit 30 784 et non pas 25 000 000 comme prévu

alors pour le code voici la parti de conversion (que je répète 2 fois pour mes 2 nombres)

MOV DX, offset val_ascii1
MOV AH, 0Ah
INT 21h

LEA DI, val_ascii1 ;on charge la variable sur laquelle on travaille
INC DI ;on met le pointeur sur le nombre de caractère contenu (sans le CR)
MOV BX, 0 ;initialisation de BX à 0
MOV BL, [DI] ;on place dans BX la valeur sur laquelle pointe BI
MOV var1, BX ;et on met BX dans var pour pouvoir travailler avec par la suite
ADD DI, var1 ;on ajoute le nombre de caractère à DI pour ce placer entre le dernier caractère et le CR
MOV CX, var1 ;on place var dans CX pour faire une boucle
MOV coeff1, 1 ;initialisation du coefficiant
MOV nb1, 0 ;initialisation de la variable de sortie à 0

convertion:
MOV DX, 0
MOV AX, 0
MOV AL, [DI]

;on compare le code ASCII du caractère traité et celui de 3OH (0) s'il est inférieur
;c'est que ce n'est pas un chiffre
CMP AL, 30H
JB erreur_saisie
;on recompare avec 39H (9)
CMP AL, 39H
JA erreur_saisie

DEC DI
SUB AX, 30h
MUL coeff1 ; AX := AX x coeff1

ADD nb1, AX

MOV AX,10
MUL coeff1
MOV coeff1 ,AX

LOOP convertion

et l'affichage:

affichage: ; affiche AX sous forme de string
PUSH BX
PUSH CX
PUSH DX

MOV BX, 10
MOV CX, 0

decompose_nb:
MOV DX, 0
DIV BX ; AX := AX div 10
INC CX
PUSH DX ; empile le reste
CMP AX, 0
JNE decompose_nb

affiche_digit:
POP AX
MOV DL, 30h
ADD DL, AL
MOV AH, 02H ; fonction d'affichage
INT 21h
LOOP affiche_digit

POP DX
POP CX
POP BX
RET

la multiplication est juste constituée pour le moment d'un MUL tout simple (d'où l'overflow)
Commenter la réponse de piopium
Messages postés
202
Date d'inscription
mardi 17 mai 2005
Statut
Membre
Dernière intervention
29 septembre 2008
0
Merci
J'ai repris ton code, ton calcul 5000x5000 = 25000000 correspond en hexa à:

1388hx1388h = 17D7840h

or tu trouves 30784d soit 7840h

La partie haute du résultat est passée à l'as. Soit dx:ax =7840h, soit dx=0 et ax=7840h

Il semble que celà provient de l'instruction MOV DX,0 qui écrase la partie haute



decompose_nb:

MOV DX, 0

DIV BX ; AX : = AX div 10

INC CX

PUSH DX ; empile le reste

CMP AX, 0

JNE decompose_nb



l'opération div, divise un nombre de 32 bits (16 + 16) dx:ax par un
nombre de 16 bitset met le quotient dans ax et le reste dans dx.
Cependant il y a un pb si

(65536dx+ax)/10 > 65535 car le quotient ne tient pas dans ax et dx
est sensé contenir le reste de la division. En 32 bit le problème se
résout facilement en mettant dx et ax dans eax et en initialisant edx à
zéro. Si on se limite aux registres 16 bits le pb est plus compliqué.
Commenter la réponse de cs_Nasman
Messages postés
22
Date d'inscription
samedi 14 juin 2003
Statut
Membre
Dernière intervention
24 janvier 2006
0
Merci
non DX ne vaut pas 0, si je l'affiche il me met dans le cas présent 3
or 65536*3 + 30784 me donne le bon résultat.

j'avais pensé utilisé l'addition et l'affichage caractère par caractère (je change d'exmple pour que ce soit plus rapide) par exemple si on prend:
7000 * 10 70 000> AX = 4464 et DX = 1

Donc faire

65536
+ 4464

et empiler les résultats successif des additions (6+4 => empile 0 et la retenu passe dans l'opération suivante: 3+6+1 => empile 0 etc etc)
après il suffit de dépiler et d'affiche les caractères
Commenter la réponse de piopium
Messages postés
202
Date d'inscription
mardi 17 mai 2005
Statut
Membre
Dernière intervention
29 septembre 2008
0
Merci
Quel est le résultat que tu souhaite avoir ? Si c'est 25000000d =
17D7840h alors je ne vois pas comment tu obtient le résultat avec
65536*3+30784. Pour moi celà fait 227392

Le résultat devrait être 65536*381 + 30784, soit en hexa



17Dh*10000h + 7440h
Commenter la réponse de cs_Nasman
Messages postés
22
Date d'inscription
samedi 14 juin 2003
Statut
Membre
Dernière intervention
24 janvier 2006
0
Merci
lol je viens de me rendre compte que je me suis trompé de calcul, j'ai tellement de papier devant moi que je fais plus gaffe, donc le calcul était 5000*40 = 200 000 et on a bien
AX = 3392
DX = 3

et 65536*3 + 3392 = 200 000 et là c'est juste
Commenter la réponse de piopium
Messages postés
22
Date d'inscription
samedi 14 juin 2003
Statut
Membre
Dernière intervention
24 janvier 2006
0
Merci
et encore merci pour ton aide Nasman
Commenter la réponse de piopium
Messages postés
202
Date d'inscription
mardi 17 mai 2005
Statut
Membre
Dernière intervention
29 septembre 2008
0
Merci
Bonjour,



Je n'ai pas analysé ton dernier commentaire mais j'ai trouvé une solution. La voici :

Le problème réside dans la division de dx:ax par dix puisque dx:ax peut
atteindre 5F592E1h (9999x9999d) et le résultat ne tient pas sur 16 bits.

Le "truc" consiste à diviser dx:ax par 10000d. Ainsi le quotient sera
forcément inférieur à 10000d et le reste aussi (compte tenu que dx:ax
est le produit de deux nombres inférieurs à 10000). Les deux nombres ax
et dx tiendront donc sur 16 bits.

Il ne reste plus qu'à sauvegarder provisoirement dx, mettre ce registre
à zéro et diviser dx:ax par 10d de façon successive en extrayant les
différents restes.

Pour 25000000d tu auras ainsi:

17D7840h/2710h = 9C4h (ax) et dx=0 (nota dx pourrait être non nul mais 25000000 est divisible par 10000)

9C4h/Ah = FAh (reste 0)

FAh/Ah = 19h (reste 0)

19h/Ah = 2h (reste 5)

2h/Ah = 0h (reste 2h)



La décomposition donne donc 2 5 0 0 pour ax. On procède de même pour la sauvegarde de dx (0) pour avoir 0 0 0 0.

Le résultat global est donc 2500 x 10000 + 0000 = 25000000



Je pense que tu pourras coder cet algorithme sans difficulté.

Bonne prog
Commenter la réponse de cs_Nasman