Discussion :

[adiya]

Bonjour à vous !
j ai essayé d etablir un bout de code pour nasm (linux) qui traite chaines et nombres et surtout :

J essaie de traiter des quotients notamment je veux reduire un quotient...
J ai des erreurs a la compilation...

les lignes de code indiqués par nasm semblent concerner des 'ret' et des 'jmp'...

Je propose :

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
66
67
68
69
70
71
72
73
74
75
76
77
78
 
 
bits 64
 
global _start
 
%include 'reduire.inc'
%include 'fonctions.inc'
 
section .text   ; code
 
    _start:
 
 
 
        call saisie_quotient
        ; ch_num et ch_den sont memorises
 
        ; convertir les chaines en nombres
        mov rsi, ch_num
        call chaine_vers_nombre
        mov  qword[numerateur], rbx
 
        mov rsi, ch_den
        call chaine_vers_nombre
        mov  qword[denominateur], rbx
 
        ; affichage 1
        call afficher_quotient
 
    ; reduction quotient
        call reduire        ; rbx : numerateur  r10 : denominateur
 
    ; nouvelles chaines pour num et den
        xor r15, r15
        mov r15, ch_num     ; r15 : chaine retour...
        mov rbx, numerateur  ; rbx : nombre
        call nombre_vers_chaine
 
 
        xor r15, r15               
        mov r15, ch_den         ; r15 : chaine retour
        mov rbx, denominateur   ; rbx : nombre
        call nombre_vers_chaine
 
        ; affichage 2
        call afficher_quotient
 
      ;  pop r15
        call quit
    quit:
 
        mov rax, 60
        xor rdi, rdi
        syscall
 
section .data   ; donnees initialisees
 
    MAX equ 10
 
    aff_num: db 'numerateur ', 0
    aff_den: db 'denominateur : ', 0
 
    booleen: db NON
    OUI equ 1
    NON equ 0
 
    aff_rapport: db ' / ', 0
    retour_ligne: db 10
 
 
section .bss    ; donnees reservees
 
    numerateur: resq 1
    denominateur: resq 1
 
    ch_num: resb MAX
    ch_den: resb MAX

et mes fonctions concernant les chaines :

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
 
 
calcul_taille_chaine:                   ; calcule la longueur de la chaine jusque 0 !!
    ; rdx : compteur
    xor rdx, rdx
    mov r9, rsi
    ; [rsi+rdx] : char
 
    xor r10, r10
    verif:
 
        mov byte r10b, [r9+rdx]
        cmp r10b, 0
        je fin
 
        inc dl
        jmp verif
 
    fin:
ret         ; rdx renvoie le nb de char   si aucun char -> dx = 0 (simple code 0)
 
 
placer_fin_chaine:              ; place 0 en fin de chaine a la place du 10 (retour a la ligne de saisie)
    ; rsi : adresse
    ; rdx : compteur
    xor rdx, rdx
    mov r9, rsi
    ; [rsi+rdx] : char ([r9+rdx]...)
 
    xor r10, r10
    boucle:
 
        mov byte r10b, [r9+rdx]
        cmp r10b, 10                    ; presence de retour a la ligne ?
        je final
 
        inc dl
        jmp boucle
 
    final:
        mov byte [r9+rdx], 0 
ret         ; rdx renvoie le nb de char
 
 
 
est_un_nombre:
    ; rsi : adresse chaine
    ; retour dans booleen : OUI : est un nombre
                        ;   NON : ne l est pas
        push r9
        push rcx
        mov r9, rsi
        mov booleen, OUI
        anonyme1:
            xor rcx, rcx            ; fin de chaine ?
            mov byte cl, [r9]
            cmp byte cl, 0
            je fin_recherche        ; si fin chaine & aucun NON -> retourne OUI !!
 
            call est_un_chiffre         ; booleen = NON : pas un chiffre !
            cmp byte booleen, NON      ; -> pas un nombre !
            je fin_recherche            ; retourne NON !
 
 
            inc r9                     ; rebouclage...
            jmp anonyme1
 
        fin_recherche:          ; retourne le booleen...
        pop rcx
        pop r9
ret
 
 
 
est_un_chiffre:
    ; r9 : adresse du char
    ; retour dans booleen : OUI : est un chiffre
                          ; NON : ne l est pas
 
    cmp byte[r9], 48
    jl non
    cmp byte[r9], 57
    jg non
 
    mov byte booleen, OUI
ret
 
    non:
    mov byte booleen, NON
ret
 
 
; chiffre vers nombre
char_vers_nombre:
    sub cl, 48
ret
 
 
; nombre(chaine) -> int         rsi(adresse chaine)
chaine_vers_nombre:             ; resultat -> rbx !!!
 
 
    ; verifier est_un nombre...
    call est_un_nombre
    cmp booleen, NON
    je terminaison
 
 
    ; chaine dans rsi -> r9
    mov r9, rsi         ; adresse chaine
    xor rbx, rbx        ; rbx : resultat
 
    call calcul_taille_chaine
    ; rdx : taille de la chaine de pos0 -> pos(tailleChaine-1)...
    ; plus grand chiffre : 10 exp (taille-1)
    mov rax, 1      ; multiplicateur de 10
    mov r12, rdx    ; r12 nb char
  multiple:
    dec r12
    cmp r12, 0
    je ano2
        imul rax, 10
        jmp multiple
    ano2: 
 
 
  calcul:
    ; calcul du chiffre... cl : code ascii du chiffre...
    xor rcx, rcx
    mov byte cl, [r9]
    call char_vers_nombre
    ; cl contient le nombre a multiplier par r11...
    imul rcx, rax   ; chiffre * 10n
    add rbx, rcx    ; -> rbx
 
  cmp rax, 1
  jle terminaison
 
    mov r11, 10
    div r11        ; rax = rax/10
 
    inc r9
    cmp byte [r9], 0        ; fin de chaine ?
    je terminaison
    jmp calcul
 
    terminaison:
 
ret         ; RbX : resultat
 
 
 
nombre_vers_chaine:
    ; rbx contient le nombre...
    ; r15 : adresse chaine retour
 
    xor r9, r9      ; compteur pile
    mov r10, 1      ; multiple de 10
 
 
    mov rax, rbx    ; nb -> rax pour div...
 
 
    ano3:
        xor rdx, rdx
        mov r13, 10
        idiv r13      ; rax / 10 -> rdx : modulo
  ; resultat -> rax        
        push rdx     ; modulo -> pile
 
        inc r9          ; compteur de pile = 1 au minimum...
        imul r10, 10     ; multiple de 10
 
        cmp rax, 0      ; fin du calcul ?
        jne ano3
 
    ; depilage :
 
    xor r11, r11
    depile:
 
        xor rdx, rdx
        pop rdx
        add dl, 48
        ; rdx : char
        mov byte[r15+r11], dl
        inc r11
        dec r9
        cmp r9, 0
        jne depile
 
        mov byte[r15+r11], 0
 
ret
 
 
saisir:                                             ; saisie texte clavier + place 0 en fin de chaine
    ; rsi doit contenir l adresse de stockage
    mov rax, 0
    mov rdi, 0
 
    mov rdx, MAX ; 10 char max
 
    syscall
 
    call placer_fin_chaine
  ;  call est_un_nombre                              ; calcul de booleen...
 
ret
 
 
 
; afficher
; rsi : adresse     rdx : longueur depuis calcul_taille_chaine...
afficher:
 
    call calcul_taille_chaine
 
    mov rax, 1
    mov rdi, 1
 
    syscall
ret
 
retour:
    mov rax, 1
    mov rdi, 1
    mov rsi, retour_ligne
    mov rdx, 1
 
    syscall
ret
 
afficher_quotient:
    mov rsi, ch_num
    call afficher
 
    mov rsi, aff_rapport
    call afficher
 
    mov rsi, ch_den
    call afficher
 
    call retour
ret
 
saisie_quotient:
    mov rsi, aff_num
    call afficher
 
    mov rsi, ch_num
    call saisir
 
    mov rsi, aff_den
    call afficher
 
    mov rsi, ch_den
    call saisir
ret

et enfin la fonction qui est sensée réduire le quotient :

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
66
67
68
69
70
71
72
73
74
75
76
 
 
 
reduire:        
 
 
    mov rbx, qword[numerateur]
    mov r10, qword[denominateur]     
 
    ; le plus petit :
 
    cmp rbx, r10    ; rbx est le plus grand ? (numerateur)
    jge ano4              ; rax recoit le plus petit !!
        mov r13, r10    ; r13 : le plus grand   
        mov rax, rbx  ; rax : numerateur : plus petit...
        jmp suite
    ano4:
        mov r13, rbx    ; r13 : numerateur (plus grand)
        mov rax, r10    ; rax : denominateur   (plus petit)   
 
 
    suite:
 
        ; sauvegarde de rax : r12
        mov r12, rax        ; r12 : plus petit
 
    calcul_modulo:
        mov rax, r12    ; restaure rax
            cmp rax, 1
            jle termine
 
        mov rcx, rax    ; rax > 1
        inc rcx
        ano5:
            dec rcx         ; diviseur = plus petit
 
            cmp rcx, 1
            jle termine
 
 
        xor rdx, rdx        ; prepare le futur modulo
        div rcx         ; rax / rcx
 
        mov rax, r12
 
        cmp rdx, 0
 
        jne ano5      ; si modulo rax/rcx = 0 :
 
            ; modulo de r13 ??? par rcx ???
            mov rax, r13
            xor rdx, rdx
            div rcx         ; r13 / rcx
                cmp rdx, 0  ; rcx divise le plus petit ET le plus grand ??
                je division
            ; sinon:
 
            dec r12
        jmp calcul_modulo
 
        division:
            mov rax, rbx
            div rcx         
            mov rbx, rax   ; rbx = rbx/rcx
            mov rax, r10
            div rcx
            mov r10, rax    ; r10 = r10/rcx
 
            dec r12
        jmp calcul_modulo
 
    termine:
        mov qword[numerateur], rbx
        mov qword[denominateur], r10
 
ret

les erreurs signalees en console sont tres approximatives...
de type error: invalid combination of opcode and operands

merci de m eclairer....

[adiya]

Je pense que la syntaxe nasm, ici, n a simplement pas été respectée...
Je ne vois pas où...

[vincent Boulou]

Bonsoir.
J'ai recopié votre code et j'ai trouvé les erreurs suivantes :
la fonction reduire n'est pas dans votre code.
Erreur : vous avez bien joint la fonction reduire
Et vous ne pouvez pas acceder directement à la variable booleen.
Vous devez charger son adresse d'abord dans un registre par exemple mov r10,booleen
puis effectuer la comparaison comme ceci : cmp byte [r10],OUI

Et peut être on peut comparer directement comme cela cmp byte[booleen],OUI

[adiya]

Bonjour...

La fonction 'reduire' est appelee dans le .asm avec %include 'reduire.inc'...

J ai bien corrigé les compare de booleen en passant par un registre...

Il me reste une erreur (pas tres bien localisée) de type error: invalid effective address...

Normalement c est un souci de registre utilisé en tant que pointeur memoire, je pense à la fonction 'est_un_nombre:' qui passe de l adresse d un char vers le suivant :

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
 
 
 
est_un_nombre:
    ; rsi : adresse chaine
    ; retour dans booleen : OUI : est un nombre
                        ;   NON : ne l est pas
 
        mov r9, rsi
        mov booleen, OUI
        anonyme1:
            xor rcx, rcx            ; fin de chaine ?
            mov byte rcx, [r9]
            cmp byte [cl], 0
            je fin_recherche        ; si fin chaine & aucun NON -> retourne OUI !!
 
            call est_un_chiffre         ; booleen = NON : pas un chiffre !
 
            xor r14, r14
            mov r14, [booleen]
            cmp r14b, NON      ; -> pas un nombre !
            je fin_recherche            ; retourne NON !
 
 
            inc r9                     ; rebouclage...
            jmp anonyme1
 
        fin_recherche:          ; retourne le booleen...
 
ret

Ca devrait se passer a ce niveau...

[adiya]

Apres correction :

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
 
 
 
est_un_nombre:
    ; rsi : adresse chaine
    ; retour dans booleen : OUI : est un nombre
                        ;   NON : ne l est pas
 
        mov r9, rsi
        mov [booleen], OUI
        anonyme1:
            xor rcx, rcx            ; fin de chaine ?
            mov byte rcx, [r9]
            cmp byte rcx, 0
            je fin_recherche        ; si fin chaine & aucun NON -> retourne OUI !!
 
            call est_un_chiffre         ; booleen = NON : pas un chiffre !
 
            xor r13, r13
            mov byte r13, [booleen]
            cmp r13, NON      ; -> pas un nombre !
            je fin_recherche            ; retourne NON !
 
 
            inc r9                     ; rebouclage...
            jmp anonyme1
 
        fin_recherche:          ; retourne le booleen...
 
ret

erreurs de type : error: operation size not specified : 3 et uniquement...
et NON PLUS des : error: invalid effective address

Je precise : j evite le plus possible d utiliser la pile, je prefere les registres, mais il peut y avoir des soucis quand meme dans leur usage...

[vincent Boulou]

Bonjour.
Il manque le mot byte à l'instruction
cmp r13, NON ; -> pas un nombre !

comme vous avez mis à la ligne 14.
En effet lors d'une comparaison avec une valeur immédiate, le compilateur ne peut pas savoir si vous voulez comparer un octet, 2 octets 3 octets ou 4 octets du registre avec la valeur.
Bon courage.

[adiya]

Merci de vos réponses...
Je poursuis mes recherches...

[fred1599]

Hello,

Rien que sur le 1er code j'ai l'impression qu'il y a confusion entre adresse et valeur...

Je vois aussi qu'après réduction les valeurs ne sont pas mises à jour dans numérateur et dénominateur, ou peut être que vous souhaitiez utiliser la fonction permettant de transformer en chaîne. En tout cas si ce code principal n'est pas correct, le reste peut pas fonctionner.

[adiya]

Bonjour !

Je me rend compte, niveau appels de fonctions, en plus des fonctions avec allocation dynamique (il me semble)...
...Besoin de re-étudier la question... Je pense que j aurais besoin de rbp par exemple...

a+tard !

[adiya]

Bonjour !

Voici un bout de code réalisé après avoir réétudié la question...
Les registres et la pile sont mieux respectés...

C'est encore très incomplet, mais si ça peut être utile à quelqu'un qui débute en nasm elf64, tant mieux :

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
 
 
bits 64
default rel ; adressage relatif dans TOUT le code...
 
global _start
 
%include 'fnc.asm'
 
section .data
    affNumerateur: db 'Numerateur : ', 0
    affDenominateur: db 'Denominateur', 0
 
    MAX equ 7
    OUI equ 1
    NON equ 0
 
    retourligne: db 10
 
section .bss
 
 
section .text
 
    _start:
    ; intro
       sub rsp, 8
 
    ; CORPS
        mov rdi, affNumerateur
        push rdi
        call ecrire
        call retour
        pop rdi
        xor rdi, rdi
 
 
    ; quit
        add rsp, 8
        mov rax, 60
        mov rdi, 0
        syscall

et quelques fonctions dans "fnc.asm" :

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
 
 
retour:
 
    mov rax, 1
    mov rdi, 1
    mov rsi, retourligne
    mov rdx, 1
 
    syscall
ret
 
 
ecrire:
    push rbp
    mov rbp, rsp
    ; en RBP + 16 : adresse chaine
 
    mov rsi, qword [rbp + 16]
    ; rsi : adresse
    ; taille en rdx
    ; appeler taille
    push rax
    push rcx
    push rsi
 
   call taille
    mov rdx, rax    ; RDX recupere taille de chaine
 
    pop rsi
    pop rcx
    pop rax
 
    mov rax, 1
    mov rdi, 1
 
    syscall
    mov rsp, rbp
    pop rbp
ret
 
taille:
    ; recoit une chaine avec 0
    ; renvoie taille : registre RAX
    ; chaine : adresse  APRES UN PUSH de l appelant
 
    ;                 pile : adresse retour
    push rbp        ; pile : + rbp
    mov rbp, rsp    ; rsp ne bouge pas
 
    ; rbp      : ancien rbp
    ; rbp + 8  : adr retour
    ; rbp + 16 : parametre (adresse chaine)
    push r12    ; rbp - 8
    push rbx    ; rbp - 16
 
 
   ; CORPS
        ; un registre pour adresse chaine  RBX
        ; un registre pour iterer          R12
    mov r12, 0                ; iterateur a 0
    mov rbx, qword [rbp + 16] ; rbx recoit adresse chn
    xor rax, rax              ; prepare resultat
    xor rcx, rcx              ; stocker le char
   boucle0:
        ; verifie si fin chaine
        mov cl, byte [rbx + r12]
        cmp cl, 0
        je quit0
 
        inc r12
        inc rax
        jmp boucle0
 
   ; quitter
   quit0:
    pop rbx
    pop r12
    mov rsp, rbp
    pop rbp
ret     ; rax : nb char  SANS le 0 final

Merci de tout éclairage...
Tout ce qui peut être utile... à moi et aux autres débutants.