X-Git-Url: http://erislabs.net/gitweb/?a=blobdiff_plain;f=m4%2Fc-stack.m4;h=dc6ce880a93c527dc9d956ea446e4c1dbb4d4077;hb=781cacd451d6fdd0f8b9c03c9651726f3cac8743;hp=2a89696a9c7227ad957901d55d5d587047f7498c;hpb=72be0be47bd5cb29c0c0716df6722e46257e26ad;p=gnulib.git diff --git a/m4/c-stack.m4 b/m4/c-stack.m4 index 2a89696a9..dc6ce880a 100644 --- a/m4/c-stack.m4 +++ b/m4/c-stack.m4 @@ -1,17 +1,16 @@ # Check prerequisites for compiling lib/c-stack.c. -# Copyright (C) 2002, 2003, 2004, 2008, 2009 Free Software Foundation, Inc. +# Copyright (C) 2002-2004, 2008-2014 Free Software Foundation, Inc. # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # Written by Paul Eggert. -# serial 10 +# serial 15 AC_DEFUN([AC_SYS_XSI_STACK_OVERFLOW_HEURISTIC], - [# for STACK_DIRECTION - AC_REQUIRE([AC_FUNC_ALLOCA]) + [ AC_REQUIRE([AC_CANONICAL_HOST]) AC_CHECK_FUNCS_ONCE([setrlimit]) AC_CHECK_HEADERS_ONCE([ucontext.h]) @@ -20,11 +19,11 @@ AC_DEFUN([AC_SYS_XSI_STACK_OVERFLOW_HEURISTIC], dnl is accessed, or when the stack overflows. dnl Either { SIGSEGV } or { SIGSEGV, SIGBUS }. case "$host_os" in - sunos4* | freebsd* | dragonfly* | openbsd* | netbsd* | kfreebsd* | knetbsd*) # BSD systems + sunos4* | freebsd* | dragonfly* | openbsd* | mirbsd* | netbsd* | kfreebsd* | knetbsd*) # BSD systems FAULT_YIELDS_SIGBUS=1 ;; hpux*) # HP-UX FAULT_YIELDS_SIGBUS=1 ;; - macos* | darwin*) # MacOS X + macos* | darwin*) # Mac OS X FAULT_YIELDS_SIGBUS=1 ;; gnu*) # Hurd FAULT_YIELDS_SIGBUS=1 ;; @@ -76,16 +75,18 @@ AC_DEFUN([AC_SYS_XSI_STACK_OVERFLOW_HEURISTIC], st.ss_size = SIGSTKSZ; r = sigaltstack (&st, 0); if (r != 0) - return r; + return 1; 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; + return 2; #endif - return sigaction (SIGSEGV, &act, 0); + if (sigaction (SIGSEGV, &act, 0) < 0) + return 3; + return 0; } static volatile int * recurse_1 (volatile int n, volatile int *p) @@ -103,6 +104,7 @@ AC_DEFUN([AC_SYS_XSI_STACK_OVERFLOW_HEURISTIC], int main () { + int result; #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 @@ -113,12 +115,15 @@ AC_DEFUN([AC_SYS_XSI_STACK_OVERFLOW_HEURISTIC], setrlimit (RLIMIT_STACK, &rl); #endif - return c_stack_action () || recurse (0); + result = c_stack_action (); + if (result != 0) + return result; + return recurse (0); } ]])], - [ac_cv_sys_stack_overflow_works=yes], - [ac_cv_sys_stack_overflow_works=no], - [ac_cv_sys_stack_overflow_works=cross-compiling])]) + [ac_cv_sys_stack_overflow_works=yes], + [ac_cv_sys_stack_overflow_works=no], + [ac_cv_sys_stack_overflow_works=cross-compiling])]) if test $ac_cv_sys_stack_overflow_works = yes; then AC_DEFINE([HAVE_STACK_OVERFLOW_HANDLING], [1], @@ -132,7 +137,7 @@ AC_DEFUN([AC_SYS_XSI_STACK_OVERFLOW_HEURISTIC], AC_CACHE_CHECK([for correct stack_t interpretation], [gl_cv_sigaltstack_low_base], [ AC_RUN_IFELSE([ - AC_LANG_SOURCE([[ + AC_LANG_SOURCE([[ #include #include #if HAVE_SYS_SIGNAL_H @@ -176,16 +181,16 @@ int main () exit(3); /* Provoke a SIGSEGV. */ raise (SIGSEGV); - exit (3); + exit (4); }]])], [gl_cv_sigaltstack_low_base=yes], [gl_cv_sigaltstack_low_base=no], [gl_cv_sigaltstack_low_base=cross-compiling])]) if test "$gl_cv_sigaltstack_low_base" = no; then AC_DEFINE([SIGALTSTACK_SS_REVERSED], [1], - [Define if sigaltstack() interprets the stack_t.ss_sp field - incorrectly, as the highest address of the alternate stack range - rather than as the lowest address.]) + [Define if sigaltstack() interprets the stack_t.ss_sp field + incorrectly, as the highest address of the alternate stack range + rather than as the lowest address.]) fi AC_CACHE_CHECK([for precise C stack overflow detection], @@ -244,9 +249,9 @@ int main () s += page_size; if (s < stack_size + page_size) _exit (0); + _exit (4); } - - _exit (1); + _exit (5); } static int @@ -262,16 +267,18 @@ int main () st.ss_size = SIGSTKSZ; r = sigaltstack (&st, 0); if (r != 0) - return r; + return 1; 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; + return 2; #endif - return sigaction (SIGSEGV, &act, 0); + if (sigaction (SIGSEGV, &act, 0) < 0) + return 3; + return 0; } static volatile int * recurse_1 (volatile int n, volatile int *p) @@ -289,6 +296,7 @@ int main () int main () { + int result; #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 @@ -299,22 +307,25 @@ int main () setrlimit (RLIMIT_STACK, &rl); #endif - return c_stack_action () || recurse (0); + result = c_stack_action (); + if (result != 0) + return result; + return 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])]) + [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])]) if test $ac_cv_sys_xsi_stack_overflow_heuristic = yes; then AC_DEFINE([HAVE_XSI_STACK_OVERFLOW_HEURISTIC], [1], [Define to 1 if extending the stack slightly past the limit causes - a SIGSEGV, and an alternate stack can be established with sigaltstack, - and the signal handler is passed a context that specifies the - run time stack. This behavior is defined by POSIX 1003.1-2001 - with the X/Open System Interface (XSI) option - and is a standardized way to implement a SEGV-based stack - overflow detection heuristic.]) + a SIGSEGV, and an alternate stack can be established with sigaltstack, + and the signal handler is passed a context that specifies the + run time stack. This behavior is defined by POSIX 1003.1-2001 + with the X/Open System Interface (XSI) option + and is a standardized way to implement a SEGV-based stack + overflow detection heuristic.]) fi fi]) @@ -327,7 +338,7 @@ AC_DEFUN([gl_PREREQ_C_STACK], AC_REQUIRE([AC_FUNC_ALLOCA]) AC_CHECK_FUNCS_ONCE([sigaltstack]) - AC_CHECK_DECLS([sigaltstack], , , [#include ]) + AC_CHECK_DECLS([sigaltstack], , , [[#include ]]) AC_CHECK_HEADERS_ONCE([unistd.h ucontext.h])