CODEWITHSUNDEEP
cfunctionpointersembedded
fohsie
fohsie

Reputation: 33

Pointer to end of a function code

I understand that a function pointer points to the starting address of the code for a function. But is there any way to be able to point to the end of the code of a function as well?

Edit: Specifically on an embedded system with a single processor and no virtual memory. No optimisation too. A gcc compiler for our custom processor.

I wish to know the complete address range of my function.

Upvotes: 0

Views: 1007

Answers (4)

jeb
jeb

Reputation: 82267

You didn't say why you need this information, but on some embedded system it's required to copy a single function from flash to ram in order to (re)program the flash.

Normally you are placing this functions into a new unique section and depending of your linker you can copy this section with pure C or with assembler to the new (RAM) location.

You also need to tell the linker that the code will run from another address than that it is placed in flash.

In a project the flash.c could look like

#pragma define_section pram_code "pram_code.text" RWX
#pragma section pram_code begin
uint16_t flash_command(uint16_t cmd, uint16_t *addr, uint16_t *data, uint16_t cnt)
{
 ...
}
#pragma section pram_code end

The linker command file looks like

.prog_in_p_flash_ROM : AT(Fpflash_mirror) {
    Fpram_start = .;
    # OBJECT(Fflash_command,flash.c)
    * (pram_code.text)
    . = ALIGN(2);

    # save data end and calculate data block size
    Fpram_end = .;
    Fpram_size = Fpram_end - Fpram_start;
} > .pRAM

But as others said, this is very toolchain specific

Upvotes: 3

kkrambo
kkrambo

Reputation: 7057

If you put the function within its own special linker section, then your toolchain might provide a pointer to the end (and the beginning) of the linker section. For example, with Green Hills Software (GHS) MULTI compiler I believe you can do something like this:

#pragma ghs section text=".mysection"
void MyFunction(void) { }
#pragma ghs section

That will tell the linker to locate the code for MyFunction in .mysection. Then in your code you can declare the following pointers, which point to the beginning and end of the section. The GHS linker provides the definitions automatically.

extern char __ghsbegin_mysection[];
extern char __ghsend_mysection[];

I don't know whether GCC supports similar functionality.

Upvotes: 4

Dwayne Towell
Dwayne Towell

Reputation: 8583

In some implementations (including gcc) you could do something like this (but its not guaranteed and lots of implementation details could affect it):

int foo() { 
    printf("testing\n");
    return 7;
}

void foo_end() { }

int sizeof_foo() { 
    // assumes no code size optimizations across functions
    // function could be smaller than reported
    // reports size, not range
    return (int (*)())foo_end - foo;
}

Upvotes: 1

Richard Chambers
Richard Chambers

Reputation: 17573

There is no way with C to point to the end of a function. A C compiler has a lot of latitude as to how it arranges the machine code it emits during compilation. With various optimization settings, a C compiler may actually merge machine code intermingling the machine code of the various functions.

Since along with what ever the C compiler does there is also what is done by the linker as well as the loader as a part of linking the various compiled pieces of object code together and then loading the application which may also be using various kinds of shared libraries.

In the complex running environment of modern operating systems and modern development tool chains, unless the language provides a specific mechanism for doing something, it is prudent to not try to get fancy leaving yourself open to an application which suddenly stops working due to changes in the operating environment.

In most cases if you use a non-optimizing setting of the compiler with static linked libraries, the symbol map that most linkers provide will give you a good idea as to where functions begin and end. However the only thing you can really depend on is knowing the address of the function entry points.

Upvotes: 1

Related Questions