Discussion :

[budocay]

Bonjour à tous,

Je cherche a recoder la fonction strlen de la libc. Mon problème est lorsque je calcul la length de la chaine il me retourne toujours le même nombre alors que je push bien mon argument et mov bien mes registres et je n'arrive pas a comprendre pourquoi enfaite je renvoie toujours le même nombre.
Voila ce que j'ai fais:

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
 
section .text
        global _start, my_strlen
 
my_strlen:
        push rbp,               ; met rbp sur la stack                                                               
        mov rbp, rsp            ; met rsp dans rbp                                                                   
        mov rbx, [rbp + 8]      ; met le 1er argument dans rbx                                                       
        xor rax, rax            ; taille                                                                             
loop:
        cmp byte [rbx], 0h      ; comparaison avec NULL                                                              
        jz end                  ; fin de la chain                                                                    
        inc rax                 ; incremente la taille de 1                                                          
        inc rbx                 ; prochain byte                                                                      
        jmp loop                ; rappel loop                                                                        
end:
        pop rbp
        ret

Est-ce que vous auriez une doc pour des explications ou une piste a me donner pour que je puisse corriger mon soucie.
Merci d'avance

[BufferBob]

salut,

tu ne lis pas au bon endroit, en l'occurrence tu pointes sur argc au lieu de pointer sur argv[1]

[budocay]

Salut,

merci pour ta réponse j'ai directement corrigé ma ligne mov rbp, [rsp + 8] si j'ai bien compris bien sur

Mais j'ai toujours un soucie c'est que mon strlen me renvoie toujours la même valeur (6 en l'occurence).
Je n'arrive aps a voir car cela me parait logique dans a manière ou je l'ai fait directement mais peut-être que je n'ai pas vue le soucie auxquelles je me confronte.

Merci d'avance encore

[BufferBob]

j'ai directement corrigé ma ligne mov rbp, [rsp + 8] si j'ai bien compris bien sur

raté, c'était rbp+24 ^^
dans le cas présent changer rbp pour rsp ne servait à rien, puisque tu ne crées pas de stack (ou alors t'as oublié un sub rsp, xyz) et que les deux registres ont la même valeur

tu devrais apprendre à utiliser gdb :

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
$ gdb -q ./pouet
gdb$ break *_start+4                                                          # on pose un breakpoint
Breakpoint 1 at 0x400084
gdb$ run "hello"                                                              # on lance le programme, avec comme paramètre "hello"
(...)
Breakpoint 1, 0x0000000000400084 in _start ()
gdb$ x/4gx $rbp                                                               # on dump la mémoire, 4 valeurs sur 64bits à partir de rbp
0x7fffffffe128: 0x0000000000000000      0x0000000000000002
0x7fffffffe138: 0x00007fffffffe40d      0x00007fffffffe444
gdb$ x/d $rbp+8
0x7fffffffe130: 2                                                             # argc, valeur contenue dans [rbp+8]
gdb$ x/s 0x00007fffffffe40d
0x7fffffffe40d:  "/home/gruik/Bureau/code/langages/asm/dvp/budocay/pouet"     # argv[0], pointeur contenu dans [rbp+16]
gdb$ x/s 0x00007fffffffe444
0x7fffffffe444:  "hello"                                                      # et argv[1], pointeur contenu dans [rbp+24]

[bifur]

sinon il y a aussi la possibilité des passer les argument de la sous fonction via des registres processeur:

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
my_strlen:
;entrée RBX=adresse de la chaine
;sortie RBX=taille de la chaine
push rax
xor rax,rax
 
loop:
        cmp byte [rbx], 0h      ; comparaison avec NULL                                                              
        jz end                  ; fin de la chain                                                                    
        inc rax                 ; incremente la taille de 1                                                          
        inc rbx                 ; prochain byte                                                                      
        jmp loop                ; rappel loop                                                                        
end:
        mov rbx,rax
        pop rax
        ret

c'est utilisable uniquement dans du code assembleur mais ça evite les erreurs d'oublie de libération de pile, et de faire des programme qui gache de plus en plus de mémoire
.....faut pas oublier qu'avec le 64bit on a de plus en plus de registre pour faire ça

[BufferBob]

@bifur, je crois que tu te marches sur le rax, tu push ligne 4, tu pop ligne 15, du coup ça retourne rien à priori ^^ fatigue... grosse fatigue...

sinon tant qu'à proposer des améliorations, au delà de la convention d'appel on pourrait surtout éliminer la boucle explicite en jouant du rep scas :

Code :

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

1
2
3
4
5
6
7
8
9
10
my_strlen:
   mov rdi, pointeur_chaine  ; on charge rdi avec le pointeur sur la string
   xor rax, rax              ; on met al à zéro pour scasb
   xor rcx, rcx              ; on met rcx à...
   dec rcx                   ; ... -1 , pour repnz
   cld                       ; on s'assure de pas être en marche arrière
   repnz scasb               ; et zou. "tant que [RDI] est différent de AL et que RCX est différent de 0, on incrémente RDI et on décrémente RCX"
   not rcx                   ; à la sortie on remet rcx à l'endroit
   lea rax, [rcx - 1]        ; et on stocke le résultat dans rax, par convention
   ret