pushad
invoke someWin32
mov  dword [esp+28],eax ; return eax
popad    

Also note that a few like wsprintf use cdecl calling convention.

Pushes the contents of the general-purpose registers onto the stack. The registers are stored on the stack in the following order: EAX, ECX, EDX, EBX, EBP, ESP (original value), EBP, ESI, and EDI (if the current operand-size attribute is 32) and AX, CX, DX, BX, SP (original value), BP, SI, and DI (if the operand-size attribute is 16). (These instructions perform the reverse operation of the POPA/POPAD instructions.) The value pushed for the ESP or SP register is its value before prior to pushing the first register (see the "Operation" section below).

The PUSHA (push all) and PUSHAD (push all double) mnemonics reference the same opcode. The PUSHA instruction is intended for use when the operand-size attribute is 16 and the PUSHAD instruction for when the operand-size attribute is 32. Some assemblers may force the operand size to 16 when PUSHA is used and to 32 when PUSHAD is used. Others may treat these mnemonics as synonyms (PUSHA/PUSHAD) and use the current setting of the operand-size attribute to determine the size of values to be pushed from the stack, regardless of the mnemonic used.

In the real-address mode, if the ESP or SP register is 1, 3, or 5 when the PUSHA/PUSHAD instruction is executed, the processor shuts down due to a lack of stack space. No exception is generated to indicate this condition.

Actually, just that one function only.

Does it expect you to call the same function twice or something?

// Example of a function that would destroy the parameter (supposing no optimizations are performed)
int sum(int a, int b)
{
  a += b; // Allowed, parameters work like pre-initialized variables
  return a;
}

// Some caller
accum = 0;
for (i = 0; i < 10; i++)
  for (j = 0; j < 10; j++)
    accum += sum(j,i); // Here would be an error reusing the 2nd parameter    

For variable argument counts. Else how?

Really, there is no benefit. It was simply designed by sillies and now we're stuck with it.

func:
; foo bar
; ecx=sizeof(args)
pop edx
add esp, ecx
jmp edx    

...
mov ebp,esp
stdcall printf,"%d%d%d%d%d",eax ;oops only one parameter!
mov esp,ebp
ret

printf:
;foo bar
pop edx
add esp,4*5
jmp edx    

manfred: which will defeat the CALL/RET pairing optimization that some CPUs have.

Borsuc: how would you make a VARARG function do
stack cleanup?

push string  ; assume it is "%d%d"
push eax
push ecx
push 2*4
call printf
...


printf:
pop eax
pop ecx
add esp, ecx
push eax
ret    

"Stuck with it"? If you don't like cdecl, write your functions as stdcall or fastcall, problem solved.

By the way, you don't have to "add esp, xx" after every function call for cdecl...

Nope, what if you use an API that uses it?

f0dder wrote:

By the way, you don't have to "add esp, xx" after every function call for cdecl...

How?