##------------------------------------------------------------## # # The multiple-architecture stuff in this file is pretty # cryptic. Read docs/internals/multiple-architectures.txt # for at least a partial explanation of what is going on. # ##------------------------------------------------------------## # Process this file with autoconf to produce a configure script. AC_INIT([Valgrind],[3.8.0.SVN],[valgrind-users@lists.sourceforge.net]) AC_CONFIG_SRCDIR(coregrind/m_main.c) AC_CONFIG_HEADERS([config.h]) AM_INIT_AUTOMAKE([foreign]) AM_MAINTAINER_MODE #---------------------------------------------------------------------------- # Checks for various programs. #---------------------------------------------------------------------------- CFLAGS="-Wno-long-long $CFLAGS" AC_PROG_LN_S AC_PROG_CC AM_PROG_CC_C_O AC_PROG_CPP AC_PROG_CXX # AC_PROG_OBJC apparently causes problems on older Linux distros (eg. with # autoconf 2.59). If we ever have any Objective-C code in the Valgrind code # base (eg. most likely as Darwin-specific tests) we'll need one of the # following: # - put AC_PROG_OBJC in a Darwin-specific part of this file # - Use AC_PROG_OBJC here and up the minimum autoconf version # - Use the following, which is apparently equivalent: # m4_ifdef([AC_PROG_OBJC], # [AC_PROG_OBJC], # [AC_CHECK_TOOL([OBJC], [gcc]) # AC_SUBST([OBJC]) # AC_SUBST([OBJCFLAGS]) # ]) AC_PROG_RANLIB # provide a very basic definition for AC_PROG_SED if it's not provided by # autoconf (as e.g. in autoconf 2.59). m4_ifndef([AC_PROG_SED], [AC_DEFUN([AC_PROG_SED], [AC_ARG_VAR([SED]) AC_CHECK_PROGS([SED],[gsed sed])])]) AC_PROG_SED # If no AR variable was specified, look up the name of the archiver. Otherwise # do not touch the AR variable. if test "x$AR" = "x"; then AC_PATH_PROGS([AR], [`echo $LD | $SED 's/ld$/ar/'` "ar"], [ar]) fi AC_ARG_VAR([AR],[Archiver command]) # 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, "/no/gdb/was/found/at/configure/time") 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) ]) # Check if 'diff' supports -u (universal diffs) and use it if possible. AC_MSG_CHECKING([for diff -u]) AC_SUBST(DIFF) # Comparing two identical files results in 0. tmpfile="tmp-xxx-yyy-zzz" touch $tmpfile; if diff -u $tmpfile $tmpfile ; then AC_MSG_RESULT([yes]) DIFF="diff -u" else AC_MSG_RESULT([no]) DIFF="diff" fi rm $tmpfile # We don't want gcc < 3.0 AC_MSG_CHECKING([for a supported version of gcc]) # Obtain the compiler version. # # A few examples of how the ${CC} --version output looks like: # # Arch Linux: i686-pc-linux-gnu-gcc (GCC) 4.6.2 # Debian Linux: gcc (Debian 4.3.2-1.1) 4.3.2 # openSUSE: gcc (SUSE Linux) 4.5.1 20101208 [gcc-4_5-branch revision 167585] # Exherbo Linux: x86_64-pc-linux-gnu-gcc (Exherbo gcc-4.6.2) 4.6.2 # OS/X 10.6: i686-apple-darwin10-gcc-4.2.1 (GCC) 4.2.1 (Apple Inc. build 5666) (dot 3) # OS/X 10.7: i686-apple-darwin11-llvm-gcc-4.2 (GCC) 4.2.1 (Based on Apple Inc. build 5658) (LLVM build 2335.15.00) # Clang: clang version 2.9 (tags/RELEASE_29/final) # [gcc_version=`${CC} --version \ | $SED -n -e 's/[^ ]*gcc[^ ]* ([^)]*) \([0-9.]*\).*$/\1/p' \ -e 's/[^ ]*clang version \([0-9.]*\).*$/\1/p'`] is_clang="notclang" if test "x`${CC} --version | head -n 1 | $SED 's/\(clang\) version.*/\1/'`" = "xclang" ; then is_clang="clang" fi case "${is_clang}-${gcc_version}" in notclang-3.*) AC_MSG_RESULT([ok (${gcc_version})]) ;; notclang-4.*) AC_MSG_RESULT([ok (${gcc_version})]) ;; clang-2.9) AC_MSG_RESULT([ok (clang-${gcc_version})]) ;; *) AC_MSG_RESULT([no (${gcc_version})]) AC_MSG_ERROR([please use gcc >= 3.0 or clang >= 2.9]) ;; esac #---------------------------------------------------------------------------- # Arch/OS/platform tests. #---------------------------------------------------------------------------- # We create a number of arch/OS/platform-related variables. We prefix them # all with "VGCONF_" which indicates that they are defined at # configure-time, and distinguishes them from the VGA_*/VGO_*/VGP_* # variables used when compiling C files. AC_CANONICAL_HOST AC_MSG_CHECKING([for a supported CPU]) # ARCH_MAX reflects the most that this CPU can do: for example if it # is a 64-bit capable PowerPC, then it must be set to ppc64 and not ppc32. # Ditto for amd64. It is used for more configuration below, but is not used # outside this file. case "${host_cpu}" in i?86) AC_MSG_RESULT([ok (${host_cpu})]) ARCH_MAX="x86" ;; x86_64) AC_MSG_RESULT([ok (${host_cpu})]) ARCH_MAX="amd64" ;; powerpc64) AC_MSG_RESULT([ok (${host_cpu})]) ARCH_MAX="ppc64" ;; powerpc) # On Linux this means only a 32-bit capable CPU. AC_MSG_RESULT([ok (${host_cpu})]) ARCH_MAX="ppc32" ;; s390x) AC_MSG_RESULT([ok (${host_cpu})]) ARCH_MAX="s390x" ;; armv7*) AC_MSG_RESULT([ok (${host_cpu})]) ARCH_MAX="arm" ;; *) AC_MSG_RESULT([no (${host_cpu})]) AC_MSG_ERROR([Unsupported host architecture. Sorry]) ;; esac #---------------------------------------------------------------------------- # Sometimes it's convenient to subvert the bi-arch build system and # just have a single build even though the underlying platform is # capable of both. Hence handle --enable-only64bit and # --enable-only32bit. Complain if both are issued :-) # [Actually, if either of these options are used, I think both get built, # but only one gets installed. So if you use an in-place build, both can be # used. --njn] # Check if a 64-bit only build has been requested AC_CACHE_CHECK([for a 64-bit only build], vg_cv_only64bit, [AC_ARG_ENABLE(only64bit, [ --enable-only64bit do a 64-bit only build], [vg_cv_only64bit=$enableval], [vg_cv_only64bit=no])]) # Check if a 32-bit only build has been requested AC_CACHE_CHECK([for a 32-bit only build], vg_cv_only32bit, [AC_ARG_ENABLE(only32bit, [ --enable-only32bit do a 32-bit only build], [vg_cv_only32bit=$enableval], [vg_cv_only32bit=no])]) # Stay sane if test x$vg_cv_only64bit = xyes -a x$vg_cv_only32bit = xyes; then AC_MSG_ERROR( [Nonsensical: both --enable-only64bit and --enable-only32bit.]) fi #---------------------------------------------------------------------------- # VGCONF_OS is the primary build OS, eg. "linux". It is passed in to # compilation of many C files via -VGO_$(VGCONF_OS) and # -VGP_$(VGCONF_ARCH_PRI)_$(VGCONF_OS). AC_MSG_CHECKING([for a supported OS]) AC_SUBST(VGCONF_OS) DEFAULT_SUPP="" case "${host_os}" in *linux*) AC_MSG_RESULT([ok (${host_os})]) VGCONF_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.*|3.*) AC_MSG_RESULT([2.6.x/3.x family (${kernel})]) AC_DEFINE([KERNEL_2_6], 1, [Define to 1 if you're using Linux 2.6.x or Linux 3.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 ;; *darwin*) AC_MSG_RESULT([ok (${host_os})]) VGCONF_OS="darwin" AC_DEFINE([DARWIN_10_5], 100500, [DARWIN_VERS value for Mac OS X 10.5]) AC_DEFINE([DARWIN_10_6], 100600, [DARWIN_VERS value for Mac OS X 10.6]) AC_DEFINE([DARWIN_10_7], 100700, [DARWIN_VERS value for Mac OS X 10.7]) AC_MSG_CHECKING([for the kernel version]) kernel=`uname -r` # Nb: for Darwin we set DEFAULT_SUPP here. That's because Darwin # has only one relevant version, the OS version. The `uname` check # is a good way to get that version (i.e. "Darwin 9.6.0" is Mac OS # X 10.5.6, and "Darwin 10.x" is Mac OS X 10.6.x Snow Leopard, # and possibly "Darwin 11.x" is Mac OS X 10.7.x Lion), # and we don't know of an macros similar to __GLIBC__ to get that info. # # XXX: `uname -r` won't do the right thing for cross-compiles, but # that's not a problem yet. # # jseward 21 Sept 2011: I seriously doubt whether V 3.7.0 will work # on OS X 10.5.x; I haven't tested yet, and only plan to test 3.7.0 # on 10.6.8 and 10.7.1. Although tempted to delete the configure # time support for 10.5 (the 9.* pattern just below), I'll leave it # in for now, just in case anybody wants to give it a try. But I'm # assuming that 3.7.0 is a Snow Leopard and Lion-only release. case "${kernel}" in 9.*) AC_MSG_RESULT([Darwin 9.x (${kernel}) / Mac OS X 10.5 Leopard]) AC_DEFINE([DARWIN_VERS], DARWIN_10_5, [Darwin / Mac OS X version]) DEFAULT_SUPP="darwin9.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="darwin9-drd.supp ${DEFAULT_SUPP}" ;; 10.*) AC_MSG_RESULT([Darwin 10.x (${kernel}) / Mac OS X 10.6 Snow Leopard]) AC_DEFINE([DARWIN_VERS], DARWIN_10_6, [Darwin / Mac OS X version]) DEFAULT_SUPP="darwin10.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="darwin10-drd.supp ${DEFAULT_SUPP}" ;; 11.*) AC_MSG_RESULT([Darwin 11.x (${kernel}) / Mac OS X 10.7 Lion]) AC_DEFINE([DARWIN_VERS], DARWIN_10_7, [Darwin / Mac OS X version]) # FIXME: change these to xx11.supp DEFAULT_SUPP="darwin11.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="darwin10-drd.supp ${DEFAULT_SUPP}" ;; *) AC_MSG_RESULT([unsupported (${kernel})]) AC_MSG_ERROR([Valgrind works on Darwin 10.x and 11.x (Mac OS X 10.6/7)]) ;; esac ;; *) AC_MSG_RESULT([no (${host_os})]) AC_MSG_ERROR([Valgrind is operating system specific. Sorry.]) ;; esac #---------------------------------------------------------------------------- # If we are building on a 64 bit platform test to see if the system # supports building 32 bit programs and disable 32 bit support if it # does not support building 32 bit programs case "$ARCH_MAX-$VGCONF_OS" in amd64-linux|ppc64-linux) AC_MSG_CHECKING([for 32 bit build support]) safe_CFLAGS=$CFLAGS CFLAGS="-m32" AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[ return 0; ]])], [ AC_MSG_RESULT([yes]) ], [ vg_cv_only64bit="yes" AC_MSG_RESULT([no]) ]) CFLAGS=$safe_CFLAGS;; esac if test x$vg_cv_only64bit = xyes -a x$vg_cv_only32bit = xyes; then AC_MSG_ERROR( [--enable-only32bit was specified but system does not support 32 bit builds]) fi #---------------------------------------------------------------------------- # VGCONF_ARCH_PRI is the arch for the primary build target, eg. "amd64". By # default it's the same as ARCH_MAX. But if, say, we do a build on an amd64 # machine, but --enable-only32bit has been requested, then ARCH_MAX (see # above) will be "amd64" since that reflects the most that this cpu can do, # but VGCONF_ARCH_PRI will be downgraded to "x86", since that reflects the # arch corresponding to the primary build (VGCONF_PLATFORM_PRI_CAPS). It is # passed in to compilation of many C files via -VGA_$(VGCONF_ARCH_PRI) and # -VGP_$(VGCONF_ARCH_PRI)_$(VGCONF_OS). AC_SUBST(VGCONF_ARCH_PRI) # VGCONF_ARCH_SEC is the arch for the secondary build target, eg. "x86". # It is passed in to compilation of many C files via -VGA_$(VGCONF_ARCH_SEC) # and -VGP_$(VGCONF_ARCH_SEC)_$(VGCONF_OS), if there is a secondary target. # It is empty if there is no secondary target. AC_SUBST(VGCONF_ARCH_SEC) # VGCONF_PLATFORM_PRI_CAPS is the primary build target, eg. "AMD64_LINUX". # The entire system, including regression and performance tests, will be # built for this target. The "_CAPS" indicates that the name is in capital # letters, and it also uses '_' rather than '-' as a separator, because it's # used to create various Makefile variables, which are all in caps by # convention and cannot contain '-' characters. This is in contrast to # VGCONF_ARCH_PRI and VGCONF_OS which are not in caps. AC_SUBST(VGCONF_PLATFORM_PRI_CAPS) # VGCONF_PLATFORM_SEC_CAPS is the secondary build target, if there is one. # Valgrind and tools will also be built for this target, but not the # regression or performance tests. # # By default, the primary arch is the same as the "max" arch, as commented # above (at the definition of ARCH_MAX). We may choose to downgrade it in # the big case statement just below here, in the case where we're building # on a 64 bit machine but have been requested only to do a 32 bit build. AC_SUBST(VGCONF_PLATFORM_SEC_CAPS) AC_MSG_CHECKING([for a supported CPU/OS combination]) # NB. The load address for a given platform may be specified in more # than one place, in some cases, depending on whether we're doing a biarch, # 32-bit only or 64-bit only build. eg see case for amd64-linux below. # Be careful to give consistent values in all subcases. Also, all four # valt_load_addres_{pri,sec}_{norml,inner} values must always be set, # even if it is to "0xUNSET". # case "$ARCH_MAX-$VGCONF_OS" in x86-linux) VGCONF_ARCH_PRI="x86" VGCONF_ARCH_SEC="" VGCONF_PLATFORM_PRI_CAPS="X86_LINUX" VGCONF_PLATFORM_SEC_CAPS="" valt_load_address_pri_norml="0x38000000" valt_load_address_pri_inner="0x28000000" valt_load_address_sec_norml="0xUNSET" valt_load_address_sec_inner="0xUNSET" AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})]) ;; amd64-linux) valt_load_address_sec_norml="0xUNSET" valt_load_address_sec_inner="0xUNSET" if test x$vg_cv_only64bit = xyes; then VGCONF_ARCH_PRI="amd64" VGCONF_ARCH_SEC="" VGCONF_PLATFORM_PRI_CAPS="AMD64_LINUX" VGCONF_PLATFORM_SEC_CAPS="" valt_load_address_pri_norml="0x38000000" valt_load_address_pri_inner="0x28000000" elif test x$vg_cv_only32bit = xyes; then VGCONF_ARCH_PRI="x86" VGCONF_ARCH_SEC="" VGCONF_PLATFORM_PRI_CAPS="X86_LINUX" VGCONF_PLATFORM_SEC_CAPS="" valt_load_address_pri_norml="0x38000000" valt_load_address_pri_inner="0x28000000" else VGCONF_ARCH_PRI="amd64" VGCONF_ARCH_SEC="x86" VGCONF_PLATFORM_PRI_CAPS="AMD64_LINUX" VGCONF_PLATFORM_SEC_CAPS="X86_LINUX" valt_load_address_pri_norml="0x38000000" valt_load_address_pri_inner="0x28000000" valt_load_address_sec_norml="0x38000000" valt_load_address_sec_inner="0x28000000" fi AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})]) ;; ppc32-linux) VGCONF_ARCH_PRI="ppc32" VGCONF_ARCH_SEC="" VGCONF_PLATFORM_PRI_CAPS="PPC32_LINUX" VGCONF_PLATFORM_SEC_CAPS="" valt_load_address_pri_norml="0x38000000" valt_load_address_pri_inner="0x28000000" valt_load_address_sec_norml="0xUNSET" valt_load_address_sec_inner="0xUNSET" AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})]) ;; ppc64-linux) valt_load_address_sec_norml="0xUNSET" valt_load_address_sec_inner="0xUNSET" if test x$vg_cv_only64bit = xyes; then VGCONF_ARCH_PRI="ppc64" VGCONF_ARCH_SEC="" VGCONF_PLATFORM_PRI_CAPS="PPC64_LINUX" VGCONF_PLATFORM_SEC_CAPS="" valt_load_address_pri_norml="0x38000000" valt_load_address_pri_inner="0x28000000" elif test x$vg_cv_only32bit = xyes; then VGCONF_ARCH_PRI="ppc32" VGCONF_ARCH_SEC="" VGCONF_PLATFORM_PRI_CAPS="PPC32_LINUX" VGCONF_PLATFORM_SEC_CAPS="" valt_load_address_pri_norml="0x38000000" valt_load_address_pri_inner="0x28000000" else VGCONF_ARCH_PRI="ppc64" VGCONF_ARCH_SEC="ppc32" VGCONF_PLATFORM_PRI_CAPS="PPC64_LINUX" VGCONF_PLATFORM_SEC_CAPS="PPC32_LINUX" valt_load_address_pri_norml="0x38000000" valt_load_address_pri_inner="0x28000000" valt_load_address_sec_norml="0x38000000" valt_load_address_sec_inner="0x28000000" fi AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})]) ;; # Darwin gets identified as 32-bit even when it supports 64-bit. # (Not sure why, possibly because 'uname' returns "i386"?) Just about # all Macs support both 32-bit and 64-bit, so we just build both. If # someone has a really old 32-bit only machine they can (hopefully?) # build with --enable-only32bit. See bug 243362. x86-darwin|amd64-darwin) ARCH_MAX="amd64" valt_load_address_sec_norml="0xUNSET" valt_load_address_sec_inner="0xUNSET" if test x$vg_cv_only64bit = xyes; then VGCONF_ARCH_PRI="amd64" VGCONF_ARCH_SEC="" VGCONF_PLATFORM_PRI_CAPS="AMD64_DARWIN" VGCONF_PLATFORM_SEC_CAPS="" valt_load_address_pri_norml="0x138000000" valt_load_address_pri_inner="0x128000000" elif test x$vg_cv_only32bit = xyes; then VGCONF_ARCH_PRI="x86" VGCONF_ARCH_SEC="" VGCONF_PLATFORM_PRI_CAPS="X86_DARWIN" VGCONF_PLATFORM_SEC_CAPS="" VGCONF_ARCH_PRI_CAPS="x86" valt_load_address_pri_norml="0x38000000" valt_load_address_pri_inner="0x28000000" else VGCONF_ARCH_PRI="amd64" VGCONF_ARCH_SEC="x86" VGCONF_PLATFORM_PRI_CAPS="AMD64_DARWIN" VGCONF_PLATFORM_SEC_CAPS="X86_DARWIN" valt_load_address_pri_norml="0x138000000" valt_load_address_pri_inner="0x128000000" valt_load_address_sec_norml="0x38000000" valt_load_address_sec_inner="0x28000000" fi AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})]) ;; arm-linux) VGCONF_ARCH_PRI="arm" VGCONF_PLATFORM_PRI_CAPS="ARM_LINUX" VGCONF_PLATFORM_SEC_CAPS="" valt_load_address_pri_norml="0x38000000" valt_load_address_pri_inner="0x28000000" valt_load_address_sec_norml="0xUNSET" valt_load_address_sec_inner="0xUNSET" AC_MSG_RESULT([ok (${host_cpu}-${host_os})]) ;; s390x-linux) VGCONF_ARCH_PRI="s390x" VGCONF_ARCH_SEC="" VGCONF_PLATFORM_PRI_CAPS="S390X_LINUX" VGCONF_PLATFORM_SEC_CAPS="" # we want to have the generated code close to the dispatcher valt_load_address_pri_norml="0x401000000" valt_load_address_pri_inner="0x410000000" valt_load_address_sec_norml="0xUNSET" valt_load_address_sec_inner="0xUNSET" AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})]) ;; *) VGCONF_ARCH_PRI="unknown" VGCONF_ARCH_SEC="unknown" VGCONF_PLATFORM_PRI_CAPS="UNKNOWN" VGCONF_PLATFORM_SEC_CAPS="UNKNOWN" valt_load_address_pri_norml="0xUNSET" valt_load_address_pri_inner="0xUNSET" valt_load_address_sec_norml="0xUNSET" valt_load_address_sec_inner="0xUNSET" AC_MSG_RESULT([no (${ARCH_MAX}-${VGCONF_OS})]) AC_MSG_ERROR([Valgrind is platform specific. Sorry. Please consider doing a port.]) ;; esac #---------------------------------------------------------------------------- # Set up VGCONF_ARCHS_INCLUDE_. Either one or two of these become # defined. AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_X86, test x$VGCONF_PLATFORM_PRI_CAPS = xX86_LINUX \ -o x$VGCONF_PLATFORM_SEC_CAPS = xX86_LINUX \ -o x$VGCONF_PLATFORM_PRI_CAPS = xX86_DARWIN \ -o x$VGCONF_PLATFORM_SEC_CAPS = xX86_DARWIN ) AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_AMD64, test x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_LINUX \ -o x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_DARWIN ) AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_PPC32, test x$VGCONF_PLATFORM_PRI_CAPS = xPPC32_LINUX \ -o x$VGCONF_PLATFORM_SEC_CAPS = xPPC32_LINUX ) AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_PPC64, test x$VGCONF_PLATFORM_PRI_CAPS = xPPC64_LINUX ) AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_ARM, test x$VGCONF_PLATFORM_PRI_CAPS = xARM_LINUX ) AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_S390X, test x$VGCONF_PLATFORM_PRI_CAPS = xS390X_LINUX ) # Set up VGCONF_PLATFORMS_INCLUDE_. Either one or two of these # become defined. AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_X86_LINUX, test x$VGCONF_PLATFORM_PRI_CAPS = xX86_LINUX \ -o x$VGCONF_PLATFORM_SEC_CAPS = xX86_LINUX) AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_AMD64_LINUX, test x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_LINUX) AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_PPC32_LINUX, test x$VGCONF_PLATFORM_PRI_CAPS = xPPC32_LINUX \ -o x$VGCONF_PLATFORM_SEC_CAPS = xPPC32_LINUX) AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_PPC64_LINUX, test x$VGCONF_PLATFORM_PRI_CAPS = xPPC64_LINUX) AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_ARM_LINUX, test x$VGCONF_PLATFORM_PRI_CAPS = xARM_LINUX) AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_S390X_LINUX, test x$VGCONF_PLATFORM_PRI_CAPS = xS390X_LINUX \ -o x$VGCONF_PLATFORM_SEC_CAPS = xS390X_LINUX) AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_X86_DARWIN, test x$VGCONF_PLATFORM_PRI_CAPS = xX86_DARWIN \ -o x$VGCONF_PLATFORM_SEC_CAPS = xX86_DARWIN) AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_AMD64_DARWIN, test x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_DARWIN) # Similarly, set up VGCONF_OS_IS_. Exactly one of these becomes defined. # Relies on the assumption that the primary and secondary targets are # for the same OS, so therefore only necessary to test the primary. AM_CONDITIONAL(VGCONF_OS_IS_LINUX, test x$VGCONF_PLATFORM_PRI_CAPS = xX86_LINUX \ -o x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_LINUX \ -o x$VGCONF_PLATFORM_PRI_CAPS = xPPC32_LINUX \ -o x$VGCONF_PLATFORM_PRI_CAPS = xPPC64_LINUX \ -o x$VGCONF_PLATFORM_PRI_CAPS = xARM_LINUX \ -o x$VGCONF_PLATFORM_PRI_CAPS = xS390X_LINUX) AM_CONDITIONAL(VGCONF_OS_IS_DARWIN, test x$VGCONF_PLATFORM_PRI_CAPS = xX86_DARWIN \ -o x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_DARWIN) # Sometimes, in the Makefile.am files, it's useful to know whether or not # there is a secondary target. AM_CONDITIONAL(VGCONF_HAVE_PLATFORM_SEC, test x$VGCONF_PLATFORM_SEC_CAPS != x) #---------------------------------------------------------------------------- # Inner Valgrind? #---------------------------------------------------------------------------- # Check if this should be built as an inner Valgrind, to be run within # another Valgrind. Choose the load address accordingly. AC_SUBST(VALT_LOAD_ADDRESS_PRI) AC_SUBST(VALT_LOAD_ADDRESS_SEC) AC_CACHE_CHECK([for 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_PRI=$valt_load_address_pri_inner VALT_LOAD_ADDRESS_SEC=$valt_load_address_sec_inner else VALT_LOAD_ADDRESS_PRI=$valt_load_address_pri_norml VALT_LOAD_ADDRESS_SEC=$valt_load_address_sec_norml fi #---------------------------------------------------------------------------- # Extra fine-tuning of installation directories #---------------------------------------------------------------------------- AC_ARG_WITH(tmpdir, [ --with-tmpdir=PATH Specify path for temporary files], tmpdir="$withval", tmpdir="/tmp") AC_DEFINE_UNQUOTED(VG_TMPDIR, "$tmpdir", [Temporary files directory]) #---------------------------------------------------------------------------- # Libc and suppressions #---------------------------------------------------------------------------- # This variable will collect the suppression files to be used. AC_SUBST(DEFAULT_SUPP) AC_CHECK_HEADER([features.h]) if test x$ac_cv_header_features_h = xyes; then rm -f conftest.$ac_ext cat <<_ACEOF >conftest.$ac_ext #include #if defined(__GNU_LIBRARY__) && defined(__GLIBC__) && defined(__GLIBC_MINOR__) glibc version is: __GLIBC__ __GLIBC_MINOR__ #endif _ACEOF GLIBC_VERSION="`$CPP conftest.$ac_ext | $SED -n 's/^glibc version is: //p' | $SED 's/ /./g'`" fi # not really a version check AC_EGREP_CPP([DARWIN_LIBC], [ #include #if defined(__DARWIN_VERS_1050) DARWIN_LIBC #endif ], GLIBC_VERSION="darwin") # not really a version check AC_EGREP_CPP([BIONIC_LIBC], [ #if defined(__ANDROID__) BIONIC_LIBC #endif ], GLIBC_VERSION="bionic") AC_MSG_CHECKING([the GLIBC_VERSION version]) case "${GLIBC_VERSION}" 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="glibc-2.2.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.2-LinuxThreads-helgrind.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_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="glibc-2.3.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_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="glibc-2.4.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}" ;; 2.5) AC_MSG_RESULT(2.5 family) AC_DEFINE([GLIBC_2_5], 1, [Define to 1 if you're using glibc 2.5.x]) DEFAULT_SUPP="glibc-2.5.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}" ;; 2.6) AC_MSG_RESULT(2.6 family) AC_DEFINE([GLIBC_2_6], 1, [Define to 1 if you're using glibc 2.6.x]) DEFAULT_SUPP="glibc-2.6.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}" ;; 2.7) AC_MSG_RESULT(2.7 family) AC_DEFINE([GLIBC_2_7], 1, [Define to 1 if you're using glibc 2.7.x]) DEFAULT_SUPP="glibc-2.X.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}" ;; 2.8) AC_MSG_RESULT(2.8 family) AC_DEFINE([GLIBC_2_8], 1, [Define to 1 if you're using glibc 2.8.x]) DEFAULT_SUPP="glibc-2.X.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}" ;; 2.9) AC_MSG_RESULT(2.9 family) AC_DEFINE([GLIBC_2_9], 1, [Define to 1 if you're using glibc 2.9.x]) DEFAULT_SUPP="glibc-2.X.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}" ;; 2.10) AC_MSG_RESULT(2.10 family) AC_DEFINE([GLIBC_2_10], 1, [Define to 1 if you're using glibc 2.10.x]) DEFAULT_SUPP="glibc-2.X.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}" ;; 2.11) AC_MSG_RESULT(2.11 family) AC_DEFINE([GLIBC_2_11], 1, [Define to 1 if you're using glibc 2.11.x]) DEFAULT_SUPP="glibc-2.X.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}" ;; 2.12) AC_MSG_RESULT(2.12 family) AC_DEFINE([GLIBC_2_12], 1, [Define to 1 if you're using glibc 2.12.x]) DEFAULT_SUPP="glibc-2.X.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}" ;; 2.13) AC_MSG_RESULT(2.13 family) AC_DEFINE([GLIBC_2_13], 1, [Define to 1 if you're using glibc 2.13.x]) DEFAULT_SUPP="glibc-2.X.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}" ;; 2.14) AC_MSG_RESULT(2.14 family) AC_DEFINE([GLIBC_2_14], 1, [Define to 1 if you're using glibc 2.14.x]) DEFAULT_SUPP="glibc-2.X.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}" ;; darwin) AC_MSG_RESULT(Darwin) AC_DEFINE([DARWIN_LIBC], 1, [Define to 1 if you're using Darwin]) # DEFAULT_SUPP set by kernel version check above. ;; bionic) AC_MSG_RESULT(Bionic) AC_DEFINE([BIONIC_LIBC], 1, [Define to 1 if you're using Bionic]) DEFAULT_SUPP="bionic.supp ${DEFAULT_SUPP}" ;; *) AC_MSG_RESULT([unsupported version ${GLIBC_VERSION}]) AC_MSG_ERROR([Valgrind requires glibc version 2.2 - 2.14]) AC_MSG_ERROR([or Darwin libc]) ;; esac AC_SUBST(GLIBC_VERSION) # Add default suppressions for the X client libraries. Make no # attempt to detect whether such libraries are installed on the # build machine (or even if any X facilities are present); just # add the suppressions antidisirregardless. DEFAULT_SUPP="xfree-4.supp ${DEFAULT_SUPP}" DEFAULT_SUPP="xfree-3.supp ${DEFAULT_SUPP}" # Add glibc and X11 suppressions for exp-sgcheck DEFAULT_SUPP="exp-sgcheck.supp ${DEFAULT_SUPP}" #---------------------------------------------------------------------------- # Platform variants? #---------------------------------------------------------------------------- # Normally the PLAT = (ARCH, OS) characterisation of the platform is enough. # But there are times where we need a bit more control. The motivating # and currently only case is Android: this is almost identical to arm-linux, # but not quite. So this introduces the concept of platform variant tags, # which get passed in the compile as -DVGPV___ along # with the main -DVGP__ definition. # # In almost all cases, the bit is "vanilla". But for Android # it is "android" instead. # # Consequently (eg), plain arm-linux would build with # # -DVGP_arm_linux -DVGPV_arm_linux_vanilla # # whilst an Android build would have # # -DVGP_arm_linux -DVGPV_arm_linux_android # # The setup of the platform variant is pushed relatively far down this # file in order that we can inspect any of the variables set above. # In the normal case .. VGCONF_PLATVARIANT="vanilla" # Android on ARM ? if test "$VGCONF_ARCH_PRI-$VGCONF_OS" = "arm-linux" \ -a "$GLIBC_VERSION" = "bionic"; then VGCONF_PLATVARIANT="android" fi AC_SUBST(VGCONF_PLATVARIANT) # FIXME: do we also want to define automake variables # VGCONF_PLATVARIANT_IS_, where WHATEVER is (currently) # VANILLA or ANDROID ? This would be in the style of VGCONF_ARCHS_INCLUDE, # VGCONF_PLATFORMS_INCLUDE and VGCONF_OS_IS above? Could easily enough # do that. Problem is that we can't do and-ing in Makefile.am's, but # that's what we'd need to do to use this, since what we'd want to write # is something like # # VGCONF_PLATFORMS_INCLUDE_ARM_LINUX && VGCONF_PLATVARIANT_IS_ANDROID # # Hmm. Can't think of a nice clean solution to this. AM_CONDITIONAL(VGCONF_PLATVARIANT_IS_VANILLA, test x$VGCONF_PLATVARIANT = xvanilla) AM_CONDITIONAL(VGCONF_PLATVARIANT_IS_ANDROID, test x$VGCONF_PLATVARIANT = xandroid) #---------------------------------------------------------------------------- # Checking for various library functions and other definitions #---------------------------------------------------------------------------- # Check for CLOCK_MONOTONIC AC_MSG_CHECKING([for CLOCK_MONOTONIC]) AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ #include ]], [[ struct timespec t; clock_gettime(CLOCK_MONOTONIC, &t); return 0; ]])], [ AC_MSG_RESULT([yes]) AC_DEFINE([HAVE_CLOCK_MONOTONIC], 1, [Define to 1 if you have the `CLOCK_MONOTONIC' constant.]) ], [ AC_MSG_RESULT([no]) ]) # Check for PTHREAD_RWLOCK_T AC_MSG_CHECKING([for pthread_rwlock_t]) AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ #define _GNU_SOURCE #include ]], [[ pthread_rwlock_t rwl; ]])], [ AC_MSG_RESULT([yes]) AC_DEFINE([HAVE_PTHREAD_RWLOCK_T], 1, [Define to 1 if you have the `pthread_rwlock_t' type.]) ], [ AC_MSG_RESULT([no]) ]) # Check for PTHREAD_MUTEX_ADAPTIVE_NP AC_MSG_CHECKING([for PTHREAD_MUTEX_ADAPTIVE_NP]) AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ #define _GNU_SOURCE #include ]], [[ return (PTHREAD_MUTEX_ADAPTIVE_NP); ]])], [ AC_MSG_RESULT([yes]) AC_DEFINE([HAVE_PTHREAD_MUTEX_ADAPTIVE_NP], 1, [Define to 1 if you have the `PTHREAD_MUTEX_ADAPTIVE_NP' constant.]) ], [ AC_MSG_RESULT([no]) ]) # Check for PTHREAD_MUTEX_ERRORCHECK_NP AC_MSG_CHECKING([for PTHREAD_MUTEX_ERRORCHECK_NP]) AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ #define _GNU_SOURCE #include ]], [[ return (PTHREAD_MUTEX_ERRORCHECK_NP); ]])], [ AC_MSG_RESULT([yes]) AC_DEFINE([HAVE_PTHREAD_MUTEX_ERRORCHECK_NP], 1, [Define to 1 if you have the `PTHREAD_MUTEX_ERRORCHECK_NP' constant.]) ], [ AC_MSG_RESULT([no]) ]) # Check for PTHREAD_MUTEX_RECURSIVE_NP AC_MSG_CHECKING([for PTHREAD_MUTEX_RECURSIVE_NP]) AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ #define _GNU_SOURCE #include ]], [[ return (PTHREAD_MUTEX_RECURSIVE_NP); ]])], [ AC_MSG_RESULT([yes]) AC_DEFINE([HAVE_PTHREAD_MUTEX_RECURSIVE_NP], 1, [Define to 1 if you have the `PTHREAD_MUTEX_RECURSIVE_NP' constant.]) ], [ AC_MSG_RESULT([no]) ]) # Check for PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP AC_MSG_CHECKING([for PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP]) AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ #define _GNU_SOURCE #include ]], [[ pthread_mutex_t m = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; return 0; ]])], [ AC_MSG_RESULT([yes]) AC_DEFINE([HAVE_PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP], 1, [Define to 1 if you have the `PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP' constant.]) ], [ AC_MSG_RESULT([no]) ]) # Check whether pthread_mutex_t has a member called __m_kind. AC_CHECK_MEMBER([pthread_mutex_t.__m_kind], [AC_DEFINE([HAVE_PTHREAD_MUTEX_T__M_KIND], 1, [Define to 1 if pthread_mutex_t has a member called __m_kind.]) ], [], [#include ]) # Check whether pthread_mutex_t has a member called __data.__kind. AC_CHECK_MEMBER([pthread_mutex_t.__data.__kind], [AC_DEFINE([HAVE_PTHREAD_MUTEX_T__DATA__KIND], 1, [Define to 1 if pthread_mutex_t has a member __data.__kind.]) ], [], [#include ]) # does this compiler support -maltivec and does it have the include file # ? AC_MSG_CHECKING([for Altivec]) safe_CFLAGS=$CFLAGS CFLAGS="-maltivec" AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ #include ]], [[ vector unsigned int v; ]])], [ ac_have_altivec=yes AC_MSG_RESULT([yes]) AC_DEFINE([HAS_ALTIVEC], 1, [Define to 1 if gcc/as can do Altivec.]) ], [ ac_have_altivec=no AC_MSG_RESULT([no]) ]) CFLAGS=$safe_CFLAGS AM_CONDITIONAL([HAS_ALTIVEC], [test x$ac_have_altivec = xyes]) # Check that both: the compiler supports -mvsx and that the assembler # understands VSX instructions. If either of those doesn't work, # conclude that we can't do VSX. NOTE: basically this is a kludge # in that it conflates two things that should be separate -- whether # the compiler understands the flag vs whether the assembler # understands the opcodes. This really ought to be cleaned up # and done properly, like it is for x86/x86_64. AC_MSG_CHECKING([for VSX]) safe_CFLAGS=$CFLAGS CFLAGS="-mvsx" AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ #include ]], [[ vector unsigned int v; __asm__ __volatile__("xsmaddadp 32, 32, 33" ::: "memory","cc"); ]])], [ ac_have_vsx=yes AC_MSG_RESULT([yes]) ], [ ac_have_vsx=no AC_MSG_RESULT([no]) ]) CFLAGS=$safe_CFLAGS AM_CONDITIONAL(HAS_VSX, test x$ac_have_vsx = xyes) # Check for pthread_create@GLIBC2.0 AC_MSG_CHECKING([for pthread_create@GLIBC2.0()]) safe_CFLAGS=$CFLAGS CFLAGS="-lpthread" AC_LINK_IFELSE([AC_LANG_PROGRAM([[ extern int pthread_create_glibc_2_0(void*, const void*, void *(*)(void*), void*); __asm__(".symver pthread_create_glibc_2_0, pthread_create@GLIBC_2.0"); ]], [[ #ifdef __powerpc__ /* * Apparently on PowerPC linking this program succeeds and generates an * executable with the undefined symbol pthread_create@GLIBC_2.0. */ #error This test does not work properly on PowerPC. #else pthread_create_glibc_2_0(0, 0, 0, 0); #endif return 0; ]])], [ ac_have_pthread_create_glibc_2_0=yes AC_MSG_RESULT([yes]) AC_DEFINE([HAVE_PTHREAD_CREATE_GLIBC_2_0], 1, [Define to 1 if you have the `pthread_create@glibc2.0' function.]) ], [ ac_have_pthread_create_glibc_2_0=no AC_MSG_RESULT([no]) ]) CFLAGS=$safe_CFLAGS AM_CONDITIONAL(HAVE_PTHREAD_CREATE_GLIBC_2_0, test x$ac_have_pthread_create_glibc_2_0 = xyes) # Check for eventfd_t, eventfd() and eventfd_read() AC_MSG_CHECKING([for eventfd()]) AC_LINK_IFELSE([AC_LANG_PROGRAM([[ #include ]], [[ eventfd_t ev; int fd; fd = eventfd(5, 0); eventfd_read(fd, &ev); return 0; ]])], [ AC_MSG_RESULT([yes]) AC_DEFINE([HAVE_EVENTFD], 1, [Define to 1 if you have the `eventfd' function.]) AC_DEFINE([HAVE_EVENTFD_READ], 1, [Define to 1 if you have the `eventfd_read' function.]) ], [ AC_MSG_RESULT([no]) ]) #---------------------------------------------------------------------------- # Checking for supported compiler flags. #---------------------------------------------------------------------------- # does this compiler support -m32 ? AC_MSG_CHECKING([if gcc accepts -m32]) safe_CFLAGS=$CFLAGS CFLAGS="-m32" AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 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 -m64 ? AC_MSG_CHECKING([if gcc accepts -m64]) safe_CFLAGS=$CFLAGS CFLAGS="-m64" AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ return 0; ]])], [ FLAG_M64="-m64" AC_MSG_RESULT([yes]) ], [ FLAG_M64="" AC_MSG_RESULT([no]) ]) CFLAGS=$safe_CFLAGS AC_SUBST(FLAG_M64) # does this compiler support -mmmx ? AC_MSG_CHECKING([if gcc accepts -mmmx]) safe_CFLAGS=$CFLAGS CFLAGS="-mmmx" AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 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_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 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_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 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_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 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 -Wno-empty-body ? AC_MSG_CHECKING([if gcc accepts -Wno-empty-body]) safe_CFLAGS=$CFLAGS CFLAGS="-Wno-empty-body" AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[ return 0; ]])], [ AC_SUBST([FLAG_W_NO_EMPTY_BODY], [-Wno-empty-body]) AC_MSG_RESULT([yes]) ], [ AC_SUBST([FLAG_W_NO_EMPTY_BODY], []) AC_MSG_RESULT([no]) ]) CFLAGS=$safe_CFLAGS # does this compiler support -Wno-format-zero-length ? AC_MSG_CHECKING([if gcc accepts -Wno-format-zero-length]) safe_CFLAGS=$CFLAGS CFLAGS="-Wno-format-zero-length" AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[ return 0; ]])], [ AC_SUBST([FLAG_W_NO_FORMAT_ZERO_LENGTH], [-Wno-format-zero-length]) AC_MSG_RESULT([yes]) ], [ AC_SUBST([FLAG_W_NO_FORMAT_ZERO_LENGTH], []) AC_MSG_RESULT([no]) ]) CFLAGS=$safe_CFLAGS # does this compiler support -Wno-nonnull ? AC_MSG_CHECKING([if gcc accepts -Wno-nonnull]) safe_CFLAGS=$CFLAGS CFLAGS="-Wno-nonnull" AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[ return 0; ]])], [ AC_SUBST([FLAG_W_NO_NONNULL], [-Wno-nonnull]) AC_MSG_RESULT([yes]) ], [ AC_SUBST([FLAG_W_NO_NONNULL], []) AC_MSG_RESULT([no]) ]) CFLAGS=$safe_CFLAGS # does this compiler support -Wno-overflow ? AC_MSG_CHECKING([if gcc accepts -Wno-overflow]) safe_CFLAGS=$CFLAGS CFLAGS="-Wno-overflow" AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[ return 0; ]])], [ AC_SUBST([FLAG_W_NO_OVERFLOW], [-Wno-overflow]) AC_MSG_RESULT([yes]) ], [ AC_SUBST([FLAG_W_NO_OVERFLOW], []) AC_MSG_RESULT([no]) ]) CFLAGS=$safe_CFLAGS # does this compiler support -Wno-uninitialized ? AC_MSG_CHECKING([if gcc accepts -Wno-uninitialized]) safe_CFLAGS=$CFLAGS CFLAGS="-Wno-uninitialized" AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[ return 0; ]])], [ AC_SUBST([FLAG_W_NO_UNINITIALIZED], [-Wno-uninitialized]) AC_MSG_RESULT([yes]) ], [ AC_SUBST([FLAG_W_NO_UNINITIALIZED], []) AC_MSG_RESULT([no]) ]) CFLAGS=$safe_CFLAGS # does this compiler support -Wextra or the older -W ? AC_MSG_CHECKING([if gcc accepts -Wextra or -W]) safe_CFLAGS=$CFLAGS CFLAGS="-Wextra" AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[ return 0; ]])], [ AC_SUBST([FLAG_W_EXTRA], [-Wextra]) AC_MSG_RESULT([-Wextra]) ], [ CFLAGS="-W" AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[ return 0; ]])], [ AC_SUBST([FLAG_W_EXTRA], [-W]) AC_MSG_RESULT([-W]) ], [ AC_SUBST([FLAG_W_EXTRA], []) AC_MSG_RESULT([not supported]) ]) ]) CFLAGS=$safe_CFLAGS # does this compiler support -fno-stack-protector ? AC_MSG_CHECKING([if gcc accepts -fno-stack-protector]) safe_CFLAGS=$CFLAGS CFLAGS="-fno-stack-protector" AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ return 0; ]])], [ no_stack_protector=yes FLAG_FNO_STACK_PROTECTOR="-fno-stack-protector" AC_MSG_RESULT([yes]) ], [ no_stack_protector=no FLAG_FNO_STACK_PROTECTOR="" AC_MSG_RESULT([no]) ]) CFLAGS=$safe_CFLAGS AC_SUBST(FLAG_FNO_STACK_PROTECTOR) if test x$no_stack_protector = xyes; then CFLAGS="$CFLAGS -fno-stack-protector" fi # does this compiler support --param inline-unit-growth=... ? AC_MSG_CHECKING([if gcc accepts --param inline-unit-growth]) safe_CFLAGS=$CFLAGS CFLAGS="--param inline-unit-growth=900" AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[ return 0; ]])], [ AC_SUBST([FLAG_UNLIMITED_INLINE_UNIT_GROWTH], ["--param inline-unit-growth=900"]) AC_MSG_RESULT([yes]) ], [ AC_SUBST([FLAG_UNLIMITED_INLINE_UNIT_GROWTH], [""]) AC_MSG_RESULT([no]) ]) CFLAGS=$safe_CFLAGS # does the linker support -Wl,--build-id=none ? Note, it's # important that we test indirectly via whichever C compiler # is selected, rather than testing /usr/bin/ld or whatever # directly. AC_MSG_CHECKING([if the linker accepts -Wl,--build-id=none]) safe_CFLAGS=$CFLAGS CFLAGS="-Wl,--build-id=none" AC_LINK_IFELSE( [AC_LANG_PROGRAM([ ], [return 0;])], [ AC_SUBST([FLAG_NO_BUILD_ID], ["-Wl,--build-id=none"]) AC_MSG_RESULT([yes]) ], [ AC_SUBST([FLAG_NO_BUILD_ID], [""]) AC_MSG_RESULT([no]) ]) CFLAGS=$safe_CFLAGS # does the ppc assembler support "mtocrf" et al? AC_MSG_CHECKING([if ppc32/64 as supports mtocrf/mfocrf]) AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ __asm__ __volatile__("mtocrf 4,0"); __asm__ __volatile__("mfocrf 0,4"); ]])], [ ac_have_as_ppc_mftocrf=yes AC_MSG_RESULT([yes]) ], [ ac_have_as_ppc_mftocrf=no AC_MSG_RESULT([no]) ]) if test x$ac_have_as_ppc_mftocrf = xyes ; then AC_DEFINE(HAVE_AS_PPC_MFTOCRF, 1, [Define to 1 if as supports mtocrf/mfocrf.]) fi CFLAGS=$safe_CFLAGS # does the x86/amd64 assembler understand SSE3 instructions? # Note, this doesn't generate a C-level symbol. It generates a # automake-level symbol (BUILD_SSE3_TESTS), used in test Makefile.am's AC_MSG_CHECKING([if x86/amd64 assembler speaks SSE3]) AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ do { long long int x; __asm__ __volatile__("fisttpq (%0)" : :"r"(&x) ); } while (0) ]])], [ ac_have_as_sse3=yes AC_MSG_RESULT([yes]) ], [ ac_have_as_sse3=no AC_MSG_RESULT([no]) ]) AM_CONDITIONAL(BUILD_SSE3_TESTS, test x$ac_have_as_sse3 = xyes) # Ditto for SSSE3 instructions (note extra S) # Note, this doesn't generate a C-level symbol. It generates a # automake-level symbol (BUILD_SSSE3_TESTS), used in test Makefile.am's AC_MSG_CHECKING([if x86/amd64 assembler speaks SSSE3]) save_CFLAGS="$CFLAGS" CFLAGS="$CFLAGS -msse" AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ do { long long int x; __asm__ __volatile__( "pabsb (%0),%%xmm7" : : "r"(&x) : "xmm7" ); } while (0) ]])], [ ac_have_as_ssse3=yes AC_MSG_RESULT([yes]) ], [ ac_have_as_ssse3=no AC_MSG_RESULT([no]) ]) CFLAGS="$save_CFLAGS" AM_CONDITIONAL(BUILD_SSSE3_TESTS, test x$ac_have_as_ssse3 = xyes) # does the x86/amd64 assembler understand the PCLMULQDQ instruction? # Note, this doesn't generate a C-level symbol. It generates a # automake-level symbol (BUILD_PCLMULQDQ_TESTS), used in test Makefile.am's AC_MSG_CHECKING([if x86/amd64 assembler supports 'pclmulqdq']) AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ do { __asm__ __volatile__( "pclmulqdq \$17,%%xmm6,%%xmm7" : : : "xmm6", "xmm7" ); } while (0) ]])], [ ac_have_as_pclmulqdq=yes AC_MSG_RESULT([yes]) ], [ ac_have_as_pclmulqdq=no AC_MSG_RESULT([no]) ]) AM_CONDITIONAL(BUILD_PCLMULQDQ_TESTS, test x$ac_have_as_pclmulqdq = xyes) # does the x86/amd64 assembler understand the LZCNT instruction? # Note, this doesn't generate a C-level symbol. It generates a # automake-level symbol (BUILD_LZCNT_TESTS), used in test Makefile.am's AC_MSG_CHECKING([if x86/amd64 assembler supports 'lzcnt']) AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ do { __asm__ __volatile__("lzcnt %rax,%rax"); } while (0) ]])], [ ac_have_as_lzcnt=yes AC_MSG_RESULT([yes]) ], [ ac_have_as_lzcnt=no AC_MSG_RESULT([no]) ]) AM_CONDITIONAL([BUILD_LZCNT_TESTS], [test x$ac_have_as_lzcnt = xyes]) # does the x86/amd64 assembler understand SSE 4.2 instructions? # Note, this doesn't generate a C-level symbol. It generates a # automake-level symbol (BUILD_SSE42_TESTS), used in test Makefile.am's AC_MSG_CHECKING([if x86/amd64 assembler speaks SSE4.2]) AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ do { long long int x; __asm__ __volatile__( "crc32q %%r15,%%r15" : : : "r15" ); } while (0) ]])], [ ac_have_as_sse42=yes AC_MSG_RESULT([yes]) ], [ ac_have_as_sse42=no AC_MSG_RESULT([no]) ]) AM_CONDITIONAL(BUILD_SSE42_TESTS, test x$ac_have_as_sse42 = xyes) # XXX JRS 2010 Oct 13: what is this for? For sure, we don't need this # when building the tool executables. I think we should get rid of it. # # Check for TLS support in the compiler and linker AC_LINK_IFELSE([AC_LANG_PROGRAM([[static __thread int foo;]], [[return foo;]])], [vg_cv_linktime_tls=yes], [vg_cv_linktime_tls=no]) # Native compilation: check whether running a program using TLS succeeds. # Linking only is not sufficient -- e.g. on Red Hat 7.3 linking TLS programs # succeeds but running programs using TLS fails. # Cross-compiling: check whether linking a program using TLS succeeds. 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], [vg_cv_tls=$vg_cv_linktime_tls])])]) if test "$vg_cv_tls" = yes; then AC_DEFINE([HAVE_TLS], 1, [can use __thread to define thread-local variables]) fi #---------------------------------------------------------------------------- # Checks for C header files. #---------------------------------------------------------------------------- AC_HEADER_STDC AC_CHECK_HEADERS([ \ asm/unistd.h \ endian.h \ mqueue.h \ sys/endian.h \ sys/epoll.h \ sys/eventfd.h \ sys/klog.h \ sys/poll.h \ sys/signal.h \ sys/signalfd.h \ sys/syscall.h \ sys/time.h \ sys/types.h \ ]) # Verify whether the header is usable. AC_MSG_CHECKING([if is usable]) AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ #include ]], [[ return FUTEX_WAIT; ]])], [ ac_have_usable_linux_futex_h=yes AC_DEFINE([HAVE_USABLE_LINUX_FUTEX_H], 1, [Define to 1 if you have a usable header file.]) AC_MSG_RESULT([yes]) ], [ ac_have_usable_linux_futex_h=no AC_MSG_RESULT([no]) ]) #---------------------------------------------------------------------------- # 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_CHECK_LIB([pthread], [pthread_create]) AC_CHECK_LIB([rt], [clock_gettime]) AC_CHECK_FUNCS([ \ clock_gettime\ epoll_create \ epoll_pwait \ klogctl \ mallinfo \ memchr \ memset \ mkdir \ mremap \ ppoll \ pthread_barrier_init \ pthread_condattr_setclock \ pthread_mutex_timedlock \ pthread_rwlock_timedrdlock \ pthread_rwlock_timedwrlock \ pthread_spin_lock \ pthread_yield \ readlinkat \ semtimedop \ signalfd \ sigwaitinfo \ strchr \ strdup \ strpbrk \ strrchr \ strstr \ syscall \ utimensat \ ]) # AC_CHECK_LIB adds any library found to the variable LIBS, and links these # libraries with any shared object and/or executable. This is NOT what we # want for e.g. vgpreload_core-x86-linux.so LIBS="" AM_CONDITIONAL([HAVE_PTHREAD_BARRIER], [test x$ac_cv_func_pthread_barrier_init = xyes]) AM_CONDITIONAL([HAVE_PTHREAD_MUTEX_TIMEDLOCK], [test x$ac_cv_func_pthread_mutex_timedlock = xyes]) AM_CONDITIONAL([HAVE_PTHREAD_SPINLOCK], [test x$ac_cv_func_pthread_spin_lock = xyes]) #---------------------------------------------------------------------------- # MPI checks #---------------------------------------------------------------------------- # Do we have a useable MPI setup on the primary and/or secondary targets? # On Linux, by default, assumes mpicc and -m32/-m64 # Note: this is a kludge in that it assumes the specified mpicc # understands -m32/-m64 regardless of what is specified using # --with-mpicc=. MPI_CC="mpicc" mflag_primary= if test x$VGCONF_PLATFORM_PRI_CAPS = xX86_LINUX \ -o x$VGCONF_PLATFORM_PRI_CAPS = xPPC32_LINUX \ -o x$VGCONF_PLATFORM_PRI_CAPS = xARM_LINUX ; then mflag_primary=$FLAG_M32 elif test x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_LINUX \ -o x$VGCONF_PLATFORM_PRI_CAPS = xPPC64_LINUX \ -o x$VGCONF_PLATFORM_PRI_CAPS = xS390X_LINUX ; then mflag_primary=$FLAG_M64 fi mflag_secondary= if test x$VGCONF_PLATFORM_SEC_CAPS = xX86_LINUX \ -o x$VGCONF_PLATFORM_SEC_CAPS = xPPC32_LINUX ; then mflag_secondary=$FLAG_M32 fi AC_ARG_WITH(mpicc, [ --with-mpicc= Specify name of MPI2-ised C compiler], MPI_CC=$withval ) AC_SUBST(MPI_CC) ## See if MPI_CC works for the primary target ## AC_MSG_CHECKING([primary target for usable MPI2-compliant C compiler and mpi.h]) saved_CC=$CC saved_CFLAGS=$CFLAGS CC=$MPI_CC CFLAGS=$mflag_primary AC_LINK_IFELSE([AC_LANG_PROGRAM([[ #include #include ]], [[ int r = MPI_Init(NULL,NULL); r |= MPI_Type_get_contents( MPI_INT, 0,0,0, NULL,NULL,NULL ); return r; ]])], [ ac_have_mpi2_pri=yes AC_MSG_RESULT([yes, $MPI_CC]) ], [ ac_have_mpi2_pri=no AC_MSG_RESULT([no]) ]) CC=$saved_CC CFLAGS=$saved_CFLAGS AM_CONDITIONAL(BUILD_MPIWRAP_PRI, test x$ac_have_mpi2_pri = xyes) ## See if MPI_CC works for the secondary target. Complication: what if ## there is no secondary target? We need this to then fail. ## Kludge this by making MPI_CC something which will surely fail in ## such a case. ## AC_MSG_CHECKING([secondary target for usable MPI2-compliant C compiler and mpi.h]) saved_CC=$CC saved_CFLAGS=$CFLAGS if test x$VGCONF_PLATFORM_SEC_CAPS = x ; then CC="$MPI_CC this will surely fail" else CC=$MPI_CC fi CFLAGS=$mflag_secondary AC_LINK_IFELSE([AC_LANG_PROGRAM([[ #include #include ]], [[ int r = MPI_Init(NULL,NULL); r |= MPI_Type_get_contents( MPI_INT, 0,0,0, NULL,NULL,NULL ); return r; ]])], [ ac_have_mpi2_sec=yes AC_MSG_RESULT([yes, $MPI_CC]) ], [ ac_have_mpi2_sec=no AC_MSG_RESULT([no]) ]) CC=$saved_CC CFLAGS=$saved_CFLAGS AM_CONDITIONAL(BUILD_MPIWRAP_SEC, test x$ac_have_mpi2_sec = xyes) #---------------------------------------------------------------------------- # Other library checks #---------------------------------------------------------------------------- # There now follow some tests for Boost, and OpenMP. These # tests are present because Drd has some regression tests that use # these packages. All regression test programs all compiled only # for the primary target. And so it is important that the configure # checks that follow, use the correct -m32 or -m64 flag for the # primary target (called $mflag_primary). Otherwise, we can end up # in a situation (eg) where, on amd64-linux, the test for Boost checks # for usable 64-bit Boost facilities, but because we are doing a 32-bit # only build (meaning, the primary target is x86-linux), the build # of the regtest programs that use Boost fails, because they are # build as 32-bit (IN THIS EXAMPLE). # # Hence: ALWAYS USE $mflag_primary FOR CONFIGURE TESTS FOR FACILITIES # NEEDED BY THE REGRESSION TEST PROGRAMS. # Check whether the boost library 1.35 or later has been installed. # The Boost.Threads library has undergone a major rewrite in version 1.35.0. AC_MSG_CHECKING([for boost]) AC_LANG(C++) safe_CXXFLAGS=$CXXFLAGS CXXFLAGS="-lboost_thread-mt $mflag_primary" AC_LINK_IFELSE([AC_LANG_SOURCE([ #include static void thread_func(void) { } int main(int argc, char** argv) { boost::thread t(thread_func); return 0; } ])], [ ac_have_boost_1_35=yes AC_SUBST([BOOST_CFLAGS], []) AC_SUBST([BOOST_LIBS], ["${CXXFLAGS}"]) AC_MSG_RESULT([yes]) ], [ ac_have_boost_1_35=no AC_MSG_RESULT([no]) ]) CXXFLAGS=$safe_CXXFLAGS AC_LANG(C) AM_CONDITIONAL([HAVE_BOOST_1_35], [test x$ac_have_boost_1_35 = xyes]) # does this compiler support -fopenmp, does it have the include file # and does it have libgomp ? AC_MSG_CHECKING([for OpenMP]) safe_CFLAGS=$CFLAGS CFLAGS="-fopenmp $mflag_primary" AC_LINK_IFELSE([AC_LANG_SOURCE([ #include int main(int argc, char** argv) { omp_set_dynamic(0); return 0; } ])], [ ac_have_openmp=yes AC_MSG_RESULT([yes]) ], [ ac_have_openmp=no AC_MSG_RESULT([no]) ]) CFLAGS=$safe_CFLAGS AM_CONDITIONAL([HAVE_OPENMP], [test x$ac_have_openmp = xyes]) # does this compiler have built-in functions for atomic memory access for the # primary target ? AC_MSG_CHECKING([if gcc supports __sync_add_and_fetch for the primary target]) safe_CFLAGS=$CFLAGS CFLAGS="$mflag_primary" AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[ int variable = 1; return (__sync_bool_compare_and_swap(&variable, 1, 2) && __sync_add_and_fetch(&variable, 1) ? 1 : 0) ]])], [ ac_have_builtin_atomic_primary=yes AC_MSG_RESULT([yes]) AC_DEFINE(HAVE_BUILTIN_ATOMIC, 1, [Define to 1 if gcc supports __sync_bool_compare_and_swap() and __sync_add_and_fetch() for the primary target]) ], [ ac_have_builtin_atomic_primary=no AC_MSG_RESULT([no]) ]) CFLAGS=$safe_CFLAGS AM_CONDITIONAL([HAVE_BUILTIN_ATOMIC], [test x$ac_have_builtin_atomic_primary = xyes]) # does this compiler have built-in functions for atomic memory access for the # secondary target ? if test x$VGCONF_PLATFORM_SEC_CAPS != x; then AC_MSG_CHECKING([if gcc supports __sync_add_and_fetch for the secondary target]) safe_CFLAGS=$CFLAGS CFLAGS="$mflag_secondary" AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[ int variable = 1; return (__sync_add_and_fetch(&variable, 1) ? 1 : 0) ]])], [ ac_have_builtin_atomic_secondary=yes AC_MSG_RESULT([yes]) ], [ ac_have_builtin_atomic_secondary=no AC_MSG_RESULT([no]) ]) CFLAGS=$safe_CFLAGS fi AM_CONDITIONAL([HAVE_BUILTIN_ATOMIC_SECONDARY], [test x$ac_have_builtin_atomic_secondary = xyes]) # does this compiler have built-in functions for atomic memory access on # 64-bit integers for all targets ? AC_MSG_CHECKING([if gcc supports __sync_add_and_fetch on uint64_t for all targets]) AC_LINK_IFELSE([AC_LANG_PROGRAM([[ #include ]], [[ uint64_t variable = 1; return __sync_add_and_fetch(&variable, 1) ]])], [ ac_have_builtin_atomic64_primary=yes ], [ ac_have_builtin_atomic64_primary=no ]) if test x$VGCONF_PLATFORM_SEC_CAPS != x; then safe_CFLAGS=$CFLAGS CFLAGS="$mflag_secondary" AC_LINK_IFELSE([AC_LANG_PROGRAM([[ #include ]], [[ uint64_t variable = 1; return __sync_add_and_fetch(&variable, 1) ]])], [ ac_have_builtin_atomic64_secondary=yes ], [ ac_have_builtin_atomic64_secondary=no ]) CFLAGS=$safe_CFLAGS fi if test x$ac_have_builtin_atomic64_primary = xyes && \ test x$VGCONF_PLATFORM_SEC_CAPS = x \ -o x$ac_have_builtin_atomic64_secondary = xyes; then AC_MSG_RESULT([yes]) ac_have_builtin_atomic64=yes else AC_MSG_RESULT([no]) ac_have_builtin_atomic64=no fi AM_CONDITIONAL([HAVE_BUILTIN_ATOMIC64], [test x$ac_have_builtin_atomic64 = xyes]) # does g++ have built-in functions for atomic memory access ? AC_MSG_CHECKING([if g++ supports __sync_add_and_fetch]) safe_CXXFLAGS=$CXXFLAGS CXXFLAGS="$mflag_primary" AC_LANG_PUSH(C++) AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[ int variable = 1; return (__sync_bool_compare_and_swap(&variable, 1, 2) && __sync_add_and_fetch(&variable, 1) ? 1 : 0) ]])], [ ac_have_builtin_atomic_cxx=yes AC_MSG_RESULT([yes]) AC_DEFINE(HAVE_BUILTIN_ATOMIC_CXX, 1, [Define to 1 if g++ supports __sync_bool_compare_and_swap() and __sync_add_and_fetch()]) ], [ ac_have_builtin_atomic_cxx=no AC_MSG_RESULT([no]) ]) AC_LANG_POP(C++) CXXFLAGS=$safe_CXXFLAGS AM_CONDITIONAL([HAVE_BUILTIN_ATOMIC_CXX], [test x$ac_have_builtin_atomic_cxx = xyes]) if test x$ac_have_usable_linux_futex_h = xyes \ -a x$ac_have_builtin_atomic_primary = xyes; then ac_enable_linux_ticket_lock_primary=yes fi AM_CONDITIONAL([ENABLE_LINUX_TICKET_LOCK_PRIMARY], [test x$ac_enable_linux_ticket_lock_primary = xyes]) if test x$VGCONF_PLATFORM_SEC_CAPS != x \ -a x$ac_have_usable_linux_futex_h = xyes \ -a x$ac_have_builtin_atomic_secondary = xyes; then ac_enable_linux_ticket_lock_secondary=yes fi AM_CONDITIONAL([ENABLE_LINUX_TICKET_LOCK_SECONDARY], [test x$ac_enable_linux_ticket_lock_secondary = xyes]) # does libstdc++ support annotating shared pointers ? AC_MSG_CHECKING([if libstdc++ supports annotating shared pointers]) safe_CXXFLAGS=$CFLAGS CXXFLAGS="-std=c++0x" AC_LANG_PUSH(C++) AC_LINK_IFELSE([AC_LANG_PROGRAM([[ #include ]], [[ std::shared_ptr p ]])], [ ac_have_shared_ptr=yes ], [ ac_have_shared_ptr=no ]) if test x$ac_have_shared_ptr = xyes; then # If compilation of the program below fails because of a syntax error # triggered by substituting one of the annotation macros then that # means that libstdc++ supports these macros. AC_LINK_IFELSE([AC_LANG_PROGRAM([[ #define _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(a) (a)---- #define _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(a) (a)---- #include ]], [[ std::shared_ptr p ]])], [ ac_have_shared_pointer_annotation=no AC_MSG_RESULT([no]) ], [ ac_have_shared_pointer_annotation=yes AC_MSG_RESULT([yes]) AC_DEFINE(HAVE_SHARED_POINTER_ANNOTATION, 1, [Define to 1 if libstd++ supports annotating shared pointers]) ]) else ac_have_shared_pointer_annotation=no AC_MSG_RESULT([no]) fi AC_LANG_POP(C++) CXXFLAGS=$safe_CXXFLAGS AM_CONDITIONAL([HAVE_SHARED_POINTER_ANNOTATION], [test x$ac_have_shared_pointer_annotation = xyes]) #---------------------------------------------------------------------------- # Ok. We're done checking. #---------------------------------------------------------------------------- # Nb: VEX/Makefile is generated from Makefile.vex.in. AC_CONFIG_FILES([ Makefile VEX/Makefile:Makefile.vex.in valgrind.spec valgrind.pc glibc-2.X.supp docs/Makefile tests/Makefile tests/vg_regtest perf/Makefile perf/vg_perf gdbserver_tests/Makefile include/Makefile auxprogs/Makefile mpi/Makefile coregrind/Makefile memcheck/Makefile memcheck/tests/Makefile memcheck/tests/amd64/Makefile memcheck/tests/x86/Makefile memcheck/tests/linux/Makefile memcheck/tests/darwin/Makefile memcheck/tests/amd64-linux/Makefile memcheck/tests/x86-linux/Makefile memcheck/tests/ppc32/Makefile memcheck/tests/ppc64/Makefile memcheck/perf/Makefile cachegrind/Makefile cachegrind/tests/Makefile cachegrind/tests/x86/Makefile cachegrind/cg_annotate cachegrind/cg_diff callgrind/Makefile callgrind/callgrind_annotate callgrind/callgrind_control callgrind/tests/Makefile helgrind/Makefile helgrind/tests/Makefile massif/Makefile massif/tests/Makefile massif/perf/Makefile massif/ms_print lackey/Makefile lackey/tests/Makefile none/Makefile none/tests/Makefile none/tests/amd64/Makefile none/tests/ppc32/Makefile none/tests/ppc64/Makefile none/tests/x86/Makefile none/tests/arm/Makefile none/tests/s390x/Makefile none/tests/linux/Makefile none/tests/darwin/Makefile none/tests/x86-linux/Makefile exp-sgcheck/Makefile exp-sgcheck/tests/Makefile drd/Makefile drd/scripts/download-and-build-splash2 drd/tests/Makefile exp-bbv/Makefile exp-bbv/tests/Makefile exp-bbv/tests/x86/Makefile exp-bbv/tests/x86-linux/Makefile exp-bbv/tests/amd64-linux/Makefile exp-bbv/tests/ppc32-linux/Makefile exp-bbv/tests/arm-linux/Makefile exp-dhat/Makefile exp-dhat/tests/Makefile ]) AC_CONFIG_FILES([coregrind/link_tool_exe_linux], [chmod +x coregrind/link_tool_exe_linux]) AC_CONFIG_FILES([coregrind/link_tool_exe_darwin], [chmod +x coregrind/link_tool_exe_darwin]) AC_OUTPUT cat<