从底层理解Python的执行

我就是我 2022-08-05 01:24 220阅读 0赞

allowtransparency="true" frameborder="0" scrolling="no" src="http://hits.sinajs.cn/A1/weiboshare.html?url=http%3A%2F%2Fwww.csdn.net%2Farticle%2F2015-05-28%2F2824795&type=3&count=&appkey=&title=%E6%98%AF%E5%90%A6%E6%83%B3%E5%9C%A8Python%E8%A7%A3%E9%87%8A%E5%99%A8%E7%9A%84%E5%86%85%E9%83%A8%E6%99%83%E6%82%A0%E4%B8%80%E5%9C%88%EF%BC%9F%E6%98%AF%E4%B8%8D%E6%98%AF%E6%83%B3%E5%AE%9E%E7%8E%B0%E4%B8%80%E4%B8%AAPython%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C%E7%9A%84%E8%BF%BD%E8%B8%AA%E5%99%A8%EF%BC%9F%E6%B2%A1%E6%9C%89%E5%9F%BA%E7%A1%80%EF%BC%9F%E4%B8%8D%E8%A6%81%E6%80%95%EF%BC%8C%E8%BF%99%E7%AF%87%E6%96%87%E7%AB%A0%E8%AE%A9%E4%BD%A0%E5%88%9D%E7%AA%A5Python%E5%BA%95%E5%B1%82%E7%9A%84%E5%A5%A5%E5%A6%99%E3%80%82&pic=&ralateUid=&language=zh\_cn&rnd=1432903433705" width="22" height="16"> **摘要：**是否想在Python解释器的内部晃悠一圈？是不是想实现一个Python代码执行的追踪器？没有基础？不要怕，这篇文章让你初窥Python底层的奥妙。

【编者按】下面博文将带你创建一个字节码级别的追踪API以追踪Python的一些内部机制，比如类似YIELDVALUE、YIELDFROM操作码的实现，推式构造列表(List Comprehensions)、生成器表达式(generator expressions)以及其他一些有趣Python的编译。

--------------------

**关于译者**：赵斌， [OneAPM][]工程师，常年使用 Python/Perl 脚本，从事 DevOP、测试开发相关的开发工作。业余热爱看书，喜欢 MOOC。

--------------------

**以下为译文**

最近我在学习 Python 的运行模型。我对 Python 的一些内部机制很是好奇，比如 Python 是怎么实现类似 YIELD*VALUE、YIELD*FROM 这样的操作码的；对于 递推式构造列表(List Comprehensions)、生成器表达式(generator expressions)以及其他一些有趣的 Python 特性是怎么编译的；从字节码的层面来看，当异常抛出的时候都发生了什么事情。翻阅 CPython 的代码对于解答这些问题当然是很有帮助的，但我仍然觉得以这样的方式来做的话对于理解字节码的执行和堆栈的变化还是缺少点什么。GDB 是个好选择，但是我懒，而且只想使用一些比较高阶的接口写点 Python 代码来完成这件事。

所以呢，我的目标就是创建一个字节码级别的追踪 API，类似 sys.setrace 所提供的那样，但相对而言会有更好的粒度。这充分锻炼了我编写 Python 实现的 C 代码的编码能力。我们所需要的有如下几项，在这篇文章中所用的 Python 版本为 3.5。

*  一个新的 Cpython 解释器操作码
 *  一种将操作码注入到 Python 字节码的方法
 *  一些用于处理操作码的 Python 代码

### 一个新的 Cpython 操作码 ###

#### 新操作码：DEBUG\_OP ####

这个新的操作码 DEBUG\_OP 是我第一次尝试写 CPython 实现的 C 代码，我将尽可能的让它保持简单。 我们想要达成的目的是，当我们的操作码被执行的时候我能有一种方式来调用一些 Python 代码。同时，我们也想能够追踪一些与执行上下文有关的数据。我们的操作码会把这些信息当作参数传递给我们的回调函数。通过操作码能辨识出的有用信息如下：

*  堆栈的内容
 *  执行 DEBUG\_OP 的帧对象信息

所以呢，我们的操作码需要做的事情是：

*  找到回调函数
 *  创建一个包含堆栈内容的列表
 *  调用回调函数，并将包含堆栈内容的列表和当前帧作为参数传递给它

听起来挺简单的，现在开始动手吧！**声明**：下面所有的解释说明和代码是经过了大量段错误调试之后总结得到的结论。首先要做的是给操作码定义一个名字和相应的值，因此我们需要在[Include/opcode.h][Include_opcode.h]中添加代码。

**\[py\]** [view plain][] [copy][view plain]

1.  /\*\* My own comments begin by '\*\*' \*\*/ 
2.  /\*\* From: Includes/opcode.h \*\*/ 
3.  
4.  /\* Instruction opcodes for compiled code \*/ 
5.  
6.  /\*\* We just have to define our opcode with a free value 
7.  0 was the first one I found \*\*/ 
8.  \#define DEBUG\_OP 0
9.  
10. \#define POP\_TOP 1
11. \#define ROT\_TWO 2
12. \#define ROT\_THREE 3

这部分工作就完成了，现在我们去编写操作码真正干活的代码。

#### 实现 DEBUG\_OP ####

在考虑如何实现`DEBUG_OP`之前我们需要了解的是`DEBUG_OP`提供的接口将长什么样。 拥有一个可以调用其他代码的新操作码是相当酷眩的，但是究竟它将调用哪些代码捏？这个操作码如何找到回调函数的捏？我选择了一种最简单的方法：在帧的全局区域写死函数名。那么问题就变成了，我该怎么从字典中找到一个固定的 C 字符串？为了回答这个问题我们来看看在 Python 的 main loop 中使用到的和上下文管理相关的标识符`__enter__`和`__exit__。`

我们可以看到这两标识符被使用在操作码`SETUP_WITH`中：

**\[py\]** [view plain][] [copy][view plain]

1.  /\*\* From: Python/ceval.c \*\*/ 
2.  TARGET(SETUP\_WITH) \{ 
3.  \_Py\_IDENTIFIER(\_\_exit\_\_); 
4.  \_Py\_IDENTIFIER(\_\_enter\_\_); 
5.  PyObject \*mgr = TOP(); 
6.  PyObject \*exit = special\_lookup(mgr, &PyId\_\_\_exit\_\_), \*enter; 
7.  PyObject \*res;

现在，看一眼宏 `_Py_IDENTIFIER`的定义

**\[py\]** [view plain][] [copy][view plain]

1.  /\*\* From: Include/object.h \*\*/ 
2.  
3.  /\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* String Literals \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/ 
4.  /\* This structure helps managing static strings. The basic usage goes like this: 
5.   Instead of doing 
6.  
7.   r = PyObject\_CallMethod(o, "foo", "args", ...); 
8.  
9.   do 
10. 
11.  \_Py\_IDENTIFIER(foo); 
12.  ... 
13.  r = \_PyObject\_CallMethodId(o, &PyId\_foo, "args", ...); 
14. 
15.  PyId\_foo is a static variable, either on block level or file level. On first 
16.  usage, the string "foo"is interned, and the structures are linked. On interpreter 
17.  shutdown, all strings are released (through \_PyUnicode\_ClearStaticStrings). 
18. 
19.  Alternatively, \_Py\_static\_string allows to choose the variable name. 
20.  \_PyUnicode\_FromId returns a borrowed reference to the interned string. 
21.  \_PyObject\_\{Get,Set,Has\}AttrId are \_\_getattr\_\_ versions using \_Py\_Identifier\*. 
22. \*/ 
23. typedef struct \_Py\_Identifier \{ 
24.  struct \_Py\_Identifier \*next; 
25.  const char\* string; 
26.  PyObject \*object; 
27. \} \_Py\_Identifier; 
28. 
29. \#define \_Py\_static\_string\_init(value) \{ 0, value, 0 \}
30. \#define \_Py\_static\_string(varname, value) static \_Py\_Identifier varname = \_Py\_static\_string\_init(value)
31. \#define \_Py\_IDENTIFIER(varname) \_Py\_static\_string(PyId\_\#\#varname, \#varname)

嗯，注释部分已经说明得很清楚了。通过一番查找，我们发现了可以用来从字典找固定字符串的函数 `_PyDict_GetItemId`，所以我们操作码的查找部分的代码就是长这样滴。

**\[py\]** [view plain][] [copy][view plain]

1.   /\*\* Our callback function will be named op\_target \*\*/ 
2.  PyObject \*target = NULL; 
3.  \_Py\_IDENTIFIER(op\_target); 
4.  target = \_PyDict\_GetItemId(f->f\_globals, &PyId\_op\_target); 
5.  if (target == NULL && \_PyErr\_OCCURRED()) \{ 
6.  if (!PyErr\_ExceptionMatches(PyExc\_KeyError)) 
7.   goto error; 
8.   PyErr\_Clear(); 
9.   DISPATCH(); 
10. \}

为了方便理解，对这一段代码做一些说明：

*  `f`是当前的帧，`f->f_globals`是它的全局区域
 *  如果我们没有找到`op_target`，我们将会检查这个异常是不是`KeyError`
 *  `goto error;`是一种在 main loop 中抛出异常的方法
 *  `PyErr_Clear()`抑制了当前异常的抛出，而`DISPATCH()`触发了下一个操作码的执行

下一步就是收集我们想要的堆栈信息。

**\[py\]** [view plain][] [copy][view plain]

1.  /\*\* This code create a list with all the values on the current stack \*\*/ 
2.  PyObject \*value = PyList\_New(0); 
3.  for (i = 1 ; i <= STACK\_LEVEL(); i++) \{ 
4.   tmp = PEEK(i); 
5.  if (tmp == NULL) \{ 
6.   tmp = Py\_None; 
7.   \} 
8.   PyList\_Append(value, tmp); 
9.  \}

最后一步就是调用我们的回调函数！我们用`call_function`来搞定这件事，我们通过研究操作码`CALL_FUNCTION`的实现来学习怎么使用`call_function` 。

**\[py\]** [view plain][] [copy][view plain]

1.  /\*\* From: Python/ceval.c \*\*/ 
2.  TARGET(CALL\_FUNCTION) \{ 
3.   PyObject \*\*sp, \*res; 
4.   /\*\* stack\_pointer is a local of the main loop. 
5.   It's the pointer to the stacktop of our frame \*\*/ 
6.   sp = stack\_pointer; 
7.   res = call\_function(&sp, oparg); 
8.   /\*\* call\_function handles the args it consummed on the stack for us \*\*/ 
9.   stack\_pointer = sp; 
10.  PUSH(res); 
11.  /\*\* Standard exception handling \*\*/ 
12. if (res == NULL) 
13.  goto error; 
14.  DISPATCH(); 
15. \}

有了上面这些信息，我们终于可以捣鼓出一个操作码 `DEBUG_OP`的草稿了：

**\[py\]** [view plain][] [copy][view plain]

1.  TARGET(DEBUG\_OP) \{ 
2.   PyObject \*value = NULL; 
3.   PyObject \*target = NULL; 
4.   PyObject \*res = NULL; 
5.   PyObject \*\*sp = NULL; 
6.   PyObject \*tmp; 
7.   int i; 
8.   \_Py\_IDENTIFIER(op\_target); 
9.  
10.  target = \_PyDict\_GetItemId(f->f\_globals, &PyId\_op\_target); 
11. if (target == NULL && \_PyErr\_OCCURRED()) \{ 
12. if (!PyErr\_ExceptionMatches(PyExc\_KeyError)) 
13.  goto error; 
14.  PyErr\_Clear(); 
15.  DISPATCH(); 
16.  \} 
17.  value = PyList\_New(0); 
18.  Py\_INCREF(target); 
19. for (i = 1 ; i <= STACK\_LEVEL(); i++) \{ 
20.  tmp = PEEK(i); 
21. if (tmp == NULL) 
22.  tmp = Py\_None; 
23.  PyList\_Append(value, tmp); 
24.  \} 
25. 
26.  PUSH(target); 
27.  PUSH(value); 
28.  Py\_INCREF(f); 
29.  PUSH(f); 
30.  sp = stack\_pointer; 
31.  res = call\_function(&sp, 2); 
32.  stack\_pointer = sp; 
33. if (res == NULL) 
34.  goto error; 
35.  Py\_DECREF(res); 
36.  DISPATCH(); 
37. \}

在编写 CPython 实现的 C 代码方面我确实没有什么经验，有可能我漏掉了些细节。如果您有什么建议还请您纠正，我期待您的反馈。

编译它，成了！

一切看起来很顺利，但是当我们尝试去使用我们定义的操作码`DEBUG_OP`的时候却失败了。自从 2008 年之后，Python 使用预先写好的 [goto][](你也可以从 [这里][Link 1]获取更多的讯息)。故，我们需要更新下 goto jump table，我们在 Python/opcode\_targets.h 中做如下修改。

**\[py\]** [view plain][] [copy][view plain]

1.  /\*\* From: Python/opcode\_targets.h \*\*/ 
2.  /\*\* Easy change since DEBUG\_OP is the opcode number 1 \*\*/ 
3.  static void \*opcode\_targets\[256\] = \{ 
4.   //&&\_unknown\_opcode, 
5.   &&TARGET\_DEBUG\_OP, 
6.   &&TARGET\_POP\_TOP, 
7.   /\*\* ... \*\*/

这就完事了，我们现在就有了一个可以工作的新操作码。唯一的问题就是这货虽然存在，但是没有被人调用过。接下来，我们将 `DEBUG_OP`注入到函数的字节码中。

### 在 Python 字节码中注入操作码 DEBUG\_OP ###

有很多方式可以在 Python 字节码中注入新的操作码：

*  使用 peephole optimizer， [Quarkslab][]就是这么干的
 *  在生成字节码的代码中动些手脚
 *  在运行时直接修改函数的字节码(这就是我们将要干的事儿)

为了创造出一个新操作码，有了上面的那一堆 C 代码就够了。现在让我们回到原点，开始理解奇怪甚至神奇的 Python！

我们将要做的事儿有：

*  得到我们想要追踪函数的 code object
 *  重写字节码来注入`DEBUG_OP`
 *  将新生成的 code object 替换回去

#### 和 code object 有关的小贴士 ####

如果你从没听说过 code object，这里有一个简单的 [介绍][Link 2]网路上也有一些相关的 [文档][Link 3]可供查阅,可以直接`Ctrl+F`查找 code object

还有一件事情需要注意的是在这篇文章所指的环境中 code object 是**不可变**的：

**\[py\]** [view plain][] [copy][view plain]

1.  Python 3.4.2 (default, Oct 82014, 10:45:20) 
2.  \[GCC 4.9.1\] on linux 
3.  Type "help", "copyright", "credits"or"license"for more information. 
4.  >>> x = lambda y : 2
5.  >>> x.\_\_code\_\_ 
6.  <code object <lambda> at 0x7f481fd88390, file "<stdin>", line 1> 
7.  >>> x.\_\_code\_\_.co\_name 
8.  '<lambda>'
9.  >>> x.\_\_code\_\_.co\_name = 'truc'
10. Traceback (most recent call last): 
11.  File "<stdin>", line 1, in <module> 
12. AttributeError: readonly attribute 
13. >>> x.\_\_code\_\_.co\_consts = ('truc',) 
14. Traceback (most recent call last): 
15.  File "<stdin>", line 1, in <module> 
16. AttributeError: readonly attribute

但是不用担心，我们将会找到方法绕过这个问题的。

### 使用的工具 ###

为了修改字节码我们需要一些工具：

*  [dis][]模块用来反编译和分析字节码
 *  `dis.Bytecode`Python 3.4 新增的一个特性，对于反编译和分析字节码特别有用
 *  一个能够简单修改 code object 的方法

用 `dis.Bytecode`反编译 code bject 能告诉我们一些有关操作码、参数和上下文的信息。

**\[py\]** [view plain][] [copy][view plain]

1.  \# Python3.4
2.  >>> import dis 
3.  >>> f = lambda x: x + 3
4.  >>> for i in dis.Bytecode(f.\_\_code\_\_): print (i) 
5.  ... 
6.  Instruction(opname='LOAD\_FAST', opcode=124, arg=0, argval='x', argrepr='x', offset=0, starts\_line=1, is\_jump\_target=False) 
7.  Instruction(opname='LOAD\_CONST', opcode=100, arg=1, argval=3, argrepr='3', offset=3, starts\_line=None, is\_jump\_target=False) 
8.  Instruction(opname='BINARY\_ADD', opcode=23, arg=None, argval=None, argrepr='', offset=6, starts\_line=None, is\_jump\_target=False) 
9.  Instruction(opname='RETURN\_VALUE', opcode=83, arg=None, argval=None, argrepr='', offset=7, starts\_line=None, is\_jump\_target=False)

为了能够修改 code object，我定义了一个很小的类用来复制 code object，同时能够按我们的需求修改相应的值，然后重新生成一个新的 code object。

**\[py\]** [view plain][] [copy][view plain]

1.  class MutableCodeObject(object): 
2.   args\_name = ("co\_argcount", "co\_kwonlyargcount", "co\_nlocals", "co\_stacksize", "co\_flags", "co\_code", 
3.  "co\_consts", "co\_names", "co\_varnames", "co\_filename", "co\_name", "co\_firstlineno", 
4.  "co\_lnotab", "co\_freevars", "co\_cellvars") 
5.  
6.  def \_\_init\_\_(self, initial\_code): 
7.  self.initial\_code = initial\_code 
8.  for attr\_name inself.args\_name: 
9.   attr = getattr(self.initial\_code, attr\_name) 
10. if isinstance(attr, tuple): 
11.  attr = list(attr) 
12.  setattr(self, attr\_name, attr) 
13. 
14. def get\_code(self): 
15.  args = \[\] 
16. for attr\_name inself.args\_name: 
17.  attr = getattr(self, attr\_name) 
18. if isinstance(attr, list): 
19.  attr = tuple(attr) 
20.  args.append(attr) 
21. returnself.initial\_code.\_\_class\_\_(\*args)

这个类用起来很方便，解决了上面提到的 code object 不可变的问题。

**\[py\]** [view plain][] [copy][view plain]

1.  >>> x = lambda y : 2
2.  >>> m = MutableCodeObject(x.\_\_code\_\_) 
3.  >>> m 
4.  <new\_code.MutableCodeObject object at 0x7f3f0ea546a0> 
5.  >>> m.co\_consts 
6.  \[None, 2\] 
7.  >>> m.co\_consts\[1\] = '3'
8.  >>> m.co\_name = 'truc'
9.  >>> m.get\_code() 
10. <code object truc at 0x7f3f0ea2bc90, file "<stdin>", line 1>

### 测试我们的新操作码 ###

我们现在拥有了注入`DEBUG_OP`的所有工具，让我们来验证下我们的实现是否可用。我们将我们的操作码注入到一个最简单的函数中：

**\[py\]** [view plain][] [copy][view plain]

1.  from new\_code import MutableCodeObject 
2.  
3.  def op\_target(\*args): 
4.  print("WOOT") 
5.  print("op\_target called with args <\{0\}>".format(args)) 
6.  
7.  def nop(): 
8.  pass
9.  
10. new\_nop\_code = MutableCodeObject(nop.\_\_code\_\_) 
11. new\_nop\_code.co\_code = b"\\x00" \+ new\_nop\_code.co\_code\[0:3\] + b"\\x00" \+ new\_nop\_code.co\_code\[-1:\] 
12. new\_nop\_code.co\_stacksize += 3
13. 
14. nop.\_\_code\_\_ = new\_nop\_code.get\_code() 
15. 
16. import dis 
17. dis.dis(nop) 
18. nop() 
19. 
20. 
21. \# Don't forget that ./python is our custom Python implementing DEBUG\_OP
22. hakril@computer ~/python/CPython3.5 % ./python proof.py 
23. 80 <0> 
24. 1 LOAD\_CONST 0 (None) 
25. 4 <0> 
26. 5 RETURN\_VALUE 
27. WOOT 
28. op\_target called with args <(\[\], <frame object at 0x7fde9eaebdb0>)> 
29. WOOT 
30. op\_target called with args <(\[None\], <frame object at 0x7fde9eaebdb0>)>

看起来它成功了！有一行代码需要说明一下`new_nop_code.co_stacksize += 3`

*  co\_stacksize 表示 code object 所需要的堆栈的大小
 *  操作码`DEBUG_OP`往堆栈中增加了三项，所以我们需要为这些增加的项预留些空间

现在我们可以将我们的操作码注入到每一个 Python 函数中了！

### 重写字节码 ###

正如我们在上面的例子中所看到的那样，重写 Pyhton 的字节码似乎 so easy。为了在每一个操作码之间注入我们的操作码，我们需要获取每一个操作码的偏移量，然后将我们的操作码注入到这些位置上(把我们操作码注入到参数上是有坏处大大滴)。这些偏移量也很容易获取，使用 `dis.Bytecode` ，就像这样 。

**\[py\]** [view plain][] [copy][view plain]

1.  def add\_debug\_op\_everywhere(code\_obj): 
2.  \# We get every instruction offset in the code object
3.   offsets = \[instr.offset for instr in dis.Bytecode(code\_obj)\] 
4.  \# And insert a DEBUG\_OP at every offset
5.  return insert\_op\_debug\_list(code\_obj, offsets) 
6.  
7.  def insert\_op\_debug\_list(code, offsets): 
8.  \# We insert the DEBUG\_OP one by one
9.  for nb, off in enumerate(sorted(offsets)): 
10. \# Need to ajust the offsets by the number of opcodes already inserted before
11. \# That's why we sort our offsets!
12.  code = insert\_op\_debug(code, off + nb) 
13. return code 
14. 
15. \# Last problem: what does insert\_op\_debug looks like?

基于上面的例子，有人可能会想我们的 `insert_op_debug`会在指定的偏移量增加一个 `"\x00"`，这尼玛是个坑啊！我们第一个 `DEBUG_OP`注入的例子中被注入的函数是没有任何的分支的，为了能够实现完美一个函数注入函数 `insert_op_debug`我们需要考虑到存在分支操作码的情况。  
  
Python 的分支一共有两种：

*  绝对分支：看起来是类似这样子的`Instruction_Pointer = argument(instruction)`
 *  相对分支：看起来是类似这样子的`Instruction_Pointer += argument(instruction)`
    
     *  相对分支总是向前的

我们希望这些分支在我们插入操作码之后仍然能够正常工作，为此我们需要修改一些指令参数。以下是其逻辑流程：

*  对于每一个在插入偏移量之前的相对分支而言
    
     *  如果目标地址是严格大于我们的插入偏移量的话，将指令参数增加 1
     *  如果相等，则不需要增加 1 就能够在跳转操作和目标地址之间执行我们的操作码`DEBUG_OP`
     *  如果小于，插入我们的操作码的话并不会影响到跳转操作和目标地址之间的距离
 *  对于 code object 中的每一个绝对分支而言
    
     *  如果目标地址是严格大于我们的插入偏移量的话，将指令参数增加 1
     *  如果相等，那么不需要任何修改，理由和相对分支部分是一样的
     *  如果小于，插入我们的操作码的话并不会影响到跳转操作和目标地址之间的距离

下面是实现：

**\[py\]** [view plain][] [copy][view plain]

1.  \# Helper
2.  def bytecode\_to\_string(bytecode): 
3.  if bytecode.arg isnotNone: 
4.  return struct.pack("<Bh", bytecode.opcode, bytecode.arg) 
5.  return struct.pack("<B", bytecode.opcode) 
6.  
7.  \# Dummy class for bytecode\_to\_string
8.  class DummyInstr: 
9.  def \_\_init\_\_(self, opcode, arg): 
10. self.opcode = opcode 
11. self.arg = arg 
12. 
13. def insert\_op\_debug(code, offset): 
14.  opcode\_jump\_rel = \['FOR\_ITER', 'JUMP\_FORWARD', 'SETUP\_LOOP', 'SETUP\_WITH', 'SETUP\_EXCEPT', 'SETUP\_FINALLY'\] 
15.  opcode\_jump\_abs = \['POP\_JUMP\_IF\_TRUE', 'POP\_JUMP\_IF\_FALSE', 'JUMP\_ABSOLUTE'\] 
16.  res\_codestring = b"" 
17.  inserted = False
18. for instr in dis.Bytecode(code): 
19. if instr.offset == offset: 
20.  res\_codestring += b"\\x00"
21.  inserted = True
22. if instr.opname in opcode\_jump\_rel andnot inserted: \#relative jump are always forward
23. if offset < instr.offset + 3 \+ instr.arg: \# inserted beetwen jump and dest: add 1 to dest (3 for size)
24. \#If equal: jump on DEBUG\_OP to get info before exec instr
25.  res\_codestring += bytecode\_to\_string(DummyInstr(instr.opcode, instr.arg + 1)) 
26. continue
27. if instr.opname in opcode\_jump\_abs: 
28. if instr.arg > offset: 
29.  res\_codestring += bytecode\_to\_string(DummyInstr(instr.opcode, instr.arg + 1)) 
30. continue
31.  res\_codestring += bytecode\_to\_string(instr) 
32. \# replace\_bytecode just replaces the original code co\_code
33. return replace\_bytecode(code, res\_codestring)

让我们看一下效果如何：

**\[py\]** [view plain][] [copy][view plain]

1.  >>> def lol(x): 
2.  ... for i in range(10): 
3.  ... if x == i: 
4.  ... break
5.  
6.  >>> dis.dis(lol) 
7.  1010 SETUP\_LOOP 36 (to 39) 
8.  3 LOAD\_GLOBAL 0 (range) 
9.  6 LOAD\_CONST 1 (10) 
10. 9 CALL\_FUNCTION 1 (1 positional, 0 keyword pair) 
11. 12 GET\_ITER 
12.  >> 13 FOR\_ITER 22 (to 38) 
13. 16 STORE\_FAST 1 (i) 
14. 
15. 10219 LOAD\_FAST 0 (x) 
16. 22 LOAD\_FAST 1 (i) 
17. 25 COMPARE\_OP 2 (==) 
18. 28 POP\_JUMP\_IF\_FALSE 13
19. 
20. 10331 BREAK\_LOOP 
21. 32 JUMP\_ABSOLUTE 13
22. 35 JUMP\_ABSOLUTE 13
23.  >> 38 POP\_BLOCK 
24.  >> 39 LOAD\_CONST 0 (None) 
25. 42 RETURN\_VALUE 
26. >>> lol.\_\_code\_\_ = transform\_code(lol.\_\_code\_\_, add\_debug\_op\_everywhere, add\_stacksize=3) 
27. 
28. 
29. >>> dis.dis(lol) 
30. 1010 <0> 
31. 1 SETUP\_LOOP 50 (to 54) 
32. 4 <0> 
33. 5 LOAD\_GLOBAL 0 (range) 
34. 8 <0> 
35. 9 LOAD\_CONST 1 (10) 
36. 12 <0> 
37. 13 CALL\_FUNCTION 1 (1 positional, 0 keyword pair) 
38. 16 <0> 
39. 17 GET\_ITER 
40.  >> 18 <0> 
41. 
42. 10219 FOR\_ITER 30 (to 52) 
43. 22 <0> 
44. 23 STORE\_FAST 1 (i) 
45. 26 <0> 
46. 27 LOAD\_FAST 0 (x) 
47. 30 <0> 
48. 
49. 10331 LOAD\_FAST 1 (i) 
50. 34 <0> 
51. 35 COMPARE\_OP 2 (==) 
52. 38 <0> 
53. 39 POP\_JUMP\_IF\_FALSE 18
54. 42 <0> 
55. 43 BREAK\_LOOP 
56. 44 <0> 
57. 45 JUMP\_ABSOLUTE 18
58. 48 <0> 
59. 49 JUMP\_ABSOLUTE 18
60.  >> 52 <0> 
61. 53 POP\_BLOCK 
62.  >> 54 <0> 
63. 55 LOAD\_CONST 0 (None) 
64. 58 <0> 
65. 59 RETURN\_VALUE 
66. 
67. \# Setup the simplest handler EVER
68. >>> def op\_target(stack, frame): 
69. ... print (stack) 
70. 
71. \# GO
72. >>> lol(2) 
73. \[\] 
74. \[\] 
75. \[<class'range'>\] 
76. \[10, <class'range'>\] 
77. \[range(0, 10)\] 
78. \[<range\_iterator object at 0x7f1349afab80>\] 
79. \[0, <range\_iterator object at 0x7f1349afab80>\] 
80. \[<range\_iterator object at 0x7f1349afab80>\] 
81. \[2, <range\_iterator object at 0x7f1349afab80>\] 
82. \[0, 2, <range\_iterator object at 0x7f1349afab80>\] 
83. \[False, <range\_iterator object at 0x7f1349afab80>\] 
84. \[<range\_iterator object at 0x7f1349afab80>\] 
85. \[1, <range\_iterator object at 0x7f1349afab80>\] 
86. \[<range\_iterator object at 0x7f1349afab80>\] 
87. \[2, <range\_iterator object at 0x7f1349afab80>\] 
88. \[1, 2, <range\_iterator object at 0x7f1349afab80>\] 
89. \[False, <range\_iterator object at 0x7f1349afab80>\] 
90. \[<range\_iterator object at 0x7f1349afab80>\] 
91. \[2, <range\_iterator object at 0x7f1349afab80>\] 
92. \[<range\_iterator object at 0x7f1349afab80>\] 
93. \[2, <range\_iterator object at 0x7f1349afab80>\] 
94. \[2, 2, <range\_iterator object at 0x7f1349afab80>\] 
95. \[True, <range\_iterator object at 0x7f1349afab80>\] 
96. \[<range\_iterator object at 0x7f1349afab80>\] 
97. \[\] 
98. \[None\]

甚好！现在我们知道了如何获取堆栈信息和 Python 中每一个操作对应的帧信息。上面结果所展示的结果目前而言并不是很实用。在最后一部分中让我们对注入做进一步的封装。

### 增加 Python 封装 ###

正如您所见到的，所有的底层接口都是好用的。我们最后要做的一件事是让 op\_target 更加方便使用(这部分相对而言比较空泛一些，毕竟在我看来这不是整个项目中最有趣的部分)。

首先我们来看一下帧的参数所能提供的信息，如下所示：

*  `f_code`当前帧将执行的 code object
 *  `f_lasti`当前的操作(code object 中的字节码字符串的索引)

经过我们的处理我们可以得知`DEBUG_OP`之后要被执行的操作码，这对我们聚合数据并展示是相当有用的。

新建一个用于追踪函数内部机制的类：

*  改变函数自身的`co_code`
 *  设置回调函数作为`op_debug`的目标函数

一旦我们知道下一个操作，我们就可以分析它并修改它的参数。举例来说我们可以增加一个 `auto-follow-called-functions`的特性。

**\[py\]** [view plain][] [copy][view plain]

1.  def op\_target(l, f, exc=None): 
2.  if op\_target.callback isnotNone: 
3.   op\_target.callback(l, f, exc) 
4.  
5.  class Trace: 
6.  def \_\_init\_\_(self, func): 
7.  self.func = func 
8.  
9.  def call(self, \*args, \*\*kwargs): 
10. self.add\_func\_to\_trace(self.func) 
11. \# Activate Trace callback for the func call
12.  op\_target.callback = self.callback 
13. try: 
14.  res = self.func(\*args, \*\*kwargs) 
15. except Exception as e: 
16.  res = e 
17.  op\_target.callback = None
18. return res 
19. 
20. def add\_func\_to\_trace(self, f): 
21. \# Is it code? is it already transformed?
22. ifnot hasattr(f ,"op\_debug") and hasattr(f, "\_\_code\_\_"): 
23.  f.\_\_code\_\_ = transform\_code(f.\_\_code\_\_, transform=add\_everywhere, add\_stacksize=ADD\_STACK) 
24.  f.\_\_globals\_\_\['op\_target'\] = op\_target 
25.  f.op\_debug = True
26. 
27. def do\_auto\_follow(self, stack, frame): 
28. \# Nothing fancy: FrameAnalyser is just the wrapper that gives the next executed instruction
29.  next\_instr = FrameAnalyser(frame).next\_instr() 
30. if"CALL"in next\_instr.opname: 
31.  arg = next\_instr.arg 
32.  f\_index = (arg & 0xff) + (2 \* (arg >> 8)) 
33.  called\_func = stack\[f\_index\] 
34. 
35. \# If call target is not traced yet: do it
36. ifnot hasattr(called\_func, "op\_debug"): 
37. self.add\_func\_to\_trace(called\_func)

现在我们实现一个 Trace 的子类，在这个子类中增加 callback 和 do*report 这两个方法。callback 方法将在每一个操作之后被调用。do*report 方法将我们收集到的信息打印出来。

这是一个伪函数追踪器实现：

**\[py\]** [view plain][] [copy][view plain]

1.  class DummyTrace(Trace): 
2.  def \_\_init\_\_(self, func): 
3.  self.func = func 
4.  self.data = collections.OrderedDict() 
5.  self.last\_frame = None
6.  self.known\_frame = \[\] 
7.  self.report = \[\] 
8.  
9.  def callback(self, stack, frame, exc): 
10. if frame notinself.known\_frame: 
11. self.known\_frame.append(frame) 
12. self.report.append(" === Entering New Frame \{0\} (\{1\}) ===".format(frame.f\_code.co\_name, id(frame))) 
13. self.last\_frame = frame 
14. if frame != self.last\_frame: 
15. self.report.append(" === Returning to Frame \{0\} \{1\}===".format(frame.f\_code.co\_name, id(frame))) 
16. self.last\_frame = frame 
17. 
18. self.report.append(str(stack)) 
19.  instr = FrameAnalyser(frame).next\_instr() 
20.  offset = str(instr.offset).rjust(8) 
21.  opname = str(instr.opname).ljust(20) 
22.  arg = str(instr.arg).ljust(10) 
23. self.report.append("\{0\} \{1\} \{2\} \{3\}".format(offset, opname, arg, instr.argval)) 
24. self.do\_auto\_follow(stack, frame) 
25. 
26. def do\_report(self): 
27. print("\\n".join(self.report))

这里有一些实现的例子和使用方法。格式有些不方便观看，毕竟我并不擅长于搞这种对用户友好的报告的事儿。

*  [例1][1]自动追踪堆栈信息和已经执行的指令
 *  [例2][2]上下文管理

递推式构造列表(List Comprehensions)的追踪示例 。

*  [例3][3]伪追踪器的输出
 *  [例4][4]输出收集的堆栈信息

### 总结 ###

这个小项目是一个了解 Python 底层的良好途径，包括解释器的 main loop，Python 实现的 C 代码编程、Python 字节码。通过这个小工具我们可以看到 Python 一些有趣构造函数的字节码行为，例如生成器、上下文管理和递推式构造列表。

[这里][Link 4]是这个小项目的完整代码。更进一步的，我们还可以做的是修改我们所追踪的函数的堆栈。我虽然不确定这个是否有用，但是可以肯定是这一过程是相当有趣的。

**原文链接：** [Understanding Python execution from inside: A Python assembly tracer][Understanding Python execution from inside_ A Python assembly tracer]

[OneAPM]: http://www.oneapm.com/
[Include_opcode.h]: https://github.com/python/cpython/blob/master/Include/opcode.h
[view plain]: http://www.csdn.net/article/2015-05-28/2824795#
[goto]: http://bugs.python.org/issue4753
[Link 1]: http://eli.thegreenplace.net/2012/07/12/computed-goto-for-efficient-dispatch-tables
[Quarkslab]: http://blog.quarkslab.com/building-an-obfuscated-python-interpreter-we-need-more-opcodes.html
[Link 2]: http://blog.hakril.net/articles/0-understanding-python-by-breaking-it.html
[Link 3]: https://docs.python.org/3.4/reference/datamodel.html
[dis]: https://docs.python.org/3.4/library/dis.html
[1]: http://hakril.net/python/article/example_dummy_trace.html
[2]: http://hakril.net/python/article/example_dummy_contextmanager.html
[3]: http://hakril.net/python/article/example_list_comp_dummy.html
[4]: http://hakril.net/python/article/example_list_comp_stacktrace.html
[Link 4]: http://hakril.net/blog_data/assembly_tracer_code.zip
[Understanding Python execution from inside_ A Python assembly tracer]: http://blog.hakril.net/articles/2-understanding-python-execution-tracer.html