On HPPA, the stack grows up

Adapted from a patch for Python 3.14 submitted to the Debian BTS by John
https://bugs.debian.org/1105111#20

Co-authored-by: John David Anglin <dave.anglin@bell.net>

Author: stefanor

Include/internal/pycore_ceval.h

@@ -217,7 +217,11 @@ extern void _PyEval_DeactivateOpCache(void);
 static inline int _Py_MakeRecCheck(PyThreadState *tstate)  {
     uintptr_t here_addr = _Py_get_machine_stack_pointer();
     _PyThreadStateImpl *_tstate = (_PyThreadStateImpl *)tstate;
+#ifdef __hppa__
+    return here_addr > _tstate->c_stack_soft_limit;
+#else
     return here_addr < _tstate->c_stack_soft_limit;
+#endif
 }
 
 // Export for '_json' shared extension, used via _Py_EnterRecursiveCall()
@@ -249,7 +253,11 @@ static inline int _Py_ReachedRecursionLimit(PyThreadState *tstate)  {
     uintptr_t here_addr = _Py_get_machine_stack_pointer();
     _PyThreadStateImpl *_tstate = (_PyThreadStateImpl *)tstate;
     assert(_tstate->c_stack_hard_limit != 0);
+#ifdef __hppa__
+    return here_addr >= _tstate->c_stack_soft_limit;
+#else
     return here_addr <= _tstate->c_stack_soft_limit;
+#endif
 }
 
 static inline void _Py_LeaveRecursiveCall(void)  {

Python/ceval.c

@@ -347,21 +347,33 @@ _Py_ReachedRecursionLimitWithMargin(PyThreadState *tstate, int margin_count)
 {
     uintptr_t here_addr = _Py_get_machine_stack_pointer();
     _PyThreadStateImpl *_tstate = (_PyThreadStateImpl *)tstate;
+#ifdef __hppa__
+    if (here_addr <= _tstate->c_stack_soft_limit - margin_count * _PyOS_STACK_MARGIN_BYTES) {
+#else
     if (here_addr > _tstate->c_stack_soft_limit + margin_count * _PyOS_STACK_MARGIN_BYTES) {
+#endif
         return 0;
     }
     if (_tstate->c_stack_hard_limit == 0) {
         _Py_InitializeRecursionLimits(tstate);
     }
+#ifdef __hppa__
+    return here_addr > _tstate->c_stack_soft_limit - margin_count * _PyOS_STACK_MARGIN_BYTES;
+#else
     return here_addr <= _tstate->c_stack_soft_limit + margin_count * _PyOS_STACK_MARGIN_BYTES;
+#endif
 }
 
 void
 _Py_EnterRecursiveCallUnchecked(PyThreadState *tstate)
 {
     uintptr_t here_addr = _Py_get_machine_stack_pointer();
     _PyThreadStateImpl *_tstate = (_PyThreadStateImpl *)tstate;
+#ifdef __hppa__
+    if (here_addr > _tstate->c_stack_hard_limit) {
+#else
     if (here_addr < _tstate->c_stack_hard_limit) {
+#endif
         Py_FatalError("Unchecked stack overflow.");
     }
 }
@@ -471,7 +483,11 @@ hardware_stack_limits(uintptr_t *top, uintptr_t *base)
     }
     if (err == 0) {
         *base = ((uintptr_t)stack_addr) + guard_size;
+#ifdef __hppa__
+        *top = (uintptr_t)stack_addr;
+#else
         *top = (uintptr_t)stack_addr + stack_size;
+#endif
         return;
     }
 #  endif
@@ -491,12 +507,20 @@ _Py_InitializeRecursionLimits(PyThreadState *tstate)
 #ifdef _Py_THREAD_SANITIZER
     // Thread sanitizer crashes if we use more than half the stack.
     uintptr_t stacksize = top - base;
+#ifndef __hppa__
     base += stacksize/2;
+#endif
 #endif
     _PyThreadStateImpl *_tstate = (_PyThreadStateImpl *)tstate;
+#ifdef __hppa__
+    _tstate->c_stack_top = base + stacksize/2;
+    _tstate->c_stack_hard_limit = base + stacksize + _PyOS_STACK_MARGIN_BYTES;
+    _tstate->c_stack_soft_limit = base + +stacksize + _PyOS_STACK_MARGIN_BYTES * 2;
+#else
     _tstate->c_stack_top = top;
     _tstate->c_stack_hard_limit = base + _PyOS_STACK_MARGIN_BYTES;
     _tstate->c_stack_soft_limit = base + _PyOS_STACK_MARGIN_BYTES * 2;
+#endif
 }
 
 /* The function _Py_EnterRecursiveCallTstate() only calls _Py_CheckRecursiveCall()
@@ -508,9 +532,15 @@ _Py_CheckRecursiveCall(PyThreadState *tstate, const char *where)
     uintptr_t here_addr = _Py_get_machine_stack_pointer();
     assert(_tstate->c_stack_soft_limit != 0);
     assert(_tstate->c_stack_hard_limit != 0);
+#ifdef __hppa__
+    if (here_addr > _tstate->c_stack_hard_limit) {
+        /* Overflowing while handling an overflow. Give up. */
+        int kbytes_used = (int)(here_addr - _tstate->c_stack_top)/1024;
+#else
     if (here_addr < _tstate->c_stack_hard_limit) {
         /* Overflowing while handling an overflow. Give up. */
         int kbytes_used = (int)(_tstate->c_stack_top - here_addr)/1024;
+#endif
         char buffer[80];
         snprintf(buffer, 80, "Unrecoverable stack overflow (used %d kB)%s", kbytes_used, where);
         Py_FatalError(buffer);
@@ -519,7 +549,11 @@ _Py_CheckRecursiveCall(PyThreadState *tstate, const char *where)
         return 0;
     }
     else {
+#ifdef __hppa__
+        int kbytes_used = (int)(here_addr - _tstate->c_stack_top)/1024;
+#else
         int kbytes_used = (int)(_tstate->c_stack_top - here_addr)/1024;
+#endif
         tstate->recursion_headroom++;
         _PyErr_Format(tstate, PyExc_RecursionError,
                     "Stack overflow (used %d kB)%s",