configure.ac

   1 dnl Autoconf configuration for libsigsegv.
   2 dnl Process this file with autoconf to produce a configure script.
   3 dnl
   4 dnl Copyright (C) 2002-2008  Bruno Haible <bruno@clisp.org>
   5 dnl
   6 dnl This program is free software; you can redistribute it and/or modify
   7 dnl it under the terms of the GNU General Public License as published by
   8 dnl the Free Software Foundation; either version 2, or (at your option)
   9 dnl any later version.
  10 dnl
  11 dnl This program is distributed in the hope that it will be useful,
  12 dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 dnl GNU General Public License for more details.
  15 dnl
  16 dnl You should have received a copy of the GNU General Public License
  17 dnl along with this program; if not, write to the Free Software Foundation,
  18 dnl Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19
  20 AC_PREREQ(2.62)
  21 AC_INIT
  22 AC_CONFIG_SRCDIR(src/sigsegv.h.in)
  23 AC_CONFIG_AUX_DIR([build-aux])
  24
  25 RSE_BOLD
  26
  27 { echo; echo "${term_bold}Build Tools:${term_norm}"; } >& AS_MESSAGE_FD
  28
  29 AM_INIT_AUTOMAKE(libsigsegv, 2.7-pre1)
  30 AM_CONFIG_HEADER(config.h)
  31
  32 AC_PROG_CC
  33 AC_PROG_CPP
  34
  35 AC_CANONICAL_HOST
  36 AC_MSG_CHECKING([host platform])
  37 sv_cv_host="$host"
  38 changequote(,)dnl Autoconf 2.52 brokenness
  39 case "$host_os" in
  40   linux | linux-*)
  41     kernelversion=`uname -r | sed -e 's/^\([0-9.]*\).*/\1/'`
  42     sv_cv_host=`echo $sv_cv_host | sed -e "s/linux/linux$kernelversion/"`
  43     ;;
  44 esac
  45 changequote([,])dnl Autoconf 2.52 brokenness
  46 cat > conftest.c << EOF
  47 #include <features.h>
  48 #ifdef __GNU_LIBRARY__
  49 Version __GLIBC__ . __GLIBC_MINOR__
  50 #endif
  51 EOF
  52 glibcversion=`$CPP $CPPFLAGS conftest.c 2>/dev/null | grep Version | sed -e 's/Version//' -e 's/ //g'`
  53 if test -n "$glibcversion"; then
  54   sv_cv_host="$sv_cv_host-glibc$glibcversion"
  55 fi
  56 AC_MSG_RESULT([$sv_cv_host])
  57 PLATFORM="$sv_cv_host"
  58 AC_SUBST(PLATFORM)
  59
  60 AC_PROG_INSTALL
  61
  62 LT_INIT([disable-shared])
  63
  64 # For testing cross-compilation behaviour.
  65 #cross_compiling=yes
  66
  67 { echo; echo "${term_bold}Optional Platform Environment:${term_norm}"; } >& AS_MESSAGE_FD
  68
  69 dnl Headers to be included with <signal.h>. On MacOS X (Darwin) one also
  70 dnl needs <sys/signal.h>.
  71 AC_CHECK_HEADERS([sys/signal.h])
  72
  73 dnl List of signals that are sent when an invalid virtual memory address
  74 dnl is accessed, or when the stack overflows.
  75 case "$host_os" in
  76   sunos4* | freebsd* | dragonfly* | openbsd* | netbsd* | kfreebsd* | knetbsd*)
  77     CFG_SIGNALS=signals-bsd.h ;;
  78   hpux*)
  79     CFG_SIGNALS=signals-hpux.h ;;
  80   macos* | darwin*)
  81     CFG_SIGNALS=signals-macos.h ;;
  82   gnu*)
  83     CFG_SIGNALS=signals-hurd.h ;;
  84   *)
  85     CFG_SIGNALS=signals.h ;;
  86 esac
  87 AC_DEFINE_UNQUOTED(CFG_SIGNALS, "$CFG_SIGNALS",
  88   [The name of the include file describing the fault signals.])
  89
  90 # How to determine the memory page size.
  91 SV_GETPAGESIZE
  92
  93 # How to allocate fresh memory using mmap.
  94 # (We need mmap, because mprotect() doesn't work on malloc()ed memory on
  95 # some systems.)
  96 SV_MMAP_ANON
  97
  98 # How to write a SIGSEGV handler with access to the fault address.
  99
 100 # On MacOS X 10.2 or newer, we don't need these tests, because we'll end up
 101 # using handler-macos.c anyway. If we were to perform the tests, 5 Crash Report
 102 # dialog windows would pop up.
 103 case "$host_os" in
 104   macos* | darwin[[6-9]]* | darwin[[1-9]][[0-9]]*) ;;
 105   *)
 106
 107 dnl FIXME: Put in some more known values into the third argument.
 108 SV_TRY_FAULT([POSIX], sv_cv_fault_posix,
 109   [*-*-solaris2.[7-9] | i?86-*-linux2.[4-9]* | i?86-*-freebsd[4-9]* | alpha*-dec-osf[4-9]* | *-*-hpux11* | mips-sgi-irix6*],
 110   [],
 111   [int sig, siginfo_t *sip, void *ucp],
 112   [sip->si_addr],
 113   [action.sa_sigaction = &sigsegv_handler;
 114    action.sa_flags = SA_SIGINFO;])
 115
 116 SV_TRY_FAULT([Linux/i386], sv_cv_fault_linux_i386, [i?86-*-linux2.[2-9]*],
 117   [#include <asm/sigcontext.h>],
 118   [int sig, struct sigcontext sc],
 119   [sc.cr2])
 120
 121 SV_TRY_FAULT([old Linux/i386], sv_cv_fault_linux_i386_old,
 122   [i?86-*-linux2.[2-9]*],
 123   [],
 124   [int sig, unsigned int more],
 125   [((unsigned long *) &more) [21]])
 126
 127 dnl FIXME: Put in some more known values into the third argument.
 128 SV_TRY_FAULT([Linux/m68k], sv_cv_fault_linux_m68k, [],
 129   [#include <asm/sigcontext.h>
 130 #include "$srcdir/src/fault-linux-m68k.c"],
 131   [int sig, int code, struct sigcontext *scp],
 132   [get_fault_addr (scp)])
 133
 134 dnl FIXME: Put in some more known values into the third argument.
 135 SV_TRY_FAULT([Linux/PowerPC], sv_cv_fault_linux_powerpc, [],
 136   [#include <asm/sigcontext.h>],
 137   [int sig, struct sigcontext *scp],
 138   [scp->regs->dar])
 139
 140 dnl FIXME: Put in some more known values into the third argument.
 141 SV_TRY_FAULT([Linux/HPPA], sv_cv_fault_linux_hppa, [],
 142   [],
 143   [int sig, siginfo_t *sip, void *ucp],
 144   [sip->si_ptr],
 145   [action.sa_sigaction = &sigsegv_handler;
 146    action.sa_flags = SA_SIGINFO;])
 147
 148 dnl FIXME: Put in some more known values into the third argument.
 149 SV_TRY_FAULT([BSD], sv_cv_fault_bsd, [i?86-*-freebsd[4-9]*],
 150   [],
 151   [int sig, int code, struct sigcontext *scp, void *addr],
 152   [addr])
 153
 154 dnl FIXME: Put in some more known values into the third argument.
 155 SV_TRY_FAULT([IRIX], sv_cv_fault_irix, [mips-sgi-irix6*],
 156   [],
 157   [int sig, int code, struct sigcontext *scp],
 158   [(unsigned long) scp->sc_badvaddr])
 159
 160 dnl FIXME: Put in some more known values into the third argument.
 161 SV_TRY_FAULT([HP-UX HPPA], sv_cv_fault_hpux_hppa, [hppa*-*-hpux11*],
 162   [
 163 #define USE_64BIT_REGS(mc) \
 164   (((mc).ss_flags & SS_WIDEREGS) && ((mc).ss_flags & SS_NARROWISINVALID))
 165 #define GET_CR21(mc) \
 166   (USE_64BIT_REGS(mc) ? (mc).ss_wide.ss_64.ss_cr21 : (mc).ss_narrow.ss_cr21)
 167 ],
 168   [int sig, int code, struct sigcontext *scp],
 169   [GET_CR21 (scp->sc_sl.sl_ss)])
 170
 171 dnl FIXME: Put in some more known values into the third argument.
 172 SV_TRY_FAULT([OSF/1 Alpha], sv_cv_fault_osf_alpha,
 173   [alpha*-*-osf[4-9]* | alpha*-*-linux2.[4-9]*],
 174   [],
 175   [int sig, int code, struct sigcontext *scp],
 176   [scp->sc_traparg_a0])
 177
 178 dnl FIXME: Put in some more known values into the third argument.
 179 SV_TRY_FAULT([NetBSD Alpha], sv_cv_fault_netbsd_alpha,
 180   [alpha*-*-osf[4-9]* | alpha-*-*bsd*],
 181   [#include "$srcdir/src/fault-netbsd-alpha.c"],
 182   [int sig, int code, struct sigcontext *scp],
 183   [get_fault_addr (scp)])
 184
 185 dnl FIXME: Put in some more known values into the third argument.
 186 SV_TRY_FAULT([AIX], sv_cv_fault_aix, [*-*-aix[34]*],
 187   [],
 188   [int sig, int code, struct sigcontext *scp],
 189   [scp->sc_jmpbuf.jmp_context.o_vaddr])
 190
 191 SV_TRY_FAULT([MacOSX/Darwin7 PowerPC], sv_cv_fault_macosdarwin7_ppc,
 192   [powerpc-*-darwin7*],
 193   [#include "$srcdir/src/fault-macosdarwin7-powerpc.c"],
 194   [int sig, siginfo_t *sip, ucontext_t *ucp],
 195   [get_fault_addr (sip, ucp)],
 196   [action.sa_sigaction = &sigsegv_handler;
 197    action.sa_flags = SA_SIGINFO;])
 198
 199 if test "$sv_cv_fault_macosdarwin7_ppc" != yes; then
 200 SV_TRY_FAULT([MacOSX/Darwin5 PowerPC], sv_cv_fault_macosdarwin5_ppc,
 201   [powerpc-*-darwin5*],
 202   [#include "$srcdir/src/fault-macosdarwin5-powerpc.c"],
 203   [int sig, int code, struct sigcontext *scp],
 204   [get_fault_addr (scp)])
 205 fi
 206
 207 dnl FIXME: Put in some more known values into the third argument.
 208 SV_TRY_FAULT([Hurd], sv_cv_fault_hurd, [],
 209   [],
 210   [int sig, int code, struct sigcontext *scp],
 211   [code])
 212
 213 # End of MacOS X special casing.
 214     ;;
 215 esac
 216
 217 dnl Now determine the fault handler include file.
 218 dnl We prefer the platform specific include files to the generic fault-posix.h
 219 dnl because the former often defines SIGSEGV_FAULT_STACKPOINTER.
 220 dnl Also we put the BSD test second-to-last, because the test may produce
 221 dnl false positives.
 222 CFG_HANDLER=
 223 CFG_FAULT=
 224 CFG_MACHFAULT=
 225 FAULT_CONTEXT=void
 226 FAULT_CONTEXT_INCLUDE=
 227 dnl
 228 dnl First the cases where the OS provides the fault address.
 229 dnl
 230 if test -z "$CFG_FAULT" && test "$sv_cv_fault_aix" = yes; then
 231   case "$host_cpu" in
 232     powerpc* | rs6000) CFG_FAULT=fault-aix3-powerpc.h ;;
 233     *) CFG_FAULT=fault-aix3.h ;;
 234   esac
 235   FAULT_CONTEXT='struct sigcontext'
 236 fi
 237 if test -z "$CFG_FAULT" && test "$sv_cv_fault_irix" = yes; then
 238   case "$host_cpu" in
 239     mips*) CFG_FAULT=fault-irix-mips.h ;;
 240     *) CFG_FAULT=fault-irix.h ;;
 241   esac
 242   FAULT_CONTEXT='struct sigcontext'
 243 fi
 244 if test -z "$CFG_FAULT" && test "$sv_cv_fault_hpux_hppa" = yes; then
 245   case "$host_cpu" in
 246     hppa* | parisc*) CFG_FAULT=fault-hpux-hppa.h ;;
 247     *) CFG_FAULT=fault-hpux.h ;;
 248   esac
 249   FAULT_CONTEXT='struct sigcontext'
 250 fi
 251 if test -z "$CFG_FAULT" && test "$sv_cv_fault_osf_alpha" = yes; then
 252   case "$host_cpu" in
 253     alpha*) CFG_FAULT=fault-osf-alpha.h ;;
 254     *) CFG_FAULT=fault-osf.h ;;
 255   esac
 256   FAULT_CONTEXT='struct sigcontext'
 257 fi
 258 if test -z "$CFG_FAULT" && test "$sv_cv_fault_netbsd_alpha" = yes; then
 259   case "$host_cpu" in
 260     alpha*) CFG_FAULT=fault-netbsd-alpha.h ;;
 261   esac
 262   FAULT_CONTEXT='struct sigcontext'
 263 fi
 264 if test -z "$CFG_FAULT" && test "$sv_cv_fault_linux_i386" = yes; then
 265   case "$host_cpu" in
 266     i?86 | x86_64) CFG_FAULT=fault-linux-i386.h ;;
 267   esac
 268   FAULT_CONTEXT='struct sigcontext'
 269 fi
 270 if test -z "$CFG_FAULT" && test "$sv_cv_fault_linux_i386_old" = yes; then
 271   case "$host_cpu" in
 272     i?86 | x86_64) CFG_FAULT=fault-linux-i386-old.h ;;
 273   esac
 274   FAULT_CONTEXT='struct sigcontext'
 275 fi
 276 if test -z "$CFG_FAULT" && test "$sv_cv_fault_linux_powerpc" = yes; then
 277   case "$host_cpu" in
 278     powerpc* | rs6000) CFG_FAULT=fault-linux-powerpc.h ;;
 279   esac
 280   FAULT_CONTEXT='struct sigcontext'
 281 fi
 282 if test -z "$CFG_FAULT" && test "$sv_cv_fault_linux_hppa" = yes; then
 283   case "$host_cpu" in
 284     hppa* | parisc*) CFG_FAULT=fault-linux-hppa.h ;;
 285   esac
 286 fi
 287 if test -z "$CFG_FAULT" && test "$sv_cv_fault_hurd" = yes; then
 288   case "$host_os" in
 289     netbsd*) # A false positive.
 290       ;;
 291     *)
 292       CFG_FAULT=fault-hurd.h
 293       FAULT_CONTEXT='struct sigcontext'
 294       ;;
 295   esac
 296 fi
 297 if test -z "$CFG_FAULT" && test "$sv_cv_fault_bsd" = yes; then
 298   case "$host_os" in
 299     freebsd* | dragonfly* | kfreebsd*)
 300       case "$host_cpu" in
 301         i?86 | x86_64)
 302           CFG_FAULT=fault-freebsd-i386.h
 303           FAULT_CONTEXT='struct sigcontext'
 304           ;;
 305         *)
 306           CFG_FAULT=fault-bsd.h
 307           FAULT_CONTEXT='void'
 308           ;;
 309       esac
 310       ;;
 311     *)
 312       CFG_FAULT=fault-bsd.h
 313       FAULT_CONTEXT='void'
 314       ;;
 315   esac
 316 fi
 317 if test -z "$CFG_FAULT" && test "$sv_cv_fault_posix" = yes; then
 318   case "$host_os" in
 319     openbsd*)
 320       case "$host_cpu" in
 321         i?86 | x86_64) CFG_FAULT=fault-openbsd-i386.h ;;
 322         *) CFG_FAULT=fault-openbsd.h ;;
 323       esac
 324       FAULT_CONTEXT='struct sigcontext'
 325       ;;
 326     linux*)
 327       case "$host_cpu" in
 328         ia64)
 329           CFG_FAULT=fault-linux-ia64.h
 330           FAULT_CONTEXT='struct sigcontext'
 331           ;;
 332       esac
 333       ;;
 334   esac
 335   if test -z "$CFG_FAULT"; then
 336     case "$host_os" in
 337       solaris*)
 338         case "$host_cpu" in
 339           i?86 | x86_64) CFG_FAULT=fault-solaris-i386.h ;;
 340           sparc*) CFG_FAULT=fault-solaris-sparc.h ;;
 341           *) CFG_FAULT=fault-solaris.h ;;
 342         esac
 343         ;;
 344       aix*)
 345         case "$host_cpu" in
 346           powerpc* | rs6000) CFG_FAULT=fault-aix5-powerpc.h ;;
 347           *) CFG_FAULT=fault-aix5.h ;;
 348         esac
 349         ;;
 350       netbsd*)
 351         CFG_FAULT=fault-netbsd.h
 352         ;;
 353       *)
 354         CFG_FAULT=fault-posix.h
 355         ;;
 356     esac
 357     FAULT_CONTEXT='ucontext_t'
 358     FAULT_CONTEXT_INCLUDE='#include <ucontext.h>'
 359   fi
 360 fi
 361 if test -z "$CFG_FAULT"; then
 362   case "$host_os" in
 363     macos* | darwin[[6-9]]* | darwin[[1-9]][[0-9]]*)
 364       case "$host_cpu" in
 365         powerpc* | rs6000 | i?86 | x86_64)
 366           CFG_MACHFAULT=machfault-macos.h
 367           FAULT_CONTEXT_INCLUDE='#include <signal.h>
 368 #include <mach/thread_status.h>
 369 #if defined __ppc64__
 370 #define sigsegv_thread_state_t ppc_thread_state64_t
 371 #elif defined __ppc__
 372 #define sigsegv_thread_state_t ppc_thread_state_t
 373 #endif
 374 #if defined __x86_64__
 375 #define sigsegv_thread_state_t x86_thread_state64_t
 376 #elif defined __i386__
 377 #if defined x86_THREAD_STATE32
 378 #define sigsegv_thread_state_t x86_thread_state32_t
 379 #else
 380 #define sigsegv_thread_state_t i386_thread_state_t
 381 #endif
 382 #endif'
 383           FAULT_CONTEXT='sigsegv_thread_state_t'
 384           ;;
 385       esac
 386       if test -n "$CFG_MACHFAULT"; then
 387         CFG_HANDLER=handler-macos.c
 388         CFG_FAULT=fault-macos.h # nonexistent, just a dummy
 389       fi
 390       ;;
 391   esac
 392 fi
 393 dnl
 394 dnl Next, the cases where there is a hairy CPU dependent way to get the
 395 dnl fault address.
 396 dnl
 397 if test -z "$CFG_FAULT" && test "$sv_cv_fault_linux_m68k" = yes; then
 398   case "$host_cpu" in
 399     m68*)
 400       CFG_FAULT=fault-linux-m68k.h
 401       FAULT_CONTEXT='struct sigcontext'
 402       ;;
 403   esac
 404 fi
 405 if test -z "$CFG_FAULT" && test "$sv_cv_fault_macosdarwin7_ppc" = yes; then
 406   case "$host_cpu" in
 407     powerpc* | rs6000)
 408       CFG_FAULT=fault-macosdarwin7-powerpc.h
 409       FAULT_CONTEXT='ucontext_t'
 410       FAULT_CONTEXT_INCLUDE='#include <signal.h>
 411 #include <ucontext.h>'
 412       ;;
 413   esac
 414 fi
 415 if test -z "$CFG_FAULT" && test "$sv_cv_fault_macosdarwin5_ppc" = yes; then
 416   case "$host_cpu" in
 417     powerpc* | rs6000)
 418       CFG_FAULT=fault-macosdarwin5-powerpc.h
 419       FAULT_CONTEXT='struct sigcontext'
 420       ;;
 421   esac
 422 fi
 423 if test -z "$CFG_FAULT"; then
 424   case "$host_os" in
 425     mingw* | cygwin*)
 426       FAULT_CONTEXT='CONTEXT'
 427       FAULT_CONTEXT_INCLUDE='#include <windows.h>'
 428       CFG_FAULT=fault-win32.h # nonexistent, just a dummy
 429       ;;
 430   esac
 431 fi
 432 if test -n "$CFG_FAULT"; then
 433   sv_cv_have_sigsegv_recovery=yes
 434 else
 435   sv_cv_have_sigsegv_recovery=no
 436   dnl
 437   dnl No way to get the fault address. But other information is available.
 438   dnl
 439   case "$host_os" in
 440     linux*)
 441       case "$host_cpu" in
 442         alpha*)
 443           CFG_FAULT=fault-linux-alpha.h
 444           FAULT_CONTEXT='struct sigcontext'
 445           ;;
 446         arm* | strongarm* | xscale*)
 447           CFG_FAULT=fault-linux-arm.h
 448           FAULT_CONTEXT='struct sigcontext'
 449           ;;
 450         cris)
 451           CFG_FAULT=fault-linux-cris.h
 452           FAULT_CONTEXT='struct sigcontext'
 453           ;;
 454         mips*)
 455           CFG_FAULT=fault-linux-mips.h
 456           FAULT_CONTEXT='struct sigcontext'
 457           ;;
 458         s390*)
 459           CFG_FAULT=fault-linux-s390.h
 460           FAULT_CONTEXT='struct sigcontext'
 461           ;;
 462         sh*)
 463           CFG_FAULT=fault-linux-sh.h
 464           FAULT_CONTEXT='struct sigcontext'
 465           ;;
 466         sparc*)
 467           CFG_FAULT=fault-linux-sparc.h
 468           FAULT_CONTEXT='struct sigcontext'
 469           ;;
 470         x86_64)
 471           CFG_FAULT=fault-linux-x86_64.h
 472           FAULT_CONTEXT='struct sigcontext'
 473           ;;
 474       esac
 475       ;;
 476     beos*)
 477       case "$host_cpu" in
 478         i?86 | x86_64) CFG_FAULT=fault-beos-i386.h ;;
 479         *) CFG_FAULT=fault-beos.h ;;
 480       esac
 481       FAULT_CONTEXT='struct vregs'
 482       ;;
 483     macos* | darwin*)
 484       case "$host_cpu" in
 485         i?86 | x86_64) CFG_FAULT=fault-macos-i386.h ;;
 486       esac
 487       FAULT_CONTEXT='struct sigcontext'
 488       ;;
 489   esac
 490 fi
 491 AC_MSG_CHECKING([for the fault handler specifics])
 492 if test -n "$CFG_FAULT"; then
 493   sv_cv_fault_include=$CFG_FAULT
 494 else
 495   if test -n "$CFG_MACHFAULT"; then
 496     sv_cv_fault_include=$CFG_MACHFAULT
 497   else
 498     sv_cv_fault_include=none
 499   fi
 500 fi
 501 AC_MSG_RESULT([$sv_cv_fault_include])
 502 if test -z "$CFG_FAULT"; then
 503   CFG_FAULT=fault-none.h
 504 fi
 505 AC_DEFINE_UNQUOTED(CFG_FAULT, "$CFG_FAULT",
 506   [The name of the include file describing the fault handler.])
 507 if test -z "$CFG_MACHFAULT"; then
 508   CFG_MACHFAULT=fault-none.h
 509 fi
 510 AC_DEFINE_UNQUOTED(CFG_MACHFAULT, "$CFG_MACHFAULT",
 511   [The name of the include file describing the Mach fault handler.])
 512 AC_SUBST(FAULT_CONTEXT)
 513 AC_SUBST(FAULT_CONTEXT_INCLUDE)
 514
 515 AC_MSG_CHECKING([if the system supports catching SIGSEGV])
 516 AC_MSG_RESULT([$sv_cv_have_sigsegv_recovery])
 517 if test $sv_cv_have_sigsegv_recovery != no; then
 518   HAVE_SIGSEGV_RECOVERY=1
 519 else
 520   HAVE_SIGSEGV_RECOVERY=0
 521 fi
 522 AC_SUBST(HAVE_SIGSEGV_RECOVERY)
 523
 524 dnl The stackoverflow_context_t type depends on the CFG_FAULT include file.
 525
 526 dnl Stack direction.
 527 AC_CACHE_CHECK([for stack direction], sv_cv_stack_direction_msg, [
 528   case "$host_cpu" in
 529     dnl See the #define STACK_GROWS_DOWNWARD in gcc-3.1/gcc/config/*/*.h.
 530     a29k | \
 531     alpha* | \
 532     arc | \
 533     arm* | strongarm* | xscale* | \
 534     avr | \
 535     c1 | c2 | c32 | c34 | c38 | \
 536     clipper | \
 537     cris | \
 538     d30v | \
 539     elxsi | \
 540     fr30 | \
 541     h8300 | \
 542     i?86 | x86_64 | \
 543     i860 | \
 544     ia64 | \
 545     m32r | \
 546     m68* | \
 547     m88k | \
 548     mcore | \
 549     mips* | \
 550     mmix | \
 551     mn10200 | \
 552     mn10300 | \
 553     ns32k | \
 554     pdp11 | \
 555     pj* | \
 556     powerpc* | rs6000 | \
 557     romp | \
 558     s390* | \
 559     sh* | \
 560     sparc* | \
 561     v850 | \
 562     vax | \
 563     xtensa)
 564       sv_cv_stack_direction=-1 ;;
 565     c4x | \
 566     dsp16xx | \
 567     i960 | \
 568     hppa* | parisc* | \
 569     stormy16 | \
 570     we32k)
 571       sv_cv_stack_direction=1 ;;
 572     *)
 573       if test $cross_compiling = no; then
 574         cat > conftest.c <<EOF
 575 #include <stdio.h>
 576 int
 577 get_stack_direction ()
 578 {
 579   auto char dummy;
 580   static char *dummyaddr = (char *)0;
 581   if (dummyaddr != (char *)0)
 582     return &dummy > dummyaddr ? 1 : &dummy < dummyaddr ? -1 : 0;
 583   else
 584     {
 585       dummyaddr = &dummy;
 586       {
 587         int result = get_stack_direction ();
 588         /* The next assignment avoids tail recursion elimination
 589            (IRIX 6.4 CC).  */
 590         dummyaddr = (char *)0;
 591         return result;
 592       }
 593     }
 594 }
 595 int
 596 main ()
 597 {
 598   printf ("%d\n", get_stack_direction ());
 599   return 0;
 600 }
 601 EOF
 602         AC_TRY_EVAL(ac_link)
 603         sv_cv_stack_direction=`./conftest`
 604       else
 605         sv_cv_stack_direction=0
 606       fi
 607       ;;
 608   esac
 609   case $sv_cv_stack_direction in
 610     1)  sv_cv_stack_direction_msg="grows up";;
 611     -1) sv_cv_stack_direction_msg="grows down";;
 612     *)  sv_cv_stack_direction_msg="unknown";;
 613   esac
 614 ])
 615 AC_DEFINE_UNQUOTED(STACK_DIRECTION, [$sv_cv_stack_direction],
 616   [Define as the direction of stack growth for your system.
 617    STACK_DIRECTION > 0 => grows toward higher addresses
 618    STACK_DIRECTION < 0 => grows toward lower addresses
 619    STACK_DIRECTION = 0 => spaghetti stack.])
 620
 621 dnl Determination of the stack's virtual memory area.
 622 AC_CACHE_CHECK([for PIOCMAP in sys/procfs.h], sv_cv_procfsvma, [
 623   AC_TRY_LINK([#include <sys/procfs.h>],
 624     [int x = PIOCNMAP + PIOCMAP; prmap_t y;],
 625     sv_cv_procfsvma=yes, sv_cv_procfsvma=no)
 626 ])
 627 AC_CHECK_FUNCS([mincore])
 628 CFG_STACKVMA=
 629 if test $sv_cv_procfsvma = yes; then
 630   CFG_STACKVMA=stackvma-procfs.c
 631 else
 632   case "$host_os" in
 633     linux*)                CFG_STACKVMA=stackvma-linux.c ;;
 634     freebsd* | dragonfly*) CFG_STACKVMA=stackvma-freebsd.c ;;
 635     beos*)                 CFG_STACKVMA=stackvma-beos.c ;;
 636     macos* | darwin*)      CFG_STACKVMA=stackvma-mach.c ;;
 637   esac
 638 fi
 639 if test -z "$CFG_STACKVMA" && test $ac_cv_func_mincore = yes; then
 640   CFG_STACKVMA=stackvma-mincore.c
 641 fi
 642 if test -n "$CFG_STACKVMA"; then
 643   AC_DEFINE(HAVE_STACKVMA, 1,
 644     [Define if CFG_STACKVMA is set to a nontrivial source file.])
 645 else
 646   CFG_STACKVMA=stackvma-none.c
 647 fi
 648 AC_DEFINE_UNQUOTED(CFG_STACKVMA, "$CFG_STACKVMA",
 649   [The name of the file determining the stack virtual memory area.])
 650 AC_SUBST(CFG_STACKVMA)
 651
 652 AC_CHECK_FUNCS([getrlimit setrlimit])
 653
 654 dnl Catching stack overflow requires an alternate signal stack.
 655 dnl The old "install a guard page" trick would be unreliable, because
 656 dnl we don't know where exactly to place the guard page.
 657 SV_SIGALTSTACK
 658
 659 AC_CACHE_CHECK([if the system supports catching stack overflow],
 660                sv_cv_have_stack_overflow_recovery,
 661 [
 662   dnl On Mach, it requires a machfault-*.h (see src/handler-macos.c).
 663   dnl On Unix, it requires either sigaltstack() or the BeOS set_signal_stack()
 664   dnl function, and on Unix it requires a fault-*.h or a stackvma-*.c with
 665   dnl certain properties (see src/handler-unix.c).
 666   if test "$CFG_MACHFAULT" != fault-none.h; then
 667     sv_cv_have_stack_overflow_recovery=yes
 668   else
 669     if test "$sv_cv_sigaltstack" != no; then
 670       sv_cv_have_stack_overflow_recovery=maybe
 671     else
 672       case "$host_os" in
 673         beos*) sv_cv_have_stack_overflow_recovery=maybe ;;
 674         mingw* | cygwin*) sv_cv_have_stack_overflow_recovery=yes ;;
 675         *) sv_cv_have_stack_overflow_recovery=no ;;
 676       esac
 677     fi
 678   fi
 679   if test $sv_cv_have_stack_overflow_recovery = maybe; then
 680     if test -n "$CFG_FAULT"; then
 681       AC_EGREP_CPP([xyzzy], [
 682 #include "$srcdir/src/$CFG_FAULT"
 683 #ifdef SIGSEGV_FAULT_HANDLER_ARGLIST
 684 #ifdef SIGSEGV_FAULT_ADDRESS
 685 xyzzy
 686 #endif
 687 #endif
 688 ], [condA=true], [condA=false])
 689     else
 690       condA=false
 691     fi
 692     if test -n "$CFG_FAULT"; then
 693       AC_EGREP_CPP([xyzzy], [
 694 #include "$srcdir/src/$CFG_FAULT"
 695 #ifdef SIGSEGV_FAULT_HANDLER_ARGLIST
 696 #ifdef SIGSEGV_FAULT_STACKPOINTER
 697 xyzzy
 698 #endif
 699 #endif
 700 ], [condB=true], [condB=false])
 701     else
 702       condB=false
 703     fi
 704     if test "$CFG_STACKVMA" != "stackvma-none.c"; then
 705       condC=true
 706     else
 707       condC=false
 708     fi
 709     if { $condA && $condB; } || { $condA && $condC; } || { $condB && $condC; }; then
 710       sv_cv_have_stack_overflow_recovery=yes
 711     else
 712       sv_cv_have_stack_overflow_recovery=no
 713     fi
 714   fi
 715 ])
 716 if test $sv_cv_have_stack_overflow_recovery != no; then
 717   HAVE_STACK_OVERFLOW_RECOVERY=1
 718 else
 719   HAVE_STACK_OVERFLOW_RECOVERY=0
 720 fi
 721 AC_SUBST(HAVE_STACK_OVERFLOW_RECOVERY)
 722
 723 # How to longjmp out of a signal handler, in such a way that the
 724 # alternate signal stack remains functional.
 725
 726 # On MacOS X 10.2 or newer, we don't need these tests, because we'll end up
 727 # using handler-macos.c anyway. If we were to perform the tests, 2 Crash Report
 728 # dialog windows would pop up.
 729 case "$host_os" in
 730   macos* | darwin[[6-9]]* | darwin[[1-9]][[0-9]]*) ;;
 731   *)
 732
 733 dnl FIXME: Put in some more known values into the third argument.
 734 SV_TRY_LEAVE_HANDLER_LONGJMP([], sv_cv_leave_handler_longjmp,
 735   [*-*-osf[4-9]* | *-*-hpux11* | *-*-linux2.[2-9]*],
 736   [], [])
 737
 738 dnl FIXME: Put in some more known values into the third argument.
 739 SV_TRY_LEAVE_HANDLER_LONGJMP([ and sigaltstack],
 740   sv_cv_leave_handler_longjmp_sigaltstack,
 741   [*-*-freebsd*],
 742   [
 743 #ifndef SS_ONSTACK
 744 #define SS_ONSTACK SA_ONSTACK
 745 #endif
 746   ],
 747   [stack_t ss;
 748    if (sigaltstack (NULL, &ss) >= 0)
 749      {
 750        ss.ss_flags &= ~SS_ONSTACK;
 751        sigaltstack (&ss, NULL);
 752      }
 753   ])
 754
 755 dnl FIXME: Put in some more known values into the third argument.
 756 SV_TRY_LEAVE_HANDLER_LONGJMP([ and setcontext],
 757   sv_cv_leave_handler_longjmp_setcontext,
 758   [*-*-irix* | *-*-solaris*],
 759   [#include <ucontext.h>
 760 #ifndef SS_ONSTACK
 761 #define SS_ONSTACK SA_ONSTACK
 762 #endif
 763   ],
 764   [static int fl;
 765    static ucontext_t uc;
 766    fl = 0;
 767    if (getcontext (&uc) >= 0)
 768      if (fl == 0)
 769        if (uc.uc_stack.ss_flags & SS_ONSTACK)
 770          {
 771            uc.uc_stack.ss_flags &= ~SS_ONSTACK;
 772            fl = 1;
 773            setcontext (&uc);
 774          }
 775   ])
 776
 777 # End of MacOS X special casing.
 778     ;;
 779 esac
 780
 781 # How to siglongjmp out of a signal handler, in such a way that the
 782 # alternate signal stack remains functional.
 783
 784 # On MacOS X 10.2 or newer, we don't need these tests, because we'll end up
 785 # using handler-macos.c anyway. If we were to perform the tests, 2 Crash Report
 786 # dialog windows would pop up.
 787 case "$host_os" in
 788   macos* | darwin[[6-9]]* | darwin[[1-9]][[0-9]]*) ;;
 789   *)
 790
 791 dnl FIXME: Put in some more known values into the third argument.
 792 SV_TRY_LEAVE_HANDLER_SIGLONGJMP([], sv_cv_leave_handler_siglongjmp,
 793   [*-*-osf[4-9]* | *-*-hpux11* | *-*-linux2.[2-9]* | *-*-irix* | *-*-solaris*],
 794   [], [])
 795
 796 dnl FIXME: Put in some more known values into the third argument.
 797 SV_TRY_LEAVE_HANDLER_SIGLONGJMP([ and sigaltstack],
 798   sv_cv_leave_handler_siglongjmp_sigaltstack,
 799   [*-*-freebsd*],
 800   [
 801 #ifndef SS_ONSTACK
 802 #define SS_ONSTACK SA_ONSTACK
 803 #endif
 804   ],
 805   [stack_t ss;
 806    if (sigaltstack (NULL, &ss) >= 0)
 807      {
 808        ss.ss_flags &= ~SS_ONSTACK;
 809        sigaltstack (&ss, NULL);
 810      }
 811   ])
 812
 813 dnl FIXME: Put in some more known values into the third argument.
 814 SV_TRY_LEAVE_HANDLER_SIGLONGJMP([ and setcontext],
 815   sv_cv_leave_handler_siglongjmp_setcontext,
 816   [],
 817   [#include <ucontext.h>
 818 #ifndef SS_ONSTACK
 819 #define SS_ONSTACK SA_ONSTACK
 820 #endif
 821   ],
 822   [static int fl;
 823    static ucontext_t uc;
 824    fl = 0;
 825    if (getcontext(&uc) >= 0)
 826      if (fl == 0)
 827        if (uc.uc_stack.ss_flags & SS_ONSTACK)
 828          {
 829            uc.uc_stack.ss_flags &= ~SS_ONSTACK;
 830            fl = 1;
 831            setcontext(&uc);
 832          }
 833   ])
 834
 835 # End of MacOS X special casing.
 836     ;;
 837 esac
 838
 839 CFG_LEAVE=
 840 if test "$sv_cv_leave_handler_longjmp" != no; then
 841   CFG_LEAVE=leave-nop.c
 842 else
 843   if test "$sv_cv_leave_handler_longjmp_sigaltstack" != no; then
 844     CFG_LEAVE=leave-sigaltstack.c
 845   else
 846     if test "$sv_cv_leave_handler_longjmp_setcontext" != no; then
 847       CFG_LEAVE=leave-setcontext.c
 848     fi
 849   fi
 850 fi
 851 case "$host_os" in
 852   # On BeOS, the 6 tests fail because sigaltstack() doesn't exist.
 853   # If one uses set_signal_stack() instead of sigaltstack(), the first
 854   # test actually works. i.e. sv_cv_leave_handler_longjmp would be 'yes'.
 855   beos*) CFG_LEAVE=leave-nop.c ;;
 856 esac
 857 if test -z "$CFG_LEAVE"; then
 858   CFG_LEAVE=leave-none.c
 859 fi
 860 AC_DEFINE_UNQUOTED(CFG_LEAVE, "$CFG_LEAVE",
 861   [The name of the file implementing sigsegv_reset_onstack_flag.])
 862 AC_SUBST(CFG_LEAVE)
 863
 864 case "$host_os" in
 865   mingw* | cygwin*) CFG_HANDLER=handler-win32.c ;;
 866   *)
 867     if test -z "$CFG_HANDLER"; then
 868       if test $sv_cv_have_sigsegv_recovery = no \
 869          && test $sv_cv_have_stack_overflow_recovery = no; then
 870         CFG_HANDLER=handler-none.c
 871       else
 872         CFG_HANDLER=handler-unix.c
 873       fi
 874     fi
 875     ;;
 876 esac
 877 AC_DEFINE_UNQUOTED(CFG_HANDLER, "$CFG_HANDLER",
 878   [The name of the file implementing the handler functionality.])
 879 AC_SUBST(CFG_HANDLER)
 880
 881 { echo; echo "${term_bold}Build Parameters:${term_norm}"; } >& AS_MESSAGE_FD
 882
 883 dnl Relocatability is a nop for this package.
 884 AC_RELOCATABLE_NOP
 885
 886 { echo; echo "${term_bold}Output Substitution:${term_norm}"; } >& AS_MESSAGE_FD
 887
 888 dnl AC_OUTPUT(Makefile)
 889 AC_OUTPUT([Makefile
 890            src/Makefile src/sigsegv.h
 891            tests/Makefile])
 892
 893 { echo; echo "Now please type '${term_bold}make${term_norm}' to compile. Good luck."; echo; } >& AS_MESSAGE_FD