add back recording ops and guards

Author: eendebakpt

Include/internal/pycore_opcode_metadata.h

@@ -3688,6 +3688,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

@@ -5728,7 +5728,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

@@ -279,6 +279,31 @@ 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);
+        // Speculatively promote probable floats to known floats. The
+        // _RECORD_TOS / _RECORD_NOS uops preceding _BINARY_OP record the
+        // observed operands during tracing; if the probable type is float
+        // but no static type is known, emit a guard and narrow the symbol.
+        // For NB_TRUE_DIVIDE this enables the specialized float path
+        // below; for NB_REMAINDER it lets the result type propagate as
+        // float so downstream ops can specialize. NB_POWER is intentionally
+        // excluded: speculative guards there broke
+        // test_power_type_depends_on_input_values (see GH-127844), likely
+        // due to subtle interactions with the case A-G dispatch.
+        if (oparg == NB_TRUE_DIVIDE || oparg == NB_INPLACE_TRUE_DIVIDE
+                || oparg == NB_REMAINDER || oparg == NB_INPLACE_REMAINDER) {
+            if (!rhs_float && !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 (!lhs_float && !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 ((oparg == NB_TRUE_DIVIDE || oparg == NB_INPLACE_TRUE_DIVIDE)
                 && lhs_float && rhs_float) {
             if (PyJitRef_IsUnique(lhs)) {