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-2011  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.10])
  30 AM_CONFIG_HEADER([config.h])
  31
  32 dnl Override automake's tar command used for creating distributions.
  33 am__tar='${AMTAR} chf - --owner=root --group=root "$$tardir"'
  34
  35 AC_PROG_CC
  36 AC_PROG_CPP
  37
  38 AC_CANONICAL_HOST
  39
  40
  41 dnl ========================== Determine PLATFORM ==========================
  42 dnl Requires AC_CANONICAL_HOST.
  43 dnl PLATFORM is a modified config.guess triple that is supposed to contain
  44 dnl the bits of information which influence the configuration or functioning
  45 dnl of catching faults.
  46
  47 AC_MSG_CHECKING([host platform])
  48 sv_cv_host="$host"
  49 changequote(,)dnl Autoconf 2.52 brokenness
  50 case "$host_os" in
  51   linux | linux-*)
  52     kernelversion=`uname -r | sed -e 's/^\([0-9.]*\).*/\1/'`
  53     sv_cv_host=`echo $sv_cv_host | sed -e "s/linux/linux$kernelversion/"`
  54     ;;
  55 esac
  56 changequote([,])dnl Autoconf 2.52 brokenness
  57 cat > conftest.c << EOF
  58 #include <features.h>
  59 #ifdef __GNU_LIBRARY__
  60 Version __GLIBC__ . __GLIBC_MINOR__
  61 #endif
  62 EOF
  63 glibcversion=`$CPP $CPPFLAGS conftest.c 2>/dev/null | grep Version | sed -e 's/Version//' -e 's/ //g'`
  64 if test -n "$glibcversion"; then
  65   sv_cv_host="$sv_cv_host-glibc$glibcversion"
  66 fi
  67 AC_MSG_RESULT([$sv_cv_host])
  68 PLATFORM="$sv_cv_host"
  69 AC_SUBST([PLATFORM])
  70
  71 dnl ========================== Done with PLATFORM ==========================
  72
  73
  74 AC_PROG_INSTALL
  75
  76 LT_INIT([disable-shared])
  77
  78 # For testing cross-compilation behaviour.
  79 #cross_compiling=yes
  80
  81 { echo; echo "${term_bold}Optional Platform Environment:${term_norm}"; } >& AS_MESSAGE_FD
  82
  83 dnl Headers to be included with <signal.h>. On MacOS X (Darwin) one also
  84 dnl needs <sys/signal.h>.
  85 AC_CHECK_HEADERS([sys/signal.h])
  86
  87
  88 dnl ========================== Determine CFG_SIGNALS ==========================
  89 dnl Requires AC_CANONICAL_HOST.
  90
  91 dnl List of signals that are sent when an invalid virtual memory address
  92 dnl is accessed, or when the stack overflows.
  93 case "$host_os" in
  94   sunos4* | freebsd* | dragonfly* | openbsd* | netbsd* | kfreebsd* | knetbsd*)
  95     CFG_SIGNALS=signals-bsd.h ;;
  96   hpux*)
  97     CFG_SIGNALS=signals-hpux.h ;;
  98   macos* | darwin*)
  99     CFG_SIGNALS=signals-macos.h ;;
 100   gnu*)
 101     CFG_SIGNALS=signals-hurd.h ;;
 102   *)
 103     CFG_SIGNALS=signals.h ;;
 104 esac
 105 AC_DEFINE_UNQUOTED([CFG_SIGNALS], ["$CFG_SIGNALS"],
 106   [The name of the include file describing the fault signals.])
 107
 108 dnl ========================== Done with CFG_SIGNALS ==========================
 109
 110
 111 # How to determine the memory page size.
 112 SV_GETPAGESIZE
 113
 114 # How to allocate fresh memory using mmap.
 115 # (We need mmap, because mprotect() doesn't work on malloc()ed memory on
 116 # some systems.)
 117 SV_MMAP_ANON
 118
 119
 120 dnl ================== Determine CFG_HANDLER partially,     ==================
 121 dnl ================== CFG_FAULT, CFG_MACHFAULT,            ==================
 122 dnl ================== FAULT_CONTEXT, FAULT_CONTEXT_INCLUDE ==================
 123 dnl Requires AC_CANONICAL_HOST, SV_MMAP_ANON.
 124
 125 # How to write a SIGSEGV handler with access to the fault address.
 126
 127 # On MacOS X 10.2 or newer, we don't need these tests, because we'll end up
 128 # using handler-macos.c anyway. If we were to perform the tests, 5 Crash Report
 129 # dialog windows would pop up.
 130 case "$host_os" in
 131   macos* | darwin[[6-9]]* | darwin[[1-9]][[0-9]]*) ;;
 132   *)
 133
 134 dnl FIXME: Put in some more known values into the third argument.
 135 SV_TRY_FAULT([POSIX], sv_cv_fault_posix,
 136   [*-*-solaris2.[7-9] | i?86-*-linux2.[4-9]* | i?86-*-freebsd[4-9]* | i?86-*-mirbsd1[0-9] | alpha*-dec-osf[4-9]* | *-*-hpux11* | mips-sgi-irix6*],
 137   [],
 138   [int sig, siginfo_t *sip, void *ucp],
 139   [sip->si_addr],
 140   [action.sa_sigaction = &sigsegv_handler;
 141    action.sa_flags = SA_SIGINFO;])
 142
 143 SV_TRY_FAULT([Linux/i386], sv_cv_fault_linux_i386, [i?86-*-linux2.[2-9]*],
 144   [#include <asm/sigcontext.h>],
 145   [int sig, struct sigcontext sc],
 146   [sc.cr2])
 147
 148 SV_TRY_FAULT([old Linux/i386], sv_cv_fault_linux_i386_old,
 149   [i?86-*-linux2.[2-9]*],
 150   [],
 151   [int sig, unsigned int more],
 152   [((unsigned long *) &more) [21]])
 153
 154 dnl FIXME: Put in some more known values into the third argument.
 155 SV_TRY_FAULT([Linux/m68k], sv_cv_fault_linux_m68k, [],
 156   [#include <asm/sigcontext.h>
 157 #include "$srcdir/src/fault-linux-m68k-old.c"],
 158   [int sig, int code, struct sigcontext *scp],
 159   [get_fault_addr (scp)])
 160
 161 dnl FIXME: Put in some more known values into the third argument.
 162 SV_TRY_FAULT([Linux/PowerPC], sv_cv_fault_linux_powerpc, [],
 163   [#include <asm/sigcontext.h>],
 164   [int sig, struct sigcontext *scp],
 165   [scp->regs->dar])
 166
 167 dnl FIXME: Put in some more known values into the third argument.
 168 SV_TRY_FAULT([Linux/HPPA], sv_cv_fault_linux_hppa, [],
 169   [],
 170   [int sig, siginfo_t *sip, void *ucp],
 171   [sip->si_ptr],
 172   [action.sa_sigaction = &sigsegv_handler;
 173    action.sa_flags = SA_SIGINFO;])
 174
 175 dnl FIXME: Put in some more known values into the third argument.
 176 SV_TRY_FAULT([BSD], sv_cv_fault_bsd, [i?86-*-freebsd[4-9]*],
 177   [],
 178   [int sig, int code, struct sigcontext *scp, void *addr],
 179   [addr])
 180
 181 dnl FIXME: Put in some more known values into the third argument.
 182 SV_TRY_FAULT([IRIX], sv_cv_fault_irix, [mips-sgi-irix6*],
 183   [],
 184   [int sig, int code, struct sigcontext *scp],
 185   [(unsigned long) scp->sc_badvaddr])
 186
 187 dnl FIXME: Put in some more known values into the third argument.
 188 SV_TRY_FAULT([HP-UX HPPA], sv_cv_fault_hpux_hppa, [hppa*-*-hpux11*],
 189   [
 190 #define USE_64BIT_REGS(mc) \
 191   (((mc).ss_flags & SS_WIDEREGS) && ((mc).ss_flags & SS_NARROWISINVALID))
 192 #define GET_CR21(mc) \
 193   (USE_64BIT_REGS(mc) ? (mc).ss_wide.ss_64.ss_cr21 : (mc).ss_narrow.ss_cr21)
 194 ],
 195   [int sig, int code, struct sigcontext *scp],
 196   [GET_CR21 (scp->sc_sl.sl_ss)])
 197
 198 dnl FIXME: Put in some more known values into the third argument.
 199 SV_TRY_FAULT([OSF/1 Alpha], sv_cv_fault_osf_alpha,
 200   [alpha*-*-osf[4-9]* | alpha*-*-linux2.[4-9]*],
 201   [],
 202   [int sig, int code, struct sigcontext *scp],
 203   [scp->sc_traparg_a0])
 204
 205 dnl FIXME: Put in some more known values into the third argument.
 206 SV_TRY_FAULT([NetBSD Alpha], sv_cv_fault_netbsd_alpha,
 207   [alpha*-*-osf[4-9]* | alpha-*-*bsd*],
 208   [#include "$srcdir/src/fault-netbsd-alpha.c"],
 209   [int sig, int code, struct sigcontext *scp],
 210   [get_fault_addr (scp)])
 211
 212 dnl FIXME: Put in some more known values into the third argument.
 213 SV_TRY_FAULT([AIX], sv_cv_fault_aix, [*-*-aix[34]*],
 214   [],
 215   [int sig, int code, struct sigcontext *scp],
 216   [scp->sc_jmpbuf.jmp_context.o_vaddr])
 217
 218 SV_TRY_FAULT([MacOSX/Darwin7 PowerPC], sv_cv_fault_macosdarwin7_ppc,
 219   [powerpc-*-darwin7*],
 220   [#include "$srcdir/src/fault-macosdarwin7-powerpc.c"],
 221   [int sig, siginfo_t *sip, ucontext_t *ucp],
 222   [get_fault_addr (sip, ucp)],
 223   [action.sa_sigaction = &sigsegv_handler;
 224    action.sa_flags = SA_SIGINFO;])
 225
 226 if test "$sv_cv_fault_macosdarwin7_ppc" != yes; then
 227 SV_TRY_FAULT([MacOSX/Darwin5 PowerPC], sv_cv_fault_macosdarwin5_ppc,
 228   [powerpc-*-darwin5*],
 229   [#include "$srcdir/src/fault-macosdarwin5-powerpc.c"],
 230   [int sig, int code, struct sigcontext *scp],
 231   [get_fault_addr (scp)])
 232 fi
 233
 234 dnl FIXME: Put in some more known values into the third argument.
 235 SV_TRY_FAULT([Hurd], sv_cv_fault_hurd, [],
 236   [],
 237   [int sig, int code, struct sigcontext *scp],
 238   [code])
 239
 240 # End of MacOS X special casing.
 241     ;;
 242 esac
 243
 244 dnl Now determine the fault handler include file.
 245 dnl We prefer the platform specific include files to the generic fault-posix.h
 246 dnl because the former often defines SIGSEGV_FAULT_STACKPOINTER.
 247 dnl Also we put the BSD test second-to-last, because the test may produce
 248 dnl false positives.
 249 CFG_HANDLER=
 250 CFG_FAULT=
 251 CFG_MACHFAULT=
 252 FAULT_CONTEXT=void
 253 FAULT_CONTEXT_INCLUDE=
 254 dnl
 255 dnl First the cases where the OS provides the fault address.
 256 dnl
 257 if test -z "$CFG_FAULT" && test "$sv_cv_fault_aix" = yes; then
 258   case "$host_cpu" in
 259     powerpc* | rs6000) CFG_FAULT=fault-aix3-powerpc.h ;;
 260     *) CFG_FAULT=fault-aix3.h ;;
 261   esac
 262   FAULT_CONTEXT='struct sigcontext'
 263 fi
 264 if test -z "$CFG_FAULT" && test "$sv_cv_fault_irix" = yes; then
 265   case "$host_cpu" in
 266     mips*) CFG_FAULT=fault-irix-mips.h ;;
 267     *) CFG_FAULT=fault-irix.h ;;
 268   esac
 269   FAULT_CONTEXT='struct sigcontext'
 270 fi
 271 if test -z "$CFG_FAULT" && test "$sv_cv_fault_hpux_hppa" = yes; then
 272   case "$host_cpu" in
 273     hppa* | parisc*) CFG_FAULT=fault-hpux-hppa.h ;;
 274     *) CFG_FAULT=fault-hpux.h ;;
 275   esac
 276   FAULT_CONTEXT='struct sigcontext'
 277 fi
 278 if test -z "$CFG_FAULT" && test "$sv_cv_fault_osf_alpha" = yes; then
 279   case "$host_cpu" in
 280     alpha*) CFG_FAULT=fault-osf-alpha.h ;;
 281     *) CFG_FAULT=fault-osf.h ;;
 282   esac
 283   FAULT_CONTEXT='struct sigcontext'
 284 fi
 285 if test -z "$CFG_FAULT" && test "$sv_cv_fault_netbsd_alpha" = yes; then
 286   case "$host_cpu" in
 287     alpha*) CFG_FAULT=fault-netbsd-alpha.h ;;
 288   esac
 289   FAULT_CONTEXT='struct sigcontext'
 290 fi
 291 if test -z "$CFG_FAULT" && test "$sv_cv_fault_hurd" = yes; then
 292   case "$host_os" in
 293     netbsd*) # A false positive.
 294       ;;
 295     *)
 296       CFG_FAULT=fault-hurd.h
 297       FAULT_CONTEXT='struct sigcontext'
 298       ;;
 299   esac
 300 fi
 301 if test -z "$CFG_FAULT" && test "$sv_cv_fault_bsd" = yes; then
 302   case "$host_os" in
 303     freebsd* | dragonfly* | kfreebsd*)
 304       case "$host_cpu" in
 305         i?86 | x86_64)
 306           CFG_FAULT=fault-freebsd-i386.h
 307           FAULT_CONTEXT='struct sigcontext'
 308           ;;
 309         *)
 310           CFG_FAULT=fault-bsd.h
 311           FAULT_CONTEXT='void'
 312           ;;
 313       esac
 314       ;;
 315     *)
 316       CFG_FAULT=fault-bsd.h
 317       FAULT_CONTEXT='void'
 318       ;;
 319   esac
 320 fi
 321 if test -z "$CFG_FAULT" && test "$sv_cv_fault_posix" = yes; then
 322   case "$host_os" in
 323     openbsd*)
 324       case "$host_cpu" in
 325         alpha*) CFG_FAULT=fault-openbsd-alpha.h ;;
 326         arm* | strongarm* | xscale*) CFG_FAULT=fault-openbsd-arm.h ;;
 327         hppa* | parisc*) CFG_FAULT=fault-openbsd-hppa.h ;;
 328         i?86 | x86_64) CFG_FAULT=fault-openbsd-i386.h ;;
 329         m68*) CFG_FAULT=fault-openbsd-m68k.h ;;
 330         m88k*) CFG_FAULT=fault-openbsd-m88k.h ;;
 331         mips*) CFG_FAULT=fault-openbsd-mips.h ;;
 332         powerpc* | rs6000) CFG_FAULT=fault-openbsd-powerpc.h ;;
 333         sh*) CFG_FAULT=fault-openbsd-sh.h ;;
 334         sparc*) CFG_FAULT=fault-openbsd-sparc.h ;;
 335         vax*) CFG_FAULT=fault-openbsd-vax.h ;;
 336         *) CFG_FAULT=fault-openbsd.h ;;
 337       esac
 338       FAULT_CONTEXT='struct sigcontext'
 339       ;;
 340     mirbsd*)
 341       case "$host_cpu" in
 342         i?86 | x86_64)
 343           CFG_FAULT=fault-openbsd-i386.h
 344           FAULT_CONTEXT='struct sigcontext'
 345           ;;
 346       esac
 347       ;;
 348     linux*)
 349       case "$host_cpu" in
 350         ia64)
 351           CFG_FAULT=fault-linux-ia64-old.h
 352           FAULT_CONTEXT='struct sigcontext'
 353           ;;
 354       esac
 355       ;;
 356   esac
 357   if test -z "$CFG_FAULT"; then
 358     dnl <ucontext.h> was required by POSIX:2001, and many systems have it. But
 359     dnl POSIX:2008 does not require it any more, and MirBSD does not have it.
 360     AC_CHECK_HEADERS([ucontext.h])
 361     if test $ac_cv_header_ucontext_h = yes; then
 362       case "$host_os" in
 363         solaris*)
 364           case "$host_cpu" in
 365             i?86 | x86_64) CFG_FAULT=fault-solaris-i386.h ;;
 366             sparc*) CFG_FAULT=fault-solaris-sparc.h ;;
 367             *) CFG_FAULT=fault-solaris.h ;;
 368           esac
 369           ;;
 370         aix*)
 371           case "$host_cpu" in
 372             powerpc* | rs6000) CFG_FAULT=fault-aix5-powerpc.h ;;
 373             *) CFG_FAULT=fault-aix5.h ;;
 374           esac
 375           ;;
 376         netbsd*)
 377           CFG_FAULT=fault-netbsd.h
 378           ;;
 379         linux*)
 380           case "$host_cpu" in
 381             alpha*)
 382               CFG_FAULT=fault-linux-alpha.h
 383               ;;
 384             arm* | strongarm* | xscale*)
 385               CFG_FAULT=fault-linux-arm.h
 386               ;;
 387             cris)
 388               CFG_FAULT=fault-linux-cris.h
 389               ;;
 390             hppa* | parisc*)
 391               CFG_FAULT=fault-linux-hppa.h
 392               ;;
 393             i?86 | x86_64)
 394               CFG_FAULT=fault-linux-i386.h
 395               ;;
 396             ia64)
 397               CFG_FAULT=fault-linux-ia64.h
 398               ;;
 399             m68*)
 400               CFG_FAULT=fault-linux-m68k.h
 401               ;;
 402             mips*)
 403               CFG_FAULT=fault-linux-mips.h
 404               ;;
 405             powerpc* | rs6000)
 406               CFG_FAULT=fault-linux-powerpc.h
 407               ;;
 408             s390*)
 409               CFG_FAULT=fault-linux-s390.h
 410               ;;
 411             sh*)
 412               CFG_FAULT=fault-linux-sh.h
 413               ;;
 414             sparc*)
 415               CFG_FAULT=fault-linux-sparc.h
 416               ;;
 417             *)
 418               CFG_FAULT=fault-posix-ucontext.h
 419               ;;
 420           esac
 421           ;;
 422         *)
 423           CFG_FAULT=fault-posix-ucontext.h
 424           ;;
 425       esac
 426       FAULT_CONTEXT='ucontext_t'
 427       FAULT_CONTEXT_INCLUDE='#include <ucontext.h>'
 428     else
 429       CFG_FAULT=fault-posix.h
 430       FAULT_CONTEXT='void'
 431     fi
 432   fi
 433 fi
 434 if test -z "$CFG_FAULT" && test "$sv_cv_fault_linux_i386" = yes; then
 435   case "$host_cpu" in
 436     i?86 | x86_64) CFG_FAULT=fault-linux-i386-old.h ;;
 437   esac
 438   FAULT_CONTEXT='struct sigcontext'
 439 fi
 440 if test -z "$CFG_FAULT" && test "$sv_cv_fault_linux_i386_old" = yes; then
 441   case "$host_cpu" in
 442     i?86 | x86_64) CFG_FAULT=fault-linux-i386-oldold.h ;;
 443   esac
 444   FAULT_CONTEXT='struct sigcontext'
 445 fi
 446 if test -z "$CFG_FAULT" && test "$sv_cv_fault_linux_powerpc" = yes; then
 447   case "$host_cpu" in
 448     powerpc* | rs6000) CFG_FAULT=fault-linux-powerpc-old.h ;;
 449   esac
 450   FAULT_CONTEXT='struct sigcontext'
 451 fi
 452 if test -z "$CFG_FAULT" && test "$sv_cv_fault_linux_hppa" = yes; then
 453   case "$host_cpu" in
 454     hppa* | parisc*) CFG_FAULT=fault-linux-hppa-old.h ;;
 455   esac
 456 fi
 457 if test -z "$CFG_FAULT"; then
 458   case "$host_os" in
 459     macos* | darwin[[6-9]]* | darwin[[1-9]][[0-9]]*)
 460       case "$host_cpu" in
 461         powerpc* | rs6000 | i?86 | x86_64)
 462           CFG_MACHFAULT=machfault-macos.h
 463           FAULT_CONTEXT_INCLUDE='#include <signal.h>
 464 #include <mach/thread_status.h>
 465 #if defined __ppc64__
 466 #define sigsegv_thread_state_t ppc_thread_state64_t
 467 #elif defined __ppc__
 468 #define sigsegv_thread_state_t ppc_thread_state_t
 469 #endif
 470 #if defined __x86_64__
 471 #define sigsegv_thread_state_t x86_thread_state64_t
 472 #elif defined __i386__
 473 #if defined x86_THREAD_STATE32
 474 #define sigsegv_thread_state_t x86_thread_state32_t
 475 #else
 476 #define sigsegv_thread_state_t i386_thread_state_t
 477 #endif
 478 #endif'
 479           FAULT_CONTEXT='sigsegv_thread_state_t'
 480           ;;
 481       esac
 482       if test -n "$CFG_MACHFAULT"; then
 483         CFG_HANDLER=handler-macos.c
 484         CFG_FAULT=fault-macos.h # nonexistent, just a dummy
 485       fi
 486       ;;
 487   esac
 488 fi
 489 dnl
 490 dnl Next, the cases where there is a hairy CPU dependent way to get the
 491 dnl fault address.
 492 dnl
 493 if test -z "$CFG_FAULT" && test "$sv_cv_fault_linux_m68k" = yes; then
 494   case "$host_cpu" in
 495     m68*)
 496       CFG_FAULT=fault-linux-m68k-old.h
 497       FAULT_CONTEXT='struct sigcontext'
 498       ;;
 499   esac
 500 fi
 501 if test -z "$CFG_FAULT" && test "$sv_cv_fault_macosdarwin7_ppc" = yes; then
 502   case "$host_cpu" in
 503     powerpc* | rs6000)
 504       CFG_FAULT=fault-macosdarwin7-powerpc.h
 505       FAULT_CONTEXT='ucontext_t'
 506       FAULT_CONTEXT_INCLUDE='#include <signal.h>
 507 #include <ucontext.h>'
 508       ;;
 509   esac
 510 fi
 511 if test -z "$CFG_FAULT" && test "$sv_cv_fault_macosdarwin5_ppc" = yes; then
 512   case "$host_cpu" in
 513     powerpc* | rs6000)
 514       CFG_FAULT=fault-macosdarwin5-powerpc.h
 515       FAULT_CONTEXT='struct sigcontext'
 516       ;;
 517   esac
 518 fi
 519 case "$host_os" in
 520   mingw*)
 521     FAULT_CONTEXT='CONTEXT'
 522     FAULT_CONTEXT_INCLUDE='#include <windows.h>'
 523     CFG_FAULT=fault-win32.h # nonexistent, just a dummy
 524     ;;
 525   cygwin*)
 526     FAULT_CONTEXT='CONTEXT'
 527     FAULT_CONTEXT_INCLUDE='#include <windows.h>'
 528     # Cygwin 1.7 uses fault-posix.h. Cygwin 1.5.x needs a hacky workaround.
 529     if test -z "$CFG_FAULT"; then
 530       CFG_FAULT=fault-cygwin-old.h
 531       AC_DEFINE([OLD_CYGWIN_WORKAROUND], [1],
 532         [Define to 1 on Cygwin versions older than 1.7.])
 533     fi
 534     ;;
 535 esac
 536 if test -n "$CFG_FAULT"; then
 537   sv_cv_have_sigsegv_recovery=yes
 538 else
 539   sv_cv_have_sigsegv_recovery=no
 540   dnl
 541   dnl No way to get the fault address. But other information is available.
 542   dnl
 543   case "$host_os" in
 544     linux*)
 545       case "$host_cpu" in
 546         alpha*)
 547           CFG_FAULT=fault-linux-alpha-old.h
 548           FAULT_CONTEXT='struct sigcontext'
 549           ;;
 550         arm* | strongarm* | xscale*)
 551           CFG_FAULT=fault-linux-arm-old.h
 552           FAULT_CONTEXT='struct sigcontext'
 553           ;;
 554         cris)
 555           CFG_FAULT=fault-linux-cris-old.h
 556           FAULT_CONTEXT='struct sigcontext'
 557           ;;
 558         mips*)
 559           CFG_FAULT=fault-linux-mips-old.h
 560           FAULT_CONTEXT='struct sigcontext'
 561           ;;
 562         s390*)
 563           CFG_FAULT=fault-linux-s390-old.h
 564           FAULT_CONTEXT='struct sigcontext'
 565           ;;
 566         sh*)
 567           CFG_FAULT=fault-linux-sh-old.h
 568           FAULT_CONTEXT='struct sigcontext'
 569           ;;
 570         sparc*)
 571           CFG_FAULT=fault-linux-sparc-old.h
 572           FAULT_CONTEXT='struct sigcontext'
 573           ;;
 574         x86_64)
 575           CFG_FAULT=fault-linux-x86_64-old.h
 576           FAULT_CONTEXT='struct sigcontext'
 577           ;;
 578       esac
 579       ;;
 580     beos*)
 581       case "$host_cpu" in
 582         i?86 | x86_64) CFG_FAULT=fault-beos-i386.h ;;
 583         *) CFG_FAULT=fault-beos.h ;;
 584       esac
 585       FAULT_CONTEXT='struct vregs'
 586       ;;
 587     macos* | darwin*)
 588       case "$host_cpu" in
 589         i?86 | x86_64) CFG_FAULT=fault-macos-i386.h ;;
 590       esac
 591       FAULT_CONTEXT='struct sigcontext'
 592       ;;
 593   esac
 594 fi
 595 AC_MSG_CHECKING([for the fault handler specifics])
 596 if test -n "$CFG_FAULT"; then
 597   sv_cv_fault_include=$CFG_FAULT
 598 else
 599   if test -n "$CFG_MACHFAULT"; then
 600     sv_cv_fault_include=$CFG_MACHFAULT
 601   else
 602     sv_cv_fault_include=none
 603   fi
 604 fi
 605 AC_MSG_RESULT([$sv_cv_fault_include])
 606 if test -z "$CFG_FAULT"; then
 607   CFG_FAULT=fault-none.h
 608 fi
 609 AC_DEFINE_UNQUOTED([CFG_FAULT], ["$CFG_FAULT"],
 610   [The name of the include file describing the fault handler.])
 611 if test -z "$CFG_MACHFAULT"; then
 612   CFG_MACHFAULT=fault-none.h
 613 fi
 614 AC_DEFINE_UNQUOTED([CFG_MACHFAULT], ["$CFG_MACHFAULT"],
 615   [The name of the include file describing the Mach fault handler.])
 616 AC_SUBST([FAULT_CONTEXT])
 617 AC_SUBST([FAULT_CONTEXT_INCLUDE])
 618 dnl AM_SUBST_NOTMAKE, because FAULT_CONTEXT_INCLUDE may have a multiline value.
 619 AM_SUBST_NOTMAKE([FAULT_CONTEXT_INCLUDE])
 620
 621 dnl ================== Done with CFG_HANDLER partially,     ==================
 622 dnl ================== CFG_FAULT, CFG_MACHFAULT,            ==================
 623 dnl ================== FAULT_CONTEXT, FAULT_CONTEXT_INCLUDE ==================
 624
 625
 626 dnl ===================== Determine HAVE_SIGSEGV_RECOVERY =====================
 627 dnl Requires CFG_HANDLER / CFG_FAULT / etc.
 628
 629 AC_MSG_CHECKING([if the system supports catching SIGSEGV])
 630 AC_MSG_RESULT([$sv_cv_have_sigsegv_recovery])
 631 if test $sv_cv_have_sigsegv_recovery != no; then
 632   HAVE_SIGSEGV_RECOVERY=1
 633 else
 634   HAVE_SIGSEGV_RECOVERY=0
 635 fi
 636 AC_SUBST([HAVE_SIGSEGV_RECOVERY])
 637
 638 dnl ===================== Done with HAVE_SIGSEGV_RECOVERY =====================
 639
 640
 641 dnl The stackoverflow_context_t type depends on the CFG_FAULT include file.
 642
 643 dnl Stack direction.
 644 SV_STACK_DIRECTION
 645
 646
 647 dnl ========================= Determine CFG_STACKVMA =========================
 648 dnl Requires AC_CANONICAL_HOST.
 649
 650 dnl Determination of the stack's virtual memory area.
 651 AC_CACHE_CHECK([for PIOCMAP in sys/procfs.h], [sv_cv_procfsvma], [
 652   AC_TRY_LINK([#include <sys/procfs.h>],
 653     [int x = PIOCNMAP + PIOCMAP; prmap_t y;],
 654     [sv_cv_procfsvma=yes], [sv_cv_procfsvma=no])
 655 ])
 656 AC_CHECK_FUNCS([mquery mincore])
 657 CFG_STACKVMA=
 658 if test $sv_cv_procfsvma = yes; then
 659   CFG_STACKVMA=stackvma-procfs.c
 660 else
 661   case "$host_os" in
 662     linux*)                CFG_STACKVMA=stackvma-linux.c ;;
 663     freebsd* | dragonfly*) CFG_STACKVMA=stackvma-freebsd.c ;;
 664     netbsd*)               CFG_STACKVMA=stackvma-netbsd.c ;;
 665     beos*)                 CFG_STACKVMA=stackvma-beos.c ;;
 666     macos* | darwin*)      CFG_STACKVMA=stackvma-mach.c ;;
 667   esac
 668 fi
 669 dnl We prefer the mquery based approach over the mincore based approach,
 670 dnl because stackvma-mincore.c:is_unmapped() has a bad worst-case runtime.
 671 if test -z "$CFG_STACKVMA" && test $ac_cv_func_mquery = yes; then
 672   CFG_STACKVMA=stackvma-mquery.c
 673 fi
 674 if test -z "$CFG_STACKVMA" && test $ac_cv_func_mincore = yes; then
 675   CFG_STACKVMA=stackvma-mincore.c
 676 fi
 677 if test -n "$CFG_STACKVMA"; then
 678   AC_DEFINE([HAVE_STACKVMA], [1],
 679     [Define if CFG_STACKVMA is set to a nontrivial source file.])
 680 else
 681   CFG_STACKVMA=stackvma-none.c
 682 fi
 683 AC_DEFINE_UNQUOTED([CFG_STACKVMA], ["$CFG_STACKVMA"],
 684   [The name of the file determining the stack virtual memory area.])
 685 AC_SUBST([CFG_STACKVMA])
 686
 687 dnl ========================= Done with CFG_STACKVMA =========================
 688
 689
 690 AC_CHECK_FUNCS([getrlimit setrlimit])
 691
 692 dnl Catching stack overflow requires an alternate signal stack.
 693 dnl The old "install a guard page" trick would be unreliable, because
 694 dnl we don't know where exactly to place the guard page.
 695 SV_SIGALTSTACK
 696
 697
 698 dnl =========================== Determine CFG_LEAVE ===========================
 699 dnl Requires AC_CANONICAL_HOST.
 700
 701 # How to longjmp out of a signal handler, in such a way that the
 702 # alternate signal stack remains functional.
 703
 704 # On MacOS X 10.2 or newer, we don't need these tests, because we'll end up
 705 # using handler-macos.c anyway. If we were to perform the tests, 2 Crash Report
 706 # dialog windows would pop up.
 707 case "$host_os" in
 708   macos* | darwin[[6-9]]* | darwin[[1-9]][[0-9]]*) ;;
 709   *)
 710
 711 dnl FIXME: Put in some more known values into the third argument.
 712 SV_TRY_LEAVE_HANDLER_LONGJMP([], sv_cv_leave_handler_longjmp,
 713   [*-*-osf[4-9]* | *-*-hpux11* | *-*-linux2.[2-9]*],
 714   [], [])
 715
 716 dnl FIXME: Put in some more known values into the third argument.
 717 SV_TRY_LEAVE_HANDLER_LONGJMP([ and sigaltstack],
 718   sv_cv_leave_handler_longjmp_sigaltstack,
 719   [*-*-freebsd*],
 720   [
 721 #ifndef SS_ONSTACK
 722 #define SS_ONSTACK SA_ONSTACK
 723 #endif
 724   ],
 725   [stack_t ss;
 726    if (sigaltstack (NULL, &ss) >= 0)
 727      {
 728        ss.ss_flags &= ~SS_ONSTACK;
 729        sigaltstack (&ss, NULL);
 730      }
 731   ])
 732
 733 dnl FIXME: Put in some more known values into the third argument.
 734 SV_TRY_LEAVE_HANDLER_LONGJMP([ and setcontext],
 735   sv_cv_leave_handler_longjmp_setcontext,
 736   [*-*-irix* | *-*-solaris*],
 737   [#include <ucontext.h>
 738 #ifndef SS_ONSTACK
 739 #define SS_ONSTACK SA_ONSTACK
 740 #endif
 741   ],
 742   [static int fl;
 743    static ucontext_t uc;
 744    fl = 0;
 745    if (getcontext (&uc) >= 0)
 746      if (fl == 0)
 747        if (uc.uc_stack.ss_flags & SS_ONSTACK)
 748          {
 749            uc.uc_stack.ss_flags &= ~SS_ONSTACK;
 750            fl = 1;
 751            setcontext (&uc);
 752          }
 753   ])
 754
 755 # End of MacOS X special casing.
 756     ;;
 757 esac
 758
 759 # How to siglongjmp out of a signal handler, in such a way that the
 760 # alternate signal stack remains functional.
 761
 762 # On MacOS X 10.2 or newer, we don't need these tests, because we'll end up
 763 # using handler-macos.c anyway. If we were to perform the tests, 2 Crash Report
 764 # dialog windows would pop up.
 765 case "$host_os" in
 766   macos* | darwin[[6-9]]* | darwin[[1-9]][[0-9]]*) ;;
 767   *)
 768
 769 dnl FIXME: Put in some more known values into the third argument.
 770 SV_TRY_LEAVE_HANDLER_SIGLONGJMP([], sv_cv_leave_handler_siglongjmp,
 771   [*-*-osf[4-9]* | *-*-hpux11* | *-*-linux2.[2-9]* | *-*-irix* | *-*-solaris*],
 772   [], [])
 773
 774 dnl FIXME: Put in some more known values into the third argument.
 775 SV_TRY_LEAVE_HANDLER_SIGLONGJMP([ and sigaltstack],
 776   sv_cv_leave_handler_siglongjmp_sigaltstack,
 777   [*-*-freebsd*],
 778   [
 779 #ifndef SS_ONSTACK
 780 #define SS_ONSTACK SA_ONSTACK
 781 #endif
 782   ],
 783   [stack_t ss;
 784    if (sigaltstack (NULL, &ss) >= 0)
 785      {
 786        ss.ss_flags &= ~SS_ONSTACK;
 787        sigaltstack (&ss, NULL);
 788      }
 789   ])
 790
 791 dnl FIXME: Put in some more known values into the third argument.
 792 SV_TRY_LEAVE_HANDLER_SIGLONGJMP([ and setcontext],
 793   sv_cv_leave_handler_siglongjmp_setcontext,
 794   [],
 795   [#include <ucontext.h>
 796 #ifndef SS_ONSTACK
 797 #define SS_ONSTACK SA_ONSTACK
 798 #endif
 799   ],
 800   [static int fl;
 801    static ucontext_t uc;
 802    fl = 0;
 803    if (getcontext(&uc) >= 0)
 804      if (fl == 0)
 805        if (uc.uc_stack.ss_flags & SS_ONSTACK)
 806          {
 807            uc.uc_stack.ss_flags &= ~SS_ONSTACK;
 808            fl = 1;
 809            setcontext(&uc);
 810          }
 811   ])
 812
 813 # End of MacOS X special casing.
 814     ;;
 815 esac
 816
 817 CFG_LEAVE=
 818 if test "$sv_cv_leave_handler_longjmp" != no; then
 819   CFG_LEAVE=leave-nop.c
 820 else
 821   if test "$sv_cv_leave_handler_longjmp_sigaltstack" != no; then
 822     CFG_LEAVE=leave-sigaltstack.c
 823   else
 824     if test "$sv_cv_leave_handler_longjmp_setcontext" != no; then
 825       CFG_LEAVE=leave-setcontext.c
 826     fi
 827   fi
 828 fi
 829 case "$host_os" in
 830   # On BeOS, the 6 tests fail because sigaltstack() doesn't exist.
 831   # If one uses set_signal_stack() instead of sigaltstack(), the first
 832   # test actually works. i.e. sv_cv_leave_handler_longjmp would be 'yes'.
 833   beos*) CFG_LEAVE=leave-nop.c ;;
 834 esac
 835 if test -z "$CFG_LEAVE"; then
 836   CFG_LEAVE=leave-none.c
 837 fi
 838 AC_DEFINE_UNQUOTED([CFG_LEAVE], ["$CFG_LEAVE"],
 839   [The name of the file implementing sigsegv_reset_onstack_flag.])
 840 AC_SUBST([CFG_LEAVE])
 841
 842 dnl =========================== Done with CFG_LEAVE ===========================
 843
 844
 845 dnl ================= Determine HAVE_STACK_OVERFLOW_RECOVERY =================
 846 dnl Requires AC_CANONICAL_HOST, CFG_HANDLER / CFG_FAULT / etc., CFG_STACKVMA,
 847 dnl CFG_LEAVE.
 848
 849 AC_CACHE_CHECK([if the system supports catching stack overflow],
 850                [sv_cv_have_stack_overflow_recovery],
 851 [
 852   dnl On Mach, it requires a machfault-*.h (see src/handler-macos.c).
 853   dnl On Unix, it requires either sigaltstack() or the BeOS set_signal_stack()
 854   dnl function, and the ability to longjmp out of the signal handler, and on
 855   dnl Unix it also requires a fault-*.h or a stackvma-*.c with certain
 856   dnl properties (see src/handler-unix.c).
 857   if test "$CFG_MACHFAULT" != fault-none.h; then
 858     sv_cv_have_stack_overflow_recovery=yes
 859   else
 860     case "$host_os" in
 861       mingw* | cygwin*) sv_cv_have_stack_overflow_recovery=yes ;;
 862       *)
 863         if test "$CFG_LEAVE" != 'leave-none.c'; then
 864           if test "$sv_cv_sigaltstack" != no; then
 865             sv_cv_have_stack_overflow_recovery=maybe
 866           else
 867             case "$host_os" in
 868               beos*) sv_cv_have_stack_overflow_recovery=maybe ;;
 869               *) sv_cv_have_stack_overflow_recovery=no ;;
 870             esac
 871           fi
 872         else
 873           sv_cv_have_stack_overflow_recovery=no
 874         fi
 875         ;;
 876     esac
 877   fi
 878   if test $sv_cv_have_stack_overflow_recovery = maybe; then
 879     if test -n "$CFG_FAULT"; then
 880       AC_EGREP_CPP([xyzzy], [
 881 #include "$srcdir/src/$CFG_FAULT"
 882 #ifdef SIGSEGV_FAULT_HANDLER_ARGLIST
 883 #ifdef SIGSEGV_FAULT_ADDRESS
 884 xyzzy
 885 #endif
 886 #endif
 887 ], [condA=true], [condA=false])
 888     else
 889       condA=false
 890     fi
 891     if test -n "$CFG_FAULT"; then
 892       AC_EGREP_CPP([xyzzy], [
 893 #include "$srcdir/src/$CFG_FAULT"
 894 #ifdef SIGSEGV_FAULT_HANDLER_ARGLIST
 895 #ifdef SIGSEGV_FAULT_STACKPOINTER
 896 xyzzy
 897 #endif
 898 #endif
 899 ], [condB=true], [condB=false])
 900     else
 901       condB=false
 902     fi
 903     if test "$CFG_STACKVMA" != "stackvma-none.c"; then
 904       condC=true
 905     else
 906       condC=false
 907     fi
 908     if { $condA && $condB; } || { $condA && $condC; } || { $condB && $condC; }; then
 909       sv_cv_have_stack_overflow_recovery=yes
 910     else
 911       sv_cv_have_stack_overflow_recovery=no
 912     fi
 913   fi
 914 ])
 915 if test $sv_cv_have_stack_overflow_recovery != no; then
 916   HAVE_STACK_OVERFLOW_RECOVERY=1
 917 else
 918   HAVE_STACK_OVERFLOW_RECOVERY=0
 919 fi
 920 AC_SUBST([HAVE_STACK_OVERFLOW_RECOVERY])
 921
 922 dnl ================= Done with HAVE_STACK_OVERFLOW_RECOVERY =================
 923
 924
 925 dnl ======================= Determine CFG_HANDLER fully =======================
 926 dnl Requires AC_CANONICAL_HOST, CFG_HANDLER / CFG_FAULT / etc.,
 927 dnl HAVE_SIGSEGV_RECOVERY, HAVE_STACK_OVERFLOW_RECOVERY.
 928
 929 case "$host_os" in
 930   mingw* | cygwin*) CFG_HANDLER=handler-win32.c ;;
 931   *)
 932     if test -z "$CFG_HANDLER"; then
 933       if test $sv_cv_have_sigsegv_recovery = no \
 934          && test $sv_cv_have_stack_overflow_recovery = no; then
 935         CFG_HANDLER=handler-none.c
 936       else
 937         CFG_HANDLER=handler-unix.c
 938       fi
 939     fi
 940     ;;
 941 esac
 942 AC_DEFINE_UNQUOTED([CFG_HANDLER], ["$CFG_HANDLER"],
 943   [The name of the file implementing the handler functionality.])
 944 AC_SUBST([CFG_HANDLER])
 945
 946 dnl ======================= Done with CFG_HANDLER fully =======================
 947
 948 dnl Test whether to enable Cygwin specific tests.
 949 AM_CONDITIONAL([CYGWIN],
 950   [case "$host_os" in
 951      cygwin*) true;;
 952      *)       false;;
 953    esac])
 954
 955 dnl Test whether to make system calls fail with error EFAULT.
 956 dnl More precisely: whether passing invalid memory accesses to system calls
 957 dnl should make the system call fail with error EFAULT, rather than invoking
 958 dnl the signal handler.
 959 dnl It is necessary on Cygwin: otherwise the cygwin1 test fails.
 960 case "$host_os" in
 961   cygwin*) enable_EFAULT=yes ;;
 962   *)       enable_EFAULT=no ;;
 963 esac
 964 if test $enable_EFAULT = yes; then
 965   AC_DEFINE([ENABLE_EFAULT], [1],
 966     [Define to 1 if attempting to make system calls fail with error EFAULT])
 967 fi
 968 AM_CONDITIONAL([ENABLE_EFAULT], [test $enable_EFAULT = yes])
 969
 970 if test $enable_EFAULT = yes; then
 971   SV_SYSCALLS_EFAULT
 972 fi
 973
 974
 975 dnl Test for features used in tests.
 976 AC_TYPE_UINTPTR_T
 977
 978
 979 { echo; echo "${term_bold}Build Parameters:${term_norm}"; } >& AS_MESSAGE_FD
 980
 981 dnl Relocatability is a nop for this package.
 982 gl_RELOCATABLE_NOP
 983
 984 { echo; echo "${term_bold}Output Substitution:${term_norm}"; } >& AS_MESSAGE_FD
 985
 986 dnl AC_OUTPUT([Makefile])
 987 AC_OUTPUT([Makefile
 988            src/Makefile src/sigsegv.h
 989            tests/Makefile])
 990
 991 { echo; echo "Now please type '${term_bold}make${term_norm}' to compile. Good luck."; echo; } >& AS_MESSAGE_FD