configure.ac

   1
   2 ##------------------------------------------------------------##
   3 #
   4 # The multiple-architecture stuff in this file is pretty
   5 # cryptic.  Read docs/internals/multiple-architectures.txt
   6 # for at least a partial explanation of what is going on.
   7 #
   8 ##------------------------------------------------------------##
   9
  10 # Process this file with autoconf to produce a configure script.
  11 AC_INIT([Valgrind],[3.11.0.SVN],[valgrind-users@lists.sourceforge.net])
  12 AC_CONFIG_SRCDIR(coregrind/m_main.c)
  13 AC_CONFIG_HEADERS([config.h])
  14 AM_INIT_AUTOMAKE([foreign subdir-objects])
  15
  16 AM_MAINTAINER_MODE
  17
  18 #----------------------------------------------------------------------------
  19 # Checks for various programs.
  20 #----------------------------------------------------------------------------
  21 CFLAGS="-Wno-long-long $CFLAGS"
  22 CXXFLAGS="-Wno-long-long $CXXFLAGS"
  23
  24 AC_PROG_LN_S
  25 AC_PROG_CC
  26 AM_PROG_CC_C_O
  27 AC_PROG_CPP
  28 AC_PROG_CXX
  29 # AC_PROG_OBJC apparently causes problems on older Linux distros (eg. with
  30 # autoconf 2.59).  If we ever have any Objective-C code in the Valgrind code
  31 # base (eg. most likely as Darwin-specific tests) we'll need one of the
  32 # following:
  33 # - put AC_PROG_OBJC in a Darwin-specific part of this file
  34 # - Use AC_PROG_OBJC here and up the minimum autoconf version
  35 # - Use the following, which is apparently equivalent:
  36 #     m4_ifdef([AC_PROG_OBJC],
  37 #        [AC_PROG_OBJC],
  38 #        [AC_CHECK_TOOL([OBJC], [gcc])
  39 #         AC_SUBST([OBJC])
  40 #         AC_SUBST([OBJCFLAGS])
  41 #        ])
  42 AC_PROG_RANLIB
  43 # provide a very basic definition for AC_PROG_SED if it's not provided by
  44 # autoconf (as e.g. in autoconf 2.59).
  45 m4_ifndef([AC_PROG_SED],
  46           [AC_DEFUN([AC_PROG_SED],
  47                     [AC_ARG_VAR([SED])
  48                      AC_CHECK_PROGS([SED],[gsed sed])])])
  49 AC_PROG_SED
  50
  51 # If no AR variable was specified, look up the name of the archiver. Otherwise
  52 # do not touch the AR variable.
  53 if test "x$AR" = "x"; then
  54   AC_PATH_PROGS([AR], [`echo $LD | $SED 's/ld$/ar/'` "ar"], [ar])
  55 fi
  56 AC_ARG_VAR([AR],[Archiver command])
  57
  58 # Check for the compiler support
  59 if test "${GCC}" != "yes" ; then
  60    AC_MSG_ERROR([Valgrind relies on GCC to be compiled])
  61 fi
  62
  63 # figure out where perl lives
  64 AC_PATH_PROG(PERL, perl)
  65
  66 # figure out where gdb lives
  67 AC_PATH_PROG(GDB, gdb, "/no/gdb/was/found/at/configure/time")
  68 AC_DEFINE_UNQUOTED(GDB_PATH, "$GDB", [path to GDB])
  69
  70 # some older automake's don't have it so try something on our own
  71 ifdef([AM_PROG_AS],[AM_PROG_AS],
  72 [
  73 AS="${CC}"
  74 AC_SUBST(AS)
  75
  76 ASFLAGS=""
  77 AC_SUBST(ASFLAGS)
  78 ])
  79
  80
  81 # Check if 'diff' supports -u (universal diffs) and use it if possible.
  82
  83 AC_MSG_CHECKING([for diff -u])
  84 AC_SUBST(DIFF)
  85
  86 # Comparing two identical files results in 0.
  87 tmpfile="tmp-xxx-yyy-zzz"
  88 touch $tmpfile;
  89 if diff -u $tmpfile $tmpfile ; then
  90     AC_MSG_RESULT([yes])
  91     DIFF="diff -u"
  92 else
  93     AC_MSG_RESULT([no])
  94     DIFF="diff"
  95 fi
  96 rm $tmpfile
  97
  98
  99 # We don't want gcc < 3.0
 100 AC_MSG_CHECKING([for a supported version of gcc])
 101
 102 # Obtain the compiler version.
 103 #
 104 # A few examples of how the ${CC} --version output looks like:
 105 #
 106 # ######## gcc variants ########
 107 # Arch Linux: i686-pc-linux-gnu-gcc (GCC) 4.6.2
 108 # Debian Linux: gcc (Debian 4.3.2-1.1) 4.3.2
 109 # openSUSE: gcc (SUSE Linux) 4.5.1 20101208 [gcc-4_5-branch revision 167585]
 110 # Exherbo Linux: x86_64-pc-linux-gnu-gcc (Exherbo gcc-4.6.2) 4.6.2
 111 # MontaVista Linux for ARM: arm-none-linux-gnueabi-gcc (Sourcery G++ Lite 2009q1-203) 4.3.3
 112 # OS/X 10.6: i686-apple-darwin10-gcc-4.2.1 (GCC) 4.2.1 (Apple Inc. build 5666) (dot 3)
 113 # 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)
 114 #
 115 # ######## clang variants ########
 116 # Clang: clang version 2.9 (tags/RELEASE_29/final)
 117 # Apple clang: Apple clang version 3.1 (tags/Apple/clang-318.0.58) (based on LLVM 3.1svn)
 118 # FreeBSD clang: FreeBSD clang version 3.1 (branches/release_31 156863) 20120523
 119 #
 120 # ######## Apple LLVM variants ########
 121 # Apple LLVM version 5.1 (clang-503.0.40) (based on LLVM 3.4svn)
 122 # Apple LLVM version 6.0 (clang-600.0.51) (based on LLVM 3.5svn)
 123 #
 124 [
 125 if test "x`${CC} --version | $SED -n -e 's/.*\Apple \(LLVM\) version.*clang.*/\1/p'`" = "xLLVM" ;
 126 then
 127     is_clang="applellvm"
 128     gcc_version=`${CC} --version | $SED -n -e 's/.*LLVM version \([0-9.]*\).*$/\1/p'`
 129 elif test "x`${CC} --version | $SED -n -e 's/.*\(clang\) version.*/\1/p'`" = "xclang" ;
 130 then
 131     is_clang="clang"
 132     # Don't use -dumpversion with clang: it will always produce "4.2.1".
 133     gcc_version=`${CC} --version | $SED -n -e 's/.*clang version \([0-9.]*\).*$/\1/p'`
 134 elif test "x`${CC} --version | $SED -n -e 's/icc.+\(ICC\).*/\1/p'`" = "ICC" ; then
 135     is_clang="icc"
 136     gcc_version=`${CC} --version | $SED -n -e 's/icc.+\(ICC\).+([0-9.]+).*$/\1/p'`
 137 else
 138     is_clang="notclang"
 139     gcc_version=`${CC} -dumpversion 2>/dev/null`
 140     if test "x$gcc_version" = x; then
 141         gcc_version=`${CC} --version | $SED -n -e 's/[^ ]*gcc[^ ]* ([^)]*) \([0-9.]*\).*$/\1/p'`
 142     fi
 143 fi
 144 ]
 145 AM_CONDITIONAL(COMPILER_IS_CLANG, test $is_clang = clang -o $is_clang = applellvm)
 146 AM_CONDITIONAL(COMPILER_IS_ICC, test $is_clang = icc)
 147
 148 if test $is_clang = clang -o $is_clang = applellvm ; then
 149     CFLAGS="$CFLAGS -Wno-tautological-compare -Wno-cast-align -Wno-self-assign"
 150     CXXFLAGS="$CXXFLAGS -Wno-tautological-compare -Wno-cast-align -Wno-self-assign"
 151 fi
 152
 153 # Note: m4 arguments are quoted with [ and ] so square brackets in shell
 154 # statements have to be quoted.
 155 case "${is_clang}-${gcc_version}" in
 156      applellvm-5.1|applellvm-6.0*)
 157         AC_MSG_RESULT([ok (Apple LLVM version ${gcc_version})])
 158         ;;
 159      icc-1[3-9]*)
 160         AC_MSG_RESULT([ok (ICC version ${gcc_version})])
 161         ;;
 162      notclang-[[3-9]].*|notclang-[[1-9][0-9]]*)
 163         AC_MSG_RESULT([ok (${gcc_version})])
 164         ;;
 165      clang-2.9|clang-[[3-9]].*|clang-[[1-9][0-9]]*)
 166         AC_MSG_RESULT([ok (clang-${gcc_version})])
 167         ;;
 168      *)
 169         AC_MSG_RESULT([no (${gcc_version})])
 170         AC_MSG_ERROR([please use gcc >= 3.0 or clang >= 2.9 or icc >= 13.0])
 171         ;;
 172 esac
 173
 174 #----------------------------------------------------------------------------
 175 # Arch/OS/platform tests.
 176 #----------------------------------------------------------------------------
 177 # We create a number of arch/OS/platform-related variables.  We prefix them
 178 # all with "VGCONF_" which indicates that they are defined at
 179 # configure-time, and distinguishes them from the VGA_*/VGO_*/VGP_*
 180 # variables used when compiling C files.
 181
 182 AC_CANONICAL_HOST
 183
 184 AC_MSG_CHECKING([for a supported CPU])
 185
 186 # ARCH_MAX reflects the most that this CPU can do: for example if it
 187 # is a 64-bit capable PowerPC, then it must be set to ppc64 and not ppc32.
 188 # Ditto for amd64.  It is used for more configuration below, but is not used
 189 # outside this file.
 190 #
 191 # Power PC returns powerpc for Big Endian.  This was not changed when Little
 192 # Endian support was added to the 64-bit architecture.  The 64-bit Little
 193 # Endian systems explicitly state le in the host_cpu.  For clarity in the
 194 # Valgrind code, the ARCH_MAX name will state LE or BE for the endianess of
 195 # the 64-bit system.  Big Endian is the only mode supported on 32-bit Power PC.
 196 # The abreviation PPC or ppc refers to 32-bit and 64-bit systems with either
 197 # Endianess.  The name PPC64 or ppc64 to 64-bit systems of either Endianess.
 198 # The names ppc64be or PPC64BE refer to only 64-bit systems that are Big
 199 # Endian.  Similarly, ppc64le or PPC64LE refer to only 64-bit systems that are
 200 # Little Endian.
 201
 202 case "${host_cpu}" in
 203      i?86)
 204         AC_MSG_RESULT([ok (${host_cpu})])
 205         ARCH_MAX="x86"
 206         ;;
 207
 208      x86_64)
 209         AC_MSG_RESULT([ok (${host_cpu})])
 210         ARCH_MAX="amd64"
 211         ;;
 212
 213      powerpc64)
 214      # this only referrs to 64-bit Big Endian
 215         AC_MSG_RESULT([ok (${host_cpu})])
 216         ARCH_MAX="ppc64be"
 217         ;;
 218
 219      powerpc64le)
 220      # this only referrs to 64-bit Little Endian
 221         AC_MSG_RESULT([ok (${host_cpu})])
 222         ARCH_MAX="ppc64le"
 223         ;;
 224
 225      powerpc)
 226         # On Linux this means only a 32-bit capable CPU.
 227         AC_MSG_RESULT([ok (${host_cpu})])
 228         ARCH_MAX="ppc32"
 229         ;;
 230
 231      s390x)
 232         AC_MSG_RESULT([ok (${host_cpu})])
 233         ARCH_MAX="s390x"
 234         ;;
 235
 236      armv7*)
 237         AC_MSG_RESULT([ok (${host_cpu})])
 238         ARCH_MAX="arm"
 239         ;;
 240
 241      aarch64*)
 242        AC_MSG_RESULT([ok (${host_cpu})])
 243        ARCH_MAX="arm64"
 244        ;;
 245
 246      mips)
 247         AC_MSG_RESULT([ok (${host_cpu})])
 248         ARCH_MAX="mips32"
 249         ;;
 250
 251      mipsel)
 252         AC_MSG_RESULT([ok (${host_cpu})])
 253         ARCH_MAX="mips32"
 254         ;;
 255
 256      mipsisa32r2)
 257         AC_MSG_RESULT([ok (${host_cpu})])
 258         ARCH_MAX="mips32"
 259         ;;
 260
 261      mips64*)
 262         AC_MSG_RESULT([ok (${host_cpu})])
 263         ARCH_MAX="mips64"
 264         ;;
 265
 266      mipsisa64*)
 267         AC_MSG_RESULT([ok (${host_cpu})])
 268         ARCH_MAX="mips64"
 269         ;;
 270      *)
 271         AC_MSG_RESULT([no (${host_cpu})])
 272         AC_MSG_ERROR([Unsupported host architecture. Sorry])
 273         ;;
 274 esac
 275
 276 #----------------------------------------------------------------------------
 277
 278 # Sometimes it's convenient to subvert the bi-arch build system and
 279 # just have a single build even though the underlying platform is
 280 # capable of both.  Hence handle --enable-only64bit and
 281 # --enable-only32bit.  Complain if both are issued :-)
 282 # [Actually, if either of these options are used, I think both get built,
 283 # but only one gets installed.  So if you use an in-place build, both can be
 284 # used. --njn]
 285
 286 # Check if a 64-bit only build has been requested
 287 AC_CACHE_CHECK([for a 64-bit only build], vg_cv_only64bit,
 288    [AC_ARG_ENABLE(only64bit,
 289       [  --enable-only64bit      do a 64-bit only build],
 290       [vg_cv_only64bit=$enableval],
 291       [vg_cv_only64bit=no])])
 292
 293 # Check if a 32-bit only build has been requested
 294 AC_CACHE_CHECK([for a 32-bit only build], vg_cv_only32bit,
 295    [AC_ARG_ENABLE(only32bit,
 296       [  --enable-only32bit      do a 32-bit only build],
 297       [vg_cv_only32bit=$enableval],
 298       [vg_cv_only32bit=no])])
 299
 300 # Stay sane
 301 if test x$vg_cv_only64bit = xyes -a x$vg_cv_only32bit = xyes; then
 302    AC_MSG_ERROR(
 303       [Nonsensical: both --enable-only64bit and --enable-only32bit.])
 304 fi
 305
 306 #----------------------------------------------------------------------------
 307
 308 # VGCONF_OS is the primary build OS, eg. "linux".  It is passed in to
 309 # compilation of many C files via -VGO_$(VGCONF_OS) and
 310 # -VGP_$(VGCONF_ARCH_PRI)_$(VGCONF_OS).
 311 AC_MSG_CHECKING([for a supported OS])
 312 AC_SUBST(VGCONF_OS)
 313
 314 DEFAULT_SUPP=""
 315
 316 case "${host_os}" in
 317      *linux*)
 318         AC_MSG_RESULT([ok (${host_os})])
 319         VGCONF_OS="linux"
 320
 321         # Ok, this is linux. Check the kernel version
 322         AC_MSG_CHECKING([for the kernel version])
 323
 324         kernel=`uname -r`
 325
 326         case "${kernel}" in
 327              2.6.*|3.*)
 328                     AC_MSG_RESULT([2.6.x/3.x family (${kernel})])
 329                     AC_DEFINE([KERNEL_2_6], 1, [Define to 1 if you're using Linux 2.6.x or Linux 3.x])
 330                     ;;
 331
 332              2.4.*)
 333                     AC_MSG_RESULT([2.4 family (${kernel})])
 334                     AC_DEFINE([KERNEL_2_4], 1, [Define to 1 if you're using Linux 2.4.x])
 335                     ;;
 336
 337              *)
 338                     AC_MSG_RESULT([unsupported (${kernel})])
 339                     AC_MSG_ERROR([Valgrind works on kernels 2.4, 2.6])
 340                     ;;
 341         esac
 342
 343         ;;
 344
 345      *darwin*)
 346         AC_MSG_RESULT([ok (${host_os})])
 347         VGCONF_OS="darwin"
 348         AC_DEFINE([DARWIN_10_5], 100500, [DARWIN_VERS value for Mac OS X 10.5])
 349         AC_DEFINE([DARWIN_10_6], 100600, [DARWIN_VERS value for Mac OS X 10.6])
 350         AC_DEFINE([DARWIN_10_7], 100700, [DARWIN_VERS value for Mac OS X 10.7])
 351         AC_DEFINE([DARWIN_10_8], 100800, [DARWIN_VERS value for Mac OS X 10.8])
 352         AC_DEFINE([DARWIN_10_9], 100900, [DARWIN_VERS value for Mac OS X 10.9])
 353         AC_DEFINE([DARWIN_10_10], 101000, [DARWIN_VERS value for Mac OS X 10.10])
 354
 355         AC_MSG_CHECKING([for the kernel version])
 356         kernel=`uname -r`
 357
 358         # Nb: for Darwin we set DEFAULT_SUPP here.  That's because Darwin
 359         # has only one relevant version, the OS version. The `uname` check
 360         # is a good way to get that version (i.e. "Darwin 9.6.0" is Mac OS
 361         # X 10.5.6, and "Darwin 10.x" is Mac OS X 10.6.x Snow Leopard,
 362         # and possibly "Darwin 11.x" is Mac OS X 10.7.x Lion),
 363         # and we don't know of an macros similar to __GLIBC__ to get that info.
 364         #
 365         # XXX: `uname -r` won't do the right thing for cross-compiles, but
 366         # that's not a problem yet.
 367         #
 368         # jseward 21 Sept 2011: I seriously doubt whether V 3.7.0 will work
 369         # on OS X 10.5.x; I haven't tested yet, and only plan to test 3.7.0
 370         # on 10.6.8 and 10.7.1.  Although tempted to delete the configure
 371         # time support for 10.5 (the 9.* pattern just below), I'll leave it
 372         # in for now, just in case anybody wants to give it a try.  But I'm
 373         # assuming that 3.7.0 is a Snow Leopard and Lion-only release.
 374         case "${kernel}" in
 375              9.*)
 376                   AC_MSG_RESULT([Darwin 9.x (${kernel}) / Mac OS X 10.5 Leopard])
 377                   AC_DEFINE([DARWIN_VERS], DARWIN_10_5, [Darwin / Mac OS X version])
 378                   DEFAULT_SUPP="darwin9.supp ${DEFAULT_SUPP}"
 379                   DEFAULT_SUPP="darwin9-drd.supp ${DEFAULT_SUPP}"
 380                   ;;
 381              10.*)
 382                   AC_MSG_RESULT([Darwin 10.x (${kernel}) / Mac OS X 10.6 Snow Leopard])
 383                   AC_DEFINE([DARWIN_VERS], DARWIN_10_6, [Darwin / Mac OS X version])
 384                   DEFAULT_SUPP="darwin10.supp ${DEFAULT_SUPP}"
 385                   DEFAULT_SUPP="darwin10-drd.supp ${DEFAULT_SUPP}"
 386                   ;;
 387              11.*)
 388                   AC_MSG_RESULT([Darwin 11.x (${kernel}) / Mac OS X 10.7 Lion])
 389                   AC_DEFINE([DARWIN_VERS], DARWIN_10_7, [Darwin / Mac OS X version])
 390                   DEFAULT_SUPP="darwin11.supp ${DEFAULT_SUPP}"
 391                   DEFAULT_SUPP="darwin10-drd.supp ${DEFAULT_SUPP}"
 392                   ;;
 393              12.*)
 394                   AC_MSG_RESULT([Darwin 12.x (${kernel}) / Mac OS X 10.8 Mountain Lion])
 395                   AC_DEFINE([DARWIN_VERS], DARWIN_10_8, [Darwin / Mac OS X version])
 396                   DEFAULT_SUPP="darwin12.supp ${DEFAULT_SUPP}"
 397                   DEFAULT_SUPP="darwin10-drd.supp ${DEFAULT_SUPP}"
 398                   ;;
 399              13.*)
 400                   AC_MSG_RESULT([Darwin 13.x (${kernel}) / Mac OS X 10.9 Mavericks])
 401                   AC_DEFINE([DARWIN_VERS], DARWIN_10_9, [Darwin / Mac OS X version])
 402                   DEFAULT_SUPP="darwin13.supp ${DEFAULT_SUPP}"
 403                   DEFAULT_SUPP="darwin10-drd.supp ${DEFAULT_SUPP}"
 404                   ;;
 405              14.*)
 406                   AC_MSG_RESULT([Darwin 14.x (${kernel}) / Mac OS X 10.10 Yosemite])
 407                   AC_DEFINE([DARWIN_VERS], DARWIN_10_10, [Darwin / Mac OS X version])
 408                   DEFAULT_SUPP="darwin14.supp ${DEFAULT_SUPP}"
 409                   DEFAULT_SUPP="darwin10-drd.supp ${DEFAULT_SUPP}"
 410                   ;;
 411              *)
 412                   AC_MSG_RESULT([unsupported (${kernel})])
 413                   AC_MSG_ERROR([Valgrind works on Darwin 10.x, 11.x, 12.x, 13.x and 14.x (Mac OS X 10.6/7/8/9/10)])
 414                   ;;
 415         esac
 416         ;;
 417
 418      *)
 419         AC_MSG_RESULT([no (${host_os})])
 420         AC_MSG_ERROR([Valgrind is operating system specific. Sorry.])
 421         ;;
 422 esac
 423
 424 #----------------------------------------------------------------------------
 425
 426 # If we are building on a 64 bit platform test to see if the system
 427 # supports building 32 bit programs and disable 32 bit support if it
 428 # does not support building 32 bit programs
 429
 430 case "$ARCH_MAX-$VGCONF_OS" in
 431      amd64-linux|ppc64be-linux|arm64-linux)
 432         AC_MSG_CHECKING([for 32 bit build support])
 433         safe_CFLAGS=$CFLAGS
 434         CFLAGS="-m32"
 435         AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[
 436           return 0;
 437         ]])], [
 438         AC_MSG_RESULT([yes])
 439         ], [
 440         vg_cv_only64bit="yes"
 441         AC_MSG_RESULT([no])
 442         ])
 443         CFLAGS=$safe_CFLAGS;;
 444 esac
 445
 446 if test x$vg_cv_only64bit = xyes -a x$vg_cv_only32bit = xyes; then
 447    AC_MSG_ERROR(
 448       [--enable-only32bit was specified but system does not support 32 bit builds])
 449 fi
 450
 451 #----------------------------------------------------------------------------
 452
 453 # VGCONF_ARCH_PRI is the arch for the primary build target, eg. "amd64".  By
 454 # default it's the same as ARCH_MAX.  But if, say, we do a build on an amd64
 455 # machine, but --enable-only32bit has been requested, then ARCH_MAX (see
 456 # above) will be "amd64" since that reflects the most that this cpu can do,
 457 # but VGCONF_ARCH_PRI will be downgraded to "x86", since that reflects the
 458 # arch corresponding to the primary build (VGCONF_PLATFORM_PRI_CAPS).  It is
 459 # passed in to compilation of many C files via -VGA_$(VGCONF_ARCH_PRI) and
 460 # -VGP_$(VGCONF_ARCH_PRI)_$(VGCONF_OS).
 461 AC_SUBST(VGCONF_ARCH_PRI)
 462
 463 # VGCONF_ARCH_SEC is the arch for the secondary build target, eg. "x86".
 464 # It is passed in to compilation of many C files via -VGA_$(VGCONF_ARCH_SEC)
 465 # and -VGP_$(VGCONF_ARCH_SEC)_$(VGCONF_OS), if there is a secondary target.
 466 # It is empty if there is no secondary target.
 467 AC_SUBST(VGCONF_ARCH_SEC)
 468
 469 # VGCONF_PLATFORM_PRI_CAPS is the primary build target, eg. "AMD64_LINUX".
 470 # The entire system, including regression and performance tests, will be
 471 # built for this target.  The "_CAPS" indicates that the name is in capital
 472 # letters, and it also uses '_' rather than '-' as a separator, because it's
 473 # used to create various Makefile variables, which are all in caps by
 474 # convention and cannot contain '-' characters.  This is in contrast to
 475 # VGCONF_ARCH_PRI and VGCONF_OS which are not in caps.
 476 AC_SUBST(VGCONF_PLATFORM_PRI_CAPS)
 477
 478 # VGCONF_PLATFORM_SEC_CAPS is the secondary build target, if there is one.
 479 # Valgrind and tools will also be built for this target, but not the
 480 # regression or performance tests.
 481 #
 482 # By default, the primary arch is the same as the "max" arch, as commented
 483 # above (at the definition of ARCH_MAX).  We may choose to downgrade it in
 484 # the big case statement just below here, in the case where we're building
 485 # on a 64 bit machine but have been requested only to do a 32 bit build.
 486 AC_SUBST(VGCONF_PLATFORM_SEC_CAPS)
 487
 488 AC_MSG_CHECKING([for a supported CPU/OS combination])
 489
 490 # NB.  The load address for a given platform may be specified in more
 491 # than one place, in some cases, depending on whether we're doing a biarch,
 492 # 32-bit only or 64-bit only build.  eg see case for amd64-linux below.
 493 # Be careful to give consistent values in all subcases.  Also, all four
 494 # valt_load_addres_{pri,sec}_{norml,inner} values must always be set,
 495 # even if it is to "0xUNSET".
 496 #
 497 case "$ARCH_MAX-$VGCONF_OS" in
 498      x86-linux)
 499         VGCONF_ARCH_PRI="x86"
 500         VGCONF_ARCH_SEC=""
 501         VGCONF_PLATFORM_PRI_CAPS="X86_LINUX"
 502         VGCONF_PLATFORM_SEC_CAPS=""
 503         valt_load_address_pri_norml="0x38000000"
 504         valt_load_address_pri_inner="0x28000000"
 505         valt_load_address_sec_norml="0xUNSET"
 506         valt_load_address_sec_inner="0xUNSET"
 507         AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})])
 508         ;;
 509      amd64-linux)
 510         valt_load_address_sec_norml="0xUNSET"
 511         valt_load_address_sec_inner="0xUNSET"
 512         if test x$vg_cv_only64bit = xyes; then
 513            VGCONF_ARCH_PRI="amd64"
 514            VGCONF_ARCH_SEC=""
 515            VGCONF_PLATFORM_PRI_CAPS="AMD64_LINUX"
 516            VGCONF_PLATFORM_SEC_CAPS=""
 517            valt_load_address_pri_norml="0x38000000"
 518            valt_load_address_pri_inner="0x28000000"
 519         elif test x$vg_cv_only32bit = xyes; then
 520            VGCONF_ARCH_PRI="x86"
 521            VGCONF_ARCH_SEC=""
 522            VGCONF_PLATFORM_PRI_CAPS="X86_LINUX"
 523            VGCONF_PLATFORM_SEC_CAPS=""
 524            valt_load_address_pri_norml="0x38000000"
 525            valt_load_address_pri_inner="0x28000000"
 526         else
 527            VGCONF_ARCH_PRI="amd64"
 528            VGCONF_ARCH_SEC="x86"
 529            VGCONF_PLATFORM_PRI_CAPS="AMD64_LINUX"
 530            VGCONF_PLATFORM_SEC_CAPS="X86_LINUX"
 531            valt_load_address_pri_norml="0x38000000"
 532            valt_load_address_pri_inner="0x28000000"
 533            valt_load_address_sec_norml="0x38000000"
 534            valt_load_address_sec_inner="0x28000000"
 535         fi
 536         AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})])
 537         ;;
 538      ppc32-linux)
 539         VGCONF_ARCH_PRI="ppc32"
 540         VGCONF_ARCH_SEC=""
 541         VGCONF_PLATFORM_PRI_CAPS="PPC32_LINUX"
 542         VGCONF_PLATFORM_SEC_CAPS=""
 543         valt_load_address_pri_norml="0x38000000"
 544         valt_load_address_pri_inner="0x28000000"
 545         valt_load_address_sec_norml="0xUNSET"
 546         valt_load_address_sec_inner="0xUNSET"
 547         AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})])
 548         ;;
 549      ppc64be-linux)
 550         valt_load_address_sec_norml="0xUNSET"
 551         valt_load_address_sec_inner="0xUNSET"
 552         if test x$vg_cv_only64bit = xyes; then
 553            VGCONF_ARCH_PRI="ppc64be"
 554            VGCONF_ARCH_SEC=""
 555            VGCONF_PLATFORM_PRI_CAPS="PPC64BE_LINUX"
 556            VGCONF_PLATFORM_SEC_CAPS=""
 557            valt_load_address_pri_norml="0x38000000"
 558            valt_load_address_pri_inner="0x28000000"
 559         elif test x$vg_cv_only32bit = xyes; then
 560            VGCONF_ARCH_PRI="ppc32"
 561            VGCONF_ARCH_SEC=""
 562            VGCONF_PLATFORM_PRI_CAPS="PPC32_LINUX"
 563            VGCONF_PLATFORM_SEC_CAPS=""
 564            valt_load_address_pri_norml="0x38000000"
 565            valt_load_address_pri_inner="0x28000000"
 566         else
 567            VGCONF_ARCH_PRI="ppc64be"
 568            VGCONF_ARCH_SEC="ppc32"
 569            VGCONF_PLATFORM_PRI_CAPS="PPC64BE_LINUX"
 570            VGCONF_PLATFORM_SEC_CAPS="PPC32_LINUX"
 571            valt_load_address_pri_norml="0x38000000"
 572            valt_load_address_pri_inner="0x28000000"
 573            valt_load_address_sec_norml="0x38000000"
 574            valt_load_address_sec_inner="0x28000000"
 575         fi
 576         AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})])
 577         ;;
 578      ppc64le-linux)
 579         # Little Endian is only supported on PPC64
 580         valt_load_address_sec_norml="0xUNSET"
 581         valt_load_address_sec_inner="0xUNSET"
 582         VGCONF_ARCH_PRI="ppc64le"
 583         VGCONF_ARCH_SEC=""
 584         VGCONF_PLATFORM_PRI_CAPS="PPC64LE_LINUX"
 585         VGCONF_PLATFORM_SEC_CAPS=""
 586         valt_load_address_pri_norml="0x38000000"
 587         valt_load_address_pri_inner="0x28000000"
 588         AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})])
 589        ;;
 590      # Darwin gets identified as 32-bit even when it supports 64-bit.
 591      # (Not sure why, possibly because 'uname' returns "i386"?)  Just about
 592      # all Macs support both 32-bit and 64-bit, so we just build both.  If
 593      # someone has a really old 32-bit only machine they can (hopefully?)
 594      # build with --enable-only32bit.  See bug 243362.
 595      x86-darwin|amd64-darwin)
 596         ARCH_MAX="amd64"
 597         valt_load_address_sec_norml="0xUNSET"
 598         valt_load_address_sec_inner="0xUNSET"
 599         if test x$vg_cv_only64bit = xyes; then
 600            VGCONF_ARCH_PRI="amd64"
 601            VGCONF_ARCH_SEC=""
 602            VGCONF_PLATFORM_PRI_CAPS="AMD64_DARWIN"
 603            VGCONF_PLATFORM_SEC_CAPS=""
 604            valt_load_address_pri_norml="0x138000000"
 605            valt_load_address_pri_inner="0x128000000"
 606         elif test x$vg_cv_only32bit = xyes; then
 607            VGCONF_ARCH_PRI="x86"
 608            VGCONF_ARCH_SEC=""
 609            VGCONF_PLATFORM_PRI_CAPS="X86_DARWIN"
 610            VGCONF_PLATFORM_SEC_CAPS=""
 611            VGCONF_ARCH_PRI_CAPS="x86"
 612            valt_load_address_pri_norml="0x38000000"
 613            valt_load_address_pri_inner="0x28000000"
 614         else
 615            VGCONF_ARCH_PRI="amd64"
 616            VGCONF_ARCH_SEC="x86"
 617            VGCONF_PLATFORM_PRI_CAPS="AMD64_DARWIN"
 618            VGCONF_PLATFORM_SEC_CAPS="X86_DARWIN"
 619            valt_load_address_pri_norml="0x138000000"
 620            valt_load_address_pri_inner="0x128000000"
 621            valt_load_address_sec_norml="0x38000000"
 622            valt_load_address_sec_inner="0x28000000"
 623         fi
 624         AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})])
 625         ;;
 626      arm-linux)
 627         VGCONF_ARCH_PRI="arm"
 628         VGCONF_PLATFORM_PRI_CAPS="ARM_LINUX"
 629         VGCONF_PLATFORM_SEC_CAPS=""
 630         valt_load_address_pri_norml="0x38000000"
 631         valt_load_address_pri_inner="0x28000000"
 632         valt_load_address_sec_norml="0xUNSET"
 633         valt_load_address_sec_inner="0xUNSET"
 634         AC_MSG_RESULT([ok (${host_cpu}-${host_os})])
 635         ;;
 636      arm64-linux)
 637         valt_load_address_sec_norml="0xUNSET"
 638         valt_load_address_sec_inner="0xUNSET"
 639         if test x$vg_cv_only64bit = xyes; then
 640            VGCONF_ARCH_PRI="arm64"
 641            VGCONF_ARCH_SEC=""
 642            VGCONF_PLATFORM_PRI_CAPS="ARM64_LINUX"
 643            VGCONF_PLATFORM_SEC_CAPS=""
 644            valt_load_address_pri_norml="0x38000000"
 645            valt_load_address_pri_inner="0x28000000"
 646         elif test x$vg_cv_only32bit = xyes; then
 647            VGCONF_ARCH_PRI="arm"
 648            VGCONF_ARCH_SEC=""
 649            VGCONF_PLATFORM_PRI_CAPS="ARM_LINUX"
 650            VGCONF_PLATFORM_SEC_CAPS=""
 651            valt_load_address_pri_norml="0x38000000"
 652            valt_load_address_pri_inner="0x28000000"
 653         else
 654            VGCONF_ARCH_PRI="arm64"
 655            VGCONF_ARCH_SEC="arm"
 656            VGCONF_PLATFORM_PRI_CAPS="ARM64_LINUX"
 657            VGCONF_PLATFORM_SEC_CAPS="ARM_LINUX"
 658            valt_load_address_pri_norml="0x38000000"
 659            valt_load_address_pri_inner="0x28000000"
 660            valt_load_address_sec_norml="0x38000000"
 661            valt_load_address_sec_inner="0x28000000"
 662         fi
 663         AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})])
 664         ;;
 665      s390x-linux)
 666         VGCONF_ARCH_PRI="s390x"
 667         VGCONF_ARCH_SEC=""
 668         VGCONF_PLATFORM_PRI_CAPS="S390X_LINUX"
 669         VGCONF_PLATFORM_SEC_CAPS=""
 670         # To improve branch prediction hit rate we want to have
 671         # the generated code close to valgrind (host) code
 672         valt_load_address_pri_norml="0x800000000"
 673         valt_load_address_pri_inner="0x810000000"
 674         valt_load_address_sec_norml="0xUNSET"
 675         valt_load_address_sec_inner="0xUNSET"
 676         AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})])
 677         ;;
 678      mips32-linux)
 679         VGCONF_ARCH_PRI="mips32"
 680         VGCONF_PLATFORM_PRI_CAPS="MIPS32_LINUX"
 681         VGCONF_PLATFORM_SEC_CAPS=""
 682         valt_load_address_pri_norml="0x38000000"
 683         valt_load_address_pri_inner="0x28000000"
 684         valt_load_address_sec_norml="0xUNSET"
 685         valt_load_address_sec_inner="0xUNSET"
 686         AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})])
 687         ;;
 688      mips64-linux)
 689         VGCONF_ARCH_PRI="mips64"
 690         VGCONF_PLATFORM_PRI_CAPS="MIPS64_LINUX"
 691         VGCONF_PLATFORM_SEC_CAPS=""
 692         valt_load_address_pri_norml="0x38000000"
 693         valt_load_address_pri_inner="0x28000000"
 694         valt_load_address_sec_norml="0xUNSET"
 695         valt_load_address_sec_inner="0xUNSET"
 696         AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})])
 697         ;;
 698     *)
 699         VGCONF_ARCH_PRI="unknown"
 700         VGCONF_ARCH_SEC="unknown"
 701         VGCONF_PLATFORM_PRI_CAPS="UNKNOWN"
 702         VGCONF_PLATFORM_SEC_CAPS="UNKNOWN"
 703         valt_load_address_pri_norml="0xUNSET"
 704         valt_load_address_pri_inner="0xUNSET"
 705         valt_load_address_sec_norml="0xUNSET"
 706         valt_load_address_sec_inner="0xUNSET"
 707         AC_MSG_RESULT([no (${ARCH_MAX}-${VGCONF_OS})])
 708         AC_MSG_ERROR([Valgrind is platform specific. Sorry. Please consider doing a port.])
 709         ;;
 710 esac
 711
 712 #----------------------------------------------------------------------------
 713
 714 # Set up VGCONF_ARCHS_INCLUDE_<arch>.  Either one or two of these become
 715 # defined.
 716 AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_X86,
 717                test x$VGCONF_PLATFORM_PRI_CAPS = xX86_LINUX \
 718                  -o x$VGCONF_PLATFORM_SEC_CAPS = xX86_LINUX \
 719                  -o x$VGCONF_PLATFORM_PRI_CAPS = xX86_DARWIN \
 720                  -o x$VGCONF_PLATFORM_SEC_CAPS = xX86_DARWIN )
 721 AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_AMD64,
 722                test x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_LINUX \
 723                  -o x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_DARWIN )
 724 AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_PPC32,
 725                test x$VGCONF_PLATFORM_PRI_CAPS = xPPC32_LINUX \
 726                  -o x$VGCONF_PLATFORM_SEC_CAPS = xPPC32_LINUX )
 727 AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_PPC64,
 728                test x$VGCONF_PLATFORM_PRI_CAPS = xPPC64BE_LINUX \
 729                  -o x$VGCONF_PLATFORM_PRI_CAPS = xPPC64LE_LINUX )
 730 AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_ARM,
 731                test x$VGCONF_PLATFORM_PRI_CAPS = xARM_LINUX \
 732                  -o x$VGCONF_PLATFORM_SEC_CAPS = xARM_LINUX )
 733 AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_ARM64,
 734                test x$VGCONF_PLATFORM_PRI_CAPS = xARM64_LINUX )
 735 AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_S390X,
 736                test x$VGCONF_PLATFORM_PRI_CAPS = xS390X_LINUX )
 737 AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_MIPS32,
 738                test x$VGCONF_PLATFORM_PRI_CAPS = xMIPS32_LINUX )
 739 AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_MIPS64,
 740                test x$VGCONF_PLATFORM_PRI_CAPS = xMIPS64_LINUX )
 741
 742 # Set up VGCONF_PLATFORMS_INCLUDE_<platform>.  Either one or two of these
 743 # become defined.
 744 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_X86_LINUX,
 745                test x$VGCONF_PLATFORM_PRI_CAPS = xX86_LINUX \
 746                  -o x$VGCONF_PLATFORM_SEC_CAPS = xX86_LINUX)
 747 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_AMD64_LINUX,
 748                test x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_LINUX)
 749 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_PPC32_LINUX,
 750                test x$VGCONF_PLATFORM_PRI_CAPS = xPPC32_LINUX \
 751                  -o x$VGCONF_PLATFORM_SEC_CAPS = xPPC32_LINUX)
 752 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_PPC64BE_LINUX,
 753                test x$VGCONF_PLATFORM_PRI_CAPS = xPPC64BE_LINUX)
 754 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_PPC64LE_LINUX,
 755                test x$VGCONF_PLATFORM_PRI_CAPS = xPPC64LE_LINUX)
 756 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_ARM_LINUX,
 757                test x$VGCONF_PLATFORM_PRI_CAPS = xARM_LINUX \
 758                  -o x$VGCONF_PLATFORM_SEC_CAPS = xARM_LINUX)
 759 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_ARM64_LINUX,
 760                test x$VGCONF_PLATFORM_PRI_CAPS = xARM64_LINUX)
 761 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_S390X_LINUX,
 762                test x$VGCONF_PLATFORM_PRI_CAPS = xS390X_LINUX \
 763                  -o x$VGCONF_PLATFORM_SEC_CAPS = xS390X_LINUX)
 764 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_MIPS32_LINUX,
 765                test x$VGCONF_PLATFORM_PRI_CAPS = xMIPS32_LINUX)
 766 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_MIPS64_LINUX,
 767                test x$VGCONF_PLATFORM_PRI_CAPS = xMIPS64_LINUX)
 768 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_X86_DARWIN,
 769                test x$VGCONF_PLATFORM_PRI_CAPS = xX86_DARWIN \
 770                  -o x$VGCONF_PLATFORM_SEC_CAPS = xX86_DARWIN)
 771 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_AMD64_DARWIN,
 772                test x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_DARWIN)
 773
 774
 775 # Similarly, set up VGCONF_OS_IS_<os>.  Exactly one of these becomes defined.
 776 # Relies on the assumption that the primary and secondary targets are
 777 # for the same OS, so therefore only necessary to test the primary.
 778 AM_CONDITIONAL(VGCONF_OS_IS_LINUX,
 779                test x$VGCONF_PLATFORM_PRI_CAPS = xX86_LINUX \
 780                  -o x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_LINUX \
 781                  -o x$VGCONF_PLATFORM_PRI_CAPS = xPPC32_LINUX \
 782                  -o x$VGCONF_PLATFORM_PRI_CAPS = xPPC64BE_LINUX \
 783                  -o x$VGCONF_PLATFORM_PRI_CAPS = xPPC64LE_LINUX \
 784                  -o x$VGCONF_PLATFORM_PRI_CAPS = xARM_LINUX \
 785                  -o x$VGCONF_PLATFORM_PRI_CAPS = xARM64_LINUX \
 786                  -o x$VGCONF_PLATFORM_PRI_CAPS = xS390X_LINUX \
 787                  -o x$VGCONF_PLATFORM_PRI_CAPS = xMIPS32_LINUX \
 788                  -o x$VGCONF_PLATFORM_PRI_CAPS = xMIPS64_LINUX)
 789 AM_CONDITIONAL(VGCONF_OS_IS_DARWIN,
 790                test x$VGCONF_PLATFORM_PRI_CAPS = xX86_DARWIN \
 791                  -o x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_DARWIN)
 792
 793
 794 # Sometimes, in the Makefile.am files, it's useful to know whether or not
 795 # there is a secondary target.
 796 AM_CONDITIONAL(VGCONF_HAVE_PLATFORM_SEC,
 797                test x$VGCONF_PLATFORM_SEC_CAPS != x)
 798
 799 dnl automake-1.10 does not have AM_COND_IF (added in 1.11), so we supply a
 800 dnl fallback definition
 801 dnl The macro is courtesy of Dave Hart:
 802 dnl   https://lists.gnu.org/archive/html/automake/2010-12/msg00045.html
 803 m4_ifndef([AM_COND_IF], [AC_DEFUN([AM_COND_IF], [
 804 if test -z "$$1_TRUE"; then :
 805   m4_n([$2])[]dnl
 806 m4_ifval([$3],
 807 [else
 808   $3
 809 ])dnl
 810 fi[]dnl
 811 ])])
 812
 813 #----------------------------------------------------------------------------
 814 # Inner Valgrind?
 815 #----------------------------------------------------------------------------
 816
 817 # Check if this should be built as an inner Valgrind, to be run within
 818 # another Valgrind.  Choose the load address accordingly.
 819 AC_SUBST(VALT_LOAD_ADDRESS_PRI)
 820 AC_SUBST(VALT_LOAD_ADDRESS_SEC)
 821 AC_CACHE_CHECK([for use as an inner Valgrind], vg_cv_inner,
 822    [AC_ARG_ENABLE(inner,
 823       [  --enable-inner          enables self-hosting],
 824       [vg_cv_inner=$enableval],
 825       [vg_cv_inner=no])])
 826 if test "$vg_cv_inner" = yes; then
 827     AC_DEFINE([ENABLE_INNER], 1, [configured to run as an inner Valgrind])
 828     VALT_LOAD_ADDRESS_PRI=$valt_load_address_pri_inner
 829     VALT_LOAD_ADDRESS_SEC=$valt_load_address_sec_inner
 830 else
 831     VALT_LOAD_ADDRESS_PRI=$valt_load_address_pri_norml
 832     VALT_LOAD_ADDRESS_SEC=$valt_load_address_sec_norml
 833 fi
 834
 835
 836 #----------------------------------------------------------------------------
 837 # Define MIPS_PAGE_SHIFT (--with-pagesize)
 838 #----------------------------------------------------------------------------
 839 AC_ARG_WITH(pagesize,
 840    [  --with-pagesize=        override detected page size (4, 16 or 64)],
 841    [psize=$withval],
 842    [psize=0]
 843 )
 844
 845 if test "$psize" = "0"; then
 846     psizer=`getconf PAGESIZE`
 847     psize=$((${psizer}/1024))
 848 fi
 849
 850 if test "$psize" = "4"; then
 851     AC_DEFINE([MIPS_PAGE_SHIFT], 12, [configured page size 4k])
 852 elif test "$psize" = "16"; then
 853     AC_DEFINE([MIPS_PAGE_SHIFT], 14, [configured page size 16k])
 854 elif test "$psize" = "64"; then
 855     AC_DEFINE([MIPS_PAGE_SHIFT], 16, [configured page size 64k])
 856 else
 857    AC_DEFINE([MIPS_PAGE_SHIFT], 12, [configured default page size 4k])
 858 fi
 859 AC_MSG_RESULT([checking for Pagesize... ${psize}k])
 860
 861
 862 #----------------------------------------------------------------------------
 863 # Extra fine-tuning of installation directories
 864 #----------------------------------------------------------------------------
 865 AC_ARG_WITH(tmpdir,
 866    [  --with-tmpdir=PATH      Specify path for temporary files],
 867    tmpdir="$withval",
 868    tmpdir="/tmp")
 869 AC_DEFINE_UNQUOTED(VG_TMPDIR, "$tmpdir", [Temporary files directory])
 870 AC_SUBST(VG_TMPDIR, [$tmpdir])
 871
 872
 873 #----------------------------------------------------------------------------
 874 # Libc and suppressions
 875 #----------------------------------------------------------------------------
 876 # This variable will collect the suppression files to be used.
 877 AC_SUBST(DEFAULT_SUPP)
 878
 879 AC_CHECK_HEADER([features.h])
 880
 881 if test x$ac_cv_header_features_h = xyes; then
 882   rm -f conftest.$ac_ext
 883   cat <<_ACEOF >conftest.$ac_ext
 884 #include <features.h>
 885 #if defined(__GNU_LIBRARY__) && defined(__GLIBC__) && defined(__GLIBC_MINOR__)
 886 glibc version is: __GLIBC__ __GLIBC_MINOR__
 887 #endif
 888 _ACEOF
 889   GLIBC_VERSION="`$CPP -P conftest.$ac_ext | $SED -n 's/^glibc version is: //p' | $SED 's/ /./g'`"
 890 fi
 891
 892 # not really a version check
 893 AC_EGREP_CPP([DARWIN_LIBC], [
 894 #include <sys/cdefs.h>
 895 #if defined(__DARWIN_VERS_1050)
 896   DARWIN_LIBC
 897 #endif
 898 ],
 899 GLIBC_VERSION="darwin")
 900
 901 # not really a version check
 902 AC_EGREP_CPP([BIONIC_LIBC], [
 903 #if defined(__ANDROID__)
 904   BIONIC_LIBC
 905 #endif
 906 ],
 907 GLIBC_VERSION="bionic")
 908
 909
 910 AC_MSG_CHECKING([the glibc version])
 911
 912 case "${GLIBC_VERSION}" in
 913      2.2)
 914         AC_MSG_RESULT(${GLIBC_VERSION} family)
 915         DEFAULT_SUPP="glibc-2.2.supp ${DEFAULT_SUPP}"
 916         DEFAULT_SUPP="glibc-2.2-LinuxThreads-helgrind.supp ${DEFAULT_SUPP}"
 917         DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}"
 918         ;;
 919      2.[[3-6]])
 920         AC_MSG_RESULT(${GLIBC_VERSION} family)
 921         DEFAULT_SUPP="glibc-${GLIBC_VERSION}.supp ${DEFAULT_SUPP}"
 922         DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}"
 923         DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}"
 924         ;;
 925      2.[[7-9]])
 926         AC_MSG_RESULT(${GLIBC_VERSION} family)
 927         DEFAULT_SUPP="glibc-2.X.supp ${DEFAULT_SUPP}"
 928         DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}"
 929         DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}"
 930         ;;
 931      2.10|2.11)
 932         AC_MSG_RESULT(${GLIBC_VERSION} family)
 933         AC_DEFINE([GLIBC_MANDATORY_STRLEN_REDIRECT], 1,
 934                   [Define to 1 if strlen() has been optimized heavily (amd64 glibc >= 2.10)])
 935         DEFAULT_SUPP="glibc-2.X.supp ${DEFAULT_SUPP}"
 936         DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}"
 937         DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}"
 938         ;;
 939      2.*)
 940         AC_MSG_RESULT(${GLIBC_VERSION} family)
 941         AC_DEFINE([GLIBC_MANDATORY_STRLEN_REDIRECT], 1,
 942                   [Define to 1 if strlen() has been optimized heavily (amd64 glibc >= 2.10)])
 943         AC_DEFINE([GLIBC_MANDATORY_INDEX_AND_STRLEN_REDIRECT], 1,
 944                   [Define to 1 if index() and strlen() have been optimized heavily (x86 glibc >= 2.12)])
 945         DEFAULT_SUPP="glibc-2.X.supp ${DEFAULT_SUPP}"
 946         DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}"
 947         DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}"
 948         ;;
 949      darwin)
 950         AC_MSG_RESULT(Darwin)
 951         AC_DEFINE([DARWIN_LIBC], 1, [Define to 1 if you're using Darwin])
 952         # DEFAULT_SUPP set by kernel version check above.
 953         ;;
 954      bionic)
 955         AC_MSG_RESULT(Bionic)
 956         AC_DEFINE([BIONIC_LIBC], 1, [Define to 1 if you're using Bionic])
 957         DEFAULT_SUPP="bionic.supp ${DEFAULT_SUPP}"
 958         ;;
 959      2.0|2.1|*)
 960         AC_MSG_RESULT([unsupported version ${GLIBC_VERSION}])
 961         AC_MSG_ERROR([Valgrind requires glibc version 2.2 or later])
 962         AC_MSG_ERROR([or Darwin or Bionic libc])
 963         ;;
 964 esac
 965
 966 AC_SUBST(GLIBC_VERSION)
 967
 968
 969 # Add default suppressions for the X client libraries.  Make no
 970 # attempt to detect whether such libraries are installed on the
 971 # build machine (or even if any X facilities are present); just
 972 # add the suppressions antidisirregardless.
 973 DEFAULT_SUPP="xfree-4.supp ${DEFAULT_SUPP}"
 974 DEFAULT_SUPP="xfree-3.supp ${DEFAULT_SUPP}"
 975
 976 # Add glibc and X11 suppressions for exp-sgcheck
 977 DEFAULT_SUPP="exp-sgcheck.supp ${DEFAULT_SUPP}"
 978
 979
 980 #----------------------------------------------------------------------------
 981 # Platform variants?
 982 #----------------------------------------------------------------------------
 983
 984 # Normally the PLAT = (ARCH, OS) characterisation of the platform is enough.
 985 # But there are times where we need a bit more control.  The motivating
 986 # and currently only case is Android: this is almost identical to
 987 # {x86,arm,mips}-linux, but not quite.  So this introduces the concept of
 988 # platform variant tags, which get passed in the compile as
 989 # -DVGPV_<arch>_<os>_<variant> along with the main -DVGP_<arch>_<os> definition.
 990 #
 991 # In almost all cases, the <variant> bit is "vanilla".  But for Android
 992 # it is "android" instead.
 993 #
 994 # Consequently (eg), plain arm-linux would build with
 995 #
 996 #   -DVGP_arm_linux -DVGPV_arm_linux_vanilla
 997 #
 998 # whilst an Android build would have
 999 #
1000 #   -DVGP_arm_linux -DVGPV_arm_linux_android
1001 #
1002 # Same for x86. The setup of the platform variant is pushed relatively far
1003 # down this file in order that we can inspect any of the variables set above.
1004
1005 # In the normal case ..
1006 VGCONF_PLATVARIANT="vanilla"
1007
1008 # Android ?
1009 if test "$GLIBC_VERSION" = "bionic";
1010 then
1011    VGCONF_PLATVARIANT="android"
1012 fi
1013
1014 AC_SUBST(VGCONF_PLATVARIANT)
1015
1016
1017 # FIXME: do we also want to define automake variables
1018 # VGCONF_PLATVARIANT_IS_<WHATEVER>, where WHATEVER is (currently)
1019 # VANILLA or ANDROID ?  This would be in the style of VGCONF_ARCHS_INCLUDE,
1020 # VGCONF_PLATFORMS_INCLUDE and VGCONF_OS_IS above?  Could easily enough
1021 # do that.  Problem is that we can't do and-ing in Makefile.am's, but
1022 # that's what we'd need to do to use this, since what we'd want to write
1023 # is something like
1024 #
1025 # VGCONF_PLATFORMS_INCLUDE_ARM_LINUX && VGCONF_PLATVARIANT_IS_ANDROID
1026 #
1027 # Hmm.  Can't think of a nice clean solution to this.
1028
1029 AM_CONDITIONAL(VGCONF_PLATVARIANT_IS_VANILLA,
1030                test x$VGCONF_PLATVARIANT = xvanilla)
1031 AM_CONDITIONAL(VGCONF_PLATVARIANT_IS_ANDROID,
1032                test x$VGCONF_PLATVARIANT = xandroid)
1033
1034
1035 #----------------------------------------------------------------------------
1036 # Checking for various library functions and other definitions
1037 #----------------------------------------------------------------------------
1038
1039 # Check for AT_FDCWD
1040
1041 AC_MSG_CHECKING([for AT_FDCWD])
1042 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1043 #define _GNU_SOURCE
1044 #include <fcntl.h>
1045 #include <unistd.h>
1046 ]], [[
1047   int a = AT_FDCWD;
1048 ]])], [
1049 ac_have_at_fdcwd=yes
1050 AC_MSG_RESULT([yes])
1051 ], [
1052 ac_have_at_fdcwd=no
1053 AC_MSG_RESULT([no])
1054 ])
1055
1056 AM_CONDITIONAL([HAVE_AT_FDCWD], [test x$ac_have_at_fdcwd = xyes])
1057
1058 # Check for stpncpy function definition in string.h
1059 # This explicitly checks with _GNU_SOURCE defined since that is also
1060 # used in the test case (some systems might define it without anyway
1061 # since stpncpy is part of The Open Group Base Specifications Issue 7
1062 # IEEE Std 1003.1-2008.
1063 AC_MSG_CHECKING([for stpncpy])
1064 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
1065 #define _GNU_SOURCE
1066 #include <string.h>
1067 ]], [[
1068   char *d;
1069   char *s;
1070   size_t n = 0;
1071   char *r = stpncpy(d, s, n);
1072 ]])], [
1073 ac_have_gnu_stpncpy=yes
1074 AC_MSG_RESULT([yes])
1075 ], [
1076 ac_have_gnu_stpncpy=no
1077 AC_MSG_RESULT([no])
1078 ])
1079
1080 AM_CONDITIONAL([HAVE_GNU_STPNCPY], [test x$ac_have_gnu_stpncpy = xyes])
1081
1082 # Check for PTRACE_GETREGS
1083
1084 AC_MSG_CHECKING([for PTRACE_GETREGS])
1085 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1086 #include <stddef.h>
1087 #include <sys/ptrace.h>
1088 #include <sys/user.h>
1089 ]], [[
1090   void *p;
1091   long res = ptrace (PTRACE_GETREGS, 0, p, p);
1092 ]])], [
1093 AC_MSG_RESULT([yes])
1094 AC_DEFINE([HAVE_PTRACE_GETREGS], 1,
1095           [Define to 1 if you have the `PTRACE_GETREGS' ptrace request.])
1096 ], [
1097 AC_MSG_RESULT([no])
1098 ])
1099
1100
1101 # Check for CLOCK_MONOTONIC
1102
1103 AC_MSG_CHECKING([for CLOCK_MONOTONIC])
1104
1105 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1106 #include <time.h>
1107 ]], [[
1108   struct timespec t;
1109   clock_gettime(CLOCK_MONOTONIC, &t);
1110   return 0;
1111 ]])], [
1112 AC_MSG_RESULT([yes])
1113 AC_DEFINE([HAVE_CLOCK_MONOTONIC], 1,
1114           [Define to 1 if you have the `CLOCK_MONOTONIC' constant.])
1115 ], [
1116 AC_MSG_RESULT([no])
1117 ])
1118
1119
1120 # Check for PTHREAD_RWLOCK_T
1121
1122 AC_MSG_CHECKING([for pthread_rwlock_t])
1123
1124 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1125 #define _GNU_SOURCE
1126 #include <pthread.h>
1127 ]], [[
1128   pthread_rwlock_t rwl;
1129 ]])], [
1130 AC_MSG_RESULT([yes])
1131 AC_DEFINE([HAVE_PTHREAD_RWLOCK_T], 1,
1132           [Define to 1 if you have the `pthread_rwlock_t' type.])
1133 ], [
1134 AC_MSG_RESULT([no])
1135 ])
1136
1137
1138 # Check for PTHREAD_MUTEX_ADAPTIVE_NP
1139
1140 AC_MSG_CHECKING([for PTHREAD_MUTEX_ADAPTIVE_NP])
1141
1142 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1143 #define _GNU_SOURCE
1144 #include <pthread.h>
1145 ]], [[
1146   return (PTHREAD_MUTEX_ADAPTIVE_NP);
1147 ]])], [
1148 AC_MSG_RESULT([yes])
1149 AC_DEFINE([HAVE_PTHREAD_MUTEX_ADAPTIVE_NP], 1,
1150           [Define to 1 if you have the `PTHREAD_MUTEX_ADAPTIVE_NP' constant.])
1151 ], [
1152 AC_MSG_RESULT([no])
1153 ])
1154
1155
1156 # Check for PTHREAD_MUTEX_ERRORCHECK_NP
1157
1158 AC_MSG_CHECKING([for PTHREAD_MUTEX_ERRORCHECK_NP])
1159
1160 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1161 #define _GNU_SOURCE
1162 #include <pthread.h>
1163 ]], [[
1164   return (PTHREAD_MUTEX_ERRORCHECK_NP);
1165 ]])], [
1166 AC_MSG_RESULT([yes])
1167 AC_DEFINE([HAVE_PTHREAD_MUTEX_ERRORCHECK_NP], 1,
1168           [Define to 1 if you have the `PTHREAD_MUTEX_ERRORCHECK_NP' constant.])
1169 ], [
1170 AC_MSG_RESULT([no])
1171 ])
1172
1173
1174 # Check for PTHREAD_MUTEX_RECURSIVE_NP
1175
1176 AC_MSG_CHECKING([for PTHREAD_MUTEX_RECURSIVE_NP])
1177
1178 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1179 #define _GNU_SOURCE
1180 #include <pthread.h>
1181 ]], [[
1182   return (PTHREAD_MUTEX_RECURSIVE_NP);
1183 ]])], [
1184 AC_MSG_RESULT([yes])
1185 AC_DEFINE([HAVE_PTHREAD_MUTEX_RECURSIVE_NP], 1,
1186           [Define to 1 if you have the `PTHREAD_MUTEX_RECURSIVE_NP' constant.])
1187 ], [
1188 AC_MSG_RESULT([no])
1189 ])
1190
1191
1192 # Check for PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
1193
1194 AC_MSG_CHECKING([for PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP])
1195
1196 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1197 #define _GNU_SOURCE
1198 #include <pthread.h>
1199 ]], [[
1200   pthread_mutex_t m = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
1201   return 0;
1202 ]])], [
1203 AC_MSG_RESULT([yes])
1204 AC_DEFINE([HAVE_PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP], 1,
1205           [Define to 1 if you have the `PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP' constant.])
1206 ], [
1207 AC_MSG_RESULT([no])
1208 ])
1209
1210
1211 # Check whether pthread_mutex_t has a member called __m_kind.
1212
1213 AC_CHECK_MEMBER([pthread_mutex_t.__m_kind],
1214                 [AC_DEFINE([HAVE_PTHREAD_MUTEX_T__M_KIND],
1215                            1,
1216                            [Define to 1 if pthread_mutex_t has a member called __m_kind.])
1217                 ],
1218                 [],
1219                 [#include <pthread.h>])
1220
1221
1222 # Check whether pthread_mutex_t has a member called __data.__kind.
1223
1224 AC_CHECK_MEMBER([pthread_mutex_t.__data.__kind],
1225                 [AC_DEFINE([HAVE_PTHREAD_MUTEX_T__DATA__KIND],
1226                           1,
1227                           [Define to 1 if pthread_mutex_t has a member __data.__kind.])
1228                 ],
1229                 [],
1230                 [#include <pthread.h>])
1231
1232
1233 # does this compiler support -maltivec and does it have the include file
1234 # <altivec.h> ?
1235
1236 AC_MSG_CHECKING([for Altivec])
1237
1238 safe_CFLAGS=$CFLAGS
1239 CFLAGS="-maltivec"
1240
1241 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1242 #include <altivec.h>
1243 ]], [[
1244   vector unsigned int v;
1245 ]])], [
1246 ac_have_altivec=yes
1247 AC_MSG_RESULT([yes])
1248 AC_DEFINE([HAS_ALTIVEC], 1,
1249           [Define to 1 if gcc/as can do Altivec.])
1250 ], [
1251 ac_have_altivec=no
1252 AC_MSG_RESULT([no])
1253 ])
1254 CFLAGS=$safe_CFLAGS
1255
1256 AM_CONDITIONAL([HAS_ALTIVEC], [test x$ac_have_altivec = xyes])
1257
1258
1259 # Check that both: the compiler supports -mvsx and that the assembler
1260 # understands VSX instructions.  If either of those doesn't work,
1261 # conclude that we can't do VSX.  NOTE: basically this is a kludge
1262 # in that it conflates two things that should be separate -- whether
1263 # the compiler understands the flag vs whether the assembler
1264 # understands the opcodes.  This really ought to be cleaned up
1265 # and done properly, like it is for x86/x86_64.
1266
1267 AC_MSG_CHECKING([for VSX])
1268
1269 safe_CFLAGS=$CFLAGS
1270 CFLAGS="-mvsx"
1271
1272 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1273 #include <altivec.h>
1274 ]], [[
1275   vector unsigned int v;
1276   __asm__ __volatile__("xsmaddadp 32, 32, 33" ::: "memory","cc");
1277 ]])], [
1278 ac_have_vsx=yes
1279 AC_MSG_RESULT([yes])
1280 ], [
1281 ac_have_vsx=no
1282 AC_MSG_RESULT([no])
1283 ])
1284 CFLAGS=$safe_CFLAGS
1285
1286 AM_CONDITIONAL(HAS_VSX, test x$ac_have_vsx = xyes)
1287
1288
1289 AC_MSG_CHECKING([that assembler knows DFP])
1290
1291 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1292 ]], [[
1293   __asm__ __volatile__("dadd 1, 2, 3");
1294   __asm__ __volatile__("dcffix 1, 2");
1295 ]])], [
1296 ac_asm_have_dfp=yes
1297 AC_MSG_RESULT([yes])
1298 ], [
1299 ac_asm_have_dfp=no
1300 AC_MSG_RESULT([no])
1301 ])
1302
1303
1304 AC_MSG_CHECKING([that compiler knows -mhard-dfp switch])
1305 safe_CFLAGS=$CFLAGS
1306 CFLAGS="-mhard-dfp"
1307 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1308 ]], [[
1309   __asm__ __volatile__("dadd 1, 2, 3");
1310   __asm__ __volatile__("dcffix 1, 2");
1311 ]])], [
1312 ac_gcc_have_dfp=yes
1313 AC_MSG_RESULT([yes])
1314 ], [
1315 ac_gcc_have_dfp=no
1316 AC_MSG_RESULT([no])
1317 ])
1318
1319 CFLAGS=$safe_CFLAGS
1320
1321 AM_CONDITIONAL(HAS_DFP, test x$ac_asm_have_dfp = xyes -a x$ac_gcc_have_dfp = xyes)
1322
1323
1324 AC_MSG_CHECKING([that compiler knows DFP datatypes])
1325 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1326 ]], [[
1327   _Decimal64 x = 0.0DD;
1328 ]])], [
1329 ac_gcc_have_dfp_type=yes
1330 AC_MSG_RESULT([yes])
1331 ], [
1332 ac_gcc_have_dfp_type=no
1333 AC_MSG_RESULT([no])
1334 ])
1335
1336 AM_CONDITIONAL(BUILD_DFP_TESTS, test x$ac_gcc_have_dfp_type = xyes)
1337
1338 # isa 2.07 checking
1339 AC_MSG_CHECKING([that assembler knows ISA 2.07 ])
1340
1341 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1342 ]], [[
1343   __asm__ __volatile__("mtvsrd 1,2 ");
1344 ]])], [
1345 ac_asm_have_isa_2_07=yes
1346 AC_MSG_RESULT([yes])
1347 ], [
1348 ac_asm_have_isa_2_07=no
1349 AC_MSG_RESULT([no])
1350 ])
1351
1352 AM_CONDITIONAL(HAS_ISA_2_07, test x$ac_asm_have_isa_2_07 = xyes)
1353
1354 # Check for pthread_create@GLIBC2.0
1355 AC_MSG_CHECKING([for pthread_create@GLIBC2.0()])
1356
1357 safe_CFLAGS=$CFLAGS
1358 CFLAGS="-lpthread"
1359 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
1360 extern int pthread_create_glibc_2_0(void*, const void*,
1361                                     void *(*)(void*), void*);
1362 __asm__(".symver pthread_create_glibc_2_0, pthread_create@GLIBC_2.0");
1363 ]], [[
1364 #ifdef __powerpc__
1365 /*
1366  * Apparently on PowerPC linking this program succeeds and generates an
1367  * executable with the undefined symbol pthread_create@GLIBC_2.0.
1368  */
1369 #error This test does not work properly on PowerPC.
1370 #else
1371   pthread_create_glibc_2_0(0, 0, 0, 0);
1372 #endif
1373   return 0;
1374 ]])], [
1375 ac_have_pthread_create_glibc_2_0=yes
1376 AC_MSG_RESULT([yes])
1377 AC_DEFINE([HAVE_PTHREAD_CREATE_GLIBC_2_0], 1,
1378           [Define to 1 if you have the `pthread_create@glibc2.0' function.])
1379 ], [
1380 ac_have_pthread_create_glibc_2_0=no
1381 AC_MSG_RESULT([no])
1382 ])
1383 CFLAGS=$safe_CFLAGS
1384
1385 AM_CONDITIONAL(HAVE_PTHREAD_CREATE_GLIBC_2_0,
1386                test x$ac_have_pthread_create_glibc_2_0 = xyes)
1387
1388
1389 # Check for dlinfo RTLD_DI_TLS_MODID
1390 AC_MSG_CHECKING([for dlinfo RTLD_DI_TLS_MODID])
1391
1392 safe_LIBS="$LIBS"
1393 LIBS="-ldl"
1394 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
1395 #ifndef _GNU_SOURCE
1396 #define _GNU_SOURCE
1397 #endif
1398 #include <link.h>
1399 #include <dlfcn.h>
1400 ]], [[
1401   size_t sizes[10000];
1402   size_t modid_offset;
1403   (void) dlinfo ((void*)sizes, RTLD_DI_TLS_MODID, &modid_offset);
1404   return 0;
1405 ]])], [
1406 ac_have_dlinfo_rtld_di_tls_modid=yes
1407 AC_MSG_RESULT([yes])
1408 AC_DEFINE([HAVE_DLINFO_RTLD_DI_TLS_MODID], 1,
1409           [Define to 1 if you have a dlinfo that can do RTLD_DI_TLS_MODID.])
1410 ], [
1411 ac_have_dlinfo_rtld_di_tls_modid=no
1412 AC_MSG_RESULT([no])
1413 ])
1414 LIBS=$safe_LIBS
1415
1416 AM_CONDITIONAL(HAVE_DLINFO_RTLD_DI_TLS_MODID,
1417                test x$ac_have_dlinfo_rtld_di_tls_modid = xyes)
1418
1419
1420 # Check for eventfd_t, eventfd() and eventfd_read()
1421 AC_MSG_CHECKING([for eventfd()])
1422
1423 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
1424 #include <sys/eventfd.h>
1425 ]], [[
1426   eventfd_t ev;
1427   int fd;
1428
1429   fd = eventfd(5, 0);
1430   eventfd_read(fd, &ev);
1431   return 0;
1432 ]])], [
1433 AC_MSG_RESULT([yes])
1434 AC_DEFINE([HAVE_EVENTFD], 1,
1435           [Define to 1 if you have the `eventfd' function.])
1436 AC_DEFINE([HAVE_EVENTFD_READ], 1,
1437           [Define to 1 if you have the `eventfd_read' function.])
1438 ], [
1439 AC_MSG_RESULT([no])
1440 ])
1441
1442 # Check whether compiler can process #include <thread> without errors
1443 # clang 3.3 cannot process <thread> from e.g.
1444 # gcc (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3
1445
1446 AC_MSG_CHECKING([that C++ compiler can include <thread> header file])
1447 AC_LANG(C++)
1448 safe_CXXFLAGS=$CXXFLAGS
1449 CXXFLAGS=-std=c++0x
1450
1451 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
1452 #include <thread>
1453 ])],
1454 [
1455 ac_cxx_can_include_thread_header=yes
1456 AC_MSG_RESULT([yes])
1457 ], [
1458 ac_cxx_can_include_thread_header=no
1459 AC_MSG_RESULT([no])
1460 ])
1461 CXXFLAGS=$safe_CXXFLAGS
1462 AC_LANG(C)
1463
1464 AM_CONDITIONAL(CXX_CAN_INCLUDE_THREAD_HEADER, test x$ac_cxx_can_include_thread_header = xyes)
1465
1466
1467 # On aarch64 before glibc 2.20 we would get the kernel user_pt_regs instead
1468 # of the user_regs_struct from sys/user.h. They are structurally the same
1469 # but we get either one or the other.
1470
1471 AC_CHECK_TYPE([struct user_regs_struct],
1472               [sys_user_has_user_regs=yes], [sys_user_has_user_regs=no],
1473               [[#include <sys/ptrace.h>]
1474                [#include <sys/time.h>]
1475                [#include <sys/user.h>]])
1476 if test "$sys_user_has_user_regs" = "yes"; then
1477   AC_DEFINE(HAVE_SYS_USER_REGS, 1,
1478             [Define to 1 if <sys/user.h> defines struct user_regs_struct])
1479 fi
1480
1481
1482 #----------------------------------------------------------------------------
1483 # Checking for supported compiler flags.
1484 #----------------------------------------------------------------------------
1485
1486 # does this compiler support -m32 ?
1487 AC_MSG_CHECKING([if gcc accepts -m32])
1488
1489 safe_CFLAGS=$CFLAGS
1490 CFLAGS="-m32"
1491
1492 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
1493   return 0;
1494 ]])], [
1495 FLAG_M32="-m32"
1496 AC_MSG_RESULT([yes])
1497 ], [
1498 FLAG_M32=""
1499 AC_MSG_RESULT([no])
1500 ])
1501 CFLAGS=$safe_CFLAGS
1502
1503 AC_SUBST(FLAG_M32)
1504
1505
1506 # does this compiler support -m64 ?
1507 AC_MSG_CHECKING([if gcc accepts -m64])
1508
1509 safe_CFLAGS=$CFLAGS
1510 CFLAGS="-m64"
1511
1512 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
1513   return 0;
1514 ]])], [
1515 FLAG_M64="-m64"
1516 AC_MSG_RESULT([yes])
1517 ], [
1518 FLAG_M64=""
1519 AC_MSG_RESULT([no])
1520 ])
1521 CFLAGS=$safe_CFLAGS
1522
1523 AC_SUBST(FLAG_M64)
1524
1525
1526 # does this compiler support -march=mips32 (mips32 default) ?
1527 AC_MSG_CHECKING([if gcc accepts -march=mips32])
1528
1529 safe_CFLAGS=$CFLAGS
1530 CFLAGS="$CFLAGS -march=mips32"
1531
1532 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
1533   return 0;
1534 ]])], [
1535 FLAG_MIPS32="-march=mips32"
1536 AC_MSG_RESULT([yes])
1537 ], [
1538 FLAG_MIPS32=""
1539 AC_MSG_RESULT([no])
1540 ])
1541 CFLAGS=$safe_CFLAGS
1542
1543 AC_SUBST(FLAG_MIPS32)
1544
1545
1546 # does this compiler support -march=mips64 (mips64 default) ?
1547 AC_MSG_CHECKING([if gcc accepts -march=mips64])
1548
1549 safe_CFLAGS=$CFLAGS
1550 CFLAGS="$CFLAGS -march=mips64"
1551
1552 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
1553   return 0;
1554 ]])], [
1555 FLAG_MIPS64="-march=mips64"
1556 AC_MSG_RESULT([yes])
1557 ], [
1558 FLAG_MIPS64=""
1559 AC_MSG_RESULT([no])
1560 ])
1561 CFLAGS=$safe_CFLAGS
1562
1563 AC_SUBST(FLAG_MIPS64)
1564
1565
1566 # does this compiler support -march=octeon (Cavium OCTEON I Specific) ?
1567 AC_MSG_CHECKING([if gcc accepts -march=octeon])
1568
1569 safe_CFLAGS=$CFLAGS
1570 CFLAGS="$CFLAGS -march=octeon"
1571
1572 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
1573   return 0;
1574 ]])], [
1575 FLAG_OCTEON="-march=octeon"
1576 AC_MSG_RESULT([yes])
1577 ], [
1578 FLAG_OCTEON=""
1579 AC_MSG_RESULT([no])
1580 ])
1581 CFLAGS=$safe_CFLAGS
1582
1583 AC_SUBST(FLAG_OCTEON)
1584
1585
1586 # does this compiler support -march=octeon2 (Cavium OCTEON II Specific) ?
1587 AC_MSG_CHECKING([if gcc accepts -march=octeon2])
1588
1589 safe_CFLAGS=$CFLAGS
1590 CFLAGS="$CFLAGS -march=octeon2"
1591
1592 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
1593   return 0;
1594 ]])], [
1595 FLAG_OCTEON2="-march=octeon2"
1596 AC_MSG_RESULT([yes])
1597 ], [
1598 FLAG_OCTEON2=""
1599 AC_MSG_RESULT([no])
1600 ])
1601 CFLAGS=$safe_CFLAGS
1602
1603 AC_SUBST(FLAG_OCTEON2)
1604
1605
1606 # does this compiler support -mmmx ?
1607 AC_MSG_CHECKING([if gcc accepts -mmmx])
1608
1609 safe_CFLAGS=$CFLAGS
1610 CFLAGS="-mmmx"
1611
1612 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
1613   return 0;
1614 ]])], [
1615 FLAG_MMMX="-mmmx"
1616 AC_MSG_RESULT([yes])
1617 ], [
1618 FLAG_MMMX=""
1619 AC_MSG_RESULT([no])
1620 ])
1621 CFLAGS=$safe_CFLAGS
1622
1623 AC_SUBST(FLAG_MMMX)
1624
1625
1626 # does this compiler support -msse ?
1627 AC_MSG_CHECKING([if gcc accepts -msse])
1628
1629 safe_CFLAGS=$CFLAGS
1630 CFLAGS="-msse"
1631
1632 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
1633   return 0;
1634 ]])], [
1635 FLAG_MSSE="-msse"
1636 AC_MSG_RESULT([yes])
1637 ], [
1638 FLAG_MSSE=""
1639 AC_MSG_RESULT([no])
1640 ])
1641 CFLAGS=$safe_CFLAGS
1642
1643 AC_SUBST(FLAG_MSSE)
1644
1645
1646 # does this compiler support -mpreferred-stack-boundary=2 when
1647 # generating code for a 32-bit target?  Note that we only care about
1648 # this when generating code for (32-bit) x86, so if the compiler
1649 # doesn't recognise -m32 it's no big deal.  We'll just get code for
1650 # the Memcheck and other helper functions, that is a bit slower than
1651 # it could be, on x86; and no difference at all on any other platform.
1652 AC_MSG_CHECKING([if gcc accepts -mpreferred-stack-boundary=2 -m32])
1653
1654 safe_CFLAGS=$CFLAGS
1655 CFLAGS="-mpreferred-stack-boundary=2 -m32"
1656
1657 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
1658   return 0;
1659 ]])], [
1660 PREFERRED_STACK_BOUNDARY_2="-mpreferred-stack-boundary=2"
1661 AC_MSG_RESULT([yes])
1662 ], [
1663 PREFERRED_STACK_BOUNDARY_2=""
1664 AC_MSG_RESULT([no])
1665 ])
1666 CFLAGS=$safe_CFLAGS
1667
1668 AC_SUBST(PREFERRED_STACK_BOUNDARY_2)
1669
1670
1671 # Convenience function to check whether GCC supports a particular
1672 # warning option. Takes two arguments, first the warning flag name
1673 # to check (without -W), then the conditional name to set if that
1674 # warning flag is supported.
1675 AC_DEFUN([AC_GCC_WARNING_COND],[
1676   AC_MSG_CHECKING([if gcc accepts -W$1])
1677   safe_CFLAGS=$CFLAGS
1678   CFLAGS="-W$1"
1679   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[;]])], [
1680   has_warning_flag=yes
1681   AC_MSG_RESULT([yes])], [
1682   has_warning_flag=no
1683   AC_MSG_RESULT([no])])
1684   CFLAGS=$safe_CFLAGS
1685   AM_CONDITIONAL([$2], test x$has_warning_flag = xyes)
1686 ])
1687
1688 AC_GCC_WARNING_COND([pointer-sign], [HAS_POINTER_SIGN_WARNING])
1689 AC_GCC_WARNING_COND([write-strings], [HAS_WRITE_STRINGS_WARNING])
1690 if test $has_warning_flag = yes; then
1691   CFLAGS="$CFLAGS -Wwrite-strings"
1692   CXXFLAGS="$CXXFLAGS -Wwrite-strings"
1693 fi
1694
1695 # Convenience function to check whether GCC supports a particular
1696 # warning option. Similar to AC_GCC_WARNING_COND, but does a
1697 # substitution instead of setting an conditional. Takes two arguments,
1698 # first the warning flag name to check (without -W), then the
1699 # substitution name to set with -Wno-warning-flag if the flag exists,
1700 # or the empty string if the compiler doesn't accept the flag. Note
1701 # that checking is done against the warning flag itself, but the
1702 # substitution is then done to cancel the warning flag.
1703 AC_DEFUN([AC_GCC_WARNING_SUBST_NO],[
1704   AC_MSG_CHECKING([if gcc accepts -W$1])
1705   safe_CFLAGS=$CFLAGS
1706   CFLAGS="-W$1"
1707   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[;]])], [
1708   AC_SUBST([$2], [-Wno-$1])
1709   AC_MSG_RESULT([yes])], [
1710   AC_SUBST([$2], [])
1711   AC_MSG_RESULT([no])])
1712   CFLAGS=$safe_CFLAGS
1713 ])
1714
1715 AC_GCC_WARNING_SUBST_NO([empty-body], [FLAG_W_NO_EMPTY_BODY])
1716 AC_GCC_WARNING_SUBST_NO([format-zero-length], [FLAG_W_NO_FORMAT_ZERO_LENGTH])
1717 AC_GCC_WARNING_SUBST_NO([tautological-compare], [FLAG_W_NO_TAUTOLOGICAL_COMPARE])
1718 AC_GCC_WARNING_SUBST_NO([nonnull], [FLAG_W_NO_NONNULL])
1719 AC_GCC_WARNING_SUBST_NO([overflow], [FLAG_W_NO_OVERFLOW])
1720 AC_GCC_WARNING_SUBST_NO([uninitialized], [FLAG_W_NO_UNINITIALIZED])
1721 AC_GCC_WARNING_SUBST_NO([unused-function], [FLAG_W_NO_UNUSED_FUNCTION])
1722 AC_GCC_WARNING_SUBST_NO([static-local-in-inline], [FLAG_W_NO_STATIC_LOCAL_IN_INLINE])
1723
1724
1725 # does this compiler support -Wextra or the older -W ?
1726
1727 AC_MSG_CHECKING([if gcc accepts -Wextra or -W])
1728
1729 safe_CFLAGS=$CFLAGS
1730 CFLAGS="-Wextra"
1731
1732 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[
1733   return 0;
1734 ]])], [
1735 AC_SUBST([FLAG_W_EXTRA], [-Wextra])
1736 AC_MSG_RESULT([-Wextra])
1737 ], [
1738   CFLAGS="-W"
1739   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[
1740     return 0;
1741   ]])], [
1742   AC_SUBST([FLAG_W_EXTRA], [-W])
1743   AC_MSG_RESULT([-W])
1744   ], [
1745   AC_SUBST([FLAG_W_EXTRA], [])
1746   AC_MSG_RESULT([not supported])
1747   ])
1748 ])
1749 CFLAGS=$safe_CFLAGS
1750
1751 # does this compiler support -Wcast-qual ?
1752 AC_GCC_WARNING_COND([cast-qual], [HAS_CAST_QUAL_WARNING])
1753 if test $has_warning_flag = yes; then
1754   CFLAGS="$CFLAGS -Wcast-qual"
1755   CXXFLAGS="$CXXFLAGS -Wcast-qual"
1756 fi
1757
1758
1759 # does this compiler support -fno-stack-protector ?
1760 AC_MSG_CHECKING([if gcc accepts -fno-stack-protector])
1761
1762 safe_CFLAGS=$CFLAGS
1763 CFLAGS="-fno-stack-protector"
1764
1765 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
1766   return 0;
1767 ]])], [
1768 no_stack_protector=yes
1769 FLAG_FNO_STACK_PROTECTOR="-fno-stack-protector"
1770 AC_MSG_RESULT([yes])
1771 ], [
1772 no_stack_protector=no
1773 FLAG_FNO_STACK_PROTECTOR=""
1774 AC_MSG_RESULT([no])
1775 ])
1776 CFLAGS=$safe_CFLAGS
1777
1778 AC_SUBST(FLAG_FNO_STACK_PROTECTOR)
1779
1780 if test x$no_stack_protector = xyes; then
1781   CFLAGS="$CFLAGS -fno-stack-protector"
1782   CXXFLAGS="$CXXFLAGS -fno-stack-protector"
1783 fi
1784
1785
1786 # does this compiler support --param inline-unit-growth=... ?
1787
1788 AC_MSG_CHECKING([if gcc accepts --param inline-unit-growth])
1789
1790 safe_CFLAGS=$CFLAGS
1791 CFLAGS="--param inline-unit-growth=900"
1792
1793 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[
1794   return 0;
1795 ]])], [
1796 AC_SUBST([FLAG_UNLIMITED_INLINE_UNIT_GROWTH],
1797          ["--param inline-unit-growth=900"])
1798 AC_MSG_RESULT([yes])
1799 ], [
1800 AC_SUBST([FLAG_UNLIMITED_INLINE_UNIT_GROWTH], [""])
1801 AC_MSG_RESULT([no])
1802 ])
1803 CFLAGS=$safe_CFLAGS
1804
1805
1806 # does this compiler support -gdwarf-4 -fdebug-types-section ?
1807
1808 AC_MSG_CHECKING([if gcc accepts -gdwarf-4 -fdebug-types-section])
1809
1810 safe_CFLAGS=$CFLAGS
1811 CFLAGS="-gdwarf-4 -fdebug-types-section"
1812
1813 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[
1814   return 0;
1815 ]])], [
1816 ac_have_dwarf4=yes
1817 AC_MSG_RESULT([yes])
1818 ], [
1819 ac_have_dwarf4=no
1820 AC_MSG_RESULT([no])
1821 ])
1822 AM_CONDITIONAL(DWARF4, test x$ac_have_dwarf4 = xyes)
1823 CFLAGS=$safe_CFLAGS
1824
1825
1826 # does this compiler support nested functions ?
1827
1828 AC_MSG_CHECKING([if gcc accepts nested functions])
1829
1830 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
1831   int foo() { return 1; }
1832   return foo();
1833 ]])], [
1834 ac_have_nested_functions=yes
1835 AC_MSG_RESULT([yes])
1836 ], [
1837 ac_have_nested_functions=no
1838 AC_MSG_RESULT([no])
1839 ])
1840 AM_CONDITIONAL([HAVE_NESTED_FUNCTIONS], [test x$ac_have_nested_functions = xyes])
1841
1842
1843 # does this compiler support the 'p' constraint in ASM statements ?
1844
1845 AC_MSG_CHECKING([if gcc accepts the 'p' constraint in asm statements])
1846
1847 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
1848    char *p;
1849    __asm__ __volatile__ ("movdqa (%0),%%xmm6\n" : "=p" (p));
1850 ]])], [
1851 ac_have_asm_constraint_p=yes
1852 AC_MSG_RESULT([yes])
1853 ], [
1854 ac_have_asm_constraint_p=no
1855 AC_MSG_RESULT([no])
1856 ])
1857 AM_CONDITIONAL([HAVE_ASM_CONSTRAINT_P], [test x$ac_have_asm_constraint_p = xyes])
1858
1859
1860 # We want to use use the -Ttext-segment option to the linker.
1861 # GNU (bfd) ld supports this directly. Newer GNU gold linkers
1862 # support it as an alias of -Ttext. Sadly GNU (bfd) ld's -Ttext
1863 # semantics are NOT what we want (GNU gold -Ttext is fine).
1864 #
1865 # For GNU (bfd) ld -Ttext-segment chooses the base at which ELF headers
1866 # will reside. -Ttext aligns just the .text section start (but not any
1867 # other section).
1868 #
1869 # So test for -Ttext-segment which is supported by all bfd ld versions
1870 # and use that if it exists. If it doesn't exist it must be an older
1871 # version of gold and we can fall back to using -Ttext which has the
1872 # right semantics.
1873
1874 AC_MSG_CHECKING([if the linker accepts -Wl,-Ttext-segment])
1875
1876 safe_CFLAGS=$CFLAGS
1877 CFLAGS="-static -nodefaultlibs -nostartfiles -Wl,-Ttext-segment=$valt_load_address_pri_norml"
1878
1879 AC_LINK_IFELSE(
1880 [AC_LANG_SOURCE([int _start () { return 0; }])],
1881 [
1882   linker_using_t_text="no"
1883   AC_SUBST([FLAG_T_TEXT], ["-Ttext-segment"])
1884   AC_MSG_RESULT([yes])
1885 ], [
1886   linker_using_t_text="yes"
1887   AC_SUBST([FLAG_T_TEXT], ["-Ttext"])
1888   AC_MSG_RESULT([no])
1889 ])
1890 CFLAGS=$safe_CFLAGS
1891
1892 # If the linker only supports -Ttext (not -Ttext-segment) then we will
1893 # have to strip any build-id ELF NOTEs from the staticly linked tools.
1894 # Otherwise the build-id NOTE might end up at the default load address.
1895 # (Pedantically if the linker is gold then -Ttext is fine, but newer
1896 # gold versions also support -Ttext-segment. So just assume that unless
1897 # we can use -Ttext-segment we need to strip the build-id NOTEs.
1898 if test "x${linker_using_t_text}" = "xyes"; then
1899 AC_MSG_NOTICE([ld -Ttext used, need to strip build-id NOTEs.])
1900 # does the linker support -Wl,--build-id=none ?  Note, it's
1901 # important that we test indirectly via whichever C compiler
1902 # is selected, rather than testing /usr/bin/ld or whatever
1903 # directly.
1904 AC_MSG_CHECKING([if the linker accepts -Wl,--build-id=none])
1905 safe_CFLAGS=$CFLAGS
1906 CFLAGS="-Wl,--build-id=none"
1907
1908 AC_LINK_IFELSE(
1909 [AC_LANG_PROGRAM([ ], [return 0;])],
1910 [
1911   AC_SUBST([FLAG_NO_BUILD_ID], ["-Wl,--build-id=none"])
1912   AC_MSG_RESULT([yes])
1913 ], [
1914   AC_SUBST([FLAG_NO_BUILD_ID], [""])
1915   AC_MSG_RESULT([no])
1916 ])
1917 else
1918 AC_MSG_NOTICE([ld -Ttext-segment used, no need to strip build-id NOTEs.])
1919 AC_SUBST([FLAG_NO_BUILD_ID], [""])
1920 fi
1921 CFLAGS=$safe_CFLAGS
1922
1923 # does the ppc assembler support "mtocrf" et al?
1924 AC_MSG_CHECKING([if ppc32/64 as supports mtocrf/mfocrf])
1925
1926 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
1927 __asm__ __volatile__("mtocrf 4,0");
1928 __asm__ __volatile__("mfocrf 0,4");
1929 ]])], [
1930 ac_have_as_ppc_mftocrf=yes
1931 AC_MSG_RESULT([yes])
1932 ], [
1933 ac_have_as_ppc_mftocrf=no
1934 AC_MSG_RESULT([no])
1935 ])
1936 if test x$ac_have_as_ppc_mftocrf = xyes ; then
1937   AC_DEFINE(HAVE_AS_PPC_MFTOCRF, 1, [Define to 1 if as supports mtocrf/mfocrf.])
1938 fi
1939
1940
1941 # does the ppc assembler support "lfdp" and other phased out floating point insns?
1942 AC_MSG_CHECKING([if ppc32/64 asm supports phased out floating point instructions])
1943
1944 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
1945   do { typedef struct {
1946       double hi;
1947       double lo;
1948      } dbl_pair_t;
1949      dbl_pair_t dbl_pair[3];
1950      __asm__ volatile ("lfdp 10, %0"::"m" (dbl_pair[0]));
1951    } while (0)
1952 ]])], [
1953 ac_have_as_ppc_fpPO=yes
1954 AC_MSG_RESULT([yes])
1955 ], [
1956 ac_have_as_ppc_fpPO=no
1957 AC_MSG_RESULT([no])
1958 ])
1959 if test x$ac_have_as_ppc_fpPO = xyes ; then
1960   AC_DEFINE(HAVE_AS_PPC_FPPO, 1, [Define to 1 if as supports floating point phased out category.])
1961 fi
1962
1963
1964 # does the x86/amd64 assembler understand SSE3 instructions?
1965 # Note, this doesn't generate a C-level symbol.  It generates a
1966 # automake-level symbol (BUILD_SSE3_TESTS), used in test Makefile.am's
1967 AC_MSG_CHECKING([if x86/amd64 assembler speaks SSE3])
1968
1969 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
1970   do { long long int x;
1971      __asm__ __volatile__("fisttpq (%0)" : :"r"(&x) ); }
1972   while (0)
1973 ]])], [
1974 ac_have_as_sse3=yes
1975 AC_MSG_RESULT([yes])
1976 ], [
1977 ac_have_as_sse3=no
1978 AC_MSG_RESULT([no])
1979 ])
1980
1981 AM_CONDITIONAL(BUILD_SSE3_TESTS, test x$ac_have_as_sse3 = xyes)
1982
1983
1984 # Ditto for SSSE3 instructions (note extra S)
1985 # Note, this doesn't generate a C-level symbol.  It generates a
1986 # automake-level symbol (BUILD_SSSE3_TESTS), used in test Makefile.am's
1987 AC_MSG_CHECKING([if x86/amd64 assembler speaks SSSE3])
1988
1989 save_CFLAGS="$CFLAGS"
1990 CFLAGS="$CFLAGS -msse"
1991 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
1992   do { long long int x;
1993    __asm__ __volatile__(
1994       "pabsb (%0),%%xmm7" : : "r"(&x) : "xmm7" ); }
1995   while (0)
1996 ]])], [
1997 ac_have_as_ssse3=yes
1998 AC_MSG_RESULT([yes])
1999 ], [
2000 ac_have_as_ssse3=no
2001 AC_MSG_RESULT([no])
2002 ])
2003 CFLAGS="$save_CFLAGS"
2004
2005 AM_CONDITIONAL(BUILD_SSSE3_TESTS, test x$ac_have_as_ssse3 = xyes)
2006
2007
2008 # does the x86/amd64 assembler understand the PCLMULQDQ instruction?
2009 # Note, this doesn't generate a C-level symbol.  It generates a
2010 # automake-level symbol (BUILD_PCLMULQDQ_TESTS), used in test Makefile.am's
2011 AC_MSG_CHECKING([if x86/amd64 assembler supports 'pclmulqdq'])
2012 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
2013   do {
2014    __asm__ __volatile__(
2015       "pclmulqdq \$17,%%xmm6,%%xmm7" : : : "xmm6", "xmm7" ); }
2016   while (0)
2017 ]])], [
2018 ac_have_as_pclmulqdq=yes
2019 AC_MSG_RESULT([yes])
2020 ], [
2021 ac_have_as_pclmulqdq=no
2022 AC_MSG_RESULT([no])
2023 ])
2024
2025 AM_CONDITIONAL(BUILD_PCLMULQDQ_TESTS, test x$ac_have_as_pclmulqdq = xyes)
2026
2027
2028 # does the x86/amd64 assembler understand the VPCLMULQDQ instruction?
2029 # Note, this doesn't generate a C-level symbol.  It generates a
2030 # automake-level symbol (BUILD_VPCLMULQDQ_TESTS), used in test Makefile.am's
2031 AC_MSG_CHECKING([if x86/amd64 assembler supports 'vpclmulqdq'])
2032 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
2033   do {
2034       /*
2035        * Carry-less multiplication of xmm1 with xmm2 and store the result in
2036        * xmm3. The immediate is used to determine which quadwords of xmm1 and
2037        * xmm2 should be used.
2038        */
2039    __asm__ __volatile__(
2040       "vpclmulqdq \$0,%%xmm1,%%xmm2,%%xmm3" : : : );
2041   } while (0)
2042 ]])], [
2043 ac_have_as_vpclmulqdq=yes
2044 AC_MSG_RESULT([yes])
2045 ], [
2046 ac_have_as_vpclmulqdq=no
2047 AC_MSG_RESULT([no])
2048 ])
2049
2050 AM_CONDITIONAL(BUILD_VPCLMULQDQ_TESTS, test x$ac_have_as_vpclmulqdq = xyes)
2051
2052
2053 # does the x86/amd64 assembler understand the LZCNT instruction?
2054 # Note, this doesn't generate a C-level symbol.  It generates a
2055 # automake-level symbol (BUILD_LZCNT_TESTS), used in test Makefile.am's
2056 AC_MSG_CHECKING([if x86/amd64 assembler supports 'lzcnt'])
2057
2058 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
2059   do {
2060       __asm__ __volatile__("lzcnt %%rax,%%rax" : : : "rax");
2061   } while (0)
2062 ]])], [
2063   ac_have_as_lzcnt=yes
2064   AC_MSG_RESULT([yes])
2065 ], [
2066   ac_have_as_lzcnt=no
2067   AC_MSG_RESULT([no])
2068 ])
2069
2070 AM_CONDITIONAL([BUILD_LZCNT_TESTS], [test x$ac_have_as_lzcnt = xyes])
2071
2072
2073 # does the x86/amd64 assembler understand the LOOPNEL instruction?
2074 # Note, this doesn't generate a C-level symbol.  It generates a
2075 # automake-level symbol (BUILD_LOOPNEL_TESTS), used in test Makefile.am's
2076 AC_MSG_CHECKING([if x86/amd64 assembler supports 'loopnel'])
2077
2078 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
2079   do {
2080       __asm__ __volatile__("1:  loopnel 1b\n");
2081   } while (0)
2082 ]])], [
2083   ac_have_as_loopnel=yes
2084   AC_MSG_RESULT([yes])
2085 ], [
2086   ac_have_as_loopnel=no
2087   AC_MSG_RESULT([no])
2088 ])
2089
2090 AM_CONDITIONAL([BUILD_LOOPNEL_TESTS], [test x$ac_have_as_loopnel = xyes])
2091
2092
2093 # does the x86/amd64 assembler understand ADDR32 ?
2094 # Note, this doesn't generate a C-level symbol.  It generates a
2095 # automake-level symbol (BUILD_ADDR32_TESTS), used in test Makefile.am's
2096 AC_MSG_CHECKING([if x86/amd64 assembler supports 'addr32'])
2097
2098 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
2099   do {
2100       asm volatile ("addr32 rep movsb");
2101   } while (0)
2102 ]])], [
2103   ac_have_as_addr32=yes
2104   AC_MSG_RESULT([yes])
2105 ], [
2106   ac_have_as_addr32=no
2107   AC_MSG_RESULT([no])
2108 ])
2109
2110 AM_CONDITIONAL([BUILD_ADDR32_TESTS], [test x$ac_have_as_addr32 = xyes])
2111
2112
2113 # does the x86/amd64 assembler understand SSE 4.2 instructions?
2114 # Note, this doesn't generate a C-level symbol.  It generates a
2115 # automake-level symbol (BUILD_SSE42_TESTS), used in test Makefile.am's
2116 AC_MSG_CHECKING([if x86/amd64 assembler speaks SSE4.2])
2117
2118 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
2119   do { long long int x;
2120    __asm__ __volatile__(
2121       "crc32q %%r15,%%r15" : : : "r15" );
2122    __asm__ __volatile__(
2123       "pblendvb (%%rcx), %%xmm11" : : : "memory", "xmm11");
2124    __asm__ __volatile__(
2125       "aesdec %%xmm2, %%xmm1" : : : "xmm2", "xmm1"); }
2126   while (0)
2127 ]])], [
2128 ac_have_as_sse42=yes
2129 AC_MSG_RESULT([yes])
2130 ], [
2131 ac_have_as_sse42=no
2132 AC_MSG_RESULT([no])
2133 ])
2134
2135 AM_CONDITIONAL(BUILD_SSE42_TESTS, test x$ac_have_as_sse42 = xyes)
2136
2137
2138 # does the x86/amd64 assembler understand AVX instructions?
2139 # Note, this doesn't generate a C-level symbol.  It generates a
2140 # automake-level symbol (BUILD_AVX_TESTS), used in test Makefile.am's
2141 AC_MSG_CHECKING([if x86/amd64 assembler speaks AVX])
2142
2143 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
2144   do { long long int x;
2145    __asm__ __volatile__(
2146       "vmovupd (%%rsp), %%ymm7" : : : "xmm7" );
2147    __asm__ __volatile__(
2148       "vaddpd %%ymm6,%%ymm7,%%ymm8" : : : "xmm6","xmm7","xmm8"); }
2149   while (0)
2150 ]])], [
2151 ac_have_as_avx=yes
2152 AC_MSG_RESULT([yes])
2153 ], [
2154 ac_have_as_avx=no
2155 AC_MSG_RESULT([no])
2156 ])
2157
2158 AM_CONDITIONAL(BUILD_AVX_TESTS, test x$ac_have_as_avx = xyes)
2159
2160
2161 # does the x86/amd64 assembler understand AVX2 instructions?
2162 # Note, this doesn't generate a C-level symbol.  It generates a
2163 # automake-level symbol (BUILD_AVX2_TESTS), used in test Makefile.am's
2164 AC_MSG_CHECKING([if x86/amd64 assembler speaks AVX2])
2165
2166 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
2167   do { long long int x;
2168    __asm__ __volatile__(
2169       "vpsravd (%%rsp), %%ymm8, %%ymm7" : : : "xmm7", "xmm8" );
2170    __asm__ __volatile__(
2171       "vpaddb %%ymm6,%%ymm7,%%ymm8" : : : "xmm6","xmm7","xmm8"); }
2172   while (0)
2173 ]])], [
2174 ac_have_as_avx2=yes
2175 AC_MSG_RESULT([yes])
2176 ], [
2177 ac_have_as_avx2=no
2178 AC_MSG_RESULT([no])
2179 ])
2180
2181 AM_CONDITIONAL(BUILD_AVX2_TESTS, test x$ac_have_as_avx2 = xyes)
2182
2183
2184 # does the x86/amd64 assembler understand TSX instructions and
2185 # the XACQUIRE/XRELEASE prefixes?
2186 # Note, this doesn't generate a C-level symbol.  It generates a
2187 # automake-level symbol (BUILD_TSX_TESTS), used in test Makefile.am's
2188 AC_MSG_CHECKING([if x86/amd64 assembler speaks TSX])
2189
2190 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
2191   do {
2192    __asm__ __volatile__(
2193       "       xbegin Lfoo  \n\t"
2194       "Lfoo:  xend         \n\t"
2195       "       xacquire lock incq 0(%rsp)     \n\t"
2196       "       xrelease lock incq 0(%rsp)     \n"
2197    );
2198   } while (0)
2199 ]])], [
2200 ac_have_as_tsx=yes
2201 AC_MSG_RESULT([yes])
2202 ], [
2203 ac_have_as_tsx=no
2204 AC_MSG_RESULT([no])
2205 ])
2206
2207 AM_CONDITIONAL(BUILD_TSX_TESTS, test x$ac_have_as_tsx = xyes)
2208
2209
2210 # does the x86/amd64 assembler understand BMI1 and BMI2 instructions?
2211 # Note, this doesn't generate a C-level symbol.  It generates a
2212 # automake-level symbol (BUILD_BMI_TESTS), used in test Makefile.am's
2213 AC_MSG_CHECKING([if x86/amd64 assembler speaks BMI1 and BMI2])
2214
2215 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
2216   do { unsigned int h, l;
2217    __asm__ __volatile__( "mulx %rax,%rcx,%r8" );
2218    __asm__ __volatile__(
2219       "andn %2, %1, %0" : "=r" (h) : "r" (0x1234567), "r" (0x7654321) );
2220    __asm__ __volatile__(
2221       "movl %2, %%edx; mulx %3, %1, %0" : "=r" (h), "=r" (l) : "g" (0x1234567), "rm" (0x7654321) : "edx" ); }
2222   while (0)
2223 ]])], [
2224 ac_have_as_bmi=yes
2225 AC_MSG_RESULT([yes])
2226 ], [
2227 ac_have_as_bmi=no
2228 AC_MSG_RESULT([no])
2229 ])
2230
2231 AM_CONDITIONAL(BUILD_BMI_TESTS, test x$ac_have_as_bmi = xyes)
2232
2233
2234 # does the x86/amd64 assembler understand FMA instructions?
2235 # Note, this doesn't generate a C-level symbol.  It generates a
2236 # automake-level symbol (BUILD_FMA_TESTS), used in test Makefile.am's
2237 AC_MSG_CHECKING([if x86/amd64 assembler speaks FMA])
2238
2239 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
2240   do { unsigned int h, l;
2241    __asm__ __volatile__(
2242       "vfmadd132ps (%%rsp), %%ymm8, %%ymm7" : : : "xmm7", "xmm8" );
2243    __asm__ __volatile__(
2244       "vfnmsub231sd (%%rsp), %%xmm8, %%xmm7" : : : "xmm7", "xmm8" );
2245    __asm__ __volatile__(
2246       "vfmsubadd213pd (%%rsp), %%xmm8, %%xmm7" : : : "xmm7", "xmm8" ); }
2247   while (0)
2248 ]])], [
2249 ac_have_as_fma=yes
2250 AC_MSG_RESULT([yes])
2251 ], [
2252 ac_have_as_fma=no
2253 AC_MSG_RESULT([no])
2254 ])
2255
2256 AM_CONDITIONAL(BUILD_FMA_TESTS, test x$ac_have_as_fma = xyes)
2257
2258
2259 # does the amd64 assembler understand MPX instructions?
2260 # Note, this doesn't generate a C-level symbol.  It generates a
2261 # automake-level symbol (BUILD_MPX_TESTS), used in test Makefile.am's
2262 AC_MSG_CHECKING([if amd64 assembler knows the MPX instructions])
2263
2264 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
2265   asm ("bndmov %bnd0,(%rsp)")
2266 ]])], [
2267 ac_have_as_mpx=yes
2268 AC_MSG_RESULT([yes])
2269 ], [
2270 ac_have_as_mpx=no
2271 AC_MSG_RESULT([no])
2272 ])
2273
2274 AM_CONDITIONAL(BUILD_MPX_TESTS, test x$ac_have_as_mpx = xyes)
2275
2276
2277 # Does the C compiler support the "ifunc" attribute
2278 # Note, this doesn't generate a C-level symbol.  It generates a
2279 # automake-level symbol (BUILD_IFUNC_TESTS), used in test Makefile.am's
2280 # does the x86/amd64 assembler understand MOVBE?
2281 # Note, this doesn't generate a C-level symbol.  It generates a
2282 # automake-level symbol (BUILD_MOVBE_TESTS), used in test Makefile.am's
2283 AC_MSG_CHECKING([if x86/amd64 assembler knows the MOVBE insn])
2284
2285 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
2286   do { long long int x;
2287    __asm__ __volatile__(
2288       "movbe (%%rsp), %%r15" : : : "memory", "r15" ); }
2289   while (0)
2290 ]])], [
2291 ac_have_as_movbe=yes
2292 AC_MSG_RESULT([yes])
2293 ], [
2294 ac_have_as_movbe=no
2295 AC_MSG_RESULT([no])
2296 ])
2297
2298 AM_CONDITIONAL(BUILD_MOVBE_TESTS, test x$ac_have_as_movbe = xyes)
2299
2300
2301 # Does the C compiler support the "ifunc" attribute
2302 # Note, this doesn't generate a C-level symbol.  It generates a
2303 # automake-level symbol (BUILD_IFUNC_TESTS), used in test Makefile.am's
2304 AC_MSG_CHECKING([if gcc supports the ifunc attribute])
2305
2306 AC_LINK_IFELSE([AC_LANG_SOURCE([[
2307 static void mytest(void) {}
2308
2309 static void (*resolve_test(void))(void)
2310 {
2311     return (void (*)(void))&mytest;
2312 }
2313
2314 void test(void) __attribute__((ifunc("resolve_test")));
2315
2316 int main()
2317 {
2318     test();
2319     return 0;
2320 }
2321 ]])], [
2322 ac_have_ifunc_attr=yes
2323 AC_MSG_RESULT([yes])
2324 ], [
2325 ac_have_ifunc_attr=no
2326 AC_MSG_RESULT([no])
2327 ])
2328
2329 AM_CONDITIONAL(BUILD_IFUNC_TESTS, test x$ac_have_ifunc_attr = xyes)
2330
2331
2332 # XXX JRS 2010 Oct 13: what is this for?  For sure, we don't need this
2333 # when building the tool executables.  I think we should get rid of it.
2334 #
2335 # Check for TLS support in the compiler and linker
2336 AC_LINK_IFELSE([AC_LANG_PROGRAM([[static __thread int foo;]],
2337                                 [[return foo;]])],
2338                                [vg_cv_linktime_tls=yes],
2339                                [vg_cv_linktime_tls=no])
2340 # Native compilation: check whether running a program using TLS succeeds.
2341 # Linking only is not sufficient -- e.g. on Red Hat 7.3 linking TLS programs
2342 # succeeds but running programs using TLS fails.
2343 # Cross-compiling: check whether linking a program using TLS succeeds.
2344 AC_CACHE_CHECK([for TLS support], vg_cv_tls,
2345                [AC_ARG_ENABLE(tls, [  --enable-tls            platform supports TLS],
2346                 [vg_cv_tls=$enableval],
2347                 [AC_RUN_IFELSE([AC_LANG_PROGRAM([[static __thread int foo;]],
2348                                                 [[return foo;]])],
2349                                [vg_cv_tls=yes],
2350                                [vg_cv_tls=no],
2351                                [vg_cv_tls=$vg_cv_linktime_tls])])])
2352
2353 if test "$vg_cv_tls" = yes; then
2354 AC_DEFINE([HAVE_TLS], 1, [can use __thread to define thread-local variables])
2355 fi
2356
2357
2358 #----------------------------------------------------------------------------
2359 # Checks for C header files.
2360 #----------------------------------------------------------------------------
2361
2362 AC_HEADER_STDC
2363 AC_CHECK_HEADERS([       \
2364         asm/unistd.h     \
2365         endian.h         \
2366         mqueue.h         \
2367         sys/endian.h     \
2368         sys/epoll.h      \
2369         sys/eventfd.h    \
2370         sys/klog.h       \
2371         sys/poll.h       \
2372         sys/signal.h     \
2373         sys/signalfd.h   \
2374         sys/syscall.h    \
2375         sys/time.h       \
2376         sys/types.h      \
2377         ])
2378
2379 # Verify whether the <linux/futex.h> header is usable.
2380 AC_MSG_CHECKING([if <linux/futex.h> is usable])
2381
2382 save_CFLAGS="$CFLAGS"
2383 CFLAGS="$CFLAGS -D__user="
2384 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
2385 #include <linux/futex.h>
2386 ]], [[
2387   return FUTEX_WAIT;
2388 ]])], [
2389 ac_have_usable_linux_futex_h=yes
2390 AC_DEFINE([HAVE_USABLE_LINUX_FUTEX_H], 1,
2391           [Define to 1 if you have a usable <linux/futex.h> header file.])
2392 AC_MSG_RESULT([yes])
2393 ], [
2394 ac_have_usable_linux_futex_h=no
2395 AC_MSG_RESULT([no])
2396 ])
2397 CFLAGS="$save_CFLAGS"
2398
2399
2400 #----------------------------------------------------------------------------
2401 # Checks for typedefs, structures, and compiler characteristics.
2402 #----------------------------------------------------------------------------
2403 AC_TYPE_UID_T
2404 AC_TYPE_OFF_T
2405 AC_TYPE_SIZE_T
2406 AC_HEADER_TIME
2407
2408
2409 #----------------------------------------------------------------------------
2410 # Checks for library functions.
2411 #----------------------------------------------------------------------------
2412 AC_FUNC_MEMCMP
2413 AC_FUNC_MMAP
2414
2415 AC_CHECK_LIB([pthread], [pthread_create])
2416 AC_CHECK_LIB([rt], [clock_gettime])
2417
2418 AC_CHECK_FUNCS([     \
2419         clock_gettime\
2420         epoll_create \
2421         epoll_pwait  \
2422         klogctl      \
2423         mallinfo     \
2424         memchr       \
2425         memset       \
2426         mkdir        \
2427         mremap       \
2428         ppoll        \
2429         pthread_barrier_init       \
2430         pthread_condattr_setclock  \
2431         pthread_mutex_timedlock    \
2432         pthread_rwlock_timedrdlock \
2433         pthread_rwlock_timedwrlock \
2434         pthread_spin_lock          \
2435         pthread_yield              \
2436         pthread_setname_np         \
2437         readlinkat   \
2438         semtimedop   \
2439         signalfd     \
2440         sigwaitinfo  \
2441         strchr       \
2442         strdup       \
2443         strpbrk      \
2444         strrchr      \
2445         strstr       \
2446         syscall      \
2447         utimensat    \
2448         process_vm_readv  \
2449         process_vm_writev \
2450         ])
2451
2452 # AC_CHECK_LIB adds any library found to the variable LIBS, and links these
2453 # libraries with any shared object and/or executable. This is NOT what we
2454 # want for e.g. vgpreload_core-x86-linux.so
2455 LIBS=""
2456
2457 AM_CONDITIONAL([HAVE_PTHREAD_BARRIER],
2458                [test x$ac_cv_func_pthread_barrier_init = xyes])
2459 AM_CONDITIONAL([HAVE_PTHREAD_MUTEX_TIMEDLOCK],
2460                [test x$ac_cv_func_pthread_mutex_timedlock = xyes])
2461 AM_CONDITIONAL([HAVE_PTHREAD_SPINLOCK],
2462                [test x$ac_cv_func_pthread_spin_lock = xyes])
2463 AM_CONDITIONAL([HAVE_PTHREAD_SETNAME_NP],
2464                [test x$ac_cv_func_pthread_setname_np = xyes])
2465
2466 if test x$VGCONF_PLATFORM_PRI_CAPS = xMIPS32_LINUX \
2467      -o x$VGCONF_PLATFORM_PRI_CAPS = xMIPS64_LINUX ; then
2468   AC_DEFINE([DISABLE_PTHREAD_SPINLOCK_INTERCEPT], 1,
2469             [Disable intercept pthread_spin_lock() on MIPS32 and MIPS64.])
2470 fi
2471
2472 #----------------------------------------------------------------------------
2473 # MPI checks
2474 #----------------------------------------------------------------------------
2475 # Do we have a useable MPI setup on the primary and/or secondary targets?
2476 # On Linux, by default, assumes mpicc and -m32/-m64
2477 # Note: this is a kludge in that it assumes the specified mpicc
2478 # understands -m32/-m64 regardless of what is specified using
2479 # --with-mpicc=.
2480 AC_PATH_PROG([MPI_CC], [mpicc], [mpicc],
2481              [$PATH:/usr/lib/openmpi/bin:/usr/lib64/openmpi/bin])
2482
2483 mflag_primary=
2484 if test x$VGCONF_PLATFORM_PRI_CAPS = xX86_LINUX \
2485      -o x$VGCONF_PLATFORM_PRI_CAPS = xPPC32_LINUX \
2486      -o x$VGCONF_PLATFORM_PRI_CAPS = xARM_LINUX \
2487      -o x$VGCONF_PLATFORM_PRI_CAPS = xMIPS32_LINUX \
2488      -o x$VGCONF_PLATFORM_PRI_CAPS = xMIPS64_LINUX ; then
2489   mflag_primary=$FLAG_M32
2490 elif test x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_LINUX \
2491        -o x$VGCONF_PLATFORM_PRI_CAPS = xPPC64_LINUX \
2492        -o x$VGCONF_PLATFORM_PRI_CAPS = xARM64_LINUX \
2493        -o x$VGCONF_PLATFORM_PRI_CAPS = xS390X_LINUX ; then
2494   mflag_primary=$FLAG_M64
2495 elif test x$VGCONF_PLATFORM_PRI_CAPS = xX86_DARWIN ; then
2496   mflag_primary="$FLAG_M32 -arch i386"
2497 elif test x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_DARWIN ; then
2498   mflag_primary="$FLAG_M64 -arch x86_64"
2499 fi
2500
2501 mflag_secondary=
2502 if test x$VGCONF_PLATFORM_SEC_CAPS = xX86_LINUX \
2503      -o x$VGCONF_PLATFORM_SEC_CAPS = xPPC32_LINUX ; then
2504   mflag_secondary=$FLAG_M32
2505 elif test x$VGCONF_PLATFORM_SEC_CAPS = xX86_DARWIN ; then
2506   mflag_secondary="$FLAG_M32 -arch i386"
2507 fi
2508
2509
2510 AC_ARG_WITH(mpicc,
2511    [  --with-mpicc=           Specify name of MPI2-ised C compiler],
2512    MPI_CC=$withval
2513 )
2514 AC_SUBST(MPI_CC)
2515
2516 ## We AM_COND_IF here instead of automake "if" in mpi/Makefile.am so that we can
2517 ## use these values in the check for a functioning mpicc.
2518 ##
2519 ## We leave the MPI_FLAG_M3264_ logic in mpi/Makefile.am and assume that
2520 ## mflag_primary/mflag_secondary are sufficient approximations of that behavior
2521 AM_COND_IF([VGCONF_OS_IS_LINUX],
2522            [CFLAGS_MPI="-g -O -fno-omit-frame-pointer -Wall -fpic"
2523             LDFLAGS_MPI="-fpic -shared"])
2524 AM_COND_IF([VGCONF_OS_IS_DARWIN],
2525            [CFLAGS_MPI="-g -O -fno-omit-frame-pointer -Wall -dynamic"
2526             LDFLAGS_MPI="-dynamic -dynamiclib -all_load"])
2527
2528 AC_SUBST([CFLAGS_MPI])
2529 AC_SUBST([LDFLAGS_MPI])
2530
2531
2532 ## See if MPI_CC works for the primary target
2533 ##
2534 AC_MSG_CHECKING([primary target for usable MPI2-compliant C compiler and mpi.h])
2535 saved_CC=$CC
2536 saved_CFLAGS=$CFLAGS
2537 CC=$MPI_CC
2538 CFLAGS="$CFLAGS_MPI $mflag_primary"
2539 saved_LDFLAGS="$LDFLAGS"
2540 LDFLAGS="$LDFLAGS_MPI $mflag_primary"
2541 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
2542 #include <mpi.h>
2543 #include <stdio.h>
2544 ]], [[
2545   int ni, na, nd, comb;
2546   int r = MPI_Init(NULL,NULL);
2547   r |= MPI_Type_get_envelope( MPI_INT, &ni, &na, &nd, &comb );
2548   r |= MPI_Finalize();
2549   return r;
2550 ]])], [
2551 ac_have_mpi2_pri=yes
2552 AC_MSG_RESULT([yes, $MPI_CC])
2553 ], [
2554 ac_have_mpi2_pri=no
2555 AC_MSG_RESULT([no])
2556 ])
2557 CC=$saved_CC
2558 CFLAGS=$saved_CFLAGS
2559 LDFLAGS="$saved_LDFLAGS"
2560 AM_CONDITIONAL(BUILD_MPIWRAP_PRI, test x$ac_have_mpi2_pri = xyes)
2561
2562 ## See if MPI_CC works for the secondary target.  Complication: what if
2563 ## there is no secondary target?  We need this to then fail.
2564 ## Kludge this by making MPI_CC something which will surely fail in
2565 ## such a case.
2566 ##
2567 AC_MSG_CHECKING([secondary target for usable MPI2-compliant C compiler and mpi.h])
2568 saved_CC=$CC
2569 saved_CFLAGS=$CFLAGS
2570 saved_LDFLAGS="$LDFLAGS"
2571 LDFLAGS="$LDFLAGS_MPI $mflag_secondary"
2572 if test x$VGCONF_PLATFORM_SEC_CAPS = x ; then
2573   CC="$MPI_CC this will surely fail"
2574 else
2575   CC=$MPI_CC
2576 fi
2577 CFLAGS="$CFLAGS_MPI $mflag_secondary"
2578 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
2579 #include <mpi.h>
2580 #include <stdio.h>
2581 ]], [[
2582   int ni, na, nd, comb;
2583   int r = MPI_Init(NULL,NULL);
2584   r |= MPI_Type_get_envelope( MPI_INT, &ni, &na, &nd, &comb );
2585   r |= MPI_Finalize();
2586   return r;
2587 ]])], [
2588 ac_have_mpi2_sec=yes
2589 AC_MSG_RESULT([yes, $MPI_CC])
2590 ], [
2591 ac_have_mpi2_sec=no
2592 AC_MSG_RESULT([no])
2593 ])
2594 CC=$saved_CC
2595 CFLAGS=$saved_CFLAGS
2596 LDFLAGS="$saved_LDFLAGS"
2597 AM_CONDITIONAL(BUILD_MPIWRAP_SEC, test x$ac_have_mpi2_sec = xyes)
2598
2599
2600 #----------------------------------------------------------------------------
2601 # Other library checks
2602 #----------------------------------------------------------------------------
2603 # There now follow some tests for Boost, and OpenMP.  These
2604 # tests are present because Drd has some regression tests that use
2605 # these packages.  All regression test programs all compiled only
2606 # for the primary target.  And so it is important that the configure
2607 # checks that follow, use the correct -m32 or -m64 flag for the
2608 # primary target (called $mflag_primary).  Otherwise, we can end up
2609 # in a situation (eg) where, on amd64-linux, the test for Boost checks
2610 # for usable 64-bit Boost facilities, but because we are doing a 32-bit
2611 # only build (meaning, the primary target is x86-linux), the build
2612 # of the regtest programs that use Boost fails, because they are
2613 # build as 32-bit (IN THIS EXAMPLE).
2614 #
2615 # Hence: ALWAYS USE $mflag_primary FOR CONFIGURE TESTS FOR FACILITIES
2616 # NEEDED BY THE REGRESSION TEST PROGRAMS.
2617
2618
2619 # Check whether the boost library 1.35 or later has been installed.
2620 # The Boost.Threads library has undergone a major rewrite in version 1.35.0.
2621
2622 AC_MSG_CHECKING([for boost])
2623
2624 AC_LANG(C++)
2625 safe_CXXFLAGS=$CXXFLAGS
2626 CXXFLAGS="$mflag_primary"
2627 safe_LIBS="$LIBS"
2628 LIBS="-lboost_thread-mt -lboost_system-mt $LIBS"
2629
2630 AC_LINK_IFELSE([AC_LANG_SOURCE([
2631 #include <boost/thread.hpp>
2632 static void thread_func(void)
2633 { }
2634 int main(int argc, char** argv)
2635 {
2636   boost::thread t(thread_func);
2637   return 0;
2638 }
2639 ])],
2640 [
2641 ac_have_boost_1_35=yes
2642 AC_SUBST([BOOST_CFLAGS], [])
2643 AC_SUBST([BOOST_LIBS], ["-lboost_thread-mt -lboost_system-mt"])
2644 AC_MSG_RESULT([yes])
2645 ], [
2646 ac_have_boost_1_35=no
2647 AC_MSG_RESULT([no])
2648 ])
2649
2650 LIBS="$safe_LIBS"
2651 CXXFLAGS=$safe_CXXFLAGS
2652 AC_LANG(C)
2653
2654 AM_CONDITIONAL([HAVE_BOOST_1_35], [test x$ac_have_boost_1_35 = xyes])
2655
2656
2657 # does this compiler support -fopenmp, does it have the include file
2658 # <omp.h> and does it have libgomp ?
2659
2660 AC_MSG_CHECKING([for OpenMP])
2661
2662 safe_CFLAGS=$CFLAGS
2663 CFLAGS="-fopenmp $mflag_primary"
2664
2665 AC_LINK_IFELSE([AC_LANG_SOURCE([
2666 #include <omp.h>
2667 int main(int argc, char** argv)
2668 {
2669   omp_set_dynamic(0);
2670   return 0;
2671 }
2672 ])],
2673 [
2674 ac_have_openmp=yes
2675 AC_MSG_RESULT([yes])
2676 ], [
2677 ac_have_openmp=no
2678 AC_MSG_RESULT([no])
2679 ])
2680 CFLAGS=$safe_CFLAGS
2681
2682 AM_CONDITIONAL([HAVE_OPENMP], [test x$ac_have_openmp = xyes])
2683
2684
2685 # Check for __builtin_popcount
2686 AC_MSG_CHECKING([for __builtin_popcount()])
2687 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
2688 ]], [[
2689   __builtin_popcount(2);
2690   return 0;
2691 ]])], [
2692 AC_MSG_RESULT([yes])
2693 AC_DEFINE([HAVE_BUILTIN_POPCOUT], 1,
2694           [Define to 1 if compiler provides __builtin_popcount().])
2695 ], [
2696 AC_MSG_RESULT([no])
2697 ])
2698
2699 # Check for __builtin_clz
2700 AC_MSG_CHECKING([for __builtin_clz()])
2701 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
2702 ]], [[
2703   __builtin_clz(2);
2704   return 0;
2705 ]])], [
2706 AC_MSG_RESULT([yes])
2707 AC_DEFINE([HAVE_BUILTIN_CLZ], 1,
2708           [Define to 1 if compiler provides __builtin_clz().])
2709 ], [
2710 AC_MSG_RESULT([no])
2711 ])
2712
2713 # Check for __builtin_ctz
2714 AC_MSG_CHECKING([for __builtin_ctz()])
2715 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
2716 ]], [[
2717   __builtin_ctz(2);
2718   return 0;
2719 ]])], [
2720 AC_MSG_RESULT([yes])
2721 AC_DEFINE([HAVE_BUILTIN_CTZ], 1,
2722           [Define to 1 if compiler provides __builtin_ctz().])
2723 ], [
2724 AC_MSG_RESULT([no])
2725 ])
2726
2727 # does this compiler have built-in functions for atomic memory access for the
2728 # primary target ?
2729 AC_MSG_CHECKING([if gcc supports __sync_add_and_fetch for the primary target])
2730
2731 safe_CFLAGS=$CFLAGS
2732 CFLAGS="$mflag_primary"
2733
2734 AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[
2735   int variable = 1;
2736   return (__sync_bool_compare_and_swap(&variable, 1, 2)
2737           && __sync_add_and_fetch(&variable, 1) ? 1 : 0)
2738 ]])], [
2739   ac_have_builtin_atomic_primary=yes
2740   AC_MSG_RESULT([yes])
2741   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])
2742 ], [
2743   ac_have_builtin_atomic_primary=no
2744   AC_MSG_RESULT([no])
2745 ])
2746
2747 CFLAGS=$safe_CFLAGS
2748
2749 AM_CONDITIONAL([HAVE_BUILTIN_ATOMIC],
2750                [test x$ac_have_builtin_atomic_primary = xyes])
2751
2752
2753 # does this compiler have built-in functions for atomic memory access for the
2754 # secondary target ?
2755
2756 if test x$VGCONF_PLATFORM_SEC_CAPS != x; then
2757
2758 AC_MSG_CHECKING([if gcc supports __sync_add_and_fetch for the secondary target])
2759
2760 safe_CFLAGS=$CFLAGS
2761 CFLAGS="$mflag_secondary"
2762
2763 AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[
2764   int variable = 1;
2765   return (__sync_add_and_fetch(&variable, 1) ? 1 : 0)
2766 ]])], [
2767   ac_have_builtin_atomic_secondary=yes
2768   AC_MSG_RESULT([yes])
2769 ], [
2770   ac_have_builtin_atomic_secondary=no
2771   AC_MSG_RESULT([no])
2772 ])
2773
2774 CFLAGS=$safe_CFLAGS
2775
2776 fi
2777
2778 AM_CONDITIONAL([HAVE_BUILTIN_ATOMIC_SECONDARY],
2779                [test x$ac_have_builtin_atomic_secondary = xyes])
2780
2781 # does this compiler have built-in functions for atomic memory access on
2782 # 64-bit integers for all targets ?
2783
2784 AC_MSG_CHECKING([if gcc supports __sync_add_and_fetch on uint64_t for all targets])
2785
2786 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
2787   #include <stdint.h>
2788 ]], [[
2789   uint64_t variable = 1;
2790   return __sync_add_and_fetch(&variable, 1)
2791 ]])], [
2792   ac_have_builtin_atomic64_primary=yes
2793 ], [
2794   ac_have_builtin_atomic64_primary=no
2795 ])
2796
2797 if test x$VGCONF_PLATFORM_SEC_CAPS != x; then
2798
2799 safe_CFLAGS=$CFLAGS
2800 CFLAGS="$mflag_secondary"
2801
2802 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
2803   #include <stdint.h>
2804 ]], [[
2805   uint64_t variable = 1;
2806   return __sync_add_and_fetch(&variable, 1)
2807 ]])], [
2808   ac_have_builtin_atomic64_secondary=yes
2809 ], [
2810   ac_have_builtin_atomic64_secondary=no
2811 ])
2812
2813 CFLAGS=$safe_CFLAGS
2814
2815 fi
2816
2817 if test x$ac_have_builtin_atomic64_primary = xyes && \
2818    test x$VGCONF_PLATFORM_SEC_CAPS = x \
2819      -o x$ac_have_builtin_atomic64_secondary = xyes; then
2820   AC_MSG_RESULT([yes])
2821   ac_have_builtin_atomic64=yes
2822 else
2823   AC_MSG_RESULT([no])
2824   ac_have_builtin_atomic64=no
2825 fi
2826
2827 AM_CONDITIONAL([HAVE_BUILTIN_ATOMIC64],
2828                [test x$ac_have_builtin_atomic64 = xyes])
2829
2830
2831 # does g++ have built-in functions for atomic memory access ?
2832 AC_MSG_CHECKING([if g++ supports __sync_add_and_fetch])
2833
2834 safe_CXXFLAGS=$CXXFLAGS
2835 CXXFLAGS="$mflag_primary"
2836
2837 AC_LANG_PUSH(C++)
2838 AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[
2839   int variable = 1;
2840   return (__sync_bool_compare_and_swap(&variable, 1, 2)
2841           && __sync_add_and_fetch(&variable, 1) ? 1 : 0)
2842 ]])], [
2843   ac_have_builtin_atomic_cxx=yes
2844   AC_MSG_RESULT([yes])
2845   AC_DEFINE(HAVE_BUILTIN_ATOMIC_CXX, 1, [Define to 1 if g++ supports __sync_bool_compare_and_swap() and __sync_add_and_fetch()])
2846 ], [
2847   ac_have_builtin_atomic_cxx=no
2848   AC_MSG_RESULT([no])
2849 ])
2850 AC_LANG_POP(C++)
2851
2852 CXXFLAGS=$safe_CXXFLAGS
2853
2854 AM_CONDITIONAL([HAVE_BUILTIN_ATOMIC_CXX], [test x$ac_have_builtin_atomic_cxx = xyes])
2855
2856
2857 if test x$ac_have_usable_linux_futex_h = xyes \
2858         -a x$ac_have_builtin_atomic_primary = xyes; then
2859   ac_enable_linux_ticket_lock_primary=yes
2860 fi
2861 AM_CONDITIONAL([ENABLE_LINUX_TICKET_LOCK_PRIMARY],
2862                [test x$ac_enable_linux_ticket_lock_primary = xyes])
2863
2864 if test x$VGCONF_PLATFORM_SEC_CAPS != x \
2865         -a x$ac_have_usable_linux_futex_h = xyes \
2866         -a x$ac_have_builtin_atomic_secondary = xyes; then
2867   ac_enable_linux_ticket_lock_secondary=yes
2868 fi
2869 AM_CONDITIONAL([ENABLE_LINUX_TICKET_LOCK_SECONDARY],
2870                [test x$ac_enable_linux_ticket_lock_secondary = xyes])
2871
2872
2873 # does libstdc++ support annotating shared pointers ?
2874 AC_MSG_CHECKING([if libstdc++ supports annotating shared pointers])
2875
2876 safe_CXXFLAGS=$CXXFLAGS
2877 CXXFLAGS="-std=c++0x"
2878
2879 AC_LANG_PUSH(C++)
2880 AC_LINK_IFELSE([AC_LANG_PROGRAM([[
2881   #include <memory>
2882 ]], [[
2883   std::shared_ptr<int> p
2884 ]])], [
2885   ac_have_shared_ptr=yes
2886 ], [
2887   ac_have_shared_ptr=no
2888 ])
2889 if test x$ac_have_shared_ptr = xyes; then
2890   # If compilation of the program below fails because of a syntax error
2891   # triggered by substituting one of the annotation macros then that
2892   # means that libstdc++ supports these macros.
2893   AC_LINK_IFELSE([AC_LANG_PROGRAM([[
2894     #define _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(a) (a)----
2895     #define _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(a) (a)----
2896     #include <memory>
2897   ]], [[
2898     std::shared_ptr<int> p
2899   ]])], [
2900     ac_have_shared_pointer_annotation=no
2901     AC_MSG_RESULT([no])
2902   ], [
2903     ac_have_shared_pointer_annotation=yes
2904     AC_MSG_RESULT([yes])
2905     AC_DEFINE(HAVE_SHARED_POINTER_ANNOTATION, 1,
2906               [Define to 1 if libstd++ supports annotating shared pointers])
2907   ])
2908 else
2909   ac_have_shared_pointer_annotation=no
2910   AC_MSG_RESULT([no])
2911 fi
2912 AC_LANG_POP(C++)
2913
2914 CXXFLAGS=$safe_CXXFLAGS
2915
2916 AM_CONDITIONAL([HAVE_SHARED_POINTER_ANNOTATION],
2917                [test x$ac_have_shared_pointer_annotation = xyes])
2918
2919
2920 #----------------------------------------------------------------------------
2921 # Ok.  We're done checking.
2922 #----------------------------------------------------------------------------
2923
2924 # Nb: VEX/Makefile is generated from Makefile.vex.in.
2925 AC_CONFIG_FILES([
2926    Makefile
2927    VEX/Makefile:Makefile.vex.in
2928    valgrind.spec
2929    valgrind.pc
2930    glibc-2.X.supp
2931    docs/Makefile
2932    tests/Makefile
2933    tests/vg_regtest
2934    perf/Makefile
2935    perf/vg_perf
2936    gdbserver_tests/Makefile
2937    include/Makefile
2938    auxprogs/Makefile
2939    mpi/Makefile
2940    coregrind/Makefile
2941    memcheck/Makefile
2942    memcheck/tests/Makefile
2943    memcheck/tests/common/Makefile
2944    memcheck/tests/amd64/Makefile
2945    memcheck/tests/x86/Makefile
2946    memcheck/tests/linux/Makefile
2947    memcheck/tests/darwin/Makefile
2948    memcheck/tests/amd64-linux/Makefile
2949    memcheck/tests/x86-linux/Makefile
2950    memcheck/tests/ppc32/Makefile
2951    memcheck/tests/ppc64/Makefile
2952    memcheck/tests/s390x/Makefile
2953    memcheck/tests/vbit-test/Makefile
2954    cachegrind/Makefile
2955    cachegrind/tests/Makefile
2956    cachegrind/tests/x86/Makefile
2957    cachegrind/cg_annotate
2958    cachegrind/cg_diff
2959    callgrind/Makefile
2960    callgrind/callgrind_annotate
2961    callgrind/callgrind_control
2962    callgrind/tests/Makefile
2963    helgrind/Makefile
2964    helgrind/tests/Makefile
2965    massif/Makefile
2966    massif/tests/Makefile
2967    massif/ms_print
2968    lackey/Makefile
2969    lackey/tests/Makefile
2970    none/Makefile
2971    none/tests/Makefile
2972    none/tests/amd64/Makefile
2973    none/tests/ppc32/Makefile
2974    none/tests/ppc64/Makefile
2975    none/tests/x86/Makefile
2976    none/tests/arm/Makefile
2977    none/tests/arm64/Makefile
2978    none/tests/s390x/Makefile
2979    none/tests/mips32/Makefile
2980    none/tests/mips64/Makefile
2981    none/tests/linux/Makefile
2982    none/tests/darwin/Makefile
2983    none/tests/x86-linux/Makefile
2984    exp-sgcheck/Makefile
2985    exp-sgcheck/tests/Makefile
2986    drd/Makefile
2987    drd/scripts/download-and-build-splash2
2988    drd/tests/Makefile
2989    exp-bbv/Makefile
2990    exp-bbv/tests/Makefile
2991    exp-bbv/tests/x86/Makefile
2992    exp-bbv/tests/x86-linux/Makefile
2993    exp-bbv/tests/amd64-linux/Makefile
2994    exp-bbv/tests/ppc32-linux/Makefile
2995    exp-bbv/tests/arm-linux/Makefile
2996    exp-dhat/Makefile
2997    exp-dhat/tests/Makefile
2998    shared/Makefile
2999 ])
3000 AC_CONFIG_FILES([coregrind/link_tool_exe_linux],
3001                 [chmod +x coregrind/link_tool_exe_linux])
3002 AC_CONFIG_FILES([coregrind/link_tool_exe_darwin],
3003                 [chmod +x coregrind/link_tool_exe_darwin])
3004 AC_OUTPUT
3005
3006 cat<<EOF
3007
3008          Maximum build arch: ${ARCH_MAX}
3009          Primary build arch: ${VGCONF_ARCH_PRI}
3010        Secondary build arch: ${VGCONF_ARCH_SEC}
3011                    Build OS: ${VGCONF_OS}
3012        Primary build target: ${VGCONF_PLATFORM_PRI_CAPS}
3013      Secondary build target: ${VGCONF_PLATFORM_SEC_CAPS}
3014            Platform variant: ${VGCONF_PLATVARIANT}
3015       Primary -DVGPV string: -DVGPV_${VGCONF_ARCH_PRI}_${VGCONF_OS}_${VGCONF_PLATVARIANT}=1
3016          Default supp files: ${DEFAULT_SUPP}
3017
3018 EOF