This is the mail archive of the
binutils@sourceware.org
mailing list for the binutils project.
Re: Retrieving function addresses in an object file
- From: Nick Clifton <nickc at redhat dot com>
- To: Px Seven <px_seven at yahoo dot se>
- Cc: binutils at sourceware dot org
- Date: Tue, 06 Apr 2010 15:59:14 +0100
- Subject: Re: Retrieving function addresses in an object file
- References: <678226.6316.qm@web28201.mail.ukl.yahoo.com>
Hi Fredric,
I am in the process of creating a simple, custom object file format
Note that your email really only talks about the file format for
executables. You should also consider the file format for object files,
archives and maybe shared libraries if you are going to support them.
The question is how to accomplish this with ld and gcc?
Essentially this is all going to be handled in the linker, with very
little participation by gcc. (Probably the only thing that gcc will
have to do is to mark a given symbol as being a function entry point).
It would be very convenient if one could do something like the following in the source code:
/*pseudo code*/
function_start function_2 = "offset from start of object file to start of function_2"
Presumably you are talking about the source code of the loader here, yes ?
> Is it possible to achieve something like this?
Yes, but it is going to take some work on your part. Here is how I
imagine it would work:
Application source code:
int bar (void) { return 0; }
int main (void) { return bar (); }
Compiled code (in pseudo-assembler):
.global bar
.type bar, function
bar:
move #1, reg0
rts
.global main
.type main, function
main:
call bar
rts
Note how the .type pseudo-op is used to indicate which symbols are
function names.
The assembler will convert the compiled code into an object file. I
would expect there to be a relocation generated for the CALL
instruction. This would tell the linker that at this point in the
executable the program wants to call the function MAIN. The linker
might either insert real instructions that jump into the loader along
with a parameter that is the numeric index of MAIN in the function
lookup table, or else the relocation could be left in place and the
loader could detect it a load-time and modify the CALL instruction to go
directly to the MAIN function. (This depends upon whether you want the
code to remain position independent whilst it is running or not).
Of course this leaves the problem of what to do with function pointers ?
Essentially there are two possibilities. If you want position
independence whilst the code is running, then function pointers will
have to actually be indicies into the function lookup table. Whereas if
you only want position independence up to the point where execution
starts then function pointers can be the real address of the functions,
and the loader would have to patch every place where the address of a
function is computed.
Cheers
Nick