Determine a function's stack size.

Hi,

Once a function is called it's parameters, return address etc, are pushed onto the stack, Can we determine programatically how much stack space a function uses? i.e. by wiring some code in the called function, or the code that calls the function, and not using some profiling tool.

Thanks,
regards,
koodoo.

I searched in this forum and found this thread Want a C Function to get current thread's stack size
I then wrote the following code. It compiles/executes without error, but I don't know whether it gives me the correct value or not.
Suppose there's a function "testfunc", and we wish to find how much stackspace this fuction uses. I've written the following code for this.

Code:

#include <stdio.h>
#include <stddef.h>
ptrdiff_t testfunc (int arg1, int arg2, char *stackbase); 

int main()
{


char *stackbase;
printf("\nThe amount of stack space used by \"testfunc\" is : %ul bytes\n",testfunc(10, 5, stackbase));

return 0;
}

ptrdiff_t testfunc (int arg1, int arg2, char *stackbase)
{
//.
//.
//all function processing goes here
//.
//.
//.
//.
char temp;
return stackbase - &temp;
}

First thing is that, will this code give me the desired result?
Secondly, what is the best way to print a ptrdiff_t entity. It is a typedef I think defined in stddef.h as
typedef long ptrdiff_t;
so currently I'm just printing it as an unsigned long integer.

regards,
koodoo

Except you didn't follow the code very well....
Read it again - note that stackbase is NOT passed by value.

I read it and I even noticed that stackbase wasn't passed by value. But still made a mistake. What I wanted was something like this.

Code:

#include <stdio.h>
#include <stddef.h>
ptrdiff_t testfunc (int arg1, int arg2, char *stackbase); 

int main()
{


char stackbase;
printf("\nThe amount of stack space used by \"testfunc\" is : %ul bytes\n",testfunc(10, 5, &stackbase));

return 0;
}

ptrdiff_t testfunc (int arg1, int arg2, char *stackbase)
{
//.
//.
//all function processing goes here
//.
//.
//.
//.
char temp;
return stackbase - &temp;
}

Is this correct?

Better, but you still need to call a function to work out how much space you needed.

There is no relationship between the order in which you declare local variables, and the relative positions of them on the stack.

Or there's this way

Code:

void foo ( int a ) {
    int c = 2;
    printf("hello %d %d\n",a,c);
}

_foo:
	pushl	%ebp
	movl	%esp, %ebp
	subl	$24, %esp
	movl	$2, -4(%ebp)
	movl	-4(%ebp), %eax
	movl	%eax, 8(%esp)
	movl	8(%ebp), %eax
	movl	%eax, 4(%esp)
	movl	$LC0, (%esp)
	call	_printf
	leave
	ret

Use "gcc -S" to compile your code, then look for the size adjustment for %esp.

Thanks, I'm still very new to understanding the disassembled output. But I'll study and try to understand it.
Thanks for all the help

Since the return value of testfunc() is nonnegative, you should be using size_t instead of ptrdiff_t. This is especially true since ptrdiff_t is not actually guaranteed to be able to hold the difference between two pointers (even though the name would lead you to think otherwise), but size_t is guaranteed to be able to hold the size of any object, including an array, so it is guaranteed to be able to hold a nonnegative difference between two pointers (to the same array).