GNU gcc / ld - 在同一个目标文件中定义调用者和被调用者的包装

问题描述

为了澄清，我的问题指的是当调用者和被调用者被定义在同一个编译单元中时，使用GCC编译器和链接器将调用从一个函数/符号调用到另一个函数/符号 。

我有类似以下的情况：

pre $ / * foo.c * /
void foo（void）
{
/ * ... some stuff * /
bar（）;
}

void bar（void）
{
/ * ...其他的东西* /
}


我想打包调用这些函数，我可以用，但只重命名符号及其引用。

我想将调用替换为 foo 和 bar （在foo.o中）至 __ wrap_foo 和 __wrap_bar （就像它们通过链接器的 - wrap 选项在其他目标文件中解析一样）之前，我将* .o文件传递给链接器 - wrap 选项，而不必修改foo.c的源代码。

这样，打包/所有对 foo 和 bar 的调用都会截取，而不仅仅是发生在foo.o之外的调用。

这可能吗？

解决方案

您必须使用objcopy弱化和全局化符号。

  -W symbolname 
 --weaken-symbol = symbolname 
使符号symbolname变弱。该选项可能会多次提供。 
 --globalize-symbol = symbolname 
给符号symbolname全局作用域，以便在定义它的文件之外可见。该选项可能会多次提供。 
  

这对我有用

栏。 c：

  #include  
 int foo（）{
 printf（Wrap-FU\\\
）; 
} 
  

foo.c：

  #include< stdio.h> 
 
 void foo（）{
 printf（foo\\\
）; 
 
 
 int main（）{
 printf（main\\\
）; 
 foo（）; 
} 
  

编译它

  $ gcc -c foo.c bar.c 
  

Weaken

$ b

  $ objcopy foo.o --globalize-symbol = foo --weaken-symbol = foo foo2.o 
  

现在您可以将新的obj与包装from bar.c

  $ gcc -o nowrap foo.o＃仅供参考
 $ gcc -o wrapme foo2。 o bar.o 
  

测试

  $ ./nowrap 
 main 
 foo 
  

和包装的：

  $ ./wrapme 
主
换行符
  

to clarify, my question refers to wrapping/intercepting calls from one function/symbol to another function/symbol when the caller and the callee are defined in the same compilation unit with the GCC compiler and linker.

I have a situation resembling the following:

/* foo.c */
void foo(void)
{
  /* ... some stuff */
  bar();
}

void bar(void)
{
  /* ... some other stuff */
}

I would like to wrap calls to these functions, and I can do that (to a point) with ld's --wrap option (and then I implement __wrap_foo and __wrap_bar which in turn call __real_foo and __real_bar as expected by the result of ld's --wrap option).

gcc -Wl,--wrap=foo -Wl,--wrap=bar ...

The problem I'm having is that this only takes effect for references to foo and bar from outside of this compilation unit (and resolved at link time). That is, calls to foo and bar from other functions within foo.c do not get wrapped.

I tried using objcopy --redefine-sym, but that only renames the symbols and their references.

I would like to replace calls to foo and bar (within foo.o) to __wrap_foo and __wrap_bar (just as they get resolved in other object files by the linker's --wrap option) BEFORE I pass the *.o files to the linker's --wrap options, and without having to modify foo.c's source code.

That way, the wrapping/interception takes place for all calls to foo and bar, and not just the ones taking place outside of foo.o.

Is this possible?

解决方案

You have to weaken and globalize the symbol using objcopy.

-W symbolname
--weaken-symbol=symbolname
    Make symbol symbolname weak. This option may be given more than once.
--globalize-symbol=symbolname
    Give symbol symbolname global scoping so that it is visible outside of the file in which it is defined. This option may be given more than once.

This worked for me

bar.c:

#include <stdio.h>
int foo(){
  printf("Wrap-FU\n");
}

foo.c:

#include <stdio.h>

void foo(){
printf("foo\n");
}

int main(){
printf("main\n");
foo();
}

Compile it

$ gcc -c foo.c bar.c

Weaken the foo symbol and make it global, so it's available for linker again.

$ objcopy foo.o --globalize-symbol=foo --weaken-symbol=foo foo2.o

Now you can link your new obj with the wrap from bar.c

$ gcc -o nowrap foo.o #for reference
$ gcc -o wrapme foo2.o bar.o

Test

$ ./nowrap
main
foo

And the wrapped one:

$ ./wrapme
main
Wrap-FU

这篇关于GNU gcc / ld - 在同一个目标文件中定义调用者和被调用者的包装的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！