Peut on mieux faire ?

Question

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

BruNews · Answer

pourquoi toucher &#224; 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 &#234;tre inlin&#233; (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&#233;j&#224;.

ciao...
http://dev.winsysdev.com
BruNews, MVP VC++

cs_patatalo · Answer

salut,

mov [esp - 4],eax

acceder a une memoire non allou&#233;e est a mon avis une erreur meme si le mode prot&#233;g&#233; est sens&#233; ne pas toucher a la pile utilisateur.

@++

BruNews · Answer

Ecrire sous ESP ne pose aucun probl&#232;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 &#224; r&#233;server au mode prot&#233;g&#233;.

ciao...
http://dev.winsysdev.com
BruNews, MVP VC++

cs_patatalo · Answer

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

spiky31 · Answer

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

BruNews · Answer

Je d&#233;roule la boucle 3 fois donc 1 saut de code sur 3, appr&#233;ciable en perf sur les longues chaines.

ciao...
http://dev.winsysdev.com
BruNews, MVP VC++

spiky31 · Answer

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

cs_patatalo · Answer

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

BruNews · Answer

Quand on chaine des trucs, on ne choisit pas la position donc alignement inconnu.

ciao...
http://dev.winsysdev.com
BruNews, MVP VC++

cs_patatalo · Answer

le probleme ne vient pas de la taille alignée ou non de la chaine mais du buffer qui la contiendra ( pour eviter l'acces a une memoire non allouée )

@++

spiky31 · Answer

ton idée n'est pas mauvaise du tout patatalo mais le test pour savoir quand on arrive en fin de chaine risque d'etre couteux

BruNews · Answer

m&#233;moire non allou&#233;e ???
On est sens&#233; s'adresser ici &#224; des d&#233;veloppeurs, pas des VBistes, on va donc consid&#233;rer les buffers allou&#233;s comme il se doit sinon tout est perdu.

ciao...
http://dev.winsysdev.com
BruNews, MVP VC++

cs_patatalo · Answer

absolument pas:

.1
mov edx,[ecx]
lea ecx,[ecx+4]
and dl,dl
mov [eax],dl
lea eax,[eax+1]
je .2
shr edx,8
mov [eax],dl
lea eax,[eax+1]
je .2
shr edx,8
mov [eax],dl
lea eax,[eax+1]
je .2
shr edx,8
mov [eax],dl
lea eax,[eax+1]
jne .1
.2
ret

@++

BruNews · Answer

et tu crois qu'avec des shr &#231;a ira plus vite ???

ciao...
http://dev.winsysdev.com
BruNews, MVP VC++

cs_patatalo · Answer

si il n'y a que ca:

.1
mov dx,[ecx]
lea ecx,[ecx+2]
cmp dl,0
mov [eax],dl
lea eax,[eax+1]
je .2
cmp dh,0
mov [eax],dh
lea eax,[eax+1]
jne .1
.2
ret

cs_patatalo · Answer

si cpu >= 486

.1
mov edx,[ecx]
lea ecx,[ecx+4]
cmp dl,0
mov [eax],dl
lea eax,[eax+1]
je .2
cmp dh,0
mov [eax],dh
bswap	edx
lea eax,[eax+1]
je .2
cmp dh,0
mov [eax],dh
lea eax,[eax+1]
je .2
cmp dl,0
mov [eax],dl
lea eax,[eax+1]
jne .1
.2
ret

l'instruction bswap prends 1 clock et ne modifie pas les flags.

@++

Peut on mieux faire ?

16 réponses

Votre réponse