我們現(xiàn)在擁有了注入 DEBUG_OP 的所有工具，讓我們來(lái)驗(yàn)證下我們的實(shí)現(xiàn)是否可用。我們將我們的操作碼注入到一個(gè)最簡(jiǎn)單的函數(shù)中：

    from new_code import MutableCodeObject  

    def op_target(*args):  
        print("WOOT")  
        print("op_target called with args <{0}>".format(args))  

    def nop():  
       pass  

    new_nop_code = MutableCodeObject(nop.__code__)  
    new_nop_code.co_code = b"x00" + new_nop_code.co_code[0:3] +  b"x00" + new_nop_code.co_code[-1:]  
    new_nop_code.co_stacksize += 3  

    nop.__code__ = new_nop_code.get_code()  

    import dis  
    dis.dis(nop)  
    nop()  


    # Don"t forget that ./python is our custom Python implementing       DEBUG_OP  
    hakril@computer ~/python/CPython3.5 % ./python proof.py  
      8           0 <0>  
                  1 LOAD_CONST               0 (None)  
                  4 <0>  
                  5 RETURN_VALUE  
    WOOT  
    op_target called with args <([], )>  
    WOOT  
    op_target called with args <([None], )>  

看起來(lái)它成功了！有一行代碼需要說(shuō)明一下 new_nop_code.co_stacksize += 3

co_stacksize 表示 code object 所需要的堆棧的大小

操作碼DEBUG_OP往堆棧中增加了三項(xiàng)，所以我們需要為這些增加的項(xiàng)預(yù)留些空間

現(xiàn)在我們可以將我們的操作碼注入到每一個(gè) Python 函數(shù)中了！

正如我們?cè)谏厦娴睦又兴吹降哪菢樱貙?xiě) Pyhton 的字節(jié)碼似乎 so easy。為了在每一個(gè)操作碼之間注入我們的操作碼，我們需要獲取每一個(gè)操作碼的偏移量，然后將我們的操作碼注入到這些位置上(把我們操作碼注入到參數(shù)上是有壞處大大滴)。這些偏移量也很容易獲取，使用 dis.Bytecode，就像這樣。

    def add_debug_op_everywhere(code_obj):  
         # We get every instruction offset in the code object  
        offsets = [instr.offset for instr in dis.Bytecode(code_obj)]   
        # And insert a DEBUG_OP at every offset  
        return insert_op_debug_list(code_obj, offsets)  

    def insert_op_debug_list(code, offsets):  
         # We insert the DEBUG_OP one by one  
        for nb, off in enumerate(sorted(offsets)):  
            # Need to ajust the offsets by the number of opcodes          already inserted before  
            # That"s why we sort our offsets!  
            code = insert_op_debug(code, off + nb)  
        return code  

    # Last problem: what does insert_op_debug looks like?  

基于上面的例子，有人可能會(huì)想我們的 insert_op_debug 會(huì)在指定的偏移量增加一個(gè)"x00"，這尼瑪是個(gè)坑啊！我們第一個(gè) DEBUG_OP 注入的例子中被注入的函數(shù)是沒(méi)有任何的分支的，為了能夠?qū)崿F(xiàn)完美一個(gè)函數(shù)注入函數(shù) insert_op_debug 我們需要考慮到存在分支操作碼的情況。

Python 的分支一共有兩種：

絕對(duì)分支：看起來(lái)是類似這樣子的 Instruction_Pointer = argument(instruction)

相對(duì)分支：看起來(lái)是類似這樣子的 Instruction_Pointer += argument(instruction)

相對(duì)分支總是向前的

我們希望這些分支在我們插入操作碼之后仍然能夠正常工作，為此我們需要修改一些指令參數(shù)。以下是其邏輯流程：

對(duì)于每一個(gè)在插入偏移量之前的相對(duì)分支而言

如果目標(biāo)地址是嚴(yán)格大于我們的插入偏移量的話，將指令參數(shù)增加 1

如果相等，則不需要增加 1 就能夠在跳轉(zhuǎn)操作和目標(biāo)地址之間執(zhí)行我們的操作碼DEBUG_OP

如果小于，插入我們的操作碼的話并不會(huì)影響到跳轉(zhuǎn)操作和目標(biāo)地址之間的距離

對(duì)于 code object 中的每一個(gè)絕對(duì)分支而言

如果目標(biāo)地址是嚴(yán)格大于我們的插入偏移量的話，將指令參數(shù)增加 1

如果相等，那么不需要任何修改，理由和相對(duì)分支部分是一樣的

如果小于，插入我們的操作碼的話并不會(huì)影響到跳轉(zhuǎn)操作和目標(biāo)地址之間的距離

下面是實(shí)現(xiàn)：

    # Helper  
    def bytecode_to_string(bytecode):  
        if bytecode.arg is not None:  
            return struct.pack(" offset:  
                    res_codestring +=      bytecode_to_string(DummyInstr(instr.opcode, instr.arg + 1))  
                    continue  
            res_codestring += bytecode_to_string(instr)  
        # replace_bytecode just replaces the original code co_code  
        return replace_bytecode(code, res_codestring)  

讓我們看一下效果如何：

    >>> def lol(x):  
    ...     for i in range(10):  
    ...         if x == i:  
    ...             break  

    >>> dis.dis(lol)  
    101           0 SETUP_LOOP              36 (to 39)  
                  3 LOAD_GLOBAL              0 (range)  
                  6 LOAD_CONST               1 (10)  
                  9 CALL_FUNCTION            1 (1 positional, 0    keyword pair)  
                 12 GET_ITER  
            >>   13 FOR_ITER                22 (to 38)  
                 16 STORE_FAST               1 (i)  

    102          19 LOAD_FAST                0 (x)  
                 22 LOAD_FAST                1 (i)  
                 25 COMPARE_OP               2 (==)  
                 28 POP_JUMP_IF_FALSE       13  

    103          31 BREAK_LOOP  
                 32 JUMP_ABSOLUTE           13  
                 35 JUMP_ABSOLUTE           13  
            >>   38 POP_BLOCK  
            >>   39 LOAD_CONST               0 (None)  
                 42 RETURN_VALUE  
    >>> lol.__code__ = transform_code(lol.__code__,        add_debug_op_everywhere, add_stacksize=3)  


    >>> dis.dis(lol)  
    101           0 <0>  
                  1 SETUP_LOOP              50 (to 54)  
                  4 <0>  
                  5 LOAD_GLOBAL              0 (range)  
                  8 <0>  
                  9 LOAD_CONST               1 (10)  
                 12 <0>  
                 13 CALL_FUNCTION            1 (1 positional, 0   keyword pair)  
                 16 <0>  
                 17 GET_ITER  
            >>   18 <0>  

    102          19 FOR_ITER                30 (to 52)  
                 22 <0>  
                 23 STORE_FAST               1 (i)  
                 26 <0>  
                 27 LOAD_FAST                0 (x)  
                 30 <0>  

    103          31 LOAD_FAST                1 (i)  
                 34 <0>  
                 35 COMPARE_OP               2 (==)  
                 38 <0>  
                 39 POP_JUMP_IF_FALSE       18  
                 42 <0>  
                 43 BREAK_LOOP  
                 44 <0>  
                 45 JUMP_ABSOLUTE           18  
                 48 <0>  
                 49 JUMP_ABSOLUTE           18  
            >>   52 <0>  
                 53 POP_BLOCK  
            >>   54 <0>  
                 55 LOAD_CONST               0 (None)  
                 58 <0>  
                 59 RETURN_VALUE  

     # Setup the simplest handler EVER  
    >>> def op_target(stack, frame):  
    ...     print (stack)  

    # GO  
    >>> lol(2)  
    []  
    []  
    []  
    [10, ]  
    [range(0, 10)]  
    []  
    [0, ]  
    []  
    [2, ]  
    [0, 2, ]  
    [False, ]  
    []  
    [1, ]  
    []  
    [2, ]  
    [1, 2, ]  
    [False, ]  
    []  
    [2, ]  
    []  
    [2, ]  
    [2, 2, ]  
    [True, ]  
    []  
    []  
    [None]  

甚好！現(xiàn)在我們知道了如何獲取堆棧信息和 Python 中每一個(gè)操作對(duì)應(yīng)的幀信息。上面結(jié)果所展示的結(jié)果目前而言并不是很實(shí)用。在最后一部分中讓我們對(duì)注入做進(jìn)一步的封裝。

正如您所見(jiàn)到的，所有的底層接口都是好用的。我們最后要做的一件事是讓 op_target 更加方便使用(這部分相對(duì)而言比較空泛一些，畢竟在我看來(lái)這不是整個(gè)項(xiàng)目中最有趣的部分)。

首先我們來(lái)看一下幀的參數(shù)所能提供的信息，如下所示：

f_code當(dāng)前幀將執(zhí)行的 code object

f_lasti當(dāng)前的操作(code object 中的字節(jié)碼字符串的索引)

經(jīng)過(guò)我們的處理我們可以得知 DEBUG_OP 之后要被執(zhí)行的操作碼，這對(duì)我們聚合數(shù)據(jù)并展示是相當(dāng)有用的。

新建一個(gè)用于追蹤函數(shù)內(nèi)部機(jī)制的類：

改變函數(shù)自身的 co_code

設(shè)置回調(diào)函數(shù)作為 op_debug 的目標(biāo)函數(shù)

一旦我們知道下一個(gè)操作，我們就可以分析它并修改它的參數(shù)。舉例來(lái)說(shuō)我們可以增加一個(gè) auto-follow-called-functions 的特性。

    def op_target(l, f, exc=None):  
        if op_target.callback is not None:  
            op_target.callback(l, f, exc)  

    class Trace:  
        def __init__(self, func):  
            self.func = func  

        def call(self, *args, **kwargs):  
             self.add_func_to_trace(self.func)  
            # Activate Trace callback for the func call  
            op_target.callback = self.callback  
            try:  
                res = self.func(*args, **kwargs)  
            except Exception as e:  
                res = e  
            op_target.callback = None  
            return res  

        def add_func_to_trace(self, f):  
            # Is it code? is it already transformed?  
            if not hasattr(f ,"op_debug") and hasattr(f, "__code__"):  
                f.__code__ = transform_code(f.__code__,    transform=add_everywhere, add_stacksize=ADD_STACK)  
                f.__globals__["op_target"] = op_target  
                f.op_debug = True  

        def do_auto_follow(self, stack, frame):  
            # Nothing fancy: FrameAnalyser is just the wrapper that  gives the next executed instruction  
            next_instr = FrameAnalyser(frame).next_instr()  
            if "CALL" in next_instr.opname:  
                arg = next_instr.arg  
                f_index = (arg & 0xff) + (2 * (arg >> 8))  
                called_func = stack[f_index]  

                # If call target is not traced yet: do it  
                if not hasattr(called_func, "op_debug"):  
                    self.add_func_to_trace(called_func)  

現(xiàn)在我們實(shí)現(xiàn)一個(gè) Trace 的子類，在這個(gè)子類中增加 callback 和 doreport 這兩個(gè)方法。callback 方法將在每一個(gè)操作之后被調(diào)用。doreport 方法將我們收集到的信息打印出來(lái)。

這是一個(gè)偽函數(shù)追蹤器實(shí)現(xiàn)：

    class DummyTrace(Trace):  
        def __init__(self, func):  
            self.func = func  
            self.data = collections.OrderedDict()  
            self.last_frame = None  
            self.known_frame = []  
            self.report = []  

        def callback(self, stack, frame, exc):  
             if frame not in self.known_frame:  
                self.known_frame.append(frame)  
                self.report.append(" === Entering New Frame {0} ({1})     ===".format(frame.f_code.co_name, id(frame)))  
                self.last_frame = frame  
            if frame != self.last_frame:  
                self.report.append(" === Returning to Frame {0}     {1}===".format(frame.f_code.co_name, id(frame)))  
                self.last_frame = frame  

            self.report.append(str(stack))  
            instr = FrameAnalyser(frame).next_instr()  
            offset = str(instr.offset).rjust(8)  
            opname = str(instr.opname).ljust(20)  
            arg = str(instr.arg).ljust(10)  
            self.report.append("{0}  {1} {2} {3}".format(offset,    opname, arg, instr.argval))  
            self.do_auto_follow(stack, frame)  

        def do_report(self):  
            print("
".join(self.report))  

這里有一些實(shí)現(xiàn)的例子和使用方法。格式有些不方便觀看，畢竟我并不擅長(zhǎng)于搞這種對(duì)用戶友好的報(bào)告的事兒。

例1自動(dòng)追蹤堆棧信息和已經(jīng)執(zhí)行的指令

例2上下文管理

遞推式構(gòu)造列表(List Comprehensions)的追蹤示例。

例3偽追蹤器的輸出

例4輸出收集的堆棧信息

這個(gè)小項(xiàng)目是一個(gè)了解 Python 底層的良好途徑，包括解釋器的 main loop，Python 實(shí)現(xiàn)的 C 代碼編程、Python 字節(jié)碼。通過(guò)這個(gè)小工具我們可以看到 Python 一些有趣構(gòu)造函數(shù)的字節(jié)碼行為，例如生成器、上下文管理和遞推式構(gòu)造列表。

這里是這個(gè)小項(xiàng)目的完整代碼。更進(jìn)一步的，我們還可以做的是修改我們所追蹤的函數(shù)的堆棧。我雖然不確定這個(gè)是否有用，但是可以肯定是這一過(guò)程是相當(dāng)有趣的。

本文作者系OneAPM工程師編譯整理。想閱讀更多技術(shù)文章，請(qǐng)?jiān)L問(wèn)OneAPM官方技術(shù)博客。