Skip to content

本页便签全部 ↗

本页还没有便签

划选正文里的一段文字,点弹出的「✎ 存为便签」,回头在这里一键跳回原处。

编译器做了什么:从 C++ 到汇编 ​

上一篇的结尾,咱们把 hello.i 留在了桌上:四万四千九百七十一行的纯文本,一条 # 指令都不剩了。今天轮到编译器接手了。在不少人的印象里,编译器干的活就是查错,语法写错了它喊一声,类型对不上了它再喊一声,然后把咱们的代码翻成汇编,活就算干完了。查错和翻译确实是它的主业。咱们在开卷那篇里还留过一句话:编译器的内部,从语法分析、优化到指令选择的每一层,都够咱们讲一整篇。今天咱们不钻这些层里的算法,咱们看的是另一头:您写的源码进去,出来的汇编在哪儿被它动了手。它动了手的地方有三件,咱们一件一件看。函数的名字,被它重新编码过了。您照模板写的一份代码,被它变成了每个类型一份。您要是开了优化,它连循环的写法都敢换掉。开卷第一篇里的那串 _ZSt4cout,就是头一件的手笔,当时咱们说好了,正式的展开留给今天。

咱们照例交代环境:笔者的实验都在 WSL2 里跑,手头的工具链是 GCC 16.2.1 配 binutils 2.47,这一篇里出现的每一段输出,都是真实跑出来的。您那边的版本要是不同,符号、指令之类的细节可能有出入,不过机制本身倒是一直没变。

咱们的实验品 ​

hello.i 呢?它的差事到交棒就算办完了:四万多行里,头文件占掉了绝大多数,咱们今天要找的符号命名规律,在它里面翻捡起来太费劲了。六行的 hello.cpp 也顶不下来,它手里的角色太少。笔者备了一份 mangle.cpp,咱们今天要看的角色,它全备上了:自由函数、命名空间、const 成员函数、函数模板。

C++
// mangle.cpp
int int_max(int a, int b);
namespace util {
    int scale(int v, int k);
    struct Tracker { int count; int get() const; };
}
template <typename T>
T bigger(T a, T b) { return a > b ? a : b; }
int use_all() {
    util::Tracker t{};
    return int_max(1, 2) + util::scale(3, 4) + t.get() + bigger(10, 20) + bigger(1.5, 2.5);
}

带着函数体的只有 use_all 和 bigger,int_max、scale 和 get 就都只是声明了。不给实现是有意的:咱们今天只编到 .o 为止、不去链接,所以缺了实现也不碍事。

名字修饰:链接器只认字符串 ​

改写的头一件,落在函数的名字上。C++ 允许咱们重载函数,允许咱们把函数装进命名空间,也允许咱们的成员函数跟普通函数同名。不过链接器认不得这些门道,它在解析符号的时候,手里抓着的就是一串串字符。util::scale 和别人家的 scale,怎么在链接器那里分得开?编译器的做法,是把命名空间、类名和参数类型统统编码进函数的符号名里,这个动作的名字就叫名字修饰(name mangling)。

咱们把 mangle.cpp 编成 .o,再请 nm 把它的符号表拉出来。nm 是 binutils 家的工具,干的活就是读目标文件里的符号。咱们用 grep 只挑两类符号看:T 打头的,是在本文件里定义了的,U 打头的,是引用了别处的:

text
$ g++ -c mangle.cpp && nm mangle.o | grep -E " (T|U) "
                 U _Z7int_maxii
0000000000000000 T _Z7use_allv
                 U _ZN4util5scaleEii
                 U _ZNK4util7Tracker3getEv
                 U __stack_chk_fail

左边的长串数字是地址,U 打头的行连地址都没有,因为它的实现压根不在本文件里。右边就是链接器将来要认的符号。您从头扫一遍就会发现,自己认识的名字一个都找不着了:好好的 int_max,成了 _Z7int_maxii。您别慌,咱们一个一个来解码。

咱们拿最短的 _Z7use_allv 开练,读法其实就三条:

  • 打头的 _Z,是所有被修饰符号的固定前缀。
  • 后面跟着的 7,意思是名字占了 7 个字符,往后的 use_all 就是它。
  • 名字念完了,剩下的 v 是参数清单,v 对应的就是 void,咱们这个函数不收参数。

所以整串读下来就是 use_all()。解码这件事不用咱们手算,干解码的专职工具就是 c++filt,开卷那篇里它已经亮过相了。咱们把四个 _Z 打头的符号一个一个喂给它,它解回来的是:

text
int_max(int, int)
use_all()
util::scale(int, int)
util::Tracker::get() const

剩下的三个符号,结构上要新认识的记号只有 N、E 和 K,类型码的字母咱们也一并认下:i 对应的就是 int,d 对应的就是 double,跟 v 走的是一个路数。_Z7int_maxii 您已经会读了:7 个字符的 int_max,后面的 ii 是两个 int 参数。咱们接着看 _ZN4util5scaleEii,把它里面的 N 和 E 理解成一对括号,专管嵌套的名字:4util 是 4 个字符的 util,5scale 是 5 个字符的 scale,合起来的读法就是 util::scale,末尾的 ii 还是两个 int。_ZNK4util7Tracker3getEv 又多了一个 K:它记的是 const,咱们这儿它标在成员函数的身上,别处类型里的 const 用的也是同一个记号,所以解码回来是 util::Tracker::get() const。这一套编码的规则出自 Itanium C++ ABI,那是 C++ 二进制接口的一套规范,GCC 在 Linux 上用的就是它。跨编译器、跨平台是不是同一套编码的问题,咱们留给 ABI 那篇,咱们做到会认、会解码就够。

您读到这儿,重载的事就顺了。咱们假设给 int_max 再添一个吃两个 double 的重载:参数的类型也被编进了符号,int 版的符号是 _Z7int_maxii,double 版就成了 _Z7int_maxdd。链接器拿到的,是两个互不相干的符号,重载就是这么活下来的。您想想,要是没有这一层的编码,两个重载的名字就都得是 int_max,链接器拿什么去区分?

名单里的 __stack_chk_fail,咱们谁都没写过它,它却也出现在了名单里。它是栈保护(stack protector)的产物:GCC 在咱们这套环境里默认开了栈保护,给函数的栈帧加上一道检查,查出了问题就喊它。它的两头各挂着下划线,身上没有 _Z 的前缀,因为它本来就是运行库提供的 C 接口,不走 C++ 的修饰。

extern "C":把修饰关掉 ​

咱们在有些场合,反而需要把修饰关掉,最常见的就是调 C 库。C 编译器在咱们这套 Linux 工具链上不做名字修饰,导出的符号就是函数的本名。咱们的 C++ 代码要用人家的库,符号就得长成人家认的样子,不然的话,名字就对不上了,链接的时候谁也找不到谁。咱们有一条很直接的办法:在声明前面挂上 extern "C"。

C++
// externc.cpp
extern "C" int int_max(int a, int b);
int use() { return int_max(1, 2); }
text
$ g++ -c externc.cpp && nm externc.o | grep -E " (T|U) "
0000000000000000 T _Z3usev
                 U int_max

咱们看的还是那个 int_max,只是声明前多了 extern "C",符号就干干净净了,剩下的就是裸名 int_max。咱们把两份输出摆在一起看:修饰开着的时候,它的符号是 _Z7int_maxii。修饰关掉的时候,它就只剩一个裸名 int_max 了。这套机制的正式名字叫语言连接(language linkage),您在标准里查 linkage,查到的就是它。

C 的头文件是怎么用上它的?上一篇里咱们用 -dM 打印预定义宏的时候,__cplusplus 这个宏咱们已经见过了,它是 C++ 编译器定义的,所以 C 那边看不见它。C 库的头文件里就常常见到一套搭配:拿 #ifdef __cplusplus 问一声来的是不是 C++,来了 C++ 的话,就把一整批的声明包进 extern "C" 块里。C++ 这边包含它的时候,声明就挂上了 C 连接。C 那边来包含它的时候,中间那一段就等于不存在了。您以后翻开 C 库的头文件,再见到这几行的时候,就知道它在干什么了。

关掉修饰的代价,是重载活不下去了。您想,两个 int_max 的重载要是都挂上 extern "C",两边的符号就都成了裸名 int_max,同一个名字装着两个不同的函数。所以同一个名字的一组重载,咱们不能把它们都交给 C 连接,您真去试一下,GCC 会当场拦下您,报的错就是 conflicting declaration。笔者写这段的时候又跑了一遍,蹦出来的是一条 error,外加一条 note 的提示,指回了前面的声明。

模板:用了哪个类型,才有哪份代码 ​

改写的第二处,轮到模板了。mangle.cpp 里咱们只调用了 bigger 两次:一次传的是整数,落成了 bigger<int>,另一次传的是小数,落成了 bigger<double>。那汇编里的 bigger 长什么样?是一份什么类型都能跑的代码,还是每个类型一份?咱们直接看。内联(inline)的意思,咱们一句话就能说清:函数调用不搞了,直接把函数体铺到调用的地方。bigger 的个头太小,一旦开了优化,多半就轮到它被内联了,单独的函数体就不一定还在了。所以笔者给命令加上了 -fno-inline,把常规的内联关掉,只有标了 always_inline 属性的函数例外,咱们好数一数 bigger 生出来的代码:

text
$ g++ -S -fno-inline mangle.cpp -o mangle_noInline.s && grep "^_Z6bigger" mangle_noInline.s
_Z6biggerIiET_S0_S0_:
_Z6biggerIdET_S0_S0_:

咱们把 grep 抓到的两个标号交给 c++filt,解出来的是:

text
int bigger<int>(int, int)
double bigger<double>(double, double)

答案就摆在这儿了:汇编里的 bigger 有两份,正好对上咱们的两次调用。咱们管照着模板生成的具体代码叫一份实例,管生成的过程叫实例化(instantiation)。模板自己是不会变成任何代码的,编译器是按需干活的:您用了一个类型组合,它就给咱们生成一份。咱们没人用过 bigger<char>,整份汇编里就找不着 bigger<char> 的影子。咱们还能从符号里多看出一件事:模板的实参也被编了进去,_Z6biggerIiET_S0_S0_ 里的 Ii,对应的就是 <int>。后面的 T_ 和 S0_ 是类型的简写,咱们不必会写,交给它解就行了。

这件事回答了半个老问题:模板的定义,为什么通常要放在头文件里?编译器要生成 bigger<int> 的代码,前提是它在这个翻译单元里看得见 bigger 的完整函数体,只有一句声明的时候,它是编不出来的。所以模板的定义得跟着头文件走,谁用到了,谁的翻译单元里就得有函数体。那么下一个问题也跟着来了:十个翻译单元都用了 bigger<int>,岂不是要出现十份一样的代码?链接的时候它们怎么不打架?这就是模板与 ODR 那篇要收拾的事了,咱们把问题存到那儿。ODR 的全称是 One Definition Rule,翻过来的名字叫单一定义规则,咱们到那篇再把它展开。

-O0 与 -O2:同一份源码的两种汇编 ​

改写的第三处,编译器的自由度就大了。咱们拿一个最普通的求和函数当样品:

C++
// opt_demo.cpp
int sum_to(int n) {
    int s = 0;
    for (int i = 1; i <= n; ++i) s += i;
    return s;
}

今天的实验一个 -O 都没写过,那用的就是默认档 -O0。它的汇编咱们节选几行:

asm
	movl	%edi, -20(%rbp)
	movl	$0, -8(%rbp)
	movl	$1, -4(%rbp)
	movl	-4(%rbp), %eax
	addl	%eax, -8(%rbp)
	addl	$1, -4(%rbp)

这几行咱们一行行过。%edi 是参数 n 进来时住的寄存器,头一条把它存进栈上的 -20(%rbp)。接着是 s 的 0 和 i 的 1,分别落进了 -8(%rbp) 和 -4(%rbp)。循环体的三条也一个样:咱们把 i 从栈上搬进 %eax,把 %eax 加到栈上的 s 里,加一加的,还是栈上的 i。您看,源码里的每个变量,在栈上都有自己的一个位置,每一步都老老实实地取出来、算、再放回去,一点多余的动作没有,也一点省事的动作没有。

咱们把档位换到 -O2,节选就成了另一副样子:

asm
	leal	1(%rdi), %ecx
	movl	$1, %eax
	movl	$2, %eax
	movl	$1, %edx
	leal	1(%rdx,%rax,2), %edx

栈不见了,这几行连 %rbp 的边都没沾到。运算全搬进了寄存器,常量 1 和 2 直接编进了指令。循环本身也被改写了,GCC 把它做了部分展开,一轮干的活跟原来不一样了。不过有一个方向,您多半会猜反:文件里的指令条数并没有变少。咱们这个 sum_to,-O0 编出来的函数体是 15 条指令,-O2 编出来的反而是 23 条。这个数咱们按助记符数:objdump 反汇编印出来的地址行有 24 个,其中一行是 10 字节对齐指令的续字节,够不上一条独立的指令,机械地照行数数就会多数出一条。优化省的是程序跑起来真正执行的指令:一轮多算几个数,栈上的装卸也全免了,实际执行的指令数反倒少了一大截。可源码的语义一点没动:咱们把 sum_to(100) 送进去,回来的还是 5050,您的程序观察不到任何差别。

咱们能选的还不止这两档:GCC 还有 -O1、-O3 和 -Os,-O3 的改写比 -O2 更激进,-Os 把二进制的体积排在最前头。您挑哪一档,编译器下手的力度就不一样。还要说明的是,咱们刚才看的这些改写,全部发生在编译器的内部,链接器拿到手的,已经是改写完的成品。LTO(链接时优化)会把优化的边界往链接那边挪,那是 LTO 与链接器那篇的事了。

汇编器 as:逐条翻译,不做决定 ​

咱们到了汇编这一程,接手的是开卷第一篇里见过面的 as。它在 g++ -v 输出里的那一行长这样:

text
 as -v --64 -o xxx.o xxx.s

它接到的活很单纯:把 .s 里的指令一条一条对照着翻成机器码字节,再按 ELF 的格式打包成 .o。标号换成了地址,符号也登进了符号表,翻译就完了。咱们不用指望它懂 C++、做优化,该做的决定,编译器在写 .s 的时候就全做完了,留给它的,只有机械的对翻。

不过有一类东西,编译器和 as 是定不下来的,咱们得单独看看。您回想 mangle.o 里那批 U 符号:int_max 的实现不在本文件里,那调用它的 call 指令,目标地址该填什么?编译的时候没人知道,翻到 as 手里的时候也一样。as 的做法,是把指令里的地址空着,再补一条重定位(relocation)的记录,记录的意思是:这里的地址还没定,咱们等链接器来填。所以咱们手里的 .o 不止有代码和符号,还带着一批待定的地址。

CMake 视角:优化级别归谁管 ​

您在日常构建里多半不直接写 -O,这件事归 CMake 的 CMAKE_BUILD_TYPE 管。咱们按 GNU 这套编译器把对应关系列一遍:Debug 给的是 -g,咱们一点优化都拿不到。Release 换成的就是 -O3,还带上了 -DNDEBUG,assert 一类的断言就被关掉了。RelWithDebInfo 给的是 -O2 加 -g,优化和调试的信息两边都齐全,咱们日常发版用得最多的就是它。不过 -DNDEBUG 它也照样带着,这一档的 assert 同样是关着的。MinSizeRel 用的是 -Os 加 -DNDEBUG。

您要是压根不设置 CMAKE_BUILD_TYPE,它的值就是空的,CMake 一个 -O 都不会替您加,编译器就回到了默认的 -O0。咱们很容易吃这个亏。程序构建出来了,跑得莫名其妙地慢,咱们一路追到底,最后查到的原因就是:构建类型压根没设。

要挂 -O 之外的编译选项,咱们别去动全局,思路还是上一篇里说过的那个:选项是跟着目标走的,由用它的目标自己声明。CMake 给的写法是 target_compile_options:

cmake
target_compile_options(app PRIVATE -Wall -Wextra)

块里的 -Wall 和 -Wextra,是越开越严的两组警告开关,挂上了它们,编译器就能多替咱们查一层毛病。开头的 PRIVATE,咱们在上一篇的 target_include_directories 里也见过,它把选项锁在了 app 自己身上,别的目标沾不到这些选项的光。

交给链接器的 .o ​

咱们今天见过的东西,mangle.o 里都攒齐了,唯独有一批地址还空着,是等着链接器来填的。

它的内里到底怎么排布,重定位的记录长什么样,.text 和 .data 装的又是什么,咱们带上 objdump,到下一篇里把这些疑问一个个了结。链接要用到的材料,到那儿咱们就都见过了。

v0.13.0-17-gf6158c6 · f6158c6 · 2026-11-20