456 lines
22 KiB
Markdown
456 lines
22 KiB
Markdown
|
||
|
||
因收到Google相关通知，网站将会择期关闭。相关通知内容
|
||
|
||
|
||
15 C与汇编：揭秘C语言编译器的“搬砖”日常
|
||
你好，我是LMOS。
|
||
|
||
通过上一节课的学习，我们已经清楚了C语言可以把程序抽象成一个函数，这样的函数又抽象成表达式和流程控制，表达式又能进一步抽象成各种类型的变量和各种运算符。并且我们还搞懂了变量就是数据，运算符就是操作，而变量的运算结合起来就能对数据施加操作。这样拆分下来，是不是C语言就没那么神秘了？
|
||
|
||
今天，让我们就来继续揭秘C语言编译器的日常工作，搞清楚各种类型变量、各种运算符、流程控制以及由它们组成的函数，是如何对应到机器指令的（代码从这里下载）。
|
||
|
||
此外，我还会带你了解函数间的调用规范，这能让我们在以后写代码时，清楚自己的每行代码都会被编译器转化为什么样的机器指令。
|
||
|
||
C变量
|
||
|
||
现在，我们从最基本的C语言的变量开始说起。
|
||
|
||
C语言是如何把各种类型的变量转换成对应的汇编语言呢？高级语言更容易被工程师理解，而汇编语言这样的低级语言，则更容易被机器解读。这是因为汇编语言里的大部分内容都跟机器语言一一对应，你可以这样理解，汇编语言就是把机器语言符号化。
|
||
|
||
我举个例子让你加深理解，机器对应的加法指令是一段很长的二进制数据，在汇编语言中，这个指令就对应着“add”这个指令。无论是机器指令还是寄存器，经过汇编语言“翻译”出来都是符号。
|
||
|
||
汇编器会将汇编源代码生成二进制程序文件。在程序二进制文件里有很多段。其中text段和data段在文件里占用位置空间，text段存放了程序指令的二进制数据，data段放着各种已经初始化的数据。二进制文件里还有个更特殊的bss段，它不占用文件的位置空间，而是在文件头里记录bss段的大小。
|
||
|
||
一旦text、data段加载到内存中运行，就会占用内存空间，自然也就对应到实际的内存。至于bss段，操作台会根据文件头里记录的大小给它分配内存空间，并初始为0。
|
||
|
||
有了这些基础，我们就可以写代码来进行验证了，如下所示：
|
||
|
||
//定义整型变量
|
||
int i = 5;
|
||
//定义字符变量
|
||
char chars = 'a';
|
||
//定义结构体
|
||
struct data
|
||
{
|
||
int a;
|
||
char c;
|
||
};
|
||
//定义结构体变量并初始化
|
||
struct data d = {10, 'b'};
|
||
|
||
|
||
我们在代码中定义了三个不同类型的变量。在GCC编译器后面加上-save-temps 选项，就能留下GCC编译器各个步骤生成的临时文件，方便我们查看GCC逐步处理的结果。
|
||
|
||
我已经为你写好了makefile文件，你用VSCode打开项目代码，按下F5就会生成相应的临时文件xxxx.i、xxxx.s、xxxx.bin。
|
||
|
||
其中，xxxx.i是gcc编译器生成的预处理文件，xxxx.s是gcc编译器生成的汇编文件，xxxx.o是gcc编译器生成的可链接的目标文件，xxxx.bin是去除了ELF文件格式数据的纯二进制文件，这是我用objcopy工具生成的，这个文件可以方便我们后续观察。
|
||
|
||
下面我们打开项目代码中的variable.s文件，如下所示：
|
||
|
||
.globl i #导出全局标号i
|
||
.section .sdata,"aw" #创建sdata段，属性动态分配可读写
|
||
.size i, 4 #占用4字节大小
|
||
i: #标号i
|
||
.word 5 #定义一个字，初始化为5
|
||
|
||
.globl chars #导出全局标号chars
|
||
.size chars, 1 #占用1字节大小
|
||
chars: #标号chars
|
||
.byte 97 #定义一个字节，初始化为97，正是‘a’字符的ascii码
|
||
|
||
.globl d #导出全局标号d
|
||
.size d, 8 #占用8字节大小
|
||
d: #标号d
|
||
.word 10 #定义一个字，初始化为10
|
||
.byte 98 #定义一个字节，初始化为98，正是‘b’字符的ascii码
|
||
.zero 3 #填充3个字节，数据为0
|
||
|
||
|
||
上面的汇编代码和注释已经写得很清楚了，C语言的变量名变成了汇编语言中的标号，根据每个变量的大小，用多个汇编代码中定义数据的操作符，比如.byte、.word，进行定义初始化。
|
||
|
||
C语言结构体中的字段则要用多个.byte、.word操作符的组合实现变量定义，汇编器会根据.byte、.word来分配变量的内存空间，标号就是对应的地址。这个变量的内存空间，当程序处于非运行状态时就反映在程序文件中；一旦程序加载到内存中运行，其中的变量就会加载到内存里，对应在相应的内存地址上。
|
||
|
||
上述代码仍然是可读的文本代码，下面我们看看汇编器生成的二进制文件variable.bin，如下所示。
|
||
|
||
|
||
|
||
从这张文件截图里，我们能清楚地看到，二进制文件variable.bin一共有16字节，第5到第7个字节和第13到第15个字节为填充字节，这是为了让地址可以按32位对齐。我们可以看到i变量占用4个字节空间，chars变量占用1个字节空间，d结构体变量占用8个字节，里面有两个成员变量a和c。
|
||
|
||
截图中反映的情况，相当于从0开始分配地址空间，当然后面链接器会重新分配地址空间的，这里i变量地址为0，chars变量地址为4，d变量地址为8。
|
||
|
||
现在我们总结一下，C语言转化成汇编语言时发生了什么样的变化：C语言的变量名成了汇编语言的标号，C语言的变量对应的空间变成了汇编语言.byte、.word之类的定义数据操作符。最终，汇编器会根据.byte、.word分配内存空间。这些对应关系，我们通过对二进制文件的分析已经再清楚不过了。
|
||
|
||
C语言表达式
|
||
|
||
下面，我们来看看C语言表达式，了解C语言是怎么把各种表达式转换成对应的汇编语言的。
|
||
|
||
我先说明一下，这里本来应该介绍运算符的，但是C语言的运算符不能独立存在，必须要与变量结合起来形成表达式，所以这里我把运算符归纳到表达式里一起给你讲解，你学起来也更清晰。
|
||
|
||
我们先来写一个表达式，如下所示：
|
||
|
||
int add()
|
||
{
|
||
//定义三个局部整形变量
|
||
int a, b, c;
|
||
//赋值表达式
|
||
a = 125;
|
||
b = 100;
|
||
//运算表达式
|
||
c = a + b;
|
||
//返回表达式
|
||
return c;
|
||
}
|
||
|
||
|
||
代码注释我为你标注了表达式的类型，至于代码的含义任何一个C语言初学者都能明白，就不过多讲解了。
|
||
|
||
接下来，我们直接看GCC编译器生成的汇编代码。GCC在编译代码时我加了“-O0”，这表示让GCC不做代码优化，如下所示：
|
||
|
||
add:
|
||
addi sp,sp,-32
|
||
sw s0,28(sp)
|
||
addi s0,sp,32
|
||
li a5,125
|
||
sw a5,-20(s0)
|
||
li a5,100
|
||
sw a5,-24(s0)
|
||
lw a4,-20(s0)
|
||
lw a5,-24(s0)
|
||
add a5,a4,a5
|
||
sw a5,-28(s0)
|
||
lw a5,-28(s0)
|
||
mv a0,a5
|
||
lw s0,28(sp)
|
||
addi sp,sp,32
|
||
jr ra
|
||
|
||
|
||
上述的汇编代码你看不懂也没关系，且听我分段给你拆解。它们分别是：在栈中分配变量的内存空间、给变量赋值、进行运算、处理返回值、回收栈中分配的空间、返回。
|
||
|
||
我们首先看看C语言中的“int a,b,c;”，这是三个局部变量。在C语言中局部变量是放在栈中的，栈在后面的课程里我再介绍。这里就是给a、b、c这三个变量在栈中分配变量的内存空间，对应的代码如下所示：
|
||
|
||
# int a,b,c;
|
||
addi sp,sp,-32 #把栈指针寄存器减去32，相当于在栈中分配了32字节的空间
|
||
sw s0,28(sp) #首先把s0寄存器存放在（sp+28）的内存空间中
|
||
addi s0,sp,32 #然后把s0寄存器设为原来sp寄存器的值
|
||
|
||
|
||
上述代码通过减去sp寄存器的值，在栈中分配了内存空间。因为栈是由高地址内存空间向低地址内存空间生长的，所以分配栈内存空间是减去一个值。
|
||
|
||
接着我们来看看C语言中的“a=125;b=100;”，这两行代码就是给变量赋值，也可以叫做赋值表达式，对应的汇编代码如下所示：
|
||
|
||
# a=125;b=100;
|
||
li a5,125 #125加载到a5寄存器中
|
||
sw a5,-20(s0) #把a5寄存器储存到（s0-20）的内存空间中，即栈中
|
||
li a5,100 #100加载到a5寄存器中
|
||
sw a5,-24(s0) #把a5寄存器储存到（s0-24）的内存空间中，即栈中
|
||
|
||
|
||
现在我们已经看到了“=”赋值运算，被转化为机器的数据传输指令，即储存、加载和寄存器之间的传输指令。从-20、-24这些地址偏移量，我们可以推导出a，b两个整型变量各占4字节大小的空间。
|
||
|
||
然后，我们来看看C语言里“c = a + b;”这一行代码，它就是运算表达式，同时也赋值表达式，但运算表达式的优先级更高，对应的汇编代码如下所示：
|
||
|
||
#c=a+b;
|
||
lw a4,-20(s0) #把（s0-20）内存空间中的内容加载到a4寄存器中
|
||
lw a5,-24(s0) #把（s0-24）内存空间中的内容加载到a5寄存器中
|
||
add a5,a4,a5 #a4寄存器加上a5寄存器的结果送给a5寄存器
|
||
sw a5,-28(s0) #把a5寄存器储存到（s0-28）的内存空间中，即栈中
|
||
|
||
|
||
上述代码中，我们再一次看到，C语言中的加法运算符被转化成了机器的加法指令，运算表达式中的变量放在寄存器中，就成了加法指令的操作数。但是运算结果也被放在寄存器中，而后又被储存到内存中了。
|
||
|
||
最后，我们来看看C语言中“return c;”这一行代码，也就是返回表达式。对应的汇编代码如下所示：
|
||
|
||
#return c;
|
||
lw a5,-28(s0) #把（s0-28）内存空间中的内容加载到a5寄存器中
|
||
mv a0,a5 #a5寄存器送给a0寄存器，作为返回值
|
||
lw s0,28(sp) #恢复s0寄存器
|
||
addi sp,sp,32 #把栈指针寄存器加上32，相当于在栈中回收了32字节的空间
|
||
jr ra #把ra寄存器送给pc寄存器实现返回
|
||
|
||
|
||
从上述代码块可以看到，先把c变量加载到a5寄存器中，又把a5寄存器送给了a0寄存器。
|
||
|
||
在语言调用标准中，a0寄存器是作为返回值寄存器使用的，return语句是流程控制语句，它被转换为机器对应的跳转指令，即jr指令。jr指令会把操作数送给pc寄存器，这样就能实现程序的跳转。
|
||
|
||
到这里，C语言表达式是怎么变成汇编语言的，我们就弄明白了。
|
||
|
||
C语言流程控制
|
||
|
||
如果只存在表达式，代码只能从上到下顺序执行，很多算法都无法实现，毕竟顺序执行就是“一条道走到黑”，这显然还不够。如果我们要控制代码的执行顺序，就需要流程控制。
|
||
|
||
通过流程控制，C语言就能把程序的分支、循环结构转换成汇编语言。下面我们以C语言中最常用的for循环为例来理解流程控制。for循环这个例子很有代表性，因为它包括了循环和分支，代码如下所示。
|
||
|
||
void flowcontrol()
|
||
{
|
||
//定义了整型变量i
|
||
int i;
|
||
for(i = 0; i < 5; i++)
|
||
{
|
||
;//什么都不做
|
||
}
|
||
return;
|
||
}
|
||
|
||
|
||
可以看到上述代码中，for关键字后面的括号中有三个表达式。
|
||
|
||
开始第一步先执行的是第一个表达式：i = 0; 接着第二步，执行第二个表达式。如果表达式的运算结果为false，就跳出for循环；然后到了第三步，执行大括号“{}”中的语句，这里是空语句，什么都不做；最后的第四步执行第三个表达式：i++，再回到第二步开始下一次循环。
|
||
|
||
下面我们看看这四步对应的汇编程序，如下所示：
|
||
|
||
flowcontrol:
|
||
addi sp,sp,-32
|
||
sw s0,28(sp)
|
||
addi s0,sp,32 # int i 定义i变量
|
||
sw zero,-20(s0) # i = 0 第一步 第一个表达式
|
||
j .L2 # 无条件跳转到.L2标号处
|
||
.L3:
|
||
lw a5,-20(s0) # 加载i变量
|
||
addi a5,a5,1 # i++ 第四步 第三个表达式
|
||
sw a5,-20(s0) # 保存i变量
|
||
.L2:
|
||
lw a4,-20(s0) # 加载i变量
|
||
li a5,4 # 加载常量4
|
||
ble a4,a5,.L3 # i < 5 第二步 第二个表达式 如果i <= 4就跳转.L3标号，否则就执行后续指令，跳出循环
|
||
lw s0,28(sp) # 恢复s0寄存器
|
||
addi sp,sp,32 # 回收栈空间
|
||
jr ra # 返回
|
||
|
||
|
||
有了前面的基础，上面这段代码应该很容易理解。
|
||
|
||
你可能有点疑惑，为什么代码的注释中没有看到第三步的内容？这是因为我们写了空语句，编译器没有生成相应的指令。一般CPU会提供多种形式的跳转指令，来实现程序的流程控制，后面课程里我们在专门研究和调试跳转指令，这里你先有个印象就行。
|
||
|
||
你不妨试着想象一下，图灵机那个读头在纸带上来回移动的情景。上面的代码中j，jr都是无条件的跳转指令，ble是带比较的条件分支指令，比较的结果为真，则跳转到相应的地址上继续执行；否则就会执行后面的下一条指令。
|
||
|
||
现在已经很清楚了，C语言正是用了这些跳转、条件分支指令，才实现了如if、for、while、goto、return等程序流程控制逻辑。
|
||
|
||
C语言函数
|
||
|
||
我们再来看看C语言函数，了解一下C语言是怎么把函数转换成汇编语言的。
|
||
|
||
通过前一节课的学习，我们知道了函数是C语言中非常重要的组成部分。我们要用C语言完成一个实际的功能，就需要至少写一个函数，可见函数就是C语言中对一段功能代码的抽象。一个函数就是一个执行过程，有输入参数也有返回结果（根据需要可有可无），可以调用其它函数，也被其它函数调用。
|
||
|
||
让我们去写函数验证一下，如下所示：
|
||
|
||
//定义funcB
|
||
void funcB()
|
||
{
|
||
return;
|
||
}
|
||
//定义funcA
|
||
void funcA()
|
||
{
|
||
//调用funcB
|
||
funcB();
|
||
return;
|
||
}
|
||
|
||
|
||
上述代码中定义了funcA、funcB两个函数，函数funcA调用了函数funcB，而函数funcB是个空函数，什么也不做。
|
||
|
||
下面我们直接看它们的汇编代码，如下所示：
|
||
|
||
funcB:
|
||
addi sp,sp,-16
|
||
sw s0,12(sp) #储存s0寄存器到栈中
|
||
addi s0,sp,16
|
||
nop
|
||
lw s0,12(sp) #从栈中加载s0寄存器
|
||
addi sp,sp,16
|
||
jr ra #函数返回
|
||
|
||
funcA:
|
||
addi sp,sp,-16
|
||
sw ra,12(sp)
|
||
sw s0,8(sp) #储存ra，s0寄存器到栈中
|
||
addi s0,sp,16
|
||
call funcB #调用funcB函数
|
||
nop
|
||
lw ra,12(sp) #从栈中加载ra，s0寄存器
|
||
lw s0,8(sp)
|
||
addi sp,sp,16
|
||
jr ra #函数返回
|
||
|
||
|
||
从上面的汇编代码可以看出，函数就是从一个标号开始到返回指令的一段汇编程序，并且C语言中的函数名就是标号，对应到汇编程序中就是地址。
|
||
|
||
即使是什么也不做的空函数，C语言编译器也会把它翻译成相应的指令，分配栈空间，保存或者恢复相应的寄存器，回收栈空间，这相当于一个标准的代码模板。
|
||
|
||
其中的call其实完成了两个动作：一是把call下一条指令的地址保存到ra寄存器中；二是把后面标号地址赋值给pc寄存器，实现程序的跳转。由于被跳转的程序段最后会执行jr ra，即把ra寄存器赋值给pc寄存器，然后再跳转到call指令的下一条指令开始执行，这样就能实现函数的返回。
|
||
|
||
总结一下，C语言编译器把函数名转换成了标号，也就是汇编程序里的某个地址，并且把函数的功能翻译成各种指令。
|
||
|
||
这样我们写下一个函数，经过C语言编译器加工，就变成了CPU能够“听懂”的各种运算指令、流程控制指令。之后，CPU就能定位到相应的汇编代码段，在这些代码段之间跳来跳去，实现函数之间的调用。
|
||
|
||
C语言调用规范
|
||
|
||
现在我们来探讨另一个问题，就是一个函数调用另一个函数的情况，而且这两个函数不是同一种语言所写。
|
||
|
||
比如说，在汇编语言中调用C语言，或者反过来在C语言里调用汇编语言。这些情况要怎么办呢？这时候就需要有一种调用约定或者规范。
|
||
|
||
这个规范有什么用呢？前面的课程我们说过，CPU中的一些寄存器有特定作用的，自然不能在函数中随便使用。即使用到了也要先在栈里保存起来，然后再恢复。
|
||
|
||
这就引发了三个问题：一是需要规定好寄存器的用途；二是明确哪些寄存器需要保存和恢复；第三则是规定函数如何传递参数和返回值，比如用哪些寄存器传递参数和返回值。关于CPU寄存器的规定，你可以回顾一下[第二节课]。
|
||
|
||
首先我们看一下，C语言下的数据类型在RISC-V平台下所占据内存的大小，这也是调用规范的一部分，如下表：
|
||
|
||
|
||
|
||
下面我们结合实例来理解。我们先来写一段汇编代码和C代码，用汇编代码调用C函数，它们属于不同的文件，这些文件我已经在工程里给你准备好了。
|
||
|
||
首先，汇编代码如下：
|
||
|
||
.text //表明下列代码放在text段中
|
||
.globl main //导出main符号，链接器必须要找的到main符号
|
||
main:
|
||
addi sp,sp,-16
|
||
sw s0,12(sp) //保存s0寄存器
|
||
addi s0,sp,16
|
||
call C_function //调用C语言编写的C_function函数
|
||
li a0,0 //设置main函数的返回值为0
|
||
lw s0,12(sp) //恢复s0寄存器
|
||
addi sp,sp,16
|
||
jr ra //返回
|
||
|
||
|
||
上述代码放在了main_asm.S文件中，这些代码我都替你手动写好了，你需要从main开始，代码的作用你可以参考一下注释说明。
|
||
|
||
这段代码主要处理了栈空间，保存了s0寄存器，然后调用了C语言编写的C_function函数，该函数我放在了main_c.c文件中，如下所示：
|
||
|
||
#include "stdio.h"
|
||
void C_function()
|
||
{
|
||
printf("This is C_function!\n");
|
||
return;
|
||
}
|
||
|
||
|
||
我们用VSCode打开工程文件夹，按下“F5”键，就会出现后面图里显示的结果。-
|
||
|
||
|
||
我们看到代码运行了，打印出了This is C_function!，而且没有出现任何错误，这说明我们通过汇编代码调用C函数成功了。你可以想一想，这个过程还有什么疏漏么？
|
||
|
||
以上代码的功能很简单，很多寄存器没有用到，所以并没有保护和恢复相应的寄存器。在复杂的情况下，调用者函数应该保存和恢复临时寄存器：t0~t6（整数寄存器），ft0~ft11（浮点寄存器）。被调用者函数应该保存和恢复的寄存器：s0~s11（整数寄存器），fs0~fs11（浮点寄存器）。
|
||
|
||
现在只剩最后一个问题了，C语言函数有参数和返回值。如果没有相应规范，一个C语言函数就不知道如何给另一个C语言函数传递参数，或者接收它的返回值。
|
||
|
||
我们同样用代码来验证一下，如下所示：
|
||
|
||
int addtest(int a, int b, int c,int d, int e, int f, int g, int h, int i)
|
||
{
|
||
return a + b + c + d+ e + f + g + h + i;
|
||
}
|
||
void C_function()
|
||
{
|
||
int s = 0;
|
||
s = addtest(1,2,3,4,5,6,7,8,9);
|
||
printf("This is C_function! s = %d\n", s);
|
||
return;
|
||
}
|
||
|
||
|
||
这段代码很简单，为了验证参数的传递，我们给addtest函数定义了9个参数，在C_function函数中调用它，并打印出它的返回值。
|
||
|
||
我们直接看看它生成的汇编代码，如下所示：
|
||
|
||
addtest:
|
||
addi sp,sp,-48
|
||
sw s0,44(sp)
|
||
addi s0,sp,48 #让s0变成原sp的值
|
||
#依次将a0~a7，8个寄存器放入栈中
|
||
sw a0,-20(s0)
|
||
sw a1,-24(s0)
|
||
sw a2,-28(s0)
|
||
sw a3,-32(s0)
|
||
sw a4,-36(s0)
|
||
sw a5,-40(s0)
|
||
sw a6,-44(s0)
|
||
sw a7,-48(s0)
|
||
#从栈中加载8个整型数据相加
|
||
lw a4,-20(s0)
|
||
lw a5,-24(s0)
|
||
add a4,a4,a5
|
||
lw a5,-28(s0)
|
||
add a4,a4,a5
|
||
lw a5,-32(s0)
|
||
add a4,a4,a5
|
||
lw a5,-36(s0)
|
||
add a4,a4,a5
|
||
lw a5,-40(s0)
|
||
add a4,a4,a5
|
||
lw a5,-44(s0)
|
||
add a4,a4,a5
|
||
lw a5,-48(s0)
|
||
add a4,a4,a5
|
||
#从栈中加载第9个参数的数据，参考第4行代码
|
||
lw a5,0(s0)
|
||
add a5,a4,a5
|
||
#把累加的结果放入a0寄存器，作为返回值
|
||
mv a0,a5
|
||
lw s0,44(sp)
|
||
addi sp,sp,48 #恢复栈空间
|
||
jr ra #返回
|
||
|
||
C_function:
|
||
addi sp,sp,-48
|
||
sw ra,44(sp)
|
||
sw s0,40(sp)
|
||
addi s0,sp,48
|
||
sw zero,-20(s0)
|
||
li a5,9
|
||
sw a5,0(sp) #将9保存到栈顶空间中
|
||
li a7,8
|
||
li a6,7
|
||
li a5,6
|
||
li a4,5
|
||
li a3,4
|
||
li a2,3
|
||
li a1,2
|
||
li a0,1 #将1~8，加载到a0~a7，8个寄存器中，作为addtest函数的前8个参数
|
||
call addtest #调用addtest函数
|
||
sw a0,-20(s0) #addtest函数返回值保存到s变量中
|
||
lw a1,-20(s0) #将s变量作为printf函数的第二个参数
|
||
lui a5,%hi(.LC0)
|
||
addi a0,a5,%lo(.LC0)
|
||
call printf
|
||
nop
|
||
lw ra,44(sp)
|
||
lw s0,40(sp)
|
||
addi sp,sp,48 #恢复栈空间
|
||
jr ra #返回
|
||
|
||
|
||
根据上面的代码，我们来总结一下，C语言函数用a0~a7这个8个寄存器，传递了一个函数的前8个参数。注意如果是浮点类型的参数，则使用对应的浮点寄存器fa0~fa7，从第9个参数开始依次存放在栈中,而函数的返回值通常放在a0寄存器中。
|
||
|
||
到这里，C语言调用规范我们就搞清楚了。
|
||
|
||
重点回顾
|
||
|
||
这节课，我们一起研究了C语言编译器的“搬砖日常”，讨论了C语言跟汇编语言的对应关系。现在我们来回顾一下这节课的重点。
|
||
|
||
C语言变量经过编译器的加工，其变量名变成了汇编语言中的标号，也就是地址。变量空间由汇编语言中.byte、.word等操作符分配空间，有的空间存在于二进制文件中，有的空间需要OS加载程序之后再进行分配。
|
||
|
||
接着是C语言表达式，C语言表达式由C语言变量和C语言运算符组成，C语言运算符被转换成了对应的CPU运算指令。变量由内存加载到寄存器，变成了指令的操作数，一起完成了运算功能。
|
||
|
||
之后我们借助for循环这个例子，发现C语言函数会被编译器“翻译”成一段带有标号的汇编代码，里面包含了流程控制指令（比如跳转指令）和各种运算指令。这些指令能修改PC寄存器，使之能跳转到相应的地址上运行，实现流程控制。
|
||
|
||
最后我们讨论了C语言的调用规范。“没有规矩不成方圆”，调用规范解决了函数之间的调用约束，比如哪些寄存器由调用者根据需要保存和恢复，哪些寄存器由被调用者根据需要保存和恢复，函数之间如何传递参数，又如何接收函数的返回值等等的问题。
|
||
|
||
为了奖励你看到这里，我还准备了一张知识导图，供你复习回顾要点。
|
||
|
||
|
||
|
||
下节课起，我们将会开始汇编指令的深入学习，敬请期待。
|
||
|
||
思考题
|
||
|
||
请问C语言函数如何传递结构体类型的参数呢？
|
||
|
||
欢迎你在留言区跟我交流互动，积极参与思考有助于你更深入地学习。如果觉得这节课还不错，别忘了分享给身边的同事。
|
||
|
||
|
||
|
||
|