calling convention stdcalll and cdecl call

[George2]

Hello everyone,


Both stdcall and cdecl calling convention could support variable input parameters? Is that correct?

(I think stdcall is using RET N and cdecl is using ESP - N, so both are capable to handle variable number of input parameter, like printf?)

BTW: I have this question because I have something in mind that only one of them supports variable number of parameters, but after reading assembly language code, I think both of them are able to support this feature?


thanks in advance,
George

[olivthill]

Yes, both stdcall and cdecl calling conventions support variable input parameters. The difference is that the stack pointer is reset by the callee with stdcall, and the stack pointer is reset by the caller with cdecl.

The isssue of variable arguments depends on the argument passing order and the syntax of your functions.
With the C (stdcall or cdecl) order, arguments are passed from right to left, whereas with the Pascal order, arguments are passed from left to right.

Let's look at printf("x=%d", y=%d", x, y);
Let's say the stack pointer is 100 before the call.
Three arguments are pushed onto the stack.
With the C order (stdcall and cdecl), we have:
push y ; stack pointer is 96
push x ; stack pointer is 92
push address of "x=%d", y=%d" ; stack pointer is 88.
Inside printf, the program will examine the argument which is the closest to the stack pointer, ie. address of "x=%d", y=%d", and will find that there are two percent signs, therefore two more arguments on the stack.

With the Pascal order
push address of "x=%d", y=%d" ; stack pointer is 96.
push x ; stack pointer is 92
push y ; stack pointer is 88
Inside printf, the program will examine the argument which is the closest to the stack pointer, ie. y. Now, the program does not know if there are other arguments. However, with this convention, variable arguments are possible if printf() syntax were changed in order to have the format string at the end instead of at the beginning.

[Igor Vartanov]

Both stdcall and cdecl calling convention could support variable input parameters? Is that correct?

MSDN, C++ Language Reference
__stdcall

Microsoft Specific

The __stdcall calling convention is used to call Win32 API functions. The callee cleans the stack, so the compiler makes vararg functions __cdecl.

The proof:

// 445.cpp
int __stdcall foo(int a, char c, ...) { return 0; }

E:\Temp\445>cl 445.cpp /c
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 13.10.3077 for 80x86
Copyright (C) Microsoft Corporation 1984-2002. All rights reserved.

445.cpp

E:\Temp\445>dumpbin /SYMBOLS 445.obj
Microsoft (R) COFF/PE Dumper Version 7.10.3077
Copyright (C) Microsoft Corporation.  All rights reserved.


Dump of file 445.obj

File Type: COFF OBJECT

COFF SYMBOL TABLE
000 00000000 DEBUG  notype       Filename     | .file
    445.cpp
002 00600C05 ABS    notype       Static       | @comp.id
003 00000001 ABS    notype       Static       | @feat.00
004 00000000 SECT1  notype       Static       | .drectve
    Section length   2A, #relocs    0, #linenums    0, checksum        0
006 00000000 SECT2  notype       Static       | .debug$S
    Section length   5A, #relocs    0, #linenums    0, checksum        0
008 00000000 SECT3  notype       Static       | .text
    Section length    7, #relocs    0, #linenums    0, checksum 96F779C9
00A 00000000 SECT3  notype ()    External     | ?foo@@YAHHDZZ (int __cdecl foo(int,char,...))

String Table Size = 0x12 bytes

  Summary

          5A .debug$S
          2A .drectve
           7 .text

See the difference.

[kirants]

FYI:
Function Calls, Part 2 (Stack and Calling Conventions)

[George2]

Thanks olivthill,


I do not fully agree with you that both stdcall and cdecl call support variable input parameters. Please refer to Igor's comment below and find only cdecl supports variable input parameter feature. Any comments?

Yes, both stdcall and cdecl calling conventions support variable input parameters. The difference is that the stack pointer is reset by the callee with stdcall, and the stack pointer is reset by the caller with cdecl.

The isssue of variable arguments depends on the argument passing order and the syntax of your functions.
With the C (stdcall or cdecl) order, arguments are passed from right to left, whereas with the Pascal order, arguments are passed from left to right.

Let's look at printf("x=%d", y=%d", x, y);
Let's say the stack pointer is 100 before the call.
Three arguments are pushed onto the stack.
With the C order (stdcall and cdecl), we have:
push y ; stack pointer is 96
push x ; stack pointer is 92
push address of "x=%d", y=%d" ; stack pointer is 88.
Inside printf, the program will examine the argument which is the closest to the stack pointer, ie. address of "x=%d", y=%d", and will find that there are two percent signs, therefore two more arguments on the stack.

With the Pascal order
push address of "x=%d", y=%d" ; stack pointer is 96.
push x ; stack pointer is 92
push y ; stack pointer is 88
Inside printf, the program will examine the argument which is the closest to the stack pointer, ie. y. Now, the program does not know if there are other arguments. However, with this convention, variable arguments are possible if printf() syntax were changed in order to have the format string at the end instead of at the beginning.

regards,
George

[George2]

Thanks Igor,


What is the root cause why stdcall does not support variable number of input parameter? Maybe from generated assembly, we could find out?

(I think both caller and callee could get # of input parameters from stack in theory?)


regards,
George

[Igor Vartanov]

Thanks Igor,

What is the root cause why stdcall does not support variable number of input parameter? Maybe from generated assembly, we could find out?

Exactly!

Let's see, the very basic sample:

// 446cdecl.cpp
int __cdecl foo(int a, char c, ...) { return 0; }
int main() { return foo(0, 0, 0); }

// 445stdcall.cpp
int __stdcall foo(int a, char c) { return 0; }
int main() { return foo(0, 0); }

Compile along with producing ASM:

cl 446cdecl.cpp /c /FA && cl 446stdcall.cpp /c /FA

PUBLIC	?foo@@YAHHDZZ					; foo
; Function compile flags: /Odt
_TEXT	SEGMENT
_a$ = 8							; size = 4
_c$ = 12						; size = 1
?foo@@YAHHDZZ PROC NEAR					; foo
; File e:\temp\446\446cdecl.cpp
; Line 1
	push	ebp
	mov	ebp, esp
	xor	eax, eax
	pop	ebp
	ret	0
?foo@@YAHHDZZ ENDP					; foo
_TEXT	ENDS
PUBLIC	_main
; Function compile flags: /Odt
_TEXT	SEGMENT
_main	PROC NEAR
; Line 2
	push	ebp
	mov	ebp, esp
	push	0
	push	0
	push	0
	call	?foo@@YAHHDZZ				; foo
	add	esp, 12					; 0000000cH
compiler knows exactly the size of the stack on the caller side
	pop	ebp
	ret	0
_main	ENDP

PUBLIC	?foo@@YGHHD@Z					; foo
; Function compile flags: /Odt
_TEXT	SEGMENT
_a$ = 8							; size = 4
_c$ = 12						; size = 1
?foo@@YGHHD@Z PROC NEAR					; foo
; File e:\temp\446\446stdcall.cpp
; Line 1
	push	ebp
	mov	ebp, esp
	xor	eax, eax
	pop	ebp
	ret	8                          ; the function body knows the 
                                         ; exact size of stack to be cleared 
                                         ; (defined by function prototype) 
                                         ; but knows nothing about the actual stack size used
?foo@@YGHHD@Z ENDP					; foo
_TEXT	ENDS
PUBLIC	_main
; Function compile flags: /Odt
_TEXT	SEGMENT
_main	PROC NEAR
; Line 2
	push	ebp
	mov	ebp, esp
	push	0
	push	0
	call	?foo@@YGHHD@Z				; foo
	pop	ebp
	ret	0
_main	ENDP

(I think both caller and callee could get # of input parameters from stack in theory?)

Yep, maybe in theory. But not in practice.

[George2]

Thanks Igor!


I think the reason why stdcall can not have variable number of input parameter is, we can not have a common code which is capable to pop variable number of input parameters (a specific function is common code base, and needs common code to pop a specific number (not variable) of elements from stack, but if input parameter number is variable, it is impossible to have such a common code base), correct?


regards,
George