解密虚拟机的执行环境：栈帧对象

楔子

后续打算深入介绍 Python 的协程，这里先补充一些前置的知识。

前面我们介绍了 Python 的 PyCodeObject 对象，它是解释器对源代码编译之后的结果。该对象内部有很多属性，比如 co_code 负责存储相应的字节码，也就是虚拟机要执行的指令序列；co_names、co_consts 等等则负责存储代码中的符号、常量等静态信息。

那么问题来了，既然源代码在经过编译之后，所有字节码指令以及相关的静态信息都存储在 PyCodeObject 对象当中，那么是不是意味着虚拟机就在 PyCodeObject 对象上进行所有的动作呢？

答案显然不是的，虽然 PyCodeObject 包含了关键的字节码指令以及静态信息，但有一个东西是没有包含、也不可能包含的，就是程序在运行时的执行环境，这个执行环境在 Python 里面叫做栈帧。

什么是栈帧

栈帧，它是字节码执行时的上下文。我们看一个示例：

name = "古明地觉"

def f():
    name = "古明地恋"
    print(name)

f()
print(name)
"""
古明地恋
古明地觉
"""

上面的代码中出现了两个 print(name)，它们的字节码指令是相同的，但执行的效果却显然不同，而这样的结果正是执行环境的不同所产生的。因为环境的不同，name 的值也不同。

因此同一个符号在不同环境中可能指向不同的值，必须在运行时进行动态捕捉和维护，这些信息不可能在 PyCodeObject 对象中被静态存储。

因此虚拟机并不是在 PyCodeObject 对象上执行操作的，而是栈帧对象。虚拟机在执行时，会根据 PyCodeObject 对象动态创建出栈帧对象，然后在栈帧里面执行字节码。

因此对于上面的代码，我们可以大致描述一下流程：

当虚拟机在执行第一条语句时，已经创建了一个栈帧，这个栈帧显然是模块对应的栈帧，假设叫做 A；
所有的字节码都会在这个栈帧中执行，虚拟机可以从栈帧里面获取变量的值，也可以修改；
当发生函数调用的时候，这里是函数 f，那么虚拟机会在栈帧 A 之上，为函数 f 创建一个新的栈帧，假设叫 B，然后在栈帧 B 里面执行函数 f 的字节码指令；
在栈帧 B 里面也有一个名字为 name 的变量，但由于执行环境、或者说栈帧的不同，name 也不同。比如两个人都叫小明，但一个是北京的、一个是上海的，所以这两者没什么关系；
一旦函数 f 的字节码指令全部执行完毕，那么会将当前的栈帧 B 销毁（也可以保留下来），再回到调用者的栈帧当中。就像是递归一样，每当调用函数时，就会在当前栈帧之上创建一个新的栈帧，一层一层创建，一层一层返回；

而实际上虚拟机执行字节码这个过程，就是在模拟操作系统运行可执行文件。我们再用一段 Python 代码解释一下：

def f(a, b):
    return a + b

def g():
    return f()

g()

程序先调用函数 g，那么会为函数 g 创建栈帧；然后在函数 g 里面调用函数 f，那么系统就又会在地址空间中，于函数 g 的栈帧之上创建函数 f 的栈帧。

当程序执行函数 g 时，那么当前帧就是函数 g 的栈帧，调用者的帧则是模块的栈帧。而当程序执行函数 f 时，那么当前帧就是函数 f 的栈帧，而调用者的帧则是函数 g 的栈帧。

栈是先入后出的数据结构，内存地址从栈底到栈顶是减小的。对于一个函数而言，所有对局部变量的操作都在自己的栈帧中完成，而调用函数的时候则会为其创建新的栈帧。

当函数 f 的调用完成时，对应的栈帧就会被销毁，然后程序的运行空间会回到函数 g 的栈帧中。

那么下面我们就来看看栈帧在底层长什么样，注意：栈帧也是一个对象。

栈帧的底层结构

栈帧在底层是由 PyFrameObject 结构体表示的，但相比操作系统运行可执行文件时创建的栈帧，Python 的栈帧实际上包含了更多的信息。

typedef struct _frame {
    //可变对象的头部信息
    PyObject_VAR_HEAD      
    //上一级栈帧, 也就是调用者的栈帧 
    struct _frame *f_back;     
    //PyCodeObject对象
    //通过栈帧的f_code属性可以获取对应的PyCodeObject对象
    PyCodeObject *f_code;       
    //builtin名字空间，一个PyDictObject对象
    PyObject *f_builtins;       
    //global名字空间，一个PyDictObject对象
    PyObject *f_globals;        
    //local名字空间，一个PyDictObject对象 
    PyObject *f_locals;         
    //运行时的栈底位置 
    PyObject **f_valuestack;    
    //运行时的栈顶位置
    PyObject **f_stacktop;      
    //回溯函数，打印异常栈
    PyObject *f_trace;         
    //是否触发每一行的回溯事件
    char f_trace_lines;        
    //是否触发每一个操作码的回溯事件
    char f_trace_opcodes;       
    //是否是基于生成器的PyCodeObject构建的栈帧
    PyObject *f_gen;            
    //上一条已执行完毕的指令在f_code中的偏移量 
    int f_lasti;                
    //当前字节码对应的源代码行号
    int f_lineno;               
    //当前指令在栈f_blockstack中的索引
    int f_iblock;               
    //当前栈帧是否仍在执行
    char f_executing;           
    //用于try和loop代码块
    PyTryBlock f_blockstack[CO_MAXBLOCKS]; 
    //动态内存
    //维护 "局部变量+cell对象集合+free对象集合+运行时栈" 所需要的空间
    PyObject *f_localsplus[1];  
} PyFrameObject;

因此虚拟机会根据 PyCodeObject 对象来创建一个栈帧，也就是 PyFrameObject 对象，虚拟机实际是在栈帧对象上执行操作的。

每一个 PyFrameObject 都会维护一个 PyCodeObject，换言之，每一个 PyCodeObject 都会隶属于一个 PyFrameObject。并且从 f_back 可以看出，Python 在实际执行时，会产生很多的 PyFrameObject 对象，而这些对象会被链接起来，形成一条执行环境链表，或者说栈帧链表。

而这正是操作系统栈帧之间关系的模拟，对于操作系统而言，栈帧之间通过 rsp 和 rbp 指针建立了联系，使得新栈帧在结束之后能够顺利地返回到旧栈帧中，而 Python 则是利用 f_back 来完成这个动作。

栈帧里面的 f_code 指向相应的 PyCodeObject 对象，而 f_builtins、f_globals、f_locals 则是指向三个独立的名字空间。在这里，我们看到了名字空间和执行环境（栈帧）之间的关系，前者只是后者的一部分。

名字空间负责维护变量和对象之间的映射关系，通过名字空间，我们能够找到一个符号被绑定在了哪个对象上。

另外在 PyFrameObject 的开头有一个 PyObject_VAR_HEAD，表示栈帧是一个变长对象，即每次创建的栈帧的大小可能是不一样的，那么这个变动在什么地方呢？

首先每一个 PyFrameObject 对象都维护了一个 PyCodeObject 对象，而每一个 PyCodeObject 对象都会对应一个代码块。在编译一段代码块的时候，会计算这段代码块执行时所需要的栈空间的大小，这个栈空间大小存储在 PyCodeObject 对象的 co_stacksize 中。

而不同的代码块所需要的栈空间是不同的，因此栈帧是一个变长对象。最后，其实栈帧里面的内存空间分为两部分，一部分是编译代码块需要的空间，另一部分是执行代码块所需要的空间，也称之为运行时栈（后续聊），不过我们只需要关注运行时栈即可。

在 Python 中访问栈帧

如果要在 Python 里面拿到栈帧对象，可以通过 inspect 模块。

import inspect

def f():
    # 返回当前所在的栈帧
    # 这个函数实际上是调用了 sys._getframe(1)
    return inspect.currentframe()

frame = f()
print(frame) 
"""
<frame at ..., file 'D:/satori/main.py', line 6, code f>
"""
print(type(frame))  
"""
<class 'frame'>
"""

我们看到栈帧的类型是<class ‘frame’>，正如 PyCodeObject 对象的类型是 <class ‘code’> 一样。这两个类没有暴露给我们，所以不可以直接使用。

同理还有函数，类型是 <class ‘function’>；模块，类型是 <class ‘module’>。这些解释器都没有暴露给我们，如果直接使用的话，那么 frame、code、function、module 只是几个没有定义的变量罢了，这些类我们只能通过这种间接的方式获取。

下面我们就来访问一下栈帧的成员属性。

import inspect

def f():
    name = "古明地觉"
    age = 16
    return inspect.currentframe()

def g():
    name = "魔理沙"
    age = 333
    return f()

# 当我们调用函数 g 的时候，也会触发函数 f 的调用
# 而一旦 f 执行完毕，那么 f 对应的栈帧就被全局变量 frame 保存起来了
frame = g()
print(frame)
"""
<frame at ... 'D:/satori/main.py', line 6, code f>
"""
# 获取上一级栈帧，即调用者的栈帧
# 显然是函数 g 的栈帧
print(frame.f_back)
"""
<frame at ... 'D:/satori/main.py', line 11, code g>
"""
# 模块也是有栈帧的，我们后面会单独说
print(frame.f_back.f_back)
"""
<frame at ... 'D:/satori/main.py', line 27, code <module>>
"""
# 显然最外层就是模块了
# 模块对应的上一级栈帧是None
print(frame.f_back.f_back.f_back)
"""
None
"""

# 获取 PyCodeObject 对象
print(frame.f_code)
print(frame.f_back.f_code)
"""
<code object f ... "D:/satori/main.py", line 3>
<code object g ... "D:/satori/main.py", line 8>
"""
print(frame.f_code.co_name)
print(frame.f_back.f_code.co_name)
"""
f
g
"""

# 获取 f_locals
# 即栈帧内部的 local 名字空间
print(frame.f_locals)
"""
{'name': '古明地觉', 'age': 16}
"""
print(frame.f_back.f_locals)
"""
{'name': '魔理沙', 'age': 333}
"""

# 获取栈帧创建时对应的行号
print(frame.f_lineno)
print(frame.f_back.f_lineno)
"""
6
11
"""
# 行号为 6 的位置是: return inspect.currentframe()
# 行号为 11 的位置是: return f()

我们看到函数运行完毕之后，里面的局部变量居然还能获取，原因就是栈帧没被销毁，因为它被返回了，而且被外部变量接收了。同理该栈帧的上一级栈帧也不能被销毁，因为当前栈帧的 f_back 指向它了，引用计数不为 0，所以要保留。

通过栈帧可以获取很多的属性，我们后面还会慢慢说。此外，异常处理也可以获取到栈帧。

import sys

def foo():
    try:
        1 / 0
    except ZeroDivisionError as e:
        _, _, exc_tb = sys.exc_info()
        # exc_tb 还可以通过 e.__traceback__ 获取
        print(exc_tb)
        """
        <traceback object at 0x00000135CEFDF6C0>
        """

        # 调用 exc_tb.tb_frame 即可拿到异常对应的栈帧
        print(exc_tb.tb_frame)
        """
        <frame at ... 'D:/satori/main.py', line 15, code foo>
        """
        print(exc_tb.tb_frame.f_back)
        """
        <frame at ... 'D:/satori/main.py', line 31, code <module>>
        """
        # 显然 exc_tb.tb_frame 是当前函数 foo 的栈帧
        # 那么 exc_tb.tb_frame.f_back 就是整个模块对应的栈帧
        # 那么再上一级的话, 栈帧就是 None 了
        print(exc_tb.tb_frame.f_back.f_back)
        """
        None
        """

foo()