gcc __attribute__((const))解析

引言

在 C 语言中，编译器优化是提高程序性能的一个重要手段。编译器通过分析代码，识别出一些不必要的重复计算，消除冗余操作，从而提高程序的执行效率。为了帮助编译器更好地进行优化，GCC 提供了一些函数属性（attributes），__attribute__((const)) 就是其中之一。它告诉编译器，某些函数是纯函数（pure function），即它们的输出只依赖于输入参数，且没有副作用。通过这种方式，编译器可以更好地优化程序的性能。

在这篇文章中，我们将详细介绍 __attribute__((const)) 的工作原理，并通过代码示例演示其使用方法和实际应用。

工作原理

__attribute__((const)) 是GCC 中用于标记函数为“常量函数”的属性。它告诉编译器，这个函数的返回值只依赖于传递给它的参数，并且它不会修改任何全局状态，如全局变量、静态变量或内存、I/O等。这种类型的函数常被称为纯函数，其主要特点如下：

• 无副作用：函数调用不会改变外部环境，也不会有任何对外部环境的依赖。
• 可预测的输出：对于相同的输入，函数总是返回相同的结果。

使用 __attribute__((const)) 可以帮助编译器识别哪些函数是纯函数，从而在进行优化时应用以下策略：

1. 缓存函数结果：对于相同的输入，编译器可以避免多次调用函数，而是直接使用之前计算过的结果。这在大量重复调用同一个函数时可以显著提升性能。
2. 消除不必要的函数调用：如果编译器知道某个函数不会影响程序的外部状态，它可能会在一些场景下跳过该函数的调用，进一步提高效率。

注意：__attribute__((const)) 类似于 __attribute__((pure))，但更严格。__attribute__((pure)) 允许函数读取全局变量或内存中的数据，但不能修改它们，而 __attribute__((const)) 则要求函数既不能修改外部状态，也不能依赖外部状态。

代码演示

为了更好地理解 __attribute__((const)) 的用法，我们来看一个简单的例子：

源文件 test.c ：

#include <stdio.h>

// 使用 __attribute__((const)) 标记纯函数
int square(int x) __attribute__((const));

int square(int x) {
    return x * x;
}

int main() {
    int a = 5;

    // 调用两次 square 函数
    int result1 = square(a);  // 第一次调用
    int result2 = square(a);  // 第二次调用，相同输入

    printf("Result1: %d\n", result1);
    printf("Result2: %d\n", result2);

    return 0;
}

上述代码解析如下：

1. 定义和标记函数： 我们定义了一个 square 函数，它计算输入参数 x 的平方值。这个函数被标记为 __attribute__((const))，表示它没有副作用，且返回值只依赖于输入参数。

2. 在 main 中调用 square 函数： 我们在 main 函数中调用了两次 square(a)，其中 a 的值相同。因为函数被标记为 __attribute__((const))，编译器可能会对其进行优化。

编译运行 test.c 文件，结果如下：

[root@localhost const]# gcc -o test test.c
[root@localhost const]# ls
test  test.c
[root@localhost const]# ./test
Result1: 25
Result2: 25

通过打印结果，我们无法确定 square(5) 函数是否被调用了 2 次，因此，让我们查看该程序的汇编代码，确认 square 函数是否被调用了 2 次。生成汇编的命令如下：

[root@localhost const]# gcc -S test.c -o test.s
[root@localhost const]# ls
test  test.c  test.s
[root@localhost const]# cat test.s
        .file   "test.c"
        .text
        .globl  square
        .type   square, @function
square:
.LFB0:
        .cfi_startproc
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        movq    %rsp, %rbp
        .cfi_def_cfa_register 6
        movl    %edi, -4(%rbp)
        movl    -4(%rbp), %eax
        imull   -4(%rbp), %eax
        popq    %rbp
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc
.LFE0:
        .size   square, .-square
        .section        .rodata
.LC0:
        .string "Result1: %d\n"
.LC1:
        .string "Result2: %d\n"
        .text
        .globl  main
        .type   main, @function
main:
.LFB1:
        .cfi_startproc
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        movq    %rsp, %rbp
        .cfi_def_cfa_register 6
        subq    $16, %rsp
        movl    $5, -4(%rbp)
        movl    -4(%rbp), %eax
        movl    %eax, %edi
        call    square
        movl    %eax, -8(%rbp)
        movl    -4(%rbp), %eax
        movl    %eax, %edi
        call    square
        movl    %eax, -12(%rbp)
        movl    -8(%rbp), %eax
        movl    %eax, %esi
        movl    $.LC0, %edi
        movl    $0, %eax
        call    printf
        movl    -12(%rbp), %eax
        movl    %eax, %esi
        movl    $.LC1, %edi
        movl    $0, %eax
        call    printf
        movl    $0, %eax
        leave
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc
.LFE1:
        .size   main, .-main
        .ident  "GCC: (GNU) 8.5.0 20210514 (Red Hat 8.5.0-17)"
        .section        .note.GNU-stack,"",@progbits

根据上面生成的汇编文件内容，我们可以清晰的看到 square 函数被调用了 2 次，如下：

call    square
...
call    square

这是为什么？很多人看到这里可能会比较懵，不是说使用 __attribute__((const)) 可以帮助编译器识别哪些函数是纯函数，从而对于相同的输入，编译器可以避免多次调用函数，而是直接使用之前计算过的结果？为什么这里 square 却被调用了 2 次？怎么回事？ __attribute__((const)) 失效了吗？

其实，使用 __attribute__((const)) 标记函数后，编译器会认为这个函数是纯函数（没有副作用，且只依赖于输入参数），从而在某些情况下进行优化。然而 __attribute__((const)) 并不保证编译器一定会进行优化，它只是为编译器提供了更多优化的可能性。具体的优化行为通常依赖于编译器的优化级别。在上面的例子中，编译器虽然知道 square 函数是纯函数，但因为你编译时没有启用优化选项，编译器并没有实际进行优化，因此函数还是被调用了两次。

为了让编译器实际进行优化，我们需要在编译时添加优化选项。GCC 提供了多个优化级别，通过 -O 系列选项启用：

• -O0 或没有 -O 选项（默认）: 在该优化级别， GCC 不会实施任何优化，用近可能直接的方法来编译源代码。源代码中的每行代码被直接转换成可执行文件中的对应指令，没有任何调整。当调试一个程序时，这是使用的最佳选项。 -O0 选项等同于不指定 -O 选项。
• -O1 或 -O：这一级会打开那些不需要任何速度-空间折衷的最常见形式的优化。使用该选项后，生成的可执行文件应当比使用 -O0 更小也更快。更深度的优化，比如指令调度，在这一级别不会被用到。带选项 -O1 编译所花时间可能常常少于带 -O0 编译，这是由于在简单优化后减少了需要处理的数据量。
• -O2：该选项除了 -O1 用到的那些优化以外，打开进一步优化。这些另外的优化中包括指令调度。只有不需要速度-空间折衷的优化才被该级别用到，所以可执行文件在大小上不应该有增加。相比 -O1，编译器将花更多时间来编译程序，并需要更多内存。对要部署的程序而言，该选项通常是最佳选择，因为在不增加可执行文件大小的情况下，它提供了最大的优化。它是各种 GNU 软件发行包的默认优化级别。
• -O3：该选项除了用到低级别的 -O2 和 -O1 的所有优化以外，还打开更深度的优化，比如函数内嵌。-O3 优化级别提升生成的可执行文件的速度，但也可能增加它的大小。在有些情况下，这些优化反而可能是不利的，实际上会使得程序运行减慢。
• -Os：选择缩减可执行文件大小的优化。它的目的是为内存和磁盘空间受限的系统生成尽可能小的可执行文件。在某些情况下，由于较好的缓冲利用率，较小的可执行文件也运行得更快。

记住，你要衡量在最高级别优化所获得的好处与为此付出的代价，这是重要的。优化的代价包括增加调试的复杂度，增加编译期所花的时间和所需要的内存。就绝大部分目的而言，调试时用 -O0，开发和部署时用 -O2 就足够了。

可以通过如下方式编译代码，启用 -O2 优化选项：

[root@localhost const]# gcc -O2 -o test test.c
[root@localhost const]# gcc -O2 -S test.c -o test.s 
[root@localhost const]# cat test.s
        .file   "test.c"
        .text
        .p2align 4,,15
        .globl  square
        .type   square, @function
square:
.LFB11:
        .cfi_startproc
        imull   %edi, %edi
        movl    %edi, %eax
        ret
        .cfi_endproc
.LFE11:
        .size   square, .-square
        .section        .rodata.str1.1,"aMS",@progbits,1
.LC0:
        .string "Result1: %d\n"
.LC1:
        .string "Result2: %d\n"
        .section        .text.startup,"ax",@progbits
        .p2align 4,,15
        .globl  main
        .type   main, @function
main:
.LFB12:
        .cfi_startproc
        subq    $8, %rsp
        .cfi_def_cfa_offset 16
        movl    $25, %esi
        movl    $.LC0, %edi
        xorl    %eax, %eax
        call    printf
        movl    $25, %esi
        movl    $.LC1, %edi
        xorl    %eax, %eax
        call    printf
        xorl    %eax, %eax
        addq    $8, %rsp
        .cfi_def_cfa_offset 8
        ret
        .cfi_endproc
.LFE12:
        .size   main, .-main
        .ident  "GCC: (GNU) 8.5.0 20210514 (Red Hat 8.5.0-17)"
        .section        .note.GNU-stack,"",@progbits

让我们逐步解析上面优化后的汇编代码，以说明编译器的优化行为。

square 函数部分：

.globl  square
.type   square, @function
square:
.LFB11:
    .cfi_startproc
    imull   %edi, %edi  # 计算 x * x
    movl    %edi, %eax  # 将结果放入 %eax 寄存器
    ret                 # 返回结果
    .cfi_endproc

这里是 square 函数的汇编代码，imull %edi, %edi 表示将输入参数（传递给 square 函数的整数值）平方。计算完成后，结果被移动到 %eax 中，作为函数的返回值。然后通过 ret 返回。

但关键是，在接下来的 main 函数部分，并没有看到多次调用 square 的操作，而是编译器直接进行了优化。

main 函数部分：

main:
.LFB12:
    .cfi_startproc
    subq    $8, %rsp                   # 调整栈指针
    .cfi_def_cfa_offset 16
    movl    $25, %esi                  # 直接将常量 25 作为结果存入 %esi
    movl    $.LC0, %edi                # 加载 "Result1: %d\n" 的地址
    xorl    %eax, %eax                 # 清除 %eax 寄存器
    call    printf                     # 调用 printf 输出 "Result1: 25"

    movl    $25, %esi                  # 直接将常量 25 存入 %esi
    movl    $.LC1, %edi                # 加载 "Result2: %d\n" 的地址
    xorl    %eax, %eax                 # 清除 %eax 寄存器
    call    printf                     # 调用 printf 输出 "Result2: 25"

    xorl    %eax, %eax                 # 清除 %eax 寄存器
    addq    $8, %rsp                   # 恢复栈指针
    .cfi_def_cfa_offset 8
    ret
    .cfi_endproc

关键部分是这两行代码：

movl    $25, %esi                  # 直接将常量 25 作为结果存入 %esi
...
movl    $25, %esi                  # 直接将常量 25 存入 %esi

这表示编译器已经提前计算好了 square(5) 的值，并将结果（25）直接存入寄存器 %esi，用于后面的 printf 调用。这里没有看到对 square 函数的直接调用，而是结果 25 直接作为常量被使用了两次。

编译器通过 __attribute__((const)) 识别出 square 是纯函数，且传入的参数是常量，因此计算了一次后就将结果常量化，避免了多次调用 square 函数。

printf 调用：

call    printf                     # 调用 printf 输出 "Result1: 25"
call    printf                     # 调用 printf 输出 "Result2: 25"

在 main 中，你看到的只是 printf 函数的调用，用来输出结果，但 square 函数并没有被重复调用，而是直接输出预先计算好的常量 25。

从汇编代码可以看出，square(5) 只被计算了一次，编译器将其结果直接存储为常量 25，并多次使用这个常量，而不再重复调用 square 函数。这表明编译器确实进行了优化，利用了 __attribute__((const)) 提供的提示，实现了对重复调用的优化。

总结

__attribute__((const)) 是 GCC 提供的一个强大工具，能够帮助编译器更好地优化纯函数。通过将那些没有副作用且只依赖输入参数的函数标记为 __attribute__((const))，我们可以提升程序的执行效率，尤其是在函数被频繁调用的情况下。

在实际开发中，适当地使用 __attribute__((const)) 可以帮助编译器更有效地进行优化，同时也能帮助开发者明确哪些函数是纯函数，方便维护和调试。然而，必须注意的是，__attribute__((const)) 只适用于那些没有副作用、只依赖于输入参数的函数。对于依赖全局状态或有副作用的函数，应该使用 __attribute__((pure)) 或不加属性标记。

通过理解这些函数属性，开发者可以在日常编程中更好地利用编译器的优化功能，写出更高效的代码。