Python的运行机制--操作码(opcode)解析

上一篇文章《Python的运行机制--pyc文件浅析》中已经对Python的运行单元PyCodeObject结构体作了初步的了解，但是要真正理解Python的运行机制，
还要通过分析Python的opcode才行。opcode的解释执行通过ceval.c中的以下函数：


PyObject *PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)


来实现，所以这个函数是研究opcode的重点，对于opcode有什么不明白的地方都可以通过这个函数中相应的opcode处理过程来得到解答。


在开始分析opcode之前，还是有必要先了解一下一个PyFrameObject这个数据结构：

typedef struct _frame {
    PyObject_VAR_HEAD
    struct _frame *f_back;	/* previous frame, or NULL */
    PyCodeObject *f_code;	/* code segment */
    PyObject *f_builtins;	/* builtin symbol table (PyDictObject) */
    PyObject *f_globals;	/* global symbol table (PyDictObject) */
    PyObject *f_locals;		/* local symbol table (any mapping) */
    PyObject **f_valuestack;	/* points after the last local */
    /* Next free slot in f_valuestack.  Frame creation sets to f_valuestack.
       Frame evaluation usually NULLs it, but a frame that yields sets it
       to the current stack top. */
    PyObject **f_stacktop;
    PyObject *f_trace;		/* Trace function */


    /* If an exception is raised in this frame, the next three are used to
     * record the exception info (if any) originally in the thread state.  See
     * comments before set_exc_info() -- it's not obvious.
     * Invariant:  if _type is NULL, then so are _value and _traceback.
     * Desired invariant:  all three are NULL, or all three are non-NULL.  That
     * one isn't currently true, but "should be".
     */
    PyObject *f_exc_type, *f_exc_value, *f_exc_traceback;


    PyThreadState *f_tstate;
    int f_lasti;		/* Last instruction if called */
    /* Call PyFrame_GetLineNumber() instead of reading this field
       directly.  As of 2.3 f_lineno is only valid when tracing is
       active (i.e. when f_trace is set).  At other times we use
       PyCode_Addr2Line to calculate the line from the current
       bytecode index. */
    int f_lineno;		/* Current line number */
    int f_iblock;		/* index in f_blockstack */
    PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
    PyObject *f_localsplus[1];	/* locals+stack, dynamically sized */
} PyFrameObject;

这里我们重点关注下以下的成员：

    PyObject **f_stacktop;
...
    PyCodeObject *f_code;	/* code segment */
    PyObject *f_globals;	/* global symbol table (PyDictObject) */
    PyObject *f_locals;		/* local symbol table (any mapping) */

可见PyFrameObject中包含一个PyCodeObject的结构体指针f_code,
PyFrameObject中的f_globals和f_locals这两个dict对象分别用于保存全局对象和局部对象，
可以说，PyFrameObject结构就是PyCodeObject的运行环境，PyCodeObject结构是静态的，创建以后就一般不会再变，而PyFrameObject则是动态的，
在创建以后,f_globals和f_locals这两个dict都经常会发生变化，并且一个PyCodeObject可能对应好几个的PyFrameObject中。


好，下面来开始分析opcode，还是延用上篇文件的例子，在这个例子中，通过showfile.py脚本，我们可以看到整个pyc文件中一共保存了5个PyCodeObject结构：
最外层的为模块test的PyCodeObject，其中的代码在import或者直接运行时会得到执行。
在module的PyCodeObject中嵌套了add函数的PyCodeObject结构以及world类的PyCodeObject结构。
在world类的PyCodeObject结构中，又嵌套了__init__方法和sayHello方法的PyCodeObject结构。
我们先来分析一下test模块的PyCodeObject结构体:

  
    0 
    0
    3
    0040
   
      6400006401006c00005a00006501005a02006402008400005a0300640300
      640500640400840000830000595a04006504008300005a05006505006a06
      008300000164010053
   
   
...
   
    ('dis', 'True', 'myglobal', 'add', 'world', 'w', 'sayHello')
    ()
    ()
    ()
    'test.py'
    ''
    1
   
      -1
      None
...
	

再来解析一下产生的opcode：
下面的注释中，locals即为PyFrameObject.f_locals，names代码的对象即为PyCodeObject.co_names

  1           0 LOAD_CONST               0 (-1) #加载consts数组中索引为0处的值，这里为数值-1
              3 LOAD_CONST               1 (None) #加载consts数组中索引为1处的值，这里为None


              6 IMPORT_NAME              0 (dis) #加载dis模块：names[0]即为"dis"
              9 STORE_NAME               0 (dis) #将模块保存到一个dict中，这个dict专门用来保存局部变量的值，key为names[0],即"dis"


  2          12 LOAD_NAME                1 (True) #将names[1]，即True压栈。
             15 STORE_NAME               2 (myglobal) #将栈顶的元素，即True保存到locals['myglobal']中,names[2]即为字符串'myglobal'


  4          18 LOAD_CONST               2 () #将consts[2]，即add函数的PyCodeObject压栈。
             21 MAKE_FUNCTION            0 #通过add函数的PyCodeObject创建一个函数，并压入栈顶。
             24 STORE_NAME               3 (add) #将创建的函数出栈并保存到locals['add']中


  9          27 LOAD_CONST               3 ('world') #consts[3],即"world"入栈
             30 LOAD_CONST               5 (()) #consts[5],即空数组入栈
             33 LOAD_CONST               4 () #将consts[4]，即world的PyCodeObject入栈。
             36 MAKE_FUNCTION            0 #创建函数
             39 CALL_FUNCTION            0 #调用刚创建的函数，用于初始化类，会返回一个dict到栈顶，这个dict中保存了类的方法以及一些全局变量，
                                           #具体的实现要看world类的PyCodeObject中的opcode
             42 BUILD_CLASS         #创建类，注意BUILD_CLASS会用到栈中的三个对象，这里分别为：保存在dict中的类的信息，基类数组，这里为空数组(),类的名称："world"
             43 STORE_NAME               4 (world) #将类保存到locals['world']中


 15          46 LOAD_NAME                4 (world)
             49 CALL_FUNCTION            0
             52 STORE_NAME               5 (w)
#以上三行代码创建一个world对象
 16          55 LOAD_NAME                5 (w)
             58 LOAD_ATTR                6 (sayHello)
             61 CALL_FUNCTION            0
#以上三行代码调用w.sayHello()
             64 POP_TOP             
             65 LOAD_CONST               1 (None)
             68 RETURN_VALUE        

上面对反汇编中来的opcode作了个简单的注释，这里只解释了比较常见的opcode，在Python 2.7中，一共有147条opcode,定义在opcode.h中，
可以研究PyEval_EvalFrameEx的代码来理解它们。
通过分析Python的opcode，相信对于Python的运行应该有了更深刻的理解，当然还有更多的疑问还有待于去解答，如PyFrameObject是怎么创建的，
什么时候会创建，以及如何维护的等等。