How to know the function name by function pointer's address - Unix

Hi forks:

I use the gcc's compiler flag -finstrument-functions which will
generate instrumentation calls for entry and exit to every
functions.Just after function entry and just before function exit, the
fol-
lowing profiling functions will be called with the address of the
current function and its call site.

The prototype of function which shall be called afetr function entry
is
void __cyg_profile_func_enter (void *this_fn, void *call_site);

the pointer this_fn is the address of callee function, and the
call_site is the address of caller function.

How do I know the function name by these addresses?

BR,

Chisin wrote:
> Hi forks:
>
> I use the gcc's compiler flag -finstrument-functions which will
> generate instrumentation calls for entry and exit to every
> functions.Just after function entry and just before function exit, the
> fol-
> lowing profiling functions will be called with the address of the
> current function and its call site.
>
> The prototype of function which shall be called afetr function entry
> is
> void __cyg_profile_func_enter (void *this_fn, void *call_site);
>
> the pointer this_fn is the address of callee function, and the
> call_site is the address of caller function.
>
> How do I know the function name by these addresses?


In Linux/GNU libc maybe you can use:

#include

backtrace()
backtrace_symbols()

On 10 Aug, 10:26, Chisin wrote:

> I use the gcc's compiler flag -finstrument-functions which will
> generate instrumentation calls for entry and exit to every
> functions.Just after function entry and just before function exit, the
> fol-
> lowing profiling functions will be called with the address of the
> current function and its call site.
>
> The prototype of function which shall be called afetr function entry
> is
> void __cyg_profile_func_enter (void *this_fn, void *call_site);
>
> the pointer this_fn is the address of callee function, and the
> call_site is the address of caller function.
>
> How do I know the function name by these addresses?

You can get it from the symbol table using libbfd, as nm utility does.
http://en.wikipedia.org/wiki/Binary_File_Descriptor

Chisin writes:

> Hi forks:
>
> I use the gcc's compiler flag -finstrument-functions which will
> generate instrumentation calls for entry and exit to every
> functions.Just after function entry and just before function exit, the
> fol-
> lowing profiling functions will be called with the address of the
> current function and its call site.
>
> The prototype of function which shall be called afetr function entry
> is
> void __cyg_profile_func_enter (void *this_fn, void *call_site);
>
> the pointer this_fn is the address of callee function, and the
> call_site is the address of caller function.
>
> How do I know the function name by these addresses?

But if you want to do it portably, you have to do it explicitely.

% cat a.c

#include

int f(){return(0);}
int g(){return(1);}
int h(){return(2);}

struct { void* fun; char* name; } table[] = {{f,"f"},{g,"g"},{h,"h"},{0,0}};

const char* getname(void* fun){
int i;
for(i=0;table[i].name!=0;i++){
if(fun==table[i].fun){
return(table[i].name);
}
}
return(0);
}

int main(){
printf("%s %s %s\n",getname(f),getname(g),getname(h));
return(0);
}

% cc a.c -o a
% ./a
f g h

You can also play with macros to avoid filling the table explicitely.

--
__Pascal Bourguignon__ http://www.informatimago.com/

NOTE: The most fundamental particles in this product are held
together by a "gluing" force about which little is currently known
and whose adhesive power can therefore not be permanently
guaranteed.

On Aug 10, 7:28 pm, Pascal Bourguignon wrote:
> Chisin writes:
> > Hi forks:
>
> > I use the gcc's compiler flag -finstrument-functions which will
> > generate instrumentation calls for entry and exit to every
> > functions.Just after function entry and just before function exit, the
> > fol-
> > lowing profiling functions will be called with the address of the
> > current function and its call site.
>
> > The prototype of function which shall be called afetr function entry
> > is
> > void __cyg_profile_func_enter (void *this_fn, void *call_site);
>
> > the pointer this_fn is the address of callee function, and the
> > call_site is the address of caller function.
>
> > How do I know the function name by these addresses?
>
> But if you want to do it portably, you have to do it explicitely.
>
> % cat a.c
>
> #include
>
> int f(){return(0);}
> int g(){return(1);}
> int h(){return(2);}
>
> struct { void* fun; char* name; } table[] = {{f,"f"},{g,"g"},{h,"h"},{0,0}};
>
> const char* getname(void* fun){
> int i;
> for(i=0;table[i].name!=0;i++){
> if(fun==table[i].fun){
> return(table[i].name);
> }
> }
> return(0);
>
> }
>
> int main(){
> printf("%s %s %s\n",getname(f),getname(g),getname(h));
> return(0);
>
> }
>
> % cc a.c -o a
> % ./a
> f g h
>
> You can also play with macros to avoid filling the table explicitely.
>
> --
> __Pascal Bourguignon__ http://www.informatimago.com/
>
> NOTE: The most fundamental particles in this product are held
> together by a "gluing" force about which little is currently known
> and whose adhesive power can therefore not be permanently
> guaranteed.- Hide quoted text -
>
> - Show quoted text -

I know it's a good way to make my own table, but if I own hundreds of
functions?
It seems the better way is to use the libbfd as my solution.
Any suggestions?


BR,
Chisin

Chisin writes:
> I know it's a good way to make my own table, but if I own hundreds of
> functions?
> It seems the better way is to use the libbfd as my solution.
> Any suggestions?

Then:

>> You can also play with macros to avoid filling the table explicitely.

Use a macro like:

--------------------------(implemacs.h)---------------------------------
#define DEFUN(name,args,resultype) resultype name args

------------------------------------------------------------------------
#include

DEFUN(f,(int a,int b),float)
{
return(0.0);
}

DEFUN(g,(int a,int b),int)
{
return(a+b);
}
------------------------------------------------------------------------

everywhere.



So now you can easily do some nice stuff, like making the .h from the .c:

--------------------------(intermacs.h)---------------------------------
echo '#define DEFUN(name,args,resultype) extern resultype name args;

--------------------------(Makefile)------------------------------------
SOURCES=src1.c src2.c
OBJECTS=$(SOURCES:.c=.o)
HEADERS=$(SOURCES:.c=.h)
$HEADERS:$(SOURCES)
for f in $(SOURCES) ; do \
echo '#include ' > $${f/.c/.h} ;\
grep -e '/^DEFUN(/' < $$f >> $${f/.c/.h} ;\
done

# But you can also easily build the table:

table.c: $(SOURCES)
for f in $(SOURCES) ; do \
echo '#define DEFUN(name,args,resultype) { name , #name },' ;\
echo 'struct {void* fun,char* nam} table[]={' ;\
grep -e '/^DEFUN(/' < $$f ;\
echo '{0,0}};' ;\
done > table.c

------------------------------------------------------------------------

for example...

--
__Pascal Bourguignon__ http://www.informatimago.com/

NOTE: The most fundamental particles in this product are held
together by a "gluing" force about which little is currently known
and whose adhesive power can therefore not be permanently
guaranteed.

hi,
i am trying to do something similar, i have used backtrace and backtrace_symbols
but even symbols is giving library .so name and address.
How do i get the function name from it?
Can someone please help me.

Thanks.
~taker