Rename to PyUnstable_ThreadState_SetStackProtection()

Author: vstinner

Doc/c-api/exceptions.rst

@@ -940,7 +940,7 @@ because the :ref:`call protocol <call>` takes care of recursion handling.
    depth limit.
 
    .. seealso::
-      The :c:func:`PyUnstable_ThreadState_SetStack` function.
+      The :c:func:`PyUnstable_ThreadState_SetStackProtection` function.
 
    .. versionchanged:: 3.9
       This function is now also available in the :ref:`limited API <limited-c-api>`.

Doc/c-api/init.rst

@@ -1353,7 +1353,7 @@ All of the following functions must be called after :c:func:`Py_Initialize`.
    .. versionadded:: 3.11
 
 
-.. c:function:: int PyUnstable_ThreadState_SetStack(PyThreadState *tstate, void *stack_start_addr, size_t stack_size)
+.. c:function:: int PyUnstable_ThreadState_SetStackProtection(PyThreadState *tstate, void *stack_start_addr, size_t stack_size)
 
    Set the stack start address and stack size of a Python thread state.
 
@@ -1367,24 +1367,24 @@ All of the following functions must be called after :c:func:`Py_Initialize`.
    normally gets from the operating system.
    When the stack is changed, for example using context switching techniques like the
    Boost library's ``boost::context``, you must call
-   :c:func:`~PyUnstable_ThreadState_SetStack` to inform CPython of the change.
+   :c:func:`~PyUnstable_ThreadState_SetStackProtection` to inform CPython of the change.
 
-   Call :c:func:`~PyUnstable_ThreadState_SetStack` either before
+   Call :c:func:`~PyUnstable_ThreadState_SetStackProtection` either before
    or after changing the stack.
    Do not call any other Python C API between the call and the stack
    change.
 
-   See :c:func:`PyUnstable_ThreadState_ResetStack` for undoing this operation.
+   See :c:func:`PyUnstable_ThreadState_ResetStackProtection` for undoing this operation.
 
    .. versionadded:: next
 
 
-.. c:function:: void PyUnstable_ThreadState_ResetStack(PyThreadState *tstate)
+.. c:function:: void PyUnstable_ThreadState_ResetStackProtection(PyThreadState *tstate)
 
    Reset the stack start address and stack size of a Python thread state to
    the operating system defaults.
 
-   See :c:func:`PyUnstable_ThreadState_SetStack` for an explanation.
+   See :c:func:`PyUnstable_ThreadState_SetStackProtection` for an explanation.
 
    .. versionadded:: next
 

Doc/whatsnew/3.14.rst

@@ -2994,8 +2994,8 @@ New features in the C API
   as arguments to C API functions.
   (Contributed by Sam Gross in :gh:`133164`.)
 
-* Add :c:func:`PyUnstable_ThreadState_SetStack` and
-  :c:func:`PyUnstable_ThreadState_ResetStack` functions to set the stack base
+* Add :c:func:`PyUnstable_ThreadState_SetStackProtection` and
+  :c:func:`PyUnstable_ThreadState_ResetStackProtection` functions to set the stack base
   address and stack size of a Python thread state.
   (Contributed by Victor Stinner in :gh:`139653`.)
 

Include/cpython/pystate.h

@@ -253,13 +253,13 @@ PyAPI_FUNC(int) PyGILState_Check(void);
 PyAPI_FUNC(PyObject*) _PyThread_CurrentFrames(void);
 
 // Set the stack start address and stack size of a Python thread state
-PyAPI_FUNC(int) PyUnstable_ThreadState_SetStack(
+PyAPI_FUNC(int) PyUnstable_ThreadState_SetStackProtection(
     PyThreadState *tstate,
     void *stack_start_addr,  // Stack start address
     size_t stack_size);      // Stack size (in bytes)
 
 // Reset the stack start address and stack size of a Python thread state
-PyAPI_FUNC(void) PyUnstable_ThreadState_ResetStack(
+PyAPI_FUNC(void) PyUnstable_ThreadState_ResetStackProtection(
     PyThreadState *tstate);
 
 /* Routines for advanced debuggers, requested by David Beazley.

Include/internal/pycore_tstate.h

@@ -37,7 +37,7 @@ typedef struct _PyThreadStateImpl {
     uintptr_t c_stack_soft_limit;
     uintptr_t c_stack_hard_limit;
 
-    // PyUnstable_ThreadState_ResetStack() values
+    // PyUnstable_ThreadState_ResetStackProtection() values
     uintptr_t c_stack_init_base;
     uintptr_t c_stack_init_top;
 

Misc/NEWS.d/next/C_API/2025-10-06-22-17-47.gh-issue-139653.6-1MOd.rst

@@ -1,3 +1,3 @@
-Add :c:func:`PyUnstable_ThreadState_SetStack` and
-:c:func:`PyUnstable_ThreadState_ResetStack` functions to set the stack base
+Add :c:func:`PyUnstable_ThreadState_SetStackProtection` and
+:c:func:`PyUnstable_ThreadState_ResetStackProtection` functions to set the stack base
 address and stack size of a Python thread state. Patch by Victor Stinner.

Modules/_testinternalcapi.c

@@ -2421,7 +2421,7 @@ set_vectorcall_nop(PyObject *self, PyObject *func)
 static void
 check_threadstate_set_stack(PyThreadState *tstate, void *start, size_t size)
 {
-    assert(PyUnstable_ThreadState_SetStack(tstate, start, size) == 0);
+    assert(PyUnstable_ThreadState_SetStackProtection(tstate, start, size) == 0);
     assert(!PyErr_Occurred());
 
     _PyThreadStateImpl *ts = (_PyThreadStateImpl *)tstate;
@@ -2455,12 +2455,12 @@ test_threadstate_set_stack(PyObject *self, PyObject *Py_UNUSED(args))
     // Test invalid size (too small)
     size = 5;
     start = (void*)(_Py_get_machine_stack_pointer() - size);
-    assert(PyUnstable_ThreadState_SetStack(tstate, start, size) == -1);
+    assert(PyUnstable_ThreadState_SetStackProtection(tstate, start, size) == -1);
     assert(PyErr_ExceptionMatches(PyExc_ValueError));
     PyErr_Clear();
 
-    // Test PyUnstable_ThreadState_ResetStack()
-    PyUnstable_ThreadState_ResetStack(tstate);
+    // Test PyUnstable_ThreadState_ResetStackProtection()
+    PyUnstable_ThreadState_ResetStackProtection(tstate);
     assert(ts->c_stack_init_base == init_base);
     assert(ts->c_stack_init_top == init_top);
 

Python/ceval.c

@@ -530,7 +530,7 @@ _Py_InitializeRecursionLimits(PyThreadState *tstate)
 
 
 int
-PyUnstable_ThreadState_SetStack(PyThreadState *tstate,
+PyUnstable_ThreadState_SetStackProtection(PyThreadState *tstate,
                                 void *stack_start_addr, size_t stack_size)
 {
     if (stack_size < _PyOS_MIN_STACK_SIZE) {
@@ -548,7 +548,7 @@ PyUnstable_ThreadState_SetStack(PyThreadState *tstate,
 
 
 void
-PyUnstable_ThreadState_ResetStack(PyThreadState *tstate)
+PyUnstable_ThreadState_ResetStackProtection(PyThreadState *tstate)
 {
     _PyThreadStateImpl *ts = (_PyThreadStateImpl *)tstate;
     if (ts->c_stack_init_top != 0) {