Use uintptr_t instead of char * to avoid warnings and UB

Author: markshannon

Include/cpython/pystate.h

@@ -112,8 +112,9 @@ struct _ts {
     int py_recursion_remaining;
     int py_recursion_limit;
 
-    char *c_stack_soft_limit;
-    char *c_stack_hard_limit;
+    // These are addresses, but we need to convert to ints to avoid UB.
+    uintptr_t c_stack_soft_limit;
+    uintptr_t c_stack_hard_limit;
     int recursion_headroom; /* Allow 50 more calls to handle any errors. */
 
     /* 'tracing' keeps track of the execution depth when tracing/profiling.

Include/internal/pycore_ceval.h

@@ -195,7 +195,8 @@ extern void _PyEval_DeactivateOpCache(void);
 
 static inline int _Py_MakeRecCheck(PyThreadState *tstate)  {
     char here;
-    return &here < tstate->c_stack_soft_limit;
+    uintptr_t here_addr = (uintptr_t)&here;
+    return here_addr < tstate->c_stack_soft_limit;
 }
 
 // Export for '_json' shared extension, used via _Py_EnterRecursiveCall()
@@ -223,7 +224,8 @@ static inline void _Py_LeaveRecursiveCallTstate(PyThreadState *tstate)  {
 
 static inline int _Py_ReachedRecursionLimit(PyThreadState *tstate, int margin_count)  {
     char here;
-    return &here <= tstate->c_stack_soft_limit + margin_count * PYOS_STACK_MARGIN_BYTES;
+    uintptr_t here_addr = (uintptr_t)&here;
+    return here_addr <= tstate->c_stack_soft_limit + margin_count * PYOS_STACK_MARGIN_BYTES;
 }
 
 static inline void _Py_LeaveRecursiveCall(void)  {

Modules/_testinternalcapi.c

@@ -116,7 +116,8 @@ get_c_recursion_remaining(PyObject *self, PyObject *Py_UNUSED(args))
 {
     PyThreadState *tstate = _PyThreadState_GET();
     char here;
-    int remaining = (int)((&here - tstate->c_stack_soft_limit)/PYOS_STACK_MARGIN_BYTES * 50);
+    uintptr_t here_addr = (uintptr_t)&here;
+    int remaining = (int)((here_addr - tstate->c_stack_soft_limit)/PYOS_STACK_MARGIN_BYTES * 50);
     return PyLong_FromLong(remaining);
 }
 

Python/ceval.c

@@ -312,7 +312,8 @@ void
 _Py_EnterRecursiveCallUnchecked(PyThreadState *tstate)
 {
     char here;
-    if (&here < tstate->c_stack_hard_limit) {
+    uintptr_t here_addr = (uintptr_t)&here;
+    if (here_addr < tstate->c_stack_hard_limit) {
         Py_FatalError("Unchecked stack overflow.");
     }
 }
@@ -329,29 +330,30 @@ int
 _Py_CheckRecursiveCall(PyThreadState *tstate, const char *where)
 {
     char here;
-    assert(tstate->c_stack_soft_limit != NULL);
-    if (tstate->c_stack_hard_limit == NULL) {
+    uintptr_t here_addr = (uintptr_t)&here;
+    assert(tstate->c_stack_soft_limit != 0);
+    if (tstate->c_stack_hard_limit == 0) {
 #ifdef USE_STACKCHECK
         assert(_PyOS_CheckStack(PYOS_STACK_MARGIN));
         if (_PyOS_CheckStack(PYOS_STACK_MARGIN * 2) == 0) {
-            tstate->c_stack_soft_limit = &here - PYOS_STACK_MARGIN_BYTES;
+            tstate->c_stack_soft_limit = here_addr - PYOS_STACK_MARGIN_BYTES;
             return 0;
         }
         else {
-            assert(tstate->c_stack_soft_limit != (char*)UINTPTR_MAX);
+            assert(tstate->c_stack_soft_limit != UINTPTR_MAX);
             tstate->c_stack_hard_limit = tstate->c_stack_soft_limit - PYOS_STACK_MARGIN_BYTES;
-        }F
+        }
 #else
-        assert(tstate->c_stack_soft_limit == (char*)UINTPTR_MAX);
-        tstate->c_stack_soft_limit = &here - Py_C_STACK_SIZE;
-        tstate->c_stack_hard_limit = &here - (Py_C_STACK_SIZE + PYOS_STACK_MARGIN_BYTES);
+        assert(tstate->c_stack_soft_limit == UINTPTR_MAX);
+        tstate->c_stack_soft_limit = here_addr - Py_C_STACK_SIZE;
+        tstate->c_stack_hard_limit = here_addr - (Py_C_STACK_SIZE + PYOS_STACK_MARGIN_BYTES);
 #endif
     }
-    if (&here >= tstate->c_stack_soft_limit) {
+    if (here_addr >= tstate->c_stack_soft_limit) {
         return 0;
     }
-    assert(tstate->c_stack_hard_limit != NULL);
-    if (&here < tstate->c_stack_hard_limit) {
+    assert(tstate->c_stack_hard_limit != 0);
+    if (here_addr < tstate->c_stack_hard_limit) {
         /* Overflowing while handling an overflow. Give up. */
         Py_FatalError("Cannot recover from stack overflow.");
     }

Python/pystate.c

@@ -1492,8 +1492,8 @@ init_threadstate(_PyThreadStateImpl *_tstate,
 
     tstate->py_recursion_limit = interp->ceval.recursion_limit;
     tstate->py_recursion_remaining = interp->ceval.recursion_limit;
-    tstate->c_stack_soft_limit = (char *)UINTPTR_MAX;
-    tstate->c_stack_hard_limit = NULL;
+    tstate->c_stack_soft_limit = UINTPTR_MAX;
+    tstate->c_stack_hard_limit = 0;
 
     tstate->exc_info = &tstate->exc_state;