check _LOAD_GLOBAL_BUILTINS in test

Author: kumaraditya303

Lib/test/test_capi/test_opt.py

@@ -5255,7 +5255,7 @@ def g():
 
     def test_call_kw(self):
         def func(a):
-            return 42 * a
+            return int(a) * 42
 
         def testfunc(n):
             x = 0
@@ -5269,26 +5269,30 @@ def testfunc(n):
         uops = get_opnames(ex)
         self.assertIn("_PUSH_FRAME", uops)
         self.assertIn("_CHECK_FUNCTION_VERSION_KW", uops)
+        self.assertNotIn("_LOAD_GLOBAL_BUILTINS", uops)
+        self.assertIn("_CALL_BUILTIN_CLASS", uops)
 
     def test_call_kw_bound_method(self):
         class C:
-            def method(self, a):
-                return 42 * a
+            def method(self, a, b):
+                return int(a) + int(b)
 
         def testfunc(n):
             obj = C()
             x = 0
             meth = obj.method
             for _ in range(n):
-                x += meth(a=1)
+                x += meth(a=1, b=2)
             return x
 
         res, ex = self._run_with_optimizer(testfunc, TIER2_THRESHOLD)
-        self.assertEqual(res, 42 * TIER2_THRESHOLD)
+        self.assertEqual(res, 3 * TIER2_THRESHOLD)
         self.assertIsNotNone(ex)
         uops = get_opnames(ex)
         self.assertIn("_PUSH_FRAME", uops)
         self.assertIn("_CHECK_METHOD_VERSION_KW", uops)
+        self.assertNotIn("_LOAD_GLOBAL_BUILTINS", uops)
+        self.assertIn("_CALL_BUILTIN_CLASS", uops)
 
     def test_func_version_guarded_on_change(self):
         def testfunc(n):

Python/optimizer_bytecodes.c

@@ -1057,6 +1057,29 @@ dummy_func(void) {
         sym_set_type(callable, &PyMethod_Type);
     }
 
+    op(_CHECK_METHOD_VERSION_KW, (func_version/2, callable, null, unused[oparg], unused -- callable, null, unused[oparg], unused)) {
+        if (sym_is_const(ctx, callable) && sym_matches_type(callable, &PyMethod_Type)) {
+            PyMethodObject *method = (PyMethodObject *)sym_get_const(ctx, callable);
+            assert(PyMethod_Check(method));
+            ADD_OP(_CHECK_FUNCTION_VERSION_INLINE, 0, func_version);
+            uop_buffer_last(&ctx->out_buffer)->operand1 = (uintptr_t)method->im_func;
+        }
+        else {
+            // Guarding on the bound method, safe to promote.
+            PyObject *bound_method = sym_get_probable_value(callable);
+            if (bound_method != NULL && Py_TYPE(bound_method) == &PyMethod_Type) {
+                PyMethodObject *method = (PyMethodObject *)bound_method;
+                PyObject *func = method->im_func;
+                if (PyFunction_Check(func) &&
+                    ((PyFunctionObject *)func)->func_version == func_version) {
+                    _Py_BloomFilter_Add(dependencies, func);
+                    sym_set_const(callable, bound_method);
+                }
+            }
+        }
+        sym_set_type(callable, &PyMethod_Type);
+    }
+
     op(_CHECK_FUNCTION_EXACT_ARGS, (callable, self_or_null, unused[oparg] -- callable, self_or_null, unused[oparg])) {
         assert(sym_matches_type(callable, &PyFunction_Type));
         if (sym_is_const(ctx, callable)) {