bpo-45260: Add superinstruction, UNPACK_SEQUENCE__STORE_FAST

Lib/opcode.py

@@ -174,6 +174,7 @@ def jabs_op(name, op):
 haslocal.append(125)
 def_op('DELETE_FAST', 126)      # Local variable number
 haslocal.append(126)
+def_op('UNPACK_SEQUENCE__STORE_FAST', 127)
 
 def_op('GEN_START', 129)        # Kind of generator/coroutine
 def_op('RAISE_VARARGS', 130)    # Number of raise arguments (1, 2, or 3)

Lib/test/test_dis.py

@@ -522,7 +522,8 @@ def test_widths(self):
         for opcode, opname in enumerate(dis.opname):
             if opname in ('BUILD_MAP_UNPACK_WITH_CALL',
                           'BUILD_TUPLE_UNPACK_WITH_CALL',
-                          'JUMP_IF_NOT_EXC_MATCH'):
+                          'JUMP_IF_NOT_EXC_MATCH',
+                          'UNPACK_SEQUENCE__STORE_FAST'):
                 continue
             with self.subTest(opname=opname):
                 width = dis._OPNAME_WIDTH

Misc/NEWS.d/next/Core and Builtins/2021-10-09-03-52-11.bpo-45260.lLIZZy.rst

@@ -0,0 +1 @@
+Add superinstruction UNPACK_SEQUENCE__STORE_FAST using the PEP 659 machinery.

Python/ceval.c

@@ -1705,6 +1705,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, InterpreterFrame *frame, int thr
         }
 
         TARGET(LOAD_FAST) {
+            PREDICTED(LOAD_FAST);
             PyObject *value = GETLOCAL(oparg);
             if (value == NULL) {
                 goto unbound_local_error;
@@ -1730,6 +1731,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, InterpreterFrame *frame, int thr
         }
 
         TARGET(LOAD_FAST__LOAD_FAST) {
+            PREDICTED(LOAD_FAST__LOAD_FAST);
             PyObject *value = GETLOCAL(oparg);
             if (value == NULL) {
                 goto unbound_local_error;
@@ -2962,6 +2964,49 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, InterpreterFrame *frame, int thr
             DISPATCH();
         }
 
+        TARGET(UNPACK_SEQUENCE__STORE_FAST) {
+            PREDICTED(UNPACK_SEQUENCE__STORE_FAST);
+            PyObject *seq = POP(), *item, **items;
+            if (PyTuple_CheckExact(seq) &&
+                PyTuple_GET_SIZE(seq) == oparg) {
+                items = ((PyTupleObject *)seq)->ob_item;
+                int i = -1, next_oparg;
+                while (++i < oparg) {
+                    item = items[i];
+                    Py_INCREF(item);
+                    next_oparg= _Py_OPARG(*(next_instr++));
+                    SETLOCAL(next_oparg, item);
+                }
+            } else if (PyList_CheckExact(seq) &&
+                       PyList_GET_SIZE(seq) == oparg) {
+                items = ((PyListObject *)seq)->ob_item;
+                int i = -1, next_oparg;
+                while (++i < oparg) {
+                    item = items[i];
+                    Py_INCREF(item);
+                    next_oparg= _Py_OPARG(*(next_instr++));
+                    SETLOCAL(next_oparg, item);
+                }
+            } else if (unpack_iterable(tstate, seq, oparg, -1,
+                                       stack_pointer + oparg)) {
+                items = stack_pointer + oparg - 1;
+                int i = -1, next_oparg;
+                while (++i < oparg) {
+                    item = *(items - i);
+                    next_oparg= _Py_OPARG(*(next_instr++));
+                    SETLOCAL(next_oparg, item);
+                }
+            } else {
+                /* unpack_iterable() raised an exception */
+                Py_DECREF(seq);
+                goto error;
+            }
+            Py_DECREF(seq);
+            PREDICT(LOAD_FAST__LOAD_FAST);
+            PREDICT(LOAD_FAST);
+            DISPATCH();
+        }
+
         TARGET(UNPACK_EX) {
             int totalargs = 1 + (oparg & 0xFF) + (oparg >> 8);
             PyObject *seq = POP();
@@ -4230,6 +4275,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, InterpreterFrame *frame, int thr
             if (next != NULL) {
                 PUSH(next);
                 PREDICT(STORE_FAST);
+                PREDICT(UNPACK_SEQUENCE__STORE_FAST);
                 PREDICT(UNPACK_SEQUENCE);
                 DISPATCH();
             }

Python/compile.c

@@ -1092,6 +1092,7 @@ stack_effect(int opcode, int oparg, int jump)
         case DELETE_NAME:
             return 0;
         case UNPACK_SEQUENCE:
+        case UNPACK_SEQUENCE__STORE_FAST:
             return oparg-1;
         case UNPACK_EX:
             return (oparg&0xFF) + (oparg>>8);
@@ -4009,10 +4010,25 @@ assignment_helper(struct compiler *c, asdl_expr_seq *elts)
 {
     Py_ssize_t n = asdl_seq_LEN(elts);
     RETURN_IF_FALSE(unpack_helper(c, elts));
+    basicblock *bb = c->u->u_curblock;
+    int idx = bb->b_iused-1;
     for (Py_ssize_t i = 0; i < n; i++) {
         expr_ty elt = asdl_seq_GET(elts, i);
         VISIT(c, expr, elt->kind != Starred_kind ? elt : elt->v.Starred.value);
     }
+    struct instr *stmt = &bb->b_instr[idx];
+    if (stmt->i_opcode == UNPACK_SEQUENCE) {
+        int count = stmt->i_oparg;
+        int i = 1;
+        for (; i <= count; ++i) {
+            if ((stmt + i)->i_opcode != STORE_FAST) {
+                break;
+            }
+        }
+        if (i > count) {
+            stmt->i_opcode = UNPACK_SEQUENCE__STORE_FAST;
+        }
+    }
     return 1;
 }
 
@@ -5962,6 +5978,8 @@ pattern_helper_sequence_unpack(struct compiler *c, asdl_pattern_seq *patterns,
                                Py_ssize_t star, pattern_context *pc)
 {
     RETURN_IF_FALSE(pattern_unpack_helper(c, patterns));
+    basicblock *bb = c->u->u_curblock;
+    int idx = bb->b_iused-1;
     Py_ssize_t size = asdl_seq_LEN(patterns);
     // We've now got a bunch of new subjects on the stack. They need to remain
     // there after each subpattern match:
@@ -5972,6 +5990,19 @@ pattern_helper_sequence_unpack(struct compiler *c, asdl_pattern_seq *patterns,
         pattern_ty pattern = asdl_seq_GET(patterns, i);
         RETURN_IF_FALSE(compiler_pattern_subpattern(c, pattern, pc));
     }
+    struct instr *stmt = &bb->b_instr[idx];
+    if (stmt->i_opcode == UNPACK_SEQUENCE) {
+        int count = stmt->i_oparg;
+        int i = 1;
+        for (; i <= count; ++i) {
+            if ((stmt + i)->i_opcode != STORE_FAST) {
+                break;
+            }
+        }
+        if (i > count) {
+            stmt->i_opcode = UNPACK_SEQUENCE__STORE_FAST;
+        }
+    }
     return 1;
 }
 

Python/specialize.c

@@ -344,6 +344,10 @@ optimize(SpecializedCacheOrInstruction *quickened, int len)
             /* Super instructions don't use the cache,
              * so no need to update the offset. */
             switch (opcode) {
+                case UNPACK_SEQUENCE__STORE_FAST: {
+                    i += oparg;
+                    break;
+                }
                 case JUMP_ABSOLUTE:
                     instructions[i] = _Py_MAKECODEUNIT(JUMP_ABSOLUTE_QUICK, oparg);
                     break;