reduce function call

Author: cocolato

Include/internal/pycore_list.h

@@ -14,6 +14,7 @@ extern "C" {
 
 PyAPI_FUNC(PyObject*) _PyList_Extend(PyListObject *, PyObject *);
 PyAPI_FUNC(PyObject) *_PyList_SliceSubscript(PyObject*, PyObject*);
+PyAPI_FUNC(PyObject *) _PyList_BinarySlice(PyObject *, PyObject *, PyObject *);
 extern void _PyList_DebugMallocStats(FILE *out);
 // _PyList_GetItemRef should be used only when the object is known as a list
 // because it doesn't raise TypeError when the object is not a list, whereas PyList_GetItemRef does.

Include/internal/pycore_tuple.h

@@ -25,6 +25,7 @@ extern PyStatus _PyTuple_InitGlobalObjects(PyInterpreterState *);
 
 PyAPI_FUNC(PyObject *)_PyTuple_FromStackRefStealOnSuccess(const union _PyStackRef *, Py_ssize_t);
 PyAPI_FUNC(PyObject *)_PyTuple_FromArraySteal(PyObject *const *, Py_ssize_t);
+PyAPI_FUNC(PyObject *) _PyTuple_BinarySlice(PyObject *, PyObject *, PyObject *);
 
 typedef struct {
     PyObject_HEAD

Include/internal/pycore_unicodeobject.h

@@ -32,6 +32,7 @@ extern PyObject* _PyUnicode_ResizeCompact(
     PyObject *unicode,
     Py_ssize_t length);
 extern PyObject* _PyUnicode_GetEmpty(void);
+PyAPI_FUNC(PyObject*) _PyUnicode_BinarySlice(PyObject *, PyObject *, PyObject *);
 
 
 /* Generic helper macro to convert characters of different types.

Modules/_testinternalcapi/test_cases.c.h

@@ -716,6 +716,30 @@ list_slice_lock_held(PyListObject *a, Py_ssize_t ilow, Py_ssize_t ihigh)
     return (PyObject *)np;
 }
 
+PyObject *
+_PyList_BinarySlice(PyObject *container, PyObject *start, PyObject *stop)
+{
+    assert(PyList_CheckExact(container));
+    Py_ssize_t istart = 0;
+    Py_ssize_t istop = PY_SSIZE_T_MAX;
+    /* Unpack the index values before acquiring the lock, since
+     * _PyEval_SliceIndex may call __index__ which could execute
+     * arbitrary Python code. */
+    if (!_PyEval_SliceIndex(start, &istart)) {
+        return NULL;
+    }
+    if (!_PyEval_SliceIndex(stop, &istop)) {
+        return NULL;
+    }
+    PyObject *ret;
+    Py_BEGIN_CRITICAL_SECTION(container);
+    Py_ssize_t len = Py_SIZE(container);
+    PySlice_AdjustIndices(len, &istart, &istop, 1);
+    ret = list_slice_lock_held((PyListObject *)container, istart, istop);
+    Py_END_CRITICAL_SECTION();
+    return ret;
+}
+
 PyObject *
 PyList_GetSlice(PyObject *a, Py_ssize_t ilow, Py_ssize_t ihigh)
 {

Objects/listobject.c

@@ -472,6 +472,25 @@ tuple_slice(PyTupleObject *a, Py_ssize_t ilow,
     return PyTuple_FromArray(a->ob_item + ilow, ihigh - ilow);
 }
 
+PyObject *
+_PyTuple_BinarySlice(PyObject *container, PyObject *start, PyObject *stop)
+{
+    assert(PyTuple_CheckExact(container));
+    Py_ssize_t len = Py_SIZE(container);
+    Py_ssize_t istart, istop;
+    if (!_PyEval_UnpackIndices(start, stop, len, &istart, &istop)) {
+        return NULL;
+    }
+    if (istart == 0 && istop == len) {
+        return Py_NewRef(container);
+    }
+    if (istop < istart) {
+        istop = istart;
+    }
+    return PyTuple_FromArray(((PyTupleObject *)container)->ob_item + istart,
+                             istop - istart);
+}
+
 PyObject *
 PyTuple_GetSlice(PyObject *op, Py_ssize_t i, Py_ssize_t j)
 {

Objects/tupleobject.c

@@ -12312,6 +12312,18 @@ _PyUnicode_XStrip(PyObject *self, int striptype, PyObject *sepobj)
     return PyUnicode_Substring(self, i, j);
 }
 
+PyObject*
+_PyUnicode_BinarySlice(PyObject *container, PyObject *start_o, PyObject *stop_o)
+{
+    assert(PyUnicode_CheckExact(container));
+    Py_ssize_t len = PyUnicode_GET_LENGTH(container);
+    Py_ssize_t istart, istop;
+    if (!_PyEval_UnpackIndices(start_o, stop_o, len, &istart, &istop)) {
+        return NULL;
+    }
+    return PyUnicode_Substring(container, istart, istop);
+}
+
 PyObject*
 PyUnicode_Substring(PyObject *self, Py_ssize_t start, Py_ssize_t end)
 {

Objects/unicodeobject.c

@@ -870,29 +870,14 @@ dummy_func(
             PyObject *start_o = PyStackRef_AsPyObjectBorrow(start);
             PyObject *stop_o = PyStackRef_AsPyObjectBorrow(stop);
             PyObject *res_o;
-            if ((PyList_CheckExact(container_o) ||
-                 PyTuple_CheckExact(container_o) ||
-                 PyUnicode_CheckExact(container_o)) &&
-                (start_o == Py_None || PyLong_CheckExact(start_o)) &&
-                (stop_o == Py_None || PyLong_CheckExact(stop_o))) {
-                Py_ssize_t len = PyUnicode_CheckExact(container_o)
-                    ? PyUnicode_GET_LENGTH(container_o)
-                    : Py_SIZE(container_o);
-                Py_ssize_t istart, istop;
-                int err = _PyEval_UnpackIndices(start_o, stop_o, len,
-                                                      &istart, &istop);
-                if (err == 0) {
-                    res_o = NULL;
-                }
-                else if (PyList_CheckExact(container_o)) {
-                    res_o = PyList_GetSlice(container_o, istart, istop);
-                }
-                else if (PyTuple_CheckExact(container_o)) {
-                    res_o = PyTuple_GetSlice(container_o, istart, istop);
-                }
-                else {
-                    res_o = PyUnicode_Substring(container_o, istart, istop);
-                }
+            if (PyList_CheckExact(container_o)) {
+                res_o = _PyList_BinarySlice(container_o, start_o, stop_o);
+            }
+            else if (PyTuple_CheckExact(container_o)) {
+                res_o = _PyTuple_BinarySlice(container_o, start_o, stop_o);
+            }
+            else if (PyUnicode_CheckExact(container_o)) {
+                res_o = _PyUnicode_BinarySlice(container_o, start_o, stop_o);
             }
             else {
                 PyObject *slice = PySlice_New(start_o, stop_o, NULL);

Python/bytecodes.c

@@ -1,6 +1,7 @@
 /* Execute compiled code */
 
 #include "ceval.h"
+#include "pycore_long.h"
 
 int
 Py_GetRecursionLimit(void)
@@ -2886,7 +2887,22 @@ _PyEval_SliceIndex(PyObject *v, Py_ssize_t *pi)
     PyThreadState *tstate = _PyThreadState_GET();
     if (!Py_IsNone(v)) {
         Py_ssize_t x;
-        if (_PyIndex_Check(v)) {
+        if (PyLong_CheckExact(v)) {
+            // Fast path for compact ints (single digit) -- most slice indices.
+            if (_PyLong_IsCompact((PyLongObject *)v)) {
+                x = _PyLong_CompactValue((PyLongObject *)v);
+            }
+            else {
+                x = PyLong_AsSsize_t(v);
+                if (x == -1 && _PyErr_Occurred(tstate)) {
+                    assert(_PyErr_ExceptionMatches(tstate, PyExc_OverflowError));
+                    _PyErr_Clear(tstate);
+                    x = _PyLong_IsNegative((PyLongObject *)v)
+                        ? PY_SSIZE_T_MIN : PY_SSIZE_T_MAX;
+                }
+            }
+        }
+        else if (_PyIndex_Check(v)) {
             x = PyNumber_AsSsize_t(v, NULL);
             if (x == -1 && _PyErr_Occurred(tstate))
                 return 0;
@@ -2907,7 +2923,21 @@ _PyEval_SliceIndexNotNone(PyObject *v, Py_ssize_t *pi)
 {
     PyThreadState *tstate = _PyThreadState_GET();
     Py_ssize_t x;
-    if (_PyIndex_Check(v)) {
+    if (PyLong_CheckExact(v)) {
+        if (_PyLong_IsCompact((PyLongObject *)v)) {
+            x = _PyLong_CompactValue((PyLongObject *)v);
+        }
+        else {
+            x = PyLong_AsSsize_t(v);
+            if (x == -1 && _PyErr_Occurred(tstate)) {
+                assert(_PyErr_ExceptionMatches(tstate, PyExc_OverflowError));
+                _PyErr_Clear(tstate);
+                x = _PyLong_IsNegative((PyLongObject *)v)
+                    ? PY_SSIZE_T_MIN : PY_SSIZE_T_MAX;
+            }
+        }
+    }
+    else if (_PyIndex_Check(v)) {
         x = PyNumber_AsSsize_t(v, NULL);
         if (x == -1 && _PyErr_Occurred(tstate))
             return 0;