configure.in - fp2-dev/platform/external/valgrind - Gitiles

 # Process this file with autoconf to produce a configure script.
 AC_INIT(Valgrind, 3.1.SVN, valgrind-users@lists.sourceforge.net)
 AC_CONFIG_SRCDIR(coregrind/m_main.c)
 AM_CONFIG_HEADER(config.h)
 AM_INIT_AUTOMAKE

 AM_MAINTAINER_MODE

 # Where is VEX ?
 # Nb: For the 2nd arg, the help string, AS_HELP_STRING is the proper way, but
 #     older autoconfs don't support it... here's what it would say:
 #
 #    AS_HELP_STRING([--with-vex], [Vex directory]),
 #
 AC_ARG_WITH(vex,
     [  --with-vex=/path/to/vex/dir    Vex directory],
 [
     AC_CHECK_FILE($withval/pub/libvex.h,
         [VEX_DIR=$withval],
         [AC_MSG_ERROR([Directory '$withval' does not exist, or does not contain Vex])])
 ],
 [
     VEX_DIR='$(top_srcdir)/VEX'
 ])
 AC_SUBST(VEX_DIR)

 # "make distcheck" first builds a tarball, then extracts it.
 # Then it creates a build directory different from the extracted sources
 # (called _build), and issues
 #
 #   ../configure $(DISTCHECK_CONFIGURE_FLAGS)
 #
 # and then builds, runs "make check", installs using DESTDIR, runs make
 # installcheck, uninstalls, checks whether the installed base is empty
 # again, then does yet another "make dist" and compares the resulting
 # tarball with the one it started off with for identical content.  Then it
 # tests "make distclean" for no leftover files.
 #
 # So this line means:  when doing "make dist", use the same --with-vex value
 # that you used when running configure to configure this tree in the first
 # place.
 AC_SUBST([DISTCHECK_CONFIGURE_FLAGS], [--with-vex=$VEX_DIR])

 # Checks for programs.
 CFLAGS="-Wno-long-long"

 AC_PROG_LN_S
 AC_PROG_CC
 ##AM_PROG_CC_C_O
 AC_PROG_CPP
 AC_PROG_CXX
 AC_PROG_RANLIB

 # Check for the compiler support
 if test "${GCC}" != "yes" ; then
    AC_MSG_ERROR([Valgrind relies on GCC to be compiled])
 fi

 # figure out where perl lives
 AC_PATH_PROG(PERL, perl)

 # figure out where gdb lives
 AC_PATH_PROG(GDB, gdb)
 AC_DEFINE_UNQUOTED(GDB_PATH, "$GDB", [path to GDB])

 # some older automake's don't have it so try something on our own
 ifdef([AM_PROG_AS],[AM_PROG_AS],
 [
 AS="${CC}"
 AC_SUBST(AS)

 ASFLAGS=""
 AC_SUBST(ASFLAGS)
 ])

 # This variable will collect the individual suppression files
 # depending on the results of autoconf

 DEFAULT_SUPP=""


 # We don't want gcc < 3.0
 AC_MSG_CHECKING([for a supported version of gcc])

 gcc_version=`${CC} --version | head -n 1`

 case "${gcc_version}" in
      gcc-2.7.*)
 	AC_MSG_RESULT([no (${gcc_version})])
 	AC_MSG_ERROR([please use a recent (>= gcc-3.0) version of gcc])
 	;;
      gcc-2.8.*)
 	AC_MSG_RESULT([no (${gcc_version})])
 	AC_MSG_ERROR([please use a recent (>= gcc-3.0) version of gcc])
 	;;
      gcc-2.9*)
 	AC_MSG_RESULT([no (${gcc_version})])
 	AC_MSG_ERROR([please use a recent (>= gcc-3.0) version of gcc])
 	;;

      *)
 	AC_MSG_RESULT([ok (${gcc_version})])
 	;;
 esac


 # Checks for the platform
 AC_CANONICAL_HOST

 AC_MSG_CHECKING([for a supported CPU])
 AC_SUBST(VG_ARCH)
 AC_SUBST(VG_ARCH_ALL)
 VG_ARCH_ALL="amd64 ppc32 x86"
 AC_SUBST(VALT_LOAD_ADDRESS)

 case "${host_cpu}" in
      i?86)
 	AC_MSG_RESULT([ok (${host_cpu})])
         VG_ARCH="x86"
         valt_load_address_normal="0xb0000000"
         valt_load_address_inner="0xa0000000"
         ;;

      x86_64)
         AC_MSG_RESULT([ok (${host_cpu})])
         VG_ARCH="amd64"
         # XXX: relocations under amd64's "small model" are 32-bit signed
         # quantities; therefore going above 0x7fffffff doesn't work... this is
         # a problem.
         valt_load_address_normal="0x70000000"
         valt_load_address_inner="0x60000000"
         ;;

      powerpc*)
         AC_MSG_RESULT([ok (${host_cpu})])
         VG_ARCH="ppc32"
         valt_load_address_normal="0x70000000"
         valt_load_address_inner="0x60000000"
         ;;

      *)
 	AC_MSG_RESULT([no (${host_cpu})])
 	AC_MSG_ERROR([Unsupported host architecture. Sorry])
 	;;
 esac

 # Check if this should be built as an inner Valgrind, to be run within
 # another Valgrind.  Choose the load address accordingly.
 AC_CACHE_CHECK([enable use as an inner Valgrind], vg_cv_inner,
 	       [AC_ARG_ENABLE(inner, [  --enable-inner          enables self-hosting],
 		[vg_cv_inner=$enableval],
                	[vg_cv_inner=no])])
 if test "$vg_cv_inner" = yes; then
     AC_DEFINE([ENABLE_INNER], 1, [configured to run as an inner Valgrind])
     VALT_LOAD_ADDRESS=$valt_load_address_inner
 else
     VALT_LOAD_ADDRESS=$valt_load_address_normal
 fi

 AC_MSG_CHECKING([for a supported OS])
 AC_SUBST(VG_OS)
 AC_SUBST(VG_OS_ALL)
 VG_OS_ALL="linux"

 case "${host_os}" in
      *linux*)
 	AC_MSG_RESULT([ok (${host_os})])
         VG_OS="linux"

         # Ok, this is linux. Check the kernel version
         AC_MSG_CHECKING([for the kernel version])

         kernel=`uname -r`

         case "${kernel}" in
              2.6.*)
         	    AC_MSG_RESULT([2.6 family (${kernel})])
         	    AC_DEFINE([KERNEL_2_6], 1, [Define to 1 if you're using Linux 2.6.x])
         	    ;;

              2.4.*)
         	    AC_MSG_RESULT([2.4 family (${kernel})])
         	    AC_DEFINE([KERNEL_2_4], 1, [Define to 1 if you're using Linux 2.4.x])
         	    ;;

              *)
         	    AC_MSG_RESULT([unsupported (${kernel})])
         	    AC_MSG_ERROR([Valgrind works on kernels 2.4, 2.6])
         	    ;;
         esac

         ;;

      *freebsd*)
         AC_MSG_RESULT([ok (${host_os})])
         VG_OS="freebsd"
         ;;

      *)
 	AC_MSG_RESULT([no (${host_os})])
 	AC_MSG_ERROR([Valgrind is operating system specific. Sorry. Please consider doing a port.])
 	;;
 esac

 AC_MSG_CHECKING([for a supported CPU/OS combination])
 AC_SUBST(VG_PLATFORM)
 AC_SUBST(VG_PLATFORM_ALL)
 VG_PLATFORM_ALL="amd64-linux ppc32-linux x86-linux"

 VG_PLATFORM="$VG_ARCH-$VG_OS"

 case $VG_PLATFORM in
     x86-linux|amd64-linux|ppc32-linux)
         AC_MSG_RESULT([ok (${host_cpu}-${host_os})])
         ;;

     *)
         AC_MSG_RESULT([no (${host_cpu}-${host_os})])
         AC_MSG_ERROR([Valgrind is platform specific. Sorry. Please consider doing a port.])
         ;;
 esac

 AM_CONDITIONAL(VG_X86_LINUX, test x$VG_PLATFORM = xx86-linux -o x$VG_PLATFORM = xamd64-linux)
 AM_CONDITIONAL(VG_AMD64_LINUX, test x$VG_PLATFORM = xamd64-linux)
 AM_CONDITIONAL(VG_PPC32_LINUX, test x$VG_PLATFORM = xppc32-linux)

 AC_SUBST(VG_MAKE_PLATFORM)
 VG_MAKE_PLATFORM=`echo $VG_PLATFORM | tr [a-z-] [A-Z_]`

 AC_SUBST(DEFAULT_SUPP)

 glibc=""

 AC_EGREP_CPP([GLIBC_22], [
 #include <features.h>
 #ifdef __GNU_LIBRARY__
  #if (__GLIBC__ == 2 && __GLIBC_MINOR__ == 2)
   GLIBC_22
  #endif
 #endif
 ],
 glibc="2.2")

 AC_EGREP_CPP([GLIBC_23], [
 #include <features.h>
 #ifdef __GNU_LIBRARY__
  #if (__GLIBC__ == 2 && __GLIBC_MINOR__ == 3)
   GLIBC_23
  #endif
 #endif
 ],
 glibc="2.3")

 AC_EGREP_CPP([GLIBC_24], [
 #include <features.h>
 #ifdef __GNU_LIBRARY__
  #if (__GLIBC__ == 2 && __GLIBC_MINOR__ == 4)
   GLIBC_24
  #endif
 #endif
 ],
 glibc="2.4")

 AC_MSG_CHECKING([the glibc version])

 case "${glibc}" in
      2.2)
 	AC_MSG_RESULT(2.2 family)
 	AC_DEFINE([GLIBC_2_2], 1, [Define to 1 if you're using glibc 2.2.x])
 	DEFAULT_SUPP="${DEFAULT_SUPP} glibc-2.2.supp"
 	;;

      2.3)
 	AC_MSG_RESULT(2.3 family)
 	AC_DEFINE([GLIBC_2_3], 1, [Define to 1 if you're using glibc 2.3.x])
 	DEFAULT_SUPP="${DEFAULT_SUPP} glibc-2.3.supp"
 	;;

      2.4)
 	AC_MSG_RESULT(2.4 family)
 	AC_DEFINE([GLIBC_2_4], 1, [Define to 1 if you're using glibc 2.4.x])
 	DEFAULT_SUPP="${DEFAULT_SUPP} glibc-2.4.supp"
 	;;

      *)
 	AC_MSG_RESULT(unsupported version)
 	AC_MSG_ERROR([Valgrind requires glibc version 2.2, 2.3 or 2.4])
 	;;
 esac


 # We don't know how to detect the X client library version
 # (detecting the server version is easy, bu no help).  So we
 # just use a hack: always include the suppressions for both
 # versions 3 and 4.
 AC_PATH_X
 if test "${no_x}" != 'yes' ; then
    DEFAULT_SUPP="${DEFAULT_SUPP} xfree-4.supp"
    DEFAULT_SUPP="${DEFAULT_SUPP} xfree-3.supp"
 fi


 # does this compiler support -m32 ?
 AC_MSG_CHECKING([if gcc accepts -m32])

 safe_CFLAGS=$CFLAGS
 CFLAGS="-m32"

 AC_TRY_COMPILE(, [
 int main () { return 0 ; }
 ],
 [
 FLAG_M32="-m32"
 AC_MSG_RESULT([yes])
 ], [
 FLAG_M32=""
 AC_MSG_RESULT([no])
 ])
 CFLAGS=$safe_CFLAGS

 AC_SUBST(FLAG_M32)


 # does this compiler support -mmmx ?
 AC_MSG_CHECKING([if gcc accepts -mmmx])

 safe_CFLAGS=$CFLAGS
 CFLAGS="-mmmx"

 AC_TRY_COMPILE(, [
 int main () { return 0 ; }
 ],
 [
 FLAG_MMMX="-mmmx"
 AC_MSG_RESULT([yes])
 ], [
 FLAG_MMMX=""
 AC_MSG_RESULT([no])
 ])
 CFLAGS=$safe_CFLAGS

 AC_SUBST(FLAG_MMMX)


 # does this compiler support -msse ?
 AC_MSG_CHECKING([if gcc accepts -msse])

 safe_CFLAGS=$CFLAGS
 CFLAGS="-msse"

 AC_TRY_COMPILE(, [
 int main () { return 0 ; }
 ],
 [
 FLAG_MSSE="-msse"
 AC_MSG_RESULT([yes])
 ], [
 FLAG_MSSE=""
 AC_MSG_RESULT([no])
 ])
 CFLAGS=$safe_CFLAGS

 AC_SUBST(FLAG_MSSE)


 # does this compiler support -mpreferred-stack-boundary=2 ?
 AC_MSG_CHECKING([if gcc accepts -mpreferred-stack-boundary])

 safe_CFLAGS=$CFLAGS
 CFLAGS="-mpreferred-stack-boundary=2"

 AC_TRY_COMPILE(, [
 int main () { return 0 ; }
 ],
 [
 PREFERRED_STACK_BOUNDARY="-mpreferred-stack-boundary=2"
 AC_MSG_RESULT([yes])
 ], [
 PREFERRED_STACK_BOUNDARY=""
 AC_MSG_RESULT([no])
 ])
 CFLAGS=$safe_CFLAGS

 AC_SUBST(PREFERRED_STACK_BOUNDARY)


 # does this compiler support -Wno-pointer-sign ?
 AC_MSG_CHECKING([if gcc accepts -Wno-pointer-sign ])

 safe_CFLAGS=$CFLAGS
 CFLAGS="-Wno-pointer-sign"

 AC_TRY_COMPILE(, [
 int main () { return 0 ; }
 ],
 [
 no_pointer_sign=yes
 AC_MSG_RESULT([yes])
 ], [
 no_pointer_sign=no
 AC_MSG_RESULT([no])
 ])
 CFLAGS=$safe_CFLAGS

 if test x$no_pointer_sign = xyes; then
   CFLAGS="$CFLAGS -Wno-pointer-sign"
 fi


 # does this compiler support -Wdeclaration-after-statement ?
 AC_MSG_CHECKING([if gcc accepts -Wdeclaration-after-statement ])

 safe_CFLAGS=$CFLAGS
 CFLAGS="-Wdeclaration-after-statement"

 AC_TRY_COMPILE(, [
 int main () { return 0 ; }
 ],
 [
 declaration_after_statement=yes
 AC_MSG_RESULT([yes])
 ], [
 declaration_after_statement=no
 AC_MSG_RESULT([no])
 ])
 CFLAGS=$safe_CFLAGS

 if test x$declaration_after_statement = xyes; then
   CFLAGS="$CFLAGS -Wdeclaration-after-statement"
 fi


 # Check for TLS support in the compiler and linker
 AC_CACHE_CHECK([for TLS support], vg_cv_tls,
 	       [AC_ARG_ENABLE(tls, [  --enable-tls            platform supports TLS],
 		[vg_cv_tls=$enableval],
                	[AC_RUN_IFELSE([AC_LANG_PROGRAM([[static __thread int foo;]],
                                                 [[return foo;]])],
                                [vg_cv_tls=yes],
                                [vg_cv_tls=no])])])

 if test "$vg_cv_tls" = yes; then
 AC_DEFINE([HAVE_TLS], 1, [can use __thread to define thread-local variables])
 fi


 # Checks for header files.
 AC_HEADER_STDC
 AC_CHECK_HEADERS([sys/endian.h endian.h mqueue.h])


 # Checks for typedefs, structures, and compiler characteristics.
 AC_TYPE_UID_T
 AC_TYPE_OFF_T
 AC_TYPE_SIZE_T
 AC_HEADER_TIME


 # Checks for library functions.
 AC_FUNC_MEMCMP
 AC_FUNC_MMAP
 AC_TYPE_SIGNAL

 AC_CHECK_FUNCS([floor memchr memset mkdir strchr strdup strpbrk strrchr strstr semtimedop])

 AC_OUTPUT(
    Makefile
    valgrind.spec
    valgrind.pc
    docs/Makefile
    docs/lib/Makefile
    docs/images/Makefile
    docs/internals/Makefile
    docs/xml/Makefile
    tests/Makefile
    tests/vg_regtest
    include/Makefile
    auxprogs/Makefile
    coregrind/Makefile
    addrcheck/Makefile
    addrcheck/tests/Makefile
    addrcheck/docs/Makefile
    memcheck/Makefile
    memcheck/tests/Makefile
    memcheck/tests/amd64/Makefile
    memcheck/tests/ppc32/Makefile
    memcheck/tests/x86/Makefile
    memcheck/docs/Makefile
    cachegrind/Makefile
    cachegrind/tests/Makefile
    cachegrind/tests/amd64/Makefile
    cachegrind/tests/ppc32/Makefile
    cachegrind/tests/x86/Makefile
    cachegrind/docs/Makefile
    cachegrind/cg_annotate
    helgrind/Makefile
    helgrind/tests/Makefile
    helgrind/docs/Makefile
    massif/Makefile
    massif/hp2ps/Makefile
    massif/tests/Makefile
    massif/docs/Makefile
    lackey/Makefile
    lackey/tests/Makefile
    lackey/docs/Makefile
    none/Makefile
    none/tests/Makefile
    none/tests/amd64/Makefile
    none/tests/ppc32/Makefile
    none/tests/x86/Makefile
    none/docs/Makefile
 )

 cat<<EOF

 Using the following suppressions by default:

       ${DEFAULT_SUPP}
 EOF

 cat<<EOF > default.supp
 # This is a generated file, composed of the following suppression rules:
 #
 #      ${DEFAULT_SUPP}
 #

 EOF

 for file in ${DEFAULT_SUPP} ; do
     cat ${srcdir}/$file >> default.supp
 done
	# Process this file with autoconf to produce a configure script.
	AC_INIT(Valgrind, 3.1.SVN, valgrind-users@lists.sourceforge.net)
	AC_CONFIG_SRCDIR(coregrind/m_main.c)
	AM_CONFIG_HEADER(config.h)
	AM_INIT_AUTOMAKE

	AM_MAINTAINER_MODE

	# Where is VEX ?
	# Nb: For the 2nd arg, the help string, AS_HELP_STRING is the proper way, but
	# older autoconfs don't support it... here's what it would say:
	#
	# AS_HELP_STRING([--with-vex], [Vex directory]),
	#
	AC_ARG_WITH(vex,
	[ --with-vex=/path/to/vex/dir Vex directory],
	[
	AC_CHECK_FILE($withval/pub/libvex.h,
	[VEX_DIR=$withval],
	[AC_MSG_ERROR([Directory '$withval' does not exist, or does not contain Vex])])
	],
	[
	VEX_DIR='$(top_srcdir)/VEX'
	])
	AC_SUBST(VEX_DIR)

	# "make distcheck" first builds a tarball, then extracts it.
	# Then it creates a build directory different from the extracted sources
	# (called _build), and issues
	#
	# ../configure $(DISTCHECK_CONFIGURE_FLAGS)
	#
	# and then builds, runs "make check", installs using DESTDIR, runs make
	# installcheck, uninstalls, checks whether the installed base is empty
	# again, then does yet another "make dist" and compares the resulting
	# tarball with the one it started off with for identical content. Then it
	# tests "make distclean" for no leftover files.
	#
	# So this line means: when doing "make dist", use the same --with-vex value
	# that you used when running configure to configure this tree in the first
	# place.
	AC_SUBST([DISTCHECK_CONFIGURE_FLAGS], [--with-vex=$VEX_DIR])

	# Checks for programs.
	CFLAGS="-Wno-long-long"

	AC_PROG_LN_S
	AC_PROG_CC
	##AM_PROG_CC_C_O
	AC_PROG_CPP
	AC_PROG_CXX
	AC_PROG_RANLIB

	# Check for the compiler support
	if test "${GCC}" != "yes" ; then
	AC_MSG_ERROR([Valgrind relies on GCC to be compiled])
	fi

	# figure out where perl lives
	AC_PATH_PROG(PERL, perl)

	# figure out where gdb lives
	AC_PATH_PROG(GDB, gdb)
	AC_DEFINE_UNQUOTED(GDB_PATH, "$GDB", [path to GDB])

	# some older automake's don't have it so try something on our own
	ifdef([AM_PROG_AS],[AM_PROG_AS],
	[
	AS="${CC}"
	AC_SUBST(AS)

	ASFLAGS=""
	AC_SUBST(ASFLAGS)
	])

	# This variable will collect the individual suppression files
	# depending on the results of autoconf

	DEFAULT_SUPP=""


	# We don't want gcc < 3.0
	AC_MSG_CHECKING([for a supported version of gcc])

	gcc_version=`${CC} --version \| head -n 1`

	case "${gcc_version}" in
	gcc-2.7.*)
	AC_MSG_RESULT([no (${gcc_version})])
	AC_MSG_ERROR([please use a recent (>= gcc-3.0) version of gcc])
	;;
	gcc-2.8.*)
	AC_MSG_RESULT([no (${gcc_version})])
	AC_MSG_ERROR([please use a recent (>= gcc-3.0) version of gcc])
	;;
	gcc-2.9*)
	AC_MSG_RESULT([no (${gcc_version})])
	AC_MSG_ERROR([please use a recent (>= gcc-3.0) version of gcc])
	;;

	*)
	AC_MSG_RESULT([ok (${gcc_version})])
	;;
	esac


	# Checks for the platform
	AC_CANONICAL_HOST

	AC_MSG_CHECKING([for a supported CPU])
	AC_SUBST(VG_ARCH)
	AC_SUBST(VG_ARCH_ALL)
	VG_ARCH_ALL="amd64 ppc32 x86"
	AC_SUBST(VALT_LOAD_ADDRESS)

	case "${host_cpu}" in
	i?86)
	AC_MSG_RESULT([ok (${host_cpu})])
	VG_ARCH="x86"
	valt_load_address_normal="0xb0000000"
	valt_load_address_inner="0xa0000000"
	;;

	x86_64)
	AC_MSG_RESULT([ok (${host_cpu})])
	VG_ARCH="amd64"
	# XXX: relocations under amd64's "small model" are 32-bit signed
	# quantities; therefore going above 0x7fffffff doesn't work... this is
	# a problem.
	valt_load_address_normal="0x70000000"
	valt_load_address_inner="0x60000000"
	;;

	powerpc*)
	AC_MSG_RESULT([ok (${host_cpu})])
	VG_ARCH="ppc32"
	valt_load_address_normal="0x70000000"
	valt_load_address_inner="0x60000000"
	;;

	*)
	AC_MSG_RESULT([no (${host_cpu})])
	AC_MSG_ERROR([Unsupported host architecture. Sorry])
	;;
	esac

	# Check if this should be built as an inner Valgrind, to be run within
	# another Valgrind. Choose the load address accordingly.
	AC_CACHE_CHECK([enable use as an inner Valgrind], vg_cv_inner,
	[AC_ARG_ENABLE(inner, [ --enable-inner enables self-hosting],
	[vg_cv_inner=$enableval],
	[vg_cv_inner=no])])
	if test "$vg_cv_inner" = yes; then
	AC_DEFINE([ENABLE_INNER], 1, [configured to run as an inner Valgrind])
	VALT_LOAD_ADDRESS=$valt_load_address_inner
	else
	VALT_LOAD_ADDRESS=$valt_load_address_normal
	fi

	AC_MSG_CHECKING([for a supported OS])
	AC_SUBST(VG_OS)
	AC_SUBST(VG_OS_ALL)
	VG_OS_ALL="linux"

	case "${host_os}" in
	linux)
	AC_MSG_RESULT([ok (${host_os})])
	VG_OS="linux"

	# Ok, this is linux. Check the kernel version
	AC_MSG_CHECKING([for the kernel version])

	kernel=`uname -r`

	case "${kernel}" in
	2.6.*)
	AC_MSG_RESULT([2.6 family (${kernel})])
	AC_DEFINE([KERNEL_2_6], 1, [Define to 1 if you're using Linux 2.6.x])
	;;

	2.4.*)
	AC_MSG_RESULT([2.4 family (${kernel})])
	AC_DEFINE([KERNEL_2_4], 1, [Define to 1 if you're using Linux 2.4.x])
	;;

	*)
	AC_MSG_RESULT([unsupported (${kernel})])
	AC_MSG_ERROR([Valgrind works on kernels 2.4, 2.6])
	;;
	esac

	;;

	freebsd)
	AC_MSG_RESULT([ok (${host_os})])
	VG_OS="freebsd"
	;;

	*)
	AC_MSG_RESULT([no (${host_os})])
	AC_MSG_ERROR([Valgrind is operating system specific. Sorry. Please consider doing a port.])
	;;
	esac

	AC_MSG_CHECKING([for a supported CPU/OS combination])
	AC_SUBST(VG_PLATFORM)
	AC_SUBST(VG_PLATFORM_ALL)
	VG_PLATFORM_ALL="amd64-linux ppc32-linux x86-linux"

	VG_PLATFORM="$VG_ARCH-$VG_OS"

	case $VG_PLATFORM in
	x86-linux\|amd64-linux\|ppc32-linux)
	AC_MSG_RESULT([ok (${host_cpu}-${host_os})])
	;;

	*)
	AC_MSG_RESULT([no (${host_cpu}-${host_os})])
	AC_MSG_ERROR([Valgrind is platform specific. Sorry. Please consider doing a port.])
	;;
	esac

	AM_CONDITIONAL(VG_X86_LINUX, test x$VG_PLATFORM = xx86-linux -o x$VG_PLATFORM = xamd64-linux)
	AM_CONDITIONAL(VG_AMD64_LINUX, test x$VG_PLATFORM = xamd64-linux)
	AM_CONDITIONAL(VG_PPC32_LINUX, test x$VG_PLATFORM = xppc32-linux)

	AC_SUBST(VG_MAKE_PLATFORM)
	VG_MAKE_PLATFORM=`echo $VG_PLATFORM \| tr [a-z-] [A-Z_]`

	AC_SUBST(DEFAULT_SUPP)

	glibc=""

	AC_EGREP_CPP([GLIBC_22], [
	#include <features.h>
	#ifdef __GNU_LIBRARY__
	#if (__GLIBC__ == 2 && __GLIBC_MINOR__ == 2)
	GLIBC_22
	#endif
	#endif
	],
	glibc="2.2")

	AC_EGREP_CPP([GLIBC_23], [
	#include <features.h>
	#ifdef __GNU_LIBRARY__
	#if (__GLIBC__ == 2 && __GLIBC_MINOR__ == 3)
	GLIBC_23
	#endif
	#endif
	],
	glibc="2.3")

	AC_EGREP_CPP([GLIBC_24], [
	#include <features.h>
	#ifdef __GNU_LIBRARY__
	#if (__GLIBC__ == 2 && __GLIBC_MINOR__ == 4)
	GLIBC_24
	#endif
	#endif
	],
	glibc="2.4")

	AC_MSG_CHECKING([the glibc version])

	case "${glibc}" in
	2.2)
	AC_MSG_RESULT(2.2 family)
	AC_DEFINE([GLIBC_2_2], 1, [Define to 1 if you're using glibc 2.2.x])
	DEFAULT_SUPP="${DEFAULT_SUPP} glibc-2.2.supp"
	;;

	2.3)
	AC_MSG_RESULT(2.3 family)
	AC_DEFINE([GLIBC_2_3], 1, [Define to 1 if you're using glibc 2.3.x])
	DEFAULT_SUPP="${DEFAULT_SUPP} glibc-2.3.supp"
	;;

	2.4)
	AC_MSG_RESULT(2.4 family)
	AC_DEFINE([GLIBC_2_4], 1, [Define to 1 if you're using glibc 2.4.x])
	DEFAULT_SUPP="${DEFAULT_SUPP} glibc-2.4.supp"
	;;

	*)
	AC_MSG_RESULT(unsupported version)
	AC_MSG_ERROR([Valgrind requires glibc version 2.2, 2.3 or 2.4])
	;;
	esac


	# We don't know how to detect the X client library version
	# (detecting the server version is easy, bu no help). So we
	# just use a hack: always include the suppressions for both
	# versions 3 and 4.
	AC_PATH_X
	if test "${no_x}" != 'yes' ; then
	DEFAULT_SUPP="${DEFAULT_SUPP} xfree-4.supp"
	DEFAULT_SUPP="${DEFAULT_SUPP} xfree-3.supp"
	fi


	# does this compiler support -m32 ?
	AC_MSG_CHECKING([if gcc accepts -m32])

	safe_CFLAGS=$CFLAGS
	CFLAGS="-m32"

	AC_TRY_COMPILE(, [
	int main () { return 0 ; }
	],
	[
	FLAG_M32="-m32"
	AC_MSG_RESULT([yes])
	], [
	FLAG_M32=""
	AC_MSG_RESULT([no])
	])
	CFLAGS=$safe_CFLAGS

	AC_SUBST(FLAG_M32)


	# does this compiler support -mmmx ?
	AC_MSG_CHECKING([if gcc accepts -mmmx])

	safe_CFLAGS=$CFLAGS
	CFLAGS="-mmmx"

	AC_TRY_COMPILE(, [
	int main () { return 0 ; }
	],
	[
	FLAG_MMMX="-mmmx"
	AC_MSG_RESULT([yes])
	], [
	FLAG_MMMX=""
	AC_MSG_RESULT([no])
	])
	CFLAGS=$safe_CFLAGS

	AC_SUBST(FLAG_MMMX)


	# does this compiler support -msse ?
	AC_MSG_CHECKING([if gcc accepts -msse])

	safe_CFLAGS=$CFLAGS
	CFLAGS="-msse"

	AC_TRY_COMPILE(, [
	int main () { return 0 ; }
	],
	[
	FLAG_MSSE="-msse"
	AC_MSG_RESULT([yes])
	], [
	FLAG_MSSE=""
	AC_MSG_RESULT([no])
	])
	CFLAGS=$safe_CFLAGS

	AC_SUBST(FLAG_MSSE)


	# does this compiler support -mpreferred-stack-boundary=2 ?
	AC_MSG_CHECKING([if gcc accepts -mpreferred-stack-boundary])

	safe_CFLAGS=$CFLAGS
	CFLAGS="-mpreferred-stack-boundary=2"

	AC_TRY_COMPILE(, [
	int main () { return 0 ; }
	],
	[
	PREFERRED_STACK_BOUNDARY="-mpreferred-stack-boundary=2"
	AC_MSG_RESULT([yes])
	], [
	PREFERRED_STACK_BOUNDARY=""
	AC_MSG_RESULT([no])
	])
	CFLAGS=$safe_CFLAGS

	AC_SUBST(PREFERRED_STACK_BOUNDARY)


	# does this compiler support -Wno-pointer-sign ?
	AC_MSG_CHECKING([if gcc accepts -Wno-pointer-sign ])

	safe_CFLAGS=$CFLAGS
	CFLAGS="-Wno-pointer-sign"

	AC_TRY_COMPILE(, [
	int main () { return 0 ; }
	],
	[
	no_pointer_sign=yes
	AC_MSG_RESULT([yes])
	], [
	no_pointer_sign=no
	AC_MSG_RESULT([no])
	])
	CFLAGS=$safe_CFLAGS

	if test x$no_pointer_sign = xyes; then
	CFLAGS="$CFLAGS -Wno-pointer-sign"
	fi


	# does this compiler support -Wdeclaration-after-statement ?
	AC_MSG_CHECKING([if gcc accepts -Wdeclaration-after-statement ])

	safe_CFLAGS=$CFLAGS
	CFLAGS="-Wdeclaration-after-statement"

	AC_TRY_COMPILE(, [
	int main () { return 0 ; }
	],
	[
	declaration_after_statement=yes
	AC_MSG_RESULT([yes])
	], [
	declaration_after_statement=no
	AC_MSG_RESULT([no])
	])
	CFLAGS=$safe_CFLAGS

	if test x$declaration_after_statement = xyes; then
	CFLAGS="$CFLAGS -Wdeclaration-after-statement"
	fi


	# Check for TLS support in the compiler and linker
	AC_CACHE_CHECK([for TLS support], vg_cv_tls,
	[AC_ARG_ENABLE(tls, [ --enable-tls platform supports TLS],
	[vg_cv_tls=$enableval],
	[AC_RUN_IFELSE([AC_LANG_PROGRAM([[static __thread int foo;]],
	[[return foo;]])],
	[vg_cv_tls=yes],
	[vg_cv_tls=no])])])

	if test "$vg_cv_tls" = yes; then
	AC_DEFINE([HAVE_TLS], 1, [can use __thread to define thread-local variables])
	fi


	# Checks for header files.
	AC_HEADER_STDC
	AC_CHECK_HEADERS([sys/endian.h endian.h mqueue.h])


	# Checks for typedefs, structures, and compiler characteristics.
	AC_TYPE_UID_T
	AC_TYPE_OFF_T
	AC_TYPE_SIZE_T
	AC_HEADER_TIME


	# Checks for library functions.
	AC_FUNC_MEMCMP
	AC_FUNC_MMAP
	AC_TYPE_SIGNAL

	AC_CHECK_FUNCS([floor memchr memset mkdir strchr strdup strpbrk strrchr strstr semtimedop])

	AC_OUTPUT(
	Makefile
	valgrind.spec
	valgrind.pc
	docs/Makefile
	docs/lib/Makefile
	docs/images/Makefile
	docs/internals/Makefile
	docs/xml/Makefile
	tests/Makefile
	tests/vg_regtest
	include/Makefile
	auxprogs/Makefile
	coregrind/Makefile
	addrcheck/Makefile
	addrcheck/tests/Makefile
	addrcheck/docs/Makefile
	memcheck/Makefile
	memcheck/tests/Makefile
	memcheck/tests/amd64/Makefile
	memcheck/tests/ppc32/Makefile
	memcheck/tests/x86/Makefile
	memcheck/docs/Makefile
	cachegrind/Makefile
	cachegrind/tests/Makefile
	cachegrind/tests/amd64/Makefile
	cachegrind/tests/ppc32/Makefile
	cachegrind/tests/x86/Makefile
	cachegrind/docs/Makefile
	cachegrind/cg_annotate
	helgrind/Makefile
	helgrind/tests/Makefile
	helgrind/docs/Makefile
	massif/Makefile
	massif/hp2ps/Makefile
	massif/tests/Makefile
	massif/docs/Makefile
	lackey/Makefile
	lackey/tests/Makefile
	lackey/docs/Makefile
	none/Makefile
	none/tests/Makefile
	none/tests/amd64/Makefile
	none/tests/ppc32/Makefile
	none/tests/x86/Makefile
	none/docs/Makefile
	)

	cat<<EOF

	Using the following suppressions by default:

	${DEFAULT_SUPP}
	EOF

	cat<<EOF > default.supp
	# This is a generated file, composed of the following suppression rules:
	#
	# ${DEFAULT_SUPP}
	#

	EOF

	for file in ${DEFAULT_SUPP} ; do
	cat ${srcdir}/$file >> default.supp
	done