align 16
strlen:  
;;string len with aligned and padded buffer 
;;[esp+4] string pointer 
        mov     eax,[esp+4] 
        push    ebx 
        test    eax,eax 
        jz      .fail 
        pxor    xmm0,xmm0 
        mov     ebx,eax 
;AMDPad16 ;;NOP sequence 16 byte align padding macro
.len: 
;;load 32 bytes of the string 
        movdqa  xmm2,[eax+16] 
        movdqa  xmm1,[eax] 
;;search for a null character 
        pcmpeqb xmm2,xmm0 
        pcmpeqb xmm1,xmm0 
;;move results to 32bit registers 
        pmovmskb edx,xmm2 
        pmovmskb ecx,xmm1 
;;combine the bit flagged results and increment the loop 
        shl     edx,16 
        add     eax,32 
        or      ecx,edx 
        jz      .len 
;;calculate the length (end-start + byte_offset - 32) 
        sub     eax,ebx 
        bsf     ecx,ecx 
        lea     eax,[eax+ecx-32] 
        pop     ebx 
        ret     4 
.fail: 
        xor     eax,eax 
        pop     ebx 
        ret     4 
    

  @@strlen:
           mov   ecx,[esp+$4]
           or    eax,-$1
  @@:
           lea   eax,[eax+$1]
           cmp   byte[ecx+eax],$0
           jnz   @b
           ret
    

asmhack:
lea eax,[eax+1] ??????

inc eax is better...

but it's sure to be slower.

Anyway, inc in P4 is worst because it doesn't modify the CF so it generates a dependency that stalls execution so you must use add or lea since it doesn't touch EFLAGS at all so no CF dependency is generated.

The INC and DEC instructions do not modify the carry flag but they do modify the other arithmetic flags. Writing to only part of the flags register costs an extra uop on P4 and P4E.
It can cause a partial flags stalls on other Intel processors if a subsequent instruction reads
al the flag bits. Furthermore, it can cause a false dependence on the carry flag from a previous instruction.

Use ADD and SUB when optimizing for speed. Use INC and DEC when optimizing for size or when no penalty is expected.

add or lea since it doesn't touch EFLAGS at all so no CF dependency is generated.

mov ebx, 8
xor ecx, ecx
align 16
.loop: 
  inc eax 
  dec ecx 
  jnz .loop

  dec ebx
  jnz .loop

; 34781 ms
    

mov ebx, 8
xor ecx, ecx
align 16
.loop: 
  lea eax, [eax+1]
  dec ecx 
  jnz .loop

  dec ebx
  jnz .loop 

; 34782 ms
    

Use one-byte instructions as much as possible. This will reduce code size and help increase
instruction density in the instruction cache. The most common example is using inc and
dec rather than adding or subtracting the constant 1 with add or sub. Another common
example is using the push and pop instructions instead of the equivalent sequence.

Use one-byte instructions as much as possible.

Also, it says LEA takes 1 clock and is pairable in either U or V pipeline.