gh-91432: Add FOR_END, alternate: keep FOR_ITER around.

Doc/library/dis.rst

@@ -1009,12 +1009,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)

Doc/whatsnew/3.11.rst

@@ -774,6 +774,12 @@ CPython bytecode changes
   opcodes to speed up conditional jumps.
 
 
+* 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
 ==========
 

Lib/dis.py

@@ -30,7 +30,6 @@
 LOAD_CONST = opmap['LOAD_CONST']
 LOAD_GLOBAL = opmap['LOAD_GLOBAL']
 BINARY_OP = opmap['BINARY_OP']
-JUMP_BACKWARD = opmap['JUMP_BACKWARD']
 
 CACHE = opmap["CACHE"]
 
@@ -393,7 +392,8 @@ def parse_exception_table(code):
         return entries
 
 def _is_backward_jump(op):
-    return 'JUMP_BACKWARD' in opname[op]
+    name = opname[op]
+    return 'JUMP_BACKWARD' in name or name == "FOR_END"
 
 def _get_instructions_bytes(code, varname_from_oparg=None,
                             names=None, co_consts=None,

Lib/importlib/_bootstrap_external.py

@@ -415,7 +415,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 = (3492).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__'

Lib/opcode.py

@@ -201,6 +201,7 @@ def jabs_op(name, op, entries=0):
 jrel_op('POP_JUMP_BACKWARD_IF_NONE', 174)
 jrel_op('POP_JUMP_BACKWARD_IF_FALSE', 175)
 jrel_op('POP_JUMP_BACKWARD_IF_TRUE', 176)
+jrel_op('FOR_END', 177)
 
 
 del def_op, name_op, jrel_op, jabs_op
@@ -267,6 +268,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",

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)

Lib/test/test_dis.py

@@ -146,12 +146,15 @@ def bug708901():
 %3d        PRECALL                  2
            CALL                     2
            GET_ITER
-        >> FOR_ITER                 2 (to 40)
-           STORE_FAST               0 (res)
+           FOR_ITER                 5 (to 46)
+        >> 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
+        >> LOAD_CONST               0 (None)
            RETURN_VALUE
 """ % (bug708901.__code__.co_firstlineno,
        bug708901.__code__.co_firstlineno + 1,
@@ -569,13 +572,13 @@ def foo(x):
 %3d        RESUME                   0
            BUILD_LIST               0
            LOAD_FAST                0 (.0)
-        >> FOR_ITER                 7 (to 24)
-           STORE_FAST               1 (z)
+           FOR_ITER                 7 (to 24)
+        >> STORE_FAST               1 (z)
            LOAD_DEREF               2 (x)
            LOAD_FAST                1 (z)
            BINARY_OP                0 (+)
            LIST_APPEND              2
-           JUMP_BACKWARD            8 (to 8)
+           FOR_END                  7 (to 10)
         >> RETURN_VALUE
 """ % (dis_nested_1,
        __file__,
@@ -1226,7 +1229,7 @@ def _prepare_test_cases():
   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='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),
@@ -1243,7 +1246,7 @@ def _prepare_test_cases():
   Instruction(opname='POP_JUMP_FORWARD_IF_FALSE', opcode=114, arg=2, 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='FOR_END', opcode=177, 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=True, 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),

Lib/test/test_peepholer.py

@@ -510,16 +510,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'

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.

Objects/frameobject.c

@@ -283,6 +283,19 @@ mark_stacks(PyCodeObject *code_obj, int len)
                     stacks[j] = target_stack;
                     break;
                 }
+                case FOR_END:
+                {
+                    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;
+                    break;
+                }
                 case END_ASYNC_FOR:
                     next_stack = pop_value(pop_value(pop_value(next_stack)));
                     stacks[i+1] = next_stack;
@@ -580,7 +593,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";