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