Custom stacktrace implementation for ARM

Question

I need to have a stacktrace in my program that is written in C++ and runs on ARM-device. I can't find any reliable way to get starcktrace so I decided to write my own that will be as simple as possible, just to get something like stacktrace in gdb.

Here's an idea: write a macro that will push FUNCTION and __PRETTY_FUNCTION__. There are several questions:

Consider I have such a macro:

#define STACKTRACE_ENTER_FUNC \
    ... lock mutex
    ... push info into the global list
    ... set scope-exit handler to delete info at function exit
    ... unlock mutex 

Now I need to place this macro in every function in my code. But there are too many of them. Is there any better way to achieve the goal or should I really change every function to include this macro:

void foo()
{
    STACKTRACE_ENTER_FUNC;
    ...
}

void bar()
{
    STACKTRACE_ENTER_FUNC;
    ...
}

The next question is: I can use __PRETTY_FUNCTION__ (because we use only gcc of fixed version and the stacktrace implementation is only for debug builds on the fixed platform, no cross-platform or compiler issues). I can even parse it a bit to split the string to function name and function arguments names. But how can I print all function arguments without knowing too much about them: like types or number of arguments? Like:

int foo(char x, float y)
{
     PRINT_ARGS("arg1", "arg2"); // Gives me the string: "arg1 = 'A', arg2 = 13.37"
     ...
}

int main()
{
    foo('A', 13.37);
    ...
}

P.S. If you know a better approach to get stack-trace in running program on ARMv6, please let me know (compiler: arm-openwrt-linux-uclibcgnueabi-gcc 4.7.3, libc: uClibc-0.9.33.2)

Thanks in advance.

Answer 1

The easier solution is to drop down to assembly - stack traces don't exist on C++ level anyway.

From an assembly perspective, you use a map of function addresses (which any linker can generate). The current Instruction Pointer identifies the top frame, the return addresses identify the call stack. The tricky part is tail-call optimization, which is a bit philosophical (do you want the logical or the actual call stack?)