MUL mal maitrisé

kelly · Message par **kelly** » mar. 19/juil./2005 18:12

Voici une erreur que je n'arrive pas a corriger.
La partie ASM doit multiplier 2 registres 8 bit et ecrire le resultat dans AX :

Code : Tout sélectionner

Result.b
Resulta.w

Address = @n64(i) 
!  MOV     ebx, dword [v_Address] 
!  MOV     al, [ebx] 

Address = @i1
!  MOV     ebx, dword [v_Address] 
!  MOV     dl, [ebx]
!  MOV     ah, 0
!  MUL     dl                         ; je pense que l'erreur est la
!  MOV     [v_Resulta], ax     ; ou la

i2.w= Resulta

Debug ("====")
Debug i2
i2=n64(i)*i1                        ; la vrai valeiur de i2
Debug i2

comtois · Message par **comtois** » mar. 19/juil./2005 18:39

en attendant les spécialistes de l'ASM
peut-être que ça t'aidera ?

http://menuet.homelinux.net/Asm:Mul

filperj · Message par **filperj** » mar. 19/juil./2005 23:12

L'erreur vient probablement de la ligne "Address = @i1 " qui modifie EAX.
Ton utilisation de MUL a l'air correcte

VPureBasic · Message par **VPureBasic** » mer. 20/juil./2005 3:13

Salut Kelly,

Je penses bien qu'un code comme celui-ci pourra repondre a ton besoin...

Code : Tout sélectionner

Global    i.l                      ; Index du Tableau
Global    i1.b                     ; Multiplicateur 
Global    i2.w                     ; Resultat

Dim       n64.b(10)                ; Tableau de 10 variables de type bytes

;    ASM SOURCE

     !PUSH     dword Ebx           ; Sauvegarde ce Registre Important Pour PB
                                   ;
     !MOV      dword Ebx,[a_n64]   ; Charge Address Initial du Tableau
     !ADD      dword Ebx,[v_i  ]   ; Additionne la valeur l'index du tableau         
                                   ;
     !MOVSX    byte  Eax,[Ebx  ]   ; Charge une valeur bits dans eax 
     !MOVSX    byte  Ebx,[v_i1 ]   ; Charge la valeur i1 dans ebx
                                   ;
     !IMUL     dword Eax,Ebx       ; Effectue la multiplication
                                   ;
     !MOV      word  [v_i2 ],Ax    ; Sauvegarde le resultat
     
     !XOR      dword Eax,Eax       ; Efface le registre (Mettre a 0)
     !POP      dword Ebx           ; Replace le registre

Donne-moi des nouvelles...

Roger

La seule limite de PureBasic... c'est notre imagination!

kelly · Message par **kelly** » mer. 20/juil./2005 12:53

merci mais ca va, j'ai pas mal debuggué. Je reviendrais ici pour savoir une autre chose...
thx

kelly · Message par **kelly** » jeu. 21/juil./2005 11:30

Bon, je maitrise de plus en plus, j'en suis ravie. But look :

Code : Tout sélectionner

...........
Repeat

Address = @n64(i) 
!  MOV     edx, dword [v_Address] 
!  MOV     ax, [edx] 

i+1
.........

A la place d'augmenter I, comment dire directement a la ligne "! MOV edx, dword [v_Address] " que "[v_Address]" doit etre a +1 ?
Ca s'ecrit avec une ligne de code comme "! add v_Address, 1" ??

fweil · Message par **fweil** » jeu. 21/juil./2005 11:32

Pour incrémenter de 1, on peut utiliser l'instruction INC :

! INC edx

après le premier MOV placera la valeur + 1 dans edx.

kelly · Message par **kelly** » jeu. 21/juil./2005 11:34

"! INC edx "

Non, tu fais erreur. Car je pense que ca augmente de 1 la valeur qui etait dans EAX. Mais ca ne permet pas de regarder la valeur suivante dans un Dim !!

VPureBasic · Message par **VPureBasic** » jeu. 21/juil./2005 12:29

Salut Kelly,

Est-ce que as essayer le code que je t'avais suggerer? Si oui alors pour augmenter la lecture du prochain n64(i), tu n'as qu'a augmenter sa valeur de 1 comme suit...

Code : Tout sélectionner

Global    i.l                      ; Index du Tableau 
Global    i1.b                     ; Multiplicateur 
Global    i2.w                     ; Resultat 

Dim       n64.b(10)                ; Tableau de 10 variables de type bytes 

;    ASM SOURCE 

!PUSH     dword Ebx           ; Sauvegarde ce Registre Important Pour PB 
                              ; 
!MOV      dword Ebx,[a_n64]   ; Charge Address Initial du Tableau 
!ADD      dword Ebx,[v_i  ]   ; Additionne la valeur l'index du tableau          
                                   ; 
!MOVSX    byte  Eax,[Ebx  ]   ; Charge une valeur bits dans eax 
!MOVSX    byte  Ebx,[v_i1 ]   ; Charge la valeur i1 dans ebx 
                                   ; 
!IMUL     dword Eax,Ebx       ; Effectue la multiplication 
                                   ; 
!MOV      word  [v_i2 ],Ax    ; Sauvegarde le resultat 

; Ajoute Ceci
!MOV      dword Eax,[v_i]     ; Copier la valeur de l'index
!INC      dword Eax           ; Augmente de 1
!CMP      dword Eax,10        ; Compare avec limite du DIM
!JNE      near  Suite_Du_Code ; Si Eax <> Maximum
!MOV      dword [v_i],0       ; Remet index a 0


!Suite_Du_Code:
!XOR      dword Eax,Eax       ; Efface le registre (Mettre a 0) 
!POP      dword Ebx           ; Replace le registre

Roger

La seule limite de PureBasic,... c'est notre imagination!

kelly · Message par **kelly** » jeu. 21/juil./2005 14:08

@VPureBasic :

Non, je n'ai pas utilisé ton code car j'avais en fait 3 blocs asm a "souder" et j'y suis arrivée avant de te lire.
Bon, apparement, EBX est important pour PB. Donc, un push semble essenciel avant d'utiliser EBX. Alors, il n'y a plus qu'a.
Je vais tester ca....

kelly · Message par **kelly** » jeu. 21/juil./2005 14:55

Ha tiens, un probleme interessant. Comment mettre la valeur 0 a l'adresse Addi ?
Je veux le contraire de ca quoi :

Code : Tout sélectionner

!  MOV     eax, dword [v_Addi]

Anonyme2 · Message par **Anonyme2** » jeu. 21/juil./2005 15:21

kelly a écrit :Ha tiens, un probleme interessant. Comment mettre la valeur 0 a l'adresse Addi ?
Je veux le contraire de ca quoi :
Code : Tout sélectionner
!  MOV     eax, dword [v_Addi]

Tu devrais lire le tut 7 que j'ai fait. Je suis pas un grand spécialiste mais tu pourras te familiariser avec l'instruction la plus utilisée, MOV

Code : Tout sélectionner

 Global Addi
 
 SUB    eax, eax
 MOV    dword [v_Addi], eax
 
;  ou 
 
 XOR    eax, eax
 MOV    dword [v_Addi], eax

;  ou 

 MOV    eax, 0
 MOV    dword [v_Addi], eax

;  ou 
 
 MOV    dword [v_Addi], 0
 
;  ou 
 
 PUSH Dword 0
 POP  Dword[v_Addi]

;  ou 

ADDI = 12   ; pour montrer que Addi vaut au départ 12
MessageRequester("","Addi =" +Str(Addi),16)
 
 MOV  eax, [v_Addi]
 SUB  Dword[v_Addi], eax
 
MessageRequester("","Addi =" +Str(Addi),16)

kelly · Message par **kelly** » jeu. 21/juil./2005 15:31

waouw, merci denis

kelly · Message par **kelly** » jeu. 21/juil./2005 16:12

Code : Tout sélectionner

!  MOV     edx, dword [v_Addi]
!  ADD     dword ptr [edx], 1

C'est poussé mais ca ne marche pas.
comme ma valeur "Addi" est un .l en PB, je dois bien mettre dword ptr, non ?
ca devrait augmenter de 1 cette valeur, mais ca marche pô

Anonyme2 · Message par **Anonyme2** » jeu. 21/juil./2005 16:24

y a pas de ptr

! MOV edx, dword [v_Addi]
! ADD dword [edx], 1

si tu veux ajouter 1 à Addi, utilise l'instruction INC

! INC dword[v_Addi]