Discussion :

[Arthur57255]

Bonjour à tous,

Je suis actuellement en DUT Informatique (en première année) et je dois réaliser une calculatrice en Assembleur 8086.

J'avoue que je bloque un peu sur l'opération de la multiplication...
La multiplication demandé doit multiplier deux nombres saisit par l'utilisateur de 4 digits maximum par nombre.

J'ai eu donc l'idée de faire des enchainement d'addition dans une boucle. Dans un premier temps je récupère la valeur d'un nombre (ici mon nb2) et je la met dans CL.
Par la suite, j'ai tenté de faire une boucle du type :

Tant que CL > 0 faire

nb1 := nb1 + nb1
CL := CL - 1

Fin Tant que

Affichage


Malheureusement j'ai l'impression que la compteur ne fonctionne pas..
J'obtiens dans tout les cas : nb1 * 2
C'est à dire je rentre :
- Entrer nb1 : 4
- Entrer nb2 : 3
- Le résultat est : 0008

Voici mon code :

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
multiplication :
 
		CRLF
 
		CMP recupnum, 0 ; booleen qui dit si les nombres ont été saisit ou non
		JE recupnuminter ; je saute recupérer les deux nombres à multiplier entre eux
 
		MOV AL,  nb2+5
        ADD AL,  0
        AAA ; adjust ascii for addition 
        MOV res+6, AL
        MOV AL,  nb2+4
        ADC AL,  0
        AAA
        MOV res+5, AL
        MOV AL,  nb2+3
        ADC AL,  0
        AAA
        MOV res+4, AL
        MOV AL,  nb2+2
        ADC AL,  0
        AAA
        MOV res+3, AL
        MOV AL, 0
        ADC AL, 0
        MOV res+2, AL
 
        CALL AJUST ; procédure qui converti les nombres en ASCII en décimal
 
        MOV CL, res
 
 
 
go :    
		CMP CL, 0
		JE next
 
		DEC CL
		MOV AL,  nb1+5
        ADD AL,  nb1+5
        AAA ; adjust ascii for addition : on converti les nombres pour l'addition
        MOV res+6, AL
        MOV AL,  nb1+4
        ADC AL,  nb1+4
        AAA
        MOV res+5, AL
        MOV AL,  nb1+3
        ADC AL,  nb1+3
        AAA
        MOV res+4, AL
        MOV AL,  nb1+2
        ADC AL,  nb1+2
        AAA
        MOV res+3, AL
        MOV AL, 0
        ADC AL, 0
        MOV res+2, AL
		JMP go
 
next :    
        CALL AJUST
 
        AFFICHMUL
 
        JMP start ; start est le début du programme

Merci d'avance pour l'aide !

Bonne journée !

[Kannagi]

Je ne vois pas de boucle pour la multiplication dans ton code.
il y'a plusieurs façon de faire un mul en assembleur (le plus long et le moins optimisé c'est de faire une boucle d'addition ) mais ma question est :pourquoi ne pas utiliser l'instruction mul ? x)
L'autre point pourquoi utilisé ADC et non ADD ?
ADC additionne avec le carry , du coup cela t'oblige de clear le carry assez souvent , ADC techniquement c'est utilisé pour gérer des nombre plus grand que 16 bits sur le 8086 (en faisant deux adc).

En pseudo code ça donnerai

Code :

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

1
2
3
4
5
6
7
8
9
10
 
initialise r1 à 0
met facteur1 dans r0
saute sur  endmul si r0 est égal à 0
mul:
addition r1 avec facteur2
décrémente r0
compare r0 avec 0
Si r0 différent de 0 alors saute à mul
endmul:

[Arthur57255]

Bonjour, je vous remercie déjà grandement pour votre réponse.

Ma supposée boucle est en réalité l'étiquette "go", il est fort possible que ma méthode pour la boucle n'est pas bonne.
A propos des ADC, j'ai remarqué que certaines fois, le résultat était faux si je laissais ADD simplement, d’où les ADC ici.

Pour l'instruction MUL, je n'ai pas bien compris son fonctionnement, c'est pourquoi je passe ici par un enchainement d'addition. En effet, j'ai déjà réalisé l'opération addition alors pourquoi pas la réutiliser

A propos de l'idée de code que vous m'avez donné ici :

Code :

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

1
2
3
4
5
6
7
8
9
initialise r1 à 0
met facteur1 dans r0
saute sur  endmul si r0 est égal à 0
mul:
addition r1 avec facteur2
décrémente r0
compare r0 avec 0
Si r0 différent de 0 alors saute à mul
endmul:

Est-il possible d'avoir plus de précision sur les variables utilisées ? (r0, r1, facteur1, facteur2) Je ne comprends pas à quoi elle correspondent...

Merci d'avance pour les futures répondes.
Bonne journée.

[Kannagi]

Alors :
1) Non ADD ne bug pas (ou alors ton émulateur est mal foutu) , et l'autre point ben ADC c'est l'addition avec Carry , donc je me répète tu dois clear le carry à chaque fois.

2) Effectivement tu as une boucle assez étrange , en général une boucle d'addition , je l'imaginais pas comme ça aussi...
(entre autre parce que une boucle avec un JMP , j'en fais jamais pour des boucles du type "for").
Si tu as de l'ASCII alors ton algo est mauvais , en convertir d'abord son string en nombre , et ensuite en fait la multiplication.

3)Alors c'est complètement stupide de ne pas utiliser mul parce qu'on ne sait pas l'utiliser , et qu'on ne sait pas non plus faire une boucle d'addition
La seule fois que j'avais besoin de faire un mul en software c'est dans un vieux proc le 6502/6800 qui ne disposait pas d'instruction mul, mais je te rassure qu'on ne faisait pas une boucle d'addition , (tu imagine un simple 1*256 risquait de faire l'opération 256 fois ! et ça prenait facile 3000 cycles énorme pour l'époque , une autre méthode est de combiner les test de bit et les décalages binaire , qui réduit donc l'opération à 8 comparaison/calcul (pour 8 bits) qui permet d'avoir le mul pour a peu près entre 60 à 150 cycles

4) C'est juste du pseudo code , si tu ne le comprend pas alors c'est que mon pseudo code n'est pas assez lisible tout simplement , sinon r pour registre , et facteur 1 et facteur 2 c'est les bases de la multiplication : " les nombres que l'on multiplie sont les facteurs. "

Donc mon conseil apprend à utiliser mul ,c'est pas une opération complexe, il considère juste AX/EAX/RAX comme accumulateur.
Genre : mul bl , équivaux à ax = al*bl
J'avais déjà répondu à quelque question sur le mul ici : https://www.developpez.net/forums/d1...omprehensible/
et ici : https://www.developpez.net/forums/d1...omprehensible/

Et ils existent plein de doc sur les instructions sets du x86 sur le net donc un peu de recherche...