#include <windows.h>

int test()
{
       return 4;
}

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow)
{
int a = test();
}    

CPU Disasm
Address   Hex dump          Command                                  Comments
00401000   $  C2 1000       RETN 10                                  ; test.00401000(guessed Arg1,Arg2,Arg3,Arg4)
    

#include <windows.h>

int test()
{
        return 4;
}

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow)
{
volatile int a = test();
}    

CPU Disasm
Address   Hex dump          Command                                  Comments
00401000  /$  51            PUSH ECX                                 ; test.00401000(guessed Arg1,Arg2,Arg3,Arg4)
00401001  |.  C70424 040000 MOV DWORD PTR SS:[LOCAL.0],4
00401008  |.  59            POP ECX
00401009  \.  C2 1000       RETN 10    

push ecx ;this is not saving the value of ecx, but is allocating stack space. Could also be "sub esp,4", but this is an optimised version.
mov [esp],4 ;our volatile variable MUST be saved to memory, we told it to do this by using volatile
pop ecx ;this is merely to release our local stack storage, the ecx value is not a return value. Could also be "add esp,4", but this is an optimised version.
retn 0x10 ;remove callers parameters from stack, stdcall    

Why is it storing it in ecx? I thought stdcall uses eax.

#include <windows.h>

int test()
{
 return 4;
}

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow)
{
volatile int       a = test();
         a = 1;
              a = 2;
              a = 3;
              a = 4;
              a = 5;
              return 6;
}    

Here is something you can try:

Code:

#include <windows.h>

int test()
{
  return 4;
}

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow)
{
volatile int       a = test();
         a = 1;
              a = 2;
              a = 3;
              a = 4;
              a = 5;
              return 6;
}    

Now what does it assemble?

CPU Disasm
Address   Hex dump          Command                                  Comments
00401000  /$  55            PUSH EBP                                 ; test.00401000(guessed Arg1,Arg2,Arg3,Arg4)
00401001  |.  8BEC          MOV EBP,ESP
00401003  |.  51            PUSH ECX
00401004  |.  6A 04         PUSH 4
00401006  |.  58            POP EAX
00401007  |.  8945 FC       MOV DWORD PTR SS:[LOCAL.1],EAX
0040100A  |.  C745 FC 01000 MOV DWORD PTR SS:[LOCAL.1],1
00401011  |.  C745 FC 02000 MOV DWORD PTR SS:[LOCAL.1],2
00401018  |.  C745 FC 03000 MOV DWORD PTR SS:[LOCAL.1],3
0040101F  |.  8945 FC       MOV DWORD PTR SS:[LOCAL.1],EAX
00401022  |.  6A 06         PUSH 6
00401024  |.  C745 FC 05000 MOV DWORD PTR SS:[LOCAL.1],5
0040102B  |.  58            POP EAX
0040102C  |.  C9            LEAVE
0040102D  \.  C2 1000       RETN 10    

Looks good to me. Optimised for size also. And your return value (6) has been set.

I still do not call that efficient to store the 4 on the stack when I was asking for a return of 4. Storing it in EAX, for instance, and RETN 10 would have been better in an efficiency point of view.

Now, if you were to write that by hand, for an entirely ASM project, how would you have written it?

Why is it storing it in ecx? I thought stdcall uses eax.

DarkAlchemist wrote:

Now, if you were to write that by hand, for an entirely ASM project, how would you have written it?

That is not really relevant. We already know HLL compilers are stupid. If you want to criticise the code it generates then go ahead, but we all already know that discussion. As far as HLL compilers go, that one did a pretty decent job. It certainly could have done much worse. But don't expect it to make perfect assembly, else you will be forever disappointed.

Tyler wrote:

Why is it storing it in ecx? I thought stdcall uses eax.

Probably because the WinMain is supposed to return an int, but no return value was provided, and an implicit '0' will be returned... which means EAX can't be used for this purpose. If the code had done "return test()" instead of using the volatile variable, things would have been very different... like, "mov eax, 4"

#include <windows.h>

int test()
{
    return 4;
}

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow)
{
return test();
}    

CPU Disasm
Address   Hex dump          Command                                  Comments
00401000  /$  6A 04         PUSH 4                                   ; test.00401000(guessed Arg1,Arg2,Arg3,Arg4)
00401002  |.  58            POP EAX
00401003  \.  C2 1000       RETN 10    

int main()
{
   return 42;
}    

PUBLIC _main
; Function compile flags: /Ogtpy
; File e:\temp\ret4.c
_TEXT SEGMENT
_main PROC

; 3 : return 42;

00000 b8 2a 00 00 00 mov eax, 42

; 4 : }

00005 c3 ret 0
_main ENDP
_TEXT ENDS
END

PUBLIC _main
; Function compile flags: /Ogspy
; File e:\temp\ret4.c
; COMDAT _main
_TEXT SEGMENT
_main PROC

; 3 : return 42;

00000 6a 2a push 42
00002 58 pop eax

; 4 : }

00003 c3 ret 0
_main ENDP
_TEXT ENDS
END

So, the sites that say to optimize for size normally produces faster code these days was full of bunk? Your examples says, at least in this instance, it was.