单遍解释器：函数调用

1493 字

7 分钟

单遍解释器：函数调用

2026-03-31

Compiler-Principles

单遍解释器

/

函数调用

在这一节中，我们将设计并实现函数调用的相关机制。

前提#

在我们实现的单遍解释器中，我们采用的是线性中间表达，即字节码。

语言运行的整体流程为：源代码 -> 解析器 -> 字节码 -> 虚拟机执行。

开始#

在解释器中，函数会经历两个阶段：

解析器对函数进行声明、定义、解析为字节码等；
虚拟机在执行过程中遇到函数调用指令时，进行函数调用的相关处理。

了解这两个阶段后，我们可以绘制出函数在解释器的虚拟机中的调用与返回过程：

Function calling and returning DFA

通过这个图，我们可以了解到函数调用其实本质上是一个状态转换的过程：

在虚拟机中，当遇到函数调用指令时，虚拟机会为其分配一个新的栈帧，这个栈帧包含了函数对象在堆中的引用、局部变量等。当函数执行完成后，虚拟机会退出被调用函数的栈帧，继续执行调用函数的后续指令。

其中相应函数的字节码需要我们提前在解析器阶段生成。

解析器生成函数字节码#

在解析器阶段，我们需要将函数声明和定义解析为字节码指令，以便虚拟机能够跳转到这个字节码块并进行字节码匹配。

具体而言，我们需要合理利用解析器的上下文成员 Context 来存储当前解析的位置（位于哪个函数），并将解析结果写到对应的字节码块中，下面是函数与上下文数据结构：

1
struct Function {
2
    name: String,
3
    chunk: Vec<u8>,
4
    /// The number of parameters the function takes.
5
    arity: u8,
6
}
7
struct Context {
8
    caller: Option<Box<Context>>,
9
    current_function: Function,
10
    scope_depth: usize,
11
}

通过当前上下文，我们就能在解析过程中访问到当前函数的字节码块并写入内部解析得到的结果。

还有一个问题需要我们解决：函数调用指令的参数传递。

在函数调用指令中，我们需要将实参传递给被调用函数的形参。

我们可以通过虚拟机的栈来实现参数传递：在调用函数之前，将实参压入栈中，然后在被调用函数的栈帧中访问这些实参。

解析器与虚拟机之间的栈同步机制👉单遍解释器：局部变量。

拿具体的代码来说，给出这样一段代码：

1
fun sum(a, b, c) {
2
  return a + b + c;
3
}
4

5
print sum(5, 10, 15);

笔者实现的解释器给出的反编译结果如下：

1
Disassemble 'sum':
2
Offset  Line  Opcode
3
000000  0002  GetLocal  <index 1>
4
000002     -  GetLocal  <index 2>
5
000004     -  Add
6
000005     -  GetLocal  <index 3>
7
000007     -  Add
8
000008     -  Return
9
000009  0003  Nil
10
000010     -  Return
11

12
Disassemble '<Global>':
13
Offset  Line  Opcode
14
000000  0003  Closure   <fn sum>
15
000002     -  DefineGlobal  "sum"
16
000004  0005  GetGlobal  "sum"
17
000006     -  Constant  5
18
000008     -  Constant  10
19
000010     -  Constant  15
20
000012     -  Call      argc(3)
21
000014     -  Print
22
000015     -  Nil
23
000016     -  Return

可以看到，在执行 Call 指令之前，我们通过三个 Constant 指令将实参 5、10 和 15 压入了虚拟机的栈中；在执行 Call 指令时，虚拟机会根据参数个数 argc(3) 跳到栈顶前三条指令即 GetGlobal 来访问函数的字节码并为其生成栈帧。

Function calling

由于 sum 函数的形参也是一种局部变量，因此形参在内部被访问是通过虚拟机的栈偏移量实现的（如 GetLocal <index 1> 表示 sum 函数栈底往上一个偏移量，即 5）。因此，在调用 sum 函数时，虚拟机会将该函数的栈指针移动到函数调用所在位置，并通过偏移量来访问实参的值。

TIP
为了简化虚拟机的实现，我们将全局作用域作为一个 <Global> 函数来看待。

TIP
<index n> 表示在当前函数的栈帧中，往上 n 个位置的局部变量。第一个局部变量从 1 开始计数而不是 0，是因为 0 的位置通常用来存储函数对象本身，也就是 self/this。

虚拟机执行函数调用#

前面我们大致介绍了虚拟机中函数调用和返回的过程，即创建栈帧与销毁栈帧。

现在我们来看看具体的实现细节：

1
let opcode = Self::read_byte(&chunk, pc);
2
match opcode {
3
    OpCode::Return => {
4
        let ret = self.pop();
5
        self.frame_count -= 1;
6
        if self.frame_count == 0 {
7
            self.pop();
8
            return InterpretResult::Ok;
9
        }
10
        // Destory the call frame of callee by fallback stack pointer.
11
        self.stack_top = slot_offset;
12
        self.push(ret);
13
    }
14
    OpCode::Call => {
15
        let arg_count = Self::read_byte(&chunk, pc) as usize;
16
        if !self.call_value(arg_count) {
17
            return InterpretResult::RuntimeError;
18
        }
19
    }
20
}