06 · 写:内联汇编,把机器的那几行接进 C++
讲函数门面的那一篇收尾的时候留了一句:那些汇编行眼下都得喂给汇编器过一遍,想让它直接住进 C++ 里,行话叫内联汇编,下一篇就动手。咱们这一篇把这句话兑现。
要还的东西不复杂。咱们写下的汇编字符串会落进编译器吐出的汇编输出:基本 asm 的指令原样照搬,扩展 asm 里的 %0、%% 还会被替换成具体的寄存器。GCC 只管它周围的那些代码。两边住在同一份函数体里,咱们得让它知道围栏里头动了什么。
基本 asm:原样塞进去的那几行
咱们抄起编辑器写个最小的:两个没有操作数、没有返回值的 asm 语句,存成 e1a_basic.cpp,让 g++ -O2 -S 吐一份汇编出来。
int main() {
asm("nop");
asm("nop\n\tnop\n\tnop");
return 0;
}这是基本 asm,括号里只有一串指令,没有别的。咱们把产物搁进 build/ 这个目录,它得建出来才能往里写。.s 也翻出来,找那对书签。屏里的行号和 N-、N: 前缀都是 grep -n 添上的:- 是上下文行,: 是命中的那一行。往后这类从 .s 里截出来的屏,咱们只截跟当前问题有关的那几行,函数收尾的 .cfi_endproc、.size 之类不一定贴全。
mkdir -p build
g++ -O2 -S e1a_basic.cpp -o build/e1a_basic_O2.s
grep -n -B1 -A9 '#APP' build/e1a_basic_O2.s9- .cfi_startproc
10:#APP
11-# 2 "e1a_basic.cpp" 1
12- nop
13-# 0 "" 2
14-# 3 "e1a_basic.cpp" 1
15- nop
16- nop
17- nop
18-# 0 "" 2
19-#NO_APP#APP 和 #NO_APP 是 GCC 划的围栏,围栏之间是咱们亲笔写的指令,编译器一个字没动。咱们还会发现一件小事:两条独立的 asm 语句被并进了同一对围栏。围栏内那四行,# 2 "e1a_basic.cpp" 1、# 0 "" 2 这样成对出现的,是给汇编器和调试信息看的行号标记,咱们读的时候可以跳过。想数自己嵌了几对围栏,写 grep -c '#APP',这一段会回一个 1。要是写 grep -c 'APP',数出来的就是 APP 这个串出现了几次,一对围栏含 #APP 和 #NO_APP 两处,同样的输入会回一个 2。两把尺子各量各的,咱们后面说数就认 #APP 这把。老版本 GCC 的书签拼成 # APP(中间带空格),GCC 16 不带,咱们手里的 pattern 最好两种拼法都认。
基本 asm 省事,代价也摆在那儿。手册说 GCC 对非空的基本 asm 有个保守假设:它不动任何通用寄存器,可是它可能读写任何全局可见的变量。咱们在机器上能验证这一层:换一个全局变量 g 写进 e1b_basic_global.cpp,让围栏去动它,两个优化档笔者都跑过一遍,围栏之后那次读 g 都落在了真加载上。屏只贴 -O2 那一档(-O0 档同样,只是前后多几行):
26-#APP
27-# 4 "e1b_basic_global.cpp" 1
28- movl $99, g(%rip)
29-# 0 "" 2
30-#NO_APP
31- movl g(%rip), %eax
32- ret这段保守是白送的,不过别的门都关着:模板里没有操作数通道,寄存器假设交给编译器,连 % 的写法都跟外面不一样。那句假设还会随版本变,老一点的 GCC 换一套行为。前面跑的那两档在本机都没复现出毛病,所以咱们只把它当版本敏感性记着:咱们在这里验不出问题,不代表别人机器上也验不出来。咱们要的是能跟编译器谈条件的手艺,所以往下走。
扩展 asm:模板四段,编号从 0 起
想跟编译器谈条件,就得在模板之外再挂几段。完整的形状长这样:asm(模板 : 输出 : 输入 : clobber),四段用冒号隔开,每一段都能空着。空段后面连着还有内容的时候,冒号得照样写出来。输入和 clobber 都空、模板后面再没有别的段,后面那些冒号就可以省掉。咱们把一个最小的例子摆出来,把 42 装进一个变量,存成 e2a_min.cpp:
int Load42() {
int x = 0;
asm("movl $42, %0" : "=r"(x));
return x;
}模板里那个 %0 是笔者给输出占的位置。"=r"(x) 分成两部分看:= 说的是“这段只负责写”,r 说的是“请给我一个通用寄存器”。咱们看看它在 -O2 下变成什么:
6:_Z6Load42v:
7-.LFB0:
8- .cfi_startproc
9-#APP
10-# 3 "e2a_min.cpp" 1
11- movl $42, %eax
12-# 0 "" 2
13-#NO_APP
14- ret围栏里 %0 换成了 %eax。这里最容易想岔的一步来了:咱们别把 %eax 读成承诺,分配器挑中它只是为了眼下这一档顺手。换一条命令、换一个函数、换一次内联,挑出来的可能是别的寄存器。咱们摆一个两操作数的现场,模板里同时用 %0 和 %1,存成 e2b_ext.cpp:
int AddOne(int in) {
int out;
asm("leal 1(%1), %0" : "=r"(out) : "r"(in));
return out;
}
int main() {
return AddOne(41);
}咱们看 -O0 那一档,独立函数里 %1 落在 %eax:
5:_Z6AddOnei:
6-.LFB0:
7- .cfi_startproc
…
13- movl %edi, -20(%rbp)
14- movl -20(%rbp), %eax
15-#APP
16-# 3 "e2b_ext.cpp" 1
17- leal 1(%eax), %eax
18-# 0 "" 2
19-#NO_APP
20- movl %eax, -4(%rbp)
21- movl -4(%rbp), %eax咱们再看 -O2:参数原样留在 %edi 里,内联进 main 的一份拷贝又回到了 %eax:
6:_Z6AddOnei:
7-.LFB0:
8- .cfi_startproc
9-#APP
10-# 3 "e2b_ext.cpp" 1
11- leal 1(%edi), %eax
12-# 0 "" 2
13-#NO_APP
14- ret咱们再把内联进 main 的拷贝也翻出来:
g++ -O2 -S e2b_ext.cpp -o build/e2b_ext_O2.s
grep -n -A8 'main:' build/e2b_ext_O2.s22:main:
23-.LFB1:
24- .cfi_startproc
25- movl $41, %eax
26-#APP
27-# 3 "e2b_ext.cpp" 1
28- leal 1(%eax), %eax
29-# 0 "" 2
30-#NO_APP咱们对着这两屏数一遍:同一个文件、同一条模板,%1 在独立函数里落一处,内联进 main 的拷贝里又落一处,一处是 %edi,一处是 %eax。编号规则本身倒是稳的,操作数从 0 起数,输出排在前、输入排在后,%0 是输出 out、%1 是输入 in,写模板的人只管位置。
模板里还想写字面的寄存器名,笔画就得反过来,写成 %%eax 这样的双百分号。咱们抄一份同时用到操作数编号和字面寄存器名的源码,存成 e2c_pct.cpp:
int Pct(int in) {
int out;
asm("movl %1, %0\n\t"
"addl $1, %0\n\t"
"movl %%eax, %%ebx"
: "=r"(out)
: "r"(in)
: "ebx");
return out;
}咱们把整段交给汇编器,%% 会变回单个 %,围栏后紧跟的是函数尾声:
6:_Z3Pcti:
7-.LFB0:
8- .cfi_startproc
9- pushq %rbx
…
12-#APP
13-# 3 "e2c_pct.cpp" 1
14- movl %edi, %eax
15- addl $1, %eax
16- movl %eax, %ebx
17-# 0 "" 2
18-#NO_APP
19- popq %rbx咱们把 e2c_pct.cpp 里的 %%eax 写成 %eax,另存成 e2c_bad_pct.cpp 试试,% 后面跟着的东西会被当成操作数编号来读:
e2c_bad_pct.cpp: In function 'int BadPct(int)':
e2c_bad_pct.cpp:3:5: error: invalid 'asm': operand number missing after %-letter
3 | asm("movl %1, %0\n\t"
| ^~~
e2c_bad_pct.cpp:3:5: error: invalid 'asm': operand number missing after %-letter
exit_status=1编译器当场把这次尝试拦了下来,咱们收到的诊断是“% 后面缺一个操作数编号”。这层错在编译前端,连汇编器都到不了。末尾那行 exit_status=1,是咱们在命令后头接了一句 echo "exit_status=$?" 报出来的,不是编译器打的。
约束:值住寄存器,还是住内存
r 说的是“给我一个通用寄存器”,它有个走另一条路的兄弟 m:操作数不进寄存器,直接落在内存上。同一个语义、同一行模板,咱们只把约束字母从 +r 换成 +m,两份源码的差别就落在约束串上。一份写一个文件,存成 e3_r.cpp:
int BumpR(int x) {
asm("incl %0" : "+r"(x));
return x;
}另一份咱们只换约束字母,存成 e3_m.cpp:
int BumpM(int x) {
asm("incl %0" : "+m"(x));
return x;
}咱们把两份源码各自编成目标文件,再把反汇编倒出来(产物照旧搁进 build/):
g++ -O2 -c e3_r.cpp -o build/e3_r_O2.o && objdump -d build/e3_r_O2.o
g++ -O2 -c e3_m.cpp -o build/e3_m_O2.o && objdump -d build/e3_m_O2.o0000000000000000 <_Z5BumpRi>:
0: 89 f8 mov %edi,%eax
2: ff c0 inc %eax
4: c3 ret0000000000000000 <_Z5BumpMi>:
0: 89 7c 24 fc mov %edi,-0x4(%rsp)
4: ff 44 24 fc incl -0x4(%rsp)
8: 8b 44 24 fc mov -0x4(%rsp),%eax
c: c3 ret+r 版全程活在寄存器里,inc %eax 两个字节 ff c0 就完事。+m 版把 %edi 在 -4(%rsp) 安了家,incl -0x4(%rsp) 是内存形态,编码 ff 44 24 fc 四字节,加完再取回 %eax。哪个好,看指令有没有寄存器形态,incl 两种都行,那当然寄存器快。往后咱们会碰上只有内存形态的指令,像装描述表的 lgdt、invlpg 这类,它们的操作数天生只能落在内存,那时候 m 就是唯一的路。这里还漏出一句行话:-4(%rsp) 落在红区里(讲栈那一篇交代过的那 128 字节),只有不再往下 call 谁的叶子函数才敢白用。这层福利只归用户态,进了内核就被关掉。
漏掉 "memory" 的那个 bug
四段里的最后一段 clobber,咱们用一个真错来认识它。下面这段源码存成 e4_bug.cpp,它的意图很直白:把 g 的当前值收进 first,让 asm 往 g 里存一个 99,回手再把 g 收进 second 打印出来。输出和输入两段都空着,所以模板后面只跟了两个冒号,第四段还没有影子。咱们照它跑,它会给出一份错答案:
#include <cstdio>
int g = 1;
int main() {
int first = g;
asm("movl $99, g(%%rip)" ::);
int second = g;
std::printf("first=%d second=%d\n", first, second);
return 0;
}笔者在 asm 里明明白白把 99 存进 g,回手再读一次,-O2 下跑出来是这样:
g++ -O2 e4_bug.cpp -o build/e4_bug_O2 && build/e4_bug_O2; echo "exit_status=$?"first=1 second=1
exit_status=0没有崩溃,没有警告,退出码干干净净的 0,second 就是 1。您别急着看修法,咱们按老办法翻 .s 找机制,汇编里那几行关键代码在这儿:
10:main:
11-.LFB15:
12- .cfi_startproc
13- subq $8, %rsp
14- .cfi_def_cfa_offset 16
15- movl g(%rip), %esi
16-#APP
17-# 7 "e4_bug.cpp" 1
18- movl $99, g(%rip)
19-# 0 "" 2
20-#NO_APP
21- leaq .LC0(%rip), %rdi
22- movl %esi, %edx
23- xorl %eax, %eax
24- call printf@PLT真相在这一行里:第一次读 g 落进了 %esi,围栏之后的第二次读压根没有发生,GCC 直接把 %esi 顶了上去。它还给了自己一个很像样的理由:咱们只写了 ::,clobber 段是空的,那 GCC 凭什么认为围栏动过内存。它敢拿围栏之前知道的旧值顶上,这次是咱们的申报漏了它。
咱们换一换优化档,这事还有花样:
-O0 → first=1 second=99
-O1 → first=1 second=1
-O2 → first=1 second=1
-O3 → first=1 second=1-O0 老老实实每次读都摸内存,-O1 起就翻了车。“没优化没事,一优化出事”这句话,咱们往后夜里还会遇上它。
咱们换个写法还能更狠。下面这段存成 e4_bug_b.cpp,还是让 asm 去写局部变量,只是改成经输入指针进去写:输出段空着,输入段挂的是变量地址,末尾照旧空着:
#include <cstdio>
int main() {
int x = 1;
int first = x;
asm("movl $99, (%0)" :: "r"(&x));
int second = x;
std::printf("first=%d second=%d\n", first, second);
return 0;
}它在 -O2 下也打印 first=1 second=1。咱们翻 .s 看,围栏之后第二次读连加载都不见了:
g++ -O2 -S e4_bug_b.cpp -o build/e4_bug_b_O2.s && grep -n -A18 'main:' build/e4_bug_b_O2.s21-# 6 "e4_bug_b.cpp" 1
22- movl $99, (%rax)
23-# 0 "" 2
24-#NO_APP
25- xorl %eax, %eax
26- movl $1, %edx
27- movl $1, %esi
28- leaq .LC0(%rip), %rdi咱们看到第二次读的结果被 GCC 直接折成了立即数,连内存都不碰。机制是同一个:它拿围栏之前知道的值顶上,至于是挪用寄存器还是折算成常量,随版本和现场变。
修法只有一行,咱们把空着的 clobber 段补上 "memory"。做法是把 e4_bug.cpp 原样另存为 e4_fixed.cpp,只把那一行的 :: 补成 ::: "memory":
asm("movl $99, g(%%rip)" ::: "memory");模板里的指令一个字没动,咱们拿同一个 -O2 再跑一遍,这回的输出是:
g++ -O2 e4_fixed.cpp -o build/e4_fixed_O2 && build/e4_fixed_O2; echo "exit_status=$?"first=1 second=99
exit_status=0这一屏里两版只差一行,咱们并排看:
21- leaq .LC0(%rip), %rdi
22- movl %esi, %edx
23- xorl %eax, %eax
24- call printf@PLT21- movl g(%rip), %edx
22- leaq .LC0(%rip), %rdi
23- xorl %eax, %eax
24- call printf@PLT咱们把两版摆在一起看:错版围栏后是 movl %esi, %edx,复用围栏之前那次加载的结果。对版围栏后是 movl g(%rip), %edx,老老实实重读了一次。一行的申报,换回一次真加载。手册把这层意思写得很重:"memory" 告诉编译器,这块 asm 对操作数之外的内存也动过手,编译器不再假设 asm 之前读过的内存值仍然有效,需要的时候它会重新加载。手册说它“为编译器构成了一道读写的内存屏障”。
手册紧接着划了一道界:这道屏障管的是编译器,处理器自己往 asm 之后做推测读,它拦不住。处理器那边的乱序另有 fence 一类的东西管着,咱们在这儿不展开。
volatile:让它照写的样子留下
您大概听过一句“加个 volatile 就稳了”。咱们现场验一验它到底保什么,来看一段有寄存器输出、可那个输出之后没人再用的 asm,存成 e5_drop2.cpp,编成 -O2 的汇编:
#include <cstdio>
int main() {
int x = 0;
asm("movl $42, %0" : "=r"(x));
std::printf("done\n");
return 0;
}g++ -O2 -S e5_drop2.cpp -o build/e5_drop2_O2.s14- .cfi_def_cfa_offset 16
15- leaq .LC0(%rip), %rdi
16- call puts@PLT
17- xorl %eax, %eax
18- addq $8, %rsp
19- .cfi_def_cfa_offset 8
20- ret
21- .cfi_endproc
22-.LFE15:围栏一对都没有,GCC 把整段 asm 扫了出去,程序照跑,照打印 done,删没删从外面看不出来。咱们把 volatile 给同一段 asm 加上,别的都不动,另存成 e5_keep2.cpp,编成另一份 -O2 的汇编:
#include <cstdio>
int main() {
int x = 0;
asm volatile("movl $42, %0" : "=r"(x));
std::printf("done\n");
return 0;
}g++ -O2 -S e5_keep2.cpp -o build/e5_keep2_O2.s围栏就回来了,还是用 #APP 那把尺子,这次咱们数得到:
14- .cfi_def_cfa_offset 16
15-#APP
16-# 5 "e5_keep2.cpp" 1
17- movl $42, %eax
18-# 0 "" 2
19-#NO_APP
20- leaq .LC0(%rip), %rdi
21- call puts@PLT尺子本身也就是咱们手里这两行 grep -c:
$ grep -c 'APP' build/e5_drop2_O2.s # → 0
$ grep -c 'APP' build/e5_keep2_O2.s # → 2两版跑起来输出一模一样,差别全在 .s 里。往后咱们写端口 IO 这类全靠副作用的指令,全指着它给咱们保命。
它在循环里的表现更直观。咱们把同一段 asm 放进循环体,存成 e5_loop.cpp:
#include <cstdio>
int main() {
int x = 0;
for (int i = 0; i < 3; ++i) {
asm("movl $42, %0" : "=r"(x));
std::printf("done\n");
}
return 0;
}同一段再加上 volatile,咱们另存成 e5_loop_v.cpp:
#include <cstdio>
int main() {
int x = 0;
for (int i = 0; i < 3; ++i) {
asm volatile("movl $42, %0" : "=r"(x));
std::printf("done\n");
}
return 0;
}咱们各编一份 -O2 的汇编:
g++ -O2 -S e5_loop.cpp -o build/e5_loop_O2.s
g++ -O2 -S e5_loop_v.cpp -o build/e5_loop_v_O2.s不加 volatile,-O2 把整段从循环体里删了,咱们在整个 .s 里一对围栏都数不着。同一段加上 volatile,围栏就留在循环标签底下。两条尺子的读数:
$ grep -c 'APP' build/e5_loop_O2.s # → 0
$ grep -c 'APP' build/e5_loop_v_O2.s # → 2还有两处边界得记清。输出是 "=m" 的那段,咱们存成 e5_drop2_m.cpp:
#include <cstdio>
int main() {
int x = 0;
asm("movl $42, %0" : "=m"(x));
std::printf("done\n");
return 0;
}咱们看到的是它即使没人消费也没删,往内存里写被它当成副作用保守留了下来。没有输出操作数的基本 asm 存成 e5_basic.cpp:
#include <cstdio>
int main() {
asm("nop");
std::printf("done\n");
return 0;
}它隐含 volatile,咱们写 asm("nop") 不写关键字也不会被删。两份照旧各编一份 -O2 的汇编:
g++ -O2 -S e5_drop2_m.cpp -o build/e5_drop2_m_O2.s
g++ -O2 -S e5_basic.cpp -o build/e5_basic_O2.s咱们就用这两把尺子照样读得出:
$ grep -c 'APP' build/e5_drop2_m_O2.s # → 2:输出是 "=m"、同样没人消费,本机不删
$ grep -c 'APP' build/e5_basic_O2.s # → 2:基本 asm 无 volatile 也不删那么加上 volatile 能不能救前面那个内存 bug?咱们把上面那段错源码的 asm 改成 volatile,另存成 e5_vol_mem.cpp,clobber 段照旧空着:
#include <cstdio>
int g = 1;
int main() {
int first = g;
asm volatile("movl $99, g(%%rip)" ::);
int second = g;
std::printf("first=%d second=%d\n", first, second);
return 0;
}咱们拿 -O2 跑出来是这样(末尾那行 exit_status=0 同样是 echo "exit_status=$?" 报的):
g++ -O2 e5_vol_mem.cpp -o build/e5_vol_mem_O2 && build/e5_vol_mem_O2; echo "exit_status=$?"first=1 second=1
exit_status=0咱们跑出来的还是 first=1 second=1。翻 .s 看,volatile 只把围栏保住了,围栏之后依旧是那一行:
22- movl %esi, %edxvolatile 留住的只有这段代码本身,周围的内存它管不着。手册还说:volatile asm 一样可能被编译器相对别的代码挪动,连跨跳转指令挪动都不排除。谁在管周围的内存,咱们前一段刚交代过,是 "memory"。
clobber 里还能登记什么
clobber 段不止 "memory" 一个名字。咱们在 asm 里碰过的寄存器,得按名字如实报给编译器。名字的写法有讲究,咱们把三种拼法各写一遍,放进同一个文件存成 e6_clobname.cpp:
int ClobEb() {
int r;
asm("movl $42, %0" : "=r"(r) : : "ebx");
return r;
}
int BadName() {
int r;
asm("movl $43, %0" : "=r"(r) : : "%%ebx");
return r;
}
int BadRsp() {
int r;
asm("movl $44, %0" : "=r"(r) : : "rsp");
return r;
}咱们把它递给编译器,"%%ebx" 吃了报错,"rsp" 吃了警告和一条附注:
g++ -O2 -S e6_clobname.cpp -o build/e6_clobname_O2.s; echo "exit_status=$?"e6_clobname.cpp: In function 'int BadName()':
e6_clobname.cpp:9:5: error: unknown register name '%%ebx' in 'asm'
9 | asm("movl $43, %0" : "=r"(r) : : "%%ebx");
| ^~~
e6_clobname.cpp: In function 'int BadRsp()':
e6_clobname.cpp:15:5: warning: listing the stack pointer register 'rsp' in a clobber list is deprecated [-Wdeprecated]
15 | asm("movl $44, %0" : "=r"(r) : : "rsp");
| ^~~
e6_clobname.cpp:15:5: note: the value of the stack pointer after an 'asm' statement must be the same as it was before the statement
exit_status=1末尾那行 exit_status=1 也是咱们那句 echo "exit_status=$?" 报的,不是编译器打的。
规范写法是不带 % 的名字,写 "ebx"。咱们把同一个写法换上一对单百分号,跟 ClobEb() 一起存进 e6b.cpp:
int ClobEbPct() {
int r;
asm("movl $43, %0" : "=r"(r) : : "%ebx");
return r;
}它和上面那个 ClobEb() 是同一个文件 e6b.cpp 里的两个函数,材料里本来就是这么放的。咱们看到 "ebx" 和 "%ebx" 两个在本机 GCC 16 上都编译得过,只有 "%%ebx" 报了 unknown register name。“带 % 必报错”这话经不起检验,报错的是双百分号。
咱们报上名字之后,GCC 会绕开它给操作数挑寄存器,该保存的时候它自己包一份保存和还原。下面这一屏取自 e6b.cpp 的 _Z6ClobEbv(文件头略去,标签到 #APP 之间是 GCC 自己垫的 .cfi_* 与一条 pushq %rbx):
.cfi_startproc
pushq %rbx
.cfi_def_cfa_offset 16
.cfi_offset 3, -16
#APP
# 3 "e6b.cpp" 1
movl $42, %eax
# 0 "" 2
#NO_APP
popq %rbx
.cfi_def_cfa_offset 8
ret%rbx 是约定里被调方必须原样还原的那一拨,咱们报了名字,GCC 就自己押上了这对 push 和 pop。调用约定把寄存器分成两拨:%rbx、%rbp、%r12 到 %r15 是被调方必须原样还原的,%rax、%rcx、%rdx、%rsi、%rdi、%r8 到 %r11 是临时寄存器,谁用谁负责。%rsp 这边只在上面留了个废弃警告,真正要守的规范是进出等值,asm 前后栈指针必须一样。
能用 C 写,就别劳驾汇编
手艺到手了,泼冷水的忠告也该到位。GCC 手册自己承认它不解析咱们模板里的指令,写错了没有编译期的体检,验收的路只剩看字节一条。多条独立的 asm 也不保证编译后还紧挨着,必须连续的指令请咱们写进同一个字符串。Linux 内核的代码风格文档大意说得更直白:C 能干的活就别劳驾内联汇编,常见的一小段可以包成一个 C 小函数,大块的汇编进单独的 .S 文件。咱们这一篇学的约束、clobber、volatile 申报纪律,本身说的就是这件事,每一样都在替 GCC 补它看不见的信息。内联汇编的正经用场,是 C++ 实在表达不了的那几行:端口 IO、停机、开关中断,咱们数得过来。
没铺开的,咱们照例摆在桌面上:浮点和 SIMD 的约束字母、asm goto 跳 C 标签、%= 自制不重号的局部标号、%P 这类操作数修饰符、双方言花括号,手册里都有,咱们用到再取。% 后面跟数字或以 [ 开头的才是操作数引用,这一点两套 asm 各有一套写法。clobber 里还留了个 "redzone",您在 asm 里用 call、push 的时候跟它有关系,这里只留个名字,不给行为断言。
再往前的路,是机器刚上电、内存还没铺好的地方,那里连栈都得咱们亲手摆,内联汇编的用场会比今天多得多。