multiplication et overflow

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

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+

je ne peux pas utilisé les registres de 32bits car, je tourne en dos et donc 16bits maximum mais merci quand même

je me suis trompé, en rajoutant .386 j'ai accès à ces registre mais ça ne marche toujours pas

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

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)

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é.

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

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

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