gh-115758: Optimizer constant propagation for 64-bit ints and doubles

Include/internal/pycore_floatobject.h

@@ -55,6 +55,7 @@ extern PyObject* _Py_string_to_number_with_underscores(
 
 extern double _Py_parse_inf_or_nan(const char *p, char **endptr);
 
+PyAPI_FUNC(PyObject *) _PyFloat_From64Bits(int64_t);
 
 #ifdef __cplusplus
 }

Lib/test/test_capi/test_opt.py

@@ -794,48 +794,44 @@ def testfunc(n):
 
     def test_float_add_constant_propagation(self):
         def testfunc(n):
-            a = 1.0
             for _ in range(n):
+                a = 1.0
                 a = a + 0.25
                 a = a + 0.25
                 a = a + 0.25
                 a = a + 0.25
             return a
 
         res, ex = self._run_with_optimizer(testfunc, 32)
-        self.assertAlmostEqual(res, 33.0)
+        self.assertAlmostEqual(res, 2.0)
         self.assertIsNotNone(ex)
         uops = get_opnames(ex)
-        guard_both_float_count = [opname for opname in iter_opnames(ex) if opname == "_GUARD_BOTH_FLOAT"]
-        self.assertLessEqual(len(guard_both_float_count), 1)
-        # TODO gh-115506: this assertion may change after propagating constants.
-        # We'll also need to verify that propagation actually occurs.
-        self.assertIn("_BINARY_OP_ADD_FLOAT", uops)
+        self.assertNotIn("_BINARY_OP_ADD_FLOAT", uops)
+        self.assertIn("_LOAD_FLOAT", uops)
 
     def test_float_subtract_constant_propagation(self):
         def testfunc(n):
-            a = 1.0
             for _ in range(n):
+                a = 1.0
                 a = a - 0.25
                 a = a - 0.25
                 a = a - 0.25
                 a = a - 0.25
             return a
 
         res, ex = self._run_with_optimizer(testfunc, 32)
-        self.assertAlmostEqual(res, -31.0)
+        self.assertAlmostEqual(res, 0.0)
         self.assertIsNotNone(ex)
         uops = get_opnames(ex)
         guard_both_float_count = [opname for opname in iter_opnames(ex) if opname == "_GUARD_BOTH_FLOAT"]
         self.assertLessEqual(len(guard_both_float_count), 1)
-        # TODO gh-115506: this assertion may change after propagating constants.
-        # We'll also need to verify that propagation actually occurs.
-        self.assertIn("_BINARY_OP_SUBTRACT_FLOAT", uops)
+        self.assertNotIn("_BINARY_OP_SUBTRACT_FLOAT", uops)
+        self.assertIn("_LOAD_FLOAT", uops)
 
     def test_float_multiply_constant_propagation(self):
         def testfunc(n):
-            a = 1.0
             for _ in range(n):
+                a = 1.0
                 a = a * 1.0
                 a = a * 1.0
                 a = a * 1.0
@@ -848,9 +844,22 @@ def testfunc(n):
         uops = get_opnames(ex)
         guard_both_float_count = [opname for opname in iter_opnames(ex) if opname == "_GUARD_BOTH_FLOAT"]
         self.assertLessEqual(len(guard_both_float_count), 1)
-        # TODO gh-115506: this assertion may change after propagating constants.
-        # We'll also need to verify that propagation actually occurs.
-        self.assertIn("_BINARY_OP_MULTIPLY_FLOAT", uops)
+        self.assertNotIn("_BINARY_OP_MULTIPLY_FLOAT", uops)
+        self.assertIn("_LOAD_FLOAT", uops)
+
+    def test_int_add_constant_propagation_peepholer_advanced(self):
+        def testfunc(n):
+            for _ in range(n):
+                a = 1
+                a = (a + a) + (a + a + (a + a))
+            return a
+
+        res, ex = self._run_with_optimizer(testfunc, 32)
+        self.assertAlmostEqual(res, 6)
+        self.assertIsNotNone(ex)
+        uops = get_opnames(ex)
+        self.assertNotIn("_BINARY_OP_ADD_INT", uops)
+        self.assertIn("_LOAD_INT", uops)
 
     def test_add_unicode_propagation(self):
         def testfunc(n):
@@ -941,7 +950,8 @@ def testfunc(n):
         self.assertIsNotNone(ex)
         uops = get_opnames(ex)
         self.assertNotIn("_GUARD_BOTH_INT", uops)
-        self.assertIn("_BINARY_OP_ADD_INT", uops)
+        # Constant folded
+        self.assertIn("_LOAD_INT", uops)
         # Try again, but between the runs, set the global to a float.
         # This should result in no executor the second time.
         ns = {}
@@ -1245,5 +1255,36 @@ def testfunc(n):
         self.assertEqual(res, 32 * 32)
         self.assertIsNone(ex)
 
+    def test_int_constant_propagation(self):
+        def testfunc(n):
+            for _ in range(n):
+                a = 1
+                x = a + a - a * a
+            return x
+
+        res, ex = self._run_with_optimizer(testfunc, 32)
+        self.assertTrue(res)
+        self.assertIsNotNone(ex)
+        uops = get_opnames(ex)
+        self.assertNotIn("_BINARY_OP_ADD_INT", uops)
+        self.assertNotIn("_BINARY_OP_MULTIPLY_INT", uops)
+        self.assertNotIn("_BINARY_OP_SUBTRACT_INT", uops)
+
+    def test_no_bigint_constant_propagation(self):
+        # We don't want to hold strong references in the trace.
+        def testfunc(n):
+            for _ in range(n):
+                a = 100000000000000000000000000000000000000
+                x = a + a - a * a
+            return x
+
+        res, ex = self._run_with_optimizer(testfunc, 32)
+        self.assertTrue(res)
+        self.assertIsNotNone(ex)
+        uops = get_opnames(ex)
+        self.assertIn("_BINARY_OP_ADD_INT", uops)
+        self.assertIn("_BINARY_OP_MULTIPLY_INT", uops)
+        self.assertIn("_BINARY_OP_SUBTRACT_INT", uops)
+
 if __name__ == "__main__":
     unittest.main()

Objects/floatobject.c

@@ -2614,3 +2614,12 @@ PyFloat_Unpack8(const char *data, int le)
         return x;
     }
 }
+
+PyObject*
+_PyFloat_From64Bits(int64_t val)
+{
+    assert(sizeof(double) == sizeof(int64_t));
+    double dst;
+    memcpy(&dst, &val, sizeof(int64_t));
+    return PyFloat_FromDouble(dst);
+}

Python/bytecodes.c

@@ -4127,6 +4127,30 @@ dummy_func(
             null = NULL;
         }
 
+        tier2 pure op(_LOAD_INT, (cached/4 -- value)) {
+            value = PyLong_FromLong((int64_t)cached);
+            ERROR_IF(value == NULL, error);
+        }
+
+        tier2 pure op(_POP_TWO_LOAD_INT, (cached/4, pop1, pop2 -- value)) {
+            Py_DECREF(pop1);
+            Py_DECREF(pop2);
+            value = PyLong_FromLong((int64_t)cached);
+            ERROR_IF(value == NULL, error);
+        }
+
+        tier2 pure op(_LOAD_FLOAT, (cached/4: int64_t -- value)) {
+            value = _PyFloat_From64Bits((int64_t)cached);
+            ERROR_IF(value == NULL, error);
+        }
+
+        tier2 pure op(_POP_TWO_LOAD_FLOAT, (cached/4: int64_t, pop1, pop2 -- value)) {
+            Py_DECREF(pop1);
+            Py_DECREF(pop2);
+            value = _PyFloat_From64Bits((int64_t)cached);
+            ERROR_IF(value == NULL, error);
+        }
+
         tier2 op(_CHECK_FUNCTION, (func_version/2 -- )) {
             assert(PyFunction_Check(frame->f_funcobj));
             DEOPT_IF(((PyFunctionObject *)frame->f_funcobj)->func_version != func_version);