Get the address of an instruction in C/C++

Question

Any ways to get the address of an instruction? I have tried to used to labeled the instruction and get the address of the label but seems that it only works in GCC compiler with the && operator. (Refer to: this article) What if other compilers?

Any thoughts of this question?

Arctogaea

C++ is not required to be implemented with instructions. – Materially

Hi Basile, I am currently doing some research on the instruction / data watch features. – Arctogaea

Can we assume GCC with explicit register variables? In that case, I'd use register char *program_counter asm("pc");, assuming that the program counter register PC (for ARM, use the instruction pointer, IP, on x86...it's processor dependent). – Psychosis

Seth, sorry, why I used instruction instead of statement is that after the code compiled, it will has one or more instructions associated with the statement. But I want to refer to the first instruction of the statement. Thanks for clarifying me. – Arctogaea

Hi all, also I thought of using function pointer to a function of which only contains the instruction you want to get the address. It is a solution, but I don't think it is a neat way. :) – Arctogaea

@Arctogaea you miss my point; there's no way this can be done in standard C because C has no concept of instructions or the address of statements. (Sorry I said C++ before, I forget which tag I'm in all the time.) – Materially

I think he isn't looking for a generic, standard safe way.. maybe just a somewhat portable one? @nigong: what are the targeted compilers/platforms? – Effeminate

@KarolyHorvath: Anything non-standard is inherently non-portable. – Jabe

@Ed S.: you missed the word "somewhat" (eg: working with gcc and msvc) – Effeminate

@KarolyHorvath My platform is VDSP from Analog Devices, but I am also looking at a generic way to do so. – Arctogaea

@KarolyHorvath: No, it is inherently non-portable. Of course, in practice there are ways to get around this, but technically, if it's you're relying on something that's not specified in the standard then you risk encountering issues when targeting a different platform. That much I think we can agree upon. – Jabe

@Ed S.: agree? that was obvious. – Effeminate

@KarolyHorvath: Then what are you questioning exactly? I'm confused. – Jabe

@Ed S.: yes, you seem to be confused. I've just asked him about the targeted platform, that's all. I guess he's rather looking for a practical solution than a dogmatic answer ("there's no generic way") which doesn't have much pragmatic value. welcome to the real world (just kidding, don't take it seriously). – Effeminate

@KarolyHorvath: Oh, is that last bit kind of like saying "No offense, but you're an idiot"? I already said there are obviously ways to work around it, doesn't change the fact that non-standard code is inherently non-portable. – Jabe

@Ed S.: I just don't understand what made you think I wasn't aware of that... but nevermind. – Effeminate

Answer 1

I'm not sure that the C or the C++ language standards speak of instruction; you could conceivably run a C program compiled to be executed by a large group of human slaves (but that would be unethical, even if standard conforming). You can run by yourself a simplistic tiny program with a pencil and paper, you could use a C interpreter, etc... etc...

An optimizing C or C++ compiler would also translate some C statements into several machine instructions located at various places (in particular, compilers do inline or clone functions or even basic blocks, even without any inline keyword in the source code).

On most system, you might hand code (e.g. in assembly) a routine which returns as a pointer value its return address (i.e. the address of the caller).

With GCC (and compatible compilers, perhaps Clang/LLVM), you might use __builtin_return_address and related builtins.

Gnu Libc on Linux offers you backtrace (but I have been diappointed by it, when I tried).

Notice that these tricks might not work when compiling with -fno-frame-pointer

You might also consider customizing GCC e.g. with plugins or MELT extensions (MELT is a domain specific language, implemented as a GPLv3 plugin to GCC, to extend GCC more easily than with plugins coded in C). Your customized GCC might insert calls to instrumentation functions at appropriate places.

Canvass

Hi Basile, thanks for your answer. But I didn't mean to say the relation of instructions and statement. What I want to do is just get the address of a statement or instruction in C/C++. :) – Arctogaea

@Arctogaea He's basically saying that there may not even be instructions at all. Especially if it were being run by slaves rather than a CPU. – Roulette

If 'instruction' and 'statement' were sufficiently similar concepts, this might be feasible. However, most statements generate multiple instructions, which may not even be consecutive (loop constructs, etc.) and may be interleaved (optimization, instruction scheduling) with instructions from other statements. – Smackdab

Answer 2

Caution: Way out of the box here..

Can you have the linker generate a map file that contains the addresses ( relative or otherwise ) of the applications objects ( functions and data )? Your application could then simply parse the linker map file...

Coping

On Linux, dladdr does that for you -see <dlfcn.h> and dlopen) or at least helps a lot. – Canvass

Answer 3

The only standard C or C++ construct that is even close to the address of an instruction is a function pointer, which I suppose is not what you mean. However, you can accomplish most of what you might do with gcc label values using instead pointers to functions containing the necessary blocks of code.

There are no other options in C/C++.

Qadi

Answer 4

The return address of a function is the location of the next instruction to be executed upon return from the current function. GCC exposes this through __builtin_return_address; while Visual C++ provides it via _ReturnAddress.

Transpolar