Remove ReturnConst/Break/Continue ops (#6816)

youknowone · web-flow · commit e0cceaf31c70 · 2026-01-21T00:03:43.000+09:00
* Remove ReturnConst

* Remove break/continue ops
diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py
@@ -216,10 +216,7 @@
     'BEFORE_WITH': 213,
     'BINARY_SUBSCR': 214,
     'BUILD_CONST_KEY_MAP': 215,
-    'BREAK': 216,
-    'CONTINUE': 217,
     'JUMP_IF_NOT_EXC_MATCH': 220,
-    'RETURN_CONST': 222,
     'SET_EXC_INFO': 223,
     'INSTRUMENTED_END_FOR': 234,
     'INSTRUMENTED_POP_ITER': 235,
diff --git a/Lib/dis.py b/Lib/dis.py
@@ -34,7 +34,6 @@
 
 ENTER_EXECUTOR = opmap['ENTER_EXECUTOR']
 LOAD_CONST = opmap['LOAD_CONST']
-RETURN_CONST = opmap['RETURN_CONST']
 LOAD_GLOBAL = opmap['LOAD_GLOBAL']
 BINARY_OP = opmap['BINARY_OP']
 JUMP_BACKWARD = opmap['JUMP_BACKWARD']
diff --git a/Lib/test/test_dis.py b/Lib/test/test_dis.py
@@ -210,7 +210,8 @@ def bug42562():
 
 dis_bug42562 = """\
           RESUME                   0
-          RETURN_CONST             0 (None)
+          LOAD_CONST               0 (None)
+          RETURN_VALUE
 """
 
 # Extended arg followed by NOP
diff --git a/Lib/test/test_peepholer.py b/Lib/test/test_peepholer.py
@@ -117,7 +117,7 @@ def f():
             return None
 
         self.assertNotInBytecode(f, 'LOAD_GLOBAL')
-        self.assertInBytecode(f, 'RETURN_CONST', None)
+        self.assertInBytecode(f, 'LOAD_CONST', None)
         self.check_lnotab(f)
 
     @unittest.expectedFailure # TODO: RUSTPYTHON
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
@@ -7688,17 +7688,11 @@ impl Compiler {
     }
 
     fn emit_return_const(&mut self, constant: ConstantData) {
-        let idx = self.arg_constant(constant);
-        self.emit_arg(idx, |idx| Instruction::ReturnConst { idx })
+        self.emit_load_const(constant);
+        emit!(self, Instruction::ReturnValue)
     }
 
     fn emit_return_value(&mut self) {
-        if let Some(inst) = self.current_block().instructions.last_mut()
-            && let AnyInstruction::Real(Instruction::LoadConst { idx }) = inst.instr
-        {
-            inst.instr = Instruction::ReturnConst { idx }.into();
-            return;
-        }
         emit!(self, Instruction::ReturnValue)
     }
 
@@ -7876,11 +7870,8 @@ impl Compiler {
         }
 
         // Jump to target
-        if is_break {
-            emit!(self, Instruction::Break { target: exit_block });
-        } else {
-            emit!(self, Instruction::Continue { target: loop_block });
-        }
+        let target = if is_break { exit_block } else { loop_block };
+        emit!(self, PseudoInstruction::Jump { target });
 
         Ok(())
     }
diff --git a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ands.snap b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ands.snap
diff --git a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_mixed.snap b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_mixed.snap
diff --git a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ors.snap b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ors.snap
diff --git a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
@@ -266,16 +266,7 @@ pub enum Instruction {
     BuildConstKeyMap {
         size: Arg<u32>,
     } = 215, // Placeholder
-    Break {
-        target: Arg<Label>,
-    } = 216,
-    Continue {
-        target: Arg<Label>,
-    } = 217,
     JumpIfNotExcMatch(Arg<Label>) = 220,
-    ReturnConst {
-        idx: Arg<u32>,
-    } = 222,
     SetExcInfo = 223,
     // CPython 3.14 RESUME (128)
     Resume {
@@ -427,14 +418,7 @@ impl TryFrom<u8> for Instruction {
             u8::from(Self::BuildConstKeyMap {
                 size: Arg::marker(),
             }),
-            u8::from(Self::Break {
-                target: Arg::marker(),
-            }),
-            u8::from(Self::Continue {
-                target: Arg::marker(),
-            }),
             u8::from(Self::JumpIfNotExcMatch(Arg::marker())),
-            u8::from(Self::ReturnConst { idx: Arg::marker() }),
             u8::from(Self::SetExcInfo),
         ];
 
@@ -463,8 +447,6 @@ impl InstructionMetadata for Instruction {
             | Self::PopJumpIfTrue { target: l }
             | Self::PopJumpIfFalse { target: l }
             | Self::ForIter { target: l }
-            | Self::Break { target: l }
-            | Self::Continue { target: l }
             | Self::Send { target: l } => Some(*l),
             _ => None,
         }
@@ -476,10 +458,7 @@ impl InstructionMetadata for Instruction {
             Self::JumpForward { .. }
                 | Self::JumpBackward { .. }
                 | Self::JumpBackwardNoInterrupt { .. }
-                | Self::Continue { .. }
-                | Self::Break { .. }
                 | Self::ReturnValue
-                | Self::ReturnConst { .. }
                 | Self::RaiseVarargs { .. }
                 | Self::Reraise { .. }
         )
@@ -528,8 +507,6 @@ impl InstructionMetadata for Instruction {
             Self::GetLen => 1,
             Self::CallIntrinsic1 { .. } => 0,  // Takes 1, pushes 1
             Self::CallIntrinsic2 { .. } => -1, // Takes 2, pushes 1
-            Self::Continue { .. } => 0,
-            Self::Break { .. } => 0,
             Self::PopJumpIfTrue { .. } => -1,
             Self::PopJumpIfFalse { .. } => -1,
             Self::MakeFunction => {
@@ -559,7 +536,6 @@ impl InstructionMetadata for Instruction {
             Self::ContainsOp(_) => -1,
             Self::JumpIfNotExcMatch(_) => -2,
             Self::ReturnValue => -1,
-            Self::ReturnConst { .. } => 0,
             Self::Resume { .. } => 0,
             Self::YieldValue { .. } => 0,
             // SEND: (receiver, val) -> (receiver, retval) - no change, both paths keep same depth
@@ -838,7 +814,6 @@ impl InstructionMetadata for Instruction {
             Self::BeforeWith => w!(BEFORE_WITH),
             Self::BinaryOp { op } => write!(f, "{:pad$}({})", "BINARY_OP", op.get(arg)),
             Self::BinarySubscr => w!(BINARY_SUBSCR),
-            Self::Break { target } => w!(BREAK, target),
             Self::BuildList { size } => w!(BUILD_LIST, size),
             Self::BuildMap { size } => w!(BUILD_MAP, size),
             Self::BuildSet { size } => w!(BUILD_SET, size),
@@ -855,7 +830,6 @@ impl InstructionMetadata for Instruction {
             Self::CleanupThrow => w!(CLEANUP_THROW),
             Self::CompareOp { op } => w!(COMPARE_OP, ?op),
             Self::ContainsOp(inv) => w!(CONTAINS_OP, ?inv),
-            Self::Continue { target } => w!(CONTINUE, target),
             Self::ConvertValue { oparg } => write!(f, "{:pad$}{}", "CONVERT_VALUE", oparg.get(arg)),
             Self::Copy { index } => w!(COPY, index),
             Self::DeleteAttr { idx } => w!(DELETE_ATTR, name = idx),
@@ -935,7 +909,6 @@ impl InstructionMetadata for Instruction {
             Self::RaiseVarargs { kind } => w!(RAISE_VARARGS, ?kind),
             Self::Reraise { depth } => w!(RERAISE, depth),
             Self::Resume { arg } => w!(RESUME, arg),
-            Self::ReturnConst { idx } => fmt_const("RETURN_CONST", arg, f, idx),
             Self::ReturnValue => w!(RETURN_VALUE),
             Self::Send { target } => w!(SEND, target),
             Self::SetAdd { i } => w!(SET_ADD, i),
diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
@@ -211,7 +211,6 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             // If that was an unconditional branch or return, mark future instructions unreachable
             match instruction {
                 Instruction::ReturnValue
-                | Instruction::ReturnConst { .. }
                 | Instruction::JumpBackward { .. }
                 | Instruction::JumpBackwardNoInterrupt { .. }
                 | Instruction::JumpForward { .. } => {
@@ -628,11 +627,6 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 // TODO: Implement the resume instruction
                 Ok(())
             }
-            Instruction::ReturnConst { idx } => {
-                let val = self
-                    .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
-                self.return_value(val)
-            }
             Instruction::ReturnValue => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 self.return_value(val)
diff --git a/crates/jit/tests/common.rs b/crates/jit/tests/common.rs
@@ -141,7 +141,7 @@ fn extract_annotations_from_annotate_code(code: &CodeObject) -> HashMap<Wtf8Buf,
             | Instruction::ExtendedArg => {
                 // Ignore these instructions for annotation extraction
             }
-            Instruction::ReturnValue | Instruction::ReturnConst { .. } => {
+            Instruction::ReturnValue => {
                 // End of function - return what we have
                 return annotations;
             }
@@ -276,11 +276,6 @@ impl StackMachine {
                     self.stack.push(StackValue::Function(func));
                 }
             }
-            Instruction::ReturnConst { idx } => {
-                let idx = idx.get(arg);
-                self.stack.push(constants[idx as usize].clone().into());
-                return ControlFlow::Break(());
-            }
             Instruction::ReturnValue => return ControlFlow::Break(()),
             Instruction::ExtendedArg => {}
             _ => unimplemented!(
diff --git a/crates/stdlib/src/opcode.rs b/crates/stdlib/src/opcode.rs
@@ -71,9 +71,7 @@ mod opcode {
         pub fn has_const(opcode: i32) -> bool {
             matches!(
                 Self::try_from(opcode).map(|op| op.inner()),
-                Ok(AnyInstruction::Real(
-                    Instruction::LoadConst { .. } | Instruction::ReturnConst { .. }
-                ))
+                Ok(AnyInstruction::Real(Instruction::LoadConst { .. }))
             )
         }
 
@@ -104,9 +102,7 @@ mod opcode {
             matches!(
                 Self::try_from(opcode).map(|op| op.inner()),
                 Ok(AnyInstruction::Real(
-                    Instruction::Break { .. }
-                        | Instruction::Continue { .. }
-                        | Instruction::ForIter { .. }
+                    Instruction::ForIter { .. }
                         | Instruction::JumpIfNotExcMatch(_)
                         | Instruction::PopJumpIfFalse { .. }
                         | Instruction::PopJumpIfTrue { .. }
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
@@ -45,13 +45,6 @@ enum UnwindReason {
     /// We hit an exception, so unwind any try-except and finally blocks. The exception should be
     /// on top of the vm exception stack.
     Raising { exception: PyBaseExceptionRef },
-
-    // NoWorries,
-    /// We are unwinding blocks, since we hit break
-    Break { target: bytecode::Label },
-
-    /// We are unwinding blocks since we hit a continue statements.
-    Continue { target: bytecode::Label },
 }
 
 #[derive(Debug)]
@@ -658,12 +651,6 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
 
-            Instruction::Break { target } => self.unwind_blocks(
-                vm,
-                UnwindReason::Break {
-                    target: target.get(arg),
-                },
-            ),
             Instruction::BuildList { size } => {
                 let sz = size.get(arg) as usize;
                 let elements = self.pop_multiple(sz).collect();
@@ -804,13 +791,6 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(value).into());
                 Ok(None)
             }
-            Instruction::Continue { target } => self.unwind_blocks(
-                vm,
-                UnwindReason::Continue {
-                    target: target.get(arg),
-                },
-            ),
-
             Instruction::ConvertValue { oparg: conversion } => {
                 self.convert_value(conversion.get(arg), vm)
             }
@@ -1562,10 +1542,6 @@ impl ExecutingFrame<'_> {
                 // }
                 Ok(None)
             }
-            Instruction::ReturnConst { idx } => {
-                let value = self.code.constants[idx.get(arg) as usize].clone().into();
-                self.unwind_blocks(vm, UnwindReason::Returning { value })
-            }
             Instruction::ReturnValue => {
                 let value = self.pop_value();
                 self.unwind_blocks(vm, UnwindReason::Returning { value })
@@ -2059,11 +2035,6 @@ impl ExecutingFrame<'_> {
                 drop(fastlocals);
                 Ok(Some(ExecutionResult::Return(value)))
             }
-            UnwindReason::Break { target } | UnwindReason::Continue { target } => {
-                // Break/continue: jump to the target label
-                self.jump(target);
-                Ok(None)
-            }
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -7688,17 +7688,11 @@ impl Compiler {`
`7688`	`7688`	`}`
`7689`	`7689`
`7690`	`7690`	`fn emit_return_const(&mut self, constant: ConstantData) {`
`7691`		`- let idx = self.arg_constant(constant);`
`7692`		`- self.emit_arg(idx, \|idx\| Instruction::ReturnConst { idx })`
	`7691`	`+ self.emit_load_const(constant);`
	`7692`	`+ emit!(self, Instruction::ReturnValue)`
`7693`	`7693`	`}`
`7694`	`7694`
`7695`	`7695`	`fn emit_return_value(&mut self) {`
`7696`		`- if let Some(inst) = self.current_block().instructions.last_mut()`
`7697`		`- && let AnyInstruction::Real(Instruction::LoadConst { idx }) = inst.instr`
`7698`		`- {`
`7699`		`- inst.instr = Instruction::ReturnConst { idx }.into();`
`7700`		`- return;`
`7701`		`- }`
`7702`	`7696`	`emit!(self, Instruction::ReturnValue)`
`7703`	`7697`	`}`
`7704`	`7698`
`@@ -7876,11 +7870,8 @@ impl Compiler {`
`7876`	`7870`	`}`
`7877`	`7871`
`7878`	`7872`	`// Jump to target`
`7879`		`- if is_break {`
`7880`		`- emit!(self, Instruction::Break { target: exit_block });`
`7881`		`- } else {`
`7882`		`- emit!(self, Instruction::Continue { target: loop_block });`
`7883`		`- }`
	`7873`	`+ let target = if is_break { exit_block } else { loop_block };`
	`7874`	`+ emit!(self, PseudoInstruction::Jump { target });`
`7884`	`7875`
`7885`	`7876`	`Ok(())`
`7886`	`7877`	`}`