PureBasic

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

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

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

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

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!

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

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" ??

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

! INC edx

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

"! 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 !!

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!

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

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]

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)

waouw, merci denis

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ô

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]

PureBasic

MUL mal maitrisé

MUL mal maitrisé