Thread: Variable allocation, when?

Just a little dumb question.
You know, when declaring a variable it is pushed onto the stack and is then accessed through some addressing relative the stack pointer, right?
My question is, when a function is called are all variables pushed directly at the call or can they be pushed later if you wait with the declaration?

Code:

void Func(int Arg)
{
   int Var1;

   if(Arg == something) return;

   int Var2;
}

In the exampple above, will Var2 always be pushed or only when Arg is not 'something'?
I usually declare all my variables at the top to easily see what are used in the function, but for speed (duh!) it may be better to wait with the declaration until they are actually used?

...Just me being bored and having nothing better to think of...

Usually, on entering a function, the code produces a stack frame.....this is done by looking at what space is needed (maybe 10 DWORDs..sometimes more) and adjusting the stack pointer and base pointer to give the required stack room...

In your code, the int declarations do nothing, and they most likely wont appear on the stack at all, but their space requirement would be taken into account if they were used.

As for the return, yes - I guess the second int would have space allocated (if it was used - as it's not used, the optimiser may ignore it) as the logic test to return or not is done at runtime, so at compile time, the compiler would take a more prudent view

Also, exactly how does the 'relative adressing' work? I guess you can't use a constant since that would screw things up if you push something else. If it's some kind of variable, where is it stored?

Note: In the example above, I assumed that the compiler didn't do any kind of optimization, so the variable declarations remains .

Thanks Salem, that was a useful feature. I think I got it now. There is also a datapointer pointing to the variables in the current block, and they are referenced through constants relative the DP. The DP still points at the same location even if the SP is changed.
I also learned how arguments/return values for functions are handled .

I thought that you had to declare the variables at the beginning of any block, before any other code...unless I've been misinformed, your code wouldn't work without some more brackets.

Originally posted by blackrat364
I thought that you had to declare the variables at the beginning of any block, before any other code...unless I've been misinformed, your code wouldn't work without some more brackets.

For C, yes. For C++, no. I prefer using the C style, because it looks like crap otherwise, and makes your code harder to follow usually.

Quzah.

Originally posted by quzah
For C, yes. For C++, no. I prefer using the C style, because it looks like crap otherwise, and makes your code harder to follow usually.

Quzah.

Agreed. I would rather declare vars and pointers at the beginning of any code... it just makes more sense that way, looks better, and is easier to read (like Quzah said).

Originally posted by quzah
For C, yes. For C++, no. I prefer using the C style, because it looks like crap otherwise, and makes your code harder to follow usually.

Quzah.

It does make the code more understandable, but if the variable is a class with a constructor, then it's often more efficient to declare when needed.....

Code:

class foobar
{
   foobar(){/*Do something*/}
};

void SomeFunc(bool b)
{
   foobar foo;//constructor called no matter what

   if(!b)return;

   foobar bar;//constructor only called if needed

}

...but for standard ints, char*s and the like, this doesnt matter and the extra clarity of having variables at the top of a block makes sense

If you need to access variables explicitly off the stack it is quite straight forward. However, what you have to remember is when the activation record is being constructed (before the ip is even loaded with the address of the function) the parameters of the functions are pushed from right to left. Therefore to access the very first parameter off the stack you would have to use indirect addressing, e.g. mov eax, [ebp + 8] The plus 8 is to skip the callers saved base pointer and the return address of the function.
If you really want to declare a variable within a function which might not be used, but you want to prevent it from being optimised out, you would declare it as volatile.

Hope this is a bit more help for ya.

There is a reason it is like that in c++. the reason is that most times a variable is declared a constructor is called ( sometimes many). This is an expensive performance hit for an unused variable. Same goes for its destruction.
Scott meyers wrote an article on this in 1 of his books.