[Win32] Stack basics?

[TheSheep]

I'd like to know whether each thread in an application gets its own stack space that isn't modified by other applications. I'd also like to confirm that parameters to functions are sent to the functions by being pushed onto the stack in reverse order and popped off in the correct order. To illustrate my point, are these two statements essentially the same?

ExecuteMyFunction(param1,param2,param3);

and

__asm
   {
   push param3
   push param2
   push param1
   call ExecuteMyFunction
   }

The reason is that I'm trying to make a printf-style function that outputs in a different way. It's defined (very simplified) as follows:

//ignore amtldlm :D
void Message(void *amtldlm,char *stri,...)
{
printf("Message: ");
printf(stri); //other parameters still sitting on stack
printf("\n");
}

The idea is that the user passes a printf-format string (stri) and any additional parameters. The additional params are never retrieved so should be one the stack, right?
Looking at stdarg.h, it looks instead like each parameter is just copied side-by-side into memory; in which case is there some way (easier than parsing the string and using va_arg) that I can transfer the extra parameters from one function to the other?

Rgds.

[redhead]

Something like this ?

void Message(void *amtldlm, const char* fmt, ...)
{
  va_list ap; 
  fprintf(stdout, "Message: ");
  va_start(ap, fmt);
  vfprintf(stdout, fmt, ap);
  va_end(ap);
  fprintf(stdout, "\n");
}

[TheSheep]

Fantastic, thanks!!

[Locutus]

As for your original question...
For that particular example, essentially yes, but it depends on the calling convention the function uses.

In the default C/C++ calling convention, cdecl, arguments are pushed onto the stack right to left by the calling function, and the calling function is also the one that cleans up the stack.

Win32 API functions use a different calling convention, stdcall. Arguments are pushed right to left as with cdecl, but the called function is responsable for cleaning up the stack (ie, stdcall functions end with stuff like ret 4, ret 8, etc).

Since for variable argument functions only the calling functions knows the number of arguments, cdecl has to be used for those.

Win16 used the pascal/fortran calling convention where arguments are pushed left to right onto the stack. Called function cleans the stack.

There's also fastcall, used by MS for some stuff, which passes the first two arguments that fit into a register through ecx & edx and passes the rest rigth to left through the stack. Called functions cleans up the stack.

Thiscall is the default for C++ member function, with "this" being passed through ecx, the rest right to left through the stack, called function cleans the stack.

GCC has the "regparm(num)" attribute you can use on a function to specify it should pass up to num arguments through registers. I think the maximum is 3.

You don't really need to know all that for solving your problem, as redhead pretty much did , but it's nice stuff to know anyway.

[TheSheep]

You don't really need to know all that for solving your problem, as redhead pretty much did , but it's nice stuff to know anyway

It certainly is good to know; I might actually end up using this info though for another project (a security patch for a game, which hooks an existing DLL function). Thanks.