Add 2-operand support

Include/internal/pycore_optimizer.h

@@ -59,6 +59,7 @@ typedef struct {
         };
     };
     uint64_t operand;  // A cache entry
+    uint64_t operand1;
 } _PyUOpInstruction;
 
 typedef struct {

Python/bytecodes.c

@@ -3442,8 +3442,7 @@ dummy_func(
             EXIT_IF(func->func_version != func_version);
         }
 
-        tier2 op(_CHECK_FUNCTION_VERSION_INLINE, (callable_o/4 --)) {
-            uint16_t func_version = oparg;
+        tier2 op(_CHECK_FUNCTION_VERSION_INLINE, (func_version/2, callable_o/4 --)) {
             assert(PyFunction_Check(callable_o));
             PyFunctionObject *func = (PyFunctionObject *)callable_o;
             EXIT_IF(func->func_version != func_version);

Python/ceval_macros.h

@@ -410,6 +410,7 @@ do { \
 #define CURRENT_OPARG() (next_uop[-1].oparg)
 
 #define CURRENT_OPERAND() (next_uop[-1].operand)
+#define CURRENT_OPERAND1() (next_uop[-1].operand1)
 
 #define JUMP_TO_JUMP_TARGET() goto jump_to_jump_target
 #define JUMP_TO_ERROR() goto jump_to_error_target

Python/optimizer_bytecodes.c

@@ -593,9 +593,8 @@ dummy_func(void) {
         (void)self_or_null;
         if (sym_is_const(callable) && sym_matches_type(callable, &PyFunction_Type)) {
             assert(PyFunction_Check(sym_get_const(callable)));
-            if (func_version == (uint16_t)func_version) {
-                REPLACE_OP(this_instr, _CHECK_FUNCTION_VERSION_INLINE, func_version, (uintptr_t)sym_get_const(callable));
-            }
+            REPLACE_OP(this_instr, _CHECK_FUNCTION_VERSION_INLINE, 0, func_version);
+            this_instr->operand1 = (uintptr_t)sym_get_const(callable);
         }
         sym_set_type(callable, &PyFunction_Type);
     }

Tools/cases_generator/analyzer.py

@@ -200,7 +200,7 @@ def why_not_viable(self) -> str | None:
             return "has tier 1 control flow"
         if self.properties.needs_this:
             return "uses the 'this_instr' variable"
-        if len([c for c in self.caches if c.name != "unused"]) > 1:
+        if len([c for c in self.caches if c.name != "unused"]) > 2:
             return "has unused cache entries"
         if self.properties.error_with_pop and self.properties.error_without_pop:
             return "has both popping and not-popping errors"

Tools/cases_generator/tier2_generator.py

@@ -181,14 +181,17 @@ def write_uop(uop: Uop, emitter: Emitter, stack: Stack) -> Stack:
         code_list, storage = Storage.for_uop(stack, uop)
         for code in code_list:
             emitter.emit(code)
-        for cache in uop.caches:
+        for idx, cache in enumerate(uop.caches):
             if cache.name != "unused":
                 if cache.size == 4:
                     type = cast = "PyObject *"
                 else:
                     type = f"uint{cache.size*16}_t "
                     cast = f"uint{cache.size*16}_t"
-                emitter.emit(f"{type}{cache.name} = ({cast})CURRENT_OPERAND();\n")
+                if idx == 0:
+                    emitter.emit(f"{type}{cache.name} = ({cast})CURRENT_OPERAND();\n")
+                else:
+                    emitter.emit(f"{type}{cache.name} = ({cast})CURRENT_OPERAND{idx}();\n")
         storage = emitter.emit_tokens(uop, storage, None)
     except StackError as ex:
         raise analysis_error(ex.args[0], uop.body[0]) from None

Tools/jit/_stencils.py

@@ -34,6 +34,11 @@ class HoleValue(enum.Enum):
     # The current uop's operand on 32-bit platforms (exposed as _JIT_OPERAND_HI/LO):
     OPERAND_HI = enum.auto()
     OPERAND_LO = enum.auto()
+    # The current uop's operand1 on 64-bit platforms (exposed as _JIT_OPERAND):
+    OPERAND1 = enum.auto()
+    # The current uop's operand1 on 32-bit platforms (exposed as _JIT_OPERAND_HI/LO):
+    OPERAND1_HI = enum.auto()
+    OPERAND1_LO = enum.auto()
     # The current uop's target (exposed as _JIT_TARGET):
     TARGET = enum.auto()
     # The base address of the machine code for the jump target (exposed as _JIT_JUMP_TARGET):
@@ -102,6 +107,9 @@ class HoleValue(enum.Enum):
     HoleValue.OPERAND: "instruction->operand",
     HoleValue.OPERAND_HI: "(instruction->operand >> 32)",
     HoleValue.OPERAND_LO: "(instruction->operand & UINT32_MAX)",
+    HoleValue.OPERAND1: "instruction->operand1",
+    HoleValue.OPERAND1_HI: "(instruction->operand1 >> 32)",
+    HoleValue.OPERAND1_LO: "(instruction->operand1 & UINT32_MAX)",
     HoleValue.TARGET: "instruction->target",
     HoleValue.JUMP_TARGET: "state->instruction_starts[instruction->jump_target]",
     HoleValue.ERROR_TARGET: "state->instruction_starts[instruction->error_target]",

Tools/jit/template.c

@@ -29,6 +29,9 @@
 #undef CURRENT_OPERAND
 #define CURRENT_OPERAND() (_operand)
 
+#undef CURRENT_OPERAND1
+#define CURRENT_OPERAND1() (_operand1)
+
 #undef DEOPT_IF
 #define DEOPT_IF(COND, INSTNAME) \
     do {                         \
@@ -105,6 +108,14 @@ _JIT_ENTRY(_PyInterpreterFrame *frame, _PyStackRef *stack_pointer, PyThreadState
     PATCH_VALUE(uint32_t, _operand_hi, _JIT_OPERAND_HI)
     PATCH_VALUE(uint32_t, _operand_lo, _JIT_OPERAND_LO)
     uint64_t _operand = ((uint64_t)_operand_hi << 32) | _operand_lo;
+#endif
+#if SIZEOF_VOID_P == 8
+    PATCH_VALUE(uint64_t, _operand1, _JIT_OPERAND1)
+#else
+    assert(SIZEOF_VOID_P == 4);
+    PATCH_VALUE(uint32_t, _operand1_hi, _JIT_OPERAND1_HI)
+    PATCH_VALUE(uint32_t, _operand1_lo, _JIT_OPERAND1_LO)
+    uint64_t _operand1 = ((uint64_t)_operand1_hi << 32) | _operand1_lo;
 #endif
     PATCH_VALUE(uint32_t, _target, _JIT_TARGET)