stateDiagram-v2
    [*] --> 创建Frame: PyEval_EvalCode()
    创建Frame --> 初始化栈: 分配栈空间
    初始化栈 --> 进入解释器: _PyEval_EvalFrameDefault()
    进入解释器 --> 指令循环: DISPATCH()

    指令循环 --> 取指令: next_instr++
    取指令 --> 解码: opcode, oparg
    解码 --> 执行指令: switch(opcode)

    执行指令 --> 正常完成: 大多数指令
    正常完成 --> 检查信号: check_periodics()
    检查信号 --> 指令循环: 继续

    执行指令 --> 函数调用: CALL
    函数调用 --> 内联调用: Python函数
    内联调用 --> 指令循环: 栈帧切换

    执行指令 --> 返回: RETURN_VALUE
    返回 --> 弹出栈帧: 恢复调用者
    弹出栈帧 --> 指令循环: 继续调用者
    弹出栈帧 --> [*]: 顶层返回

    执行指令 --> 异常: ERROR
    异常 --> 查找Handler: 异常表
    查找Handler --> 指令循环: 找到Handler
    查找Handler --> 展开栈帧: 未找到
    展开栈帧 --> 查找Handler: 上层Frame
    展开栈帧 --> [*]: 未捕获异常

flowchart TB
    subgraph 入口层
        A[PyEval_EvalCode] --> B[PyEval_EvalFrame]
        B --> C[_PyEval_EvalFrame]
        C --> D[_PyEval_EvalFrameDefault]
    end

    subgraph 栈帧管理
        E[_PyInterpreterFrame] --> F[stack_pointer]
        E --> G[instr_ptr]
        E --> H[locals + stack]
        E --> I[previous frame]
    end

    subgraph 指令执行循环
        J[DISPATCH宏] --> K[取指令]
        K --> L[解码]
        L --> M{USE_COMPUTED_GOTOS?}
        M -->|是| N[跳转表]
        M -->|否| O[Switch语句]
        N --> P[执行指令]
        O --> P
    end

    subgraph 指令实现
        P --> Q[栈操作指令]
        P --> R[对象操作指令]
        P --> S[控制流指令]
        P --> T[函数调用指令]
        P --> U[异常处理指令]
    end

    subgraph 性能优化
        V[内联缓存] --> W[LOAD_ATTR缓存]
        V --> X[LOAD_GLOBAL缓存]
        V --> Y[CALL缓存]

        Z[指令特化] --> AA[quickening]
        Z --> AB[adaptive指令]
        AB --> AC[专用版本]

        AD[Tier 2优化] --> AE[_PyUOpExecutor]
        AD --> AF[trace缓存]
        AD --> AG[JIT编译]
    end

    subgraph 异常处理
        AH[异常发生] --> AI[PyErr_Occurred]
        AI --> AJ[查找异常表]
        AJ --> AK[展开栈]
        AK --> AL[执行Handler]
        AL --> AM{处理成功?}
        AM -->|是| J
        AM -->|否| AH
    end

    subgraph 周期性检查
        AN[eval_breaker] --> AO[信号处理]
        AN --> AP[GIL释放请求]
        AN --> AQ[异步异常]
        AN --> AR[待处理调用]
        AN --> AS[GC触发]
    end

    D --> E
    D --> J
    P --> V
    P --> Z
    P --> AD
    P --> AH
    J --> AN

typedef struct _PyInterpreterFrame {
    PyObject *f_executable;      // Code Object 或函数对象
    struct _PyInterpreterFrame *previous;  // 调用者栈帧
    _Py_CODEUNIT *instr_ptr;     // 当前指令指针
    _PyStackRef *stackpointer;   // 栈顶指针
    uint16_t return_offset;      // 返回偏移
    char owner;                  // 栈帧所有者
    bool is_entry;               // 是否入口帧
    _PyStackRef localsplus[1];   // 局部变量+栈空间（变长）
} _PyInterpreterFrame;

+-------------------+
| f_executable      |
| previous          |
| instr_ptr         |
| stackpointer      |
| return_offset     |
| owner, is_entry   |
+-------------------+
| localsplus[0]     |  <- 局部变量 0
| localsplus[1]     |  <- 局部变量 1
| ...               |
| localsplus[N-1]   |  <- 局部变量 N-1
+-------------------+
| localsplus[N]     |  <- 栈底
| localsplus[N+1]   |
| ...               |  <- 求值栈
| localsplus[N+M-1] |  <- 栈顶（最大）
+-------------------+

struct PyCodeObject {
    PyObject_HEAD
    int co_argcount;              // 参数数量
    int co_posonlyargcount;       // 仅位置参数数量
    int co_kwonlyargcount;        // 仅关键字参数数量
    int co_stacksize;             // 栈深度
    int co_firstlineno;           // 首行号

    PyObject *co_code;            // 字节码（bytes对象）
    PyObject *co_consts;          // 常量元组
    PyObject *co_names;           // 名称元组
    PyObject *co_localsplusnames; // 局部变量名

    PyObject *co_exceptiontable;  // 异常表
    int co_flags;                 // 标志位

    _PyCoCached *_co_cached;      // 缓存（quickening数据）
    uint64_t _co_instrumentation_version; // 版本号
    _Py_CODEUNIT *co_code_adaptive; // 自适应字节码
    ...
};

#define CO_OPTIMIZED         0x0001  // 使用 LOAD_FAST
#define CO_NEWLOCALS         0x0002  // 新局部命名空间
#define CO_VARARGS           0x0004  // *args
#define CO_VARKEYWORDS       0x0008  // **kwargs
#define CO_GENERATOR         0x0020  // 生成器
#define CO_COROUTINE         0x0080  // 协程
#define CO_ASYNC_GENERATOR   0x0200  // 异步生成器

typedef uint16_t _Py_CODEUNIT;

// 位分布（16位）
// | opcode (8位) | oparg (8位) |

#define _Py_OPCODE(word) ((word) & 0xFF)
#define _Py_OPARG(word) ((word) >> 8)

EXTENDED_ARG  high_byte
REAL_OPCODE   low_byte

oparg = 0;
while (opcode == EXTENDED_ARG) {
    oparg = (oparg << 8) | next_oparg;
    // 读取下一条指令
}

LOAD_ATTR  oparg
CACHE      entry1
CACHE      entry2
...

typedef struct {
    _Py_CODEUNIT counter;     // 计数器
    _Py_CODEUNIT type_version; // 类型版本
    _Py_CODEUNIT index;       // 属性索引
} _PyLoadAttrCache;

PyObject *
_PyEval_EvalFrameDefault(PyThreadState *tstate,
                         _PyInterpreterFrame *frame,
                         int throwflag)
{
    // 1. 初始化局部变量
    _Py_CODEUNIT *next_instr = frame->instr_ptr;
    _PyStackRef *stack_pointer = frame->stackpointer;
    PyCodeObject *co = (PyCodeObject *)frame->f_executable;

    // 2. 主循环
    for (;;) {
        // 2.1 取指令
        _Py_CODEUNIT word = *next_instr++;
        uint8_t opcode = _Py_OPCODE(word);
        uint8_t oparg = _Py_OPARG(word);

        // 2.2 处理 EXTENDED_ARG
        while (opcode == EXTENDED_ARG) {
            word = *next_instr++;
            opcode = _Py_OPCODE(word);
            oparg = (oparg << 8) | _Py_OPARG(word);
        }

        // 2.3 分发执行
        switch (opcode) {

        case NOP:
            break;

        case LOAD_FAST:
            // 加载局部变量
            value = GETLOCAL(oparg);
            PUSH(value);
            break;

        case STORE_FAST:
            // 存储局部变量
            value = POP();
            SETLOCAL(oparg, value);
            break;

        case LOAD_CONST:
            // 加载常量
            value = GETITEM(co->co_consts, oparg);
            PUSH(value);
            break;

        case BINARY_OP:
            // 二元运算
            right = POP();
            left = POP();
            result = binary_op(left, oparg, right);
            PUSH(result);
            break;

        case RETURN_VALUE:
            // 返回
            retval = POP();
            goto exit_eval_frame;

        // ... 更多指令
        }

        // 2.4 周期性检查
        if (eval_breaker) {
            if (check_periodics(tstate) < 0) {
                goto error;
            }
        }
    }

exit_eval_frame:
    // 清理并返回
    return retval;

error:
    // 异常处理
    return NULL;
}

switch (opcode) {
    case LOAD_FAST: ...
    case STORE_FAST: ...
    ...
}

static void *jump_table[256] = {
    &&TARGET_LOAD_FAST,
    &&TARGET_STORE_FAST,
    ...
};

DISPATCH() {
    goto *jump_table[opcode];
}

TARGET_LOAD_FAST:
    // 指令实现
    DISPATCH();

TARGET_STORE_FAST:
    // 指令实现
    DISPATCH();

// NOP - 无操作
inst(NOP) {
    // 什么都不做
}

// POP_TOP - 弹出栈顶
inst(POP_TOP) {
    PyObject *value = POP();
    Py_DECREF(value);
}

// COPY - 复制栈上元素
inst(COPY, (value -- value, value)) {
    // value 保持在栈上，并复制一份
    Py_INCREF(value);
}

// SWAP - 交换栈上元素
inst(SWAP, (top, bottom -- bottom, top)) {
    // 交换两个栈元素
}

// LOAD_FAST - 加载局部变量
inst(LOAD_FAST, (-- value)) {
    value = GETLOCAL(oparg);
    if (value == NULL) {
        // 未绑定局部变量
        format_exc_check_arg(UnboundLocalError, ...);
        goto error;
    }
}

// STORE_FAST - 存储局部变量
inst(STORE_FAST, (value --)) {
    SETLOCAL(oparg, value);
}

// LOAD_CONST - 加载常量
inst(LOAD_CONST, (-- value)) {
    value = GETITEM(co->co_consts, oparg);
}

// LOAD_GLOBAL - 加载全局变量
family(LOAD_GLOBAL) = {
    LOAD_GLOBAL_MODULE,    // 专用：模块全局
    LOAD_GLOBAL_BUILTIN,   // 专用：内置
};

inst(LOAD_GLOBAL, (-- value, null if (oparg & 1))) {
    // 1. 查找全局命名空间
    value = PyDict_GetItem(GLOBALS(), name);
    if (value == NULL) {
        // 2. 查找内置命名空间
        value = PyDict_GetItem(BUILTINS(), name);
        if (value == NULL) {
            format_exc_check_arg(NameError, ...);
            goto error;
        }
    }
}

// LOAD_ATTR - 加载属性
family(LOAD_ATTR) = {
    LOAD_ATTR_INSTANCE_VALUE,  // 实例属性（共享键）
    LOAD_ATTR_MODULE,          // 模块属性
    LOAD_ATTR_WITH_HINT,       // 带提示
    LOAD_ATTR_SLOT,            // __slots__
    LOAD_ATTR_METHOD,          // 方法
    LOAD_ATTR_PROPERTY,        // property
    LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN,  // 重写 __getattribute__
};

inst(LOAD_ATTR, (owner -- attr, self_or_null if (oparg & 1))) {
    PyObject *name = GETITEM(co->co_names, oparg >> 1);
    attr = PyObject_GetAttr(owner, name);
    if (attr == NULL) goto error;
    Py_DECREF(owner);
}

// 专用版本：实例属性
inst(LOAD_ATTR_INSTANCE_VALUE, (owner -- attr, null)) {
    PyDictObject *dict = (PyDictObject *)owner->ob_dict;
    // 使用缓存的索引直接访问
    attr = dict->ma_values->values[index];
}

// BINARY_OP - 二元运算
family(BINARY_OP) = {
    BINARY_OP_ADD_INT,         // 整数加法
    BINARY_OP_ADD_FLOAT,       // 浮点加法
    BINARY_OP_ADD_UNICODE,     // 字符串连接
    BINARY_OP_MULTIPLY_INT,    // 整数乘法
    BINARY_OP_MULTIPLY_FLOAT,  // 浮点乘法
    // ... 更多专用版本
};

inst(BINARY_OP, (lhs, rhs -- result)) {
    result = binary_ops[oparg](lhs, rhs);
    Py_DECREF(lhs);
    Py_DECREF(rhs);
    if (result == NULL) goto error;
}

// 专用版本：整数加法
inst(BINARY_OP_ADD_INT, (left, right -- result)) {
    // 快速路径：小整数
    if (is_small_int(left) && is_small_int(right)) {
        result = add_small_ints(left, right);
    } else {
        result = PyNumber_Add(left, right);
    }
}

// JUMP_FORWARD - 无条件前向跳转
inst(JUMP_FORWARD) {
    JUMPBY(oparg);
}

// JUMP_BACKWARD - 无条件后向跳转（循环）
inst(JUMP_BACKWARD) {
    _Py_CODEUNIT *next = next_instr - oparg;
    next_instr = next;
    // 检查 eval breaker（后向跳转）
    CHECK_EVAL_BREAKER();
}

// POP_JUMP_IF_FALSE - 条件跳转
inst(POP_JUMP_IF_FALSE, (cond --)) {
    int is_true = PyObject_IsTrue(cond);
    Py_DECREF(cond);
    if (is_true < 0) goto error;
    if (is_true == 0) {
        JUMPBY(oparg);
    }
}

// FOR_ITER - 迭代器循环
inst(FOR_ITER, (iter -- iter, next)) {
    next = (*Py_TYPE(iter)->tp_iternext)(iter);
    if (next == NULL) {
        if (PyErr_Occurred()) {
            if (!PyErr_ExceptionMatches(PyExc_StopIteration)) {
                goto error;
            }
            PyErr_Clear();
        }
        // 迭代结束
        Py_DECREF(iter);
        JUMPBY(oparg);
    }
}

// CALL - 函数调用
family(CALL) = {
    CALL_PY_EXACT_ARGS,        // Python函数，精确参数
    CALL_PY_WITH_DEFAULTS,     // Python函数，带默认值
    CALL_BOUND_METHOD_EXACT_ARGS,  // 绑定方法
    CALL_BUILTIN_O,            // 内置函数，单参数
    CALL_BUILTIN_FAST,         // 内置函数，快速调用
    CALL_METHOD_DESCRIPTOR_O,  // 方法描述符
    // ... 更多专用版本
};

inst(CALL, (callable, args[oparg] -- result)) {
    // 1. 准备参数
    PyObject **args_array = stack_pointer - oparg;

    // 2. 调用
    result = PyObject_Vectorcall(callable, args_array, oparg, NULL);

    // 3. 清理
    Py_DECREF(callable);
    for (int i = 0; i < oparg; i++) {
        Py_DECREF(args_array[i]);
    }

    if (result == NULL) goto error;
}

// 专用版本：Python函数调用（内联）
inst(CALL_PY_EXACT_ARGS, (callable, args[oparg] -- result)) {
    PyFunctionObject *func = (PyFunctionObject *)callable;
    PyCodeObject *code = (PyCodeObject *)func->func_code;

    // 1. 创建新栈帧
    _PyInterpreterFrame *new_frame =
        _PyFrame_PushUnchecked(tstate, func, oparg);

    // 2. 复制参数到新栈帧
    for (int i = 0; i < oparg; i++) {
        new_frame->localsplus[i] = args[i];
    }

    // 3. 切换到新栈帧（内联调用）
    frame = new_frame;
    next_instr = code->co_code_adaptive;
    stack_pointer = _PyFrame_Stackbase(frame);
    goto start_frame;  // 不返回，直接执行
}

// RAISE_VARARGS - 抛出异常
inst(RAISE_VARARGS, (args[oparg] --)) {
    PyObject *exc = NULL, *cause = NULL;

    switch (oparg) {
    case 2:
        cause = args[1];  // from 子句
        // fall through
    case 1:
        exc = args[0];
        break;
    case 0:
        // 重新抛出当前异常
        exc = get_current_exception(tstate);
        break;
    }

    do_raise(tstate, exc, cause);
    goto error;
}

// PUSH_EXC_INFO - 推入异常信息
inst(PUSH_EXC_INFO, (new_exc -- prev_exc, new_exc)) {
    prev_exc = tstate->exc_info->exc_value;
    tstate->exc_info->exc_value = new_exc;
}

// CHECK_EXC_MATCH - 检查异常匹配
inst(CHECK_EXC_MATCH, (left, right -- left, result)) {
    // 检查 left 是否是 right 的实例
    result = PyErr_GivenExceptionMatches(left, right) ? Py_True : Py_False;
}

typedef struct {
    _Py_CODEUNIT counter;      // 执行计数
    _Py_CODEUNIT type_version; // 类型版本
    _Py_CODEUNIT index;        // 字典索引
    _Py_CODEUNIT unused;       // 对齐
} _PyLoadAttrCache;

inst(LOAD_ATTR_INSTANCE_VALUE, (owner -- attr, null)) {
    // 获取缓存
    _PyLoadAttrCache *cache = (_PyLoadAttrCache *)next_instr;

    // 1. 检查类型版本
    PyTypeObject *tp = Py_TYPE(owner);
    if (tp->tp_version_tag != cache->type_version) {
        // 缓存失效，回退到通用版本
        goto deopt;
    }

    // 2. 使用缓存的索引直接访问
    PyDictObject *dict = (PyDictObject *)owner->__dict__;
    PyObject **values = dict->ma_values->values;
    attr = values[cache->index];

    // 3. 跳过缓存条目
    next_instr += sizeof(_PyLoadAttrCache) / sizeof(_Py_CODEUNIT);
}

flowchart LR
    A[通用指令] --> B[执行计数]
    B --> C{达到阈值?}
    C -->|否| A
    C -->|是| D[分析运行时类型]
    D --> E{可特化?}
    E -->|是| F[替换为专用指令]
    E -->|否| G[标记为不可特化]
    F --> H[快速执行]
    G --> A

# 原始代码
x = a + b

# 字节码（初始）
BINARY_OP  0 (ADD)

# 执行几次后，如果 a 和 b 总是 int
# 替换为：
BINARY_OP_ADD_INT

# 如果是 float
BINARY_OP_ADD_FLOAT

# 如果是 str
BINARY_OP_ADD_UNICODE

通用版本：100ns
专用 int：20ns
专用 float：25ns
专用 str：30ns

inst(BINARY_OP) {
    // 检查计数器
    _PyBinaryOpCache *cache = (_PyBinaryOpCache *)next_instr;
    if (cache->counter-- == 0) {
        // 尝试特化
        _Py_Specialize_BinaryOp(left, right, oparg, next_instr);
    }

    // 执行通用版本
    result = PyNumber_BinaryOp(left, oparg, right);
}

Tier 1: 字节码解释器（默认）
         ↓ 检测热点
Tier 2: 微指令（μops）优化器
         ↓ 转换
Trace: 优化的微指令序列
         ↓ 可选
JIT: 机器码（未来）

# Python 代码
def fib(n):
    if n <= 1:
        return 1
    return fib(n-1) + fib(n-2)

# Tier 1 字节码
LOAD_FAST n
LOAD_CONST 1
COMPARE_OP <=
POP_JUMP_IF_FALSE label
LOAD_CONST 1
RETURN_VALUE
label:
...

# Tier 2 Trace（假设 n > 1）
_LOAD_FAST n
_LOAD_CONST 1
_GUARD_NOT_TRUE  // 假设条件为 False
_LOAD_GLOBAL fib
_LOAD_FAST n
_LOAD_CONST 1
_BINARY_OP_SUBTRACT_INT
_CALL_PY_EXACT_ARGS
...

import sys
sys._setopt('optimize', 2)  # 启用 Tier 2

// 异常表条目
typedef struct {
    int start;      // 起始偏移
    int end;        // 结束偏移
    int target;     // 处理器偏移
    int depth;      // 栈深度
    bool lasti;     // 是否保存 lasti
} ExceptionTableEntry;

def foo():
    try:           # start=0
        x = 1/0
    except ZeroDivisionError:  # target=10
        print("error")
    # end=5

| start | end | target | depth | lasti |
|-------|-----|--------|-------|-------|
|   0   |  5  |   10   |   0   |  yes  |

// 异常发生
error:
    // 1. 获取当前异常
    PyObject *exc = PyErr_GetRaisedException();

    // 2. 查找异常表
    int offset = (next_instr - co->co_code_adaptive);
    ExceptionTableEntry *entry = find_exception_handler(
        co->co_exceptiontable, offset);

    if (entry != NULL) {
        // 3. 找到处理器
        // 3.1 调整栈深度
        while (stack_pointer > stack_base + entry->depth) {
            Py_DECREF(POP());
        }

        // 3.2 推入异常信息
        PUSH(exc);

        // 3.3 跳转到处理器
        next_instr = co->co_code_adaptive + entry->target;
        goto start_frame;
    } else {
        // 4. 未找到处理器，传播到上层
        frame = frame->previous;
        if (frame == NULL) {
            // 顶层，终止程序
            PyErr_Display(exc);
            return NULL;
        }
        // 继续在上层查找
        goto error;
    }

try:
    x = 1/0
finally:
    cleanup()

// eval_breaker 是位掩码
#define _PY_SIGNAL_PENDING     (1 << 0)  // 信号待处理
#define _PY_GIL_DROP_REQUEST   (1 << 1)  // GIL释放请求
#define _PY_ASYNC_EXCEPTION    (1 << 2)  // 异步异常
#define _PY_PENDING_CALL       (1 << 3)  // 待处理调用
#define _PY_GC_PENDING         (1 << 4)  // GC请求
#define _PY_EVAL_TRACING       (1 << 5)  // 追踪模式

// 后向跳转（循环）
inst(JUMP_BACKWARD) {
    JUMPBY(-oparg);
    CHECK_EVAL_BREAKER();  // 每次循环都检查
}

// 函数调用后
inst(CALL) {
    result = PyObject_Call(callable, args, kwargs);
    CHECK_EVAL_BREAKER();  // 调用后检查
}

// RESUME 指令（函数入口）
inst(RESUME) {
    CHECK_EVAL_BREAKER();
}

int check_periodics(PyThreadState *tstate)
{
    uintptr_t eval_breaker = tstate->eval_breaker;

    // 1. 信号处理（仅主线程）
    if (eval_breaker & _PY_SIGNAL_PENDING) {
        if (PyErr_CheckSignals() < 0) {
            return -1;
        }
    }

    // 2. GIL 释放请求
    if (eval_breaker & _PY_GIL_DROP_REQUEST) {
        drop_gil(tstate);
        // 等待其他线程
        take_gil(tstate);
    }

    // 3. 异步异常
    if (eval_breaker & _PY_ASYNC_EXCEPTION) {
        PyObject *exc = tstate->async_exc;
        tstate->async_exc = NULL;
        PyErr_SetRaisedException(exc);
        return -1;
    }

    // 4. 待处理调用
    if (eval_breaker & _PY_PENDING_CALL) {
        if (make_pending_calls(tstate) < 0) {
            return -1;
        }
    }

    // 5. GC
    if (eval_breaker & _PY_GC_PENDING) {
        _PyGC_Collect(tstate);
    }

    return 0;
}

x = a + b

LOAD_FAST    0 (a)
LOAD_FAST    1 (b)
BINARY_OP    0 (ADD)
STORE_FAST   2 (x)

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

result = add(1, 2)

LOAD_GLOBAL  0 (add)
LOAD_CONST   1 (1)
LOAD_CONST   2 (2)
CALL         2
STORE_FAST   0 (result)

# 默认限制
import sys
print(sys.getrecursionlimit())  # 1000

# 修改限制
sys.setrecursionlimit(2000)

int _Py_EnterRecursiveCallTstate(PyThreadState *tstate, const char *where)
{
    if (--tstate->py_recursion_remaining <= 0) {
        tstate->py_recursion_remaining += 50;  // 留余地处理异常
        _PyErr_Format(tstate, PyExc_RecursionError,
                      "maximum recursion depth exceeded%s", where);
        tstate->py_recursion_remaining -= 50;
        return -1;
    }
    return 0;
}

def deep_expr():
    return (((((1)))))  # 深度嵌套表达式

// Python/compile.c
int stackdepth(struct compiler *c)
{
    // 遍历 CFG，计算最大栈深度
    for (basicblock *b : cfg) {
        int depth = simulate_block(b);
        maxdepth = max(maxdepth, depth);
    }
    return maxdepth;
}

import dis

def foo(x):
    return x + 1

dis.dis(foo)

  2           0 LOAD_FAST                0 (x)
              2 LOAD_CONST               1 (1)
              4 BINARY_OP                0 (+)
              8 RETURN_VALUE

# 编译时启用调试
./configure --with-pydebug
make

# 运行时启用追踪
python -d script.py  # 详细日志

import sys

# 启用统计
sys._setopt('stats', 1)

# 运行代码
...

# 查看统计
sys._getstats()

// Python/ceval.c

PyObject* _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int throwflag)
{
    _Py_CODEUNIT *next_instr;
    PyObject **stack_pointer;

    // 初始化
    next_instr = frame->prev_instr + 1;
    stack_pointer = _PyFrame_GetStackPointer(frame);

    // 主解释循环
    for (;;) {
        _Py_CODEUNIT word = *next_instr++;
        int opcode = _Py_OPCODE(word);
        int oparg = _Py_OPARG(word);

        // 指令分发
        switch (opcode) {
        case LOAD_FAST: {
            PyObject *value = GETLOCAL(oparg);
            if (value == NULL) {
                format_exc_check_arg(tstate, PyExc_UnboundLocalError, ...);
                goto error;
            }
            Py_INCREF(value);
            PUSH(value);
            DISPATCH();
        }

        case STORE_FAST: {
            PyObject *value = POP();
            SETLOCAL(oparg, value);
            DISPATCH();
        }

        case BINARY_OP: {
            PyObject *rhs = POP();
            PyObject *lhs = TOP();
            PyObject *res = _PyEval_BinaryOps[oparg](lhs, rhs);
            SET_TOP(res);
            Py_DECREF(lhs);
            Py_DECREF(rhs);
            if (res == NULL) goto error;
            DISPATCH();
        }

        case CALL: {
            PyObject **args = stack_pointer - oparg - 1;
            PyObject *callable = args[-1];
            PyObject *res = _PyObject_Vectorcall(callable, args, oparg, NULL);
            if (res == NULL) goto error;
            stack_pointer = args;
            PUSH(res);
            DISPATCH();
        }

        // ... 更多指令
        }
    }
}

sequenceDiagram
    autonumber
    participant Call as 函数调用
    participant Eval as _PyEval_EvalFrameDefault
    participant Frame as 栈帧
    participant Stack as 值栈
    participant Instr as 指令

    Call->>Eval: 执行代码对象
    Eval->>Frame: 创建/初始化栈帧
    Frame->>Stack: 初始化值栈

    loop 解释循环
        Eval->>Instr: 获取下一条指令
        Instr-->>Eval: opcode + oparg

        alt LOAD指令
            Eval->>Frame: 从局部变量加载
            Frame-->>Stack: 压入值
        else STORE指令
            Stack-->>Eval: 弹出值
            Eval->>Frame: 存储到局部变量
        else BINARY_OP
            Stack-->>Eval: 弹出2个操作数
            Eval->>Eval: 执行操作
            Eval-->>Stack: 压入结果
        else CALL
            Stack-->>Eval: 弹出参数和callable
            Eval->>Call: 递归调用
            Call-->>Stack: 压入返回值
        end

        Eval->>Eval: DISPATCH()
    end

    Eval-->>Call: 返回结果

// Python/ceval.c (约1023行起)

PyObject* _PyEval_EvalFrameDefault(
    PyThreadState *tstate,        // 线程状态
    _PyInterpreterFrame *frame,   // 待执行的栈帧
    int throwflag                 // 是否抛出异常
)

PyObject* _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int throwflag)
{
    // 1. 检查递归深度
    if (_Py_EnterRecursiveCallTstate(tstate, "")) {
        _PyEval_FrameClearAndPop(tstate, frame);
        return NULL;
    }

    // 2. 初始化局部变量（寄存器化优化）
    _Py_CODEUNIT *next_instr;           // 下一条指令指针
    _PyStackRef *stack_pointer;          // 值栈指针

    // 3. 创建入口帧（用于异常处理）
    _PyEntryFrame entry;
    entry.frame.previous = tstate->current_frame;
    frame->previous = &entry.frame;
    tstate->current_frame = frame;

    // 4. 检查是否有Tier 2执行器（JIT优化）
    #ifdef _Py_TIER2
    if (tstate->current_executor != NULL) {
        // 执行JIT编译的代码
        PyObject *res = _PyJIT_ExecuteTrace(tstate, frame);
        if (res != NULL) {
            _Py_LeaveRecursiveCallTstate(tstate);
            return res;
        }
    }
    #endif

    // 5. 初始化指令指针和栈指针
    PyCodeObject *co = _PyFrame_GetCode(frame);
    next_instr = _PyCode_CODE(co);
    stack_pointer = _PyFrame_Stackbase(frame);

    // 6. 主解释循环
    #if USE_COMPUTED_GOTOS
        // 使用computed goto优化（GCC/Clang）
        void **opcode_targets = opcode_targets_table;
        #define DISPATCH() goto *opcode_targets[opcode]
    #else
        // 标准switch-case
        #define DISPATCH() continue
    #endif

    for (;;) {
        // 6.1 获取当前指令
        _Py_CODEUNIT word = *next_instr++;
        uint8_t opcode = _Py_OPCODE(word);
        int oparg = _Py_OPARG(word);

        // 6.2 周期性检查（信号、GIL释放、线程切换）
        if (_Py_atomic_load_relaxed_int32(&tstate->interp->ceval.eval_breaker)) {
            if (eval_frame_handle_pending(tstate) != 0) {
                goto error;
            }
        }

        // 6.3 指令分发
        switch (opcode) {

        // === 变量加载指令 ===
        case LOAD_FAST: {
            _PyStackRef value = GETLOCAL(oparg);
            if (PyStackRef_IsNull(value)) {
                _PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError,
                    UNBOUNDLOCAL_ERROR_MSG,
                    PyTuple_GetItem(co->co_localsplusnames, oparg));
                goto error;
            }
            stack_pointer[0] = PyStackRef_Dup(value);
            stack_pointer++;
            DISPATCH();
        }

        case LOAD_CONST: {
            PyObject *value = PyTuple_GET_ITEM(co->co_consts, oparg);
            stack_pointer[0] = PyStackRef_FromPyObjectNew(value);
            stack_pointer++;
            DISPATCH();
        }

        case LOAD_GLOBAL: {
            // 支持内联缓存优化
            PyObject *name = PyTuple_GET_ITEM(co->co_names, oparg);
            PyObject *v = NULL;

            // 尝试从内联缓存加载
            _Py_CODEUNIT *cache = next_instr;
            uint32_t version = cache[0].cache;
            if (version == GLOBALS()->ma_version_tag) {
                // 缓存命中
                v = (PyObject *)cache[1].cache;
                Py_INCREF(v);
            }
            else {
                // 缓存未命中，从字典查找
                v = PyDict_GetItemWithError(GLOBALS(), name);
                if (v == NULL) {
                    v = PyDict_GetItemWithError(BUILTINS(), name);
                    if (v == NULL) {
                        _PyEval_FormatExcCheckArg(tstate, PyExc_NameError,
                            NAME_ERROR_MSG, name);
                        goto error;
                    }
                }
                Py_INCREF(v);

                // 更新缓存
                cache[0].cache = GLOBALS()->ma_version_tag;
                cache[1].cache = (uintptr_t)v;
            }

            stack_pointer[0] = PyStackRef_FromPyObjectSteal(v);
            stack_pointer++;
            next_instr += 2;  // 跳过缓存条目
            DISPATCH();
        }

        // === 变量存储指令 ===
        case STORE_FAST: {
            _PyStackRef v = stack_pointer[-1];
            SETLOCAL(oparg, v);
            stack_pointer--;
            DISPATCH();
        }

        case STORE_GLOBAL: {
            PyObject *name = PyTuple_GET_ITEM(co->co_names, oparg);
            _PyStackRef v = stack_pointer[-1];
            int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v));
            PyStackRef_CLOSE(v);
            stack_pointer--;
            if (err != 0) goto error;
            DISPATCH();
        }

        // === 二元运算指令 ===
        case BINARY_OP: {
            _PyStackRef rhs = stack_pointer[-1];
            _PyStackRef lhs = stack_pointer[-2];
            PyObject *res;

            // 根据oparg选择操作
            switch (oparg) {
            case NB_ADD:
                res = PyNumber_Add(
                    PyStackRef_AsPyObjectBorrow(lhs),
                    PyStackRef_AsPyObjectBorrow(rhs)
                );
                break;
            case NB_SUBTRACT:
                res = PyNumber_Subtract(
                    PyStackRef_AsPyObjectBorrow(lhs),
                    PyStackRef_AsPyObjectBorrow(rhs)
                );
                break;
            case NB_MULTIPLY:
                res = PyNumber_Multiply(
                    PyStackRef_AsPyObjectBorrow(lhs),
                    PyStackRef_AsPyObjectBorrow(rhs)
                );
                break;
            // ... 其他操作
            }

            PyStackRef_CLOSE(lhs);
            PyStackRef_CLOSE(rhs);
            if (res == NULL) goto error;

            stack_pointer[-2] = PyStackRef_FromPyObjectSteal(res);
            stack_pointer--;
            DISPATCH();
        }

        // === 函数调用指令 ===
        case CALL: {
            int total_args = oparg;
            _PyStackRef *args = stack_pointer - total_args - 1;
            _PyStackRef callable_ref = args[-1];
            PyObject *callable = PyStackRef_AsPyObjectBorrow(callable_ref);

            // 快速路径：Python函数
            if (PyFunction_Check(callable)) {
                PyFunctionObject *func = (PyFunctionObject *)callable;
                PyCodeObject *func_code = (PyCodeObject *)func->func_code;

                // 创建新栈帧
                _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit(
                    tstate, func, NULL, args, total_args, NULL
                );

                if (new_frame == NULL) {
                    goto error;
                }

                // 保存当前状态
                _PyFrame_SetStackPointer(frame, stack_pointer);
                frame->instr_ptr = next_instr;

                // 切换到新栈帧
                frame = new_frame;
                tstate->current_frame = frame;

                // 重新加载寄存器
                co = func_code;
                next_instr = _PyCode_CODE(co);
                stack_pointer = _PyFrame_Stackbase(frame);

                goto start_frame;
            }

            // 慢速路径：使用通用调用
            PyObject *res = _PyObject_Vectorcall(
                callable,
                (PyObject **)args,
                total_args,
                NULL
            );

            // 清理参数
            for (int i = 0; i <= total_args; i++) {
                PyStackRef_CLOSE(args[i - 1]);
            }

            if (res == NULL) goto error;

            stack_pointer = args - 1;
            stack_pointer[0] = PyStackRef_FromPyObjectSteal(res);
            stack_pointer++;
            DISPATCH();
        }

        // === 控制流指令 ===
        case RETURN_VALUE: {
            _PyStackRef retval = stack_pointer[-1];
            stack_pointer--;

            // 恢复上一个栈帧
            _PyInterpreterFrame *prev = frame->previous;
            _PyEvalFrameClearAndPop(tstate, frame);

            if (prev == &entry.frame) {
                // 返回到C调用者
                _Py_LeaveRecursiveCallTstate(tstate);
                return PyStackRef_AsPyObjectSteal(retval);
            }

            // 返回到Python调用者
            frame = prev;
            tstate->current_frame = frame;

            // 恢复寄存器
            co = _PyFrame_GetCode(frame);
            next_instr = frame->instr_ptr;
            stack_pointer = _PyFrame_GetStackPointer(frame);

            // 将返回值压栈
            stack_pointer[0] = retval;
            stack_pointer++;
            DISPATCH();
        }

        case POP_JUMP_IF_FALSE: {
            _PyStackRef cond = stack_pointer[-1];
            int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(cond));
            PyStackRef_CLOSE(cond);
            stack_pointer--;

            if (err > 0) {
                // 条件为真，继续执行
            }
            else if (err == 0) {
                // 条件为假，跳转
                next_instr = _PyCode_CODE(co) + oparg;
            }
            else {
                // 发生错误
                goto error;
            }
            DISPATCH();
        }

        // === 异常处理指令 ===
        case RAISE_VARARGS: {
            PyObject *cause = NULL, *exc = NULL;

            switch (oparg) {
            case 2:
                cause = PyStackRef_AsPyObjectSteal(stack_pointer[-1]);
                // fallthrough
            case 1:
                exc = PyStackRef_AsPyObjectSteal(stack_pointer[-2]);
                break;
            default:
                PyErr_SetString(PyExc_SystemError, "bad RAISE_VARARGS oparg");
                goto error;
            }

            stack_pointer -= oparg;

            if (do_raise(tstate, exc, cause) < 0) {
                goto exception_unwind;
            }
            goto error;
        }

        default:
            // 未知指令
            PyErr_Format(PyExc_SystemError,
                "unknown opcode %d", opcode);
            goto error;
        }

    start_frame:
        // 新栈帧开始执行
        if (_Py_EnterRecursivePy(tstate) < 0) {
            goto exit_unwind;
        }
        DISPATCH();

    error:
        // 错误处理
        exception_unwind:
        {
            // 查找异常处理器
            while (frame != &entry.frame) {
                if (_PyFrame_IsEntryFrame(frame)) {
                    break;
                }

                PyObject *exc = _PyErr_GetRaisedException(tstate);
                _Py_CODEUNIT *handler = _PyFrame_GetExceptHandler(frame);

                if (handler != NULL) {
                    // 找到异常处理器
                    next_instr = handler;
                    stack_pointer = _PyFrame_Stackbase(frame);

                    // 压入异常对象
                    stack_pointer[0] = PyStackRef_FromPyObjectSteal(exc);
                    stack_pointer++;

                    DISPATCH();
                }

                // 当前帧无处理器，返回上一帧
                _PyInterpreterFrame *prev = frame->previous;
                _PyEvalFrameClearAndPop(tstate, frame);
                frame = prev;
                tstate->current_frame = frame;

                _PyErr_SetRaisedException(tstate, exc);
            }

            // 未找到处理器，传播异常
            goto exit_unwind;
        }

    exit_unwind:
        // 清理并退出
        _Py_LeaveRecursiveCallTstate(tstate);
        return NULL;
    }
}

// Include/internal/pycore_interpframe_structs.h

struct _PyInterpreterFrame {
    // 可执行对象（代码对象或None）
    _PyStackRef f_executable;

    // 指向上一个栈帧
    struct _PyInterpreterFrame *previous;

    // 函数对象（延迟或强引用）
    _PyStackRef f_funcobj;

    // 全局变量字典（借用引用）
    PyObject *f_globals;

    // 内置变量字典（借用引用）
    PyObject *f_builtins;

    // 局部变量字典（强引用，可为NULL）
    PyObject *f_locals;

    // 帧对象（用于调试）
    PyFrameObject *frame_obj;

    // 当前执行的指令指针
    _Py_CODEUNIT *instr_ptr;

    // 值栈指针
    _PyStackRef *stackpointer;

    #ifdef Py_GIL_DISABLED
    // 线程本地字节码索引
    int32_t tlbc_index;
    #endif

    // 返回偏移量
    uint16_t return_offset;

    // 帧所有者标志
    char owner;

    // 访问标志
    uint8_t visited;

    // 局部变量和值栈（可变长度数组）
    _PyStackRef localsplus[1];
};

// Python/ceval.c

#if USE_COMPUTED_GOTOS
// GCC/Clang支持的computed goto优化
#include "opcode_targets.h"

// 跳转表
static void *opcode_targets[256] = {
    &&TARGET_LOAD_FAST,
    &&TARGET_LOAD_CONST,
    &&TARGET_STORE_FAST,
    // ...
};

#define DISPATCH() goto *opcode_targets[opcode]

// 主循环
dispatch_opcode:
    opcode = *next_instr++;
    goto *opcode_targets[opcode];

TARGET_LOAD_FAST:
    // 处理LOAD_FAST
    DISPATCH();

TARGET_LOAD_CONST:
    // 处理LOAD_CONST
    DISPATCH();

#else
// 标准switch-case
#define DISPATCH() goto dispatch_opcode

dispatch_opcode:
    opcode = *next_instr++;
    switch (opcode) {
    case LOAD_FAST:
        // 处理
        DISPATCH();
    case LOAD_CONST:
        // 处理
        DISPATCH();
    }
#endif

// Python/ceval.c - LOAD_GLOBAL优化

case LOAD_GLOBAL: {
    // 缓存布局：
    // [version_tag] [cached_value]
    _Py_CODEUNIT *cache = next_instr;
    uint32_t version = cache[0].cache;

    PyObject *name = PyTuple_GET_ITEM(co->co_names, oparg);
    PyDictObject *globals = (PyDictObject *)frame->f_globals;

    // 检查版本
    if (version == globals->ma_version_tag) {
        // 缓存命中
        PyObject *value = (PyObject *)cache[1].cache;
        Py_INCREF(value);
        PUSH(PyStackRef_FromPyObjectNew(value));
        next_instr += 2;  // 跳过缓存
        DISPATCH();
    }

    // 缓存未命中，常规查找
    PyObject *value = _PyDict_LoadGlobal(globals, BUILTINS(), name);
    if (value == NULL) {
        goto error;
    }

    // 更新缓存
    cache[0].cache = globals->ma_version_tag;
    cache[1].cache = (uintptr_t)value;

    PUSH(PyStackRef_FromPyObjectNew(value));
    next_instr += 2;
    DISPATCH();
}

// Python/ceval.c - LOAD_ATTR优化

case LOAD_ATTR: {
    // 缓存布局：
    // [version_tag] [dict_offset] [index]
    _Py_CODEUNIT *cache = next_instr;

    _PyStackRef owner_ref = stack_pointer[-1];
    PyObject *owner = PyStackRef_AsPyObjectBorrow(owner_ref);
    PyTypeObject *tp = Py_TYPE(owner);

    // 检查类型版本
    if (cache[0].cache == tp->tp_version_tag) {
        // 缓存命中 - 直接从字典获取
        PyDictObject *dict = *(PyDictObject **)
            ((char *)owner + cache[1].cache);

        if (dict != NULL) {
            PyDictKeysObject *keys = dict->ma_keys;
            Py_ssize_t index = cache[2].cache;

            if (index < keys->dk_nentries) {
                PyObject *value = keys->dk_entries[index].me_value;
                if (value != NULL) {
                    Py_INCREF(value);
                    stack_pointer[-1] = PyStackRef_FromPyObjectSteal(value);
                    PyStackRef_CLOSE(owner_ref);
                    next_instr += 3;
                    DISPATCH();
                }
            }
        }
    }

    // 缓存未命中或过期，使用常规路径
    PyObject *name = PyTuple_GET_ITEM(co->co_names, oparg);
    PyObject *res = PyObject_GetAttr(owner, name);

    PyStackRef_CLOSE(owner_ref);
    if (res == NULL) goto error;

    // 更新缓存（如果可能）
    if (PyType_HasFeature(tp, Py_TPFLAGS_VALID_VERSION_TAG)) {
        cache[0].cache = tp->tp_version_tag;
        // 设置dict_offset和index...
    }

    stack_pointer[-1] = PyStackRef_FromPyObjectSteal(res);
    next_instr += 3;
    DISPATCH();
}