python源码剖析-字节码和虚拟机

发表于 2016-11-13 | 分类于 python源码剖析 |

Python会将代码先编译成字节码，然后在虚拟机中动态得依次解释执行字节码。编译好的字节码存储在硬盘中以.pyc、.pyd等为扩展名。而在运行态，这些字节码会作为Python的一种对象PyCodeObject存在。PyCodeObject可以理解为C语言中的文本段，用于存储编译后的字节码、调试信息、常量值、变量名等。

本文不会讲述代码如何一步步编译成PyCodeObject，只会简单介绍PyCodeObject中各个域的含义，而把重点放在介绍Python的虚拟机和执行流。

Python中的伪码PyCodeObject

PyCodeObject保存代编译后的静态信息，在运行时再结合上下文形成一个完整的运行态环境。让我们看看静态编译后的信息都有哪些。

typedef struct {

PyObject_HEAD

int co_argcount; // co_argcount 参数，不包括不定参数

int co_nlocals; // co_nlocals 变量个数，co_argcount +

// 可变参数个数 + co_kwonlyargcount(py3.0) + 局部变量个数

int co_stacksize; // 栈的大小 (编译后需要的最大栈深度)

int co_flags; // PyCodeObject的一些标志位，用来优化运行时的性能

PyObject *co_code; // 编译后的字节码字符串

PyObject *co_consts; // 常量的列表

PyObject *co_names; // 常量中的字符串对象

PyObject *co_varnames; // 变量名字的元组

PyObject *co_freevars; // 自由变量的元组

PyObject *co_cellvars; // cell变量的元组

/* The rest doesn‘t count for hash/cmp */

PyObject *co_filename; // 文件名

PyObject *co_name; // 对象的名字，例如函数的名字、类的名字等

int co_firstlineno; // 对应的代码在源码文件中的起始行号

PyObject *co_lnotab; // 伪码与行号的映射

void *co_zombieframe; // 对于一些特殊情况下的优化

PyObject *co_weakreflist; // 支持弱引用

} PyCodeObject;

其中有些域需要特别解释。

co_flags 用来保存一些编译信息，主要用于优化工作。例如co_VARARGS(0x0004)表示有可变参数等，具体见code.h文件。
co_freevars 自由变量是一些在作用域内使用，但是没有在本作用域定义的变量。
co_cellvars 当前作用域定义，而在闭包等内部使用的变量。
co_lnotab 字节码的偏移值与对应的源码的行号的相对值。

字节码在co_code中的偏移值真实行号行号的偏移值

0 1 0

6 2 1

50 7 5

那么实际上co_lnotab记录的是(0, 0), (6, 1), (44, 5)，当然实际记录中没有括号。具体偏移值和真实行号的对应关系可以通过下面的算法计算出来。

// codeobject.c

int

PyCode_Addr2Line(PyCodeObject *co, int addrq)

{

int size = PyString_Size(co->co_lnotab) / 2;

unsigned char *p = (unsigned char*)PyString_AsString(co->co_lnotab);

int line = co->co_firstlineno;

int addr = 0;

while (--size >= 0) {

addr += *p++;

if (addr > addrq)

break;

line += *p++;

}

return line;

}

co_code 记录编译后的字节码，以字符串的形式保存，而实际上就是数字。后面我们通过一个例子详细描述。

PyCodeObject的示例

先给定一个Python代码示例，然后打印出其中的各个域。

from __future__ import print_function

import dis

def out(a, b=1, *args, **kwargs):

c = 2

def inner(d, e=3, *iargs, **ikwargs):

f = 4

g = c

print(‘inner-->co_argcount :‘, inner.__code__.co_argcount)

# print(‘inner-->co_kwonlyargcount :‘, inner.__code__.co_kwonlyargcount)

print(‘inner-->co_nlocals :‘, inner.__code__.co_nlocals)

print(‘inner-->co_stacksize :‘, inner.__code__.co_stacksize)

print(‘inner-->co_flags :‘, inner.__code__.co_flags)

print(‘inner-->co_code :‘, inner.__code__.co_code)

print(‘inner-->co_consts :‘, inner.__code__.co_consts)

print(‘inner-->co_names :‘, inner.__code__.co_names)

print(‘inner-->co_varnames :‘, inner.__code__.co_varnames)

print(‘inner-->co_freevars :‘, inner.__code__.co_freevars)

print(‘inner-->co_cellvars :‘, inner.__code__.co_cellvars)

print(‘inner-->co_filename :‘, inner.__code__.co_filename)

print(‘inner-->co_name :‘, inner.__code__.co_name)

print(‘inner-->co_firstlineno :‘, inner.__code__.co_firstlineno)

print(‘inner-->co_lnotab :‘, inner.__code__.co_lnotab)

print(‘out-->co_argcount :‘, out.__code__.co_argcount)

#print(‘out-->co_kwonlyargcount :‘, out.__code__.co_kwonlyargcount)

print(‘out-->co_nlocals :‘, out.__code__.co_nlocals)

print(‘out-->co_stacksize :‘, out.__code__.co_stacksize)

print(‘out-->co_flags :‘, out.__code__.co_flags)

print(‘out-->co_code :‘, out.__code__.co_code)

print(‘out-->co_consts :‘, out.__code__.co_consts)

print(‘out-->co_names :‘, out.__code__.co_names)

print(‘out-->co_varnames :‘, out.__code__.co_varnames)

print(‘out-->co_freevars :‘, out.__code__.co_freevars)

print(‘out-->co_cellvars :‘, out.__code__.co_cellvars)

print(‘out-->co_filename :‘, out.__code__.co_filename)

print(‘out-->co_name :‘, out.__code__.co_name)

print(‘out-->co_firstlineno :‘, out.__code__.co_firstlineno)

print(‘out-->co_lnotab :‘, out.__code__.co_lnotab)

print(‘=========================================================‘)

out(1, 2, 3, 4, 5, 6, 7, e = 8, f = 9)

print()

print(‘disamble:‘)

print(dis.dis(out))

需要先解释一下co_kwonlyargcount，这个域在PY3才有，用于支持在不定参数后定义的位置参数，例如def func(*args, kwonly=None)。

这个实例的输出可以看到对应的各个域的详细内容。

out-->co_argcount : 2 # a, b

out-->co_nlocals : 5 # a, b, c, d, e

out-->co_stacksize : 3

out-->co_flags : 65551 # b‘0b10000000000001111‘ CO_FUTURE_PRINT_FUNCTION|CO_VARKEYWORDS|CO_VARARGS|CO_NEWLOCALS|CO_OPTIMIZED

out-->co_code : ddfd}t... # 部分省略，后续分析

out-->co_consts : (None, 2, 3, <code object inner>, ‘inner-->co_argcount :‘, # 省略其他‘inner-->‘) # 常量值，这里添加了默认返回值None

out-->co_names : (‘print‘, ‘__code__‘, ‘co_argcount‘, ‘co_nlocals‘, ‘co_stacksize‘, ‘co_flags‘, ‘co_code‘, ‘co_consts‘, ‘co_names‘, ‘co_varnames‘, ‘co_freevars‘,‘co_cellvars‘, ‘co_filename‘, ‘co_name‘, ‘co_firstlineno‘, ‘co_lnotab‘) # 常量名

out-->co_varnames : (‘a‘, ‘b‘, ‘args‘, ‘kwargs‘, ‘inner‘) # 变量名字，包括参数变量和内部变量

out-->co_freevars : () # 无

out-->co_cellvars : (‘c‘,) # 用于给子作用域使用的变量

out-->co_filename : pycode.py

out-->co_name : out

out-->co_firstlineno : 3 # 起始行号

out-->co_lnotab : # 省略

=========================================================

inner-->co_argcount : 2 # d, e

inner-->co_nlocals : 6 # d, e, iargs, ikwargs, f, g

inner-->co_stacksize : 1 #

inner-->co_code : d}}dS # 省略

inner-->co_consts : (None, 4) # 常量

inner-->co_names : () #

inner-->co_varnames : (‘d‘, ‘e‘, ‘iargs‘, ‘ikwargs‘, ‘f‘, ‘g‘) # 变量名字

inner-->co_freevars : (‘c‘,) # 自由变量，引用的父作用域的变量

inner-->co_cellvars : () # 无

inner-->co_filename : pycode.py

inner-->co_name : inner

inner-->co_firstlineno : 6 # 起始行号

inner-->co_lnotab : # 省略

从这个例子中可以清楚了解常量、变量、自由变量以及cell变量的含义。接下来我们看下co_code的含义，使用linux的xdd工具将其转换成十六进制，并且使用dis模块反编译其字节码。

import dis

def out(a, b=1, *args, **kwargs):

c = 2

def inner(d, e=3, *iargs, **ikwargs):

f = 4

g = c

print out.__code__.co_code

dis.dis(out)

# co_code的十六进制内容

0000000: 6401 0089 0000 6402 0087 0000 6601 0064 d.....d.....f..d

0000010: 0300 8601 007d 0400 6400 0053 0a .....}..d..S.

# 字节码的反编译

4 0 LOAD_CONST 1 (2)

3 STORE_DEREF 0 (c)

6 6 LOAD_CONST 2 (3)

9 LOAD_CLOSURE 0 (c)

12 BUILD_TUPLE 1

15 LOAD_CONST 3 (<code object inner at 00000000039E69B0, file "<ipython-input-2-656e8bface8a>", line 6>)

18 MAKE_CLOSURE 1

21 STORE_FAST 4 (inner)

24 LOAD_CONST 0 (None)

27 RETURN_VALUE

十六进制的第一个为64值100，查阅opcode.h可以看到起对应的字节码#define LOAD_CONST 100，与反编译中的命令LOAD_CONST相符。
十六进制的第二个为01值01，对应的是字节码LOAD_CONST的参数1。
十六进制的第三个为00值00，此值表示STOP_CDOE，一个完整字节码的结束标志。

同理可以解析接下来的字节码和对应的操作的含义。至此，我们明白字节码的格式为

1	字节码指令编号(64) 多个参数值(1) 结束标志(00)

到现在为止我们明白了字节码的数据结构、各域值的含义，co_code字节码的格式以及如何与操作命令对应。下面我们看看这些字节码如何运行。

PyFrameObject

Python模拟了C语言中的运行栈作为运行时的环境，每个栈用PyFrameObject结构表示。

typedef struct _frame {

PyObject_VAR_HEAD

struct _frame *f_back; // 前一个运行栈，调用方

PyCodeObject *f_code; // 执行的PyCodeObject对象

PyObject *f_builtins; // builtins环境变量集合

PyObject *f_globals; // globals全局变量集合

PyObject *f_locals; // locals本地变量集合

PyObject **f_valuestack; // 栈起始地址，最后一个本地变量之后

PyObject **f_stacktop; // 栈针位置，指向栈中下一个空闲位置

PyObject *f_trace; // trace函数

PyObject *f_exc_type, *f_exc_value, *f_exc_traceback; // 记录异常处理

PyThreadState *f_tstate; // 当前的线程

int f_lasti; // 当前执行的字节码的地址

int f_lineno; // 当前的行号

int f_iblock; // 一些局部block块

PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */

PyObject *f_localsplus[1]; // 栈地址，大小为本地变量+co_stacksize

} PyFrameObject;

对应的结构图

《python源码剖析-字节码和虚拟机》

当执行函数调用时会进入新的栈帧，那么当前栈帧就作为下一个栈帧的f_back字段。

《python源码剖析-字节码和虚拟机》

多个栈帧链属于一个线程，而同时可能存在多个线程，每个线程拥有一个栈帧链。这样形成了Python的虚拟机运行环境。

《python源码剖析-字节码和虚拟机》

Python执行字节码

字节码的执行就像上图所示，由一个大的循环和选择语句构成，逻辑骨干比较简单。

for(;;;) {

switch(opcode) {

case 100: # LOAD_CONST

{

x = POP()

... // 执行的具体操作

break;

};

case 101: # LOAD_NAME

{

...

break;

}

...

};

接下来，我们通过反编译代码追踪其如何一步步执行。

# 字节码的反编译

4 0 LOAD_CONST 1 (2)

3 STORE_DEREF 0 (c)

6 6 LOAD_CONST 2 (3)

9 LOAD_CLOSURE 0 (c)

12 BUILD_TUPLE 1

15 LOAD_CONST 3 (<code object inner at 00000000039E69B0, ...>)

18 MAKE_CLOSURE 1

21 STORE_FAST 4 (inner)

24 LOAD_CONST 0 (None)

27 RETURN_VALUE

通过追踪每个指令码的执行过程以及对应的PyFrameObject的栈帧变化，可以一步步看到虚拟机的执行过程。

PyObject *

PyEval_EvalFrame(PyFrameObject *f) {

co = f->f_code;

names = co->co_names;

consts = co->co_consts;

fastlocals = f->f_localsplus;

// freevars在内存中对应的不是f->f_freevars，而是f->f_cellvars

freevars = f->f_localsplus + co->co_nlocals;

first_instr = (unsigned char*) PyString_AS_STRING(co->co_code);

// f->f_lasti默认值为-1

next_instr = first_instr + f->f_lasti + 1;

// 执行栈顶

stack_pointer = f->f_stacktop;

for (;;) {

fast_next_opcode:

f->f_lasti = INSTR_OFFSET();

opcode = NEXTOP(); // 获取字节码

oparg = 0;

if (HAS_ARG(opcode)) // 如果字节码有参数，获取参数

oparg = NEXTARG();

TARGET(LOAD_CONST) // 0, 6, 24 行反编译指令LOAD_CONST

{

x = GETITEM(consts, oparg); // 从const中获取值压栈

Py_INCREF(x);

PUSH(x);

FAST_DISPATCH(); // goto fast_next_opcode

}

...

TARGET(STORE_DEREF) // 3

{

w = POP(); // 从栈中取值，设置为CellObejct的值

x = freevars[oparg];

PyCell_Set(x, w);

Py_DECREF(w);

DISPATCH();

}

初始化以及分别执行0和3字节码的PyFrameObject结构变化。

LOAD_CONST 将co_consts中对应的值压栈
STORE_DEREF 解引用，设置栈中的变量值

《python源码剖析-字节码和虚拟机》

TARGET(LOAD_CLOSURE) // 9

{

x = freevars[oparg];

Py_INCREF(x);

PUSH(x);

if (x != NULL) DISPATCH();

break;

}

TARGET(BUILD_TUPLE) // 12

{

x = PyTuple_New(oparg); // 创建一个元组，并且将栈中的元素设置为元组的元素

if (x != NULL) {

for (; --oparg >= 0;) {

w = POP();

PyTuple_SET_ITEM(x, oparg, w);

}

PUSH(x);

DISPATCH();

}

break;

}

TARGET(MAKE_CLOSURE) // 18

{

v = POP(); /* code object */

x = PyFunction_New(v, f->f_globals); // 创建函数

Py_DECREF(v);

if (x != NULL) {

v = POP();

if (PyFunction_SetClosure(x, v) != 0) {

/* Can‘t happen unless bytecode is corrupt. */

why = WHY_EXCEPTION;

}

Py_DECREF(v);

}

if (x != NULL && oparg > 0) {

v = PyTuple_New(oparg);

if (v == NULL) {

Py_DECREF(x);

x = NULL;

break;

}

while (--oparg >= 0) {

w = POP();

PyTuple_SET_ITEM(v, oparg, w);

}

if (PyFunction_SetDefaults(x, v) != 0) {

/* Can‘t happen unless

PyFunction_SetDefaults changes. */

why = WHY_EXCEPTION;

}

Py_DECREF(v);

}

PUSH(x);

break;

}

LOAD_CLOSURE 将freevars中的对象压栈
BUILD_TUPLE 用栈帧中的元素创建元组，并压栈
BUILD_CLOSURE 创建PyFunction对象，并设置其中的f_closure域

《python源码剖析-字节码和虚拟机》

TARGET(STORE_FAST) // 21

{

v = POP(); // 设置locals值

SETLOCAL(oparg, v);

FAST_DISPATCH();

}

TARGET_NOARG(RETURN_VALUE) // 27

{

retval = POP();

why = WHY_RETURN;

goto fast_block_end;

}

《python源码剖析-字节码和虚拟机》

STORE_FAST 将栈中的一个元素设置到对应的本地变量域中
RETURN_VALUE return，并且设置退出原因WHY_RETURN

从上面的代码和过程图，整个代码的执行过程清楚的显现出来：）

(完）

《python源码剖析-字节码和虚拟机》

| 分类于 python源码剖析 |

python源码剖析-字节码和虚拟机

Python中的伪码PyCodeObject

PyCodeObject的示例

PyFrameObject

Python执行字节码

相关推荐