linker - In C, is it possible to change exported function name to different one?

Question

all.

I want to link a library which calls malloc() function. However, my target environment is different one and malloc() is supplied as inline-function.

How can I make the library's call to malloc() direct to my target environment's malloc() routine?

Is it any way to change the exported function name? If so I can code my_malloc() first and export it as malloc() and link the library to that one:

#include <my_environment.h>  // malloc() is inline function declared there 
void my_malloc (void) {
   malloc (void);             
}

---

More specifically, the library is one from linux distro so it depends on libc. But my environment is embedded one and has no libc library and malloc(), free(), ... are custom-implemented. Some are inline functions and some are library functions.

Answer 1

The GNU linker (ld) supports a --wrap=functionname parameter. I'll simply quote the documentation from the man page as it includes an example which should do exactly what you need:

--wrap=symbol Use a wrapper function for symbol. Any undefined reference to symbol will be resolved to "__wrap_symbol". Any undefined reference to "__real_symbol" will be resolved to symbol.

This can be used to provide a wrapper for a system function. The wrapper function should be called "__wrap_symbol". If it wishes to call the system function, it should call "__real_symbol".

Here is a trivial example:

void *
__wrap_malloc (size_t c)
{
    printf ("malloc called with %zu
", c);
    return __real_malloc (c);
}

If you link other code with this file using --wrap malloc, then all calls to "malloc" will call the function "__wrap_malloc" instead. The call to "__real_malloc" in "__wrap_malloc" will call the real "malloc" function.

You may wish to provide a "__real_malloc" function as well, so that links without the --wrap option will succeed. If you do this, you should not put the definition of "__real_malloc" in the same file as "__wrap_malloc"; if you do, the assembler may resolve the call before the linker has a chance to wrap it to "malloc".