【嵌入式】C语言高级编程-内建函数(11)-白红宇的个人博客

【嵌入式】C语言高级编程-内建函数(11)

发布日期：2021-06-29 20:48:21 浏览次数：3 分类：技术文章

本文共 9758 字，大约阅读时间需要 32 分钟。

00. 目录

文章目录

01. 内建函数概述

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

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

用来处理变长参数列表；

用来处理程序运行异常；

程序的编译优化、性能优化；

查看函数运行中的底层信息、堆栈信息等；

C 标准库函数的内建版本。

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

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

02. 常用内建函数

**__builtin_return_address(LEVEL)

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

0：返回当前函数的返回地址；

1：返回当前函数调用者的返回地址；

2：返回当前函数调用者的调用者的返回地址；

……

程序示例

void f(void){
       int *p;    p = __builtin_return_address(0);    printf("f    return address: %p\n",p);    p = __builtin_return_address(1);;    printf("func return address: %p\n",p);    p = __builtin_return_address(2);;    printf("main return address: %p\n",p);    printf("\n");}void func(void){
       int *p;    p = __builtin_return_address(0);    printf("func return address: %p\n",p);    p = __builtin_return_address(1);;    printf("main return address: %p\n",p);    printf("\n");    f();}int main(void){
       int *p;    p = __builtin_return_address(0);    printf("main return address: %p\n",p);    printf("\n");     func();    printf("goodbye!\n");    return 0;}

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

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

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

main return address:0040124Bfunc return address:004013C3main return address:0040124Bf    return address:00401385func return address:004013C3main return address:0040124B

**__builtin_frame_address(LEVEL)

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

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

0：查看当前函数的栈帧地址

1：查看当前函数调用者的栈帧地址

……

void func(void){
       int *p;    p = __builtin_frame_address(0);    printf("func frame:%p\n",p);    p = __builtin_frame_address(1);    printf("main frame:%p\n",p);}int main(void){
       int *p;    p = __builtin_frame_address(0);    printf("main frame:%p\n",p);    printf("\n");    func();    return 0;}

执行结果

main frame:0028FF48func frame:0028FF28main frame:0028FF48

___builtin_constant_p(n)

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

#define _dma_cache_sync(addr, sz, dir)        \do {                            \    if (__builtin_constant_p(dir))          \        __inline_dma_cache_sync(addr, sz, dir); \    else                        \        __arc_dma_cache_sync(addr, sz, dir);    \}                            \while (0);

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

__builtin_expect

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

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

int main(void){
           int a;    a = __builtin_expect(3,1);    printf("a = %d\n",a);    a = __builtin_expect(3,10);    printf("a = %d\n",a);    a = __builtin_expect(3,100);    printf("a = %d\n",a);    return 0;}

这个函数的主要用途就是编译器的分支预测优化。现代 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，用来提醒程序员优化程序。

03. C 标准库的内建函数

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

常见的标准库函数如下：

内存相关的函数：memcpy 、memset、memcmp

数学函数：log、cos、abs、exp

字符串处理函数：strcat、strcmp、strcpy、strlen

打印函数：printf、scanf、putchar、puts

使用与 C 标准库对应的内建函数

#include 
   
    #include 
    
     int main(void){
       char str[100];    __builtin_memcpy(str, "hello shenzhen", strlen("hello shenzhen"));    __builtin_puts(str);    return 0;}

执行结果

deng@itcast:~/tmp$ ./a.out  hello shenzhen

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

04. 内核中的 likely 和 unlikely

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

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

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

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

#include 
   
    int main(void){
       int a = 0;    scanf("%d", &a);    if (0 == a)    {
           printf("%d", 1);        printf("%d", 2);        printf("\n");    }    else    {
           printf("%d", 5);        printf("%d", 6);        printf("\n");    }    return 0;}

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

deng@itcast:~/tmp$ arm-linux-gcc test.c deng@itcast:~/tmp$ arm-linux-objdump -D a.out 00008438 
   
    :    8438:       e92d4800        push    {fp, lr}    843c:       e28db004        add     fp, sp, #4    8440:       e24dd008        sub     sp, sp, #8    8444:       e3a03000        mov     r3, #0    8448:       e50b3008        str     r3, [fp, #-8]    844c:       e59f207c        ldr     r2, [pc, #124]  ; 84d0 
    
         8450:       e24b3008        sub     r3, fp, #8    8454:       e1a00002        mov     r0, r2    8458:       e1a01003        mov     r1, r3    845c:       ebffffc7        bl      8380 <_init+0x5c>    8460:       e51b3008        ldr     r3, [fp, #-8]    8464:       e3530000        cmp     r3, #0    8468:       1a00000a        bne     8498 
     
          846c:       e59f305c        ldr     r3, [pc, #92]   ; 84d0 
      
           8470:       e1a00003        mov     r0, r3    8474:       e3a01001        mov     r1, #1    8478:       ebffffbd        bl      8374 <_init+0x50>    847c:       e59f304c        ldr     r3, [pc, #76]   ; 84d0 
       
            8480:       e1a00003        mov     r0, r3    8484:       e3a01002        mov     r1, #2    8488:       ebffffb9        bl      8374 <_init+0x50>    848c:       e3a0000a        mov     r0, #10    8490:       ebffffb4        bl      8368 <_init+0x44>    8494:       ea000009        b       84c0 
        
          8498: e59f3030 ldr r3, [pc, #48] ; 84d0 
         
           849c: e1a00003 mov r0, r3 84a0: e3a01005 mov r1, #5 84a4: ebffffb2 bl 8374 <_init+0x50> 84a8: e59f3020 ldr r3, [pc, #32] ; 84d0 
          
            84ac: e1a00003 mov r0, r3 84b0: e3a01006 mov r1, #6 84b4: ebffffae bl 8374 <_init+0x50> 84b8: e3a0000a mov r0, #10 84bc: ebffffa9 bl 8368 <_init+0x44> 84c0: e3a03000 mov r3, #0 84c4: e1a00003 mov r0, r3 84c8: e24bd004 sub sp, fp, #4 84cc: e8bd8800 pop {fp, pc} 84d0: 0000854c andeq r8, r0, ip, asr #10

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

#include 
   
    int main(void){
       int a = 0;    scanf("%d", &a);    if (unlikely(0 == a))    {
           printf("%d", 1);        printf("%d", 2);        printf("\n");    }    else    {
           printf("%d", 5);        printf("%d", 6);        printf("\n");    }    return 0;}

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

$ arm-linux-gnueabi-gcc -O2 expect.c $ arm-linux-gnueabi-objdump -D a.out00010438 
   
    :   10438:    e92d4010    push    {r4, lr}   1043c:    e59f4080    ldr r4, [pc, #128]     10440:    e24dd008    sub sp, sp, #8   10444:    e5943000    ldr r3, [r4]   10448:    e1a0100d    mov r1, sp   1044c:    e59f0074    ldr r0, [pc, #116]   10450:    e58d3004    str r3, [sp, #4]   10454:    ebfffff1    bl  10420 <__isoc99_scanf@plt>   10458:    e59d3000    ldr r3, [sp]   1045c:    e3530000    cmp r3, #0   10460:    0a000010    beq 104a8 
    
        10464:    e3a02005    mov r2, #5   10468:    e59f105c    ldr r1, [pc, #92]   1046c:    e3a00001    mov r0, #1   10470:    ebffffe7    bl  10414 <__printf_chk@plt>   10474:    e3a02006    mov r2, #6   10478:    e59f104c    ldr r1, [pc, #76]   1047c:    e3a00001    mov r0, #1   10480:    ebffffe3    bl  10414 <__printf_chk@plt>   10484:    e3a0000a    mov r0, #10   10488:    ebffffde    bl  10408 
     
         1048c:    e59d2004    ldr r2, [sp, #4]   10490:    e5943000    ldr r3, [r4]   10494:    e3a00000    mov r0, #0   10498:    e1520003    cmp r2, r3   1049c:    1a000007    bne 104c0 
      
          104a0:    e28dd008    add sp, sp, #8   104a4:    e8bd8010    pop {r4, pc}   104a8:    e3a02001    mov r2, #1   104ac:    e59f1018    ldr r1, [pc, #24]   104b0:    e1a00002    mov r0, r2   104b4:    ebffffd6    bl  10414 <__printf_chk@plt>   104b8:    e3a02002    mov r2, #2   104bc:    eaffffed    b   10478

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

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

05. 附录

参考: C语言嵌入式Linux高级编程

转载地址：https://dengjin.blog.csdn.net/article/details/107233812 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！

上一篇：【嵌入式】C语言高级编程-可变参数宏(12)

下一篇：【嵌入式】C语言高级编程-内联函数(10)

发表评论

关于作者

喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！

-- 愿君每日到此一游！