Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C Programming > Getting the size of a C function

Reply
Thread Tools

Getting the size of a C function

 
 
john
Guest
Posts: n/a
 
      01-22-2010
Hi,

I need to know the size of a function or module because I need to
temporarily relocate the function or module from flash into sram to
do firmware updates.

How can I determine that at runtime? The
sizeof( myfunction)
generates an error: "size of function unknown".

Thanks.
 
Reply With Quote
 
 
 
 
David Empson
Guest
Posts: n/a
 
      01-22-2010
john <(E-Mail Removed)> wrote:

> I need to know the size of a function or module because I need to
> temporarily relocate the function or module from flash into sram to
> do firmware updates.


In general, C does not provide a mechanism to find the size of a
function. Some compilers might implement sizeof(function) but it is not
standard C.

If your compiler always outputs functions to the object code in the same
order as they appear in the source code, you could take the address of
the next function and the address of the function in question, convert
them to (char *) and get the difference between them. This assumes you
never rearrange your source code - comment well!

If your compiler outputs functions in a somewhat unpredictable order
then this won't work.

The technique I used for a similar problem was to examine the object
code to determine the size of the function manually, added a safety
margin to allow for potential code growth, and embedded that as a
constant in the source code. It then needs to be re-checked after source
changes (or a revised compiler) to confirm that the size hasn't grown
too much.

--
David Empson
http://www.velocityreviews.com/forums/(E-Mail Removed)
 
Reply With Quote
 
 
 
 
jacob navia
Guest
Posts: n/a
 
      01-22-2010
john a écrit :
> Hi,
>
> I need to know the size of a function or module because I need to
> temporarily relocate the function or module from flash into sram to
> do firmware updates.
>
> How can I determine that at runtime? The
> sizeof( myfunction)
> generates an error: "size of function unknown".
>
> Thanks.


(1)
There is the method already mentioned that subtracts two function
addresses. If your compiler is "well behaved" that could work
except for the last function in the module...

(2)
Another method is to generate an assembly listing and insert at the end
of each function a "marker" by just using (the equivalent) of
.byte 0,1,2,3,4,5,6,7,8,9,8,7,6,5,4,3,2,1
Then, at runtime you load the code and search for the terminator marker
Obviously the terminator should contain at least one illegal instruction
to be sure that it doesn't appear in the code itself

(3)
Yet another method is to generate a linker map table and read the
size of each function from the table, what comes to method (1) but
at compile time.

(4) Another method is to locate all function prologues and
function epilogues ofthe functions in the code you generate.
Locating the prologue means searching for the sequence of
instructions that the compiler generates for each function start,
probably the saving of some registers and the allocating of stack
space for the local variables.
Caveat: It could be that for certain functions the compiler
doesn't generate any prologue... specially if the function
doesn't call any other functions and receives no arguments...

Locating the epilogue means searching for the return instruction
Caveat: It could be that the compiler generates several...
You should find the last one, before you find a prologue.

From all those possibilities, the option (3) looks the more
promising one to me. Method (1) isn't very precise and
there is the problem of the last function in a compilation unit.

Method 2 is a PITA since you have to generate the assembly,
insert the markers, re-assemble...

Method (4) needs a disassembler, and a LOT of parsing work,
and it is very sensitive to compilation options.

 
Reply With Quote
 
BGB / cr88192
Guest
Posts: n/a
 
      01-23-2010

"john" <(E-Mail Removed)> wrote in message
news:hjda8u$t4k$(E-Mail Removed)...
> Hi,
>
> I need to know the size of a function or module because I need to
> temporarily relocate the function or module from flash into sram to
> do firmware updates.
>
> How can I determine that at runtime? The
> sizeof( myfunction)
> generates an error: "size of function unknown".
>


my recommendation:
in this case, it might actually be better advised to generate the function
as a chunk of arch-specific ASM or machine code (ASM is preferable IMO, but
requires an assembler...), which could then be located wherever (such as the
heap).

the reason for suggesting this is that, for many archs, relocating compiled
code (for example, via memcpy) may very well cause it to break. at least
with custom ASM, one can be more certain that the code will survive the
relocation.

another possibility would be to compile some code itself as a relocatable
module (such as an ELF or COFF object or image or whatever is common on the
arch), which can then be stored as a glob of binary data (this can be done
fairly easily by writing a tool to convert the module into a an array of
bytes in C syntax which can be linked into the image). when needed, this
module is itself relocated to the target address, and jumped to.

this would allow more complex modules to be used (and is less-effort in the
non-trivial case than would be writing it in ASM or raw machine code).


keep in mind that there is no really "good" or "general purpose" ways to do
these sorts of tasks.


> Thanks.



 
Reply With Quote
 
Grant Edwards
Guest
Posts: n/a
 
      01-23-2010
On 2010-01-23, BGB / cr88192 <(E-Mail Removed)> wrote:

> in this case, it might actually be better advised to generate the function
> as a chunk of arch-specific ASM or machine code (ASM is preferable IMO, but
> requires an assembler...), which could then be located wherever (such as the
> heap).


IMO, the "right" thing to do is to tell the compiler to put the
function into a separate section and then have it linked so
that it's "located" to run in RAM at the proper address but
stored in ROM.

That way you know the code will work correctly when it's run
from RAM. Defining approprate symbols in the linker command
file will allow the program to refer to the start and end of
the section's address in ROM.

The OP needs to spend some time studying the manuals for his
compiler and linker.

 
Reply With Quote
 
Keith Thompson
Guest
Posts: n/a
 
      01-23-2010
WangoTango <(E-Mail Removed)> writes:
> In article <hjda8u$t4k$(E-Mail Removed)>, (E-Mail Removed) says...
>> I need to know the size of a function or module because I need to
>> temporarily relocate the function or module from flash into sram to
>> do firmware updates.
>>
>> How can I determine that at runtime? The
>> sizeof( myfunction)
>> generates an error: "size of function unknown".
>>

> Good question, and I would like to know if there is an easy way to do it
> during runtime, and a portable way would be nice too. I would probably
> look at the map file and use the size I calculated from there, but
> that's surely not runtime.
>
> You can get the starting address of the function pretty easy, but how
> about the end? Hmmm, gotta' think about that.


You can't even portably assume that &func is the memory address of the
beginning of the function. I think there are systems (AS/400) where
function pointers are not just machine addresses.

Given whatever it is you're doing, you're probably not too concerned
with portability, so that likely not to be an issue. But there's no
portable way in C to determine the size of a function, so you're more
likely to get help somewhere other than comp.lang.c.

--
Keith Thompson (The_Other_Keith) (E-Mail Removed) <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"
 
Reply With Quote
 
David Empson
Guest
Posts: n/a
 
      01-23-2010
Tim Wescott <(E-Mail Removed)> wrote:

> On Sat, 23 Jan 2010 12:03:18 +1300, David Empson wrote:
>
> > john <(E-Mail Removed)> wrote:
> >
> >> I need to know the size of a function or module because I need to
> >> temporarily relocate the function or module from flash into sram to do
> >> firmware updates.

> >
> > In general, C does not provide a mechanism to find the size of a
> > function. Some compilers might implement sizeof(function) but it is not
> > standard C.
> >
> > If your compiler always outputs functions to the object code in the same
> > order as they appear in the source code, you could take the address of
> > the next function and the address of the function in question, convert
> > them to (char *) and get the difference between them. This assumes you
> > never rearrange your source code - comment well!

>
> I've seen it done like this:
>
> whatever my_eeprom_burning_code()
> {
> // insert deathless prose here
> }
>
> void end_my_eeprom_burning_code(void)
> {
> }
>
> As long as the second function doesn't get optimized away or moved,
> you're home free.


Except if the compiler outputs the functions in reverse order, as one
I've used does (which means you need a "begin_my_eeprom_burning_code"
dummy function instead). You need to know the pattern generated by your
particular compiler, which might depend on factors other than the order
the functions appear in the source code.

--
David Empson
(E-Mail Removed)
 
Reply With Quote
 
Nobody
Guest
Posts: n/a
 
      01-23-2010
On Fri, 22 Jan 2010 22:53:18 +0000, john wrote:

> I need to know the size of a function or module because I need to
> temporarily relocate the function or module from flash into sram to
> do firmware updates.


Do you need to be able to run it from RAM? If so, simply memcpy()ing it
may not work. And you would also need to copy anything which the function
calls (just because there aren't any explicit function calls in the source
code, that doesn't mean that there aren't any in the resulting object code).

 
Reply With Quote
 
Mark Borgerson
Guest
Posts: n/a
 
      01-23-2010
In article <(E-Mail Removed)>,
(E-Mail Removed) says...
> On Fri, 22 Jan 2010 22:53:18 +0000, john wrote:
>
> > I need to know the size of a function or module because I need to
> > temporarily relocate the function or module from flash into sram to
> > do firmware updates.

>
> Do you need to be able to run it from RAM? If so, simply memcpy()ing it
> may not work. And you would also need to copy anything which the function
> calls (just because there aren't any explicit function calls in the source
> code, that doesn't mean that there aren't any in the resulting object code).
>
>

At the expense of a few words of code and a parameter, you could do


int MoveMe(...., bool findend){
if(!findend){

// do all the stuff the function is supposed to do

} else Markend();

}


Where Markend is a function that pulls the return
address off the stack and stashes it somewhere
convenient. Markend may have to have some
assembly code. External code can then
subtract the function address from the address
stashed by Markend(), add a safety margin, and
know how many bytes to move to RAM.


Mark Borgerson

 
Reply With Quote
 
Paul Keinanen
Guest
Posts: n/a
 
      01-23-2010
On Fri, 22 Jan 2010 22:53:18 +0000 (UTC), john <(E-Mail Removed)>
wrote:

>I need to know the size of a function or module because I need to
>temporarily relocate the function or module from flash into sram to
>do firmware updates.


Do you actually want to execute that function while in RAM or just
store some bytes into safety during the update ?

If you intend to execute, the code must be position independent e.g.
with PC relative branch, however accessing some fixed addresses, such
as memory mapped peripherals, some absolute addressing mode must be
used, no PC relative addressing modes can not be used.


 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Preferred Size, Minimum Size, Size Jason Cavett Java 5 05-25-2008 08:32 AM
Getting picture size/setting window size jodleren Javascript 2 02-15-2007 12:35 PM
mega pixels, file size, image size, and print size - Adobe Evangelists Frank ess Digital Photography 0 11-14-2006 05:08 PM
write a function such that when ever i call this function in some other function .it should give me tha data type and value of calling function parameter komal C++ 6 01-25-2005 11:13 AM
Passing a C++ object's member function to a C function expecing a function pointer! James Vanns C++ 7 01-21-2004 02:39 AM



Advertisments