GH-131798: Optimize away type(x) in the JIT when the result is known (GH-135194)

tomasr8 · web-flow · commit 46151648ca8b · 2025-06-06T16:44:43.000-07:00
diff --git a/Lib/test/test_capi/test_opt.py b/Lib/test/test_capi/test_opt.py
@@ -1778,11 +1778,12 @@ def testfunc(n):
         self.assertNotIn("_GUARD_TOS_UNICODE", uops)
         self.assertIn("_BINARY_OP_ADD_UNICODE", uops)
 
-    def test_call_type_1(self):
+    def test_call_type_1_guards_removed(self):
         def testfunc(n):
             x = 0
             for _ in range(n):
-                x += type(42) is int
+                foo = eval('42')
+                x += type(foo) is int
             return x
 
         res, ex = self._run_with_optimizer(testfunc, TIER2_THRESHOLD)
@@ -1793,6 +1794,25 @@ def testfunc(n):
         self.assertNotIn("_GUARD_NOS_NULL", uops)
         self.assertNotIn("_GUARD_CALLABLE_TYPE_1", uops)
 
+    def test_call_type_1_known_type(self):
+        def testfunc(n):
+            x = 0
+            for _ in range(n):
+                x += type(42) is int
+            return x
+
+        res, ex = self._run_with_optimizer(testfunc, TIER2_THRESHOLD)
+        self.assertEqual(res, TIER2_THRESHOLD)
+        self.assertIsNotNone(ex)
+        uops = get_opnames(ex)
+        # When the result of type(...) is known, _CALL_TYPE_1 is replaced with
+        # _POP_CALL_ONE_LOAD_CONST_INLINE_BORROW which is optimized away in
+        # remove_unneeded_uops.
+        self.assertNotIn("_CALL_TYPE_1", uops)
+        self.assertNotIn("_POP_CALL_ONE_LOAD_CONST_INLINE_BORROW", uops)
+        self.assertNotIn("_POP_CALL_LOAD_CONST_INLINE_BORROW", uops)
+        self.assertNotIn("_POP_TOP_LOAD_CONST_INLINE_BORROW", uops)
+
     def test_call_type_1_result_is_const(self):
         def testfunc(n):
             x = 0
@@ -1806,7 +1826,6 @@ def testfunc(n):
         self.assertEqual(res, TIER2_THRESHOLD)
         self.assertIsNotNone(ex)
         uops = get_opnames(ex)
-        self.assertIn("_CALL_TYPE_1", uops)
         self.assertNotIn("_GUARD_IS_NOT_NONE_POP", uops)
 
     def test_call_str_1(self):
diff --git a/Misc/NEWS.d/next/Core_and_Builtins/2025-06-05-21-58-30.gh-issue-131798.nt5Ab7.rst b/Misc/NEWS.d/next/Core_and_Builtins/2025-06-05-21-58-30.gh-issue-131798.nt5Ab7.rst
@@ -0,0 +1,2 @@
+Optimize away ``_CALL_TYPE_1`` in the JIT when the return type is known.
+Patch by Tomas Roun
diff --git a/Python/optimizer_bytecodes.c b/Python/optimizer_bytecodes.c
@@ -937,8 +937,11 @@ dummy_func(void) {
     }
 
     op(_CALL_TYPE_1, (unused, unused, arg -- res)) {
-        if (sym_has_type(arg)) {
-            res = sym_new_const(ctx, (PyObject *)sym_get_type(arg));
+        PyObject* type = (PyObject *)sym_get_type(arg);
+        if (type) {
+            res = sym_new_const(ctx, type);
+            REPLACE_OP(this_instr, _POP_CALL_ONE_LOAD_CONST_INLINE_BORROW, 0,
+                       (uintptr_t)type);
         }
         else {
             res = sym_new_not_null(ctx);
diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	+Optimize away ``_CALL_TYPE_1`` in the JIT when the return type is known.
	`2`	`+Patch by Tomas Roun`
Original file line number	Diff line number	Diff line change
`@@ -937,8 +937,11 @@ dummy_func(void) {`
`937`	`937`	`}`
`938`	`938`
`939`	`939`	`op(_CALL_TYPE_1, (unused, unused, arg -- res)) {`
`940`		`- if (sym_has_type(arg)) {`
`941`		`- res = sym_new_const(ctx, (PyObject *)sym_get_type(arg));`
	`940`	`+ PyObject* type = (PyObject *)sym_get_type(arg);`
	`941`	`+ if (type) {`
	`942`	`+ res = sym_new_const(ctx, type);`
	`943`	`+ REPLACE_OP(this_instr, _POP_CALL_ONE_LOAD_CONST_INLINE_BORROW, 0,`
	`944`	`+ (uintptr_t)type);`
`942`	`945`	`}`
`943`	`946`	`else {`
`944`	`947`	`res = sym_new_not_null(ctx);`