Merge remote-tracking branch 'upstream/main' into add_checks_tp_version

Fidget-Spinner · Fidget-Spinner · commit 66c75a2d4b94 · 2021-12-15T23:08:26.000+08:00
diff --git a/Include/opcode.h b/Include/opcode.h
diff --git a/Lib/opcode.py b/Lib/opcode.py
@@ -259,6 +259,8 @@ def jabs_op(name, op):
     "CALL_NO_KW_PY_SIMPLE",
     "CALL_NO_KW_LIST_APPEND",
     "CALL_NO_KW_METHOD_DESCRIPTOR_O",
+    "CALL_NO_KW_TYPE_1",
+    "CALL_NO_KW_BUILTIN_CLASS_1",
     "CALL_NO_KW_METHOD_DESCRIPTOR_FAST",
     "JUMP_ABSOLUTE_QUICK",
     "LOAD_ATTR_ADAPTIVE",
diff --git a/Misc/NEWS.d/next/Core and Builtins/2021-12-07-11-04-21.bpo-44525.6OWCgr.rst b/Misc/NEWS.d/next/Core and Builtins/2021-12-07-11-04-21.bpo-44525.6OWCgr.rst
@@ -0,0 +1,3 @@
+Specialize the CALL_FUNCTION instruction for calls to builtin types with a
+single argument. Speeds up ``range(x)``, ``list(x)``, and specifically
+``type(obj)``.
diff --git a/Python/ceval.c b/Python/ceval.c
@@ -4854,6 +4854,41 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, InterpreterFrame *frame, int thr
             goto start_frame;
         }
 
+        TARGET(CALL_NO_KW_TYPE_1) {
+            assert(STACK_ADJUST_IS_RESET);
+            assert(GET_CACHE()->adaptive.original_oparg == 1);
+            PyObject *obj = TOP();
+            PyObject *callable = SECOND();
+            DEOPT_IF(callable != (PyObject *)&PyType_Type, CALL_NO_KW);
+            PyObject *res = Py_NewRef(Py_TYPE(obj));
+            STACK_SHRINK(1);
+            Py_DECREF(callable);
+            Py_DECREF(obj);
+            SET_TOP(res);
+            DISPATCH();
+        }
+
+        TARGET(CALL_NO_KW_BUILTIN_CLASS_1) {
+            assert(STACK_ADJUST_IS_RESET);
+            SpecializedCacheEntry *caches = GET_CACHE();
+            _PyAdaptiveEntry *cache0 = &caches[0].adaptive;
+            assert(cache0->original_oparg == 1);
+            PyObject *callable = SECOND();
+            PyObject *arg = TOP();
+            DEOPT_IF(!PyType_Check(callable), CALL_NO_KW);
+            PyTypeObject *tp = (PyTypeObject *)callable;
+            DEOPT_IF(tp->tp_version_tag != cache0->version, CALL_NO_KW);
+            STACK_SHRINK(1);
+            PyObject *res = tp->tp_vectorcall((PyObject *)tp, stack_pointer, 1, NULL);
+            SET_TOP(res);
+            Py_DECREF(tp);
+            Py_DECREF(arg);
+            if (res == NULL) {
+                goto error;
+            }
+            DISPATCH();
+        }
+
         TARGET(CALL_NO_KW_BUILTIN_O) {
             assert(cframe.use_tracing == 0);
             assert(STACK_ADJUST_IS_RESET);
diff --git a/Python/opcode_targets.h b/Python/opcode_targets.h
diff --git a/Python/specialize.c b/Python/specialize.c
@@ -491,8 +491,10 @@ initial_counter_value(void) {
 #define SPEC_FAIL_PYCFUNCTION_NOARGS 16
 #define SPEC_FAIL_BAD_CALL_FLAGS 17
 #define SPEC_FAIL_CLASS 18
-#define SPEC_FAIL_C_METHOD_CALL 19
-#define SPEC_FAIL_METHDESCR_NON_METHOD 20
+#define SPEC_FAIL_PYTHON_CLASS 19
+#define SPEC_FAIL_C_METHOD_CALL 20
+#define SPEC_FAIL_METHDESCR_NON_METHOD 21
+#define SPEC_FAIL_METHOD_CALL_CLASS 22
 
 /* COMPARE_OP */
 #define SPEC_FAIL_STRING_COMPARE 13
@@ -1292,6 +1294,27 @@ specialize_class_call(
     PyObject *callable, _Py_CODEUNIT *instr,
     int nargs, SpecializedCacheEntry *cache)
 {
+    assert(PyType_Check(callable));
+    PyTypeObject *tp = (PyTypeObject *)callable;
+    if (_Py_OPCODE(instr[-1]) == PRECALL_METHOD) {
+        SPECIALIZATION_FAIL(CALL_NO_KW, SPEC_FAIL_METHOD_CALL_CLASS);
+        return -1;
+    }
+    if (tp->tp_new == PyBaseObject_Type.tp_new) {
+        SPECIALIZATION_FAIL(CALL_NO_KW, SPEC_FAIL_PYTHON_CLASS);
+        return -1;
+    }
+    if (nargs == 1) {
+        if (tp == &PyType_Type) {
+            *instr = _Py_MAKECODEUNIT(CALL_NO_KW_TYPE_1, _Py_OPARG(*instr));
+            return 0;
+        }
+        if ((tp->tp_flags & Py_TPFLAGS_IMMUTABLETYPE) && tp->tp_vectorcall != NULL) {
+            cache->adaptive.version = tp->tp_version_tag;
+            *instr = _Py_MAKECODEUNIT(CALL_NO_KW_BUILTIN_CLASS_1, _Py_OPARG(*instr));
+            return 0;
+        }
+    }
     SPECIALIZATION_FAIL(CALL_NO_KW, SPEC_FAIL_CLASS);
     return -1;
 }

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+Specialize the CALL_FUNCTION instruction for calls to builtin types with a`
	`2`	+single argument. Speeds up ``range(x)``, ``list(x)``, and specifically
	`3`	+``type(obj)``.