Chinaunix首页 | 论坛 | 博客
  • 博客访问: 766347
  • 博文数量: 13
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 165
  • 用 户 组: 普通用户
  • 注册时间: 2019-02-01 13:13
个人简介

嵌入式视频淘宝店:wanglitao.taobao.com

文章分类
文章存档

2019年(13)

我的朋友

分类: 嵌入式

2019-04-18 08:59:13

9.1 属性声明:weak

GNU C 通过 __atttribute__ 声明weak属性,可以将一个强符号转换为弱符号。

使用方法如下。

  1. void __attribute__((weak)) func(void);
  2. int num __attribte__((weak);

编译器在编译源程序时,无论你是变量名、函数名,在它眼里,都是一个符号而已,用来表征一个地址。编译器会将这些符号集中,存放到一个叫符号表的 section 中。

在一个软件工程项目中,可能有多个源文件,由不同工程师开发。有时候可能会遇到这种情况:A 工程师在他负责的 A.c 源文件中定义了一个全局变量 num,而 B 工程师也在他负责的 B.c 源文件中定义了一个同名全局变量 num。那么当我们在程序中打印变量 num 的值时,是该打印哪个值呢?

是时候表演真正的技术了。这时候,就需要用编译链接的原理知识来分析这个问题了。编译链接的基本过程其实很简单,主要分为三个阶段。

  • 编译阶段:编译器以源文件为单位,将每一个源文件编译为一个 .o 后缀的目标文件。每一个目标文件由代码段、数据段、符号表等组成。

  • 链接阶段:链接器将各个目标文件组装成一个大目标文件。链接器将各个目标文件中的代码段组装在一起,组成一个大的代码段;各个数据段组装在一起,组成一个大的数据段;各个符号表也会集中在一起,组成一个大的符号表。最后再将合并后的代码段、数据段、符号表等组合成一个大的目标文件。

  • 重定位:因为各个目标文件重新组装,各个目标文件中的变量、函数的地址都发生了变化,所以要重新修正这些函数、变量的地址,这个过程称为重定位。重定位结束后,就生成了可以在机器上运行的可执行程序。

上面举例的工程项目,在编译过程中的链接阶段,可能就会出现问题:A.c 和 B.c 文件中都定义了一个同名变量 num,那链接器到底该用哪一个呢?

这个时候,就需要引入强符号和弱符号的概念了。

9.2 强符号和弱符号

在一个程序中,无论是变量名,还是函数名,在编译器的眼里,就是一个符号而已。符号可以分为强符号和弱符号。

  • 强符号:函数名、初始化的全局变量名;
  • 弱符号:未初始化的全局变量名。

在一个工程项目中,对于相同的全局变量名、函数名,我们一般可以归结为下面三种场景。

  • 强符号+强符号
  • 强符号+弱符号
  • 弱符号+弱符号

强符号和弱符号在解决程序编译链接过程中,出现的多个同名变量、函数的冲突问题非常有用。一般我们遵循下面三个规则。

  • 一山不容二虎
  • 强弱可以共处
  • 体积大者胜出

为了方便,这是我编的顺口溜。主要意思就是:在一个项目中,不能同时存在两个强符号,比如你在一个多文件的工程中定义两个同名的函数,或初始化的全局变量,那么链接器在链接时就会报重定义的错误。但一个工程中允许强符号和弱符号同时存在。比如你可以同时定义一个初始化的全局变量和一个未初始化的全局变量,这种写法在编译时是可以编译通过的。编译器对于这种同名符号冲突,在作符号决议时,一般会选用强符号,丢掉弱符号。还有一种情况就是,一个工程中,同名的符号都是弱符号,那编译器该选择哪个呢?谁的体积大,即谁在内存中存储空间大,就选谁。

我们接下来写一个简单的程序,来验证上面的理论。定义两个源文件:main.c 和 func.c。

  1. //func.c
  2. int a = 1;
  3. int b;
  4. void func(void)
  5. {
  6.     printf("func:a = %d\n", a);
  7.     printf("func: b = %d\n", b);
  8. }

  9. //main.c
  10. int a;
  11. int b = 2;
  12. void func(void);
  13. int main(void)
  14. {
  15.     printf("main:a = %d\n", a);
  16.     printf("main: b = %d\n", b);
  17.     func();
  18.     return 0;
  19. }

编译程序,可以看到程序运行结果。

  1. $ gcc -o a.out main.c func.c
  2. main: a = 1
  3. main: b = 2
  4. func: a = 1
  5. func: b = 2

我们在 main.c 和 func.c 中分别定义了两个同名全局变量 a 和 b,但是一个是强符号,一个是弱符号。链接器在链接过程中,看到冲突的同名符号,会选择强符号,所以你会看到,无论是 main 函数,还是 func 函数,打印的都是强符号的值。

一般来讲,不建议在一个工程中定义多个不同类型的弱符号,编译的时候可能会出现各种各样的问题,这里就不举例了。在一个工程中,也不能同时定义两个同名的强符号,即初始化的全局变量或函数,否则就会报重定义错误。但是我们可以使用 GNU C 扩展的 weak 属性,将一个强符号转换为弱符号。

  1. //func.c
  2. int a __attribute__((weak)) = 1;
  3. void func(void)
  4. {
  5.     printf("func:a = %d\n", a);
  6. }

  7. //main.c
  8. int a = 4;
  9. void func(void);
  10. int main(void)
  11. {
  12.     printf("main:a = %d\n", a);
  13.     func();
  14.     return 0;
  15. }

编译程序,可以看到程序运行结果。

  1. $ gcc -o a.out main.c func.c
  2. main: a = 4
  3. func: a = 4

我们通过 weak 属性声明,将 func.c 中的全局变量 a,转换为一个弱符号,然后在 main.c 里同样定义一个全局变量 a,并初始化 a 为4。链接器在链接时会选择 main.c 中的这个强符号,所以在两个文件中,打印变量 a 的值都是4。

9.3 函数的强符号和弱符号

链接器对于同名变量冲突的处理遵循上面的强弱规则,对于函数同名冲突,同样也遵循相同的规则。函数名本身就是一个强符号,在一个工程中定义两个同名的函数,编译时肯定会报重定义错误。但我们可以通过 weak 属性声明,将其中一个函数转换为弱符号。

  1. //func.c
  2. int a __attribute__((weak)) = 1;
  3. void __attribute__((weak)) func(void)
  4. {
  5.     printf("func:a = %d\n", a);
  6. }

  7. //main.c
  8. int a = 4;
  9. void func(void)
  10. {
  11.     printf("I am a strong symbol!\n");
  12. }
  13. int main(void)
  14. {
  15.     printf("main:a = %d\n", a);
  16.     func();
  17.     return 0;
  18. }

编译程序,可以看到程序运行结果。

  1. $ gcc -o a.out main.c func.c
  2. main: a = 4
  3. func: I am a strong

在这个程序示例中,我们在 main.c 中重新定义了一个同名的 func 函数,然后将 func.c 文件中的 func() 函数,通过 weak 属性声明转换为一个弱符号。链接器在链接时会选择 main.c 中的强符号,所以我们在 main 函数中调用 func() 时,实际上调用的是 main.c 文件里的 func() 函数。

9.4 弱符号的用途

在一个源文件中引用一个变量或函数,当我们只声明,而没有定义时,一般编译是可以通过的。这是因为编译是以文件为单位的,编译器会将一个个源文件首先编译为 .o 目标文件。编译器只要能看到函数或变量的声明,会认为这个变量或函数的定义可能会在其它的文件中,所以不会报错。甚至如果你没有包含头文件,连个声明也没有,编译器也不会报错,顶多就是给你一个警告信息。但链接阶段是要报错的,链接器在各个目标文件、库中都找不到这个变量或函数的定义,一般就会报未定义错误。

当函数被声明为一个弱符号时,会有一个奇特的地方:当链接器找不到这个函数的定义时,也不会报错。编译器会将这个函数名,即弱符号,设置为0或一个特殊的值。只有当程序运行时,调用到这个函数,跳转到0地址或一个特殊的地址才会报错。

  1. //func.c
  2. int a __attribute__((weak)) = 1;

  3. //main.c
  4. int a = 4;
  5. void __attribute__((weak)) func(void);
  6. int main(void)
  7. {
  8.     printf("main:a = %d\n", a);
  9.     func();
  10.     return 0;
  11. }

  12. 编译程序,可以看到程序运行结果。

  13. $ gcc -o a.out main.c func.c
  14. main: a = 4
  15. Segmentation fault (core dumped)

在这个示例程序中,我们没有定义 func() 函数,仅仅是在 main.c 里作了一个声明,并将其声明为一个弱符号。编译这个工程,你会发现是可以编译通过的,只是到了程序运行时才会出错。

为了防止函数运行出错,我们可以在运行这个函数之前,先做一个判断,即看这个函数名的地址是不是0,然后再决定是否调用、运行。这样就可以避免段错误了,示例代码如下。

  1. //func.c
  2. int a __attribute__((weak)) = 1;

  3. //main.c
  4. int a = 4;
  5. void __attribute__((weak)) func(void);
  6. int main(void)
  7. {
  8.     printf("main:a = %d\n", a);
  9.     if (func)
  10.         func();
  11.     return 0;
  12. }
  13. 编译程序,可以看到程序运行结果。

  14. $ gcc -o a.out main.c func.c
  15. main: a = 4

函数名的本质就是一个地址,在调用 func 之前,我们先判断其是否为0,为0的话就不调用了,直接跳过。你会发现,通过这样的设计,即使这个 func() 函数没有定义,我们整个工程也能正常的编译、链接和运行!

弱符号的这个特性,在库函数中应用很广泛。比如你在开发一个库,基础的功能已经实现,有些高级的功能还没实现,那你可以将这些函数通过 weak 属性声明,转换为一个弱符号。通过这样设置,即使函数还没有定义,我们在应用程序中只要做一个非0的判断就可以了,并不影响我们程序的运行。等以后你发布新的库版本,实现了这些高级功能,应用程序也不需要任何修改,直接运行就可以调用这些高级功能。

弱符号还有一个好处,如果我们对库函数的实现不满意,我们可以自定义与库函数同名的函数,实现更好的功能。比如我们 C 标准库中定义的 gets() 函数,就存在漏洞,常常成为黑客堆栈溢出攻击的靶子。

  1. int main(void)
  2. {
  3.     char a[10];
  4.     gets(a);
  5.     puts(a);
  6.     return 0;
  7. }

C 标准定义的库函数 gets() 主要用于输入字符串,它的一个 Bug 就是使用回车符来判断用户输入结束标志。这样的设计很容易造成堆栈溢出。比如上面的程序,我们定义一个长度为10的字符数组用来存储用户输入的字符串,当我们输入一个长度大于10的字符串时,就会发生内存错误。

接着我们定义一个跟 gets() 相同类型的同名函数,并在 main 函数中直接调用,代码如下。

  1. #include<stdio.h>

  2.  char * gets (char * str)
  3.  {
  4.      printf("hello world!\n");
  5.      return (char *)0;
  6.  }

  7. int main(void)
  8. {
  9.     char a[10];
  10.     gets(a);
  11.     return 0;
  12. }

  13. 程序运行结果如下。

  14. hello

通过运行结果,我们可以看到,虽然我们定义了跟 C 标准库函数同名的 gets() 函数,但编译是可以通过的。程序运行时调用 gets() 函数时,就会跳转到我们自定义的 gets() 函数中运行。


9.5 属性声明:alias

GNU C 扩展了一个 alias 属性,这个属性很简单,主要用来给函数定义一个别名。


  1. void __f(void)
  2. {
  3.     printf("__f\n");
  4. }

  5. void f() __attribute__((alias("__f")));
  6. int main(void)
  7. {
  8.     f();
  9.     return 0;
  10. }

  1. 程序运行结果如下。

  2. __f

通过 alias 属性声明,我们就可以给 f() 函数定义一个别名 f(),以后我们想调用 f() 函数,可以直接通过 f() 调用即可。

在 Linux 内核中,你会发现 alias 有时会和 weak 属性一起使用。比如有些函数随着内核版本升级,函数接口发生了变化,我们可以通过 alias 属性给这个旧接口名字做下封装,起一个新接口的名字。


  1. //f.c
  2. void __f(void)
  3. {
  4.     printf("__f()\n");
  5. }
  6. void f() __attribute__((weak,alias("__f")));

  7. //main.c
  8. void __attribute__((weak)) f(void);
  9. void f(void)
  10. {
  11.     printf("f()\n");
  12. }

  13. int main(void)
  14. {
  15.     f();
  16.     return 0;
  17. }

当我们在 main.c 中新定义了 f() 函数时,在 main 函数中调用 f() 函数,会直接调用 main.c 中新定义的函数;当 f() 函数没有新定义时,就会调用 __f() 函数。

更多嵌入式教程:QQ群/微信公众号:宅学部落
本教程电子书籍下载地址:https://pan.baidu.com/s/1a6L0cyIQKKLlmIfRw7U6Dg

阅读(221104) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册