fix bugs && add tests

Author: cocolato

Include/cpython/ceval.h

@@ -23,6 +23,9 @@ _PyEval_RequestCodeExtraIndex(freefunc f) {
 
 PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject *, Py_ssize_t *);
 PyAPI_FUNC(int) _PyEval_SliceIndexNotNone(PyObject *, Py_ssize_t *);
+PyAPI_FUNC(int) _PyEval_UnpackIndices(PyObject *, PyObject *,
+                                       Py_ssize_t,
+                                       Py_ssize_t *, Py_ssize_t *);
 
 
 // Trampoline API

Include/internal/pycore_uop_metadata.h

@@ -3130,6 +3130,26 @@ def testfunc(n):
         self.assertIn("_BINARY_SLICE_UNICODE", uops)
         self.assertNotIn("_BINARY_SLICE", uops)
 
+    def test_binary_slice_deopt(self):
+        def testfunc(data, n):
+            a, b = 0, 1
+            for _ in range(n):
+                x = data[a:b]
+            return x
+
+        res = testfunc([1, 2], TIER2_THRESHOLD)
+        self.assertEqual(res, [1])
+        ex = get_first_executor(testfunc)
+        self.assertIsNotNone(ex)
+        uops = get_opnames(ex)
+        self.assertIn("_BINARY_SLICE_LIST", uops)
+
+        res2 = testfunc((10, 20), TIER2_THRESHOLD)
+        self.assertEqual(res2, (10,))
+
+        res3 = testfunc("ab", TIER2_THRESHOLD)
+        self.assertEqual(res3, "a")
+
     def test_unary_invert_long_type(self):
         def testfunc(n):
             for _ in range(n):

Lib/test/test_capi/test_opt.py

@@ -881,24 +881,19 @@ dummy_func(
         }
 
         tier2 op(_UNPACK_INDICES, (container, start, stop -- container, sta, sto)) {
-            Py_ssize_t istart = 0, istop = PY_SSIZE_T_MAX;
-            int err = _PyEval_SliceIndex(PyStackRef_AsPyObjectBorrow(start), &istart);
+            Py_ssize_t istart, istop;
+            int err = _PyEval_UnpackIndices(
+                PyStackRef_AsPyObjectBorrow(start),
+                PyStackRef_AsPyObjectBorrow(stop),
+                PyObject_Length(PyStackRef_AsPyObjectBorrow(container)),
+                &istart, &istop);
             if (err == 0) {
                 ERROR_NO_POP();
             }
-            err = _PyEval_SliceIndex(PyStackRef_AsPyObjectBorrow(stop), &istop);
-            if (err == 0) {
-                ERROR_NO_POP();
-            }
-            Py_ssize_t len = PyObject_Length(PyStackRef_AsPyObjectBorrow(container));
-            if (len < 0) {
-                ERROR_NO_POP();
-            }
-            PySlice_AdjustIndices(len, &istart, &istop, 1);
-            DEOPT_IF(!PyStackRef_CanTagInt(istart));
-            DEOPT_IF(!PyStackRef_CanTagInt(istop));
             PyStackRef_CLOSE(stop);
             PyStackRef_CLOSE(start);
+            assert(PyStackRef_CanTagInt(istart));
+            assert(PyStackRef_CanTagInt(istop));
             sta = PyStackRef_TagInt((intptr_t)istart);
             sto = PyStackRef_TagInt((intptr_t)istop);
         }

Python/bytecodes.c

@@ -2915,6 +2915,26 @@ _PyEval_SliceIndexNotNone(PyObject *v, Py_ssize_t *pi)
     return 1;
 }
 
+int
+_PyEval_UnpackIndices(PyObject *start, PyObject *stop,
+                      Py_ssize_t len,
+                      Py_ssize_t *istart, Py_ssize_t *istop)
+{
+    if (len < 0) {
+        return 0;
+    }
+    *istart = 0;
+    *istop = PY_SSIZE_T_MAX;
+    if (!_PyEval_SliceIndex(start, istart)) {
+        return 0;
+    }
+    if (!_PyEval_SliceIndex(stop, istop)) {
+        return 0;
+    }
+    PySlice_AdjustIndices(len, istart, istop, 1);
+    return 1;
+}
+
 PyObject *
 _PyEval_ImportName(PyThreadState *tstate, _PyInterpreterFrame *frame,
             PyObject *name, PyObject *fromlist, PyObject *level)

Python/ceval.c

@@ -1493,21 +1493,28 @@ dummy_func(void) {
 
     op(_BINARY_SLICE, (container, start, stop -- res)) {
         // Slicing a string/list/tuple always returns the same type.
-        PyTypeObject *type = sym_get_probable_type(container);
+        PyTypeObject *known_type = sym_get_type(container);
+        PyTypeObject *type = known_type ? known_type : sym_get_probable_type(container);
         if (type == &PyList_Type) {
-            ADD_OP(_GUARD_3OS_TYPE, 0, (uintptr_t)type);
+            if (!known_type) {
+                ADD_OP(_GUARD_3OS_TYPE, 0, (uintptr_t)type);
+            }
             ADD_OP(_UNPACK_INDICES, 0, 0);
             ADD_OP(_BINARY_SLICE_LIST, 0, 0);
             res = sym_new_type(ctx, type);
         }
         else if (type == &PyTuple_Type) {
-            ADD_OP(_GUARD_3OS_TYPE, 0, (uintptr_t)type);
+            if (!known_type) {
+                ADD_OP(_GUARD_3OS_TYPE, 0, (uintptr_t)type);
+            }
             ADD_OP(_UNPACK_INDICES, 0, 0);
             ADD_OP(_BINARY_SLICE_TUPLE, 0, 0);
             res = sym_new_type(ctx, type);
         }
         else if (type == &PyUnicode_Type) {
-            ADD_OP(_GUARD_3OS_TYPE, 0, (uintptr_t)type);
+            if (!known_type) {
+                ADD_OP(_GUARD_3OS_TYPE, 0, (uintptr_t)type);
+            }
             ADD_OP(_UNPACK_INDICES, 0, 0);
             ADD_OP(_BINARY_SLICE_UNICODE, 0, 0);
             res = sym_new_type(ctx, type);
@@ -1519,8 +1526,8 @@ dummy_func(void) {
 
     op(_UNPACK_INDICES, (container, start, stop -- container, sta, sto)) {
         (void)container;
-        sta = sym_new_compact_int(ctx);
-        sto = sym_new_compact_int(ctx);
+        sta = sym_new_type(ctx, &PyLong_Type);
+        sto = sym_new_type(ctx, &PyLong_Type);
     }
 
     op(_GUARD_GLOBALS_VERSION, (version/1 --)) {