fix logic

Author: picnixz

Lib/test/support/__init__.py

@@ -901,6 +901,21 @@ def check_sizeof(test, o, size):
             % (type(o), result, size)
     test.assertEqual(result, size, msg)
 
+
+def get_frame_specials_size():
+    """Compute the C defined constant FRAME_SPECIALS_SIZE in codeobject.c."""
+    try:
+        import _testinternalcapi
+    except ImportError:
+        raise unittest.SkipTest("_testinternalcapi required")
+
+    c = (lambda: ...).__code__
+    # co_framesize = co_stacksize + co_nlocalsplus + FRAME_SPECIALS_SIZE
+    co_framesize = _testinternalcapi.get_co_framesize(c)
+    co_nlocalsplus = len({*c.co_varnames, *c.co_cellvars, *c.co_freevars})
+    return co_framesize - c.co_stacksize - co_nlocalsplus
+
+
 #=======================================================================
 # Decorator/context manager for running a code in a different locale,
 # correctly resetting it afterwards.

Lib/test/test_code.py

@@ -535,6 +535,7 @@ def test_code_equal_with_instrumentation(self):
         self.assertNotEqual(code1, code2)
         sys.settrace(None)
 
+    @unittest.skipUnless(ctypes, "requires ctypes")
     @unittest.skipUnless(_testcapi, "requires _testcapi")
     @unittest.skipUnless(_testinternalcapi, "requires _testinternalcapi")
     def test_co_framesize_overflow(self):
@@ -545,28 +546,17 @@ def foo(a, b):
             return x
 
         c = foo.__code__
-        co_nlocalsplus = len({*c.co_varnames, *c.co_cellvars, *c.co_freevars})
-        # co_framesize = co_stacksize + co_nlocalsplus + FRAME_SPECIALS_SIZE
-        co_framesize = _testinternalcapi.get_co_framesize(c)
-        FRAME_SPECIALS_SIZE = co_framesize - c.co_stacksize - co_nlocalsplus
 
+        fss = support.get_frame_specials_size()
         ps = ctypes.sizeof(ctypes.c_void_p)  # sizeof(PyObject *)
-        smallest_evil_co_stacksize = (
-            (_testcapi.INT_MAX - co_nlocalsplus - FRAME_SPECIALS_SIZE) // ps
-        )
+        co_nlocalsplus = len({*c.co_varnames, *c.co_cellvars, *c.co_freevars})
+        # anything below that limit is a valid co_stacksize
+        evil_stacksize = int(_testcapi.INT_MAX / ps - fss - co_nlocalsplus)
+        self.assertLessEqual(evil_stacksize, _testcapi.INT_MAX // ps)
 
-        for evil_co_stacksize in [
-            _testcapi.INT_MAX,
-            _testcapi.INT_MAX // ps,
-            smallest_evil_co_stacksize,
-        ]:
-            with (
-                self.subTest(evil_co_stacksize),
-                self.assertRaisesRegex(OverflowError, "co_stacksize")
-            ):
-                c.__replace__(co_stacksize=evil_co_stacksize)
-
-        c.__replace__(co_stacksize=smallest_evil_co_stacksize - 1)
+        with self.assertRaisesRegex(OverflowError, "co_stacksize"):
+            c.__replace__(co_stacksize=evil_stacksize)
+        c.__replace__(co_stacksize=evil_stacksize - 1)
 
 
 def isinterned(s):

Lib/test/test_frame.py

@@ -225,11 +225,20 @@ def test_f_lineno_del_segfault(self):
     @unittest.skipUnless(_testcapi, "requires _testcapi")
     def test_sizeof_overflow(self):
         # See: https://github.com/python/cpython/issues/126119
-        evil_co_stacksize = _testcapi.INT_MAX // support.calcobjsize('P')
+        ctypes = import_helper.import_module('ctypes')
+
         f, _, _ = self.make_frames()
-        evil_code = f.f_code.replace(co_stacksize=evil_co_stacksize)
+        c = f.f_code
+        co_nlocalsplus = len({*c.co_varnames, *c.co_cellvars, *c.co_freevars})
+
+        fss = support.get_frame_specials_size()
+        ps = ctypes.sizeof(ctypes.c_void_p)  # sizeof(PyObject *)
+        evil_stacksize = int(_testcapi.INT_MAX / ps - fss - co_nlocalsplus)
+        # an evil code with a valid (but very large) stack size
+        evil_code = f.f_code.replace(co_stacksize=evil_stacksize - 1)
         frame = _testcapi.frame_new(evil_code, globals(), locals())
-        self.assertGreaterEqual(frame.__sizeof__(), evil_co_stacksize)
+        message = re.escape("size exceeds INT_MAX")
+        self.assertRaisesRegex(OverflowError, message, frame.__sizeof__)
 
 
 class ReprTest(unittest.TestCase):

Lib/test/test_generators.py

@@ -11,6 +11,7 @@
 import types
 
 from test import support
+from test.support import import_helper
 
 try:
     import _testcapi
@@ -269,16 +270,24 @@ def loop():
         #This should not raise
         loop()
 
-    @unittest.skipUnless(_testcapi, "requires _testcapi.INT_MAX")
+    @unittest.skipUnless(_testcapi, "requires _testcapi")
     def test_gi_frame_f_code_overflow(self):
         # See: https://github.com/python/cpython/issues/126119
+        ctypes = import_helper.import_module('ctypes')
 
         def f(): yield
+        c = f().gi_frame.f_code
+        co_nlocalsplus = len({*c.co_varnames, *c.co_cellvars, *c.co_freevars})
 
-        evil_co_stacksize = _testcapi.INT_MAX // support.calcobjsize("P")
-        evil = f().gi_frame.f_code.__replace__(co_stacksize=evil_co_stacksize)
+        ps = ctypes.sizeof(ctypes.c_void_p)  # sizeof(PyObject *)
+        fss = support.get_frame_specials_size()
+        # anything below that limit is a valid co_stacksize
+        evil_stacksize = int(_testcapi.INT_MAX / ps - fss - co_nlocalsplus)
+
+        evil = c.__replace__(co_stacksize=evil_stacksize - 1)
         evil_gi = types.FunctionType(evil, {})()
-        self.assertGreaterEqual(evil_gi.__sizeof__(), evil_co_stacksize)
+        message = re.escape("size exceeds INT_MAX")
+        self.assertRaisesRegex(OverflowError, message, evil_gi.__sizeof__)
 
 
 class ModifyUnderlyingIterableTest(unittest.TestCase):

Objects/codeobject.c

@@ -437,17 +437,16 @@ _PyCode_Validate(struct _PyCodeConstructor *con)
         return -1;
     }
     /*
-     * Ensure that the framesize will not overflow.
+     * The framesize = stacksize + nlocalsplus + FRAME_SPECIALS_SIZE is used
+     * as framesize * sizeof(PyObject *) and assumed to be < INT_MAX. Thus,
+     * we need to dynamically limit the value of stacksize.
      *
-     * There are various places in the code where the size of the object
-     * is assumed to be at most INT_MAX / sizeof(PyObject *). Since this
-     * size is the framesize, we need to guarantee that there will not
-     * be an overflow on "framesize * sizeof(PyObject *) + CONSTANT".
+     * See https://github.com/python/cpython/issues/126119 for details.
      */
-    int nlocalsplus = PyTuple_GET_SIZE(con->localsplusnames);
-    if ((size_t)con->stacksize
-        >= (INT_MAX - FRAME_SPECIALS_SIZE - nlocalsplus) / sizeof(PyObject *))
-    {
+    int max_stacksize = (int)(INT_MAX / sizeof(PyObject *))
+                        - FRAME_SPECIALS_SIZE
+                        - PyTuple_GET_SIZE(con->localsplusnames);
+    if (con->stacksize >= max_stacksize) {
         PyErr_SetString(PyExc_OverflowError, "code: co_stacksize is too large");
         return -1;
     }

Objects/frameobject.c

@@ -1804,17 +1804,24 @@ PyDoc_STRVAR(clear__doc__,
 static PyObject *
 frame_sizeof(PyFrameObject *f, PyObject *Py_UNUSED(ignored))
 {
-    Py_ssize_t res = offsetof(PyFrameObject, _f_frame_data)
-                     + offsetof(_PyInterpreterFrame, localsplus);
+    Py_ssize_t base = offsetof(PyFrameObject, _f_frame_data)
+                      + offsetof(_PyInterpreterFrame, localsplus);
     PyCodeObject *code = _PyFrame_GetCode(f->f_frame);
     int nslots = _PyFrame_NumSlotsForCodeObject(code);
     assert(nslots >= 0);
     // By construction, 0 <= nslots < code->co_framesize <= INT_MAX.
     // It should not be possible to have nslots >= PY_SSIZE_T_MAX
     // even if PY_SSIZE_T_MAX < INT_MAX because code->co_framesize
-    // is checked in _PyCode_Validate().
-    assert((size_t)nslots < (INT_MAX - res) / sizeof(PyObject *));
-    return PyLong_FromSsize_t(res + nslots * sizeof(PyObject *));
+    // is checked in _PyCode_Validate(). However, it is possible
+    // to make base + nslots * sizeof(PyObject *) >= INT_MAX since
+    // 'base' is not yet known when creating code objects.
+    //
+    // See https://github.com/python/cpython/issues/126119 for details.
+    if (nslots >= (int)((INT_MAX - base) / sizeof(PyObject *))) {
+        PyErr_SetString(PyExc_OverflowError, "size exceeds INT_MAX");
+        return NULL;
+    }
+    return PyLong_FromSsize_t(base + nslots * sizeof(PyObject *));
 }
 
 PyDoc_STRVAR(sizeof__doc__,

Objects/genobject.c

@@ -817,17 +817,24 @@ static PyMemberDef gen_memberlist[] = {
 static PyObject *
 gen_sizeof(PyGenObject *gen, PyObject *Py_UNUSED(ignored))
 {
-    Py_ssize_t res = offsetof(PyGenObject, gi_iframe)
-                     + offsetof(_PyInterpreterFrame, localsplus);
+    Py_ssize_t base = offsetof(PyGenObject, gi_iframe)
+                      + offsetof(_PyInterpreterFrame, localsplus);
     PyCodeObject *code = _PyGen_GetCode(gen);
     int nslots = _PyFrame_NumSlotsForCodeObject(code);
     assert(nslots >= 0);
     // By construction, 0 <= nslots < code->co_framesize <= INT_MAX.
     // It should not be possible to have nslots >= PY_SSIZE_T_MAX
     // even if PY_SSIZE_T_MAX < INT_MAX because code->co_framesize
-    // is checked in _PyCode_Validate().
-    assert((size_t)nslots < (INT_MAX - res) / sizeof(PyObject *));
-    return PyLong_FromSsize_t(res + nslots * sizeof(PyObject *));
+    // is checked in _PyCode_Validate(). However, it is possible
+    // to make base + nslots * sizeof(PyObject *) >= INT_MAX since
+    // 'base' is not yet known when creating code objects.
+    //
+    // See https://github.com/python/cpython/issues/126119 for details.
+    if (nslots >= (int)((INT_MAX - base) / sizeof(PyObject *))) {
+        PyErr_SetString(PyExc_OverflowError, "size exceeds INT_MAX");
+        return NULL;
+    }
+    return PyLong_FromSsize_t(base + nslots * sizeof(PyObject *));
 }
 
 PyDoc_STRVAR(sizeof__doc__,