Can someone explain with this strcpy algorithm ?

I got it from microsoft visual studio source code.

Code:

---

strlen  proc

        .FPO    ( 0, 1, 0, 0, 0, 0 )

string  equ    [esp + 4]

        mov    ecx,string              ; ecx -> string
        test    ecx,3                  ; test if string is aligned on 32 bits
        je      short main_loop

str_misaligned:
        ; simple byte loop until string is aligned
        mov    al,byte ptr [ecx]
        add    ecx,1
        test    al,al
        je      short byte_3
        test    ecx,3
        jne    short str_misaligned

        add    eax,dword ptr 0        ; 5 byte nop to align label below

        align  16                      ; should be redundant

main_loop:
        mov    eax,dword ptr [ecx]    ; read 4 bytes
        mov    edx,7efefeffh
        add    edx,eax
        xor    eax,-1
        xor    eax,edx
        add    ecx,4
        test    eax,81010100h
        je      short main_loop
        ; found zero byte in the loop
        mov    eax,[ecx - 4]
        test    al,al                  ; is it byte 0
        je      short byte_0
        test    ah,ah                  ; is it byte 1
        je      short byte_1
        test    eax,00ff0000h          ; is it byte 2
        je      short byte_2
        test    eax,0ff000000h          ; is it byte 3
        je      short byte_3
        jmp    short main_loop        ; taken if bits 24-30 are clear and bit
                                        ; 31 is set

byte_3:
        lea    eax,[ecx - 1]
        mov    ecx,string
        sub    eax,ecx
        ret
byte_2:
        lea    eax,[ecx - 2]
        mov    ecx,string
        sub    eax,ecx
        ret
byte_1:
        lea    eax,[ecx - 3]
        mov    ecx,string
        sub    eax,ecx
        ret
byte_0:
        lea    eax,[ecx - 4]
        mov    ecx,string
        sub    eax,ecx
        ret

strlen  endp

---

what is .FPO ?
what did it mean testing if the string aligned on 32 bit ?
what is string misalign ?
what 'align 16' for in code ? redudant ?

The .FPO directive controls the emission of debug records to the .debug$F segment or section. FPO (cdwLocals, cdwParams, cbProlog, cbRegs, fUseBP, cbFrame).

A string is aligned on 32 bit if its adress divided by 4 is zero, which is the same as having the two less signifignant bits to 0, which is the same as having 0 when the address is ORed with 3.

align 16 in your code is not redundant because it is used for aligning the code of the main_loop loop, not for aligning the address of the variable called 'string'.

(Bonus, a silly joke:
Q: Do you know the name of the lead singer of the group called pRolice?
A: StRing.)

thanx for the answer,
but why it's has to be 32 bit align ?
and
I know 'align 16' is for the code not for string. but what for 'align 16' ? is it speed up the process or something else ?
what kind of effect if I removed the 'align 16'

and the last is when I check the algorithm of main loop it's read 4 byte to check for null.
what if null or 0 value in the first byte from 4 byte it read. and last 3 byte that from the memory isn't belong to the process, isn't it memory violation because the code try to read from memory that not belong them ?

Okay, here are new comments:

1. In the title of this post, the word, strcpy should be replaced with strlen.

2. The header of the file should mention
Entry: const char * str - string whose length is to be computed
Exit: EAX = length of the string "str", exclusive of the final null byte

3. The code comes from vc\crt\src\[cpu vendor]\strlen.asm

4. The first comment, ecx -> string should be string -> ecx.

5. This program is based on an algorihm from Magmai Kai Holmlor:

Code:

---

  int strlen(const char* cszStr)
  {
        DWORD* p = (DWORD*) cszStr;
        DWORD k,kk;
       
        while(DWORD(p)&3)
                {
                if(*(char*)(p)==0)
                        return (char*)(p)-cszStr;
                p = (DWORD*) (((char*)(p)) + 1);
                }
       
        do
                {
                k = *p;
                kk = k + 0x7efefeff;
                k ^= -1;
                k ^= kk;
                p++;
                } while(!(k&0x81010100));
       
        k = *(--p);
        if(!(k&0x000000ff))
                return (char*)(p)-cszStr;
       
        //if(!(k&0x0000ffff)) Thanks Kippesoep!
        if(!(k&0x0000ff00))
                return (char*)(p)-cszStr+1;
       
        if(!(k&0x00ff0000))
                return (char*)(p)-cszStr+2;
       
        if(!(k&0xff000000))
                return (char*)(p)-cszStr+3;
       
        return (char*)(p)-cszStr;
  }

---

I found it at http://www.gamedev.net/community/for...opic_id=315709

6. Yes, it is very likely that "align 16" was put to speed up the process.

7. You may remove "align 16". The program will return exactly the same result.

8. As a matter of fact, the 32-bit alignment does not concern the string, but the address in ecx. The string may be at any address. It's just that, before entering main_loop, ecx should contain an address on a 32-bit boundary.

9. The purpose of having an aligned address in ecx is to be able to scan the string, not one byte at a time, but four bytes at a time, in order to speed up the process.

10. You're right, the process can read 1, 2, or 3 bytes beyond the end of the string, since it reads the string by chunks of four bytes.

Good post. I was also confused with "test" statement before.