首页
登录 | 注册

嵌入式C语言自我修养 11:有一种函数,叫内建函数

11.1 什么是内建函数

内建函数,顾名思义,就是编译器内部实现的函数。这些函数跟关键字一样,可以直接使用,无须像标准库函数那样,要 #include 对应的头文件才能使用。

内建函数的函数命名,通常以 __builtin 开头。这些函数主要在编译器内部使用,主要是为编译器服务的。内建函数的主要用途如下。

  • 用来处理变长参数列表;
  • 用来处理程序运行异常;
  • 程序的编译优化、性能优化;
  • 查看函数运行中的底层信息、堆栈信息等;
  • C 标准库函数的内建版本。

因为内建函数是编译器内部定义,主要由编译器相关的工具和程序调用,所以这些函数并没有文档说明,而且变动而频繁。对于程序开发者来说,不建议使用这些函数。

但有些函数,对于我们了解程序运行的底层信息、编译优化很有帮助,而且在 Linux 内核中也经常使用这些函数,所以还是很有必要去了解 Linux 内核中常用的一些内建函数。


11.2 常用内建函数

__builtin_return_address(LEVEL)

这个函数用来返回当前函数或调用者的返回地址。函数的参数 LEVEl 表示函数调用链中的不同层次的函数,各个值代表的意义如下。

  • 0:返回当前函数的返回地址;
  • 1:返回当前函数调用者的返回地址;
  • 2:返回当前函数调用者的调用者的返回地址;
  • ……

我们接下来写一个测试程序。

  1. void f(void)
  2.     {
  3.         int *p;
  4.         p = __builtin_return_address(0);
  5.         printf("f return address: %p\n",p);
  6.         p = __builtin_return_address(1);;
  7.         printf("func return address: %p\n",p);
  8.         p = __builtin_return_address(2);;
  9.         printf("main return address: %p\n",p);
  10.         printf("\n");
  11.     }
  12.     void func(void)
  13.     {
  14.         int *p;
  15.         p = __builtin_return_address(0);
  16.         printf("func return address: %p\n",p);
  17.         p = __builtin_return_address(1);;
  18.         printf("main return address: %p\n",p);
  19.         printf("\n");
  20.         f();
  21.     }

  22.     int main(void)
  23.     {
  24.         int *p;
  25.         p = __builtin_return_address(0);
  26.         printf("main return address: %p\n",p);
  27.         printf("\n");
  28.         func();
  29.         printf("goodbye!\n");
  30.         return 0;
  31.     }

C 语言函数在调用过程中,会将当前函数的返回地址、寄存器等现场信息保存在堆栈中,然后才会跳到被调用函数中去执行。当被调用函数执行结束后,根据保存在堆栈中的返回地址,就可以直接返回到原来的函数中继续执行。

在这个程序中,main() 函数调用 func() 函数,在 main() 函数跳转到 func() 函数执行之前,会将程序正在运行的当前语句的下一条语句(如下代码所示)的地址保存到堆栈中,然后才去执行 func(); 这条语句,跳到 func() 函数去执行。func() 执行完毕后,如何返回到 main() 函数呢?很简单,将保存到堆栈中的返回地址赋值给 PC 指针,就可以直接返回到 main() 函数,继续往下执行了。

  1. printf("goodbye!\n");

每一层函数调用,都会将当前函数的下一条指令地址,即返回地址压入堆栈保存。各层函数调用就构成 了一个函数调用链。在各层函数内部,我们使用内建函数就可以打印这个调用链上各个函数的返回地址。程序的运行结果如下。


  1. main return address:0040124B

  2. func return address:004013C3
  3. main return address:0040124B

  4. f return address:00401385
  5. func return address:004013C3
  6. main return address:0040124B

__builtin_frame_address(LEVEL)

在函数调用过程中,还有一个“栈帧”的概念。函数每调用一次,都会将当前函数的现场(返回地址、寄存器等)保存在栈中,每一层函数调用都会将各自的现场信息都保存在各自的栈中。这个栈也就是当前函数的栈帧,每一个栈帧有起始地址和结束地址,表示当前函数的堆栈信息。多层函数调用就会有多个栈帧,每个栈帧里会保存上一层栈帧的起始地址,这样各个栈帧就形成了一个调用链。很多调试器、GDB、包括我们的这个内建函数,其实都是通过回溯函数栈帧调用链来获取函数底层的各种信息的。比如,返回地址 i、调用关系等。在 ARM 系统中,使用 FP 和 SP 这两个寄存器,分别指向当前函数栈帧的起始地址和结束地址。当函数继续调用或者返回,这两个寄存器的值也会发生变化,总是指向当前函数栈帧的起始地址和结束地址。

我们可以通过内建函数 __builtinframeaddress(LEVEL),查看函数的栈帧地址。

  • 0:查看当前函数的栈帧地址
  • 1:查看当前函数调用者的栈帧地址
  • ……

写一个程序,打印当前函数的栈帧地址。

  1. void func(void)
  2. {
  3.     int *p;
  4.     p = __builtin_frame_address(0);
  5.     printf("func frame:%p\n",p);
  6.     p = __builtin_frame_address(1);
  7.     printf("main frame:%p\n",p);
  8. }

  9. int main(void)
  10. {
  11.     int *p;
  12.     p = __builtin_frame_address(0);
  13.     printf("main frame:%p\n",p);
  14.     printf("\n");
  15.     func();
  16.     return 0;
  17. }

  1. 程序运行结果如下。

  2. main frame:0028FF48

  3. func frame:0028FF28
  4. main frame:0028FF48

11.3 C 标准库的内建函数

在 GNU C 编译器内部,实现了一些和 C 标准库函数类似的内建函数。这些函数跟 C 标准库函数功能相似,函数名也相同,只是在前面加了一个前缀 __builtin。如果你不想使用 C 库函数,也可以加个前缀,直接使用对应的内建函数。

常见的标准库函数如下:

  • 内存相关的函数:memcpy 、memset、memcmp
  • 数学函数:log、cos、abs、exp
  • 字符串处理函数:strcat、strcmp、strcpy、strlen
  • 打印函数:printf、scanf、putchar、puts

接下来我们写个小程序,使用与 C 标准库对应的内建函数。


  1. int main(void)
  2. {
  3.     char a[100];
  4.     __builtin_memcpy(a,"hello world!",20);
  5.     __builtin_puts(a);

  6.     return 0;
  7. }

  1. 程序运行结果如下。

  2. hello

通过运行结果我们看到,使用与 C 标准库对应的内建函数,同样也能实现字符串的复制和打印,实现 C 标准库函数的功能。

11.4 内建函数:__builtin_constant_p(n)

编译器内部还有一些内建函数,主要用来编译优化、性能优化,如 __builtinconstantp(n) 函数。该函数主要用来判断参数 n 在编译时是否为常量,是常量的话,函数返回1;否则函数返回0。该函数常用于宏定义中,用于编译优化。一个宏定义,根据宏的参数是常量还是变量,可能实现的方法不一样。在内核中经常看到这样的宏。

  1. #define _dma_cache_sync(addr, sz, dir) \
  2. do { \
  3.     if (__builtin_constant_p(dir)) \
  4.         __inline_dma_cache_sync(addr, sz, dir); \
  5.     else \
  6.         __arc_dma_cache_sync(addr, sz, dir); \
  7. } \
  8. while (0);

很多计算或者操作在参数为常数时可能有更优化的实现,在这个宏定义中,我们实现了两个版本。根据参数是否为常数,我们可以灵活选用不同的版本。

11.5 内建函数:__builtin_expect(exp,c)

内建函数 __builtin_expect 也常常用来编译优化。这个函数有两个参数,返回值就是其中一个参数,仍是 exp。这个函数的意义主要就是告诉编译器:参数 exp 的值为 c 的可能性很大。然后编译器可能就会根据这个提示信息,做一些分支预测上的代码优化。

参数 c 跟这个函数的返回值无关,无论 c 为何值,函数的返回值都是 exp。

  1. int main(void)
  2. {
  3.     int a;
  4.     a = __builtin_expect(3,1);
  5.     printf("a = %d\n",a);

  6.     a = __builtin_expect(3,10);
  7.     printf("a = %d\n",a);

  8.     a = __builtin_expect(3,100);
  9.     printf("a = %d\n",a);
  10.     return 0;
  11. }

  1. 程序运行结果如下。

  2. a = 3
  3. a = 3
  4. a = 3

这个函数的主要用途就是编译器的分支预测优化。现代 CPU 内部,都有 cache 这个缓存器件。CPU 的运行速度很高,而外部 RAM 的速度相对来说就低了不少,所以当 CPU 从内存 RAM 读写数据时就会有一定的性能瓶颈。为了提高程序执行效率,CPU 都会通过 cache 这个 CPU 内部缓冲区来缓存一定的指令或数据。CPU 读写内存 RAM 中的数据时,会先到 cache 里面去看看能不能找到。找到的话就直接进行读写;找不到的话,cache 会重新缓存一部分内存数据进来。CPU 读写 cache 的速度远远大于内存 RAM,所以通过这种方式,可以提高系统的性能。

那 cache 如何缓存内存数据呢?简单来说,就是依据空间相近原则。比如 CPU 正在执行一条指令,那么下一个指令周期,CPU 就会大概率执行当前指令的下一条指令。如果此时 cache 将下面几条指令都缓存到 cache 里面,下一个指令周期 CPU 就可以直接到 cache 里取指、翻译、执行,从而使运算效率大大提高。

但有时候也会出现意外。比如程序在执行过程中遇到函数调用、if 分支、goto 跳转等程序结构,会跳到其它地址执行,那么缓存到 cache 中的指令就不是 CPU 要获取的指令。此时,我们就说 cache 没有命中,cache 会重新缓存正确的指令代码给 CPU 读取,这就是 cache 工作的基本流程。

有了这个理论基础,我们在编写程序时,遇到 if/switch 这种选择分支的程序结构,可以将大概率发生的分支写在前面,这样程序运行时,因为大概率发生,所以大部分时间就不需要跳转,程序就相当于一个顺序结构,从而提高 cache 的命中率。内核中已经实现一些相关的宏,如 likely 和 unlikely,用来提醒程序员优化程序。


11.6 内核中的 likely 和 unlikely

Linux 内核中,使用 __builtin_expect 内建函数,定义了两个宏。

  1. #define likely(x) __builtin_expect(!!(x),1)
  2. #define unlikely(x) __builtin_expect(!!(x),0)

这两个宏的主要作用,就是告诉编译器:某一个分支发生的概率很高,或者说很低,基本不可能发生。编译器就根据这个提示信息,就会去做一些分值预测的编译优化。在这两个宏定义有一个细节,就是对宏的参数 x 做两次取非操作,这是为了将参数 x 转换为布尔类型,然后与 1 和 0 作比较,告诉编译器 x 为真或为假的可能性很高。

我们接下来举个例子,让大家感受下,使用这两个宏后,编译器在分支预测上的一些编译变化。

  1. //expect.c
  2. int main(void)
  3. {
  4.     int a;
  5.     scanf("%d",&a);
  6.     if( a==0)
  7.     {
  8.         printf("%d",1);
  9.         printf("%d",2);
  10.         printf("\n");
  11.     }
  12.     else
  13.     {
  14.         printf("%d",5);
  15.         printf("%d",6);
  16.         printf("\n");
  17.     }
  18.     return 0;
  19. }

在这个程序中,根据我们输入变量 a 的值,程序会执行不同的分支代码。我们接着对这个程序反汇编,生成对应的汇编代码。

  1. $ arm-linux-gnueabi-gcc expect.c
  2. $ arm-linux-gnueabi-objdump -D a.out
  3.  00010558 <main>:
  4.    10558: e92d4800 push {fp, lr}
  5.    1055c: e28db004 add fp, sp, #4
  6.    10560: e24dd008 sub sp, sp, #8
  7.    10564: e59f308c ldr r3, [pc, #140]
  8.    10568: e5933000 ldr r3, [r3]
  9.    1056c: e50b3008 str r3, [fp, #-8]
  10.    10570: e24b300c sub r3, fp, #12
  11.    10574: e1a01003 mov r1, r3
  12.    10578: e59f007c ldr r0, [pc, #124]
  13.    1057c: ebffffa5 bl 10418 <__isoc99_scanf@plt>
  14.    10580: e51b300c ldr r3, [fp, #-12]
  15.    10584: e3530000 cmp r3, #0
  16.    10588: 1a000008 bne 105b0 <main+0x58>
  17.    1058c: e3a01001 mov r1, #1
  18.    10590: e59f0068 ldr r0, [pc, #104]
  19.    10594: ebffff90 bl 103dc <printf@plt>
  20.    10598: e3a01002 mov r1, #2
  21.    1059c: e59f005c ldr r0, [pc, #92]
  22.    105a0: ebffff8d bl 103dc <printf@plt>
  23.    105a4: e3a0000a mov r0, #10
  24.    105a8: ebffff97 bl 1040c <putchar@plt>
  25.    105ac: ea000007 b 105d0 <main+0x78>
  26.    105b0: e3a01005 mov r1, #5
  27.    105b4: e59f0044 ldr r0, [pc, #68]
  28.    105b8: ebffff87 bl 103dc <printf@plt>
  29.    105bc: e3a01006 mov r1, #6
  30.    105c0: e59f0038 ldr r0, [pc, #56]
  31.    105c4: ebffff84 bl 103dc <printf@plt>

观察 main 函数的反汇编代码,我们看到:汇编代码的结构就是基于我们的 if/else 分支先后顺序,依次生成对应的汇编代码(看 10588:bne 105b0 跳转)。我们接着改一下代码,使用 unlikely 修饰 if 分支,告诉编译器,这个 if 分支小概率发生,或者说不可能发生。

  1. //expect.c
  2. int main(void)
  3. {
  4.     int a;
  5.     scanf("%d",&a);
  6.     if( unlikely(a==0) )
  7.     {
  8.         printf("%d",1);
  9.         printf("%d",2);
  10.         printf("\n");
  11.     }
  12.     else
  13.     {
  14.         printf("%d",5);
  15.         printf("%d",6);
  16.         printf("\n");
  17.     }
  18.     return 0;
  19. }

对这个程序添加 -O2 优化参数编译,并对生成的可执行文件 a.out 反汇编。

  1. $ arm-linux-gnueabi-gcc -O2 expect.c
  2.  $ arm-linux-gnueabi-objdump -D a.out
  3. 00010438 <main>:
  4.    10438: e92d4010 push {r4, lr}
  5.    1043c: e59f4080 ldr r4, [pc, #128]
  6.    10440: e24dd008 sub sp, sp, #8
  7.    10444: e5943000 ldr r3, [r4]
  8.    10448: e1a0100d mov r1, sp
  9.    1044c: e59f0074 ldr r0, [pc, #116]
  10.    10450: e58d3004 str r3, [sp, #4]
  11.    10454: ebfffff1 bl 10420 <__isoc99_scanf@plt>
  12.    10458: e59d3000 ldr r3, [sp]
  13.    1045c: e3530000 cmp r3, #0
  14.    10460: 0a000010 beq 104a8 <main+0x70>
  15.    10464: e3a02005 mov r2, #5
  16.    10468: e59f105c ldr r1, [pc, #92]
  17.    1046c: e3a00001 mov r0, #1
  18.    10470: ebffffe7 bl 10414 <__printf_chk@plt>
  19.    10474: e3a02006 mov r2, #6
  20.    10478: e59f104c ldr r1, [pc, #76]
  21.    1047c: e3a00001 mov r0, #1
  22.    10480: ebffffe3 bl 10414 <__printf_chk@plt>
  23.    10484: e3a0000a mov r0, #10
  24.    10488: ebffffde bl 10408 <putchar@plt>
  25.    1048c: e59d2004 ldr r2, [sp, #4]
  26.    10490: e5943000 ldr r3, [r4]
  27.    10494: e3a00000 mov r0, #0
  28.    10498: e1520003 cmp r2, r3
  29.    1049c: 1a000007 bne 104c0 <main+0x88>
  30.    104a0: e28dd008 add sp, sp, #8
  31.    104a4: e8bd8010 pop {r4, pc}
  32.    104a8: e3a02001 mov r2, #1
  33.    104ac: e59f1018 ldr r1, [pc, #24]
  34.    104b0: e1a00002 mov r0, r2
  35.    104b4: ebffffd6 bl 10414 <__printf_chk@plt>
  36.    104b8: e3a02002 mov r2, #2
  37.    104bc: eaffffed b 10478 <main+0x40>

我们对 if 分支条件表达式使用 unlikely 修饰,告诉编译器这个分支小概率发生。在编译器开启优化编译条件下,通过生成的反汇编代码(10460:beq 104a8),我们可以看到,编译器将小概率发生的 if 分支汇编代码放在了后面,将 else 分支的汇编代码放在了前面,这样就确保了程序在执行时,大部分时间都不需要跳转,直接按顺序执行下面大概率发生的分支代码。

在 Linux 内核中,你会发现很多地方使用 likely 和 unlikely 宏修饰,此时你应该知道它们的用途了吧。

更多嵌入式技术教程,可关注 QQ群/微信公众号:宅学部落
本教程根据《C语言嵌入式Linux高级编程》改编
电子版本教程下载地址:https://pan.baidu.com/s/1a6L0cyIQKKLlmIfRw7U6Dg

















相关文章

  • GNU C 增加一个 __atttribute__ 关键字用来声明一个函数.变量或类型的特殊属性.声明这个特殊属性有什么用呢?主要用途就是指导编译器在编译程序时进行特定方面的优化或代码检查.比如,我们可以通过使用属性声明指定某个变量的数据边 ...
  • 前面12节的课程,主要针对 Linux 内核中 GNU C 扩展的一些常用 C 语言语法进行了分析.GNU C 的这些扩展语法,主要用来完善 C 语言标准和编译优化.而通过 C 标准的发展过程我们又发现,对于一些编译器扩展的一些特性,或者其 ...
  • 这一节,接着讲 __atttribute__ 属性声明,__atttribute__ 可以说是 GNU C 最大的特色.我们接下来继续讲一下跟内联函数相关的两个属性:noinline 和 always_inline.这两个属性的用途是告诉编 ...
  • GNU C 通过 __atttribute__ 声明weak属性,可以将一个强符号转换为弱符号. 编译器在编译源程序时,无论你是变量名.函数名,在它眼里,都是一个符号而已,用来表征一个地址.编译器会将这些符号集中,存放到一个叫符号表的 se ...
  • GNU 通过 __atttribute__ 扩展的 format 属性,用来指定变参函数的参数格式检查. 我们经常实现一些自己的打印调试函数.这些打印函数往往是变参函数,那编译器编译程序时,怎么知道我们的参数格式对不对呢?因为我们实现的是变 ...

2020 unjeep.com webmaster#unjeep.com
12 q. 0.015 s.
京ICP备10005923号