Merge branch 'jit_float_truediv' of github.com:eendebakpt/cpython into pr/146397

Author: Fidget-Spinner

Include/internal/pycore_opcode_metadata.h

@@ -3707,6 +3707,48 @@ def testfunc(args):
         uops = get_opnames(ex)
         self.assertIn("_BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT", uops)
 
+    def test_float_truediv_speculative_guards_from_tracing(self):
+        # a, b are locals with no statically known type. _RECORD_TOS /
+        # _RECORD_NOS (added to the BINARY_OP macro) capture the observed
+        # operand types during tracing, and the optimizer then speculatively
+        # emits _GUARD_{TOS,NOS}_FLOAT and specializes the division.
+        def testfunc(args):
+            a, b, n = args
+            total = 0.0
+            for _ in range(n):
+                total += a / b
+            return total
+
+        res, ex = self._run_with_optimizer(testfunc, (10.0, 3.0, TIER2_THRESHOLD))
+        self.assertAlmostEqual(res, TIER2_THRESHOLD * (10.0 / 3.0))
+        self.assertIsNotNone(ex)
+        uops = get_opnames(ex)
+        self.assertIn("_GUARD_TOS_FLOAT", uops)
+        self.assertIn("_GUARD_NOS_FLOAT", uops)
+        self.assertIn("_BINARY_OP_TRUEDIV_FLOAT", uops)
+
+    def test_float_remainder_speculative_guards_from_tracing(self):
+        # a, b are locals with no statically known type. Tracing records
+        # them as floats; the optimizer then speculatively emits
+        # _GUARD_{TOS,NOS}_FLOAT for NB_REMAINDER. That narrows both
+        # operands to float, and the _BINARY_OP handler marks the result
+        # as a unique float. Downstream, `* 2.0` therefore specializes
+        # to _BINARY_OP_MULTIPLY_FLOAT_INPLACE.
+        def testfunc(args):
+            a, b, n = args
+            total = 0.0
+            for _ in range(n):
+                total += (a % b) * 2.0
+            return total
+
+        res, ex = self._run_with_optimizer(testfunc, (10.0, 3.0, TIER2_THRESHOLD))
+        self.assertAlmostEqual(res, TIER2_THRESHOLD * (10.0 % 3.0) * 2.0)
+        self.assertIsNotNone(ex)
+        uops = get_opnames(ex)
+        self.assertIn("_GUARD_TOS_FLOAT", uops)
+        self.assertIn("_GUARD_NOS_FLOAT", uops)
+        self.assertIn("_BINARY_OP_MULTIPLY_FLOAT_INPLACE", uops)
+
     def test_float_truediv_type_propagation(self):
         # Test the _BINARY_OP_TRUEDIV_FLOAT propagates type information
         def testfunc(args):

Lib/test/test_capi/test_opt.py

@@ -5725,7 +5725,7 @@ dummy_func(
             DEAD(rhs);
         }
 
-        macro(BINARY_OP) = _SPECIALIZE_BINARY_OP + unused/4 + _BINARY_OP + POP_TOP + POP_TOP;
+        macro(BINARY_OP) = _SPECIALIZE_BINARY_OP + _RECORD_TOS + _RECORD_NOS + unused/4 + _BINARY_OP + POP_TOP + POP_TOP;
 
         pure replicate(2:4) inst(SWAP, (bottom, unused[oparg-2], top --
                     bottom, unused[oparg-2], top)) {

Python/bytecodes.c

@@ -289,8 +289,34 @@ dummy_func(void) {
         bool rhs_int = sym_matches_type(rhs, &PyLong_Type);
         bool lhs_float = sym_matches_type(lhs, &PyFloat_Type);
         bool rhs_float = sym_matches_type(rhs, &PyFloat_Type);
-        if ((oparg == NB_TRUE_DIVIDE || oparg == NB_INPLACE_TRUE_DIVIDE)
-                && lhs_float && rhs_float) {
+        bool is_truediv = (oparg == NB_TRUE_DIVIDE
+                           || oparg == NB_INPLACE_TRUE_DIVIDE);
+        bool is_remainder = (oparg == NB_REMAINDER
+                             || oparg == NB_INPLACE_REMAINDER);
+        // Promote probable-float operands to known floats via speculative
+        // guards. _RECORD_TOS / _RECORD_NOS in the BINARY_OP macro record
+        // the observed operand during tracing, which sym_get_probable_type
+        // reads here. Applied only to ops where narrowing unlocks a
+        // meaningful downstream win:
+        //   - NB_TRUE_DIVIDE: enables the specialized float path below.
+        //   - NB_REMAINDER: lets the float result type propagate.
+        // NB_POWER is excluded — speculative guards there regressed
+        // test_power_type_depends_on_input_values (GH-127844).
+        if (is_truediv || is_remainder) {
+            if (!sym_has_type(rhs)
+                    && sym_get_probable_type(rhs) == &PyFloat_Type) {
+                ADD_OP(_GUARD_TOS_FLOAT, 0, 0);
+                sym_set_type(rhs, &PyFloat_Type);
+                rhs_float = true;
+            }
+            if (!sym_has_type(lhs)
+                    && sym_get_probable_type(lhs) == &PyFloat_Type) {
+                ADD_OP(_GUARD_NOS_FLOAT, 0, 0);
+                sym_set_type(lhs, &PyFloat_Type);
+                lhs_float = true;
+            }
+        }
+        if (is_truediv && lhs_float && rhs_float) {
             if (PyJitRef_IsUnique(lhs)) {
                 ADD_OP(_BINARY_OP_TRUEDIV_FLOAT_INPLACE, 0, 0);
                 l = sym_new_null(ctx);
@@ -308,7 +334,7 @@ dummy_func(void) {
             }
             res = PyJitRef_MakeUnique(sym_new_type(ctx, &PyFloat_Type));
         }
-        else if ((oparg == NB_TRUE_DIVIDE || oparg == NB_INPLACE_TRUE_DIVIDE)
+        else if (is_truediv
                 && (lhs_int || lhs_float) && (rhs_int || rhs_float)) {
             res = PyJitRef_MakeUnique(sym_new_type(ctx, &PyFloat_Type));
         }