Determining a functions calling address

[johny smith]

I am trying to figure out a way to print the address of what called a
certain function once inside the function.

I am assuming that this information is on the stack somewhere. But can
someone give me some
advice? I don't know where to go to look this information up.

Do I need to access the stack, and hence do some kind of inline assembly
code to get the calling address?
For example:

int main()
{

myFunction(); // I need the address of this location or the next
line to be printed in the myFunction function.

[David Hilsee]

"johny smith" <pr************ **@charter.net> wrote in message
news:10******** *****@corp.supe rnews.com...
[snip]

void myFunction()
{
// print out the calling functions address in main or the address of
the location that made this function call.
// basically, I am trying to figure out who called this function based on the address. This is used in debugging
// so I can track down who (what location) made the call if I get an
error in this function.
}

There is no portable way to do what you want to do. I would recommend
sprinkling your code with informative output/log statements. For example:

log("In main(), calling myFunction() the first time.");
myFunction();

log("In main(), calling myFunction() the second time.");
myFunction();

That approach would probably make your logs more readable, and the code
would be more portable.

--
David Hilsee

[Stephen Tyndall]

"johny smith" <pr************ **@charter.net> wrote in message
news:10******** *****@corp.supe rnews.com...

I am trying to figure out a way to print the address of what called a
certain function once inside the function.

Couldn't you just pass the address of the caller to the function? For
example, the following shows two versions: a template version and a normal
function version. Hope this helps.

#include <iostream>

using std::cout;

void doThatStuff(voi d* vp);

template<class T>

void doThisStuff(T* ptr) {

cout << "Error. doStuff(T* ptr) called from address " << ptr << "\n";

}

int main() {

doThisStuff(&ma in);

doThatStuff(&ma in);

return 0;

}

void doThatStuff(voi d* vp) {

cout << "Error. doStuff(void* vp) called from address " << vp << "\n";

}

//mike tyndall

[Stephen Tyndall]

"Stephen Tyndall" <sw*******@hotm ail.com> wrote in message
news:L_******** ************@co mcast.com...

"johny smith" <pr************ **@charter.net> wrote in message
news:10******** *****@corp.supe rnews.com...

I am trying to figure out a way to print the address of what called a
certain function once inside the function.

Couldn't you just pass the address of the caller to the function? For
example, the following shows two versions: a template version and a normal
function version. Hope this helps.

#include <iostream>

using std::cout;

void doThatStuff(voi d* vp);

template<class T>

void doThisStuff(T* ptr) {

cout << "Error. doStuff(T* ptr) called from address " << ptr << "\n";

}

int main() {

doThisStuff(&ma in);

doThatStuff(&ma in);

return 0;

}

void doThatStuff(voi d* vp) {

cout << "Error. doStuff(void* vp) called from address " << vp << "\n";

}

//mike tyndall

BTW, I realize this is totally impractical for any large-scale project, but
maybe it'll help somehow. Maybe you could put #ifdef DEBUG directives in
the code, where extra function arguments are added if DEBUG is defined.
Good luck!

[Jack Klein]

On Sun, 1 Aug 2004 21:43:19 -0500, "Stephen Tyndall"
<sw*******@hotm ail.com> wrote in comp.lang.c++:

"johny smith" <pr************ **@charter.net> wrote in message
news:10******** *****@corp.supe rnews.com...

I am trying to figure out a way to print the address of what called a
certain function once inside the function.

Couldn't you just pass the address of the caller to the function? For
example, the following shows two versions: a template version and a normal
function version. Hope this helps.

#include <iostream>

using std::cout;

void doThatStuff(voi d* vp);

template<class T>

void doThisStuff(T* ptr) {

cout << "Error. doStuff(T* ptr) called from address " << ptr << "\n";

}

int main() {

doThisStuff(&ma in);

doThatStuff(&ma in);

There are two problems with this. One is that there is no need to
apply the & operator to the name of a free-standing function to take
its address. The second is more important. There is no defined
conversion between pointer to any type of function and pointer to
void, or indeed pointer to any other object type. The code above will
not compile.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://www.eskimo.com/~scs/C-faq/top.html
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.l earn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html

[Stephen Tyndall]

"Jack Klein" <ja*******@spam cop.net> wrote in message
news:al******** *************** *********@4ax.c om...

On Sun, 1 Aug 2004 21:43:19 -0500, "Stephen Tyndall"
<sw*******@hotm ail.com> wrote in comp.lang.c++:

"johny smith" <pr************ **@charter.net> wrote in message
news:10******** *****@corp.supe rnews.com...

I am trying to figure out a way to print the address of what called a
certain function once inside the function.

Couldn't you just pass the address of the caller to the function? For
example, the following shows two versions: a template version and a normal function version. Hope this helps.

#include <iostream>

using std::cout;

void doThatStuff(voi d* vp);

template<class T>

void doThisStuff(T* ptr) {

cout << "Error. doStuff(T* ptr) called from address " << ptr << "\n";

}

int main() {

doThisStuff(&ma in);

doThatStuff(&ma in);

There are two problems with this. One is that there is no need to
apply the & operator to the name of a free-standing function to take
its address. The second is more important. There is no defined
conversion between pointer to any type of function and pointer to
void, or indeed pointer to any other object type. The code above will
not compile.

It compiles; I wrote it in VC++.NET and it works with no problems. BTW, I
know that the & wasn't necessary, but there's nothing wrong with making it
obvious that an address is being passed.

[Jack Klein]

On Mon, 2 Aug 2004 00:02:28 -0500, "Stephen Tyndall"
<sw*******@hotm ail.com> wrote in comp.lang.c++:

"Jack Klein" <ja*******@spam cop.net> wrote in message
news:al******** *************** *********@4ax.c om...

On Sun, 1 Aug 2004 21:43:19 -0500, "Stephen Tyndall"
<sw*******@hotm ail.com> wrote in comp.lang.c++:

"johny smith" <pr************ **@charter.net> wrote in message
news:10******** *****@corp.supe rnews.com...
> I am trying to figure out a way to print the address of what called a
> certain function once inside the function.

Couldn't you just pass the address of the caller to the function? For
example, the following shows two versions: a template version and a normal function version. Hope this helps.

#include <iostream>

using std::cout;

void doThatStuff(voi d* vp);

template<class T>

void doThisStuff(T* ptr) {

cout << "Error. doStuff(T* ptr) called from address " << ptr << "\n";

}

int main() {

doThisStuff(&ma in);

doThatStuff(&ma in);
There are two problems with this. One is that there is no need to
apply the & operator to the name of a free-standing function to take
its address. The second is more important. There is no defined
conversion between pointer to any type of function and pointer to
void, or indeed pointer to any other object type. The code above will
not compile.

Now that I think of it, taking the address of main() in a C++ program
is illegal no matter what you do with the address.
It compiles; I wrote it in VC++.NET and it works with no problems. BTW, I
know that the & wasn't necessary, but there's nothing wrong with making it
obvious that an address is being passed.

Apparently you are not using a real C++ compiler, or you are not using
the one you have in a standard conforming mode.

First you should have received diagnostics along these lines:

========
Borland C++ 5.6.4 for Win32 Copyright (c) 1993, 2002 Borland
simple.cpp:
"simple.cpp ": E2012 Cannot take address of 'main' in function main()
at line 16
"simple.cpp ": E2012 Cannot take address of 'main' in function main()
at line 17
*** 2 errors in Compile ***
BCC32 exited with error code: 1
Build cancelled due to errors
========

Interestingly enough when I modify your source code to remove the
illegality of taking the address of main, like this:
========
#include <iostream>

using std::cout;

void doThatStuff(voi d* vp);

template<class T>

void doThisStuff(T* ptr)
{
cout << "Error. doStuff(T* ptr) called from address " << ptr <<
"\n";
}

void my_main()
{
doThisStuff(my_ main);
doThatStuff(my_ main);
}

int main()
{
my_main();
return 0;
}

void doThatStuff(voi d* vp)
{
cout << "Error. doStuff(void* vp) called from address " << vp <<
"\n";
}
========

Borland's C++ Builder X accepts it without complaint, as does
Microsoft's Visual C++ 2005 Express Beta. The MINGW 3.2 included with
C++ Builder X generates a proper diagnostic:

========
C:\prog\CBuilde rX\mingw\bin\g+ + -c -o
C:\prog\CBuilde rX\projects\sim ple2\windows\De bug_Build\simpl e2.cpp.obj
-g2 -O0 -MD -BC:\prog\CBuild erX\MinGW\bin
-IC:\prog\CBuild erX\mingw\inclu de
-IC:\prog\CBuild erX\mingw\inclu de\c++\3.2
windows\Debug_B uild\simple2.cp p.cpp
windows/Debug_Build/simple2.cpp.cpp : In function `void my_main()':
"simple2.cpp.cp p": windows/Debug_Build/simple2.cpp.cpp invalid
conversion from `void (*)()' to at line 17
`void*'
Build cancelled due to errors
========

Testing it online with Comeau Computing's EDG front-end, arguably the
most standard conforming implementation readily accessible, also
results in a correct, and better presented, diagnostic:

========
Your Comeau C/C++ test results are as follows:

Comeau C/C++ 4.3.3 (Aug 6 2003 15:13:37) for ONLINE_EVALUATI ON_BETA1
Copyright 1988-2003 Comeau Computing. All rights reserved.
MODE:strict errors C++
"ComeauTest .c", line 17: error: argument of type "void (*)()" is
incompatible with
parameter of type "void *"
doThatStuff(my_ main);
^
1 error detected in the compilation of "ComeauTest .c".
========

Note that ISO/IEC 14882 determines what is and is not legal C++, not
just what some compilers happen to accept. In particular, Windows
based compilers (Microsoft and Borland) seem to let a lot slip by,
such as an implicit conversion from "pointer to function returning
void and accepting no arguments" to "pointer to void".

The fact that compiler accepted it without issuing a diagnostic only
means that there is a serious error in your compiler. The fact that
it allowed you to take the address of main() in a C++ program is
another serious error. Microsoft's C++ compilers prior to 7.1 did not
put a great deal of emphasis on C++ standard conformance.

Regardless of what you think, the sample code you posted had two
serious errors.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://www.eskimo.com/~scs/C-faq/top.html
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.l earn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html

[Stephen Tyndall]

"Jack Klein" <ja*******@spam cop.net> wrote in message
news:cq******** *************** *********@4ax.c om...

On Mon, 2 Aug 2004 00:02:28 -0500, "Stephen Tyndall"
<sw*******@hotm ail.com> wrote in comp.lang.c++:

"Jack Klein" <ja*******@spam cop.net> wrote in message
news:al******** *************** *********@4ax.c om...

On Sun, 1 Aug 2004 21:43:19 -0500, "Stephen Tyndall"
<sw*******@hotm ail.com> wrote in comp.lang.c++:

> "johny smith" <pr************ **@charter.net> wrote in message
> news:10******** *****@corp.supe rnews.com...
> > I am trying to figure out a way to print the address of what called a > > certain function once inside the function.
>
> Couldn't you just pass the address of the caller to the function? For > example, the following shows two versions: a template version and a normal

> function version. Hope this helps.
>
> #include <iostream>
>
> using std::cout;
>
> void doThatStuff(voi d* vp);
>
> template<class T>
>
> void doThisStuff(T* ptr) {
>
> cout << "Error. doStuff(T* ptr) called from address " << ptr << "\n"; >
> }
>
> int main() {
>
> doThisStuff(&ma in);
>
> doThatStuff(&ma in);

There are two problems with this. One is that there is no need to
apply the & operator to the name of a free-standing function to take
its address. The second is more important. There is no defined
conversion between pointer to any type of function and pointer to
void, or indeed pointer to any other object type. The code above will
not compile.
Now that I think of it, taking the address of main() in a C++ program
is illegal no matter what you do with the address.

It compiles; I wrote it in VC++.NET and it works with no problems. BTW,

I know that the & wasn't necessary, but there's nothing wrong with making it obvious that an address is being passed.

Apparently you are not using a real C++ compiler, or you are not using
the one you have in a standard conforming mode.

I'm using VC++.NET 2003, and I haven't fiddled with any options.
First you should have received diagnostics along these lines:

======== [error listing snipped] ========

Interestingly enough when I modify your source code to remove the
illegality of taking the address of main, like this:
========
#include <iostream>

using std::cout;

void doThatStuff(voi d* vp);

template<class T>

void doThisStuff(T* ptr)
{
cout << "Error. doStuff(T* ptr) called from address " << ptr <<
"\n";
}

void my_main()
{
doThisStuff(my_ main);
doThatStuff(my_ main);
}

int main()
{
my_main();
return 0;
}

void doThatStuff(voi d* vp)
{
cout << "Error. doStuff(void* vp) called from address " << vp <<
"\n";
}
========

Borland's C++ Builder X accepts it without complaint, as does
Microsoft's Visual C++ 2005 Express Beta. The MINGW 3.2 included with
C++ Builder X generates a proper diagnostic:

======== [error listing snipped] ========

Testing it online with Comeau Computing's EDG front-end, arguably the
most standard conforming implementation readily accessible, also
results in a correct, and better presented, diagnostic:

======== [error listing snipped] ========
You went to a lot of effort. I couldn't have checked these, as I don't have
those compilers and I don't know where to get them.

Note that ISO/IEC 14882 determines what is and is not legal C++, not
just what some compilers happen to accept. In particular, Windows
based compilers (Microsoft and Borland) seem to let a lot slip by,
such as an implicit conversion from "pointer to function returning
void and accepting no arguments" to "pointer to void".

The fact that compiler accepted it without issuing a diagnostic only
means that there is a serious error in your compiler. The fact that
it allowed you to take the address of main() in a C++ program is
another serious error. Microsoft's C++ compilers prior to 7.1 did not
put a great deal of emphasis on C++ standard conformance.
I had no way of knowing this. I can't afford a copy of the C++ Standard;
all I do is compile and check for errors. Other than that, I learn what I
can from the newsgroups and books.
Regardless of what you think, the sample code you posted had two
serious errors.

Regardless of what you think, I wasn't trying to argue with you. All I said
was that it compiled with VC++.NET.

//mike tyndall

[Denis Perelyubskiy]

johny smith wrote:

I am trying to figure out a way to print the address of what called a
certain function once inside the function.

I am assuming that this information is on the stack somewhere. But can
someone give me some
advice? I don't know where to go to look this information up.

Do I need to access the stack, and hence do some kind of inline assembly
code to get the calling address?

As far as I know, there is no standard/portable way of doing this. There
may be some extension in the compiler you are using (I don't know of any
that do this, but who knows).

If you don't need your code to be portable but need to get this working,
google for subroutine calling convention for your hardware architecture,
or, perhaps, for stack layout. This should give you a clue of how to get
this sort of information.

Another thing you might try, is ask folks in some newsgroup, which deals
with your architecture (perhaps assembly, or something like that)

-d

[Peter van Merkerk]

johny smith wrote:

I am trying to figure out a way to print the address of what called a
certain function once inside the function.

I am assuming that this information is on the stack somewhere. But can
someone give me some
advice? I don't know where to go to look this information up.

Do I need to access the stack, and hence do some kind of inline assembly
code to get the calling address?
For example:

int main()
{

myFunction(); // I need the address of this location or the next
line to be printed in the myFunction function.
.
.

}

void myFunction()
{
// print out the calling functions address in main or the address of
the location that made this function call.
// basically, I am trying to figure out who called this function based
on the address. This is used in debugging
// so I can track down who (what location) made the call if I get an
error in this function.
}

There is no standard or portable way to do this. But if you are using a
debugger you could just take a peek at the call stack (I would be
surprised if the debugger you are using doesn't support this).

If you use Windows you might find this article interesting:
http://www.codeguru.com/Cpp/V-S/debu...cle.php/c4429/

--
Peter van Merkerk
peter.van.merke rk(at)dse.nl