Merge branch master into master-slp.

Issue python#26110: Add LOAD_METHOD/CALL_METHOD opcodes.
The outcome of this merge is not functional.

Author: Anselm Kruis

Doc/whatsnew/3.7.rst

@@ -92,6 +92,11 @@ Improved Modules
 Optimizations
 =============
 
+* Added two new opcodes: ``LOAD_METHOD`` and ``CALL_METHOD`` to avoid
+  instantiation of bound method objects for method calls, which results
+  in method calls being faster up to 20%.
+  (Contributed by Yury Selivanov and INADA Naoki in :issue:`26110`.)
+
 
 Build and C API Changes
 =======================

Include/opcode.h

@@ -126,6 +126,8 @@ extern "C" {
 #define BUILD_CONST_KEY_MAP     156
 #define BUILD_STRING            157
 #define BUILD_TUPLE_UNPACK_WITH_CALL 158
+#define LOAD_METHOD             160
+#define CALL_METHOD             161
 
 /* EXCEPT_HANDLER is a special, implicit block type which is created when
    entering an except handler. It is not an opcode but we define it here

Lib/importlib/_bootstrap_external.py

@@ -240,6 +240,7 @@ def _write_atomic(path, data, mode=0o666):
 #     Python 3.6b1  3377 (set __class__ cell from type.__new__ #23722)
 #     Python 3.6b2  3378 (add BUILD_TUPLE_UNPACK_WITH_CALL #28257)
 #     Python 3.6rc1 3379 (more thorough __class__ validation #23722)
+#     Python 3.7a0  3390 (add LOAD_METHOD and CALL_METHOD opcodes)
 #
 # MAGIC must change whenever the bytecode emitted by the compiler may no
 # longer be understood by older implementations of the eval loop (usually
@@ -248,7 +249,7 @@ def _write_atomic(path, data, mode=0o666):
 # Whenever MAGIC_NUMBER is changed, the ranges in the magic_values array
 # in PC/launcher.c must also be updated.
 
-MAGIC_NUMBER = (3379).to_bytes(2, 'little') + b'\r\n'
+MAGIC_NUMBER = (3390).to_bytes(2, 'little') + b'\r\n'
 _RAW_MAGIC_NUMBER = int.from_bytes(MAGIC_NUMBER, 'little')  # For import.c
 
 _PYCACHE = '__pycache__'

Lib/opcode.py

@@ -212,4 +212,7 @@ def jabs_op(name, op):
 def_op('BUILD_STRING', 157)
 def_op('BUILD_TUPLE_UNPACK_WITH_CALL', 158)
 
+name_op('LOAD_METHOD', 160)
+def_op('CALL_METHOD', 161)
+
 del def_op, name_op, jrel_op, jabs_op

Lib/test/test_syntax.py

@@ -207,6 +207,33 @@
 ...  # doctest: +ELLIPSIS
 () [('a000', 0), ('a001', 1), ('a002', 2), ..., ('a298', 298), ('a299', 299)]
 
+>>> class C:
+...     def meth(self, *args):
+...         return args
+>>> obj = C()
+>>> obj.meth(
+...   0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+...   20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
+...   38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
+...   56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
+...   74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
+...   92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
+...   108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
+...   122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
+...   136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
+...   150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163,
+...   164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177,
+...   178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
+...   192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
+...   206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
+...   220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,
+...   234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247,
+...   248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261,
+...   262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275,
+...   276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289,
+...   290, 291, 292, 293, 294, 295, 296, 297, 298, 299)  # doctest: +ELLIPSIS
+(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ..., 297, 298, 299)
+
 >>> f(lambda x: x[0] = 3)
 Traceback (most recent call last):
 SyntaxError: lambda cannot contain assignment

Misc/NEWS

@@ -174,6 +174,9 @@ Core and Builtins
 - Issue #28721: Fix asynchronous generators aclose() and athrow() to
   handle StopAsyncIteration propagation properly.
 
+- Issue #26110: Speed-up method calls: add LOAD_METHOD and CALL_METHOD
+  opcodes.
+
 Library
 -------
 

Objects/object.c

@@ -1028,11 +1028,99 @@ _PyObject_NextNotImplemented(PyObject *self)
     return NULL;
 }
 
-/* Generic GetAttr functions - put these in your tp_[gs]etattro slot */
+
+/* Specialized version of _PyObject_GenericGetAttrWithDict
+   specifically for the LOAD_METHOD opcode.
+
+   Return 1 if a method is found, 0 if it's a regular attribute
+   from __dict__ or something returned by using a descriptor
+   protocol.
+
+   `method` will point to the resolved attribute or NULL.  In the
+   latter case, an error will be set.
+*/
+int
+_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method)
+{
+    PyTypeObject *tp = Py_TYPE(obj);
+    PyObject *descr;
+    descrgetfunc f = NULL;
+    PyObject **dictptr, *dict;
+    PyObject *attr;
+    int meth_found = 0;
+
+    assert(*method == NULL);
+
+    if (Py_TYPE(obj)->tp_getattro != PyObject_GenericGetAttr
+            || !PyUnicode_Check(name)) {
+        *method = PyObject_GetAttr(obj, name);
+        return 0;
+    }
+
+    if (tp->tp_dict == NULL && PyType_Ready(tp) < 0)
+        return 0;
+
+    descr = _PyType_Lookup(tp, name);
+    if (descr != NULL) {
+        Py_INCREF(descr);
+        if (PyFunction_Check(descr)) {
+            /* A python method. */
+            meth_found = 1;
+        } else {
+            f = descr->ob_type->tp_descr_get;
+            if (f != NULL && PyDescr_IsData(descr)) {
+                *method = f(descr, obj, (PyObject *)obj->ob_type);
+                Py_DECREF(descr);
+                return 0;
+            }
+        }
+    }
+
+    dictptr = _PyObject_GetDictPtr(obj);
+    if (dictptr != NULL && (dict = *dictptr) != NULL) {
+        Py_INCREF(dict);
+        attr = PyDict_GetItem(dict, name);
+        if (attr != NULL) {
+            Py_INCREF(attr);
+            *method = attr;
+            Py_DECREF(dict);
+            Py_XDECREF(descr);
+            return 0;
+        }
+        Py_DECREF(dict);
+    }
+
+    if (meth_found) {
+        *method = descr;
+        return 1;
+    }
+
+    if (f != NULL) {
+        *method = f(descr, obj, (PyObject *)Py_TYPE(obj));
+        Py_DECREF(descr);
+        return 0;
+    }
+
+    if (descr != NULL) {
+        *method = descr;
+        return 0;
+    }
+
+    PyErr_Format(PyExc_AttributeError,
+                 "'%.50s' object has no attribute '%U'",
+                 tp->tp_name, name);
+    return 0;
+}
+
+/* Generic GetAttr functions - put these in your tp_[gs]etattro slot. */
 
 PyObject *
 _PyObject_GenericGetAttrWithDict(PyObject *obj, PyObject *name, PyObject *dict)
 {
+    /* Make sure the logic of _PyObject_GetMethod is in sync with
+       this method.
+    */
+
     PyTypeObject *tp = Py_TYPE(obj);
     PyObject *descr = NULL;
     PyObject *res = NULL;

PC/launcher.c

@@ -1090,6 +1090,7 @@ static PYC_MAGIC magic_values[] = {
     { 3250, 3310, L"3.4" },
     { 3320, 3351, L"3.5" },
     { 3360, 3379, L"3.6" },
+    { 3390, 3399, L"3.7" },
     { 0 }
 };
 

Python/ceval.c

@@ -32,6 +32,9 @@
 #define CHECKEXC 1      /* Double-check exception checking */
 #endif
 
+/* Private API for the LOAD_METHOD opcode. */
+extern int _PyObject_GetMethod(PyObject *, PyObject *, PyObject **);
+
 typedef PyObject *(*callproc)(PyObject *, PyObject *, PyObject *);
 
 /* Forward declarations */
@@ -3419,6 +3422,100 @@ _PyEval_EvalFrameDefault(PyFrameObject *f, int throwflag)
             DISPATCH();
         }
 
+        TARGET(LOAD_METHOD) {
+            /* Designed to work in tamdem with CALL_METHOD. */
+            PyObject *name = GETITEM(names, oparg);
+            PyObject *obj = TOP();
+            PyObject *meth = NULL;
+
+            int meth_found = _PyObject_GetMethod(obj, name, &meth);
+
+            SET_TOP(meth);  /* Replace `obj` on top; OK if NULL. */
+            if (meth == NULL) {
+                /* Most likely attribute wasn't found. */
+                Py_DECREF(obj);
+                goto error;
+            }
+
+            if (meth_found) {
+                /* The method object is now on top of the stack.
+                   Push `obj` back to the stack, so that the stack
+                   layout would be:
+
+                       method | obj | arg1 | ... | argN
+                */
+                PUSH(obj);
+            }
+            else {
+                /* Not a method (but a regular attr, or something
+                   was returned by a descriptor protocol).  Push
+                   NULL to the top of the stack, to signal
+                   CALL_METHOD that it's not a method call.
+                */
+                Py_DECREF(obj);
+                PUSH(NULL);
+            }
+            DISPATCH();
+        }
+
+        TARGET(CALL_METHOD) {
+            /* Designed to work in tamdem with LOAD_METHOD. */
+            PyObject **sp, *res, *obj;
+
+            sp = stack_pointer;
+
+            obj = PEEK(oparg + 1);
+            if (obj == NULL) {
+                /* `obj` is NULL when LOAD_METHOD thinks that it's not
+                   a method call.  Swap the NULL and callable.
+
+                   Stack layout:
+
+                       ... | callable | NULL | arg1 | ... | argN
+                                                           ^- TOP()
+                                              ^- (-oparg)
+                                       ^- (-oparg-1)
+                              ^- (-oparg-2)
+
+                   after the next line it will be:
+
+                       ... | callable | callable | arg1 | ... | argN
+                                                                ^- TOP()
+                                                   ^- (-oparg)
+                                        ^- (-oparg-1)
+                              ^- (-oparg-2)
+
+                   Right side `callable` will be POPed by call_funtion.
+                   Left side `callable` will be POPed manually later
+                   (one of "callbale" refs on the stack is borrowed.)
+                */
+                SET_VALUE(oparg + 1, PEEK(oparg + 2));
+                res = call_function(&sp, oparg, NULL);
+                stack_pointer = sp;
+                (void)POP(); /* POP the left side callable. */
+            }
+            else {
+                /* This is a method call.  Stack layout:
+
+                     ... | method | obj | arg1 | ... | argN
+                                                        ^- TOP()
+                                           ^- (-oparg)
+                                     ^- (-oparg-1)
+
+                  `obj` and `method` will be POPed by call_function.
+                  We'll be passing `oparg + 1` to call_function, to
+                  make it accept the `obj` as a first argument.
+                */
+                res = call_function(&sp, oparg + 1, NULL);
+                stack_pointer = sp;
+            }
+
+            PUSH(res);
+            if (res == NULL)
+                goto error;
+            DISPATCH();
+        }
+
         PREDICTED(CALL_FUNCTION);
         TARGET(CALL_FUNCTION) {
             PyObject **sp, *res;

Python/compile.c

@@ -1040,6 +1040,8 @@ PyCompile_OpcodeStackEffect(int opcode, int oparg)
             return -oparg;
         case CALL_FUNCTION:
             return -oparg;
+        case CALL_METHOD:
+            return -oparg-1;
         case CALL_FUNCTION_KW:
             return -oparg-1;
         case CALL_FUNCTION_EX:
@@ -1078,6 +1080,8 @@ PyCompile_OpcodeStackEffect(int opcode, int oparg)
             /* If there's a fmt_spec on the stack, we go from 2->1,
                else 1->1. */
             return (oparg & FVS_MASK) == FVS_HAVE_SPEC ? -1 : 0;
+        case LOAD_METHOD:
+            return 1;
         default:
             return PY_INVALID_STACK_EFFECT;
     }
@@ -3399,9 +3403,42 @@ compiler_compare(struct compiler *c, expr_ty e)
     return 1;
 }
 
+static int
+maybe_optimize_method_call(struct compiler *c, expr_ty e)
+{
+    Py_ssize_t argsl, i;
+    expr_ty meth = e->v.Call.func;
+    asdl_seq *args = e->v.Call.args;
+
+    /* Check that the call node is an attribute access, and that
+       the call doesn't have keyword parameters. */
+    if (meth->kind != Attribute_kind || meth->v.Attribute.ctx != Load ||
+            asdl_seq_LEN(e->v.Call.keywords))
+        return -1;
+
+    /* Check that there are no *varargs types of arguments. */
+    argsl = asdl_seq_LEN(args);
+    for (i = 0; i < argsl; i++) {
+        expr_ty elt = asdl_seq_GET(args, i);
+        if (elt->kind == Starred_kind) {
+            return -1;
+        }
+    }
+
+    /* Alright, we can optimize the code. */
+    VISIT(c, expr, meth->v.Attribute.value);
+    ADDOP_NAME(c, LOAD_METHOD, meth->v.Attribute.attr, names);
+    VISIT_SEQ(c, expr, e->v.Call.args);
+    ADDOP_I(c, CALL_METHOD, asdl_seq_LEN(e->v.Call.args));
+    return 1;
+}
+
 static int
 compiler_call(struct compiler *c, expr_ty e)
 {
+    if (maybe_optimize_method_call(c, e) > 0)
+        return 1;
+
     VISIT(c, expr, e->v.Call.func);
     return compiler_call_helper(c, 0,
                                 e->v.Call.args,