sweeneyde · Feb 20, 2022 · Feb 20, 2022 · Feb 20, 2022 · Mar 1, 2022 · Mar 20, 2022
diff --git a/Doc/library/dis.rst b/Doc/library/dis.rst
@@ -981,12 +981,15 @@ iterations of the loop.
    .. versionadded:: 3.1
 
 
-.. opcode:: FOR_ITER (delta)
+.. opcode:: FOR_END (delta)
 
    TOS is an :term:`iterator`.  Call its :meth:`~iterator.__next__` method.  If
    this yields a new value, push it on the stack (leaving the iterator below
-   it).  If the iterator indicates it is exhausted, TOS is popped, and the byte
-   code counter is incremented by *delta*.
+   it), then decrement the bytecode counter by *delta*.  If the iterator
+   indicates it is exhausted, then pop TOS and do not decrement the bytecode
+   counter.
+
+   .. versionadded:: 3.11
 
 
 .. opcode:: LOAD_GLOBAL (namei)

@@ -763,6 +763,12 @@ CPython bytecode changes
 
 * Added :opcode:`JUMP_BACKWARD_NO_INTERRUPT`, which is used in certain loops where it is undesirable to handle interrupts.
 
+* Replaced :opcode:`FOR_ITER` (jumps if iterator exhausted)
+  with :opcode:`FOR_END` (jumps if iterator is not exhausted).
+  At the end of each ``for``-loop iteration, instead of an unconditional
+  jump targeted at a conditional jump, there is now
+  only one (conditional) jump.
+
 Deprecated
 ==========
 

diff --git a/Include/opcode.h b/Include/opcode.h
diff --git a/Lib/dis.py b/Lib/dis.py
@@ -30,7 +30,9 @@
 LOAD_CONST = opmap['LOAD_CONST']
 LOAD_GLOBAL = opmap['LOAD_GLOBAL']
 BINARY_OP = opmap['BINARY_OP']
-JUMP_BACKWARD = opmap['JUMP_BACKWARD']
+
+BACK_JUMPS = {code for name, code in opmap.items()
+              if 'JUMP_BACKWARD' in name} | {opmap['FOR_END']}
 
 CACHE = opmap["CACHE"]
 
@@ -442,7 +444,7 @@ def _get_instructions_bytes(code, varname_from_oparg=None,
                 argval = arg*2
                 argrepr = "to " + repr(argval)
             elif op in hasjrel:
-                signed_arg = -arg if op == JUMP_BACKWARD else arg
+                signed_arg = -arg if op in BACK_JUMPS else arg
                 argval = offset + 2 + signed_arg*2
                 argrepr = "to " + repr(argval)
             elif op in haslocal or op in hasfree:
@@ -568,7 +570,7 @@ def findlabels(code):
     for offset, op, arg in _unpack_opargs(code):
         if arg is not None:
             if op in hasjrel:
-                if op == JUMP_BACKWARD:
+                if op in BACK_JUMPS:
                     arg = -arg
                 label = offset + 2 + arg*2
             elif op in hasjabs:

@@ -414,7 +414,7 @@ def _write_atomic(path, data, mode=0o666):
 # Whenever MAGIC_NUMBER is changed, the ranges in the magic_values array
 # in PC/launcher.c must also be updated.
 
-MAGIC_NUMBER = (3491).to_bytes(2, 'little') + b'\r\n'
+MAGIC_NUMBER = (3493).to_bytes(2, 'little') + b'\r\n'
 _RAW_MAGIC_NUMBER = int.from_bytes(MAGIC_NUMBER, 'little')  # For import.c
 
 _PYCACHE = '__pycache__'

diff --git a/Lib/opcode.py b/Lib/opcode.py
@@ -111,7 +111,6 @@ def jabs_op(name, op, entries=0):
 name_op('STORE_NAME', 90)       # Index in name list
 name_op('DELETE_NAME', 91)      # ""
 def_op('UNPACK_SEQUENCE', 92, 1)   # Number of tuple items
-jrel_op('FOR_ITER', 93)
 def_op('UNPACK_EX', 94)
 name_op('STORE_ATTR', 95, 4)       # Index in name list
 name_op('DELETE_ATTR', 96)      # ""
@@ -197,6 +196,7 @@ def jabs_op(name, op, entries=0):
 def_op('KW_NAMES', 172)
 hasconst.append(172)
 
+jrel_op('FOR_END', 173)
 
 del def_op, name_op, jrel_op, jabs_op
 
@@ -262,6 +262,9 @@ def jabs_op(name, op, entries=0):
     "JUMP_BACKWARD": [
         "JUMP_BACKWARD_QUICK",
     ],
+    "FOR_END": [
+        "FOR_END_QUICK",
+    ],
     "LOAD_ATTR": [
         "LOAD_ATTR_ADAPTIVE",
         "LOAD_ATTR_INSTANCE_VALUE",

diff --git a/Lib/test/test__opcode.py b/Lib/test/test__opcode.py
@@ -37,10 +37,10 @@ def test_stack_effect_jump(self):
         self.assertEqual(stack_effect(JUMP_IF_TRUE_OR_POP, 0), 0)
         self.assertEqual(stack_effect(JUMP_IF_TRUE_OR_POP, 0, jump=True), 0)
         self.assertEqual(stack_effect(JUMP_IF_TRUE_OR_POP, 0, jump=False), -1)
-        FOR_ITER = dis.opmap['FOR_ITER']
-        self.assertEqual(stack_effect(FOR_ITER, 0), 1)
-        self.assertEqual(stack_effect(FOR_ITER, 0, jump=True), -1)
-        self.assertEqual(stack_effect(FOR_ITER, 0, jump=False), 1)
+        FOR_END = dis.opmap['FOR_END']
+        self.assertEqual(stack_effect(FOR_END, 0), 1)
+        self.assertEqual(stack_effect(FOR_END, 0, jump=True), 1)
+        self.assertEqual(stack_effect(FOR_END, 0, jump=False), -1)
         JUMP_FORWARD = dis.opmap['JUMP_FORWARD']
         self.assertEqual(stack_effect(JUMP_FORWARD, 0), 0)
         self.assertEqual(stack_effect(JUMP_FORWARD, 0, jump=True), 0)

diff --git a/Lib/test/test_dis.py b/Lib/test/test_dis.py
@@ -146,12 +146,13 @@ def bug708901():
 %3d        PRECALL                  2
            CALL                     2
            GET_ITER
-        >> FOR_ITER                 2 (to 40)
-           STORE_FAST               0 (res)
+           JUMP_FORWARD             2 (to 40)
+        >> STORE_FAST               0 (res)
 
-%3d        JUMP_BACKWARD            3 (to 34)
+%3d        NOP
 
-%3d     >> LOAD_CONST               0 (None)
+%3d     >> FOR_END                  3 (to 36)
+           LOAD_CONST               0 (None)
            RETURN_VALUE
 """ % (bug708901.__code__.co_firstlineno,
        bug708901.__code__.co_firstlineno + 1,
@@ -569,14 +570,14 @@ def foo(x):
 %3d        RESUME                   0
            BUILD_LIST               0
            LOAD_FAST                0 (.0)
-        >> FOR_ITER                 7 (to 24)
-           STORE_FAST               1 (z)
+           JUMP_FORWARD             6 (to 22)
+        >> STORE_FAST               1 (z)
            LOAD_DEREF               2 (x)
            LOAD_FAST                1 (z)
            BINARY_OP                0 (+)
            LIST_APPEND              2
-           JUMP_BACKWARD            8 (to 8)
-        >> RETURN_VALUE
+        >> FOR_END                  7 (to 10)
+           RETURN_VALUE
 """ % (dis_nested_1,
        __file__,
        _h.__code__.co_firstlineno + 3,
@@ -1217,8 +1218,8 @@ def _prepare_test_cases():
   Instruction(opname='PRECALL', opcode=166, arg=1, argval=1, argrepr='', offset=16, starts_line=None, is_jump_target=False, positions=None),
   Instruction(opname='CALL', opcode=171, arg=1, argval=1, argrepr='', offset=20, starts_line=None, is_jump_target=False, positions=None),
   Instruction(opname='GET_ITER', opcode=68, arg=None, argval=None, argrepr='', offset=30, starts_line=None, is_jump_target=False, positions=None),
-  Instruction(opname='FOR_ITER', opcode=93, arg=32, argval=98, argrepr='to 98', offset=32, starts_line=None, is_jump_target=True, positions=None),
-  Instruction(opname='STORE_FAST', opcode=125, arg=0, argval='i', argrepr='i', offset=34, starts_line=None, is_jump_target=False, positions=None),
+  Instruction(opname='JUMP_FORWARD', opcode=110, arg=31, argval=96, argrepr='to 96', offset=32, starts_line=None, is_jump_target=True, positions=None),
+  Instruction(opname='STORE_FAST', opcode=125, arg=0, argval='i', argrepr='i', offset=34, starts_line=None, is_jump_target=True, positions=None),
   Instruction(opname='LOAD_GLOBAL', opcode=116, arg=3, argval='print', argrepr='NULL + print', offset=36, starts_line=4, is_jump_target=False, positions=None),
   Instruction(opname='LOAD_FAST', opcode=124, arg=0, argval='i', argrepr='i', offset=48, starts_line=None, is_jump_target=False, positions=None),
   Instruction(opname='PRECALL', opcode=166, arg=1, argval=1, argrepr='', offset=50, starts_line=None, is_jump_target=False, positions=None),
@@ -1235,8 +1236,8 @@ def _prepare_test_cases():
   Instruction(opname='POP_JUMP_IF_FALSE', opcode=114, arg=48, argval=96, argrepr='to 96', offset=90, starts_line=None, is_jump_target=False, positions=None),
   Instruction(opname='POP_TOP', opcode=1, arg=None, argval=None, argrepr='', offset=92, starts_line=8, is_jump_target=False, positions=None),
   Instruction(opname='JUMP_FORWARD', opcode=110, arg=16, argval=128, argrepr='to 128', offset=94, starts_line=None, is_jump_target=False, positions=None),
-  Instruction(opname='JUMP_BACKWARD', opcode=140, arg=33, argval=32, argrepr='to 32', offset=96, starts_line=7, is_jump_target=True, positions=None),
-  Instruction(opname='LOAD_GLOBAL', opcode=116, arg=3, argval='print', argrepr='NULL + print', offset=98, starts_line=10, is_jump_target=True, positions=None),
+  Instruction(opname='FOR_END', opcode=173, arg=32, argval=34, argrepr='to 34', offset=96, starts_line=3, is_jump_target=True, positions=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=116, arg=3, argval='print', argrepr='NULL + print', offset=98, starts_line=10, is_jump_target=False, positions=None),
   Instruction(opname='LOAD_CONST', opcode=100, arg=4, argval='I can haz else clause?', argrepr="'I can haz else clause?'", offset=110, starts_line=None, is_jump_target=False, positions=None),
   Instruction(opname='PRECALL', opcode=166, arg=1, argval=1, argrepr='', offset=112, starts_line=None, is_jump_target=False, positions=None),
   Instruction(opname='CALL', opcode=171, arg=1, argval=1, argrepr='', offset=116, starts_line=None, is_jump_target=False, positions=None),

diff --git a/Lib/test/test_peepholer.py b/Lib/test/test_peepholer.py
@@ -509,16 +509,16 @@ def f(x):
     def test_assignment_idiom_in_comprehensions(self):
         def listcomp():
             return [y for x in a for y in [f(x)]]
-        self.assertEqual(count_instr_recursively(listcomp, 'FOR_ITER'), 1)
+        self.assertEqual(count_instr_recursively(listcomp, 'FOR_END'), 1)
         def setcomp():
             return {y for x in a for y in [f(x)]}
-        self.assertEqual(count_instr_recursively(setcomp, 'FOR_ITER'), 1)
+        self.assertEqual(count_instr_recursively(setcomp, 'FOR_END'), 1)
         def dictcomp():
             return {y: y for x in a for y in [f(x)]}
-        self.assertEqual(count_instr_recursively(dictcomp, 'FOR_ITER'), 1)
+        self.assertEqual(count_instr_recursively(dictcomp, 'FOR_END'), 1)
         def genexpr():
             return (y for x in a for y in [f(x)])
-        self.assertEqual(count_instr_recursively(genexpr, 'FOR_ITER'), 1)
+        self.assertEqual(count_instr_recursively(genexpr, 'FOR_END'), 1)
 
     def test_format_combinations(self):
         flags = '-+ #0'

diff --git a/Misc/NEWS.d/next/Core and Builtins/2022-04-10-21-49-23.gh-issue-91432.2yBtR8.rst b/Misc/NEWS.d/next/Core and Builtins/2022-04-10-21-49-23.gh-issue-91432.2yBtR8.rst
@@ -0,0 +1,5 @@
+Replaced the ``FOR_ITER`` opcode that lived at the top of ``for``-loops with a
+``FOR_END`` opcode that lives at the bottom. This form of `Loop Inversion
+<https://en.wikipedia.org/wiki/Loop_inversion>`_ replaces the (unconditional
+jump, conditional jump) pair with just one conditional jump during most
+iterations.
@@ -263,11 +263,14 @@ mark_stacks(PyCodeObject *code_obj, int len)
                     next_stack = push_value(pop_value(next_stack), Iterator);
                     stacks[i+1] = next_stack;
                     break;
-                case FOR_ITER:
+                case FOR_END:
                 {
-                    int64_t target_stack = pop_value(next_stack);
-                    stacks[i+1] = push_value(next_stack, Object);
-                    j = get_arg(code, i) + i + 1;
+                    int64_t target_stack = push_value(next_stack, Object);
+                    stacks[i+1] = pop_value(next_stack);
+                    j = i + 1 - get_arg(code, i);
+                    if (stacks[j] == UNINITIALIZED && j < i) {
+                        todo = 1;
+                    }
                     assert(j < len);
                     assert(stacks[j] == UNINITIALIZED || stacks[j] == target_stack);
                     stacks[j] = target_stack;
@@ -570,7 +573,7 @@ frame_setlineno(PyFrameObject *f, PyObject* p_new_lineno, void *Py_UNUSED(ignore
             }
             else if (err < 0) {
                 if (start_stack == OVERFLOWED) {
-                    msg = "stack to deep to analyze";
+                    msg = "stack too deep to analyze";
                 }
                 else if (start_stack == UNINITIALIZED) {
                     msg = "can't jump from within an exception handler";