Peut on mieux faire ?

Bonjour Voila j'ai commencé ce matin a programmer en assembleur intel et j'aurais voulu avoir votre avis (Je me considére pas vraiment comme un noob vu que j'ai fais beaucoup de programmes en assembleur 68000 mais bon ...) : J'ai fait une version de "strcpy" en assembleur quoique ce n'est pas mon but final (heureusement !!) mais c'est déja un début ... voici le code : __declspec(naked) void __fastcall myStrCpy(char *dest,char *src) { __asm { mov [esp - 4],eax mov al,byte ptr[edx] mov byte ptr[ecx],al or al,al jnz short L1 mov eax,[esp - 4] ret 0 L1 : mov [esp - 8],esi xor esi,esi L2 : inc esi mov al,byte ptr[edx + esi] mov byte ptr[ecx + esi],al or al,al jnz short L2 mov esi,[esp - 8] mov eax,[esp - 4] ret 0 } } qu'en pensez vous ? peut on l'améliorer ? Merci d'avance

pourquoi toucher à ESI ???


#ifndef MCRASM_H
#define MCRASM_H

#ifndef BNINLINE
#ifdef __cplusplus
#define BNINLINE inline
#else
#define BNINLINE __inline
#endif /* __cplusplus */
#endif /* BNINLINE */

BNINLINE char* bnstrcpy(char *dst, char *src) // return ptr sur NULL final
{
  __asm {
    mov   eax, dst
    mov   ecx, src
    dec   eax
LcpyLoop:
    mov   dl, [ecx]
    inc   eax
    inc   ecx
    mov   [eax], dl
    or    dl, dl
    jz    short LcpyOut
    mov   dl, [ecx]
    inc   eax
    inc   ecx
    mov   [eax], dl
    or    dl, dl
    jz    short LcpyOut
    mov   dl, [ecx]
    inc   eax
    inc   ecx
    mov   [eax], dl
    or    dl, dl
    jnz   short LcpyLoop
LcpyOut:
  }
}

#endif

un strcpy doit être inliné (comme une macro), un appel de fonction coute cher.
bnstrcpy() retourne pointeur sur fin de copie, permet chainage sans reparcourir la chaine. C'est autrement moins couillon que strcpy qui retourne ce qu'on lui donne et donc qu'on avait déjà.

ciao...
[ Lien ]
BruNews, MVP VC++

salut,

mov [esp - 4],eax

acceder a une memoire non allouée est a mon avis une erreur meme si le mode protégé est sensé ne pas toucher a la pile utilisateur.

@++

Ecrire sous ESP ne pose aucun problème tant qu'on ne fera pas un 'call' ou truc de ce genre faisant bouger ESP, c'est plus performant que 'push pop' mais bien entendu à réserver au mode protégé.

ciao...
[ Lien ]
BruNews, MVP VC++

salut, et a ne surtout pas utiliser dans un kernel. @++

Merci pour toutes ces précisions, je viens encore d'apprendre quelques trucs ... j'ai juste une petite question BruNews : pourquoi ton code plutot que celui la : BNINLINE char* bnstrcpy(char *dst, char *src) // return ptr sur NULL final { __asm { mov eax, dst mov ecx, src dec eax LcpyLoop: mov dl, [ecx] inc eax inc ecx mov [eax], dl or dl, dl jnz short LcpyLoop } } il semble fonctionner pareil ... ??

Je déroule la boucle 3 fois donc 1 saut de code sur 3, appréciable en perf sur les longues chaines.

ciao...
[ Lien ]
BruNews, MVP VC++

Alors je viens de faire quelque tests et effectivement la version déroulée est beaucoup plus rapide que la version non déroulée c'est impressionant !!

aligner les chaines sur 4 octets permet de faire une lecture DWORD et de travailler sur le registre ensuite. @++

Quand on chaine des trucs, on ne choisit pas la position donc alignement inconnu.

ciao...
[ Lien ]
BruNews, MVP VC++