Define _Py_STACK_GROWS_DOWN to declare the stack direction

Author: stefanor

Include/internal/pycore_ceval.h

@@ -16,6 +16,12 @@ extern "C" {
 #include "pycore_stats.h"         // EVAL_CALL_STAT_INC()
 #include "pycore_typedefs.h"      // _PyInterpreterFrame
 
+/* HP PA-RISC has a stack that goes up */
+#ifdef __hppa__
+#  define _Py_STACK_GROWS_DOWN 0
+#else
+#  define _Py_STACK_GROWS_DOWN 1
+#endif
 
 /* Forward declarations */
 struct _ceval_runtime_state;
@@ -217,10 +223,10 @@ 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
+#if _Py_STACK_GROWS_DOWN
     return here_addr < _tstate->c_stack_soft_limit;
+#else
+    return here_addr > _tstate->c_stack_soft_limit;
 #endif
 }
 
@@ -253,10 +259,10 @@ 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
+#if _Py_STACK_GROWS_DOWN
     return here_addr <= _tstate->c_stack_soft_limit;
+#else
+    return here_addr >= _tstate->c_stack_soft_limit;
 #endif
 }
 

Python/ceval.c

@@ -347,20 +347,20 @@ _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 _Py_STACK_GROWS_DOWN
     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
+#if _Py_STACK_GROWS_DOWN
     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
 }
 
@@ -369,10 +369,10 @@ _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 _Py_STACK_GROWS_DOWN
     if (here_addr < _tstate->c_stack_hard_limit) {
+#else
+    if (here_addr > _tstate->c_stack_hard_limit) {
 #endif
         Py_FatalError("Unchecked stack overflow.");
     }
@@ -503,21 +503,21 @@ _Py_InitializeRecursionLimits(PyThreadState *tstate)
 #ifdef _Py_THREAD_SANITIZER
     // Thread sanitizer crashes if we use more than half the stack.
     uintptr_t stacksize = top - base;
-#  ifdef __hppa__
-    top -= stacksize/2;
-#  else
+#  if _Py_STACK_GROWS_DOWN
     base += stacksize/2;
+#  else
+    top -= stacksize/2;
 #  endif
 #endif
     _PyThreadStateImpl *_tstate = (_PyThreadStateImpl *)tstate;
-#ifdef __hppa__
-    _tstate->c_stack_top = base;
-    _tstate->c_stack_hard_limit = top - _PyOS_STACK_MARGIN_BYTES;
-    _tstate->c_stack_soft_limit = top - _PyOS_STACK_MARGIN_BYTES * 2;
-#else
+#if _Py_STACK_GROWS_DOWN
     _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;
+#else
+    _tstate->c_stack_top = base;
+    _tstate->c_stack_hard_limit = top - _PyOS_STACK_MARGIN_BYTES;
+    _tstate->c_stack_soft_limit = top - _PyOS_STACK_MARGIN_BYTES * 2;
 #endif
 }
 
@@ -530,14 +530,14 @@ _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 _Py_STACK_GROWS_DOWN
     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;
+#else
+    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;
 #endif
         char buffer[80];
         snprintf(buffer, 80, "Unrecoverable stack overflow (used %d kB)%s", kbytes_used, where);
@@ -547,10 +547,10 @@ _Py_CheckRecursiveCall(PyThreadState *tstate, const char *where)
         return 0;
     }
     else {
-#ifdef __hppa__
-        int kbytes_used = (int)(here_addr - _tstate->c_stack_top)/1024;
-#else
+#if _Py_STACK_GROWS_DOWN
         int kbytes_used = (int)(_tstate->c_stack_top - here_addr)/1024;
+#else
+        int kbytes_used = (int)(here_addr - _tstate->c_stack_top)/1024;
 #endif
         tstate->recursion_headroom++;
         _PyErr_Format(tstate, PyExc_RecursionError,