Macros giving problems with dladdr()

Question

I have implemented tracing behavior using the -finstrument-functions option of gcc and this (simplified) code:

void __cyg_profile_func_enter(void *this_fn, void *call_site)
{
    Dl_info di;
    if(dladdr(this_fn, &di))
        printf("entered %s\n", (di.dli_sname?di_dli_sname:"<unknown>"));
}

This works great, except for one thing: macros are processed as well, but the function prints the information of the function which contains the macro.

So functions containing macros have their information printed multiple times (which is of course undesired).

Is there anything to detect that a macro is being processed? Or is is possible to turn off instrumenting macros at all?

PS Same problems occur with sizeof()

Edit: To clarify: I am looking for a solution to prevent macros messing with the instrumented functions (which they should not be doing). Not for methods to trace macros, functions and/or other things.

Answer 1

Macros are expanded inline by the preprocessor, therefore there is no way to distinguish between a function called directly from the code and called from a macro.

The only possible way around this would be to have your macros set a global flag, which your tracing function will check. This is of course less than foolproof, since any calls done by a function called from a macro will also appear the same way.

Answer 2

If you really want to dig into it you can see my response to breakdown c++ code size. C++ templates are really just more formal macros, so this may work for you.

It also may not, since LINE and FILE within a macro correspond to the caller.

edit from my comment on this:

$ gcc -E foo.c | gcc -x c-cpp-output -c -finstrument-functions - -o foo.o

preprocess piped into gcc expecting preprocessed input on standard input