Raise OverflowError on out-of-range c_int/c_byte kernel arguments

[rparolin]

Prepared with the assistance of an automated agent (Claude Code / Claude Opus 4.8). Please review carefully.

Summary

An out-of-range Python int passed as a c_int / c_byte kernel argument was silently narrowed — e.g. 2**32 + 5 was stored as 5, so the kernel ran with a value the caller never intended, with no error or warning.

The c_int/c_byte param feeders now range-check the value and raise OverflowError instead. Implementation notes:

• A single code path across all supported Pythons via PyLong_AsLongAndOverflow (flags out-of-long values through its overflow out-param) plus an explicit 32-bit / 8-bit bounds check.
• feed() is declared except? -1 in the .pxd so Cython actually propagates the exception — without that, the raise would be silently swallowed (the same class of bug).

Behavior change (please confirm)

This is intentionally stricter than ctypes' own behavior, which silently wraps out-of-range ints. Raising was chosen deliberately over matching ctypes.

Tests

test_kernelParams_c_int_out_of_range_raises (GPU): an in-range value still launches; 2**32+5 (c_int) and 200 (c_byte) now raise OverflowError. Verified on Python 3.14.

Context

Addresses Glasswing finding V9.1. Behavior and implementation reviewed/shaped by @leofang (the single-code-path PyLong_AsLongAndOverflow form was his call). Split out from the hardening batch in #2399 so it can be reviewed on its own.

[github-actions]

Doc Preview CI
🚀 View preview at https://nvidia.github.io/cuda-python/pr-preview/pr-2402/
https://nvidia.github.io/cuda-python/pr-preview/pr-2402/cuda-core/
https://nvidia.github.io/cuda-python/pr-preview/pr-2402/cuda-bindings/
https://nvidia.github.io/cuda-python/pr-preview/pr-2402/cuda-pathfinder/
Preview will be ready when the GitHub Pages deployment is complete.

[mdboom]

Python 3.13 and later have PyLong_AsInt, which already does exactly what we want. The usual way to handle this is to put a backport copy of the function here, and then gate on the Python version.

Below is the implementation directly from CPython, wrapped in a version guard. This should be added to the top of the file.

#if PY_VERSION_HEX < 0x030D0000
int
PyLong_AsInt(PyObject *obj)
{
    int overflow;
    long result = PyLong_AsLongAndOverflow(obj, &overflow);
    if (overflow || result > INT_MAX || result < INT_MIN) {
        PyErr_SetString(PyExc_OverflowError,
                        "Python int too large to convert to C int");
        return -1;
    }
    return (int)result;
}
#endif

Suggested change

	// Bound to the 32-bit int slot, NOT to `long`. AsLongAndOverflow's
	// `overflow` only flags values outside `long`, which is 64-bit on
	// LP64 (Linux/macOS) -- so a value in 2**31..2**63 comes back with
	// overflow==0 and would be silently truncated by (int)v. The
	// explicit INT_MIN/INT_MAX check rejects it. When overflow!=0, v is
	// the -1 sentinel (not the real value), so that case must be caught
	// first, before trusting v.
	int overflow = 0;
	long v = PyLong_AsLongAndOverflow(value, &overflow);
	if (overflow == 0 && v == -1 && PyErr_Occurred())
	return -1; // non-overflow conversion error; exception already set
	if (overflow != 0 || v < INT_MIN || v > INT_MAX)
	{
	PyErr_SetString(PyExc_OverflowError,
	"Python int is out of range for a c_int (32-bit) kernel argument");
	return -1;
	}
	*((int*)ptr) = (int)v;
	v = PyLong_AsInt(value);
	if (v == -1 && PyErr_Occurred())
	return -1;
	*((int*)ptr) = (int)v;

[mdboom]

This one we do need to keep because it doesn't have an equivalent in CPython.