在本篇文章當中主要給大家介紹 cpython 虛擬機對于字節(jié)碼的設計以及在調試過程當中一個比較重要的字段 co_lnotab 的設計原理！

python 字節(jié)碼設計

一條 python 字節(jié)碼主要有兩部分組成，一部分是操作碼，一部分是這個操作碼的參數，在 cpython 當中只有部分字節(jié)碼有參數，如果對應的字節(jié)碼沒有參數，那么 oparg 的值就等于 0 ，在 cpython 當中 opcode < 90 的指令是沒有參數的。

opcode 和 oparg 各占一個字節(jié)，cpython 虛擬機使用小端方式保存字節(jié)碼。

我們使用下面的代碼片段先了解一下字節(jié)碼的設計：

import dis


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


if __name__ == '__main__':
    print(add.__code__.co_code)
    print("bytecode: ", list(bytearray(add.__code__.co_code)))
    dis.dis(add)

上面的代碼在 python3.9 的輸出如下所示：

b'|\x00|\x01\x17\x00S\x00'
bytecode:  [124, 0, 124, 1, 23, 0, 83, 0]
  5           0 LOAD_FAST                0 (a)
              2 LOAD_FAST                1 (b)
              4 BINARY_ADD
              6 RETURN_VALUE

首先 需要了解的是 add.__code__.co_code 是函數 add 的字節(jié)碼，是一個字節(jié)序列，list(bytearray(add.__code__.co_code)) 是將和這個序列一個字節(jié)一個字節(jié)進行分開，并且將其變成 10 進制形式。根據前面我們談到的每一條指令——字節(jié)碼占用 2 個字節(jié)，因此上面的字節(jié)碼有四條指令：

操作碼和對應的操作指令在文末有詳細的對應表。在上面的代碼當中主要使用到了三個字節(jié)碼指令分別是 124，23 和 83 ，他們對應的操作指令分別為 LOAD_FAST，BINARY_ADD，RETURN_VALUE。他們的含義如下：

LOAD_FAST：將 varnames[var_num] 壓入棧頂。 BINARY_ADD：從棧中彈出兩個對象并且將它們相加的結果壓入棧頂。 RETURN_VALUE：彈出棧頂的元素，將其作為函數的返回值。

首先我們需要知道的是 BINARY_ADD 和 RETURN_VALUE，這兩個操作指令是沒有參數的，因此在這兩個操作碼之后的參數都是 0 。

但是 LOAD_FAST 是有參數的，在上面我們已經知道 LOAD_FAST 是將 co-varnames[var_num] 壓入棧，var_num 就是指令 LOAD_FAST 的參數。在上面的代碼當中一共有兩條 LOAD_FAST 指令，分別是將 a 和 b 壓入到棧中，他們在 varnames 當中的下標分別是 0 和 1，因此他們的操作數就是 0 和 1 。

字節(jié)碼擴展參數

在上面我們談到的 python 字節(jié)碼操作數和操作碼各占一個字節(jié)，但是如果 varnames 或者常量表的數據的個數大于 1 個字節(jié)的表示范圍的話那么改如何處理呢？

為了解決這個問題，cpython 為字節(jié)碼設計的擴展參數，比如說我們要加載常量表當中的下標為 66113 的對象，那么對應的字節(jié)碼如下：

[144, 1, 144, 2, 100, 65] 

其中 144 表示 EXTENDED_ARG，他本質上不是一個 python 虛擬機需要執(zhí)行的字節(jié)碼，這個字段設計出來主要是為了用與計算擴展參數的。

100 對應的操作指令是 LOAD_CONST ，其操作碼是 65，但是上面的指令并不會加載常量表當中下標為 65 對象，而是會加載下標為 66113 的對象，原因就是因為 EXTENDED_ARG 。

現在來模擬一下上面的分析過程：

先讀取一條字節(jié)碼指令，操作碼等于 144 ，說明是擴展參數，那么此時的參數 arg 就等于 (1 x (1 << 8)) = 256 。 讀取第二條字節(jié)碼指令，操作碼等于 144 ，說明是擴展參數，因為前面 arg 已經存在切不等于 0 了，那么此時 arg 的計算方式已經發(fā)生了改變，arg = arg << 8 + 2 << 8 ，也就是說原來的 arg 乘以 256 再加上新的操作數乘以 256 ，此時 arg = 66048 。 讀取第三條字節(jié)碼指令，操作碼等于 100，此時是 LOAD_CONST 這條指令，那么此時的操作碼等于 arg += 65，因為操作碼不是 EXTENDED_ARG 因此操作數不需要在乘以 256 了。

上面的計算過程用程序代碼表示如下，下面的代碼當中 code 就是真正的字節(jié)序列 HAVE_ARGUMENT = 90 。

def _unpack_opargs(code):
    extended_arg = 0
    for i in range(0, len(code), 2):
        op = code[i]
        if op >= HAVE_ARGUMENT:
            arg = code[i+1] | extended_arg
            extended_arg = (arg << 8) if op == EXTENDED_ARG else 0
        else:
            arg = None
        yield (i, op, arg)

我們可以使用代碼來驗證我們前面的分析：

import dis


def num_to_byte(n):
    return n.to_bytes(1, "little")


def nums_to_bytes(data):
    ans = b"".join([num_to_byte(n) for n in data])
    return ans


if __name__ == '__main__':
    # extended_arg extended_num opcode oparg for python_version > 3.5
    bytecode = nums_to_bytes([144, 1, 144, 2, 100, 65])
    print(bytecode)
    dis.dis(bytecode)

上面的代碼輸出結果如下所示：

b'\x90\x01\x90\x02dA'
          0 EXTENDED_ARG             1
          2 EXTENDED_ARG           258
          4 LOAD_CONST           66113 (66113)

根據上面程序的輸出結果可以看到我們的分析結果是正確的。

源代碼字節(jié)碼映射表

在本小節(jié)主要分析一個 code object 對象當中的 co_lnotab 字段，通過分析一個具體的字段來學習這個字段的設計。

import dis


def add(a, b):
    a += 1
    b += 2
    return a + b


if __name__ == '__main__':
    dis.dis(add.__code__)
    print(f"{list(bytearray(add.__code__.co_lnotab)) = }")
    print(f"{add.__code__.co_firstlineno = }")

首先 dis 的輸出第一列是字節(jié)碼對應的源代碼的行號，第二列是字節(jié)碼在字節(jié)序列當中的位移。

上面的代碼輸出結果如下所示：

  源代碼的行號  字節(jié)碼的位移
  6           0 LOAD_FAST                0 (a)
              2 LOAD_CONST               1 (1)
              4 INPLACE_ADD
              6 STORE_FAST               0 (a)

  7           8 LOAD_FAST                1 (b)
             10 LOAD_CONST               2 (2)
             12 INPLACE_ADD
             14 STORE_FAST               1 (b)

  8          16 LOAD_FAST                0 (a)
             18 LOAD_FAST                1 (b)
             20 BINARY_ADD
             22 RETURN_VALUE
list(bytearray(add.__code__.co_lnotab)) = [0, 1, 8, 1, 8, 1]
add.__code__.co_firstlineno = 5

從上面代碼的輸出結果可以看出字節(jié)碼一共分成三段，每段表示一行代碼的字節(jié)碼?，F在我們來分析一下 co_lnotab 這個字段，這個字段其實也是兩個字節(jié)為一段的。比如上面的 [0, 1, 8, 1, 8, 1] 就可以分成三段 [0, 1], [8, 1], [8, 1] 。這其中的含義分別為：

第一個數字表示距離上一行代碼的字節(jié)碼數目。 第二個數字表示距離上一行有效代碼的行數。

現在我們來模擬上面代碼的字節(jié)碼的位移和源代碼行數之間的關系：

[0, 1]，說明這行代碼離上一行代碼的字節(jié)位移是 0 ，因此我們可以看到使用 dis 輸出的字節(jié)碼 LOAD_FAST ，前面的數字是 0，距離上一行代碼的行數等于 1 ，代碼的第一行的行號等于 5，因此 LOAD_FAST 對應的行號等于 5 + 1 = 6 。 [8, 1]，說明這行代碼距離上一行代碼的字節(jié)位移為 8 個字節(jié)，因此第二塊的 LOAD_FAST 前面是 8 ，距離上一行代碼的行數等于 1，因此這個字節(jié)碼對應的源代碼的行號等于 6 + 1 = 7。 [8, 1]，同理可以知道這塊字節(jié)碼對應源代碼的行號是 8 。

現在有一個問題是當兩行代碼之間相距的行數超過 一個字節(jié)的表示范圍怎么辦？在 python3.5 以后如果行數差距大于 127，那么就使用 (0, 行數) 對下一個組合進行表示，(0, \(x_1\)), (0,$ x_2$) ... ，直到 \(x_1 + ... + x_n\) = 行數。

在后面的程序當中我們會使用 compile 這個 python 內嵌函數。當你使用Python編寫代碼時，可以使用compile()函數將Python代碼編譯成字節(jié)代碼對象。這個字節(jié)碼對象可以被傳遞給Python的解釋器或虛擬機，以執(zhí)行代碼。

compile()函數接受三個參數：

source: 要編譯的Python代碼，可以是字符串，字節(jié)碼或AST對象。 filename: 代碼來源的文件名（如果有），通常為字符串。 mode: 編譯代碼的模式?？梢允?'exec'、'eval' 或 'single' 中的一個。'exec' 模式用于編譯多行代碼，'eval' 用于編譯單個表達式，'single' 用于編譯單行代碼。

import dis

code = """
x=1
y=2
""" \
+ "\n" * 500 + \
"""
z=x+y
"""

code = compile(code, '<string>', 'exec')
print(list(bytearray(code.co_lnotab)))
print(code.co_firstlineno)
dis.dis(code)

上面的代碼輸出結果如下所示：

[0, 1, 4, 1, 4, 127, 0, 127, 0, 127, 0, 121]
1
  2           0 LOAD_CONST               0 (1)
              2 STORE_NAME               0 (x)

  3           4 LOAD_CONST               1 (2)
              6 STORE_NAME               1 (y)

505           8 LOAD_NAME                0 (x)
             10 LOAD_NAME                1 (y)
             12 BINARY_ADD
             14 STORE_NAME               2 (z)
             16 LOAD_CONST               2 (None)
             18 RETURN_VALUE

根據我們前面的分析因為第三行和第二行之間的差距大于 127 ，因此后面的多個組合都是用于表示行數的。

505 = 3(前面已經有三行了) + (127 + 127 + 127 + 121)(這個是第二行和第三行之間的差距，這個值為 502，中間有 500 個換行但是因為字符串相加的原因還增加了兩個換行，因此一共是 502 個換行)。

具體的算法用代碼表示如下所示，下面的參數就是我們傳遞給 dis 模塊的 code，也就是一個 code object 對象。

def findlinestarts(code):
    """Find the offsets in a byte code which are start of lines in the source.

    Generate pairs (offset, lineno) as described in Python/compile.c.

    """
    byte_increments = code.co_lnotab[0::2]
    line_increments = code.co_lnotab[1::2]
    bytecode_len = len(code.co_code)

    lastlineno = None
    lineno = code.co_firstlineno
    addr = 0
    for byte_incr, line_incr in zip(byte_increments, line_increments):
        if byte_incr:
            if lineno != lastlineno:
                yield (addr, lineno)
                lastlineno = lineno
            addr += byte_incr
            if addr >= bytecode_len:
                # The rest of the lnotab byte offsets are past the end of
                # the bytecode, so the lines were optimized away.
                return
        if line_incr >= 0x80:
            # line_increments is an array of 8-bit signed integers
            line_incr -= 0x100
        lineno += line_incr
    if lineno != lastlineno:
        yield (addr, lineno)

總結

在本篇文章當中主要給大家介紹了 cpython 當中對于字節(jié)碼和源代碼和字節(jié)碼之間的映射關系的具體設計，這對于我們深入去理解 cpython 虛擬機的設計非常有幫助！

本篇文章是深入理解 python 虛擬機系列文章之一，文章地址：https://github.com/Chang-LeHung/dive-into-cpython

更多精彩內容合集可訪問項目：https://github.com/Chang-LeHung/CSCore

到此這篇關于深入理解 python 虛擬機的文章就介紹到這了,更多相關深入理解 python 虛擬機內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論