m4/c-stack.m4

   1 # Check prerequisites for compiling lib/c-stack.c.
   2
   3 # Copyright (C) 2002 Free Software Foundation, Inc.
   4
   5 # This program is free software; you can redistribute it and/or modify
   6 # it under the terms of the GNU General Public License as published by
   7 # the Free Software Foundation; either version 2, or (at your option)
   8 # any later version.
   9
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program; if not, write to the Free Software
  17 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  18 # 02111-1307, USA.
  19
  20 # Written by Paul Eggert.
  21
  22 AC_DEFUN([AC_SYS_XSI_STACK_OVERFLOW_HEURISTIC],
  23   [# for STACK_DIRECTION
  24    AC_REQUIRE([AC_FUNC_ALLOCA])
  25
  26    AC_CACHE_CHECK([for working C stack overflow detection],
  27      ac_cv_sys_xsi_stack_overflow_heuristic,
  28      [AC_TRY_RUN(
  29         [
  30          #include <signal.h>
  31          #include <ucontext.h>
  32
  33          static union
  34          {
  35            char buffer[SIGSTKSZ];
  36            long double ld;
  37            long u;
  38            void *p;
  39          } alternate_signal_stack;
  40
  41          #if STACK_DIRECTION
  42          # define find_stack_direction(ptr) STACK_DIRECTION
  43          #else
  44          static int
  45          find_stack_direction (char const *addr)
  46          {
  47            char dummy;
  48            return (! addr ? find_stack_direction (&dummy)
  49                    : addr < &dummy ? 1 : -1);
  50          }
  51          #endif
  52
  53          static void
  54          segv_handler (int signo, siginfo_t *info, void *context)
  55          {
  56            if (0 < info->si_code)
  57              {
  58                ucontext_t const *user_context = context;
  59                char const *stack_min = user_context->uc_stack.ss_sp;
  60                size_t stack_size = user_context->uc_stack.ss_size;
  61                char const *faulting_address = info->si_addr;
  62                size_t s = faulting_address - stack_min;
  63                size_t page_size = sysconf (_SC_PAGESIZE);
  64                if (find_stack_direction (0) < 0)
  65                  s += page_size;
  66                if (s < stack_size + page_size)
  67                  _exit (0);
  68              }
  69
  70            _exit (1);
  71          }
  72
  73          static int
  74          c_stack_action (void)
  75          {
  76            stack_t st;
  77            struct sigaction act;
  78            int r;
  79
  80            st.ss_flags = 0;
  81            st.ss_sp = alternate_signal_stack.buffer;
  82            st.ss_size = sizeof alternate_signal_stack.buffer;
  83            r = sigaltstack (&st, 0);
  84            if (r != 0)
  85              return r;
  86
  87            sigemptyset (&act.sa_mask);
  88            act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND | SA_SIGINFO;
  89            act.sa_sigaction = segv_handler;
  90            return sigaction (SIGSEGV, &act, 0);
  91          }
  92
  93          static int
  94          recurse (char *p)
  95          {
  96            char array[500];
  97            array[0] = 1;
  98            return *p + recurse (array);
  99          }
 100
 101          int
 102          main (void)
 103          {
 104            c_stack_action ();
 105            return recurse ("\1");
 106          }
 107         ],
 108         [ac_cv_sys_xsi_stack_overflow_heuristic=yes],
 109         [ac_cv_sys_xsi_stack_overflow_heuristic=no],
 110         [ac_cv_sys_xsi_stack_overflow_heuristic=cross-compiling])])
 111
 112    if test $ac_cv_sys_xsi_stack_overflow_heuristic = yes; then
 113      AC_DEFINE(HAVE_XSI_STACK_OVERFLOW_HEURISTIC, 1,
 114        [Define to 1 if extending the stack slightly past the limit causes
 115         a SIGSEGV, and an alternate stack can be established with sigaltstack,
 116         and the signal handler is passed a context that specifies the
 117         run time stack.  This behavior is defined by POSIX 1003.1-2001
 118         with the X/Open System Interface (XSI) option
 119         and is a standardized way to implement a SEGV-based stack
 120         overflow detection heuristic.])
 121    fi])
 122
 123
 124 AC_DEFUN([jm_PREREQ_C_STACK],
 125   [AC_REQUIRE([AC_SYS_XSI_STACK_OVERFLOW_HEURISTIC])
 126
 127    # for STACK_DIRECTION
 128    AC_REQUIRE([AC_FUNC_ALLOCA])
 129
 130    AC_CHECK_FUNCS(getcontext sigaltstack)
 131    AC_CHECK_DECLS([getcontext], , , [#include <ucontext.h>])
 132    AC_CHECK_DECLS([sigaltstack], , , [#include <signal.h>])
 133
 134    AC_CHECK_HEADERS_ONCE(sys/time.h unistd.h)
 135    AC_CHECK_HEADERS(sys/resource.h ucontext.h)
 136
 137    AC_CHECK_TYPES([stack_t], , , [#include <signal.h>])])
 138
 139 AC_DEFUN([gl_C_STACK],
 140 [
 141   dnl Prerequisites of lib/c-stack.c.
 142   jm_PREREQ_C_STACK
 143 ])