python
diff --git a/Include/internal/pycore_code.h b/Include/internal/pycore_code.h
@@ -263,6 +263,9 @@ cache_backoff(_PyAdaptiveEntry *entry) {
     entry->counter = ADAPTIVE_CACHE_BACKOFF;
 }
 
+/* _interpreter_frame is defined in pycore_frame.h */
+typedef struct _interpreter_frame InterpreterFrame;
+
 /* Specialization functions */
 
 int _Py_Specialize_LoadAttr(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name, SpecializedCacheEntry *cache);
@@ -272,7 +275,8 @@ int _Py_Specialize_LoadMethod(PyObject *owner, _Py_CODEUNIT *instr, PyObject *na
 int _Py_Specialize_BinarySubscr(PyObject *sub, PyObject *container, _Py_CODEUNIT *instr, SpecializedCacheEntry *cache);
 int _Py_Specialize_StoreSubscr(PyObject *container, PyObject *sub, _Py_CODEUNIT *instr);
 int _Py_Specialize_CallNoKw(PyObject *callable, _Py_CODEUNIT *instr, int nargs,
-    PyObject *kwnames, SpecializedCacheEntry *cache, PyObject *builtins);
+     PyObject *kwnames, SpecializedCacheEntry *cache, PyObject *builtins,
+    PyObject **stack_pointer, InterpreterFrame *frame, PyObject *names);
-     PyObject *kwnames, SpecializedCacheEntry *cache, PyObject *builtins,
-    PyObject **stack_pointer, InterpreterFrame *frame, PyObject *names);
+    PyObject *kwnames, SpecializedCacheEntry *cache, PyObject *builtins,
+    PyObject **stack_pointer, InterpreterFrame *frame, PyObject *names);
-     PyObject *kwnames, SpecializedCacheEntry *cache, PyObject *builtins,
-    PyObject **stack_pointer, InterpreterFrame *frame, PyObject *names);
+                                              PyObject *kwnames, SpecializedCacheEntry *cache, PyObject *builtins,
+                                              PyObject **stack_pointer, InterpreterFrame *frame, PyObject *names);
-     PyObject *kwnames, SpecializedCacheEntry *cache, PyObject *builtins,
-    PyObject **stack_pointer, InterpreterFrame *frame, PyObject *names);
+    PyObject *kwnames, SpecializedCacheEntry *cache, PyObject *builtins,
+    PyObject **stack_pointer, InterpreterFrame *frame, PyObject *names);
-     PyObject *kwnames, SpecializedCacheEntry *cache, PyObject *builtins,
-    PyObject **stack_pointer, InterpreterFrame *frame, PyObject *names);
+                                              PyObject *kwnames, SpecializedCacheEntry *cache, PyObject *builtins,
+                                              PyObject **stack_pointer, InterpreterFrame *frame, PyObject *names);
 void _Py_Specialize_BinaryOp(PyObject *lhs, PyObject *rhs, _Py_CODEUNIT *instr,
                              SpecializedCacheEntry *cache);
 void _Py_Specialize_CompareOp(PyObject *lhs, PyObject *rhs, _Py_CODEUNIT *instr, SpecializedCacheEntry *cache);

diff --git a/Include/internal/pycore_typeobject.h b/Include/internal/pycore_typeobject.h
@@ -43,6 +43,11 @@ extern PyStatus _PyTypes_InitSlotDefs(void);
 
 extern void _PyStaticType_Dealloc(PyTypeObject *type);
 
+/* _interpreter_frame is defined in pycore_frame.h */
+typedef struct _interpreter_frame InterpreterFrame;
+
+PyObject *_PySuper_Lookup(PyTypeObject *, PyObject *, PyObject *, int *);
+int _PySuper_GetTypeArgs(InterpreterFrame *, PyCodeObject *, PyTypeObject **, PyObject **);
 
 #ifdef __cplusplus
 }

diff --git a/Include/opcode.h b/Include/opcode.h
diff --git a/Lib/opcode.py b/Lib/opcode.py
@@ -288,6 +288,9 @@ def jabs_op(name, op):
     "LOAD_FAST__LOAD_CONST",
     "LOAD_CONST__LOAD_FAST",
     "STORE_FAST__STORE_FAST",
+    # Specialized super instructions.
+    "CALL_NO_KW_SUPER_0__LOAD_METHOD_CACHED",
+    "CALL_NO_KW_SUPER_2__LOAD_METHOD_CACHED",
 ]
 _specialization_stats = [
     "success",

diff --git a/Misc/NEWS.d/next/Core and Builtins/2022-01-29-00-44-09.bpo-46564.MwLSHf.rst b/Misc/NEWS.d/next/Core and Builtins/2022-01-29-00-44-09.bpo-46564.MwLSHf.rst
@@ -0,0 +1,5 @@
+Method calls on :class:`super` are sped up. The 2-argument form,
+``super(type, obj).meth()`` is now nearly as fast as an equivalent
+``self.meth()`` call. The 0-argument form, while still slower, is still
+faster than in previous versions of CPython. Patch by Ken Jin, with
+additional contributions by Vladimir Matveev.
@@ -8846,16 +8846,18 @@ super_repr(PyObject *self)
             "<super: <class '%s'>, NULL>",
             su->type ? su->type->tp_name : "NULL");
 }
+/* Forward */
+static PyTypeObject *supercheck(PyTypeObject *type, PyObject *obj);
 
 static PyObject *
-super_getattro(PyObject *self, PyObject *name)
+do_super_lookup(superobject *su, PyTypeObject *su_type, PyObject *su_obj,
+                PyTypeObject *su_obj_type, PyObject *name, int *meth_found)
 {
-    superobject *su = (superobject *)self;
     PyTypeObject *starttype;
     PyObject *mro;
     Py_ssize_t i, n;
 
-    starttype = su->obj_type;
+    starttype = su_obj_type;
     if (starttype == NULL)
         goto skip;
 
@@ -8875,7 +8877,7 @@ super_getattro(PyObject *self, PyObject *name)
 
     /* No need to check the last one: it's gonna be skipped anyway.  */
     for (i = 0; i+1 < n; i++) {
-        if ((PyObject *)(su->type) == PyTuple_GET_ITEM(mro, i))
+        if ((PyObject *)(su_type) == PyTuple_GET_ITEM(mro, i))
             break;
     }
     i++;  /* skip su->type (if any)  */
@@ -8893,17 +8895,25 @@ super_getattro(PyObject *self, PyObject *name)
         PyObject *res = PyDict_GetItemWithError(dict, name);
         if (res != NULL) {
             Py_INCREF(res);
-
-            descrgetfunc f = Py_TYPE(res)->tp_descr_get;
-            if (f != NULL) {
-                PyObject *res2;
-                res2 = f(res,
-                    /* Only pass 'obj' param if this is instance-mode super
-                       (See SF ID #743627)  */
-                    (su->obj == (PyObject *)starttype) ? NULL : su->obj,
-                    (PyObject *)starttype);
-                Py_DECREF(res);
-                res = res2;
+            if (meth_found &&
+                _PyType_HasFeature(Py_TYPE(res), Py_TPFLAGS_METHOD_DESCRIPTOR)) {
+                *meth_found = 1;
+            }
+            else {
+                if (meth_found) {
+                    *meth_found = 0;
+                }
+                descrgetfunc f = Py_TYPE(res)->tp_descr_get;
+                if (f != NULL) {
+                    PyObject *res2;
+                    res2 = f(res,
+                            /* Only pass 'obj' param if this is instance-mode super
+                            (See SF ID #743627)  */
+                            (su_obj == (PyObject *)starttype) ? NULL : su_obj,
+                            (PyObject *)starttype);
+                    Py_DECREF(res);
+                    res = res2;
+                }
             }
 
             Py_DECREF(mro);
@@ -8919,7 +8929,31 @@ super_getattro(PyObject *self, PyObject *name)
     Py_DECREF(mro);
 
   skip:
-    return PyObject_GenericGetAttr(self, name);
+    /* only happens when using manual _PySuper_Lookup, never happens in super_getattro */
+    if (su == NULL) {
+        PyErr_BadInternalCall();
+        return NULL;
+    }
+    return PyObject_GenericGetAttr((PyObject *)su, name);
+}
+
+static PyObject *
+super_getattro(PyObject *self, PyObject *name)
+{
+    superobject *su = (superobject *)self;
+    return do_super_lookup(su, su->type, su->obj, su->obj_type, name, NULL);
+}
+
+PyObject *
+_PySuper_Lookup(PyTypeObject *su_type, PyObject *su_obj, PyObject *name, int *meth_found)
+{
+    PyTypeObject *starttype = supercheck(su_type, su_obj);
+    if (starttype == NULL) {
+        return NULL;
+    }
+    PyObject *res = do_super_lookup(NULL, su_type, su_obj, starttype, name, meth_found);
+    Py_DECREF(starttype);
+    return res;
 }
 
 static PyTypeObject *
@@ -9011,8 +9045,8 @@ super_descr_get(PyObject *self, PyObject *obj, PyObject *type)
     }
 }
 
-static int
-super_init_without_args(InterpreterFrame *cframe, PyCodeObject *co,
+int
+_PySuper_GetTypeArgs(InterpreterFrame *cframe, PyCodeObject *co,
                         PyTypeObject **type_p, PyObject **obj_p)
-                        PyTypeObject **type_p, PyObject **obj_p)
+                     PyTypeObject **type_p, PyObject **obj_p)
-                        PyTypeObject **type_p, PyObject **obj_p)
+                     PyTypeObject **type_p, PyObject **obj_p)
 {
     if (co->co_argcount == 0) {
@@ -9102,7 +9136,8 @@ super_init(PyObject *self, PyObject *args, PyObject *kwds)
                             "super(): no current frame");
             return -1;
         }
-        int res = super_init_without_args(cframe, cframe->f_code, &type, &obj);
+
+        int res = _PySuper_GetTypeArgs(cframe, cframe->f_code, &type, &obj);
 
         if (res < 0) {
             return -1;

@@ -1361,6 +1361,7 @@ eval_frame_handle_pending(PyThreadState *tstate)
 
 /* The integer overflow is checked by an assertion below. */
 #define INSTR_OFFSET() ((int)(next_instr - first_instr))
+#define NEXT_INSTR_OFFSET() ((int)(next_instr+1 - first_instr))
 #define NEXTOPARG()  do { \
         _Py_CODEUNIT word = *next_instr; \
         opcode = _Py_OPCODE(word); \
@@ -1486,6 +1487,9 @@ eval_frame_handle_pending(PyThreadState *tstate)
 #define GET_CACHE() \
     _GetSpecializedCacheEntryForInstruction(first_instr, INSTR_OFFSET(), oparg)
 
+# define GET_NEXT_INSTR_CACHE() \
+    _GetSpecializedCacheEntryForInstruction(first_instr, NEXT_INSTR_OFFSET(), \
+    _Py_OPARG(*next_instr))
 
 #define DEOPT_IF(cond, instname) if (cond) { goto instname ## _miss; }
 
@@ -4633,7 +4637,8 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, InterpreterFrame *frame, int thr
                 int nargs = call_shape.total_args;
                 int err = _Py_Specialize_CallNoKw(
                     call_shape.callable, next_instr, nargs,
-                    call_shape.kwnames, cache, BUILTINS());
+                    call_shape.kwnames, cache, BUILTINS(),
+                    stack_pointer, frame, names);
                 if (err < 0) {
                     goto error;
                 }
@@ -5070,6 +5075,86 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, InterpreterFrame *frame, int thr
             DISPATCH();
         }
 
+        TARGET(CALL_NO_KW_SUPER_0__LOAD_METHOD_CACHED) {
+            /* super().meth */
+            assert(_Py_OPCODE(next_instr[0]) == LOAD_METHOD_ADAPTIVE);
+            assert(_Py_OPCODE(next_instr[-2]) != PRECALL_METHOD);
+            SpecializedCacheEntry *caches = GET_CACHE();
+            _PyAdaptiveEntry *cache0 = &caches[0].adaptive;
+            _PyObjectCache *cache1 = &caches[-1].obj;
+            _PyAdaptiveEntry *lm_adaptive = &caches[-2].adaptive;
+            assert(lm_adaptive == &GET_NEXT_INSTR_CACHE()[0].adaptive);
+            assert(call_shape.total_args == 0);
+
+            /* CALL_NO_KW_SUPER */
+            PyObject *su_obj;
+            PyTypeObject *su_type;
+            PyObject *meth;
+            PyObject *super_callable = TOP();
+
+            DEOPT_IF(_PyType_CAST(super_callable) != &PySuper_Type, CALL);
+            /* super() - zero argument form */
+            if (_PySuper_GetTypeArgs(frame, frame->f_code, &su_type, &su_obj) < 0) {
+                PyErr_Clear();
+                DEOPT_IF(1, CALL);
+            }
+            assert(su_obj != NULL);
+            DEOPT_IF(lm_adaptive->version != Py_TYPE(su_obj)->tp_version_tag, CALL);
+            DEOPT_IF(cache0->version != su_type->tp_version_tag, CALL);
+            STAT_INC(CALL, hit);
+
+            /* LOAD_METHOD_CACHED */
+            meth = cache1->obj;
+            assert(meth != NULL && _PyType_HasFeature(Py_TYPE(meth), Py_TPFLAGS_METHOD_DESCRIPTOR));
+            Py_INCREF(meth);
+            SET_TOP(meth);
+            Py_INCREF(su_obj);
+            PUSH(su_obj);
+
+            Py_DECREF(super_callable);
+            next_instr++;
+            DISPATCH();
+        }
+
+        TARGET(CALL_NO_KW_SUPER_2__LOAD_METHOD_CACHED) {
+            /* super(type, obj).meth */
+            assert(_Py_OPCODE(next_instr[0]) == LOAD_METHOD_ADAPTIVE);
+            assert(_Py_OPCODE(next_instr[-2]) != PRECALL_METHOD);
+            SpecializedCacheEntry *caches = GET_CACHE();
+            _PyAdaptiveEntry *cache0 = &caches[0].adaptive;
+            _PyObjectCache *cache1 = &caches[-1].obj;
+            _PyAdaptiveEntry *lm_adaptive = &caches[-2].adaptive;
+            assert(lm_adaptive == &GET_NEXT_INSTR_CACHE()[0].adaptive);
+            assert(call_shape.total_args == 2);
+            assert(call_shape.kwnames == NULL);
+
+            /* CALL_NO_KW_SUPER */
+            /* super(type, obj) - two argument form */
+            PyObject *su_obj = TOP();
+            PyTypeObject *su_type = _PyType_CAST(SECOND());
+            PyObject *super_callable = THIRD();
+            PyObject *meth;
+
+            DEOPT_IF(_PyType_CAST(super_callable) != &PySuper_Type, CALL);
+            assert(su_obj != NULL);
+            DEOPT_IF(lm_adaptive->version != Py_TYPE(su_obj)->tp_version_tag, CALL);
+            DEOPT_IF(cache0->version != su_type->tp_version_tag, CALL);
+            STAT_INC(CALL, hit);
+
+            (void)(POP());
+            /* LOAD_METHOD_CACHED */
+            meth = cache1->obj;
+            assert(meth != NULL && _PyType_HasFeature(Py_TYPE(meth), Py_TPFLAGS_METHOD_DESCRIPTOR));
+            Py_INCREF(meth);
+            SET_SECOND(meth);
+            SET_TOP(su_obj);
+
+            Py_DECREF(super_callable);
+            Py_DECREF(su_type);
+            next_instr++;
+            DISPATCH();
+        }
+
         TARGET(CALL_FUNCTION_EX) {
             PREDICTED(CALL_FUNCTION_EX);
             PyObject *func, *callargs, *kwargs = NULL, *result;

diff --git a/Python/opcode_targets.h b/Python/opcode_targets.h