X-Git-Url: http://erislabs.net/gitweb/?a=blobdiff_plain;f=m4%2Fc-stack.m4;h=2a89696a9c7227ad957901d55d5d587047f7498c;hb=84405cbc35207f178b1b50617254cb85ea803128;hp=0963cc580eed75982577483ef74aab69489b426d;hpb=42d1eda5dcce2d68deab7a642e7f29bcd7144a0d;p=gnulib.git

diff --git a/m4/c-stack.m4 b/m4/c-stack.m4
index 0963cc580..2a89696a9 100644
--- a/m4/c-stack.m4
+++ b/m4/c-stack.m4
@@ -7,7 +7,7 @@
 
 # Written by Paul Eggert.
 
-# serial 9
+# serial 10
 
 AC_DEFUN([AC_SYS_XSI_STACK_OVERFLOW_HEURISTIC],
   [# for STACK_DIRECTION
@@ -36,86 +36,86 @@ AC_DEFUN([AC_SYS_XSI_STACK_OVERFLOW_HEURISTIC],
 
    AC_CACHE_CHECK([for working C stack overflow detection],
      [ac_cv_sys_stack_overflow_works],
-     [AC_TRY_RUN(
-	[
-	 #include <unistd.h>
-	 #include <signal.h>
-	 #if HAVE_SETRLIMIT
-	 # include <sys/types.h>
-	 # include <sys/time.h>
-	 # include <sys/resource.h>
-	 #endif
-	 #ifndef SIGSTKSZ
-	 # define SIGSTKSZ 16384
-	 #endif
-
-	 static union
-	 {
-	   char buffer[2 * SIGSTKSZ];
-	   long double ld;
-	   long u;
-	   void *p;
-	 } alternate_signal_stack;
-
-	 static void
-	 segv_handler (int signo)
-	 {
-	   _exit (0);
-	 }
-
-	 static int
-	 c_stack_action ()
-	 {
-	   stack_t st;
-	   struct sigaction act;
-	   int r;
-
-	   st.ss_flags = 0;
-	   /* Use the midpoint to avoid Irix sigaltstack bug.  */
-	   st.ss_sp = alternate_signal_stack.buffer + SIGSTKSZ;
-	   st.ss_size = SIGSTKSZ;
-	   r = sigaltstack (&st, 0);
-	   if (r != 0)
-	     return r;
-
-	   sigemptyset (&act.sa_mask);
-	   act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND;
-	   act.sa_handler = segv_handler;
-	   #if FAULT_YIELDS_SIGBUS
-	   if (sigaction (SIGBUS, &act, 0) < 0)
-	     return -1;
-	   #endif
-	   return sigaction (SIGSEGV, &act, 0);
-	 }
-	 static volatile int *
-	 recurse_1 (volatile int n, volatile int *p)
-	 {
-	   if (n >= 0)
-	     *recurse_1 (n + 1, p) += n;
-	   return p;
-	 }
-	 static int
-	 recurse (volatile int n)
-	 {
-	   int sum = 0;
-	   return *recurse_1 (n, &sum);
-	 }
-	 int
-	 main ()
-	 {
-	   #if HAVE_SETRLIMIT && defined RLIMIT_STACK
-	   /* Before starting the endless recursion, try to be friendly
-	      to the user's machine.  On some Linux 2.2.x systems, there
-	      is no stack limit for user processes at all.  We don't want
-	      to kill such systems.  */
-	   struct rlimit rl;
-	   rl.rlim_cur = rl.rlim_max = 0x100000; /* 1 MB */
-	   setrlimit (RLIMIT_STACK, &rl);
-	   #endif
-
-	   return c_stack_action () || recurse (0);
-	 }
-	],
+     [AC_RUN_IFELSE([AC_LANG_SOURCE(
+           [[
+            #include <unistd.h>
+            #include <signal.h>
+            #if HAVE_SETRLIMIT
+            # include <sys/types.h>
+            # include <sys/time.h>
+            # include <sys/resource.h>
+            #endif
+            #ifndef SIGSTKSZ
+            # define SIGSTKSZ 16384
+            #endif
+
+            static union
+            {
+              char buffer[2 * SIGSTKSZ];
+              long double ld;
+              long u;
+              void *p;
+            } alternate_signal_stack;
+
+            static void
+            segv_handler (int signo)
+            {
+              _exit (0);
+            }
+
+            static int
+            c_stack_action ()
+            {
+              stack_t st;
+              struct sigaction act;
+              int r;
+
+              st.ss_flags = 0;
+              /* Use the midpoint to avoid Irix sigaltstack bug.  */
+              st.ss_sp = alternate_signal_stack.buffer + SIGSTKSZ;
+              st.ss_size = SIGSTKSZ;
+              r = sigaltstack (&st, 0);
+              if (r != 0)
+                return r;
+
+              sigemptyset (&act.sa_mask);
+              act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND;
+              act.sa_handler = segv_handler;
+              #if FAULT_YIELDS_SIGBUS
+              if (sigaction (SIGBUS, &act, 0) < 0)
+                return -1;
+              #endif
+              return sigaction (SIGSEGV, &act, 0);
+            }
+            static volatile int *
+            recurse_1 (volatile int n, volatile int *p)
+            {
+              if (n >= 0)
+                *recurse_1 (n + 1, p) += n;
+              return p;
+            }
+            static int
+            recurse (volatile int n)
+            {
+              int sum = 0;
+              return *recurse_1 (n, &sum);
+            }
+            int
+            main ()
+            {
+              #if HAVE_SETRLIMIT && defined RLIMIT_STACK
+              /* Before starting the endless recursion, try to be friendly
+                 to the user's machine.  On some Linux 2.2.x systems, there
+                 is no stack limit for user processes at all.  We don't want
+                 to kill such systems.  */
+              struct rlimit rl;
+              rl.rlim_cur = rl.rlim_max = 0x100000; /* 1 MB */
+              setrlimit (RLIMIT_STACK, &rl);
+              #endif
+
+              return c_stack_action () || recurse (0);
+            }
+           ]])],
 	[ac_cv_sys_stack_overflow_works=yes],
 	[ac_cv_sys_stack_overflow_works=no],
 	[ac_cv_sys_stack_overflow_works=cross-compiling])])
@@ -190,118 +190,118 @@ int main ()
 
    AC_CACHE_CHECK([for precise C stack overflow detection],
      ac_cv_sys_xsi_stack_overflow_heuristic,
-     [AC_TRY_RUN(
-	[
-	 #include <unistd.h>
-	 #include <signal.h>
-	 #if HAVE_UCONTEXT_H
-	 # include <ucontext.h>
-	 #endif
-	 #if HAVE_SETRLIMIT
-	 # include <sys/types.h>
-	 # include <sys/time.h>
-	 # include <sys/resource.h>
-	 #endif
-	 #ifndef SIGSTKSZ
-	 # define SIGSTKSZ 16384
-	 #endif
-
-	 static union
-	 {
-	   char buffer[2 * SIGSTKSZ];
-	   long double ld;
-	   long u;
-	   void *p;
-	 } alternate_signal_stack;
-
-	 #if STACK_DIRECTION
-	 # define find_stack_direction(ptr) STACK_DIRECTION
-	 #else
-	 static int
-	 find_stack_direction (char const *addr)
-	 {
-	   char dummy;
-	   return (! addr ? find_stack_direction (&dummy)
-		   : addr < &dummy ? 1 : -1);
-	 }
-	 #endif
-
-	 static void
-	 segv_handler (int signo, siginfo_t *info, void *context)
-	 {
-	   if (0 < info->si_code)
-	     {
-	       /* For XSI heuristics to work, we need uc_stack to describe
-		  the interrupted stack (as on Solaris), and not the
-		  currently executing stack (as on Linux).  */
-	       ucontext_t const *user_context = context;
-	       char const *stack_min = user_context->uc_stack.ss_sp;
-	       size_t stack_size = user_context->uc_stack.ss_size;
-	       char const *faulting_address = info->si_addr;
-	       size_t s = faulting_address - stack_min;
-	       size_t page_size = sysconf (_SC_PAGESIZE);
-	       if (find_stack_direction (0) < 0)
-		 s += page_size;
-	       if (s < stack_size + page_size)
-		 _exit (0);
-	     }
-
-	   _exit (1);
-	 }
-
-	 static int
-	 c_stack_action ()
-	 {
-	   stack_t st;
-	   struct sigaction act;
-	   int r;
-
-	   st.ss_flags = 0;
-	   /* Use the midpoint to avoid Irix sigaltstack bug.  */
-	   st.ss_sp = alternate_signal_stack.buffer + SIGSTKSZ;
-	   st.ss_size = SIGSTKSZ;
-	   r = sigaltstack (&st, 0);
-	   if (r != 0)
-	     return r;
-
-	   sigemptyset (&act.sa_mask);
-	   act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND | SA_SIGINFO;
-	   act.sa_sigaction = segv_handler;
-	   #if FAULT_YIELDS_SIGBUS
-	   if (sigaction (SIGBUS, &act, 0) < 0)
-	     return -1;
-	   #endif
-	   return sigaction (SIGSEGV, &act, 0);
-	 }
-	 static volatile int *
-	 recurse_1 (volatile int n, volatile int *p)
-	 {
-	   if (n >= 0)
-	     *recurse_1 (n + 1, p) += n;
-	   return p;
-	 }
-	 static int
-	 recurse (volatile int n)
-	 {
-	   int sum = 0;
-	   return *recurse_1 (n, &sum);
-	 }
-	 int
-	 main ()
-	 {
-	   #if HAVE_SETRLIMIT && defined RLIMIT_STACK
-	   /* Before starting the endless recursion, try to be friendly
-	      to the user's machine.  On some Linux 2.2.x systems, there
-	      is no stack limit for user processes at all.  We don't want
-	      to kill such systems.  */
-	   struct rlimit rl;
-	   rl.rlim_cur = rl.rlim_max = 0x100000; /* 1 MB */
-	   setrlimit (RLIMIT_STACK, &rl);
-	   #endif
-
-	   return c_stack_action () || recurse (0);
-	 }
-	],
+     [AC_RUN_IFELSE([AC_LANG_SOURCE(
+           [[
+            #include <unistd.h>
+            #include <signal.h>
+            #if HAVE_UCONTEXT_H
+            # include <ucontext.h>
+            #endif
+            #if HAVE_SETRLIMIT
+            # include <sys/types.h>
+            # include <sys/time.h>
+            # include <sys/resource.h>
+            #endif
+            #ifndef SIGSTKSZ
+            # define SIGSTKSZ 16384
+            #endif
+
+            static union
+            {
+              char buffer[2 * SIGSTKSZ];
+              long double ld;
+              long u;
+              void *p;
+            } alternate_signal_stack;
+
+            #if STACK_DIRECTION
+            # define find_stack_direction(ptr) STACK_DIRECTION
+            #else
+            static int
+            find_stack_direction (char const *addr)
+            {
+              char dummy;
+              return (! addr ? find_stack_direction (&dummy)
+                      : addr < &dummy ? 1 : -1);
+            }
+            #endif
+
+            static void
+            segv_handler (int signo, siginfo_t *info, void *context)
+            {
+              if (0 < info->si_code)
+                {
+                  /* For XSI heuristics to work, we need uc_stack to describe
+                     the interrupted stack (as on Solaris), and not the
+                     currently executing stack (as on Linux).  */
+                  ucontext_t const *user_context = context;
+                  char const *stack_min = user_context->uc_stack.ss_sp;
+                  size_t stack_size = user_context->uc_stack.ss_size;
+                  char const *faulting_address = info->si_addr;
+                  size_t s = faulting_address - stack_min;
+                  size_t page_size = sysconf (_SC_PAGESIZE);
+                  if (find_stack_direction (0) < 0)
+                    s += page_size;
+                  if (s < stack_size + page_size)
+                    _exit (0);
+                }
+
+              _exit (1);
+            }
+
+            static int
+            c_stack_action ()
+            {
+              stack_t st;
+              struct sigaction act;
+              int r;
+
+              st.ss_flags = 0;
+              /* Use the midpoint to avoid Irix sigaltstack bug.  */
+              st.ss_sp = alternate_signal_stack.buffer + SIGSTKSZ;
+              st.ss_size = SIGSTKSZ;
+              r = sigaltstack (&st, 0);
+              if (r != 0)
+                return r;
+
+              sigemptyset (&act.sa_mask);
+              act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND | SA_SIGINFO;
+              act.sa_sigaction = segv_handler;
+              #if FAULT_YIELDS_SIGBUS
+              if (sigaction (SIGBUS, &act, 0) < 0)
+                return -1;
+              #endif
+              return sigaction (SIGSEGV, &act, 0);
+            }
+            static volatile int *
+            recurse_1 (volatile int n, volatile int *p)
+            {
+              if (n >= 0)
+                *recurse_1 (n + 1, p) += n;
+              return p;
+            }
+            static int
+            recurse (volatile int n)
+            {
+              int sum = 0;
+              return *recurse_1 (n, &sum);
+            }
+            int
+            main ()
+            {
+              #if HAVE_SETRLIMIT && defined RLIMIT_STACK
+              /* Before starting the endless recursion, try to be friendly
+                 to the user's machine.  On some Linux 2.2.x systems, there
+                 is no stack limit for user processes at all.  We don't want
+                 to kill such systems.  */
+              struct rlimit rl;
+              rl.rlim_cur = rl.rlim_max = 0x100000; /* 1 MB */
+              setrlimit (RLIMIT_STACK, &rl);
+              #endif
+
+              return c_stack_action () || recurse (0);
+            }
+           ]])],
 	[ac_cv_sys_xsi_stack_overflow_heuristic=yes],
 	[ac_cv_sys_xsi_stack_overflow_heuristic=no],
 	[ac_cv_sys_xsi_stack_overflow_heuristic=cross-compiling])])