Pyc字节码分析虚拟机指令集分析

2022-02-13

字数统计: 8.9k字 | 阅读时长≈ 42分

12号玩了玩VNCTF2022，感觉自己又菜了114514倍。以前学习的时候都是每个小模块稍微学习一下就浅尝辄止了，现在决心死磕一个板块，一个一个搞透了。

Pyc字节码分析——虚拟机指令集分析

注意

关于本博客主旨

dis — Python 字节码反汇编器 — Python 3.10.2 文档

作为官方文档的补充，在此基础上提供一些例子。冷门指令（也就是我搞不懂的）不讲
老版本中被抛弃的指令显然是因为不好用且很少用，所以我直接选取最高版本3.10.2的指令集分析。

提示

Py36以上，每条指令使用2个字节。
dis 模块通过反汇编支持CPython的 bytecode 分析。该模块作为输入的 CPython 字节码在文件 Include/opcode.h 中定义，并由编译器和解释器使用。

环境

1	Python3.10.2

dis模块

1 2	def myfunc(alist): return len(alist)

`dis.dis()`显示反汇编

>>> dis.dis(myfunc)
  2           0 LOAD_GLOBAL              0 (len)
              2 LOAD_FAST                0 (alist)
              4 CALL_FUNCTION            1
              6 RETURN_VALUE

`Bytecode`对象

>>> bytecode = dis.Bytecode(myfunc)
>>> for instr in bytecode:
...     print(instr.opname)
...
LOAD_GLOBAL
LOAD_FAST
CALL_FUNCTION
RETURN_VALUE

from_traceback(tb)

从给定traceback构造一个 Bytecode 实例，将设置 current_offset 为异常负责的指令。

codeobj

已编译的代码对象。

first_line

代码对象的第一个源代码行（如果可用）

dis()

返回字节码操作的格式化视图（与 dis.dis() 打印相同，但作为字符串返回）。

info()

返回带有关于代码对象的详细信息的格式化多行字符串，如 code_info() 。

>>> bytecode.dis()
'  2           0 LOAD_GLOBAL              0 (len)\n              2 LOAD_FAST                0 (alist)\n              4 CALL_FUNCTION            1\n              6 RETURN_VALUE\n'
>>> bytecode.info()
'Name:              myfunc\nFilename:          <stdin>\nArgument count:    1\nKw-only arguments: 0\nNumber of locals:  1\nStack size:        2\nFlags:             OPTIMIZED, NEWLOCALS, NOFREE\nConstants:\n   0: None\nNames:\n   0: len\nVariable names:\n   0: alist'
>>> bytecode.first_line
1
>>> bytecode.codeobj
<code object myfunc at 0x000001E40D173E40, file "<stdin>", line 1>

函数

我常用的是

1 2	dis.dis() dis.code_info(x)

>>> dis.dis(myfunc)
  2           0 LOAD_GLOBAL              0 (len)
              2 LOAD_FAST                0 (alist)
              4 CALL_FUNCTION            1
              6 RETURN_VALUE
>>> dis.code_info(myfunc)
'Name:              myfunc\nFilename:          <stdin>\nArgument count:    1\nKw-only arguments: 0\nNumber of locals:  1\nStack size:        2\nFlags:             OPTIMIZED, NEWLOCALS, NOFREE\nConstants:\n   0: None\nNames:\n   0: len\nVariable names:\n   0: alist'

其他的省略。

指令集分析

TOS：”Top of Stack”，栈顶

里面有一些指令我没有设置成小标题，因为我不清楚其意思和用法。

无参指令

`NOP`

什么都不做。用作字节码优化器的占位符。

>>> dis.opmap['NOP']
9
>>> dis.dis(b'\x09\x00')
          0 NOP

`POP_TOP`

删除堆栈顶部（TOS）项。

>>> def func():
...     return 2
...
>>> def callfunc():
...     func()
...

>>> dis.dis(callfunc)
  2           0 LOAD_GLOBAL              0 (func)
              2 CALL_FUNCTION            0
              4 POP_TOP
              6 LOAD_CONST               0 (None)
              8 RETURN_VALUE
            
>>> def callfunc2():
...     a = func()
...
>>> dis.dis(callfunc2)
  2           0 LOAD_GLOBAL              0 (func)
              2 CALL_FUNCTION            0
              4 STORE_FAST               0 (a)
              6 LOAD_CONST               0 (None)
              8 RETURN_VALUE

常用于抛弃函数的返回值。

`ROT_TWO`

交换两个最顶层的堆栈项。

>>> def func():
...     a, b = b, a
...
>>> dis.dis(func)
  2           0 LOAD_FAST                0 (b)
              2 LOAD_FAST                1 (a)
              4 ROT_TWO
              6 STORE_FAST               1 (a)
              8 STORE_FAST               0 (b)
             10 LOAD_CONST               0 (None)
             12 RETURN_VALUE

交换值时会遇到。

`ROT_THREE`

将第二个和第三个堆栈项向上提升一个位置，顶项移动到位置三。

>>> def func():
...     a, b, c = c, b, a
...
>>> dis.dis(func)
  2           0 LOAD_FAST                0 (c)
              2 LOAD_FAST                1 (b)
              4 LOAD_FAST                2 (a)
              6 ROT_THREE
              8 ROT_TWO
             10 STORE_FAST               2 (a)
             12 STORE_FAST               1 (b)
             14 STORE_FAST               0 (c)
             16 LOAD_CONST               0 (None)
             18 RETURN_VALUE

`ROT_FOUR`（Py38）

将第二个、第三个和第四个堆栈项向上提升一个位置，将顶项移动到第四个位置。

大于4个参数的相互交换就使用元组（BUILD_TUPLE）指令了，故暂时找不到例子

`DUP_TOP`（Py32）

复制堆栈顶部的引用。

Python: 链式赋值的坑 - SegmentFault 思否

>>> def func():
...     a = b = c = 3
...
>>> dis.dis(func)
  2           0 LOAD_CONST               1 (3)
              2 DUP_TOP
              4 STORE_FAST               0 (a)
              6 DUP_TOP
              8 STORE_FAST               1 (b)
             10 STORE_FAST               2 (c)
             12 LOAD_CONST               0 (None)
             14 RETURN_VALUE

链式赋值时会用上。

作用

复制栈顶元素
然后push进栈中

这样栈顶就有两个一样的”对象”了。但是，似乎栈上的都是对象指针，所以实际上指向的是同一个对象。

且Python的链式赋值和C的不一样。Python中的链式赋值似乎是从左往右走的。

>>> def func():
...     a = b = c = hashlib.md5()
...     print(a)
...     print(b)
...     print(c)
...
>>> dis.dis(func)
  2           0 LOAD_GLOBAL              0 (hashlib)
              2 LOAD_METHOD              1 (md5)
              4 CALL_METHOD              0
              6 DUP_TOP
              8 STORE_FAST               0 (a)
             10 DUP_TOP
             12 STORE_FAST               1 (b)
             14 STORE_FAST               2 (c)

  3          16 LOAD_GLOBAL              2 (print)
             18 LOAD_FAST                0 (a)
             20 CALL_FUNCTION            1
             22 POP_TOP

  4          24 LOAD_GLOBAL              2 (print)
             26 LOAD_FAST                1 (b)
             28 CALL_FUNCTION            1
             30 POP_TOP

  5          32 LOAD_GLOBAL              2 (print)
             34 LOAD_FAST                2 (c)
             36 CALL_FUNCTION            1
             38 POP_TOP
             40 LOAD_CONST               0 (None)
             42 RETURN_VALUE
>>> func()
<md5 _hashlib.HASH object @ 0x00000152FDDD19D0>
<md5 _hashlib.HASH object @ 0x00000152FDDD19D0>
<md5 _hashlib.HASH object @ 0x00000152FDDD19D0>

可以发现a, b, c指向的是同一个地址空间下的对象。

>>> def func():
...     s = [1, 2, 3, 4, 5]
...     i = 0
...     i = s[i] = 3
...     print(s)
...
>>> func()
[1, 2, 3, 3, 5]
>>> dis.dis(func)
  2           0 BUILD_LIST               0
              2 LOAD_CONST               1 ((1, 2, 3, 4, 5))
              4 LIST_EXTEND              1
              6 STORE_FAST               0 (s)

  3           8 LOAD_CONST               2 (0)
             10 STORE_FAST               1 (i)

  4          12 LOAD_CONST               3 (3)
             14 DUP_TOP
             16 STORE_FAST               1 (i)
             18 LOAD_FAST                0 (s)
             20 LOAD_FAST                1 (i)
             22 STORE_SUBSCR

  5          24 LOAD_GLOBAL              0 (print)
             26 LOAD_FAST                0 (s)
             28 CALL_FUNCTION            1
             30 POP_TOP
             32 LOAD_CONST               0 (None)
             34 RETURN_VALUE

由于从左到右，所以i先变成了3，进而对s[3]进行了修改，而不是s[0]。

//取自 python/ceval.c

PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
{
        ... (省略)
        TARGET_NOARG(DUP_TOP)
        {
            v = TOP();    // 复制运行栈帧的顶部值
            Py_INCREF(v); // 增加引用计数
            PUSH(v);      // 再压入运行栈帧
            FAST_DISPATCH();
        }
        ... (省略)
}

`DUP_TOP_TWO`（Py32）

复制堆栈顶部的两个引用，使它们保持相同的顺序。

没怎么见过。

一元操作

偷懒，能用lambda表达式的就用。

`UNARY_POSITIVE`

实现 TOS = +TOS 。

>>> dis.dis(lambda x : +x)
  1           0 LOAD_FAST                0 (x)
              2 UNARY_POSITIVE
              4 RETURN_VALUE

`UNARY_NEGATIVE`

实现 TOS = -TOS 。

>>> dis.dis(lambda x : -x)
  1           0 LOAD_FAST                0 (x)
              2 UNARY_NEGATIVE
              4 RETURN_VALUE

`UNARY_NOT`

实现 TOS = not TOS 。

>>> dis.dis(lambda x : not x)
  1           0 LOAD_FAST                0 (x)
              2 UNARY_NOT
              4 RETURN_VALUE

`UNARY_INVERT`

实现 TOS = ~TOS 。

>>> y = lambda x : ~x
>>> dis.dis(y)
  1           0 LOAD_FAST                0 (x)
              2 UNARY_INVERT
              4 RETURN_VALUE

`GET_ITER`

实现 TOS = iter(TOS) 。

原地将原来的对象引用变成迭代器对象。

>>> def func():
...     for i in range(10):
...             pass
...
>>> dis.dis(func)
  2           0 LOAD_GLOBAL              0 (range)
              2 LOAD_CONST               1 (10)
              4 CALL_FUNCTION            1
              6 GET_ITER
        >>    8 FOR_ITER                 2 (to 14)
             10 STORE_FAST               0 (i)

  3          12 JUMP_ABSOLUTE            4 (to 8)

  2     >>   14 LOAD_CONST               0 (None)
             16 RETURN_VALUE
        
>>> def func():
...     s = [1,2,3]
...     for i in s:
...             pass
...
>>> dis.dis(func)
  2           0 BUILD_LIST               0
              2 LOAD_CONST               1 ((1, 2, 3))
              4 LIST_EXTEND              1
              6 STORE_FAST               0 (s)	# s = list().

  3           8 LOAD_FAST                0 (s)
             10 GET_ITER
        >>   12 FOR_ITER                 2 (to 18)
             14 STORE_FAST               1 (i)

  4          16 JUMP_ABSOLUTE            6 (to 12)

  3     >>   18 LOAD_CONST               0 (None)
             20 RETURN_VALUE

在使用for i in xxx遍历数组，range()对象等可遍历对象时，会调用此指令。但是显性地使用iter()函数，则会编译成函数调用。

>>> dis.dis(lambda x: iter(x))
  1           0 LOAD_GLOBAL              0 (iter)
              2 LOAD_FAST                0 (x)
              4 CALL_FUNCTION            1
              6 RETURN_VALUE

`GET_YIELD_FROM_ITER`

如果 TOS 是一个 generator iterator 或 coroutine 对象则保持原样。否则实现 TOS = iter(TOS) 。

没找到用法。

二元操作

二元操作从堆栈中删除堆栈顶部（TOS）和第二个最顶层堆栈项（TOS1）。它们执行操作，并将结果放回堆栈。

`BINARY_POWER`

实现 TOS = TOS1 ** TOS 。

>>> dis.dis(lambda x,y : x**y)
  1           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 BINARY_POWER
              6 RETURN_VALUE

`BINARY_MULTIPLY`

实现 TOS = TOS1 * TOS 。

>>> dis.dis(lambda x,y : x*y)
  1           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 BINARY_MULTIPLY
              6 RETURN_VALUE

`BINARY_MATRIX_MULTIPLY`（Py35）

实现 TOS = TOS1 @ TOS 。

本操作需要（大概率）外部导入模块比如numpy。

>>> def func():
...     a = np.matrix([[1,2],[3,4]])
...     b = np.matrix([5,6]).T
...     c = a@b
...     print(c)
>>> import dis
>>> dis.dis(func)
  2           0 LOAD_GLOBAL              0 (np)
              2 LOAD_METHOD              1 (matrix)
              4 LOAD_CONST               1 (1)
              6 LOAD_CONST               2 (2)
              8 BUILD_LIST               2
             10 LOAD_CONST               3 (3)
             12 LOAD_CONST               4 (4)
             14 BUILD_LIST               2
             16 BUILD_LIST               2
             18 CALL_METHOD              1
             20 STORE_FAST               0 (a)

  3          22 LOAD_GLOBAL              0 (np)
             24 LOAD_METHOD              1 (matrix)
             26 LOAD_CONST               5 (5)
             28 LOAD_CONST               6 (6)
             30 BUILD_LIST               2
             32 CALL_METHOD              1
             34 LOAD_ATTR                2 (T)
             36 STORE_FAST               1 (b)

  4          38 LOAD_FAST                0 (a)
             40 LOAD_FAST                1 (b)
             42 BINARY_MATRIX_MULTIPLY
             44 STORE_FAST               2 (c)

  5          46 LOAD_GLOBAL              3 (print)
             48 LOAD_FAST                2 (c)
             50 CALL_FUNCTION            1
             52 POP_TOP
             54 LOAD_CONST               0 (None)
             56 RETURN_VALUE

`BINARY_FLOOR_DIVIDE`

实现 TOS = TOS1 // TOS。

>>> dis.dis(lambda x,y : x//y)
  1           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 BINARY_FLOOR_DIVIDE
              6 RETURN_VALUE

`BINARY_TRUE_DIVIDE`

实现 TOS = TOS1 / TOS 。

>>> dis.dis(lambda x,y : x/y)
  1           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 BINARY_TRUE_DIVIDE
              6 RETURN_VALUE

`BINARY_MODULO`

实现 TOS = TOS1 % TOS 。

>>> dis.dis(lambda x,y : x%y)
  1           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 BINARY_MODULO
              6 RETURN_VALUE

`BINARY_ADD`

实现 TOS = TOS1 + TOS 。

>>> dis.dis(lambda x,y : x+y)
  1           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 BINARY_ADD
              6 RETURN_VALUE

`BINARY_SUBTRACT`

实现 TOS = TOS1 - TOS 。

>>> dis.dis(lambda x,y : x-y)
  1           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 BINARY_SUBTRACT
              6 RETURN_VALUE

`BINARY_SUBSCR`

实现 TOS = TOS1[TOS] 。

>>> dis.dis(lambda s,i : s[i])
  1           0 LOAD_FAST                0 (s)
              2 LOAD_FAST                1 (i)
              4 BINARY_SUBSCR
              6 RETURN_VALUE

`BINARY_LSHIFT`

实现 TOS = TOS1 << TOS 。

>>> dis.dis(lambda x,y : x << y)
  1           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 BINARY_LSHIFT
              6 RETURN_VALUE

`BINARY_RSHIFT`

实现 TOS = TOS1 >> TOS 。

>>> dis.dis(lambda x,y : x >> y)
  1           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 BINARY_RSHIFT
              6 RETURN_VALUE

`BINARY_AND`

实现 TOS = TOS1 & TOS 。

>>> dis.dis(lambda x,y : x & y)
  1           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 BINARY_AND
              6 RETURN_VALUE

`BINARY_XOR`

实现 TOS = TOS1 ^ TOS 。

>>> dis.dis(lambda x,y : x | y)
  1           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 BINARY_XOR
              6 RETURN_VALUE

`BINARY_OR`

实现 TOS = TOS1 | TOS 。

>>> dis.dis(lambda x,y : x | y)
  1           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 BINARY_OR
              6 RETURN_VALUE

就地操作

就地操作就像二元操作，因为它们删除了TOS和TOS1，并将结果推回到堆栈上，但是当TOS1支持它时，操作就地完成，并且产生的TOS可能是（但不一定）原来的TOS1。

`INPLACE_POWER`

就地实现 TOS **= TOS1 。

>>> def func():
...     a = 2
...     a **= 2
...
>>> dis.dis(func)
  2           0 LOAD_CONST               1 (2)
              2 STORE_FAST               0 (a)

  3           4 LOAD_FAST                0 (a)
              6 LOAD_CONST               1 (2)
              8 INPLACE_POWER
             10 STORE_FAST               0 (a)
             12 LOAD_CONST               0 (None)
             14 RETURN_VALUE

`INPLACE_MULTIPLY`

就地实现 TOS *= TOS1 。

`INPLACE_MATRIX_MULTIPLY`

就地实现 TOS @= TOS1 。（Py35）

`INPLACE_FLOOR_DIVIDE`

就地实现 TOS //= TOS1 。

`INPLACE_TRUE_DIVIDE`

就地实现 TOS /= TOS1 。

`INPLACE_MODULO`

就地实现 TOS %= TOS1 。

`INPLACE_ADD`

就地实现 TOS += TOS1 。

`INPLACE_SUBTRACT`

就地实现 TOS -= TOS1 。

>>> def func():
...     a = 2
...     a -= 1
...
>>> dis.dis(func)
  2           0 LOAD_CONST               1 (2)
              2 STORE_FAST               0 (a)

  3           4 LOAD_FAST                0 (a)
              6 LOAD_CONST               2 (1)
              8 INPLACE_SUBTRACT
             10 STORE_FAST               0 (a)
             12 LOAD_CONST               0 (None)
             14 RETURN_VALUE

`INPLACE_LSHIFT`

就地实现 TOS <<= TOS1 。

`INPLACE_RSHIFT`

就地实现 TOS >>= TOS1 。

`INPLACE_AND`

就地实现 TOS &= TOS1 。

`INPLACE_XOR`

就地实现 TOS ^= TOS1 。

`INPLACE_OR`

就地实现 TOS |= TOS1 。

`STORE_SUBSCR`

实现 TOS1[TOS] = TOS2 。

>>> def func():
...     s = [1,2,3,4,5]
...     s[0] = 7
...
>>> dis.dis(func)
  2           0 BUILD_LIST               0
              2 LOAD_CONST               1 ((1, 2, 3, 4, 5))
              4 LIST_EXTEND              1
              6 STORE_FAST               0 (s)

  3           8 LOAD_CONST               2 (7)	# 2
             10 LOAD_FAST                0 (s)	# 1
             12 LOAD_CONST               3 (0)	# 0
             14 STORE_SUBSCR
             16 LOAD_CONST               0 (None)
             18 RETURN_VALUE

`DELETE_SUBSCR`

实现 del TOS1[TOS] 。

>>> def func():
...     s = [1,2,3,4,5]
...     del s[0]
...     print(s)
...
>>> dis.dis(func)
  2           0 BUILD_LIST               0
              2 LOAD_CONST               1 ((1, 2, 3, 4, 5))
              4 LIST_EXTEND              1
              6 STORE_FAST               0 (s)

  3           8 LOAD_FAST                0 (s)
             10 LOAD_CONST               2 (0)
             12 DELETE_SUBSCR

  4          14 LOAD_GLOBAL              0 (print)
             16 LOAD_FAST                0 (s)
             18 CALL_FUNCTION            1
             20 POP_TOP
             22 LOAD_CONST               0 (None)
             24 RETURN_VALUE

协程操作码（暂不分析）

GET_AWAITABLE（Py35）

实现 TOS = get_awaitable(TOS) ，其中 get_awaitable(o) 返回 o 如果 o 是一个有 CO_ITERABLE_COROUTINE 标志的协程对象或生成器对象，否则解析 o.__await__ 。

GET_AITER

实现 TOS = TOS.__aiter__() 。（Py35）

在 3.7 版更改：已经不再支持从 __aiter__ 返回可等待对象。

GET_ANEXT

实现 PUSH(get_awaitable(TOS.__anext__())) 。参见 GET_AWAITABLE 获取更多 get_awaitable 的细节（Py35）

END_ASYNC_FOR

终止一个 async for 循环。处理等待下一个项目时引发的异常。如果 TOS 是 StopAsyncIteration，从堆栈弹出7个值，并使用后三个恢复异常状态。否则，使用堆栈中的三个值重新引发异常。从块堆栈中删除异常处理程序块。（Py38）

BEFORE_ASYNC_WITH

从栈顶对象解析 __aenter__ 和 __aexit__ 。将 __aexit__ 和 __aenter__() 的结果推入堆栈。（Py35）

SETUP_ASYNC_WITH

创建一个新的帧对象。（Py35）

其他操作码

`PRINT_EXPR`

实现交互模式的表达式语句。TOS从堆栈中被移除并打印。在非交互模式下，表达式语句以 POP_TOP 终止。

一般情况下遇不到。

`SET_ADD(i)`

调用 set.add(TOS1[-i], TOS) 。用于实现集合推导。

>>> def func():
...     s = {x+1 for x in [1,2,3,4,4,5,]}
...
>>> dis.dis(func)
  2           0 LOAD_CONST               1 (<code object <setcomp> at 0x00000152FDE23E10, file "<stdin>", line 2>)
              2 LOAD_CONST               2 ('func.<locals>.<setcomp>')
              4 MAKE_FUNCTION            0
              6 LOAD_CONST               3 ((1, 2, 3, 4, 4, 5))
              8 GET_ITER
             10 CALL_FUNCTION            1
             12 STORE_FAST               0 (s)
             14 LOAD_CONST               0 (None)
             16 RETURN_VALUE

Disassembly of <code object <setcomp> at 0x00000152FDE23E10, file "<stdin>", line 2>:
  2           0 BUILD_SET                0		  # set
              2 LOAD_FAST                0 (.0)	   # push var .0 -> iter((1, 2, 3, 4, 4, 5))
        >>    4 FOR_ITER                 6 (to 18) # 
              6 STORE_FAST               1 (x)	   # pop; x = ...
              8 LOAD_FAST                1 (x)	   # 
             10 LOAD_CONST               0 (1)	   # 
             12 BINARY_ADD						# x + 1
             14 SET_ADD                  2        # x + 1 --> set()
             16 JUMP_ABSOLUTE            2 (to 4)
        >>   18 RETURN_VALUE

推导式的本质是内部嵌套实现了一个函数代码对象，然后再去调用。

def func():
    def setcomp(iterobj):
        
        pass
    s = setcomp(iter((1,2,3,4,4,5)))

看一下这个内嵌的函数有啥。

def func():
	s = {x+1 for x in [1,2,3,4,4,5,]}
    
>>> func.__code__.co_consts[1].co_consts
(1,)
>>> func.__code__.co_consts[1].co_varnames
('.0', 'x')
>>> func.__code__.co_consts[1].co_names
()

.0应该就是外面函数传入的参数，是一个iter()对象。

`LIST_APPEND(i)`

调用 list.append(TOS1[-i], TOS)。用于实现列表推导式。

>>> def func():
...     ls = [x*2 for x in (1,2,3,4,5)]
...
>>> dis.dis(func)
  2           0 LOAD_CONST               1 (<code object <listcomp> at 0x00000152FDE01C60, file "<stdin>", line 2>)
              2 LOAD_CONST               2 ('func.<locals>.<listcomp>')
              4 MAKE_FUNCTION            0
              6 LOAD_CONST               3 ((1, 2, 3, 4, 5))
              8 GET_ITER
             10 CALL_FUNCTION            1
             12 STORE_FAST               0 (ls)
             14 LOAD_CONST               0 (None)
             16 RETURN_VALUE

Disassembly of <code object <listcomp> at 0x00000152FDE01C60, file "<stdin>", line 2>:
  2           0 BUILD_LIST               0
              2 LOAD_FAST                0 (.0)
        >>    4 FOR_ITER                 6 (to 18)
              6 STORE_FAST               1 (x)
              8 LOAD_FAST                1 (x)
             10 LOAD_CONST               0 (2)
             12 BINARY_MULTIPLY
             14 LIST_APPEND              2
             16 JUMP_ABSOLUTE            2 (to 4)
        >>   18 RETURN_VALUE

`MAP_ADD(i)`

调用 dict.__setitem__(TOS1[-i], TOS1, TOS) 。用于实现字典推导。

在 3.8 版更改：映射值为 TOS ，映射键为 TOS1 。之前，它们被颠倒了。

# Py310版本测试
>>> def func():
...     d = {a:len(a) for a in ["1", "22", "333"]}
...
>>> dis.dis(func)
  2           0 LOAD_CONST               1 (<code object <dictcomp> at 0x00000152FDE01BB0, file "<stdin>", line 2>)
              2 LOAD_CONST               2 ('func.<locals>.<dictcomp>')
              4 MAKE_FUNCTION            0
              6 LOAD_CONST               3 (('1', '22', '333'))
              8 GET_ITER
             10 CALL_FUNCTION            1
             12 STORE_FAST               0 (d)
             14 LOAD_CONST               0 (None)
             16 RETURN_VALUE

Disassembly of <code object <dictcomp> at 0x00000152FDE01BB0, file "<stdin>", line 2>:
  2           0 BUILD_MAP                0
              2 LOAD_FAST                0 (.0)
        >>    4 FOR_ITER                 7 (to 20)
              6 STORE_FAST               1 (a)	# a = ...; 栈上只有容器
              8 LOAD_FAST                1 (a)	# a | dict()
             10 LOAD_GLOBAL              0 (len)
             12 LOAD_FAST                1 (a)
             14 CALL_FUNCTION            1		# push len(a)
             16 MAP_ADD                  2		# 等价于dict().update({a:len(a)})
             18 JUMP_ABSOLUTE            2 (to 4)
        >>   20 RETURN_VALUE

对于所有 SET_ADD 、 LIST_APPEND 和 MAP_ADD 指令，当弹出添加的值或键值对时，容器对象保留在堆栈上，以便它可用于循环的进一步迭代。

`RETURN_VALUE`

返回 TOS 到函数的调用者。

>>> def func():
...     return 114514
...
>>> dis.dis(func)
  2           0 LOAD_CONST               1 (114514)
              2 RETURN_VALUE
              
>>> def func():
...     return 114514, 1919810, 123
...
>>> dis.dis(func)
  2           0 LOAD_CONST               1 ((114514, 1919810, 123))
              2 RETURN_VALUE

单返回值就返回一个值，多返回值返回一个元组。

`YIELD_VALUE`

弹出 TOS 并从一个 generator 生成它。

>>> def func():
...     print("Before Yield")
...     while True:
...             res = yield 114514
...             print("Res:", res)
...             print("After Yield")
...
>>> g = func()
>>> next(g)
Before Yield
114514
>>> print(next(g))
Res: None
After Yield
114514
>>> dis.dis(func)
  2           0 LOAD_GLOBAL              0 (print)
              2 LOAD_CONST               1 ('Before Yield')
              4 CALL_FUNCTION            1
              6 POP_TOP					# print("...")

  3           8 SETUP_LOOP              28 (to 38)

  4     >>   10 LOAD_CONST               2 (114514)
             12 YIELD_VALUE				
             14 STORE_FAST               0 (res)	# res = yield 114514

  5          16 LOAD_GLOBAL              0 (print)
             18 LOAD_CONST               3 ('Res:')
             20 LOAD_FAST                0 (res)
             22 CALL_FUNCTION            2
             24 POP_TOP					# print("...")

  6          26 LOAD_GLOBAL              0 (print)
             28 LOAD_CONST               4 ('After Yield')
             30 CALL_FUNCTION            1
             32 POP_TOP
             34 JUMP_ABSOLUTE           10
             36 POP_BLOCK
        >>   38 LOAD_CONST               0 (None)
             40 RETURN_VALUE

可见这是yield的汇编形式。

`YIELD_FROM`

弹出 TOS 并将其委托给它作为 generator 的子迭代器。（Py33）

这个是yield from的汇编形式，没怎么研究过。

SETUP_ANNOTATIONS

检查 __annotations__ 是否在 locals() 中定义，如果没有，它被设置为空 dict 。只有在类或模块体静态地包含 variable annotations 时才会发出此操作码。（Py36）

`IMPORT_STAR`

将所有不以 '_' 开头的符号直接从模块 TOS 加载到局部命名空间。加载所有名称后弹出该模块。这个操作码实现了 from module import * 。

from module import *只能全局调用，无法在函数中使用，故暂时无法演示。

`POP_BLOCK`

从块堆栈中删除一个块。有一块堆栈，每帧用于表示 try 语句等。

>>> def func():
...     try:
...             print(1/0)
...     except(ArithmeticError):
...             print("AAA")
...
>>> func()
AAA
>>> dis.dis(func)
  2           0 SETUP_EXCEPT            16 (to 18)	# 表示try的开头

  3           2 LOAD_GLOBAL              0 (print)
              4 LOAD_CONST               1 (1)
              6 LOAD_CONST               2 (0)
              8 BINARY_TRUE_DIVIDE
             10 CALL_FUNCTION            1
             12 POP_TOP
             14 POP_BLOCK							# try的结尾
             16 JUMP_FORWARD            28 (to 46)

  4     >>   18 DUP_TOP
             20 LOAD_GLOBAL              1 (ArithmeticError)
             22 COMPARE_OP              10 (exception match)
             24 POP_JUMP_IF_FALSE       44
             26 POP_TOP
             28 POP_TOP
             30 POP_TOP

  5          32 LOAD_GLOBAL              0 (print)
             34 LOAD_CONST               3 ('AAA')
             36 CALL_FUNCTION            1
             38 POP_TOP
             40 POP_EXCEPT
             42 JUMP_FORWARD             2 (to 46)
        >>   44 END_FINALLY
        >>   46 LOAD_CONST               0 (None)
             48 RETURN_VALUE

通常在try块的结尾，弹出整个块。

`POP_EXCEPT`

从块堆栈中删除一个块。弹出的块必须是异常处理程序块，在进入 except 处理程序时隐式创建。除了从帧堆栈弹出无关值之外，最后三个弹出值还用于恢复异常状态。

上面一个例子有

RERAISE

重新引发当前位于栈顶的异常。如果 oparg 为非零值，则将当前帧的 f_lasti 恢复为异常被引发时的值。（Py39）

WITH_EXCEPT_START

调用堆栈中 7 号位置上的函数并附带栈顶位置的三项作为参数。用来在 with 语句内发生异常时实现调用 context_manager.__exit__(*exc_info())。（Py39）

`LOAD_ASSERTION_ERROR`

将 AssertionError 推入栈顶。由 assert 语句使用。（Py39）

>>> def func():
...     assert 1 == False
...
>>> dis.dis(func)
  2           0 LOAD_CONST               1 (1)
              2 LOAD_CONST               2 (False)
              4 COMPARE_OP               2 (==)
              6 POP_JUMP_IF_TRUE        12
              8 LOAD_GLOBAL              0 (AssertionError)
             10 RAISE_VARARGS            1
        >>   12 LOAD_CONST               0 (None)
             14 RETURN_VALUE

没成功。等价于LOAD_GLOBAL和RAISE_VARARGS配合，还更灵活

LOAD_BUILD_CLASS

将 builtins .__ build_class__() 推到堆栈上。它之后被 CALL_FUNCTION 调用来构造一个类。

SETUP_WITH(delta)

此操作码会在 with 代码块开始之前执行多个操作。首先，它从上下文管理器加载 __exit__() 并将其推入栈顶以供 WITH_EXCEPT_START 后续使用。然后，调用 __enter__()，并推入一个指向 delta 的 finally 代码块。最后，将调用 __enter__() 方法的结果推入栈顶。下一个操作码将忽略它 (POP_TOP)，或将其存储在一个或多个变量 (STORE_FAST, STORE_NAME 或 UNPACK_SEQUENCE) 中。3.2 新版功能.

COPY_DICT_WITHOUT_KEYS

TOS 是一个映射键的元组，而 TOS1 是匹配目标。将 TOS 替换为由 TOS1 条目组成的 dict，但不包含任何 TOS 中的键。（Py310）

`GET_LEN`

将 len(TOS) 推入栈顶。（Py310）

直接调用len()函数无法触发这个指令。需要其他方法。

MATCH_MAPPING

如果 TOS 是 collections.abc.Mapping 的实例（或者更准确地说：如果在它的 tp_flags 中设置了 Py_TPFLAGS_MAPPING 旗标），则将 True 推入栈顶。否则，推入 False。（Py310）

MATCH_SEQUENCE

如果 TOS 是 collections.abc.Sequence 的实例而不是 str/bytes/bytearray 的实例（或者更准确地说：如果在它的 tp_flags 中设置了 Py_TPFLAGS_SEQUENCE 旗标），则将 True 推入栈顶。否则，推入 False。（Py310）

MATCH_KEYS

TOS 是一个映射键的元组，而 TOS1 是匹配目标。如果 TOS1 包含 TOS 中的所有键，则推入一个包含对应值的 tuple，再推入 True。否则，推入 None，再推入 False。（Py310）

以下所有操作码均使用其参数。

STORE_NAME(*namei*)

实现 name = TOS。 namei 是 name 在代码对象的 co_names 属性中的索引。在可能的情况下，编译器会尝试使用 STORE_FAST 或 STORE_GLOBAL。

DELETE_NAME(*namei*)

实现 del name ，其中 namei 是代码对象的 co_names 属性的索引。

UNPACK_SEQUENCE(*count*)

将 TOS 解包为 count 个单独的值，它们将按从右至左的顺序被放入堆栈。

UNPACK_EX(*counts*)

实现使用带星号的目标进行赋值：将 TOS 中的可迭代对象解包为单独的值，其中值的总数可以小于可迭代对象中的项数：新值之一将是由所有剩余项构成的列表。counts 的低字节是列表值之前的值的数量，counts 中的高字节则是之后的值的数量。结果值会按从右至左的顺序入栈。

`STORE_ATTR(namei)`

实现 TOS.name = TOS1，其中 namei 是 name 在 co_names 中的索引号。

>>> class myobj:
...     pass
...
>>> a = myobj()
>>> a.fuck = 1
>>> a
<__main__.myobj object at 0x0000021C55D38348>
>>> dir(a)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'fuck']
>>> def func():
...     a = myobj()
...     a.fuck = 1
...     del a.fuck
...
>>> dis.dis(func)
  2           0 LOAD_GLOBAL              0 (myobj)
              2 CALL_FUNCTION            0
              4 STORE_FAST               0 (a)

  3           6 LOAD_CONST               1 (1)
              8 LOAD_FAST                0 (a)
             10 STORE_ATTR               1 (fuck)

  4          12 LOAD_FAST                0 (a)
             14 DELETE_ATTR              1 (fuck)
             16 LOAD_CONST               0 (None)
             18 RETURN_VALUE

`DELETE_ATTR(namei)`

实现 del TOS.name，使用 namei 作为 co_names 中的索引号。

见上

`STORE_GLOBAL(namei)`

类似于 STORE_NAME 但会将 name 存储为全局变量。

>>> def func():
...     global a
...     a = 10
...
...
>>> dis.dis(func)
  3           0 LOAD_CONST               1 (10)
              2 STORE_GLOBAL             0 (a)
              4 LOAD_CONST               0 (None)
              6 RETURN_VALUE

`DELETE_GLOBAL(namei)`

类似于 DELETE_NAME 但会删除一个全局变量。

>>> def func():
...     global a
...     a = 10
...     del a
...
>>> dis.dis(func)
  3           0 LOAD_CONST               1 (10)
              2 STORE_GLOBAL             0 (a)

  4           4 DELETE_GLOBAL            0 (a)
              6 LOAD_CONST               0 (None)
              8 RETURN_VALUE

`LOAD_CONST(consti)`

将 co_consts[consti] 推入栈顶。

`LOAD_NAME(namei)`

将与 co_names[namei] 相关联的值推入栈顶。

`BUILD_TUPLE(count)`

创建一个使用了来自栈的 count 个项的元组，并将结果元组推入栈顶。

`BUILD_LIST(count)`

类似于 BUILD_TUPLE 但会创建一个列表。

>>> def func():
...     a = [1,2,3,]
...
>>> dis.dis(func)
  2           0 LOAD_CONST               1 (1)
              2 LOAD_CONST               2 (2)
              4 LOAD_CONST               3 (3)
              6 BUILD_LIST               3
              8 STORE_FAST               0 (a)
             10 LOAD_CONST               0 (None)
             12 RETURN_VALUE

其他几个BUILD_指令都一样的。

`BUILD_SET(count)`

类似于 BUILD_TUPLE 但会创建一个集合。

`BUILD_MAP`(count)

将一个新字典对象推入栈顶。弹出 2 * count 项使得字典包含 count 个条目: {..., TOS3: TOS2, TOS1: TOS}。在 3.5 版更改: 字典是根据栈中的项创建而不是创建一个预设大小包含 count 项的空字典。

BUILD_CONST_KEY_MAP(*count*)

BUILD_MAP 版本专用于常量键。弹出的栈顶元素包含一个由键构成的元组，然后从 TOS1 开始从构建字典的值中弹出 count 个值。（Py36）

BUILD_STRING(*count*)

拼接 count 个来自栈的字符串并将结果字符串推入栈顶。（Py36）

LIST_TO_TUPLE

从堆栈中弹出一个列表并推入一个包含相同值的元组。（Py39）

`LIST_EXTEND(i)`

调用 list.extend(TOS1[-i], TOS)。用于构建列表。（Py39）

`SET_UPDATE`(i)

调用 set.update(TOS1[-i], TOS)。用于构建集合。（Py39）

`DICT_UPDATE`(i)

调用 dict.update(TOS1[-i], TOS)。用于构建字典。（Py39）

`DICT_MERGE`

类似于 DICT_UPDATE 但对于重复的键会引发异常。（Py39）

`LOAD_ATTR(namei)`

将 TOS 替换为 getattr(TOS, co_names[namei])。

`COMPARE_OP(opname)`

执行布尔运算操作。操作名称可在 cmp_op[opname] 中找到。

>>> def func():
...     a != b
...
>>> dis.dis(func)
  2           0 LOAD_GLOBAL              0 (a)
              2 LOAD_GLOBAL              1 (b)
              4 COMPARE_OP               3 (!=)
              6 POP_TOP
              8 LOAD_CONST               0 (None)
             10 RETURN_VALUE

IS_OP(*invert*)

执行 is 比较，或者如果 invert 为 1 则执行 is not。（Py39）

CONTAINS_OP(invert)

执行 in 比较，或者如果 invert 为 1 则执行 not in。（Py39）

上面几个似乎都能用COMPARE_OP一个应对。

`IMPORT_NAME`(namei)

导入模块 co_names[namei]。会弹出 TOS 和 TOS1 以提供 fromlist 和 level 参数给 __import__()。模块对象会被推入栈顶。当前命名空间不受影响：对于一条标准 import 语句，会执行后续的 STORE_FAST 指令来修改命名空间。

>>> def func():
...     import numpy
...
>>> dis.dis(func)
  2           0 LOAD_CONST               1 (0)
              2 LOAD_CONST               0 (None)
              4 IMPORT_NAME              0 (numpy)
              6 STORE_FAST               0 (numpy)
              8 LOAD_CONST               0 (None)
             10 RETURN_VALUE

`IMPORT_FROM(namei)`

从在 TOS 内找到的模块中加载属性 co_names[namei]。结果对象会被推入栈顶，以便由后续的 STORE_FAST 指令来保存。

`JUMP_FORWARD(delta)`

将字节码计数器的值增加 delta。

我混淆最喜欢用的指令。但是只能往后跳转。

`POP_JUMP_IF_TRUE(target)`

如果 TOS 为真值，则将字节码计数器的值设为 target。 TOS 会被弹出。（Py31）

`POP_JUMP_IF_FALSE(target)`

如果 TOS 为假值，则将字节码计数器的值设为 target。 TOS 会被弹出。（Py31）

`JUMP_IF_NOT_EXC_MATCH(target)`

检测堆栈中的第二个值是否为匹配 TOS 的异常，如果不是则会跳转。从堆栈中弹出两个值。（Py39）

`JUMP_IF_TRUE_OR_POP(target)`

如果 TOS 为真值，则将字节码计数器的值设为 target 并将 TOS 留在栈顶。否则（如 TOS 为假值），TOS 会被弹出。（Py31）

`JUMP_IF_FALSE_OR_POP(target)`

如果 TOS 为假值，则将字节码计数器的值设为 target 并将 TOS 留在栈顶。否则（如 TOS 为真值），TOS 会被弹出。（Py31）

`JUMP_ABSOLUTE(target)`

将字节码计数器的值设为 target。

`FOR_ITER(delta)`

TOS 是一个 iterator。请调用其 __next__() 方法。如果此操作产生了一个新值，则将其推入栈顶（将迭代器留在其下方）。如果迭代器提示已耗尽，TOS 会被弹出，并且字节码计数器将增加 delta。

用伪指令描述一下：

# FOR_ITER delta

# 栈中： | iter(obj) |
if get_new_value() == True:
	push new_value()			
	# | new_val | <--顶
	# | iter(o) |   
elif no_more():
    pop iter(obj)
	# |  空栈   |
    vm_ip += delta	# 跳转

此指令在循环，遍历列表，构建列表表达式时都会被用上。

`LOAD_GLOBAL(namei)`

加载名称为 co_names[namei] 的全局对象推入栈顶。

>>> global glob
>>> def func():
...     g = glob
...
>>> dis.dis(func)
  2           0 LOAD_GLOBAL              0 (glob)
              2 STORE_FAST               0 (g)
              4 LOAD_CONST               0 (None)
              6 RETURN_VALUE

`SETUP_FINALLY(delta)`

将一个来自 try-finally 或 try-except 子句的 try 代码块推入代码块栈顶。相对 finally 代码块或第一个 except 代码块 delta 个点数。

`LOAD_FAST(var_num)`

将指向局部对象 co_varnames[var_num] 的引用推入栈顶。

`STORE_FAST(var_num)`

将 TOS 存放到局部对象 co_varnames[var_num]。

`DELETE_FAST(var_num)`

移除局部对象 co_varnames[var_num]。

这几个太常用了，不搞了

LOAD_CLOSURE(*i*)

将一个包含在单元的第 i 个空位中的对单元的引用推入栈顶并释放可用的存储空间。如果 i 小于 co_cellvars 的长度则变量的名称为 co_cellvars[i]。否则为 co_freevars[i len(co_cellvars)]。

LOAD_DEREF(*i*)

加载包含在单元的第 i 个空位中的单元并释放可用的存储空间。将一个对单元所包含对象的引用推入栈顶。

LOAD_CLASSDEREF(*i*)

类似于 LOAD_DEREF 但在查询单元之前会首先检查局部对象字典。这被用于加载类语句体中的自由变量。3.4 新版功能.

STORE_DEREF(*i*)

将 TOS 存放到包含在单元的第 i 个空位中的单元内并释放可用存储空间。

DELETE_DEREF(*i*)

清空包含在单元的第 i 个空位中的单元并释放可用存储空间。被用于 del 语句。3.2 新版功能.

`RAISE_VARARGS(argc)`

使用 raise 语句的 3 种形式之一引发异常，具体形式取决于 argc 的值：0: raise (重新引发之前的异常)1: raise TOS (在 TOS 上引发异常实例或类型)2: raise TOS1 from TOS (在 TOS1 上引发异常实例或类型并将 __cause__ 设为 TOS)

>>> def func():
...     assert 1 == False
...
>>> dis.dis(func)
  2           0 LOAD_CONST               1 (1)
              2 LOAD_CONST               2 (False)
              4 COMPARE_OP               2 (==)
              6 POP_JUMP_IF_TRUE        12
              8 LOAD_GLOBAL              0 (AssertionError)
             10 RAISE_VARARGS            1
        >>   12 LOAD_CONST               0 (None)
             14 RETURN_VALUE

异常触发

`CALL_FUNCTION(argc)`

调用一个可调用对象并传入位置参数。 argc 指明位置参数的数量。栈顶包含位置参数，其中最右边的参数在最顶端。在参数之下是一个待调用的可调用对象。 CALL_FUNCTION 会从栈中弹出所有参数以及可调用对象，附带这些参数调用该可调用对象，并将可调用对象所返回的返回值推入栈顶。在 3.6 版更改: 此操作码仅用于附带位置参数的调用。

是个函数调用都用这个。

CALL_FUNCTION_KW(argc)

调用一个可调用对象并传入位置参数（如果有的话）和关键字参数。 argc 指明位置参数和关键字参数的总数量。栈顶元素包含一个关键字参数名称的元组，名称必须为字符串。在元组之下是与元组顺序相对应的关键字参数值。在它之下则是位置参数，其中最右边的参数在最顶端。在参数之下是要调用的可调用对象。 CALL_FUNCTION_KW 会从栈中弹出所有参数及可调用对象，附带这些参数调用该可调用对象，并将可调用对象所返回的返回值推入栈顶。在 3.6 版更改: 关键字参数会被打包为一个元组而非字典，argc 指明参数的总数量。

CALL_FUNCTION_EX(flags)

调用一个可调用对象并附带位置参数和关键字参数变量集合。如果设置了 flags 的最低位，则栈顶包含一个由额外关键字参数组成的映射对象。在调用该可调用对象之前，映射对象和可迭代对象会被分别“解包”并将它们的内容分别作为关键字参数和位置参数传入。 CALL_FUNCTION_EX 会中栈中弹出所有参数及可调用对象，附带这些参数调用该可调用对象，并将可调用对象所返回的返回值推入栈顶。（Py36）

`LOAD_METHOD(namei)`

从 TOS 对象加载一个名为 co_names[namei] 的方法。 TOS 将被弹出。此字节码可区分两种情况：如果 TOS 有一个名称正确的方法，字节码会将未绑定方法和 TOS 推入栈顶。 TOS 将在调用未绑定方法时被用作 CALL_METHOD 的第一个参数 (self)。否则会将 NULL 和属性查找所返回的对象推入栈顶。（Py37）

`CALL_METHOD(argc)`

调用一个方法。 argc 是位置参数的数量。关键字参数不受支持。此操作码被设计用于配合 LOAD_METHOD 使用。位置参数放在栈顶。在它们之下放在栈中的是由 LOAD_METHOD 所描述的两个条目（或者是 self 和一个未绑定方法对象，或者是 NULL 和一个任意可调用对象）。它们会被全部弹出并将返回值推入栈顶。（Py37）

>>> def func():
...     a = hashlib.md5()
...
>>> dis.dis(func)
  2           0 LOAD_GLOBAL              0 (hashlib)
              2 LOAD_METHOD              1 (md5)
              4 CALL_METHOD              0
              6 STORE_FAST               0 (a)
              8 LOAD_CONST               0 (None)
             10 RETURN_VALUE

`MAKE_FUNCTION(flags)`

将一个新函数对象推入栈顶。从底端到顶端，如果参数带有指定的旗标值则所使用的栈必须由这些值组成。0x01 一个默认值的元组，用于按位置排序的仅限位置形参以及位置或关键字形参0x02 一个仅限关键字形参的默认值的字典0x04 一个包含形参标注的字符串元组。0x08 一个包含用于自由变量的单元的元组，生成一个闭包与函数相关联的代码 (在 TOS1)函数的 qualified name (在 TOS)在 3.10 版更改: 旗标值 0x04 是一个字符串元组而非字典。

https://stackoverflow.com/questions/54877888/python-3-7-bytecode-make-function-how-to-interpret-such-disassembled-function-d
https://docs.python.org/3/library/dis.html
MAKE_FUNCTION(argc)
Pushes a new function object on the stack. From bottom to top, the consumed stack must consist of values if the argument carries a specified flag value:

0x01 a tuple of default values for positional-only and positional-or-keyword parameters in positional order
0x02 a dictionary of keyword-only parameters’ default values
0x04 an annotation dictionary
0x08 a tuple containing cells for free variables, making a closure
the code associated with the function (at TOS1)
the qualified name of the function (at TOS)

>>> def outf():
...     def inf():
...             print("IN")
...     print("OUT")
...
>>> dis.dis(outf)
  2           0 LOAD_CONST               1 (<code object inf at 0x0000021C6E0A5780, file "<stdin>", line 2>)
              2 LOAD_CONST               2 ('outf.<locals>.inf')
              4 MAKE_FUNCTION            0
              6 STORE_FAST               0 (inf)

  4           8 LOAD_GLOBAL              0 (print)
             10 LOAD_CONST               3 ('OUT')
             12 CALL_FUNCTION            1
             14 POP_TOP
             16 LOAD_CONST               0 (None)
             18 RETURN_VALUE

Disassembly of <code object inf at 0x0000021C6E0A5780, file "<stdin>", line 2>:
  3           0 LOAD_GLOBAL              0 (print)
              2 LOAD_CONST               1 ('IN')
              4 CALL_FUNCTION            1
              6 POP_TOP
              8 LOAD_CONST               0 (None)
             10 RETURN_VALUE

`BUILD_SLICE(argc)`

将一个切片对象推入栈顶。 argc 必须为 2 或 3。如果为 2，则推入 slice(TOS1, TOS)；如果为 3，则推入 slice(TOS2, TOS1, TOS)。请参阅 slice() 内置函数了解详细信息。

>>> def func():
...     a = [1,2,3,]
...     b = s[0:2]
...
>>> dis.dis(func)
  2           0 LOAD_CONST               1 (1)
              2 LOAD_CONST               2 (2)
              4 LOAD_CONST               3 (3)
              6 BUILD_LIST               3
              8 STORE_FAST               0 (a)

  3          10 LOAD_GLOBAL              0 (s)
             12 LOAD_CONST               4 (0)
             14 LOAD_CONST               2 (2)
             16 BUILD_SLICE              2		# slice(0, 2)
             18 BINARY_SUBSCR					# a[slice(0, 2)]
             20 STORE_FAST               1 (b)
             22 LOAD_CONST               0 (None)
             24 RETURN_VALUE
>>> def func():
...     a = [1,2,3,4,5,6,7,8,9,10]
...     b = a[0:8:2]
...
...
>>> dis.dis(func)
  2           0 LOAD_CONST               1 (1)
              2 LOAD_CONST               2 (2)
              4 LOAD_CONST               3 (3)
              6 LOAD_CONST               4 (4)
              8 LOAD_CONST               5 (5)
             10 LOAD_CONST               6 (6)
             12 LOAD_CONST               7 (7)
             14 LOAD_CONST               8 (8)
             16 LOAD_CONST               9 (9)
             18 LOAD_CONST              10 (10)
             20 BUILD_LIST              10
             22 STORE_FAST               0 (a)

  3          24 LOAD_FAST                0 (a)
             26 LOAD_CONST              11 (0)
             28 LOAD_CONST               8 (8)
             30 LOAD_CONST               2 (2)	
             32 BUILD_SLICE              3		# slice(0, 8, 2)
             34 BINARY_SUBSCR					# a[slice(0, 8, 2)]
             36 STORE_FAST               1 (b)
             38 LOAD_CONST               0 (None)
             40 RETURN_VALUE

EXTENDED_ARG(ext)

为任意带有大到无法放入默认的单字节的参数的操作码添加前缀。 ext 存放一个附加字节作为参数中的高比特位。对于每个操作码，最多允许三个 EXTENDED_ARG 前缀，构成两字节到三字节的参数。

FORMAT_VALUE(flags)

用于实现格式化字面值字符串（f-字符串）。从栈中弹出一个可选的 fmt_spec，然后是一个必须的 value。 flags 的解读方式如下：(flags & 0x03) == 0x00: value 按原样格式化。(flags & 0x03) == 0x01: 在格式化 value 之前调用其 str()。(flags & 0x03) == 0x02: 在格式化 value 之前调用其 repr()。(flags & 0x03) == 0x03: 在格式化 value 之前调用其 ascii()。(flags & 0x04) == 0x04: 从栈中弹出 fmt_spec 并使用它，否则使用空的 fmt_spec。使用 PyObject_Format() 执行格式化。结果会被推入栈顶。（Py36）

MATCH_CLASS(count)

TOS 是一个包含关键字属性名称的元组，TOS1 是要匹配的类，而 TOS2 是匹配目标。 count 是位置子模式的数量。弹出 TOS。如果 TOS2 是 TOS1 的一个实例且具有 count 和 TOS 所要求的位置和关键字属性，则将 TOS 设为 True 并将 TOS1 设为包含已提取属性的元组。否则，将 TOS 设为 False。（Py310）

GEN_START(kind)

Pops TOS. The kind operand corresponds to the type of generator or coroutine. The legal kinds are 0 for generator, 1 for coroutine, and 2 for async generator.（Py310）

ROT_N(count)

将栈的前 count 项向上提升一个位置，并将 TOS 下移至位置 count。（Py310）

HAVE_ARGUMENT

这不是一个真正的操作码。它用于标明使用参数和不使用参数的操作码 (分别为 < HAVE_ARGUMENT 和 >= HAVE_ARGUMENT) 之间的分隔线。

在 3.6 版更改: 现在每条指令都带有参数，但操作码 < HAVE_ARGUMENT 会忽略它。之前仅限操作码 >= HAVE_ARGUMENT 带有参数。

本文作者： Taardis
本文链接： https://taardisaa.github.io/2022/02/13/Pyc Reverse Opcode/
版权声明： 本博客所有文章除特别声明外，均采用 Apache License 2.0 许可协议。转载请注明出处！

Pyc字节码分析——虚拟机指令集分析

注意

关于本博客主旨

提示

环境

dis模块

dis.dis()显示反汇编

Bytecode对象

函数

指令集分析

无参指令

NOP

POP_TOP

ROT_TWO

ROT_THREE

ROT_FOUR（Py38）

DUP_TOP（Py32）

DUP_TOP_TWO（Py32）

一元操作

UNARY_POSITIVE

UNARY_NEGATIVE

UNARY_NOT

UNARY_INVERT

GET_ITER

GET_YIELD_FROM_ITER

二元操作

BINARY_POWER

BINARY_MULTIPLY

BINARY_MATRIX_MULTIPLY（Py35）

BINARY_FLOOR_DIVIDE

BINARY_TRUE_DIVIDE

BINARY_MODULO

BINARY_ADD

BINARY_SUBTRACT

BINARY_SUBSCR

BINARY_LSHIFT

BINARY_RSHIFT

BINARY_AND

BINARY_XOR

BINARY_OR

就地操作

INPLACE_POWER

INPLACE_MULTIPLY

INPLACE_MATRIX_MULTIPLY

INPLACE_FLOOR_DIVIDE

INPLACE_TRUE_DIVIDE

INPLACE_MODULO

INPLACE_ADD

INPLACE_SUBTRACT

INPLACE_LSHIFT

INPLACE_RSHIFT

INPLACE_AND

INPLACE_XOR

INPLACE_OR

STORE_SUBSCR

DELETE_SUBSCR