strlen() isn't easy to re-write in assembly

... at least not for me. I'm still a beginner at this assembly lark (well, x86 assembly at least).

Basically I'm trying to write my own strlen (for nothing more than educational purposes) but I, well, can't. I'm going over array access here:

http://www.geocities.com/SiliconVall...230/index.html

(Have to put up with his terrible english).

So I want to load the first character of the argument stri into a register, is this the right way to go about it?:

Code:

_declspec(naked) int StringLen(char* stri)
{
    int l;

    _asm
    {
        push    ebp
        mov     ebp, esp

        mov     [l], 0
        mov     eax, [stri]
        mov     bl, byte ptr [eax]

        mov     esp, ebp
        pop     ebp
        lea     eax, [l]
        ret
    }
}

I've stepped through it and bl does indeed get loaded with 'm' (oh, I pass the string "my name is LEEEEEEEEE") but I want to iterate it just to make sure. So I need to inc bl each time to access the next element, right?

> So I need to inc bl each time to access the next element, right?
No, you compare it with 0
eax you increment to step through the array.

Ok gimmie a sec.

Bloody hell this is frustrating. Can someone spell it out a bit more?
Pretty please

Here's what I've got:

Code:

_declspec(naked) int StringLen(char* stri)
{
    int l;

    _asm
    {
        push    ebp
        mov     ebp, esp

        mov     [l], 0
        mov     ebx, 0

_proc:
        mov     eax, stri [ebx]
        cmp     eax, 0
        je      _out
        inc     ebx
        jmp     _proc

_out:
        mov     esp, ebp
        pop     ebp
        mov     eax, [l]
        ret
    }
}

Except I'm having trouble returning the value I want (l). I thought what I've got there was right but it's not, apparently.

> mov eax, [l]
Do this before messing with restoring ebp,esp

Hmm, "DAMAGE: After normal block (#72) at <location>".
Think it's time to post the whole thing:

Code:

#include "stdafx.h"

_declspec(naked) void FastCopy16(char* src, char* dst, int c)
{
    _asm
    {
        push    ebp
        mov     ebp, esp

        mov     esi, [esp + 08h]
        mov     edi, [esp + 0Ch]
        cld
        mov     ecx, [esp + 10h]
        shr     ecx, 1
        rep     movsw
        lea     eax, [edi]
        mov     byte ptr [eax], 00h

        mov     esp, ebp
        pop     ebp
        ret
    }
}

_declspec(naked) void ZeroString(char* s, int c)
{
    _asm
    {
        push    ebp
        mov     ebp, esp

        mov     edi, [esp + 08h]
        mov     ecx, [esp + 0Ch]
        shr     ecx, 1
        xor     eax, eax
        rep     stosw

        mov     esp, ebp
        pop     ebp
        ret
    }
}

_declspec(naked) int StringLen(char* stri)
{
    int l;

    _asm
    {
        push    ebp
        mov     ebp, esp

        mov     [l], 0
        mov     ebx, 0

_proc:
        mov     eax, stri [ebx]
        cmp     eax, 0
        je      _out
        inc     ebx
        inc     l
        jmp     _proc

_out:
        mov     eax, [l]
        mov     esp, ebp
        pop     ebp
        ret
    }
}

int main(int argc, char **argv)
{
    using namespace std;

    char* src = "my name is LEEEEEEEEEE";
    char* dst = new char[120];
    int len = StringLen(src);

    ZeroString(dst, 120);
    FastCopy16(src, dst, len);
    cout << "src: " << src << "\ndst: " << dst << endl;

    delete[] dst;
    return 0;
}

Hmm, hmm indeed.
EDIT: The funny thing is my output window shows the correct output:

Code:

src: my name is LEEEEEEEEEE
dst: my name is LEEEEEEEEEE
Press any key to continue

This is just some guess but I think that the compiler should have created a stackframe for you because you declare a local variable l. In that case

Code:

    push    ebp
    mov     ebp, esp

would destroy it.
Kurt

Ah I see - I was about to ask why mov'ing it into eax first would make a difference.

Here's my go at it...although certainly not optimized, but I think I'd be using the SCASB instruction (scan string for byte) if I were trying to do a better version of this.

Code:

int StringLen(char* stri)
{
    _asm
    {
		mov edi, [stri]         // get address of parameter
		mov ebx, 0              // register to hold character
		mov eax, 0;             // register to hold character count
L1:
		inc eax                 // increment character count
		mov bl, byte ptr [edi]  // get character at address of edi
		inc edi                 // increment pointer to next character
		cmp bl, 0               // is the character a NULL?
		jnz L1                  // if it's not NULL, loop again
        // at this point, whatever's in eax will be returned by the function
    }
}

I removed the stack stuff, and the naked declaration since I don't think they're needed.

Edit: I just realized the code above is off by one, so maybe throw in a "dec eax" at the end there

Thanks veecee that worked wonders. I've learnt my one thing for today
It looks like I was over-thinking it.

Just a quick question while it's on my mind: Is there an equivalent of GCC's -S switch for MSVC 7.1?

Hmmm, did a quick google for gcc's -S option...seems like it enables outputing assembly code I guess. I don't use the command line to compile with msvc, but it looks like the "/FA" switch or "/FAs" is what you want. In the IDE, it's under "C/C++>Output Files" for your project settings.

the FA option gives you a crazy amount of output.

ex.

Code:

int strlen(const char* text)
{
	const char* s = text;
	for ( ; *s; ++s )
		;
	return (int)(s - text);
}

becomes

Code:

?strlen@@YAHPBD@Z PROC					; strlen, COMDAT
; Line 3
	push	ebp
	mov	ebp, esp
	sub	esp, 204				; 000000ccH
	push	ebx
	push	esi
	push	edi
	lea	edi, DWORD PTR [ebp-204]
	mov	ecx, 51					; 00000033H
	mov	eax, -858993460				; ccccccccH
	rep stosd
; Line 4
	mov	eax, DWORD PTR _text$[ebp]
	mov	DWORD PTR _s$[ebp], eax
	jmp	SHORT $LN3@strlen
$LN2@strlen:
; Line 5
	mov	eax, DWORD PTR _s$[ebp]
	add	eax, 1
	mov	DWORD PTR _s$[ebp], eax
$LN3@strlen:
	mov	eax, DWORD PTR _s$[ebp]
	movsx	ecx, BYTE PTR [eax]
	test	ecx, ecx
	je	SHORT $LN1@strlen
; Line 6
	jmp	SHORT $LN2@strlen
$LN1@strlen:
; Line 7
	mov	eax, DWORD PTR _s$[ebp]
	sub	eax, DWORD PTR _text$[ebp]
; Line 8
	pop	edi
	pop	esi
	pop	ebx
	mov	esp, ebp
	pop	ebp
	ret	0
?strlen@@YAHPBD@Z ENDP					; strlen

Although given it might help you <shrug>

I would suggest you keep it as simple as possible, don't worry about optimizations until you have it working.

Maybe you were using debug mode, so you got a long list of unoptimized code....I got this nice listing of your code here in release mode:

Code:

?mystrlen@@YAHPBD@Z PROC				; mystrlen, COMDAT

; 11   : 	const char* s = text;

	mov	eax, OFFSET ??_C@_0BH@GBNNBFPP@How?5long?5is?5this?5text?$DP?$AA@
$LL3@mystrlen:

; 12   : 	for ( ; *s; ++s )

	add	eax, 1
	cmp	BYTE PTR [eax], 0
	jne	SHORT $LL3@mystrlen

; 13   : 		;
; 14   : 	return (int)(s - text);

	sub	eax, OFFSET ??_C@_0BH@GBNNBFPP@How?5long?5is?5this?5text?$DP?$AA@

; 15   : }

	ret	0
?mystrlen@@YAHPBD@Z ENDP

Heh, I just realized my crappy attempt at the strlen function in asm was off by one Oh well.