Assuming you have a function f() from which you want to know the caller.

Rename that function to f_func() and define a macro f() that prints __func__ and then calls f_func(). Example:

void
f_func()
{
        do something;
}

#define f() \
        do { \
                printf("f called from %s\n", __func__); \
                f_func(); \
        } while (0)

void
a()
{
        f();
}

void
b()
{
        f();
}

int
main(int argc, char **argv)
{
        a();
        b();

        return(0);
}

There's no way to get a function name in the runtime. The only way is the preprocessor but it's very limited in its capabilities. In case you have debug information available, you could walk the stack and get the function names from the debugging information. This is, however, neither a robust nor a portable solution.

There are couple of GNU functions that allow you to get function addresses and names from backtrace - backtrace() and backtrace_symbols(), but you need to compile your binary with -rdynamic flag

NO

The short answer is NO

but with preprocessor it can be done like this

Getting the name of the calling function in C (using the preprocessor)

Assuming you have a function f() from which you want to know the caller only for debugging purpose.

Rename that function to f_func() and define a macro f() that calls a version of f that prints func and then calls f_func() when DEBUG is defined.

In the final release the information is removed by calling the real function f_func()

Example

#ifdef DEBUG
  #define f(a,b,c) f_debug(a,b,c, __func__)
#else
  #define f(a,b,c) f_func(a,b,c)
#endif

bool f_func(int par1, int par2, int par3)
{
  do_somthing();
}

bool f_debug((int par1, int par2, int par3, const char calling_func_name[])
{
  printf("f called from %s\n", calling_func_name); 
  f_func(); 
}

void a()
{
  f();
}

void b()
{
  f();
}

int main(int argc, char **argv)
{
        a();
        b();

        return(0);
}

Result is:

when DEBUG is defined

f called from a
f called from b

Use the __func__ identifier. The standard (section 6.4.2.2) requires that it be present for precisely this purpose:

The identifier __func__ shall be implicitly declared by the translator as if, immediately following the opening brace of each function definition, the declaration

static const char __func__[] = "function-name";

appeared, where function-name is the name of the lexically-enclosing function.

As Steve Jessop notes in a comment, this isn't part of the preprocessor as such, but an intrinsic part of the compiler.

There may well be ways of finding out this name by walking the stack and looking at debugging symbols. Cute, but insane.