gh-99761: add invalid_index macro

Include/internal/pycore_abstract.h

@@ -8,6 +8,16 @@ extern "C" {
 #  error "this header requires Py_BUILD_CORE define"
 #endif
 
+/* Return 1 if the specified index is outside the range[0, limit) */
+#define valid_index(index, limit) ((size_t)index < (size_t)limit)
+    /* The cast to size_t lets us use just a single comparison
+        to check whether index is in the range: 0 <= index < limit.
+
+        See:  Section 14.2 "Bounds Checking" in the Agner Fog
+        optimization manual found at:
+        https://www.agner.org/optimize/optimizing_cpp.pdf
+    */
+
 // Fast inlined version of PyIndex_Check()
 static inline int
 _PyIndex_Check(PyObject *obj)

Include/internal/pycore_long.h

@@ -78,6 +78,10 @@ static inline PyObject* _PyLong_FromUnsignedChar(unsigned char i)
     return Py_NewRef((PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS+i]);
 }
 
+/* Return 1 if the argument is negative or a multi-digit int */
+#define _PyLong_Negative_or_multi_digit_int(sub) (assert(PyLong_CheckExact(sub)), \
+                    ((size_t)Py_SIZE(sub)) > 1)
+
 PyObject *_PyLong_Add(PyLongObject *left, PyLongObject *right);
 PyObject *_PyLong_Multiply(PyLongObject *left, PyLongObject *right);
 PyObject *_PyLong_Subtract(PyLongObject *left, PyLongObject *right);

Misc/NEWS.d/next/Core and Builtins/2022-11-25-09-34-57.gh-issue-99761.sRqH37.rst

@@ -0,0 +1 @@
+Add method to calculate invalid_index

Modules/arraymodule.c

@@ -9,6 +9,7 @@
 
 #define PY_SSIZE_T_CLEAN
 #include "Python.h"
+#include "pycore_abstract.h"      // valid_index
 #include "pycore_moduleobject.h"  // _PyModule_GetState()
 #include "pycore_bytesobject.h"   // _PyBytes_Repeat
 #include "structmember.h"         // PyMemberDef
@@ -804,7 +805,7 @@ array_length(arrayobject *a)
 static PyObject *
 array_item(arrayobject *a, Py_ssize_t i)
 {
-    if (i < 0 || i >= Py_SIZE(a)) {
+    if (!valid_index(i, Py_SIZE(a))) {
         PyErr_SetString(PyExc_IndexError, "array index out of range");
         return NULL;
     }
@@ -966,7 +967,7 @@ array_del_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh)
 static int
 array_ass_item(arrayobject *a, Py_ssize_t i, PyObject *v)
 {
-    if (i < 0 || i >= Py_SIZE(a)) {
+    if (!valid_index(i, Py_SIZE(a))) {
         PyErr_SetString(PyExc_IndexError,
                          "array assignment index out of range");
         return -1;
@@ -1249,7 +1250,7 @@ array_array_pop_impl(arrayobject *self, Py_ssize_t i)
     }
     if (i < 0)
         i += Py_SIZE(self);
-    if (i < 0 || i >= Py_SIZE(self)) {
+    if (!valid_index(i, Py_SIZE(self))) {
         PyErr_SetString(PyExc_IndexError, "pop index out of range");
         return NULL;
     }
@@ -2407,7 +2408,7 @@ array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value)
             return -1;
         if (i < 0)
             i += Py_SIZE(self);
-        if (i < 0 || i >= Py_SIZE(self)) {
+        if (!valid_index(i, Py_SIZE(self))) {
             PyErr_SetString(PyExc_IndexError,
                 "array assignment index out of range");
             return -1;

Modules/mmapmodule.c

@@ -24,6 +24,7 @@
 
 #define PY_SSIZE_T_CLEAN
 #include <Python.h>
+#include "pycore_abstract.h"      // valid_index
 #include "pycore_bytesobject.h"   // _PyBytes_Find()
 #include "pycore_fileutils.h"     // _Py_stat_struct
 #include "structmember.h"         // PyMemberDef
@@ -920,7 +921,7 @@ static PyObject *
 mmap_item(mmap_object *self, Py_ssize_t i)
 {
     CHECK_VALID(NULL);
-    if (i < 0 || i >= self->size) {
+    if (!valid_index(i, self->size)) {
         PyErr_SetString(PyExc_IndexError, "mmap index out of range");
         return NULL;
     }
@@ -937,7 +938,7 @@ mmap_subscript(mmap_object *self, PyObject *item)
             return NULL;
         if (i < 0)
             i += self->size;
-        if (i < 0 || i >= self->size) {
+        if (!valid_index(i, self->size)) {
             PyErr_SetString(PyExc_IndexError,
                 "mmap index out of range");
             return NULL;
@@ -988,7 +989,7 @@ mmap_ass_item(mmap_object *self, Py_ssize_t i, PyObject *v)
     const char *buf;
 
     CHECK_VALID(-1);
-    if (i < 0 || i >= self->size) {
+    if (!valid_index(i, self->size)) {
         PyErr_SetString(PyExc_IndexError, "mmap index out of range");
         return -1;
     }
@@ -1025,7 +1026,7 @@ mmap_ass_subscript(mmap_object *self, PyObject *item, PyObject *value)
             return -1;
         if (i < 0)
             i += self->size;
-        if (i < 0 || i >= self->size) {
+        if (!valid_index(i, self->size)) {
             PyErr_SetString(PyExc_IndexError,
                             "mmap index out of range");
             return -1;

Objects/bytearrayobject.c

@@ -358,7 +358,7 @@ bytearray_irepeat(PyByteArrayObject *self, Py_ssize_t count)
 static PyObject *
 bytearray_getitem(PyByteArrayObject *self, Py_ssize_t i)
 {
-    if (i < 0 || i >= Py_SIZE(self)) {
+    if (!valid_index(i, Py_SIZE(self))) {
         PyErr_SetString(PyExc_IndexError, "bytearray index out of range");
         return NULL;
     }
@@ -377,7 +377,7 @@ bytearray_subscript(PyByteArrayObject *self, PyObject *index)
         if (i < 0)
             i += PyByteArray_GET_SIZE(self);
 
-        if (i < 0 || i >= Py_SIZE(self)) {
+        if (!valid_index(i, Py_SIZE(self))) {
             PyErr_SetString(PyExc_IndexError, "bytearray index out of range");
             return NULL;
         }
@@ -572,7 +572,7 @@ bytearray_setitem(PyByteArrayObject *self, Py_ssize_t i, PyObject *value)
         i += Py_SIZE(self);
     }
 
-    if (i < 0 || i >= Py_SIZE(self)) {
+    if (!valid_index(i, Py_SIZE(self))) {
         PyErr_SetString(PyExc_IndexError, "bytearray index out of range");
         return -1;
     }
@@ -612,7 +612,7 @@ bytearray_ass_subscript(PyByteArrayObject *self, PyObject *index, PyObject *valu
             i += PyByteArray_GET_SIZE(self);
         }
 
-        if (i < 0 || i >= Py_SIZE(self)) {
+        if (!valid_index(i, Py_SIZE(self))) {
             PyErr_SetString(PyExc_IndexError, "bytearray index out of range");
             return -1;
         }
@@ -1809,7 +1809,7 @@ bytearray_pop_impl(PyByteArrayObject *self, Py_ssize_t index)
     }
     if (index < 0)
         index += Py_SIZE(self);
-    if (index < 0 || index >= Py_SIZE(self)) {
+    if (!valid_index(index, Py_SIZE(self))) {
         PyErr_SetString(PyExc_IndexError, "pop index out of range");
         return NULL;
     }

Objects/bytesobject.c

@@ -1484,7 +1484,7 @@ bytes_contains(PyObject *self, PyObject *arg)
 static PyObject *
 bytes_item(PyBytesObject *a, Py_ssize_t i)
 {
-    if (i < 0 || i >= Py_SIZE(a)) {
+    if (!valid_index(i, Py_SIZE(a))) {
         PyErr_SetString(PyExc_IndexError, "index out of range");
         return NULL;
     }
@@ -1591,7 +1591,7 @@ bytes_subscript(PyBytesObject* self, PyObject* item)
             return NULL;
         if (i < 0)
             i += PyBytes_GET_SIZE(self);
-        if (i < 0 || i >= PyBytes_GET_SIZE(self)) {
+        if (!valid_index(i, PyBytes_GET_SIZE(self))) {
             PyErr_SetString(PyExc_IndexError,
                             "index out of range");
             return NULL;

Objects/codeobject.c

@@ -3,6 +3,7 @@
 #include "Python.h"
 #include "opcode.h"
 #include "structmember.h"         // PyMemberDef
+#include "pycore_abstract.h"      // valid_index
 #include "pycore_code.h"          // _PyCodeConstructor
 #include "pycore_frame.h"         // FRAME_SPECIALS_SIZE
 #include "pycore_interp.h"        // PyInterpreterState.co_extra_freefuncs
@@ -1346,8 +1347,7 @@ _PyCode_SetExtra(PyObject *code, Py_ssize_t index, void *extra)
 {
     PyInterpreterState *interp = _PyInterpreterState_GET();
 
-    if (!PyCode_Check(code) || index < 0 ||
-            index >= interp->co_extra_user_count) {
+    if (!PyCode_Check(code) || !valid_index(index, interp->co_extra_user_count)) {
         PyErr_BadInternalCall();
         return -1;
     }

Objects/listobject.c

@@ -226,18 +226,6 @@ PyList_Size(PyObject *op)
         return Py_SIZE(op);
 }
 
-static inline int
-valid_index(Py_ssize_t i, Py_ssize_t limit)
-{
-    /* The cast to size_t lets us use just a single comparison
-       to check whether i is in the range: 0 <= i < limit.
-
-       See:  Section 14.2 "Bounds Checking" in the Agner Fog
-       optimization manual found at:
-       https://www.agner.org/optimize/optimizing_cpp.pdf
-    */
-    return (size_t) i < (size_t) limit;
-}
 
 PyObject *
 PyList_GetItem(PyObject *op, Py_ssize_t i)
@@ -2584,9 +2572,8 @@ list_index_impl(PyListObject *self, PyObject *value, Py_ssize_t start,
     }
     if (stop < 0) {
         stop += Py_SIZE(self);
-        if (stop < 0)
-            stop = 0;
     }
+
     for (i = start; i < stop && i < Py_SIZE(self); i++) {
         PyObject *obj = self->ob_item[i];
         Py_INCREF(obj);

Objects/memoryobject.c

@@ -2299,7 +2299,7 @@ lookup_dimension(const Py_buffer *view, char *ptr, int dim, Py_ssize_t index)
     if (index < 0) {
         index += nitems;
     }
-    if (index < 0 || index >= nitems) {
+    if (!valid_index(index, nitems)) {
         PyErr_Format(PyExc_IndexError,
                      "index out of bounds on dimension %d", dim + 1);
         return NULL;

Objects/tupleobject.c

@@ -100,7 +100,7 @@ PyTuple_GetItem(PyObject *op, Py_ssize_t i)
         PyErr_BadInternalCall();
         return NULL;
     }
-    if (i < 0 || i >= Py_SIZE(op)) {
+    if (!valid_index(i, Py_SIZE(op))) {
         PyErr_SetString(PyExc_IndexError, "tuple index out of range");
         return NULL;
     }
@@ -116,7 +116,7 @@ PyTuple_SetItem(PyObject *op, Py_ssize_t i, PyObject *newitem)
         PyErr_BadInternalCall();
         return -1;
     }
-    if (i < 0 || i >= Py_SIZE(op)) {
+    if (!valid_index(i, Py_SIZE(op))) {
         Py_XDECREF(newitem);
         PyErr_SetString(PyExc_IndexError,
                         "tuple assignment index out of range");
@@ -361,7 +361,7 @@ tuplecontains(PyTupleObject *a, PyObject *el)
 static PyObject *
 tupleitem(PyTupleObject *a, Py_ssize_t i)
 {
-    if (i < 0 || i >= Py_SIZE(a)) {
+    if (!valid_index(i, Py_SIZE(a))) {
         PyErr_SetString(PyExc_IndexError, "tuple index out of range");
         return NULL;
     }

Objects/unicodeobject.c

@@ -1436,11 +1436,11 @@ PyUnicode_CopyCharacters(PyObject *to, Py_ssize_t to_start,
         return -1;
     }
 
-    if ((size_t)from_start > (size_t)PyUnicode_GET_LENGTH(from)) {
+    if (!valid_index(from_start, PyUnicode_GET_LENGTH(from))) {
         PyErr_SetString(PyExc_IndexError, "string index out of range");
         return -1;
     }
-    if ((size_t)to_start > (size_t)PyUnicode_GET_LENGTH(to)) {
+    if (!valid_index(to_start, PyUnicode_GET_LENGTH(to))) {
         PyErr_SetString(PyExc_IndexError, "string index out of range");
         return -1;
     }
@@ -3721,7 +3721,7 @@ PyUnicode_ReadChar(PyObject *unicode, Py_ssize_t index)
         PyErr_BadArgument();
         return (Py_UCS4)-1;
     }
-    if (index < 0 || index >= PyUnicode_GET_LENGTH(unicode)) {
+    if (!valid_index(index, PyUnicode_GET_LENGTH(unicode))) {
         PyErr_SetString(PyExc_IndexError, "string index out of range");
         return (Py_UCS4)-1;
     }

Python/bytecodes.c

@@ -383,8 +383,7 @@ dummy_func(
             DEOPT_IF(!PyList_CheckExact(list), BINARY_SUBSCR);
 
             // Deopt unless 0 <= sub < PyList_Size(list)
-            Py_ssize_t signed_magnitude = Py_SIZE(sub);
-            DEOPT_IF(((size_t)signed_magnitude) > 1, BINARY_SUBSCR);
+            DEOPT_IF(_PyLong_Negative_or_multi_digit_int(sub), BINARY_SUBSCR);
             assert(((PyLongObject *)_PyLong_GetZero())->ob_digit[0] == 0);
             Py_ssize_t index = ((PyLongObject*)sub)->ob_digit[0];
             DEOPT_IF(index >= PyList_GET_SIZE(list), BINARY_SUBSCR);
@@ -402,8 +401,7 @@ dummy_func(
             DEOPT_IF(!PyTuple_CheckExact(tuple), BINARY_SUBSCR);
 
             // Deopt unless 0 <= sub < PyTuple_Size(list)
-            Py_ssize_t signed_magnitude = Py_SIZE(sub);
-            DEOPT_IF(((size_t)signed_magnitude) > 1, BINARY_SUBSCR);
+            DEOPT_IF(_PyLong_Negative_or_multi_digit_int(sub), BINARY_SUBSCR);
             assert(((PyLongObject *)_PyLong_GetZero())->ob_digit[0] == 0);
             Py_ssize_t index = ((PyLongObject*)sub)->ob_digit[0];
             DEOPT_IF(index >= PyTuple_GET_SIZE(tuple), BINARY_SUBSCR);
@@ -507,7 +505,7 @@ dummy_func(
             DEOPT_IF(!PyList_CheckExact(list), STORE_SUBSCR);
 
             // Ensure nonnegative, zero-or-one-digit ints.
-            DEOPT_IF(((size_t)Py_SIZE(sub)) > 1, STORE_SUBSCR);
+            DEOPT_IF(_PyLong_Negative_or_multi_digit_int(sub), STORE_SUBSCR);
             Py_ssize_t index = ((PyLongObject*)sub)->ob_digit[0];
             // Ensure index < len(list)
             DEOPT_IF(index >= PyList_GET_SIZE(list), STORE_SUBSCR);