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.12.0.SVN],[valgrind-users (a] 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 # Do NOT modify these flags here. Except in feature tests in which case 20 # the original values must be properly restored. 21 #---------------------------------------------------------------------------- 22 CFLAGS="$CFLAGS" 23 CXXFLAGS="$CXXFLAGS" 24 25 #---------------------------------------------------------------------------- 26 # Checks for various programs. 27 #---------------------------------------------------------------------------- 28 29 AC_PROG_LN_S 30 AC_PROG_CC 31 AM_PROG_CC_C_O 32 AC_PROG_CPP 33 AC_PROG_CXX 34 # AC_PROG_OBJC apparently causes problems on older Linux distros (eg. with 35 # autoconf 2.59). If we ever have any Objective-C code in the Valgrind code 36 # base (eg. most likely as Darwin-specific tests) we'll need one of the 37 # following: 38 # - put AC_PROG_OBJC in a Darwin-specific part of this file 39 # - Use AC_PROG_OBJC here and up the minimum autoconf version 40 # - Use the following, which is apparently equivalent: 41 # m4_ifdef([AC_PROG_OBJC], 42 # [AC_PROG_OBJC], 43 # [AC_CHECK_TOOL([OBJC], [gcc]) 44 # AC_SUBST([OBJC]) 45 # AC_SUBST([OBJCFLAGS]) 46 # ]) 47 AC_PROG_RANLIB 48 # provide a very basic definition for AC_PROG_SED if it's not provided by 49 # autoconf (as e.g. in autoconf 2.59). 50 m4_ifndef([AC_PROG_SED], 51 [AC_DEFUN([AC_PROG_SED], 52 [AC_ARG_VAR([SED]) 53 AC_CHECK_PROGS([SED],[gsed sed])])]) 54 AC_PROG_SED 55 56 # If no AR variable was specified, look up the name of the archiver. Otherwise 57 # do not touch the AR variable. 58 if test "x$AR" = "x"; then 59 AC_PATH_PROGS([AR], [`echo $LD | $SED 's/ld$/ar/'` "ar"], [ar]) 60 fi 61 AC_ARG_VAR([AR],[Archiver command]) 62 63 # Check for the compiler support 64 if test "${GCC}" != "yes" ; then 65 AC_MSG_ERROR([Valgrind relies on GCC to be compiled]) 66 fi 67 68 # figure out where perl lives 69 AC_PATH_PROG(PERL, perl) 70 71 # figure out where gdb lives 72 AC_PATH_PROG(GDB, gdb, "/no/gdb/was/found/at/configure/time") 73 AC_DEFINE_UNQUOTED(GDB_PATH, "$GDB", [path to GDB]) 74 75 # some older automake's don't have it so try something on our own 76 ifdef([AM_PROG_AS],[AM_PROG_AS], 77 [ 78 AS="${CC}" 79 AC_SUBST(AS) 80 81 ASFLAGS="" 82 AC_SUBST(ASFLAGS) 83 ]) 84 85 86 # Check if 'diff' supports -u (universal diffs) and use it if possible. 87 88 AC_MSG_CHECKING([for diff -u]) 89 AC_SUBST(DIFF) 90 91 # Comparing two identical files results in 0. 92 tmpfile="tmp-xxx-yyy-zzz" 93 touch $tmpfile; 94 if diff -u $tmpfile $tmpfile ; then 95 AC_MSG_RESULT([yes]) 96 DIFF="diff -u" 97 else 98 AC_MSG_RESULT([no]) 99 DIFF="diff" 100 fi 101 rm $tmpfile 102 103 104 # We don't want gcc < 3.0 105 AC_MSG_CHECKING([for a supported version of gcc]) 106 107 # Obtain the compiler version. 108 # 109 # A few examples of how the ${CC} --version output looks like: 110 # 111 # ######## gcc variants ######## 112 # Arch Linux: i686-pc-linux-gnu-gcc (GCC) 4.6.2 113 # Debian Linux: gcc (Debian 4.3.2-1.1) 4.3.2 114 # openSUSE: gcc (SUSE Linux) 4.5.1 20101208 [gcc-4_5-branch revision 167585] 115 # Exherbo Linux: x86_64-pc-linux-gnu-gcc (Exherbo gcc-4.6.2) 4.6.2 116 # MontaVista Linux for ARM: arm-none-linux-gnueabi-gcc (Sourcery G++ Lite 2009q1-203) 4.3.3 117 # OS/X 10.6: i686-apple-darwin10-gcc-4.2.1 (GCC) 4.2.1 (Apple Inc. build 5666) (dot 3) 118 # 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) 119 # 120 # ######## clang variants ######## 121 # Clang: clang version 2.9 (tags/RELEASE_29/final) 122 # Apple clang: Apple clang version 3.1 (tags/Apple/clang-318.0.58) (based on LLVM 3.1svn) 123 # FreeBSD clang: FreeBSD clang version 3.1 (branches/release_31 156863) 20120523 124 # 125 # ######## Apple LLVM variants ######## 126 # Apple LLVM version 5.1 (clang-503.0.40) (based on LLVM 3.4svn) 127 # Apple LLVM version 6.0 (clang-600.0.51) (based on LLVM 3.5svn) 128 # 129 [ 130 if test "x`${CC} --version | $SED -n -e 's/.*\Apple \(LLVM\) version.*clang.*/\1/p'`" = "xLLVM" ; 131 then 132 is_clang="applellvm" 133 gcc_version=`${CC} --version | $SED -n -e 's/.*LLVM version \([0-9.]*\).*$/\1/p'` 134 elif test "x`${CC} --version | $SED -n -e 's/.*\(clang\) version.*/\1/p'`" = "xclang" ; 135 then 136 is_clang="clang" 137 # Don't use -dumpversion with clang: it will always produce "4.2.1". 138 gcc_version=`${CC} --version | $SED -n -e 's/.*clang version \([0-9.]*\).*$/\1/p'` 139 elif test "x`${CC} --version | $SED -n -e 's/icc.*\(ICC\).*/\1/p'`" = "xICC" ; 140 then 141 is_clang="icc" 142 gcc_version=`${CC} -dumpversion 2>/dev/null` 143 else 144 is_clang="notclang" 145 gcc_version=`${CC} -dumpversion 2>/dev/null` 146 if test "x$gcc_version" = x; then 147 gcc_version=`${CC} --version | $SED -n -e 's/[^ ]*gcc[^ ]* ([^)]*) \([0-9.]*\).*$/\1/p'` 148 fi 149 fi 150 ] 151 AM_CONDITIONAL(COMPILER_IS_CLANG, test $is_clang = clang -o $is_clang = applellvm) 152 AM_CONDITIONAL(COMPILER_IS_ICC, test $is_clang = icc) 153 154 # Note: m4 arguments are quoted with [ and ] so square brackets in shell 155 # statements have to be quoted. 156 case "${is_clang}-${gcc_version}" in 157 applellvm-5.1|applellvm-6.*|applellvm-7.*) 158 AC_MSG_RESULT([ok (Apple LLVM version ${gcc_version})]) 159 ;; 160 icc-1[[3-9]].*) 161 AC_MSG_RESULT([ok (ICC version ${gcc_version})]) 162 ;; 163 notclang-[[3-9]].*|notclang-[[1-9][0-9]]*) 164 AC_MSG_RESULT([ok (${gcc_version})]) 165 ;; 166 clang-2.9|clang-[[3-9]].*|clang-[[1-9][0-9]]*) 167 AC_MSG_RESULT([ok (clang-${gcc_version})]) 168 ;; 169 *) 170 AC_MSG_RESULT([no (${gcc_version})]) 171 AC_MSG_ERROR([please use gcc >= 3.0 or clang >= 2.9 or icc >= 13.0]) 172 ;; 173 esac 174 175 #---------------------------------------------------------------------------- 176 # Arch/OS/platform tests. 177 #---------------------------------------------------------------------------- 178 # We create a number of arch/OS/platform-related variables. We prefix them 179 # all with "VGCONF_" which indicates that they are defined at 180 # configure-time, and distinguishes them from the VGA_*/VGO_*/VGP_* 181 # variables used when compiling C files. 182 183 AC_CANONICAL_HOST 184 185 AC_MSG_CHECKING([for a supported CPU]) 186 187 # ARCH_MAX reflects the most that this CPU can do: for example if it 188 # is a 64-bit capable PowerPC, then it must be set to ppc64 and not ppc32. 189 # Ditto for amd64. It is used for more configuration below, but is not used 190 # outside this file. 191 # 192 # Power PC returns powerpc for Big Endian. This was not changed when Little 193 # Endian support was added to the 64-bit architecture. The 64-bit Little 194 # Endian systems explicitly state le in the host_cpu. For clarity in the 195 # Valgrind code, the ARCH_MAX name will state LE or BE for the endianess of 196 # the 64-bit system. Big Endian is the only mode supported on 32-bit Power PC. 197 # The abreviation PPC or ppc refers to 32-bit and 64-bit systems with either 198 # Endianess. The name PPC64 or ppc64 to 64-bit systems of either Endianess. 199 # The names ppc64be or PPC64BE refer to only 64-bit systems that are Big 200 # Endian. Similarly, ppc64le or PPC64LE refer to only 64-bit systems that are 201 # Little Endian. 202 203 case "${host_cpu}" in 204 i?86) 205 AC_MSG_RESULT([ok (${host_cpu})]) 206 ARCH_MAX="x86" 207 ;; 208 209 x86_64) 210 AC_MSG_RESULT([ok (${host_cpu})]) 211 ARCH_MAX="amd64" 212 ;; 213 214 powerpc64) 215 # this only referrs to 64-bit Big Endian 216 AC_MSG_RESULT([ok (${host_cpu})]) 217 ARCH_MAX="ppc64be" 218 ;; 219 220 powerpc64le) 221 # this only referrs to 64-bit Little Endian 222 AC_MSG_RESULT([ok (${host_cpu})]) 223 ARCH_MAX="ppc64le" 224 ;; 225 226 powerpc) 227 # On Linux this means only a 32-bit capable CPU. 228 AC_MSG_RESULT([ok (${host_cpu})]) 229 ARCH_MAX="ppc32" 230 ;; 231 232 s390x) 233 AC_MSG_RESULT([ok (${host_cpu})]) 234 ARCH_MAX="s390x" 235 ;; 236 237 armv7*) 238 AC_MSG_RESULT([ok (${host_cpu})]) 239 ARCH_MAX="arm" 240 ;; 241 242 aarch64*) 243 AC_MSG_RESULT([ok (${host_cpu})]) 244 ARCH_MAX="arm64" 245 ;; 246 247 mips) 248 AC_MSG_RESULT([ok (${host_cpu})]) 249 ARCH_MAX="mips32" 250 ;; 251 252 mipsel) 253 AC_MSG_RESULT([ok (${host_cpu})]) 254 ARCH_MAX="mips32" 255 ;; 256 257 mipsisa32r2) 258 AC_MSG_RESULT([ok (${host_cpu})]) 259 ARCH_MAX="mips32" 260 ;; 261 262 mips64*) 263 AC_MSG_RESULT([ok (${host_cpu})]) 264 ARCH_MAX="mips64" 265 ;; 266 267 mipsisa64*) 268 AC_MSG_RESULT([ok (${host_cpu})]) 269 ARCH_MAX="mips64" 270 ;; 271 272 tilegx) 273 AC_MSG_RESULT([ok (${host_cpu})]) 274 ARCH_MAX="tilegx" 275 ;; 276 277 *) 278 AC_MSG_RESULT([no (${host_cpu})]) 279 AC_MSG_ERROR([Unsupported host architecture. Sorry]) 280 ;; 281 esac 282 283 #---------------------------------------------------------------------------- 284 285 # Sometimes it's convenient to subvert the bi-arch build system and 286 # just have a single build even though the underlying platform is 287 # capable of both. Hence handle --enable-only64bit and 288 # --enable-only32bit. Complain if both are issued :-) 289 # [Actually, if either of these options are used, I think both get built, 290 # but only one gets installed. So if you use an in-place build, both can be 291 # used. --njn] 292 293 # Check if a 64-bit only build has been requested 294 AC_CACHE_CHECK([for a 64-bit only build], vg_cv_only64bit, 295 [AC_ARG_ENABLE(only64bit, 296 [ --enable-only64bit do a 64-bit only build], 297 [vg_cv_only64bit=$enableval], 298 [vg_cv_only64bit=no])]) 299 300 # Check if a 32-bit only build has been requested 301 AC_CACHE_CHECK([for a 32-bit only build], vg_cv_only32bit, 302 [AC_ARG_ENABLE(only32bit, 303 [ --enable-only32bit do a 32-bit only build], 304 [vg_cv_only32bit=$enableval], 305 [vg_cv_only32bit=no])]) 306 307 # Stay sane 308 if test x$vg_cv_only64bit = xyes -a x$vg_cv_only32bit = xyes; then 309 AC_MSG_ERROR( 310 [Nonsensical: both --enable-only64bit and --enable-only32bit.]) 311 fi 312 313 #---------------------------------------------------------------------------- 314 315 # VGCONF_OS is the primary build OS, eg. "linux". It is passed in to 316 # compilation of many C files via -VGO_$(VGCONF_OS) and 317 # -VGP_$(VGCONF_ARCH_PRI)_$(VGCONF_OS). 318 AC_MSG_CHECKING([for a supported OS]) 319 AC_SUBST(VGCONF_OS) 320 321 DEFAULT_SUPP="" 322 323 case "${host_os}" in 324 *linux*) 325 AC_MSG_RESULT([ok (${host_os})]) 326 VGCONF_OS="linux" 327 328 # Ok, this is linux. Check the kernel version 329 AC_MSG_CHECKING([for the kernel version]) 330 331 kernel=`uname -r` 332 333 case "${kernel}" in 334 0.*|1.*|2.0.*|2.1.*|2.2.*|2.3.*|2.4.*|2.5.*) 335 AC_MSG_RESULT([unsupported (${kernel})]) 336 AC_MSG_ERROR([Valgrind needs a Linux kernel >= 2.6]) 337 ;; 338 339 *) 340 AC_MSG_RESULT([2.6 or later (${kernel})]) 341 ;; 342 esac 343 344 ;; 345 346 *darwin*) 347 AC_MSG_RESULT([ok (${host_os})]) 348 VGCONF_OS="darwin" 349 AC_DEFINE([DARWIN_10_5], 100500, [DARWIN_VERS value for Mac OS X 10.5]) 350 AC_DEFINE([DARWIN_10_6], 100600, [DARWIN_VERS value for Mac OS X 10.6]) 351 AC_DEFINE([DARWIN_10_7], 100700, [DARWIN_VERS value for Mac OS X 10.7]) 352 AC_DEFINE([DARWIN_10_8], 100800, [DARWIN_VERS value for Mac OS X 10.8]) 353 AC_DEFINE([DARWIN_10_9], 100900, [DARWIN_VERS value for Mac OS X 10.9]) 354 AC_DEFINE([DARWIN_10_10], 101000, [DARWIN_VERS value for Mac OS X 10.10]) 355 AC_DEFINE([DARWIN_10_11], 101100, [DARWIN_VERS value for Mac OS X 10.11]) 356 357 AC_MSG_CHECKING([for the kernel version]) 358 kernel=`uname -r` 359 360 # Nb: for Darwin we set DEFAULT_SUPP here. That's because Darwin 361 # has only one relevant version, the OS version. The `uname` check 362 # is a good way to get that version (i.e. "Darwin 9.6.0" is Mac OS 363 # X 10.5.6, and "Darwin 10.x" is Mac OS X 10.6.x Snow Leopard, 364 # and possibly "Darwin 11.x" is Mac OS X 10.7.x Lion), 365 # and we don't know of an macros similar to __GLIBC__ to get that info. 366 # 367 # XXX: `uname -r` won't do the right thing for cross-compiles, but 368 # that's not a problem yet. 369 # 370 # jseward 21 Sept 2011: I seriously doubt whether V 3.7.0 will work 371 # on OS X 10.5.x; I haven't tested yet, and only plan to test 3.7.0 372 # on 10.6.8 and 10.7.1. Although tempted to delete the configure 373 # time support for 10.5 (the 9.* pattern just below), I'll leave it 374 # in for now, just in case anybody wants to give it a try. But I'm 375 # assuming that 3.7.0 is a Snow Leopard and Lion-only release. 376 case "${kernel}" in 377 9.*) 378 AC_MSG_RESULT([Darwin 9.x (${kernel}) / Mac OS X 10.5 Leopard]) 379 AC_DEFINE([DARWIN_VERS], DARWIN_10_5, [Darwin / Mac OS X version]) 380 DEFAULT_SUPP="darwin9.supp ${DEFAULT_SUPP}" 381 DEFAULT_SUPP="darwin9-drd.supp ${DEFAULT_SUPP}" 382 ;; 383 10.*) 384 AC_MSG_RESULT([Darwin 10.x (${kernel}) / Mac OS X 10.6 Snow Leopard]) 385 AC_DEFINE([DARWIN_VERS], DARWIN_10_6, [Darwin / Mac OS X version]) 386 DEFAULT_SUPP="darwin10.supp ${DEFAULT_SUPP}" 387 DEFAULT_SUPP="darwin10-drd.supp ${DEFAULT_SUPP}" 388 ;; 389 11.*) 390 AC_MSG_RESULT([Darwin 11.x (${kernel}) / Mac OS X 10.7 Lion]) 391 AC_DEFINE([DARWIN_VERS], DARWIN_10_7, [Darwin / Mac OS X version]) 392 DEFAULT_SUPP="darwin11.supp ${DEFAULT_SUPP}" 393 DEFAULT_SUPP="darwin10-drd.supp ${DEFAULT_SUPP}" 394 ;; 395 12.*) 396 AC_MSG_RESULT([Darwin 12.x (${kernel}) / Mac OS X 10.8 Mountain Lion]) 397 AC_DEFINE([DARWIN_VERS], DARWIN_10_8, [Darwin / Mac OS X version]) 398 DEFAULT_SUPP="darwin12.supp ${DEFAULT_SUPP}" 399 DEFAULT_SUPP="darwin10-drd.supp ${DEFAULT_SUPP}" 400 ;; 401 13.*) 402 AC_MSG_RESULT([Darwin 13.x (${kernel}) / Mac OS X 10.9 Mavericks]) 403 AC_DEFINE([DARWIN_VERS], DARWIN_10_9, [Darwin / Mac OS X version]) 404 DEFAULT_SUPP="darwin13.supp ${DEFAULT_SUPP}" 405 DEFAULT_SUPP="darwin10-drd.supp ${DEFAULT_SUPP}" 406 ;; 407 14.*) 408 AC_MSG_RESULT([Darwin 14.x (${kernel}) / Mac OS X 10.10 Yosemite]) 409 AC_DEFINE([DARWIN_VERS], DARWIN_10_10, [Darwin / Mac OS X version]) 410 DEFAULT_SUPP="darwin14.supp ${DEFAULT_SUPP}" 411 DEFAULT_SUPP="darwin10-drd.supp ${DEFAULT_SUPP}" 412 ;; 413 15.*) 414 AC_MSG_RESULT([Darwin 15.x (${kernel}) / Mac OS X 10.11 El Capitan]) 415 AC_DEFINE([DARWIN_VERS], DARWIN_10_11, [Darwin / Mac OS X version]) 416 DEFAULT_SUPP="darwin15.supp ${DEFAULT_SUPP}" 417 DEFAULT_SUPP="darwin10-drd.supp ${DEFAULT_SUPP}" 418 ;; 419 *) 420 AC_MSG_RESULT([unsupported (${kernel})]) 421 AC_MSG_ERROR([Valgrind works on Darwin 10.x, 11.x, 12.x, 13.x, 14.x and 15.x (Mac OS X 10.6/7/8/9/10/11)]) 422 ;; 423 esac 424 ;; 425 426 solaris2.11*) 427 AC_MSG_RESULT([ok (${host_os})]) 428 VGCONF_OS="solaris" 429 DEFAULT_SUPP="solaris11.supp ${DEFAULT_SUPP}" 430 ;; 431 432 solaris2.12*) 433 AC_MSG_RESULT([ok (${host_os})]) 434 VGCONF_OS="solaris" 435 DEFAULT_SUPP="solaris12.supp ${DEFAULT_SUPP}" 436 ;; 437 438 *) 439 AC_MSG_RESULT([no (${host_os})]) 440 AC_MSG_ERROR([Valgrind is operating system specific. Sorry.]) 441 ;; 442 esac 443 444 #---------------------------------------------------------------------------- 445 446 # If we are building on a 64 bit platform test to see if the system 447 # supports building 32 bit programs and disable 32 bit support if it 448 # does not support building 32 bit programs 449 450 case "$ARCH_MAX-$VGCONF_OS" in 451 amd64-linux|ppc64be-linux|arm64-linux|amd64-solaris) 452 AC_MSG_CHECKING([for 32 bit build support]) 453 safe_CFLAGS=$CFLAGS 454 CFLAGS="-m32" 455 AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[ 456 return 0; 457 ]])], [ 458 AC_MSG_RESULT([yes]) 459 ], [ 460 vg_cv_only64bit="yes" 461 AC_MSG_RESULT([no]) 462 ]) 463 CFLAGS=$safe_CFLAGS;; 464 esac 465 466 if test x$vg_cv_only64bit = xyes -a x$vg_cv_only32bit = xyes; then 467 AC_MSG_ERROR( 468 [--enable-only32bit was specified but system does not support 32 bit builds]) 469 fi 470 471 #---------------------------------------------------------------------------- 472 473 # VGCONF_ARCH_PRI is the arch for the primary build target, eg. "amd64". By 474 # default it's the same as ARCH_MAX. But if, say, we do a build on an amd64 475 # machine, but --enable-only32bit has been requested, then ARCH_MAX (see 476 # above) will be "amd64" since that reflects the most that this cpu can do, 477 # but VGCONF_ARCH_PRI will be downgraded to "x86", since that reflects the 478 # arch corresponding to the primary build (VGCONF_PLATFORM_PRI_CAPS). It is 479 # passed in to compilation of many C files via -VGA_$(VGCONF_ARCH_PRI) and 480 # -VGP_$(VGCONF_ARCH_PRI)_$(VGCONF_OS). 481 AC_SUBST(VGCONF_ARCH_PRI) 482 483 # VGCONF_ARCH_SEC is the arch for the secondary build target, eg. "x86". 484 # It is passed in to compilation of many C files via -VGA_$(VGCONF_ARCH_SEC) 485 # and -VGP_$(VGCONF_ARCH_SEC)_$(VGCONF_OS), if there is a secondary target. 486 # It is empty if there is no secondary target. 487 AC_SUBST(VGCONF_ARCH_SEC) 488 489 # VGCONF_PLATFORM_PRI_CAPS is the primary build target, eg. "AMD64_LINUX". 490 # The entire system, including regression and performance tests, will be 491 # built for this target. The "_CAPS" indicates that the name is in capital 492 # letters, and it also uses '_' rather than '-' as a separator, because it's 493 # used to create various Makefile variables, which are all in caps by 494 # convention and cannot contain '-' characters. This is in contrast to 495 # VGCONF_ARCH_PRI and VGCONF_OS which are not in caps. 496 AC_SUBST(VGCONF_PLATFORM_PRI_CAPS) 497 498 # VGCONF_PLATFORM_SEC_CAPS is the secondary build target, if there is one. 499 # Valgrind and tools will also be built for this target, but not the 500 # regression or performance tests. 501 # 502 # By default, the primary arch is the same as the "max" arch, as commented 503 # above (at the definition of ARCH_MAX). We may choose to downgrade it in 504 # the big case statement just below here, in the case where we're building 505 # on a 64 bit machine but have been requested only to do a 32 bit build. 506 AC_SUBST(VGCONF_PLATFORM_SEC_CAPS) 507 508 AC_MSG_CHECKING([for a supported CPU/OS combination]) 509 510 # NB. The load address for a given platform may be specified in more 511 # than one place, in some cases, depending on whether we're doing a biarch, 512 # 32-bit only or 64-bit only build. eg see case for amd64-linux below. 513 # Be careful to give consistent values in all subcases. Also, all four 514 # valt_load_addres_{pri,sec}_{norml,inner} values must always be set, 515 # even if it is to "0xUNSET". 516 # 517 case "$ARCH_MAX-$VGCONF_OS" in 518 x86-linux) 519 VGCONF_ARCH_PRI="x86" 520 VGCONF_ARCH_SEC="" 521 VGCONF_PLATFORM_PRI_CAPS="X86_LINUX" 522 VGCONF_PLATFORM_SEC_CAPS="" 523 valt_load_address_pri_norml="0x38000000" 524 valt_load_address_pri_inner="0x28000000" 525 valt_load_address_sec_norml="0xUNSET" 526 valt_load_address_sec_inner="0xUNSET" 527 AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})]) 528 ;; 529 amd64-linux) 530 valt_load_address_sec_norml="0xUNSET" 531 valt_load_address_sec_inner="0xUNSET" 532 if test x$vg_cv_only64bit = xyes; then 533 VGCONF_ARCH_PRI="amd64" 534 VGCONF_ARCH_SEC="" 535 VGCONF_PLATFORM_PRI_CAPS="AMD64_LINUX" 536 VGCONF_PLATFORM_SEC_CAPS="" 537 valt_load_address_pri_norml="0x38000000" 538 valt_load_address_pri_inner="0x28000000" 539 elif test x$vg_cv_only32bit = xyes; then 540 VGCONF_ARCH_PRI="x86" 541 VGCONF_ARCH_SEC="" 542 VGCONF_PLATFORM_PRI_CAPS="X86_LINUX" 543 VGCONF_PLATFORM_SEC_CAPS="" 544 valt_load_address_pri_norml="0x38000000" 545 valt_load_address_pri_inner="0x28000000" 546 else 547 VGCONF_ARCH_PRI="amd64" 548 VGCONF_ARCH_SEC="x86" 549 VGCONF_PLATFORM_PRI_CAPS="AMD64_LINUX" 550 VGCONF_PLATFORM_SEC_CAPS="X86_LINUX" 551 valt_load_address_pri_norml="0x38000000" 552 valt_load_address_pri_inner="0x28000000" 553 valt_load_address_sec_norml="0x38000000" 554 valt_load_address_sec_inner="0x28000000" 555 fi 556 AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})]) 557 ;; 558 ppc32-linux) 559 VGCONF_ARCH_PRI="ppc32" 560 VGCONF_ARCH_SEC="" 561 VGCONF_PLATFORM_PRI_CAPS="PPC32_LINUX" 562 VGCONF_PLATFORM_SEC_CAPS="" 563 valt_load_address_pri_norml="0x38000000" 564 valt_load_address_pri_inner="0x28000000" 565 valt_load_address_sec_norml="0xUNSET" 566 valt_load_address_sec_inner="0xUNSET" 567 AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})]) 568 ;; 569 ppc64be-linux) 570 valt_load_address_sec_norml="0xUNSET" 571 valt_load_address_sec_inner="0xUNSET" 572 if test x$vg_cv_only64bit = xyes; then 573 VGCONF_ARCH_PRI="ppc64be" 574 VGCONF_ARCH_SEC="" 575 VGCONF_PLATFORM_PRI_CAPS="PPC64BE_LINUX" 576 VGCONF_PLATFORM_SEC_CAPS="" 577 valt_load_address_pri_norml="0x38000000" 578 valt_load_address_pri_inner="0x28000000" 579 elif test x$vg_cv_only32bit = xyes; then 580 VGCONF_ARCH_PRI="ppc32" 581 VGCONF_ARCH_SEC="" 582 VGCONF_PLATFORM_PRI_CAPS="PPC32_LINUX" 583 VGCONF_PLATFORM_SEC_CAPS="" 584 valt_load_address_pri_norml="0x38000000" 585 valt_load_address_pri_inner="0x28000000" 586 else 587 VGCONF_ARCH_PRI="ppc64be" 588 VGCONF_ARCH_SEC="ppc32" 589 VGCONF_PLATFORM_PRI_CAPS="PPC64BE_LINUX" 590 VGCONF_PLATFORM_SEC_CAPS="PPC32_LINUX" 591 valt_load_address_pri_norml="0x38000000" 592 valt_load_address_pri_inner="0x28000000" 593 valt_load_address_sec_norml="0x38000000" 594 valt_load_address_sec_inner="0x28000000" 595 fi 596 AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})]) 597 ;; 598 ppc64le-linux) 599 # Little Endian is only supported on PPC64 600 valt_load_address_sec_norml="0xUNSET" 601 valt_load_address_sec_inner="0xUNSET" 602 VGCONF_ARCH_PRI="ppc64le" 603 VGCONF_ARCH_SEC="" 604 VGCONF_PLATFORM_PRI_CAPS="PPC64LE_LINUX" 605 VGCONF_PLATFORM_SEC_CAPS="" 606 valt_load_address_pri_norml="0x38000000" 607 valt_load_address_pri_inner="0x28000000" 608 AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})]) 609 ;; 610 # Darwin gets identified as 32-bit even when it supports 64-bit. 611 # (Not sure why, possibly because 'uname' returns "i386"?) Just about 612 # all Macs support both 32-bit and 64-bit, so we just build both. If 613 # someone has a really old 32-bit only machine they can (hopefully?) 614 # build with --enable-only32bit. See bug 243362. 615 x86-darwin|amd64-darwin) 616 ARCH_MAX="amd64" 617 valt_load_address_sec_norml="0xUNSET" 618 valt_load_address_sec_inner="0xUNSET" 619 if test x$vg_cv_only64bit = xyes; then 620 VGCONF_ARCH_PRI="amd64" 621 VGCONF_ARCH_SEC="" 622 VGCONF_PLATFORM_PRI_CAPS="AMD64_DARWIN" 623 VGCONF_PLATFORM_SEC_CAPS="" 624 valt_load_address_pri_norml="0x138000000" 625 valt_load_address_pri_inner="0x128000000" 626 elif test x$vg_cv_only32bit = xyes; then 627 VGCONF_ARCH_PRI="x86" 628 VGCONF_ARCH_SEC="" 629 VGCONF_PLATFORM_PRI_CAPS="X86_DARWIN" 630 VGCONF_PLATFORM_SEC_CAPS="" 631 VGCONF_ARCH_PRI_CAPS="x86" 632 valt_load_address_pri_norml="0x38000000" 633 valt_load_address_pri_inner="0x28000000" 634 else 635 VGCONF_ARCH_PRI="amd64" 636 VGCONF_ARCH_SEC="x86" 637 VGCONF_PLATFORM_PRI_CAPS="AMD64_DARWIN" 638 VGCONF_PLATFORM_SEC_CAPS="X86_DARWIN" 639 valt_load_address_pri_norml="0x138000000" 640 valt_load_address_pri_inner="0x128000000" 641 valt_load_address_sec_norml="0x38000000" 642 valt_load_address_sec_inner="0x28000000" 643 fi 644 AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})]) 645 ;; 646 arm-linux) 647 VGCONF_ARCH_PRI="arm" 648 VGCONF_PLATFORM_PRI_CAPS="ARM_LINUX" 649 VGCONF_PLATFORM_SEC_CAPS="" 650 valt_load_address_pri_norml="0x38000000" 651 valt_load_address_pri_inner="0x28000000" 652 valt_load_address_sec_norml="0xUNSET" 653 valt_load_address_sec_inner="0xUNSET" 654 AC_MSG_RESULT([ok (${host_cpu}-${host_os})]) 655 ;; 656 arm64-linux) 657 valt_load_address_sec_norml="0xUNSET" 658 valt_load_address_sec_inner="0xUNSET" 659 if test x$vg_cv_only64bit = xyes; then 660 VGCONF_ARCH_PRI="arm64" 661 VGCONF_ARCH_SEC="" 662 VGCONF_PLATFORM_PRI_CAPS="ARM64_LINUX" 663 VGCONF_PLATFORM_SEC_CAPS="" 664 valt_load_address_pri_norml="0x38000000" 665 valt_load_address_pri_inner="0x28000000" 666 elif test x$vg_cv_only32bit = xyes; then 667 VGCONF_ARCH_PRI="arm" 668 VGCONF_ARCH_SEC="" 669 VGCONF_PLATFORM_PRI_CAPS="ARM_LINUX" 670 VGCONF_PLATFORM_SEC_CAPS="" 671 valt_load_address_pri_norml="0x38000000" 672 valt_load_address_pri_inner="0x28000000" 673 else 674 VGCONF_ARCH_PRI="arm64" 675 VGCONF_ARCH_SEC="arm" 676 VGCONF_PLATFORM_PRI_CAPS="ARM64_LINUX" 677 VGCONF_PLATFORM_SEC_CAPS="ARM_LINUX" 678 valt_load_address_pri_norml="0x38000000" 679 valt_load_address_pri_inner="0x28000000" 680 valt_load_address_sec_norml="0x38000000" 681 valt_load_address_sec_inner="0x28000000" 682 fi 683 AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})]) 684 ;; 685 s390x-linux) 686 VGCONF_ARCH_PRI="s390x" 687 VGCONF_ARCH_SEC="" 688 VGCONF_PLATFORM_PRI_CAPS="S390X_LINUX" 689 VGCONF_PLATFORM_SEC_CAPS="" 690 # To improve branch prediction hit rate we want to have 691 # the generated code close to valgrind (host) code 692 valt_load_address_pri_norml="0x800000000" 693 valt_load_address_pri_inner="0x810000000" 694 valt_load_address_sec_norml="0xUNSET" 695 valt_load_address_sec_inner="0xUNSET" 696 AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})]) 697 ;; 698 mips32-linux) 699 VGCONF_ARCH_PRI="mips32" 700 VGCONF_PLATFORM_PRI_CAPS="MIPS32_LINUX" 701 VGCONF_PLATFORM_SEC_CAPS="" 702 valt_load_address_pri_norml="0x38000000" 703 valt_load_address_pri_inner="0x28000000" 704 valt_load_address_sec_norml="0xUNSET" 705 valt_load_address_sec_inner="0xUNSET" 706 AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})]) 707 ;; 708 mips64-linux) 709 VGCONF_ARCH_PRI="mips64" 710 VGCONF_PLATFORM_PRI_CAPS="MIPS64_LINUX" 711 VGCONF_PLATFORM_SEC_CAPS="" 712 valt_load_address_pri_norml="0x38000000" 713 valt_load_address_pri_inner="0x28000000" 714 valt_load_address_sec_norml="0xUNSET" 715 valt_load_address_sec_inner="0xUNSET" 716 AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})]) 717 ;; 718 tilegx-linux) 719 VGCONF_ARCH_PRI="tilegx" 720 VGCONF_ARCH_SEC="" 721 VGCONF_PLATFORM_PRI_CAPS="TILEGX_LINUX" 722 VGCONF_PLATFORM_SEC_CAPS="" 723 valt_load_address_pri_norml="0x38000000" 724 valt_load_address_pri_inner="0x28000000" 725 valt_load_address_sec_norml="0xUNSET" 726 valt_load_address_sec_inner="0xUNSET" 727 AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})]) 728 ;; 729 x86-solaris) 730 VGCONF_ARCH_PRI="x86" 731 VGCONF_ARCH_SEC="" 732 VGCONF_PLATFORM_PRI_CAPS="X86_SOLARIS" 733 VGCONF_PLATFORM_SEC_CAPS="" 734 valt_load_address_pri_norml="0x38000000" 735 valt_load_address_pri_inner="0x28000000" 736 valt_load_address_sec_norml="0xUNSET" 737 valt_load_address_sec_inner="0xUNSET" 738 AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})]) 739 ;; 740 amd64-solaris) 741 valt_load_address_sec_norml="0xUNSET" 742 valt_load_address_sec_inner="0xUNSET" 743 if test x$vg_cv_only64bit = xyes; then 744 VGCONF_ARCH_PRI="amd64" 745 VGCONF_ARCH_SEC="" 746 VGCONF_PLATFORM_PRI_CAPS="AMD64_SOLARIS" 747 VGCONF_PLATFORM_SEC_CAPS="" 748 valt_load_address_pri_norml="0x38000000" 749 valt_load_address_pri_inner="0x28000000" 750 elif test x$vg_cv_only32bit = xyes; then 751 VGCONF_ARCH_PRI="x86" 752 VGCONF_ARCH_SEC="" 753 VGCONF_PLATFORM_PRI_CAPS="X86_SOLARIS" 754 VGCONF_PLATFORM_SEC_CAPS="" 755 valt_load_address_pri_norml="0x38000000" 756 valt_load_address_pri_inner="0x28000000" 757 else 758 VGCONF_ARCH_PRI="amd64" 759 VGCONF_ARCH_SEC="x86" 760 VGCONF_PLATFORM_PRI_CAPS="AMD64_SOLARIS" 761 VGCONF_PLATFORM_SEC_CAPS="X86_SOLARIS" 762 valt_load_address_pri_norml="0x38000000" 763 valt_load_address_pri_inner="0x28000000" 764 valt_load_address_sec_norml="0x38000000" 765 valt_load_address_sec_inner="0x28000000" 766 fi 767 AC_MSG_RESULT([ok (${ARCH_MAX}-${VGCONF_OS})]) 768 ;; 769 *) 770 VGCONF_ARCH_PRI="unknown" 771 VGCONF_ARCH_SEC="unknown" 772 VGCONF_PLATFORM_PRI_CAPS="UNKNOWN" 773 VGCONF_PLATFORM_SEC_CAPS="UNKNOWN" 774 valt_load_address_pri_norml="0xUNSET" 775 valt_load_address_pri_inner="0xUNSET" 776 valt_load_address_sec_norml="0xUNSET" 777 valt_load_address_sec_inner="0xUNSET" 778 AC_MSG_RESULT([no (${ARCH_MAX}-${VGCONF_OS})]) 779 AC_MSG_ERROR([Valgrind is platform specific. Sorry. Please consider doing a port.]) 780 ;; 781 esac 782 783 #---------------------------------------------------------------------------- 784 785 # Set up VGCONF_ARCHS_INCLUDE_<arch>. Either one or two of these become 786 # defined. 787 AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_X86, 788 test x$VGCONF_PLATFORM_PRI_CAPS = xX86_LINUX \ 789 -o x$VGCONF_PLATFORM_SEC_CAPS = xX86_LINUX \ 790 -o x$VGCONF_PLATFORM_PRI_CAPS = xX86_DARWIN \ 791 -o x$VGCONF_PLATFORM_SEC_CAPS = xX86_DARWIN \ 792 -o x$VGCONF_PLATFORM_PRI_CAPS = xX86_SOLARIS \ 793 -o x$VGCONF_PLATFORM_SEC_CAPS = xX86_SOLARIS ) 794 AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_AMD64, 795 test x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_LINUX \ 796 -o x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_DARWIN \ 797 -o x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_SOLARIS ) 798 AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_PPC32, 799 test x$VGCONF_PLATFORM_PRI_CAPS = xPPC32_LINUX \ 800 -o x$VGCONF_PLATFORM_SEC_CAPS = xPPC32_LINUX ) 801 AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_PPC64, 802 test x$VGCONF_PLATFORM_PRI_CAPS = xPPC64BE_LINUX \ 803 -o x$VGCONF_PLATFORM_PRI_CAPS = xPPC64LE_LINUX ) 804 AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_ARM, 805 test x$VGCONF_PLATFORM_PRI_CAPS = xARM_LINUX \ 806 -o x$VGCONF_PLATFORM_SEC_CAPS = xARM_LINUX ) 807 AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_ARM64, 808 test x$VGCONF_PLATFORM_PRI_CAPS = xARM64_LINUX ) 809 AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_S390X, 810 test x$VGCONF_PLATFORM_PRI_CAPS = xS390X_LINUX ) 811 AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_MIPS32, 812 test x$VGCONF_PLATFORM_PRI_CAPS = xMIPS32_LINUX ) 813 AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_MIPS64, 814 test x$VGCONF_PLATFORM_PRI_CAPS = xMIPS64_LINUX ) 815 AM_CONDITIONAL(VGCONF_ARCHS_INCLUDE_TILEGX, 816 test x$VGCONF_PLATFORM_PRI_CAPS = xTILEGX_LINUX ) 817 818 # Set up VGCONF_PLATFORMS_INCLUDE_<platform>. Either one or two of these 819 # become defined. 820 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_X86_LINUX, 821 test x$VGCONF_PLATFORM_PRI_CAPS = xX86_LINUX \ 822 -o x$VGCONF_PLATFORM_SEC_CAPS = xX86_LINUX) 823 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_AMD64_LINUX, 824 test x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_LINUX) 825 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_PPC32_LINUX, 826 test x$VGCONF_PLATFORM_PRI_CAPS = xPPC32_LINUX \ 827 -o x$VGCONF_PLATFORM_SEC_CAPS = xPPC32_LINUX) 828 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_PPC64BE_LINUX, 829 test x$VGCONF_PLATFORM_PRI_CAPS = xPPC64BE_LINUX) 830 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_PPC64LE_LINUX, 831 test x$VGCONF_PLATFORM_PRI_CAPS = xPPC64LE_LINUX) 832 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_ARM_LINUX, 833 test x$VGCONF_PLATFORM_PRI_CAPS = xARM_LINUX \ 834 -o x$VGCONF_PLATFORM_SEC_CAPS = xARM_LINUX) 835 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_ARM64_LINUX, 836 test x$VGCONF_PLATFORM_PRI_CAPS = xARM64_LINUX) 837 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_S390X_LINUX, 838 test x$VGCONF_PLATFORM_PRI_CAPS = xS390X_LINUX \ 839 -o x$VGCONF_PLATFORM_SEC_CAPS = xS390X_LINUX) 840 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_MIPS32_LINUX, 841 test x$VGCONF_PLATFORM_PRI_CAPS = xMIPS32_LINUX) 842 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_MIPS64_LINUX, 843 test x$VGCONF_PLATFORM_PRI_CAPS = xMIPS64_LINUX) 844 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_TILEGX_LINUX, 845 test x$VGCONF_PLATFORM_PRI_CAPS = xTILEGX_LINUX) 846 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_X86_DARWIN, 847 test x$VGCONF_PLATFORM_PRI_CAPS = xX86_DARWIN \ 848 -o x$VGCONF_PLATFORM_SEC_CAPS = xX86_DARWIN) 849 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_AMD64_DARWIN, 850 test x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_DARWIN) 851 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_X86_SOLARIS, 852 test x$VGCONF_PLATFORM_PRI_CAPS = xX86_SOLARIS \ 853 -o x$VGCONF_PLATFORM_SEC_CAPS = xX86_SOLARIS) 854 AM_CONDITIONAL(VGCONF_PLATFORMS_INCLUDE_AMD64_SOLARIS, 855 test x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_SOLARIS) 856 857 858 # Similarly, set up VGCONF_OS_IS_<os>. Exactly one of these becomes defined. 859 # Relies on the assumption that the primary and secondary targets are 860 # for the same OS, so therefore only necessary to test the primary. 861 AM_CONDITIONAL(VGCONF_OS_IS_LINUX, 862 test x$VGCONF_PLATFORM_PRI_CAPS = xX86_LINUX \ 863 -o x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_LINUX \ 864 -o x$VGCONF_PLATFORM_PRI_CAPS = xPPC32_LINUX \ 865 -o x$VGCONF_PLATFORM_PRI_CAPS = xPPC64BE_LINUX \ 866 -o x$VGCONF_PLATFORM_PRI_CAPS = xPPC64LE_LINUX \ 867 -o x$VGCONF_PLATFORM_PRI_CAPS = xARM_LINUX \ 868 -o x$VGCONF_PLATFORM_PRI_CAPS = xARM64_LINUX \ 869 -o x$VGCONF_PLATFORM_PRI_CAPS = xS390X_LINUX \ 870 -o x$VGCONF_PLATFORM_PRI_CAPS = xMIPS32_LINUX \ 871 -o x$VGCONF_PLATFORM_PRI_CAPS = xMIPS64_LINUX \ 872 -o x$VGCONF_PLATFORM_PRI_CAPS = xTILEGX_LINUX) 873 AM_CONDITIONAL(VGCONF_OS_IS_DARWIN, 874 test x$VGCONF_PLATFORM_PRI_CAPS = xX86_DARWIN \ 875 -o x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_DARWIN) 876 AM_CONDITIONAL(VGCONF_OS_IS_SOLARIS, 877 test x$VGCONF_PLATFORM_PRI_CAPS = xX86_SOLARIS \ 878 -o x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_SOLARIS) 879 880 881 # Sometimes, in the Makefile.am files, it's useful to know whether or not 882 # there is a secondary target. 883 AM_CONDITIONAL(VGCONF_HAVE_PLATFORM_SEC, 884 test x$VGCONF_PLATFORM_SEC_CAPS != x) 885 886 dnl automake-1.10 does not have AM_COND_IF (added in 1.11), so we supply a 887 dnl fallback definition 888 dnl The macro is courtesy of Dave Hart: 889 dnl https://lists.gnu.org/archive/html/automake/2010-12/msg00045.html 890 m4_ifndef([AM_COND_IF], [AC_DEFUN([AM_COND_IF], [ 891 if test -z "$$1_TRUE"; then : 892 m4_n([$2])[]dnl 893 m4_ifval([$3], 894 [else 895 $3 896 ])dnl 897 fi[]dnl 898 ])]) 899 900 #---------------------------------------------------------------------------- 901 # Inner Valgrind? 902 #---------------------------------------------------------------------------- 903 904 # Check if this should be built as an inner Valgrind, to be run within 905 # another Valgrind. Choose the load address accordingly. 906 AC_SUBST(VALT_LOAD_ADDRESS_PRI) 907 AC_SUBST(VALT_LOAD_ADDRESS_SEC) 908 AC_CACHE_CHECK([for use as an inner Valgrind], vg_cv_inner, 909 [AC_ARG_ENABLE(inner, 910 [ --enable-inner enables self-hosting], 911 [vg_cv_inner=$enableval], 912 [vg_cv_inner=no])]) 913 if test "$vg_cv_inner" = yes; then 914 AC_DEFINE([ENABLE_INNER], 1, [configured to run as an inner Valgrind]) 915 VALT_LOAD_ADDRESS_PRI=$valt_load_address_pri_inner 916 VALT_LOAD_ADDRESS_SEC=$valt_load_address_sec_inner 917 else 918 VALT_LOAD_ADDRESS_PRI=$valt_load_address_pri_norml 919 VALT_LOAD_ADDRESS_SEC=$valt_load_address_sec_norml 920 fi 921 922 #---------------------------------------------------------------------------- 923 # Undefined behaviour sanitiser 924 #---------------------------------------------------------------------------- 925 # Check whether we should build with the undefined beahviour sanitiser. 926 927 AC_CACHE_CHECK([for using the undefined behaviour sanitiser], vg_cv_ubsan, 928 [AC_ARG_ENABLE(ubsan, 929 [ --enable-ubsan enables the undefined behaviour sanitiser], 930 [vg_cv_ubsan=$enableval], 931 [vg_cv_ubsan=no])]) 932 933 #---------------------------------------------------------------------------- 934 # Define MIPS_PAGE_SHIFT (--with-pagesize) 935 #---------------------------------------------------------------------------- 936 AC_ARG_WITH(pagesize, 937 [ --with-pagesize= override detected page size (4, 16 or 64)], 938 [psize=$withval], 939 [psize=0] 940 ) 941 942 if test "$psize" = "0"; then 943 psizer=`getconf PAGESIZE` 944 psize=$((${psizer}/1024)) 945 fi 946 947 if test "$psize" = "4"; then 948 AC_DEFINE([MIPS_PAGE_SHIFT], 12, [configured page size 4k]) 949 elif test "$psize" = "16"; then 950 AC_DEFINE([MIPS_PAGE_SHIFT], 14, [configured page size 16k]) 951 elif test "$psize" = "64"; then 952 AC_DEFINE([MIPS_PAGE_SHIFT], 16, [configured page size 64k]) 953 else 954 AC_DEFINE([MIPS_PAGE_SHIFT], 12, [configured default page size 4k]) 955 fi 956 AC_MSG_RESULT([checking for Pagesize... ${psize}k]) 957 958 959 #---------------------------------------------------------------------------- 960 # Extra fine-tuning of installation directories 961 #---------------------------------------------------------------------------- 962 AC_ARG_WITH(tmpdir, 963 [ --with-tmpdir=PATH Specify path for temporary files], 964 tmpdir="$withval", 965 tmpdir="/tmp") 966 AC_DEFINE_UNQUOTED(VG_TMPDIR, "$tmpdir", [Temporary files directory]) 967 AC_SUBST(VG_TMPDIR, [$tmpdir]) 968 969 970 #---------------------------------------------------------------------------- 971 # Libc and suppressions 972 #---------------------------------------------------------------------------- 973 # This variable will collect the suppression files to be used. 974 AC_SUBST(DEFAULT_SUPP) 975 976 AC_CHECK_HEADER([features.h]) 977 978 if test x$ac_cv_header_features_h = xyes; then 979 rm -f conftest.$ac_ext 980 cat <<_ACEOF >conftest.$ac_ext 981 #include <features.h> 982 #if defined(__GNU_LIBRARY__) && defined(__GLIBC__) && defined(__GLIBC_MINOR__) 983 glibc version is: __GLIBC__ __GLIBC_MINOR__ 984 #endif 985 _ACEOF 986 GLIBC_VERSION="`$CPP -P conftest.$ac_ext | $SED -n 's/^glibc version is: //p' | $SED 's/ /./g'`" 987 fi 988 989 # not really a version check 990 AC_EGREP_CPP([DARWIN_LIBC], [ 991 #include <sys/cdefs.h> 992 #if defined(__DARWIN_VERS_1050) 993 DARWIN_LIBC 994 #endif 995 ], 996 GLIBC_VERSION="darwin") 997 998 # not really a version check 999 AC_EGREP_CPP([BIONIC_LIBC], [ 1000 #if defined(__ANDROID__) 1001 BIONIC_LIBC 1002 #endif 1003 ], 1004 GLIBC_VERSION="bionic") 1005 1006 # there is only one version of libc on Solaris 1007 if test x$VGCONF_PLATFORM_PRI_CAPS = xX86_SOLARIS \ 1008 -o x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_SOLARIS; then 1009 GLIBC_VERSION="solaris" 1010 fi 1011 1012 1013 AC_MSG_CHECKING([the glibc version]) 1014 1015 case "${GLIBC_VERSION}" in 1016 2.2) 1017 AC_MSG_RESULT(${GLIBC_VERSION} family) 1018 DEFAULT_SUPP="glibc-2.2.supp ${DEFAULT_SUPP}" 1019 DEFAULT_SUPP="glibc-2.2-LinuxThreads-helgrind.supp ${DEFAULT_SUPP}" 1020 DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}" 1021 ;; 1022 2.[[3-6]]) 1023 AC_MSG_RESULT(${GLIBC_VERSION} family) 1024 DEFAULT_SUPP="glibc-${GLIBC_VERSION}.supp ${DEFAULT_SUPP}" 1025 DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}" 1026 DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}" 1027 ;; 1028 2.[[7-9]]) 1029 AC_MSG_RESULT(${GLIBC_VERSION} family) 1030 DEFAULT_SUPP="glibc-2.X.supp ${DEFAULT_SUPP}" 1031 DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}" 1032 DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}" 1033 ;; 1034 2.10|2.11) 1035 AC_MSG_RESULT(${GLIBC_VERSION} family) 1036 AC_DEFINE([GLIBC_MANDATORY_STRLEN_REDIRECT], 1, 1037 [Define to 1 if strlen() has been optimized heavily (amd64 glibc >= 2.10)]) 1038 DEFAULT_SUPP="glibc-2.X.supp ${DEFAULT_SUPP}" 1039 DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}" 1040 DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}" 1041 ;; 1042 2.*) 1043 AC_MSG_RESULT(${GLIBC_VERSION} family) 1044 AC_DEFINE([GLIBC_MANDATORY_STRLEN_REDIRECT], 1, 1045 [Define to 1 if strlen() has been optimized heavily (amd64 glibc >= 2.10)]) 1046 AC_DEFINE([GLIBC_MANDATORY_INDEX_AND_STRLEN_REDIRECT], 1, 1047 [Define to 1 if index() and strlen() have been optimized heavily (x86 glibc >= 2.12)]) 1048 DEFAULT_SUPP="glibc-2.X.supp ${DEFAULT_SUPP}" 1049 DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}" 1050 DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}" 1051 ;; 1052 darwin) 1053 AC_MSG_RESULT(Darwin) 1054 AC_DEFINE([DARWIN_LIBC], 1, [Define to 1 if you're using Darwin]) 1055 # DEFAULT_SUPP set by kernel version check above. 1056 ;; 1057 bionic) 1058 AC_MSG_RESULT(Bionic) 1059 AC_DEFINE([BIONIC_LIBC], 1, [Define to 1 if you're using Bionic]) 1060 DEFAULT_SUPP="bionic.supp ${DEFAULT_SUPP}" 1061 ;; 1062 solaris) 1063 AC_MSG_RESULT(Solaris) 1064 # DEFAULT_SUPP set in host_os switch-case above. 1065 # No other suppression file is used. 1066 ;; 1067 2.0|2.1|*) 1068 AC_MSG_RESULT([unsupported version ${GLIBC_VERSION}]) 1069 AC_MSG_ERROR([Valgrind requires glibc version 2.2 or later,]) 1070 AC_MSG_ERROR([Darwin libc, Bionic libc or Solaris libc]) 1071 ;; 1072 esac 1073 1074 AC_SUBST(GLIBC_VERSION) 1075 1076 1077 if test "$VGCONF_OS" != "solaris"; then 1078 # Add default suppressions for the X client libraries. Make no 1079 # attempt to detect whether such libraries are installed on the 1080 # build machine (or even if any X facilities are present); just 1081 # add the suppressions antidisirregardless. 1082 DEFAULT_SUPP="xfree-4.supp ${DEFAULT_SUPP}" 1083 DEFAULT_SUPP="xfree-3.supp ${DEFAULT_SUPP}" 1084 1085 # Add glibc and X11 suppressions for exp-sgcheck 1086 DEFAULT_SUPP="exp-sgcheck.supp ${DEFAULT_SUPP}" 1087 fi 1088 1089 1090 #---------------------------------------------------------------------------- 1091 # Platform variants? 1092 #---------------------------------------------------------------------------- 1093 1094 # Normally the PLAT = (ARCH, OS) characterisation of the platform is enough. 1095 # But there are times where we need a bit more control. The motivating 1096 # and currently only case is Android: this is almost identical to 1097 # {x86,arm,mips}-linux, but not quite. So this introduces the concept of 1098 # platform variant tags, which get passed in the compile as 1099 # -DVGPV_<arch>_<os>_<variant> along with the main -DVGP_<arch>_<os> definition. 1100 # 1101 # In almost all cases, the <variant> bit is "vanilla". But for Android 1102 # it is "android" instead. 1103 # 1104 # Consequently (eg), plain arm-linux would build with 1105 # 1106 # -DVGP_arm_linux -DVGPV_arm_linux_vanilla 1107 # 1108 # whilst an Android build would have 1109 # 1110 # -DVGP_arm_linux -DVGPV_arm_linux_android 1111 # 1112 # Same for x86. The setup of the platform variant is pushed relatively far 1113 # down this file in order that we can inspect any of the variables set above. 1114 1115 # In the normal case .. 1116 VGCONF_PLATVARIANT="vanilla" 1117 1118 # Android ? 1119 if test "$GLIBC_VERSION" = "bionic"; 1120 then 1121 VGCONF_PLATVARIANT="android" 1122 fi 1123 1124 AC_SUBST(VGCONF_PLATVARIANT) 1125 1126 1127 # FIXME: do we also want to define automake variables 1128 # VGCONF_PLATVARIANT_IS_<WHATEVER>, where WHATEVER is (currently) 1129 # VANILLA or ANDROID ? This would be in the style of VGCONF_ARCHS_INCLUDE, 1130 # VGCONF_PLATFORMS_INCLUDE and VGCONF_OS_IS above? Could easily enough 1131 # do that. Problem is that we can't do and-ing in Makefile.am's, but 1132 # that's what we'd need to do to use this, since what we'd want to write 1133 # is something like 1134 # 1135 # VGCONF_PLATFORMS_INCLUDE_ARM_LINUX && VGCONF_PLATVARIANT_IS_ANDROID 1136 # 1137 # Hmm. Can't think of a nice clean solution to this. 1138 1139 AM_CONDITIONAL(VGCONF_PLATVARIANT_IS_VANILLA, 1140 test x$VGCONF_PLATVARIANT = xvanilla) 1141 AM_CONDITIONAL(VGCONF_PLATVARIANT_IS_ANDROID, 1142 test x$VGCONF_PLATVARIANT = xandroid) 1143 1144 1145 #---------------------------------------------------------------------------- 1146 # Checking for various library functions and other definitions 1147 #---------------------------------------------------------------------------- 1148 1149 # Check for AT_FDCWD 1150 1151 AC_MSG_CHECKING([for AT_FDCWD]) 1152 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 1153 #define _GNU_SOURCE 1154 #include <fcntl.h> 1155 #include <unistd.h> 1156 ]], [[ 1157 int a = AT_FDCWD; 1158 ]])], [ 1159 ac_have_at_fdcwd=yes 1160 AC_MSG_RESULT([yes]) 1161 ], [ 1162 ac_have_at_fdcwd=no 1163 AC_MSG_RESULT([no]) 1164 ]) 1165 1166 AM_CONDITIONAL([HAVE_AT_FDCWD], [test x$ac_have_at_fdcwd = xyes]) 1167 1168 # Check for stpncpy function definition in string.h 1169 # This explicitly checks with _GNU_SOURCE defined since that is also 1170 # used in the test case (some systems might define it without anyway 1171 # since stpncpy is part of The Open Group Base Specifications Issue 7 1172 # IEEE Std 1003.1-2008. 1173 AC_MSG_CHECKING([for stpncpy]) 1174 AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 1175 #define _GNU_SOURCE 1176 #include <string.h> 1177 ]], [[ 1178 char *d; 1179 char *s; 1180 size_t n = 0; 1181 char *r = stpncpy(d, s, n); 1182 ]])], [ 1183 ac_have_gnu_stpncpy=yes 1184 AC_MSG_RESULT([yes]) 1185 ], [ 1186 ac_have_gnu_stpncpy=no 1187 AC_MSG_RESULT([no]) 1188 ]) 1189 1190 AM_CONDITIONAL([HAVE_GNU_STPNCPY], [test x$ac_have_gnu_stpncpy = xyes]) 1191 1192 # Check for PTRACE_GETREGS 1193 1194 AC_MSG_CHECKING([for PTRACE_GETREGS]) 1195 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 1196 #include <stdlib.h> 1197 #include <stddef.h> 1198 #include <sys/ptrace.h> 1199 #include <sys/user.h> 1200 ]], [[ 1201 void *p; 1202 long res = ptrace (PTRACE_GETREGS, 0, p, p); 1203 ]])], [ 1204 AC_MSG_RESULT([yes]) 1205 AC_DEFINE([HAVE_PTRACE_GETREGS], 1, 1206 [Define to 1 if you have the `PTRACE_GETREGS' ptrace request.]) 1207 ], [ 1208 AC_MSG_RESULT([no]) 1209 ]) 1210 1211 1212 # Check for CLOCK_MONOTONIC 1213 1214 AC_MSG_CHECKING([for CLOCK_MONOTONIC]) 1215 1216 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 1217 #include <time.h> 1218 ]], [[ 1219 struct timespec t; 1220 clock_gettime(CLOCK_MONOTONIC, &t); 1221 return 0; 1222 ]])], [ 1223 AC_MSG_RESULT([yes]) 1224 AC_DEFINE([HAVE_CLOCK_MONOTONIC], 1, 1225 [Define to 1 if you have the `CLOCK_MONOTONIC' constant.]) 1226 ], [ 1227 AC_MSG_RESULT([no]) 1228 ]) 1229 1230 1231 # Check for PTHREAD_RWLOCK_T 1232 1233 AC_MSG_CHECKING([for pthread_rwlock_t]) 1234 1235 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 1236 #define _GNU_SOURCE 1237 #include <pthread.h> 1238 ]], [[ 1239 pthread_rwlock_t rwl; 1240 ]])], [ 1241 AC_MSG_RESULT([yes]) 1242 AC_DEFINE([HAVE_PTHREAD_RWLOCK_T], 1, 1243 [Define to 1 if you have the `pthread_rwlock_t' type.]) 1244 ], [ 1245 AC_MSG_RESULT([no]) 1246 ]) 1247 1248 1249 # Check for PTHREAD_MUTEX_ADAPTIVE_NP 1250 1251 AC_MSG_CHECKING([for PTHREAD_MUTEX_ADAPTIVE_NP]) 1252 1253 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 1254 #define _GNU_SOURCE 1255 #include <pthread.h> 1256 ]], [[ 1257 return (PTHREAD_MUTEX_ADAPTIVE_NP); 1258 ]])], [ 1259 AC_MSG_RESULT([yes]) 1260 AC_DEFINE([HAVE_PTHREAD_MUTEX_ADAPTIVE_NP], 1, 1261 [Define to 1 if you have the `PTHREAD_MUTEX_ADAPTIVE_NP' constant.]) 1262 ], [ 1263 AC_MSG_RESULT([no]) 1264 ]) 1265 1266 1267 # Check for PTHREAD_MUTEX_ERRORCHECK_NP 1268 1269 AC_MSG_CHECKING([for PTHREAD_MUTEX_ERRORCHECK_NP]) 1270 1271 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 1272 #define _GNU_SOURCE 1273 #include <pthread.h> 1274 ]], [[ 1275 return (PTHREAD_MUTEX_ERRORCHECK_NP); 1276 ]])], [ 1277 AC_MSG_RESULT([yes]) 1278 AC_DEFINE([HAVE_PTHREAD_MUTEX_ERRORCHECK_NP], 1, 1279 [Define to 1 if you have the `PTHREAD_MUTEX_ERRORCHECK_NP' constant.]) 1280 ], [ 1281 AC_MSG_RESULT([no]) 1282 ]) 1283 1284 1285 # Check for PTHREAD_MUTEX_RECURSIVE_NP 1286 1287 AC_MSG_CHECKING([for PTHREAD_MUTEX_RECURSIVE_NP]) 1288 1289 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 1290 #define _GNU_SOURCE 1291 #include <pthread.h> 1292 ]], [[ 1293 return (PTHREAD_MUTEX_RECURSIVE_NP); 1294 ]])], [ 1295 AC_MSG_RESULT([yes]) 1296 AC_DEFINE([HAVE_PTHREAD_MUTEX_RECURSIVE_NP], 1, 1297 [Define to 1 if you have the `PTHREAD_MUTEX_RECURSIVE_NP' constant.]) 1298 ], [ 1299 AC_MSG_RESULT([no]) 1300 ]) 1301 1302 1303 # Check for PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP 1304 1305 AC_MSG_CHECKING([for PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP]) 1306 1307 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 1308 #define _GNU_SOURCE 1309 #include <pthread.h> 1310 ]], [[ 1311 pthread_mutex_t m = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; 1312 return 0; 1313 ]])], [ 1314 AC_MSG_RESULT([yes]) 1315 AC_DEFINE([HAVE_PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP], 1, 1316 [Define to 1 if you have the `PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP' constant.]) 1317 ], [ 1318 AC_MSG_RESULT([no]) 1319 ]) 1320 1321 1322 # Check whether pthread_mutex_t has a member called __m_kind. 1323 1324 AC_CHECK_MEMBER([pthread_mutex_t.__m_kind], 1325 [AC_DEFINE([HAVE_PTHREAD_MUTEX_T__M_KIND], 1326 1, 1327 [Define to 1 if pthread_mutex_t has a member called __m_kind.]) 1328 ], 1329 [], 1330 [#include <pthread.h>]) 1331 1332 1333 # Check whether pthread_mutex_t has a member called __data.__kind. 1334 1335 AC_CHECK_MEMBER([pthread_mutex_t.__data.__kind], 1336 [AC_DEFINE([HAVE_PTHREAD_MUTEX_T__DATA__KIND], 1337 1, 1338 [Define to 1 if pthread_mutex_t has a member __data.__kind.]) 1339 ], 1340 [], 1341 [#include <pthread.h>]) 1342 1343 # Convenience function. Set flags based on the existing HWCAP entries. 1344 # The AT_HWCAP entries are generated by glibc, and are based on 1345 # functions supported by the hardware/system/libc. 1346 # Subsequent support for whether the capability will actually be utilized 1347 # will also be checked against the compiler capabilities. 1348 # called as 1349 # AC_HWCAP_CONTAINS_FLAG[hwcap_string_to_match],[VARIABLE_TO_SET] 1350 AC_DEFUN([AC_HWCAP_CONTAINS_FLAG],[ 1351 AUXV_CHECK_FOR=$1 1352 AC_MSG_CHECKING([if AT_HWCAP contains the $AUXV_CHECK_FOR indicator]) 1353 if LD_SHOW_AUXV=1 `which true` | grep ^AT_HWCAP | grep -q -w ${AUXV_CHECK_FOR} 1354 then 1355 AC_MSG_RESULT([yes]) 1356 AC_SUBST([$2],[yes]) 1357 else 1358 AC_MSG_RESULT([no]) 1359 AC_SUBST([$2],[]) 1360 fi 1361 ]) 1362 1363 # gather hardware capabilities. (hardware/kernel/libc) 1364 AC_HWCAP_CONTAINS_FLAG([altivec],[HWCAP_HAS_ALTIVEC]) 1365 AC_HWCAP_CONTAINS_FLAG([vsx],[HWCAP_HAS_VSX]) 1366 AC_HWCAP_CONTAINS_FLAG([dfp],[HWCAP_HAS_DFP]) 1367 AC_HWCAP_CONTAINS_FLAG([arch_2_05],[HWCAP_HAS_ISA_2_05]) 1368 AC_HWCAP_CONTAINS_FLAG([arch_2_06],[HWCAP_HAS_ISA_2_06]) 1369 AC_HWCAP_CONTAINS_FLAG([arch_2_07],[HWCAP_HAS_ISA_2_07]) 1370 AC_HWCAP_CONTAINS_FLAG([htm],[HWCAP_HAS_HTM]) 1371 1372 # ISA Levels 1373 AM_CONDITIONAL(HAS_ISA_2_05, [test x$HWCAP_HAS_ISA_2_05 = xyes]) 1374 AM_CONDITIONAL(HAS_ISA_2_06, [test x$HWCAP_HAS_ISA_2_06 = xyes]) 1375 # compiler support for isa 2.07 level instructions 1376 AC_MSG_CHECKING([that assembler knows ISA 2.07 instructions ]) 1377 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 1378 ]], [[ 1379 __asm__ __volatile__("mtvsrd 1,2 "); 1380 ]])], [ 1381 ac_asm_have_isa_2_07=yes 1382 AC_MSG_RESULT([yes]) 1383 ], [ 1384 ac_asm_have_isa_2_07=no 1385 AC_MSG_RESULT([no]) 1386 ]) 1387 AM_CONDITIONAL(HAS_ISA_2_07, [test x$ac_asm_have_isa_2_07 = xyes \ 1388 -a x$HWCAP_HAS_ISA_2_07 = xyes]) 1389 1390 # altivec (vsx) support. 1391 # does this compiler support -maltivec and does it have the include file 1392 # <altivec.h> ? 1393 AC_MSG_CHECKING([for Altivec support in the compiler ]) 1394 safe_CFLAGS=$CFLAGS 1395 CFLAGS="-maltivec -Werror" 1396 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 1397 #include <altivec.h> 1398 ]], [[ 1399 vector unsigned int v; 1400 ]])], [ 1401 ac_have_altivec=yes 1402 AC_MSG_RESULT([yes]) 1403 AC_DEFINE([HAS_ALTIVEC], 1, 1404 [Define to 1 if gcc/as can do Altivec.]) 1405 ], [ 1406 ac_have_altivec=no 1407 AC_MSG_RESULT([no]) 1408 ]) 1409 CFLAGS=$safe_CFLAGS 1410 AM_CONDITIONAL([HAS_ALTIVEC], [test x$ac_have_altivec = xyes \ 1411 -a x$HWCAP_HAS_ALTIVEC = xyes]) 1412 1413 # Check that both: the compiler supports -mvsx and that the assembler 1414 # understands VSX instructions. If either of those doesn't work, 1415 # conclude that we can't do VSX. 1416 AC_MSG_CHECKING([for VSX compiler flag support]) 1417 safe_CFLAGS=$CFLAGS 1418 CFLAGS="-mvsx -Werror" 1419 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 1420 ]], [[ 1421 ]])], [ 1422 ac_compiler_supports_vsx_flag=yes 1423 AC_MSG_RESULT([yes]) 1424 ], [ 1425 ac_compiler_supports_vsx_flag=no 1426 AC_MSG_RESULT([no]) 1427 ]) 1428 CFLAGS=$safe_CFLAGS 1429 1430 AC_MSG_CHECKING([for VSX support in the assembler ]) 1431 safe_CFLAGS=$CFLAGS 1432 CFLAGS="-mvsx -Werror" 1433 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 1434 #include <altivec.h> 1435 ]], [[ 1436 vector unsigned int v; 1437 __asm__ __volatile__("xsmaddadp 32, 32, 33" ::: "memory","cc"); 1438 ]])], [ 1439 ac_compiler_supports_vsx=yes 1440 AC_MSG_RESULT([yes]) 1441 ], [ 1442 ac_compiler_supports_vsx=no 1443 AC_MSG_RESULT([no]) 1444 ]) 1445 CFLAGS=$safe_CFLAGS 1446 AM_CONDITIONAL([HAS_VSX], [test x$ac_compiler_supports_vsx_flag = xyes \ 1447 -a x$ac_compiler_supports_vsx = xyes \ 1448 -a x$HWCAP_HAS_VSX = xyes ]) 1449 1450 # DFP (Decimal Float) 1451 AC_MSG_CHECKING([that assembler knows DFP]) 1452 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 1453 ]], [[ 1454 __asm__ __volatile__("dadd 1, 2, 3"); 1455 __asm__ __volatile__("dcffix 1, 2"); 1456 ]])], [ 1457 ac_asm_have_dfp=yes 1458 AC_MSG_RESULT([yes]) 1459 ], [ 1460 ac_asm_have_dfp=no 1461 AC_MSG_RESULT([no]) 1462 ]) 1463 AC_MSG_CHECKING([that compiler knows -mhard-dfp switch]) 1464 safe_CFLAGS=$CFLAGS 1465 CFLAGS="-mhard-dfp -Werror" 1466 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 1467 ]], [[ 1468 __asm__ __volatile__("dadd 1, 2, 3"); 1469 __asm__ __volatile__("dcffix 1, 2"); 1470 ]])], [ 1471 ac_compiler_have_dfp=yes 1472 AC_MSG_RESULT([yes]) 1473 ], [ 1474 ac_compiler_have_dfp=no 1475 AC_MSG_RESULT([no]) 1476 ]) 1477 CFLAGS=$safe_CFLAGS 1478 AM_CONDITIONAL(HAS_DFP, test x$ac_asm_have_dfp = xyes \ 1479 -a x$ac_compiler_have_dfp = xyes \ 1480 -a x$HWCAP_HAS_DFP = xyes ) 1481 1482 AC_MSG_CHECKING([that compiler knows DFP datatypes]) 1483 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 1484 ]], [[ 1485 _Decimal64 x = 0.0DD; 1486 ]])], [ 1487 ac_compiler_have_dfp_type=yes 1488 AC_MSG_RESULT([yes]) 1489 ], [ 1490 ac_compiler_have_dfp_type=no 1491 AC_MSG_RESULT([no]) 1492 ]) 1493 AM_CONDITIONAL(BUILD_DFP_TESTS, test x$ac_compiler_have_dfp_type = xyes \ 1494 -a xHWCAP_$HAS_DFP = xyes ) 1495 1496 1497 # HTM (Hardware Transactional Memory) 1498 AC_MSG_CHECKING([if compiler accepts the -mhtm flag]) 1499 safe_CFLAGS=$CFLAGS 1500 CFLAGS="-mhtm -Werror" 1501 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 1502 ]], [[ 1503 return 0; 1504 ]])], [ 1505 AC_MSG_RESULT([yes]) 1506 ac_compiler_supports_htm=yes 1507 ], [ 1508 AC_MSG_RESULT([no]) 1509 ac_compiler_supports_htm=no 1510 ]) 1511 CFLAGS=$safe_CFLAGS 1512 1513 AC_MSG_CHECKING([if compiler can find the htm builtins]) 1514 safe_CFLAGS=$CFLAGS 1515 CFLAGS="-mhtm -Werror" 1516 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 1517 ]], [[ 1518 if (__builtin_tbegin (0)) 1519 __builtin_tend (0); 1520 ]])], [ 1521 AC_MSG_RESULT([yes]) 1522 ac_compiler_sees_htm_builtins=yes 1523 ], [ 1524 AC_MSG_RESULT([no]) 1525 ac_compiler_sees_htm_builtins=no 1526 ]) 1527 CFLAGS=$safe_CFLAGS 1528 1529 AM_CONDITIONAL(SUPPORTS_HTM, test x$ac_compiler_supports_htm = xyes \ 1530 -a x$ac_compiler_sees_htm_builtins = xyes \ 1531 -a x$HWCAP_HAS_HTM = xyes ) 1532 1533 # Check for pthread_create (a] GLIBC2.0 1534 AC_MSG_CHECKING([for pthread_create (a] GLIBC2.0()]) 1535 1536 safe_CFLAGS=$CFLAGS 1537 CFLAGS="-lpthread -Werror" 1538 AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 1539 extern int pthread_create_glibc_2_0(void*, const void*, 1540 void *(*)(void*), void*); 1541 __asm__(".symver pthread_create_glibc_2_0, pthread_create (a] GLIBC_2.0"); 1542 ]], [[ 1543 #ifdef __powerpc__ 1544 /* 1545 * Apparently on PowerPC linking this program succeeds and generates an 1546 * executable with the undefined symbol pthread_create (a] GLIBC_2.0. 1547 */ 1548 #error This test does not work properly on PowerPC. 1549 #else 1550 pthread_create_glibc_2_0(0, 0, 0, 0); 1551 #endif 1552 return 0; 1553 ]])], [ 1554 ac_have_pthread_create_glibc_2_0=yes 1555 AC_MSG_RESULT([yes]) 1556 AC_DEFINE([HAVE_PTHREAD_CREATE_GLIBC_2_0], 1, 1557 [Define to 1 if you have the `pthread_create (a] glibc2.0' function.]) 1558 ], [ 1559 ac_have_pthread_create_glibc_2_0=no 1560 AC_MSG_RESULT([no]) 1561 ]) 1562 CFLAGS=$safe_CFLAGS 1563 1564 AM_CONDITIONAL(HAVE_PTHREAD_CREATE_GLIBC_2_0, 1565 test x$ac_have_pthread_create_glibc_2_0 = xyes) 1566 1567 1568 # Check for dlinfo RTLD_DI_TLS_MODID 1569 AC_MSG_CHECKING([for dlinfo RTLD_DI_TLS_MODID]) 1570 1571 safe_LIBS="$LIBS" 1572 LIBS="-ldl" 1573 AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 1574 #ifndef _GNU_SOURCE 1575 #define _GNU_SOURCE 1576 #endif 1577 #include <link.h> 1578 #include <dlfcn.h> 1579 ]], [[ 1580 size_t sizes[10000]; 1581 size_t modid_offset; 1582 (void) dlinfo ((void*)sizes, RTLD_DI_TLS_MODID, &modid_offset); 1583 return 0; 1584 ]])], [ 1585 ac_have_dlinfo_rtld_di_tls_modid=yes 1586 AC_MSG_RESULT([yes]) 1587 AC_DEFINE([HAVE_DLINFO_RTLD_DI_TLS_MODID], 1, 1588 [Define to 1 if you have a dlinfo that can do RTLD_DI_TLS_MODID.]) 1589 ], [ 1590 ac_have_dlinfo_rtld_di_tls_modid=no 1591 AC_MSG_RESULT([no]) 1592 ]) 1593 LIBS=$safe_LIBS 1594 1595 AM_CONDITIONAL(HAVE_DLINFO_RTLD_DI_TLS_MODID, 1596 test x$ac_have_dlinfo_rtld_di_tls_modid = xyes) 1597 1598 1599 # Check for eventfd_t, eventfd() and eventfd_read() 1600 AC_MSG_CHECKING([for eventfd()]) 1601 1602 AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 1603 #include <sys/eventfd.h> 1604 ]], [[ 1605 eventfd_t ev; 1606 int fd; 1607 1608 fd = eventfd(5, 0); 1609 eventfd_read(fd, &ev); 1610 return 0; 1611 ]])], [ 1612 AC_MSG_RESULT([yes]) 1613 AC_DEFINE([HAVE_EVENTFD], 1, 1614 [Define to 1 if you have the `eventfd' function.]) 1615 AC_DEFINE([HAVE_EVENTFD_READ], 1, 1616 [Define to 1 if you have the `eventfd_read' function.]) 1617 ], [ 1618 AC_MSG_RESULT([no]) 1619 ]) 1620 1621 # Check whether compiler can process #include <thread> without errors 1622 # clang 3.3 cannot process <thread> from e.g. 1623 # gcc (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3 1624 1625 AC_MSG_CHECKING([that C++ compiler can include <thread> header file]) 1626 AC_LANG(C++) 1627 safe_CXXFLAGS=$CXXFLAGS 1628 CXXFLAGS=-std=c++0x 1629 1630 AC_COMPILE_IFELSE([AC_LANG_SOURCE([ 1631 #include <thread> 1632 ])], 1633 [ 1634 ac_cxx_can_include_thread_header=yes 1635 AC_MSG_RESULT([yes]) 1636 ], [ 1637 ac_cxx_can_include_thread_header=no 1638 AC_MSG_RESULT([no]) 1639 ]) 1640 CXXFLAGS=$safe_CXXFLAGS 1641 AC_LANG(C) 1642 1643 AM_CONDITIONAL(CXX_CAN_INCLUDE_THREAD_HEADER, test x$ac_cxx_can_include_thread_header = xyes) 1644 1645 1646 # On aarch64 before glibc 2.20 we would get the kernel user_pt_regs instead 1647 # of the user_regs_struct from sys/user.h. They are structurally the same 1648 # but we get either one or the other. 1649 1650 AC_CHECK_TYPE([struct user_regs_struct], 1651 [sys_user_has_user_regs=yes], [sys_user_has_user_regs=no], 1652 [[#include <sys/ptrace.h>] 1653 [#include <sys/time.h>] 1654 [#include <sys/user.h>]]) 1655 if test "$sys_user_has_user_regs" = "yes"; then 1656 AC_DEFINE(HAVE_SYS_USER_REGS, 1, 1657 [Define to 1 if <sys/user.h> defines struct user_regs_struct]) 1658 fi 1659 1660 1661 #---------------------------------------------------------------------------- 1662 # Checking for supported compiler flags. 1663 #---------------------------------------------------------------------------- 1664 1665 # does this compiler support -m32 ? 1666 AC_MSG_CHECKING([if gcc accepts -m32]) 1667 1668 safe_CFLAGS=$CFLAGS 1669 CFLAGS="-m32 -Werror" 1670 1671 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 1672 return 0; 1673 ]])], [ 1674 FLAG_M32="-m32" 1675 AC_MSG_RESULT([yes]) 1676 ], [ 1677 FLAG_M32="" 1678 AC_MSG_RESULT([no]) 1679 ]) 1680 CFLAGS=$safe_CFLAGS 1681 1682 AC_SUBST(FLAG_M32) 1683 1684 1685 # does this compiler support -m64 ? 1686 AC_MSG_CHECKING([if gcc accepts -m64]) 1687 1688 safe_CFLAGS=$CFLAGS 1689 CFLAGS="-m64 -Werror" 1690 1691 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 1692 return 0; 1693 ]])], [ 1694 FLAG_M64="-m64" 1695 AC_MSG_RESULT([yes]) 1696 ], [ 1697 FLAG_M64="" 1698 AC_MSG_RESULT([no]) 1699 ]) 1700 CFLAGS=$safe_CFLAGS 1701 1702 AC_SUBST(FLAG_M64) 1703 1704 1705 # does this compiler support -march=mips32 (mips32 default) ? 1706 AC_MSG_CHECKING([if gcc accepts -march=mips32]) 1707 1708 safe_CFLAGS=$CFLAGS 1709 CFLAGS="$CFLAGS -march=mips32 -Werror" 1710 1711 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 1712 return 0; 1713 ]])], [ 1714 FLAG_MIPS32="-march=mips32" 1715 AC_MSG_RESULT([yes]) 1716 ], [ 1717 FLAG_MIPS32="" 1718 AC_MSG_RESULT([no]) 1719 ]) 1720 CFLAGS=$safe_CFLAGS 1721 1722 AC_SUBST(FLAG_MIPS32) 1723 1724 1725 # does this compiler support -march=mips64 (mips64 default) ? 1726 AC_MSG_CHECKING([if gcc accepts -march=mips64]) 1727 1728 safe_CFLAGS=$CFLAGS 1729 CFLAGS="$CFLAGS -march=mips64 -Werror" 1730 1731 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 1732 return 0; 1733 ]])], [ 1734 FLAG_MIPS64="-march=mips64" 1735 AC_MSG_RESULT([yes]) 1736 ], [ 1737 FLAG_MIPS64="" 1738 AC_MSG_RESULT([no]) 1739 ]) 1740 CFLAGS=$safe_CFLAGS 1741 1742 AC_SUBST(FLAG_MIPS64) 1743 1744 1745 # does this compiler support -march=octeon (Cavium OCTEON I Specific) ? 1746 AC_MSG_CHECKING([if gcc accepts -march=octeon]) 1747 1748 safe_CFLAGS=$CFLAGS 1749 CFLAGS="$CFLAGS -march=octeon -Werror" 1750 1751 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 1752 return 0; 1753 ]])], [ 1754 FLAG_OCTEON="-march=octeon" 1755 AC_MSG_RESULT([yes]) 1756 ], [ 1757 FLAG_OCTEON="" 1758 AC_MSG_RESULT([no]) 1759 ]) 1760 CFLAGS=$safe_CFLAGS 1761 1762 AC_SUBST(FLAG_OCTEON) 1763 1764 1765 # does this compiler support -march=octeon2 (Cavium OCTEON II Specific) ? 1766 AC_MSG_CHECKING([if gcc accepts -march=octeon2]) 1767 1768 safe_CFLAGS=$CFLAGS 1769 CFLAGS="$CFLAGS -march=octeon2 -Werror" 1770 1771 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 1772 return 0; 1773 ]])], [ 1774 FLAG_OCTEON2="-march=octeon2" 1775 AC_MSG_RESULT([yes]) 1776 ], [ 1777 FLAG_OCTEON2="" 1778 AC_MSG_RESULT([no]) 1779 ]) 1780 CFLAGS=$safe_CFLAGS 1781 1782 AC_SUBST(FLAG_OCTEON2) 1783 1784 1785 # does this compiler support -mmmx ? 1786 AC_MSG_CHECKING([if gcc accepts -mmmx]) 1787 1788 safe_CFLAGS=$CFLAGS 1789 CFLAGS="-mmmx -Werror" 1790 1791 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 1792 return 0; 1793 ]])], [ 1794 FLAG_MMMX="-mmmx" 1795 AC_MSG_RESULT([yes]) 1796 ], [ 1797 FLAG_MMMX="" 1798 AC_MSG_RESULT([no]) 1799 ]) 1800 CFLAGS=$safe_CFLAGS 1801 1802 AC_SUBST(FLAG_MMMX) 1803 1804 1805 # does this compiler support -msse ? 1806 AC_MSG_CHECKING([if gcc accepts -msse]) 1807 1808 safe_CFLAGS=$CFLAGS 1809 CFLAGS="-msse -Werror" 1810 1811 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 1812 return 0; 1813 ]])], [ 1814 FLAG_MSSE="-msse" 1815 AC_MSG_RESULT([yes]) 1816 ], [ 1817 FLAG_MSSE="" 1818 AC_MSG_RESULT([no]) 1819 ]) 1820 CFLAGS=$safe_CFLAGS 1821 1822 AC_SUBST(FLAG_MSSE) 1823 1824 1825 # does this compiler support -mpreferred-stack-boundary=2 when 1826 # generating code for a 32-bit target? Note that we only care about 1827 # this when generating code for (32-bit) x86, so if the compiler 1828 # doesn't recognise -m32 it's no big deal. We'll just get code for 1829 # the Memcheck and other helper functions, that is a bit slower than 1830 # it could be, on x86; and no difference at all on any other platform. 1831 AC_MSG_CHECKING([if gcc accepts -mpreferred-stack-boundary=2 -m32]) 1832 1833 safe_CFLAGS=$CFLAGS 1834 CFLAGS="-mpreferred-stack-boundary=2 -m32 -Werror" 1835 1836 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 1837 return 0; 1838 ]])], [ 1839 PREFERRED_STACK_BOUNDARY_2="-mpreferred-stack-boundary=2" 1840 AC_MSG_RESULT([yes]) 1841 ], [ 1842 PREFERRED_STACK_BOUNDARY_2="" 1843 AC_MSG_RESULT([no]) 1844 ]) 1845 CFLAGS=$safe_CFLAGS 1846 1847 AC_SUBST(PREFERRED_STACK_BOUNDARY_2) 1848 1849 1850 # does this compiler support -mlong-double-128 ? 1851 AC_MSG_CHECKING([if gcc accepts -mlong-double-128]) 1852 safe_CFLAGS=$CFLAGS 1853 CFLAGS="-mlong-double-128 -Werror" 1854 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 1855 return 0; 1856 ]])], [ 1857 ac_compiler_supports_mlong_double_128=yes 1858 AC_MSG_RESULT([yes]) 1859 ], [ 1860 ac_compiler_supports_mlong_double_128=no 1861 AC_MSG_RESULT([no]) 1862 ]) 1863 CFLAGS=$safe_CFLAGS 1864 AM_CONDITIONAL(HAS_MLONG_DOUBLE_128, test x$ac_compiler_supports_mlong_double_128 = xyes) 1865 FLAG_MLONG_DOUBLE_128="-mlong-double-128" 1866 AC_SUBST(FLAG_MLONG_DOUBLE_128) 1867 1868 1869 # Convenience function to check whether GCC supports a particular 1870 # warning option. Takes two arguments, 1871 # first the warning flag name to check (without -W), then the 1872 # substitution name to set with -Wno-warning-flag if the flag exists, 1873 # or the empty string if the compiler doesn't accept the flag. Note 1874 # that checking is done against the warning flag itself, but the 1875 # substitution is then done to cancel the warning flag. 1876 AC_DEFUN([AC_GCC_WARNING_SUBST_NO],[ 1877 AC_MSG_CHECKING([if gcc accepts -W$1]) 1878 safe_CFLAGS=$CFLAGS 1879 CFLAGS="-W$1 -Werror" 1880 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[;]])], [ 1881 AC_SUBST([$2], [-Wno-$1]) 1882 AC_MSG_RESULT([yes])], [ 1883 AC_SUBST([$2], []) 1884 AC_MSG_RESULT([no])]) 1885 CFLAGS=$safe_CFLAGS 1886 ]) 1887 1888 # Convenience function. Like AC_GCC_WARNING_SUBST_NO, except it substitutes 1889 # -W$1 (instead of -Wno-$1). 1890 AC_DEFUN([AC_GCC_WARNING_SUBST],[ 1891 AC_MSG_CHECKING([if gcc accepts -W$1]) 1892 safe_CFLAGS=$CFLAGS 1893 CFLAGS="-W$1 -Werror" 1894 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[;]])], [ 1895 AC_SUBST([$2], [-W$1]) 1896 AC_MSG_RESULT([yes])], [ 1897 AC_SUBST([$2], []) 1898 AC_MSG_RESULT([no])]) 1899 CFLAGS=$safe_CFLAGS 1900 ]) 1901 1902 AC_GCC_WARNING_SUBST_NO([memset-transposed-args], [FLAG_W_NO_MEMSET_TRANSPOSED_ARGS]) 1903 AC_GCC_WARNING_SUBST_NO([nonnull], [FLAG_W_NO_NONNULL]) 1904 AC_GCC_WARNING_SUBST_NO([overflow], [FLAG_W_NO_OVERFLOW]) 1905 AC_GCC_WARNING_SUBST_NO([pointer-sign], [FLAG_W_NO_POINTER_SIGN]) 1906 AC_GCC_WARNING_SUBST_NO([uninitialized], [FLAG_W_NO_UNINITIALIZED]) 1907 AC_GCC_WARNING_SUBST_NO([unused-function], [FLAG_W_NO_UNUSED_FUNCTION]) 1908 AC_GCC_WARNING_SUBST_NO([static-local-in-inline], [FLAG_W_NO_STATIC_LOCAL_IN_INLINE]) 1909 AC_GCC_WARNING_SUBST_NO([mismatched-new-delete], [FLAG_W_NO_MISMATCHED_NEW_DELETE]) 1910 AC_GCC_WARNING_SUBST_NO([infinite-recursion], [FLAG_W_NO_INFINITE_RECURSION]) 1911 AC_GCC_WARNING_SUBST([write-strings], [FLAG_W_WRITE_STRINGS]) 1912 AC_GCC_WARNING_SUBST([empty-body], [FLAG_W_EMPTY_BODY]) 1913 AC_GCC_WARNING_SUBST([format], [FLAG_W_FORMAT]) 1914 # Disabled for now until all platforms are clean 1915 format_checking_enabled=no 1916 #format_checking_enabled=yes 1917 if test "$format_checking_enabled" = "yes"; then 1918 AC_GCC_WARNING_SUBST([format-signedness], [FLAG_W_FORMAT_SIGNEDNESS]) 1919 else 1920 dumy_assignment_to_avoid_syntax_errors=1 1921 AC_SUBST([FLAG_W_FORMAT_SIGNEDNESS], []) 1922 fi 1923 AC_GCC_WARNING_SUBST([cast-qual], [FLAG_W_CAST_QUAL]) 1924 AC_GCC_WARNING_SUBST([old-style-declaration], [FLAG_W_OLD_STYLE_DECLARATION]) 1925 AC_GCC_WARNING_SUBST([ignored-qualifiers], [FLAG_W_IGNORED_QUALIFIERS]) 1926 AC_GCC_WARNING_SUBST([missing-parameter-type], [FLAG_W_MISSING_PARAMETER_TYPE]) 1927 1928 # Does this compiler support -Wformat-security ? 1929 # Special handling is needed, because certain GCC versions require -Wformat 1930 # being present if -Wformat-security is given. Otherwise a warning is issued. 1931 # However, AC_GCC_WARNING_SUBST will stick in -Werror (see r15323 for rationale). 1932 # And with that the warning will be turned into an error with the result 1933 # that -Wformat-security is believed to be unsupported when in fact it is. 1934 AC_MSG_CHECKING([if gcc accepts -Wformat-security]) 1935 safe_CFLAGS=$CFLAGS 1936 CFLAGS="-Wformat -Wformat-security -Werror" 1937 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[;]])], [ 1938 AC_SUBST([FLAG_W_FORMAT_SECURITY], [-Wformat-security]) 1939 AC_MSG_RESULT([yes])], [ 1940 AC_SUBST([FLAG_W_FORMAT_SECURITY], []) 1941 AC_MSG_RESULT([no])]) 1942 CFLAGS=$safe_CFLAGS 1943 1944 # does this compiler support -Wextra or the older -W ? 1945 1946 AC_MSG_CHECKING([if gcc accepts -Wextra or -W]) 1947 1948 safe_CFLAGS=$CFLAGS 1949 CFLAGS="-Wextra -Werror" 1950 1951 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[ 1952 return 0; 1953 ]])], [ 1954 AC_SUBST([FLAG_W_EXTRA], [-Wextra]) 1955 AC_MSG_RESULT([-Wextra]) 1956 ], [ 1957 CFLAGS="-W -Werror" 1958 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[ 1959 return 0; 1960 ]])], [ 1961 AC_SUBST([FLAG_W_EXTRA], [-W]) 1962 AC_MSG_RESULT([-W]) 1963 ], [ 1964 AC_SUBST([FLAG_W_EXTRA], []) 1965 AC_MSG_RESULT([not supported]) 1966 ]) 1967 ]) 1968 CFLAGS=$safe_CFLAGS 1969 1970 # On ARM we do not want to pass -Wcast-align as that produces loads 1971 # of warnings. GCC is just being conservative. See here: 1972 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=65459#c4 1973 if test "X$VGCONF_ARCH_PRI" = "Xarm"; then 1974 AC_SUBST([FLAG_W_CAST_ALIGN], [""]) 1975 else 1976 AC_SUBST([FLAG_W_CAST_ALIGN], [-Wcast-align]) 1977 fi 1978 1979 # does this compiler support -fno-stack-protector ? 1980 AC_MSG_CHECKING([if gcc accepts -fno-stack-protector]) 1981 1982 safe_CFLAGS=$CFLAGS 1983 CFLAGS="-fno-stack-protector -Werror" 1984 1985 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 1986 return 0; 1987 ]])], [ 1988 no_stack_protector=yes 1989 FLAG_FNO_STACK_PROTECTOR="-fno-stack-protector" 1990 AC_MSG_RESULT([yes]) 1991 ], [ 1992 no_stack_protector=no 1993 FLAG_FNO_STACK_PROTECTOR="" 1994 AC_MSG_RESULT([no]) 1995 ]) 1996 CFLAGS=$safe_CFLAGS 1997 1998 AC_SUBST(FLAG_FNO_STACK_PROTECTOR) 1999 2000 # Does GCC support disabling Identical Code Folding? 2001 # We want to disabled Identical Code Folding for the 2002 # tools preload shared objects to get better backraces. 2003 # For GCC 5.1+ -fipa-icf is enabled by default at -O2. 2004 # "The optimization reduces code size and may disturb 2005 # unwind stacks by replacing a function by equivalent 2006 # one with a different name." 2007 AC_MSG_CHECKING([if gcc accepts -fno-ipa-icf]) 2008 2009 safe_CFLAGS=$CFLAGS 2010 CFLAGS="-fno-ipa-icf -Werror" 2011 2012 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2013 return 0; 2014 ]])], [ 2015 no_ipa_icf=yes 2016 FLAG_FNO_IPA_ICF="-fno-ipa-icf" 2017 AC_MSG_RESULT([yes]) 2018 ], [ 2019 no_ipa_icf=no 2020 FLAG_FNO_IPA_ICF="" 2021 AC_MSG_RESULT([no]) 2022 ]) 2023 CFLAGS=$safe_CFLAGS 2024 2025 AC_SUBST(FLAG_FNO_IPA_ICF) 2026 2027 2028 # Does this compiler support -fsanitize=undefined. This is true for 2029 # GCC 4.9 and newer. However, the undefined behaviour sanitiser in GCC 5.1 2030 # also checks for alignment violations on memory accesses which the valgrind 2031 # code base is sprinkled (if not littered) with. As those alignment issues 2032 # don't pose a problem we want to suppress warnings about them. 2033 # In GCC 5.1 this can be done by passing -fno-sanitize=alignment. Earlier 2034 # GCCs do not support that. 2035 # 2036 # Only checked for if --enable-ubsan was given. 2037 if test "x${vg_cv_ubsan}" = "xyes"; then 2038 AC_MSG_CHECKING([if gcc accepts -fsanitize=undefined -fno-sanitize=alignment]) 2039 safe_CFLAGS=$CFLAGS 2040 CFLAGS="-fsanitize=undefined -fno-sanitize=alignment -Werror" 2041 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2042 return 0; 2043 ]])], [ 2044 FLAG_FSANITIZE="-fsanitize=undefined -fno-sanitize=alignment" 2045 LIB_UBSAN="-static-libubsan" 2046 AC_MSG_RESULT([yes]) 2047 ], [ 2048 CFLAGS="-fsanitize=undefined -Werror" 2049 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2050 return 0; 2051 ]])], [ 2052 FLAG_FSANITIZE="-fsanitize=undefined" 2053 LIB_UBSAN="-static-libubsan" 2054 AC_MSG_RESULT([yes]) 2055 ], [ 2056 FLAG_FSANITIZE="" 2057 LIB_UBSAN="" 2058 AC_MSG_RESULT([no]) 2059 ]) 2060 ]) 2061 CFLAGS=$safe_CFLAGS 2062 AC_SUBST(FLAG_FSANITIZE) 2063 AC_SUBST(LIB_UBSAN) 2064 fi 2065 # does this compiler support --param inline-unit-growth=... ? 2066 2067 AC_MSG_CHECKING([if gcc accepts --param inline-unit-growth]) 2068 2069 safe_CFLAGS=$CFLAGS 2070 CFLAGS="--param inline-unit-growth=900 -Werror" 2071 2072 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[ 2073 return 0; 2074 ]])], [ 2075 AC_SUBST([FLAG_UNLIMITED_INLINE_UNIT_GROWTH], 2076 ["--param inline-unit-growth=900"]) 2077 AC_MSG_RESULT([yes]) 2078 ], [ 2079 AC_SUBST([FLAG_UNLIMITED_INLINE_UNIT_GROWTH], [""]) 2080 AC_MSG_RESULT([no]) 2081 ]) 2082 CFLAGS=$safe_CFLAGS 2083 2084 2085 # does this compiler support -gdwarf-4 -fdebug-types-section ? 2086 2087 AC_MSG_CHECKING([if gcc accepts -gdwarf-4 -fdebug-types-section]) 2088 2089 safe_CFLAGS=$CFLAGS 2090 CFLAGS="-gdwarf-4 -fdebug-types-section -Werror" 2091 2092 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[ 2093 return 0; 2094 ]])], [ 2095 ac_have_dwarf4=yes 2096 AC_MSG_RESULT([yes]) 2097 ], [ 2098 ac_have_dwarf4=no 2099 AC_MSG_RESULT([no]) 2100 ]) 2101 AM_CONDITIONAL(DWARF4, test x$ac_have_dwarf4 = xyes) 2102 CFLAGS=$safe_CFLAGS 2103 2104 2105 # does this compiler support nested functions ? 2106 2107 AC_MSG_CHECKING([if gcc accepts nested functions]) 2108 2109 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2110 int foo() { return 1; } 2111 return foo(); 2112 ]])], [ 2113 ac_have_nested_functions=yes 2114 AC_MSG_RESULT([yes]) 2115 ], [ 2116 ac_have_nested_functions=no 2117 AC_MSG_RESULT([no]) 2118 ]) 2119 AM_CONDITIONAL([HAVE_NESTED_FUNCTIONS], [test x$ac_have_nested_functions = xyes]) 2120 2121 2122 # does this compiler support the 'p' constraint in ASM statements ? 2123 2124 AC_MSG_CHECKING([if gcc accepts the 'p' constraint in asm statements]) 2125 2126 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2127 char *p; 2128 __asm__ __volatile__ ("movdqa (%0),%%xmm6\n" : "=p" (p)); 2129 ]])], [ 2130 ac_have_asm_constraint_p=yes 2131 AC_MSG_RESULT([yes]) 2132 ], [ 2133 ac_have_asm_constraint_p=no 2134 AC_MSG_RESULT([no]) 2135 ]) 2136 AM_CONDITIONAL([HAVE_ASM_CONSTRAINT_P], [test x$ac_have_asm_constraint_p = xyes]) 2137 2138 2139 # We want to use use the -Ttext-segment option to the linker. 2140 # GNU (bfd) ld supports this directly. Newer GNU gold linkers 2141 # support it as an alias of -Ttext. Sadly GNU (bfd) ld's -Ttext 2142 # semantics are NOT what we want (GNU gold -Ttext is fine). 2143 # 2144 # For GNU (bfd) ld -Ttext-segment chooses the base at which ELF headers 2145 # will reside. -Ttext aligns just the .text section start (but not any 2146 # other section). 2147 # 2148 # So test for -Ttext-segment which is supported by all bfd ld versions 2149 # and use that if it exists. If it doesn't exist it must be an older 2150 # version of gold and we can fall back to using -Ttext which has the 2151 # right semantics. 2152 2153 AC_MSG_CHECKING([if the linker accepts -Wl,-Ttext-segment]) 2154 2155 safe_CFLAGS=$CFLAGS 2156 CFLAGS="-static -nodefaultlibs -nostartfiles -Wl,-Ttext-segment=$valt_load_address_pri_norml -Werror" 2157 2158 AC_LINK_IFELSE( 2159 [AC_LANG_SOURCE([int _start () { return 0; }])], 2160 [ 2161 linker_using_t_text="no" 2162 AC_SUBST([FLAG_T_TEXT], ["-Ttext-segment"]) 2163 AC_MSG_RESULT([yes]) 2164 ], [ 2165 linker_using_t_text="yes" 2166 AC_SUBST([FLAG_T_TEXT], ["-Ttext"]) 2167 AC_MSG_RESULT([no]) 2168 ]) 2169 CFLAGS=$safe_CFLAGS 2170 2171 # If the linker only supports -Ttext (not -Ttext-segment) then we will 2172 # have to strip any build-id ELF NOTEs from the staticly linked tools. 2173 # Otherwise the build-id NOTE might end up at the default load address. 2174 # (Pedantically if the linker is gold then -Ttext is fine, but newer 2175 # gold versions also support -Ttext-segment. So just assume that unless 2176 # we can use -Ttext-segment we need to strip the build-id NOTEs. 2177 if test "x${linker_using_t_text}" = "xyes"; then 2178 AC_MSG_NOTICE([ld -Ttext used, need to strip build-id NOTEs.]) 2179 # does the linker support -Wl,--build-id=none ? Note, it's 2180 # important that we test indirectly via whichever C compiler 2181 # is selected, rather than testing /usr/bin/ld or whatever 2182 # directly. 2183 AC_MSG_CHECKING([if the linker accepts -Wl,--build-id=none]) 2184 safe_CFLAGS=$CFLAGS 2185 CFLAGS="-Wl,--build-id=none -Werror" 2186 2187 AC_LINK_IFELSE( 2188 [AC_LANG_PROGRAM([ ], [return 0;])], 2189 [ 2190 AC_SUBST([FLAG_NO_BUILD_ID], ["-Wl,--build-id=none"]) 2191 AC_MSG_RESULT([yes]) 2192 ], [ 2193 AC_SUBST([FLAG_NO_BUILD_ID], [""]) 2194 AC_MSG_RESULT([no]) 2195 ]) 2196 else 2197 AC_MSG_NOTICE([ld -Ttext-segment used, no need to strip build-id NOTEs.]) 2198 AC_SUBST([FLAG_NO_BUILD_ID], [""]) 2199 fi 2200 CFLAGS=$safe_CFLAGS 2201 2202 # does the ppc assembler support "mtocrf" et al? 2203 AC_MSG_CHECKING([if ppc32/64 as supports mtocrf/mfocrf]) 2204 2205 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2206 __asm__ __volatile__("mtocrf 4,0"); 2207 __asm__ __volatile__("mfocrf 0,4"); 2208 ]])], [ 2209 ac_have_as_ppc_mftocrf=yes 2210 AC_MSG_RESULT([yes]) 2211 ], [ 2212 ac_have_as_ppc_mftocrf=no 2213 AC_MSG_RESULT([no]) 2214 ]) 2215 if test x$ac_have_as_ppc_mftocrf = xyes ; then 2216 AC_DEFINE(HAVE_AS_PPC_MFTOCRF, 1, [Define to 1 if as supports mtocrf/mfocrf.]) 2217 fi 2218 2219 2220 # does the ppc assembler support "lfdp" and other phased out floating point insns? 2221 AC_MSG_CHECKING([if ppc32/64 asm supports phased out floating point instructions]) 2222 2223 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2224 do { typedef struct { 2225 double hi; 2226 double lo; 2227 } dbl_pair_t; 2228 dbl_pair_t dbl_pair[3]; 2229 __asm__ volatile ("lfdp 10, %0"::"m" (dbl_pair[0])); 2230 } while (0) 2231 ]])], [ 2232 ac_have_as_ppc_fpPO=yes 2233 AC_MSG_RESULT([yes]) 2234 ], [ 2235 ac_have_as_ppc_fpPO=no 2236 AC_MSG_RESULT([no]) 2237 ]) 2238 if test x$ac_have_as_ppc_fpPO = xyes ; then 2239 AC_DEFINE(HAVE_AS_PPC_FPPO, 1, [Define to 1 if as supports floating point phased out category.]) 2240 fi 2241 2242 2243 # does the amd64 assembler understand "fxsave64" and "fxrstor64"? 2244 AC_MSG_CHECKING([if amd64 assembler supports fxsave64/fxrstor64]) 2245 2246 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2247 void* p; 2248 asm __volatile__("fxsave64 (%0)" : : "r" (p) : "memory" ); 2249 asm __volatile__("fxrstor64 (%0)" : : "r" (p) : "memory" ); 2250 ]])], [ 2251 ac_have_as_amd64_fxsave64=yes 2252 AC_MSG_RESULT([yes]) 2253 ], [ 2254 ac_have_as_amd64_fxsave64=no 2255 AC_MSG_RESULT([no]) 2256 ]) 2257 if test x$ac_have_as_amd64_fxsave64 = xyes ; then 2258 AC_DEFINE(HAVE_AS_AMD64_FXSAVE64, 1, [Define to 1 if as supports fxsave64/fxrstor64.]) 2259 fi 2260 2261 # does the x86/amd64 assembler understand SSE3 instructions? 2262 # Note, this doesn't generate a C-level symbol. It generates a 2263 # automake-level symbol (BUILD_SSE3_TESTS), used in test Makefile.am's 2264 AC_MSG_CHECKING([if x86/amd64 assembler speaks SSE3]) 2265 2266 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2267 do { long long int x; 2268 __asm__ __volatile__("fisttpq (%0)" : :"r"(&x) ); } 2269 while (0) 2270 ]])], [ 2271 ac_have_as_sse3=yes 2272 AC_MSG_RESULT([yes]) 2273 ], [ 2274 ac_have_as_sse3=no 2275 AC_MSG_RESULT([no]) 2276 ]) 2277 2278 AM_CONDITIONAL(BUILD_SSE3_TESTS, test x$ac_have_as_sse3 = xyes) 2279 2280 2281 # Ditto for SSSE3 instructions (note extra S) 2282 # Note, this doesn't generate a C-level symbol. It generates a 2283 # automake-level symbol (BUILD_SSSE3_TESTS), used in test Makefile.am's 2284 AC_MSG_CHECKING([if x86/amd64 assembler speaks SSSE3]) 2285 2286 save_CFLAGS="$CFLAGS" 2287 CFLAGS="$CFLAGS -msse -Werror" 2288 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2289 do { long long int x; 2290 __asm__ __volatile__( 2291 "pabsb (%0),%%xmm7" : : "r"(&x) : "xmm7" ); } 2292 while (0) 2293 ]])], [ 2294 ac_have_as_ssse3=yes 2295 AC_MSG_RESULT([yes]) 2296 ], [ 2297 ac_have_as_ssse3=no 2298 AC_MSG_RESULT([no]) 2299 ]) 2300 CFLAGS="$save_CFLAGS" 2301 2302 AM_CONDITIONAL(BUILD_SSSE3_TESTS, test x$ac_have_as_ssse3 = xyes) 2303 2304 2305 # does the x86/amd64 assembler understand the PCLMULQDQ instruction? 2306 # Note, this doesn't generate a C-level symbol. It generates a 2307 # automake-level symbol (BUILD_PCLMULQDQ_TESTS), used in test Makefile.am's 2308 AC_MSG_CHECKING([if x86/amd64 assembler supports 'pclmulqdq']) 2309 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2310 do { 2311 __asm__ __volatile__( 2312 "pclmulqdq \$17,%%xmm6,%%xmm7" : : : "xmm6", "xmm7" ); } 2313 while (0) 2314 ]])], [ 2315 ac_have_as_pclmulqdq=yes 2316 AC_MSG_RESULT([yes]) 2317 ], [ 2318 ac_have_as_pclmulqdq=no 2319 AC_MSG_RESULT([no]) 2320 ]) 2321 2322 AM_CONDITIONAL(BUILD_PCLMULQDQ_TESTS, test x$ac_have_as_pclmulqdq = xyes) 2323 2324 2325 # does the x86/amd64 assembler understand the VPCLMULQDQ instruction? 2326 # Note, this doesn't generate a C-level symbol. It generates a 2327 # automake-level symbol (BUILD_VPCLMULQDQ_TESTS), used in test Makefile.am's 2328 AC_MSG_CHECKING([if x86/amd64 assembler supports 'vpclmulqdq']) 2329 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2330 do { 2331 /* 2332 * Carry-less multiplication of xmm1 with xmm2 and store the result in 2333 * xmm3. The immediate is used to determine which quadwords of xmm1 and 2334 * xmm2 should be used. 2335 */ 2336 __asm__ __volatile__( 2337 "vpclmulqdq \$0,%%xmm1,%%xmm2,%%xmm3" : : : ); 2338 } while (0) 2339 ]])], [ 2340 ac_have_as_vpclmulqdq=yes 2341 AC_MSG_RESULT([yes]) 2342 ], [ 2343 ac_have_as_vpclmulqdq=no 2344 AC_MSG_RESULT([no]) 2345 ]) 2346 2347 AM_CONDITIONAL(BUILD_VPCLMULQDQ_TESTS, test x$ac_have_as_vpclmulqdq = xyes) 2348 2349 2350 # does the x86/amd64 assembler understand the LZCNT instruction? 2351 # Note, this doesn't generate a C-level symbol. It generates a 2352 # automake-level symbol (BUILD_LZCNT_TESTS), used in test Makefile.am's 2353 AC_MSG_CHECKING([if x86/amd64 assembler supports 'lzcnt']) 2354 2355 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2356 do { 2357 __asm__ __volatile__("lzcnt %%rax,%%rax" : : : "rax"); 2358 } while (0) 2359 ]])], [ 2360 ac_have_as_lzcnt=yes 2361 AC_MSG_RESULT([yes]) 2362 ], [ 2363 ac_have_as_lzcnt=no 2364 AC_MSG_RESULT([no]) 2365 ]) 2366 2367 AM_CONDITIONAL([BUILD_LZCNT_TESTS], [test x$ac_have_as_lzcnt = xyes]) 2368 2369 2370 # does the x86/amd64 assembler understand the LOOPNEL instruction? 2371 # Note, this doesn't generate a C-level symbol. It generates a 2372 # automake-level symbol (BUILD_LOOPNEL_TESTS), used in test Makefile.am's 2373 AC_MSG_CHECKING([if x86/amd64 assembler supports 'loopnel']) 2374 2375 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2376 do { 2377 __asm__ __volatile__("1: loopnel 1b\n"); 2378 } while (0) 2379 ]])], [ 2380 ac_have_as_loopnel=yes 2381 AC_MSG_RESULT([yes]) 2382 ], [ 2383 ac_have_as_loopnel=no 2384 AC_MSG_RESULT([no]) 2385 ]) 2386 2387 AM_CONDITIONAL([BUILD_LOOPNEL_TESTS], [test x$ac_have_as_loopnel = xyes]) 2388 2389 2390 # does the x86/amd64 assembler understand ADDR32 ? 2391 # Note, this doesn't generate a C-level symbol. It generates a 2392 # automake-level symbol (BUILD_ADDR32_TESTS), used in test Makefile.am's 2393 AC_MSG_CHECKING([if x86/amd64 assembler supports 'addr32']) 2394 2395 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2396 do { 2397 asm volatile ("addr32 rep movsb"); 2398 } while (0) 2399 ]])], [ 2400 ac_have_as_addr32=yes 2401 AC_MSG_RESULT([yes]) 2402 ], [ 2403 ac_have_as_addr32=no 2404 AC_MSG_RESULT([no]) 2405 ]) 2406 2407 AM_CONDITIONAL([BUILD_ADDR32_TESTS], [test x$ac_have_as_addr32 = xyes]) 2408 2409 2410 # does the x86/amd64 assembler understand SSE 4.2 instructions? 2411 # Note, this doesn't generate a C-level symbol. It generates a 2412 # automake-level symbol (BUILD_SSE42_TESTS), used in test Makefile.am's 2413 AC_MSG_CHECKING([if x86/amd64 assembler speaks SSE4.2]) 2414 2415 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2416 do { long long int x; 2417 __asm__ __volatile__( 2418 "crc32q %%r15,%%r15" : : : "r15" ); 2419 __asm__ __volatile__( 2420 "pblendvb (%%rcx), %%xmm11" : : : "memory", "xmm11"); 2421 __asm__ __volatile__( 2422 "aesdec %%xmm2, %%xmm1" : : : "xmm2", "xmm1"); } 2423 while (0) 2424 ]])], [ 2425 ac_have_as_sse42=yes 2426 AC_MSG_RESULT([yes]) 2427 ], [ 2428 ac_have_as_sse42=no 2429 AC_MSG_RESULT([no]) 2430 ]) 2431 2432 AM_CONDITIONAL(BUILD_SSE42_TESTS, test x$ac_have_as_sse42 = xyes) 2433 2434 2435 # does the x86/amd64 assembler understand AVX instructions? 2436 # Note, this doesn't generate a C-level symbol. It generates a 2437 # automake-level symbol (BUILD_AVX_TESTS), used in test Makefile.am's 2438 AC_MSG_CHECKING([if x86/amd64 assembler speaks AVX]) 2439 2440 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2441 do { long long int x; 2442 __asm__ __volatile__( 2443 "vmovupd (%%rsp), %%ymm7" : : : "xmm7" ); 2444 __asm__ __volatile__( 2445 "vaddpd %%ymm6,%%ymm7,%%ymm8" : : : "xmm6","xmm7","xmm8"); } 2446 while (0) 2447 ]])], [ 2448 ac_have_as_avx=yes 2449 AC_MSG_RESULT([yes]) 2450 ], [ 2451 ac_have_as_avx=no 2452 AC_MSG_RESULT([no]) 2453 ]) 2454 2455 AM_CONDITIONAL(BUILD_AVX_TESTS, test x$ac_have_as_avx = xyes) 2456 2457 2458 # does the x86/amd64 assembler understand AVX2 instructions? 2459 # Note, this doesn't generate a C-level symbol. It generates a 2460 # automake-level symbol (BUILD_AVX2_TESTS), used in test Makefile.am's 2461 AC_MSG_CHECKING([if x86/amd64 assembler speaks AVX2]) 2462 2463 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2464 do { long long int x; 2465 __asm__ __volatile__( 2466 "vpsravd (%%rsp), %%ymm8, %%ymm7" : : : "xmm7", "xmm8" ); 2467 __asm__ __volatile__( 2468 "vpaddb %%ymm6,%%ymm7,%%ymm8" : : : "xmm6","xmm7","xmm8"); } 2469 while (0) 2470 ]])], [ 2471 ac_have_as_avx2=yes 2472 AC_MSG_RESULT([yes]) 2473 ], [ 2474 ac_have_as_avx2=no 2475 AC_MSG_RESULT([no]) 2476 ]) 2477 2478 AM_CONDITIONAL(BUILD_AVX2_TESTS, test x$ac_have_as_avx2 = xyes) 2479 2480 2481 # does the x86/amd64 assembler understand TSX instructions and 2482 # the XACQUIRE/XRELEASE prefixes? 2483 # Note, this doesn't generate a C-level symbol. It generates a 2484 # automake-level symbol (BUILD_TSX_TESTS), used in test Makefile.am's 2485 AC_MSG_CHECKING([if x86/amd64 assembler speaks TSX]) 2486 2487 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2488 do { 2489 __asm__ __volatile__( 2490 " xbegin Lfoo \n\t" 2491 "Lfoo: xend \n\t" 2492 " xacquire lock incq 0(%rsp) \n\t" 2493 " xrelease lock incq 0(%rsp) \n" 2494 ); 2495 } while (0) 2496 ]])], [ 2497 ac_have_as_tsx=yes 2498 AC_MSG_RESULT([yes]) 2499 ], [ 2500 ac_have_as_tsx=no 2501 AC_MSG_RESULT([no]) 2502 ]) 2503 2504 AM_CONDITIONAL(BUILD_TSX_TESTS, test x$ac_have_as_tsx = xyes) 2505 2506 2507 # does the x86/amd64 assembler understand BMI1 and BMI2 instructions? 2508 # Note, this doesn't generate a C-level symbol. It generates a 2509 # automake-level symbol (BUILD_BMI_TESTS), used in test Makefile.am's 2510 AC_MSG_CHECKING([if x86/amd64 assembler speaks BMI1 and BMI2]) 2511 2512 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2513 do { unsigned int h, l; 2514 __asm__ __volatile__( "mulx %rax,%rcx,%r8" ); 2515 __asm__ __volatile__( 2516 "andn %2, %1, %0" : "=r" (h) : "r" (0x1234567), "r" (0x7654321) ); 2517 __asm__ __volatile__( 2518 "movl %2, %%edx; mulx %3, %1, %0" : "=r" (h), "=r" (l) : "g" (0x1234567), "rm" (0x7654321) : "edx" ); } 2519 while (0) 2520 ]])], [ 2521 ac_have_as_bmi=yes 2522 AC_MSG_RESULT([yes]) 2523 ], [ 2524 ac_have_as_bmi=no 2525 AC_MSG_RESULT([no]) 2526 ]) 2527 2528 AM_CONDITIONAL(BUILD_BMI_TESTS, test x$ac_have_as_bmi = xyes) 2529 2530 2531 # does the x86/amd64 assembler understand FMA instructions? 2532 # Note, this doesn't generate a C-level symbol. It generates a 2533 # automake-level symbol (BUILD_FMA_TESTS), used in test Makefile.am's 2534 AC_MSG_CHECKING([if x86/amd64 assembler speaks FMA]) 2535 2536 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2537 do { unsigned int h, l; 2538 __asm__ __volatile__( 2539 "vfmadd132ps (%%rsp), %%ymm8, %%ymm7" : : : "xmm7", "xmm8" ); 2540 __asm__ __volatile__( 2541 "vfnmsub231sd (%%rsp), %%xmm8, %%xmm7" : : : "xmm7", "xmm8" ); 2542 __asm__ __volatile__( 2543 "vfmsubadd213pd (%%rsp), %%xmm8, %%xmm7" : : : "xmm7", "xmm8" ); } 2544 while (0) 2545 ]])], [ 2546 ac_have_as_fma=yes 2547 AC_MSG_RESULT([yes]) 2548 ], [ 2549 ac_have_as_fma=no 2550 AC_MSG_RESULT([no]) 2551 ]) 2552 2553 AM_CONDITIONAL(BUILD_FMA_TESTS, test x$ac_have_as_fma = xyes) 2554 2555 2556 # does the amd64 assembler understand MPX instructions? 2557 # Note, this doesn't generate a C-level symbol. It generates a 2558 # automake-level symbol (BUILD_MPX_TESTS), used in test Makefile.am's 2559 AC_MSG_CHECKING([if amd64 assembler knows the MPX instructions]) 2560 2561 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2562 do { 2563 asm ("bndmov %bnd0,(%rsp)"); 2564 asm ("bndldx 3(%rbx,%rdx), %bnd2"); 2565 asm ("bnd call foo\n" 2566 bnd jmp end\n" 2567 foo: bnd ret\n" 2568 end: nop"); 2569 } while (0) 2570 ]])], [ 2571 ac_have_as_mpx=yes 2572 AC_MSG_RESULT([yes]) 2573 ], [ 2574 ac_have_as_mpx=no 2575 AC_MSG_RESULT([no]) 2576 ]) 2577 2578 AM_CONDITIONAL(BUILD_MPX_TESTS, test x$ac_have_as_mpx = xyes) 2579 2580 2581 # Does the C compiler support the "ifunc" attribute 2582 # Note, this doesn't generate a C-level symbol. It generates a 2583 # automake-level symbol (BUILD_IFUNC_TESTS), used in test Makefile.am's 2584 # does the x86/amd64 assembler understand MOVBE? 2585 # Note, this doesn't generate a C-level symbol. It generates a 2586 # automake-level symbol (BUILD_MOVBE_TESTS), used in test Makefile.am's 2587 AC_MSG_CHECKING([if x86/amd64 assembler knows the MOVBE insn]) 2588 2589 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ 2590 do { long long int x; 2591 __asm__ __volatile__( 2592 "movbe (%%rsp), %%r15" : : : "memory", "r15" ); } 2593 while (0) 2594 ]])], [ 2595 ac_have_as_movbe=yes 2596 AC_MSG_RESULT([yes]) 2597 ], [ 2598 ac_have_as_movbe=no 2599 AC_MSG_RESULT([no]) 2600 ]) 2601 2602 AM_CONDITIONAL(BUILD_MOVBE_TESTS, test x$ac_have_as_movbe = xyes) 2603 2604 2605 # Does the C compiler support the "ifunc" attribute 2606 # Note, this doesn't generate a C-level symbol. It generates a 2607 # automake-level symbol (BUILD_IFUNC_TESTS), used in test Makefile.am's 2608 AC_MSG_CHECKING([if gcc supports the ifunc attribute]) 2609 2610 AC_LINK_IFELSE([AC_LANG_SOURCE([[ 2611 static void mytest(void) {} 2612 2613 static void (*resolve_test(void))(void) 2614 { 2615 return (void (*)(void))&mytest; 2616 } 2617 2618 void test(void) __attribute__((ifunc("resolve_test"))); 2619 2620 int main() 2621 { 2622 test(); 2623 return 0; 2624 } 2625 ]])], [ 2626 ac_have_ifunc_attr=yes 2627 AC_MSG_RESULT([yes]) 2628 ], [ 2629 ac_have_ifunc_attr=no 2630 AC_MSG_RESULT([no]) 2631 ]) 2632 2633 AM_CONDITIONAL(BUILD_IFUNC_TESTS, test x$ac_have_ifunc_attr = xyes) 2634 2635 2636 # XXX JRS 2010 Oct 13: what is this for? For sure, we don't need this 2637 # when building the tool executables. I think we should get rid of it. 2638 # 2639 # Check for TLS support in the compiler and linker 2640 AC_LINK_IFELSE([AC_LANG_PROGRAM([[static __thread int foo;]], 2641 [[return foo;]])], 2642 [vg_cv_linktime_tls=yes], 2643 [vg_cv_linktime_tls=no]) 2644 # Native compilation: check whether running a program using TLS succeeds. 2645 # Linking only is not sufficient -- e.g. on Red Hat 7.3 linking TLS programs 2646 # succeeds but running programs using TLS fails. 2647 # Cross-compiling: check whether linking a program using TLS succeeds. 2648 AC_CACHE_CHECK([for TLS support], vg_cv_tls, 2649 [AC_ARG_ENABLE(tls, [ --enable-tls platform supports TLS], 2650 [vg_cv_tls=$enableval], 2651 [AC_RUN_IFELSE([AC_LANG_PROGRAM([[static __thread int foo;]], 2652 [[return foo;]])], 2653 [vg_cv_tls=yes], 2654 [vg_cv_tls=no], 2655 [vg_cv_tls=$vg_cv_linktime_tls])])]) 2656 2657 if test "$vg_cv_tls" = yes -a $is_clang != applellvm; then 2658 AC_DEFINE([HAVE_TLS], 1, [can use __thread to define thread-local variables]) 2659 fi 2660 2661 2662 #---------------------------------------------------------------------------- 2663 # Solaris-specific checks. 2664 #---------------------------------------------------------------------------- 2665 2666 if test "$VGCONF_OS" = "solaris" ; then 2667 # Solaris-specific check determining if the Sun Studio Assembler is used to 2668 # build Valgrind. The test checks if the x86/amd64 assembler understands the 2669 # cmovl.l instruction, if yes then it's Sun Assembler. 2670 # 2671 # C-level symbol: none 2672 # Automake-level symbol: SOLARIS_SUN_STUDIO_AS 2673 # 2674 AC_MSG_CHECKING([if x86/amd64 assembler speaks cmovl.l (Solaris-specific)]) 2675 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 2676 ]], [[ 2677 __asm__ __volatile__("cmovl.l %edx, %eax"); 2678 ]])], [ 2679 solaris_have_sun_studio_as=yes 2680 AC_MSG_RESULT([yes]) 2681 ], [ 2682 solaris_have_sun_studio_as=no 2683 AC_MSG_RESULT([no]) 2684 ]) 2685 AM_CONDITIONAL(SOLARIS_SUN_STUDIO_AS, test x$solaris_have_sun_studio_as = xyes) 2686 2687 # Solaris-specific check determining if symbols __xpg4 and __xpg6 2688 # are present in linked elfs when gcc is invoked with -std=gnu99. 2689 # See solaris/vgpreload-solaris.mapfile for details. 2690 # gcc on Solaris instructs linker to include these symbols, 2691 # gcc on illumos does not. 2692 # 2693 # C-level symbol: none 2694 # Automake-level symbol: SOLARIS_XPG_SYMBOLS_PRESENT 2695 # 2696 save_CFLAGS="$CFLAGS" 2697 CFLAGS="$CFLAGS -std=gnu99" 2698 AC_MSG_CHECKING([if xpg symbols are present with -std=gnu99 (Solaris-specific)]) 2699 AC_RUN_IFELSE([AC_LANG_SOURCE([[ 2700 #include <limits.h> 2701 #include <stdio.h> 2702 #include <stdlib.h> 2703 2704 int main(int argc, const char *argv[]) { 2705 char command[PATH_MAX + 50]; 2706 snprintf(command, sizeof(command), "nm %s | egrep '__xpg[4,6]'", argv[0]); 2707 2708 FILE *output = popen(command, "r"); 2709 if (output == NULL) return -1; 2710 2711 char buf[100]; 2712 if (fgets(buf, sizeof(buf), output) != NULL) { 2713 pclose(output); 2714 return 0; 2715 } else { 2716 pclose(output); 2717 return 1; 2718 } 2719 } 2720 ]])], [ 2721 solaris_xpg_symbols_present=yes 2722 AC_MSG_RESULT([yes]) 2723 ], [ 2724 solaris_xpg_symbols_present=no 2725 AC_MSG_RESULT([no]) 2726 ]) 2727 AM_CONDITIONAL(SOLARIS_XPG_SYMBOLS_PRESENT, test x$solaris_xpg_symbols_present = xyes) 2728 CFLAGS="$save_CFLAGS" 2729 2730 2731 # Solaris-specific check determining if /proc/self/cmdline 2732 # or /proc/<pid>/cmdline is supported. 2733 # 2734 # C-level symbol: SOLARIS_PROC_CMDLINE 2735 # Automake-level symbol: SOLARIS_PROC_CMDLINE 2736 # 2737 AC_CHECK_FILE([/proc/self/cmdline], 2738 [ 2739 solaris_proc_cmdline=yes 2740 AC_DEFINE([SOLARIS_PROC_CMDLINE], 1, 2741 [Define to 1 if you have /proc/self/cmdline.]) 2742 ], [ 2743 solaris_proc_cmdline=no 2744 ]) 2745 AM_CONDITIONAL(SOLARIS_PROC_CMDLINE, test x$solaris_proc_cmdline = xyes) 2746 2747 2748 # Solaris-specific check determining default platform for the Valgrind launcher. 2749 # Used in case the launcher cannot select platform by looking at the client 2750 # image (for example because the executable is a shell script). 2751 # 2752 # C-level symbol: SOLARIS_LAUNCHER_DEFAULT_PLATFORM 2753 # Automake-level symbol: none 2754 # 2755 AC_MSG_CHECKING([for default platform of Valgrind launcher (Solaris-specific)]) 2756 # Get the ELF class of /bin/sh first. 2757 if ! test -f /bin/sh; then 2758 AC_MSG_ERROR([Shell interpreter `/bin/sh' not found.]) 2759 fi 2760 elf_class=$( /usr/bin/file /bin/sh | sed -n 's/.*ELF \(..\)-bit.*/\1/p' ) 2761 case "$elf_class" in 2762 64) 2763 default_arch="$VGCONF_ARCH_PRI"; 2764 ;; 2765 32) 2766 if test "x$VGCONF_ARCH_SEC" != "x"; then 2767 default_arch="$VGCONF_ARCH_SEC" 2768 else 2769 default_arch="$VGCONF_ARCH_PRI"; 2770 fi 2771 ;; 2772 *) 2773 AC_MSG_ERROR([Cannot determine ELF class of `/bin/sh'.]) 2774 ;; 2775 esac 2776 default_platform="$default_arch-$VGCONF_OS" 2777 AC_MSG_RESULT([$default_platform]) 2778 AC_DEFINE_UNQUOTED([SOLARIS_LAUNCHER_DEFAULT_PLATFORM], ["$default_platform"], 2779 [Default platform for Valgrind launcher.]) 2780 2781 2782 # Solaris-specific check determining if the old syscalls are available. 2783 # 2784 # C-level symbol: SOLARIS_OLD_SYSCALLS 2785 # Automake-level symbol: SOLARIS_OLD_SYSCALLS 2786 # 2787 AC_MSG_CHECKING([for the old Solaris syscalls (Solaris-specific)]) 2788 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 2789 #include <sys/syscall.h> 2790 ]], [[ 2791 return !SYS_open; 2792 ]])], [ 2793 solaris_old_syscalls=yes 2794 AC_MSG_RESULT([yes]) 2795 AC_DEFINE([SOLARIS_OLD_SYSCALLS], 1, 2796 [Define to 1 if you have the old Solaris syscalls.]) 2797 ], [ 2798 solaris_old_syscalls=no 2799 AC_MSG_RESULT([no]) 2800 ]) 2801 AM_CONDITIONAL(SOLARIS_OLD_SYSCALLS, test x$solaris_old_syscalls = xyes) 2802 2803 2804 # Solaris-specific check determining if the new accept() syscall is available. 2805 # 2806 # Old syscall: 2807 # int accept(int sock, struct sockaddr *name, socklen_t *namelenp, 2808 # int version); 2809 # 2810 # New syscall (available on illumos): 2811 # int accept(int sock, struct sockaddr *name, socklen_t *namelenp, 2812 # int version, int flags); 2813 # 2814 # If the old syscall is present then the following syscall will fail with 2815 # ENOTSOCK (because file descriptor 0 is not a socket), if the new syscall is 2816 # available then it will fail with EINVAL (because the flags parameter is 2817 # invalid). 2818 # 2819 # C-level symbol: SOLARIS_NEW_ACCEPT_SYSCALL 2820 # Automake-level symbol: none 2821 # 2822 AC_MSG_CHECKING([for the new `accept' syscall (Solaris-specific)]) 2823 AC_RUN_IFELSE([AC_LANG_PROGRAM([[ 2824 #include <sys/syscall.h> 2825 #include <errno.h> 2826 ]], [[ 2827 errno = 0; 2828 syscall(SYS_accept, 0, 0, 0, 0, -1); 2829 return !(errno == EINVAL); 2830 ]])], [ 2831 AC_MSG_RESULT([yes]) 2832 AC_DEFINE([SOLARIS_NEW_ACCEPT_SYSCALL], 1, 2833 [Define to 1 if you have the new `accept' syscall.]) 2834 ], [ 2835 AC_MSG_RESULT([no]) 2836 ]) 2837 2838 2839 # Solaris-specific check determining if the new illumos pipe() syscall is 2840 # available. 2841 # 2842 # Old syscall: 2843 # longlong_t pipe(); 2844 # 2845 # New syscall (available on illumos): 2846 # int pipe(intptr_t arg, int flags); 2847 # 2848 # If the old syscall is present then the following call will succeed, if the 2849 # new syscall is available then it will fail with EFAULT (because address 0 2850 # cannot be accessed). 2851 # 2852 # C-level symbol: SOLARIS_NEW_PIPE_SYSCALL 2853 # Automake-level symbol: none 2854 # 2855 AC_MSG_CHECKING([for the new `pipe' syscall (Solaris-specific)]) 2856 AC_RUN_IFELSE([AC_LANG_PROGRAM([[ 2857 #include <sys/syscall.h> 2858 #include <errno.h> 2859 ]], [[ 2860 errno = 0; 2861 syscall(SYS_pipe, 0, 0); 2862 return !(errno == EFAULT); 2863 ]])], [ 2864 AC_MSG_RESULT([yes]) 2865 AC_DEFINE([SOLARIS_NEW_PIPE_SYSCALL], 1, 2866 [Define to 1 if you have the new `pipe' syscall.]) 2867 ], [ 2868 AC_MSG_RESULT([no]) 2869 ]) 2870 2871 2872 # Solaris-specific check determining if the new lwp_sigqueue() syscall is 2873 # available. 2874 # 2875 # Old syscall: 2876 # int lwp_kill(id_t lwpid, int sig); 2877 # 2878 # New syscall (available on Solaris 11): 2879 # int lwp_sigqueue(id_t lwpid, int sig, void *value, 2880 # int si_code, timespec_t *timeout); 2881 # 2882 # C-level symbol: SOLARIS_LWP_SIGQUEUE_SYSCALL 2883 # Automake-level symbol: SOLARIS_LWP_SIGQUEUE_SYSCALL 2884 # 2885 AC_MSG_CHECKING([for the new `lwp_sigqueue' syscall (Solaris-specific)]) 2886 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 2887 #include <sys/syscall.h> 2888 ]], [[ 2889 return !SYS_lwp_sigqueue; 2890 ]])], [ 2891 solaris_lwp_sigqueue_syscall=yes 2892 AC_MSG_RESULT([yes]) 2893 AC_DEFINE([SOLARIS_LWP_SIGQUEUE_SYSCALL], 1, 2894 [Define to 1 if you have the new `lwp_sigqueue' syscall.]) 2895 ], [ 2896 solaris_lwp_sigqueue_syscall=no 2897 AC_MSG_RESULT([no]) 2898 ]) 2899 AM_CONDITIONAL(SOLARIS_LWP_SIGQUEUE_SYSCALL, test x$solaris_lwp_sigqueue_syscall = xyes) 2900 2901 2902 # Solaris-specific check determining if the lwp_sigqueue() syscall 2903 # takes both pid and thread id arguments or just thread id. 2904 # 2905 # Old syscall (available on Solaris 11.x): 2906 # int lwp_sigqueue(id_t lwpid, int sig, void *value, 2907 # int si_code, timespec_t *timeout); 2908 # 2909 # New syscall (available on Solaris 12): 2910 # int lwp_sigqueue(pid_t pid, id_t lwpid, int sig, void *value, 2911 # int si_code, timespec_t *timeout); 2912 # 2913 # If the old syscall is present then the following syscall will fail with 2914 # EINVAL (because signal is out of range); if the new syscall is available 2915 # then it will fail with ESRCH (because it would not find such thread in the 2916 # current process). 2917 # 2918 # C-level symbol: SOLARIS_LWP_SIGQUEUE_SYSCALL_TAKES_PID 2919 # Automake-level symbol: SOLARIS_LWP_SIGQUEUE_SYSCALL_TAKES_PID 2920 # 2921 AM_COND_IF(SOLARIS_LWP_SIGQUEUE_SYSCALL, 2922 AC_MSG_CHECKING([if the `lwp_sigqueue' syscall accepts pid (Solaris-specific)]) 2923 AC_RUN_IFELSE([AC_LANG_PROGRAM([[ 2924 #include <sys/syscall.h> 2925 #include <errno.h> 2926 ]], [[ 2927 errno = 0; 2928 syscall(SYS_lwp_sigqueue, 0, 101, 0, 0, 0, 0); 2929 return !(errno == ESRCH); 2930 ]])], [ 2931 solaris_lwp_sigqueue_syscall_takes_pid=yes 2932 AC_MSG_RESULT([yes]) 2933 AC_DEFINE([SOLARIS_LWP_SIGQUEUE_SYSCALL_TAKES_PID], 1, 2934 [Define to 1 if you have the new `lwp_sigqueue' syscall which accepts pid.]) 2935 ], [ 2936 solaris_lwp_sigqueue_syscall_takes_pid=no 2937 AC_MSG_RESULT([no]) 2938 ]) 2939 AM_CONDITIONAL(SOLARIS_LWP_SIGQUEUE_SYSCALL_TAKES_PID, 2940 test x$solaris_lwp_sigqueue_syscall_takes_pid = xyes) 2941 , 2942 AM_CONDITIONAL(SOLARIS_LWP_SIGQUEUE_SYSCALL_TAKES_PID, test x = y) 2943 ) 2944 2945 2946 # Solaris-specific check determining if the new lwp_name() syscall is 2947 # available. 2948 # 2949 # New syscall (available on Solaris 11): 2950 # int lwp_name(int opcode, id_t lwpid, char *name, size_t len); 2951 # 2952 # C-level symbol: SOLARIS_LWP_NAME_SYSCALL 2953 # Automake-level symbol: SOLARIS_LWP_NAME_SYSCALL 2954 # 2955 AC_MSG_CHECKING([for the new `lwp_name' syscall (Solaris-specific)]) 2956 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 2957 #include <sys/syscall.h> 2958 ]], [[ 2959 return !SYS_lwp_name; 2960 ]])], [ 2961 solaris_lwp_name_syscall=yes 2962 AC_MSG_RESULT([yes]) 2963 AC_DEFINE([SOLARIS_LWP_NAME_SYSCALL], 1, 2964 [Define to 1 if you have the new `lwp_name' syscall.]) 2965 ], [ 2966 solaris_lwp_name_syscall=no 2967 AC_MSG_RESULT([no]) 2968 ]) 2969 AM_CONDITIONAL(SOLARIS_LWP_NAME_SYSCALL, test x$solaris_lwp_name_syscall = xyes) 2970 2971 2972 # Solaris-specific check determining if the new zone() syscall subcodes 2973 # ZONE_LIST_DEFUNCT and ZONE_GETATTR_DEFUNCT are available. These subcodes 2974 # were added in Solaris 11 but are missing on illumos. 2975 # 2976 # C-level symbol: SOLARIS_ZONE_DEFUNCT 2977 # Automake-level symbol: SOLARIS_ZONE_DEFUNCT 2978 # 2979 AC_MSG_CHECKING([for ZONE_LIST_DEFUNCT and ZONE_GETATTR_DEFUNCT (Solaris-specific)]) 2980 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 2981 #include <sys/zone.h> 2982 ]], [[ 2983 return !(ZONE_LIST_DEFUNCT && ZONE_GETATTR_DEFUNCT); 2984 ]])], [ 2985 solaris_zone_defunct=yes 2986 AC_MSG_RESULT([yes]) 2987 AC_DEFINE([SOLARIS_ZONE_DEFUNCT], 1, 2988 [Define to 1 if you have the `ZONE_LIST_DEFUNCT' and `ZONE_GETATTR_DEFUNC' constants.]) 2989 ], [ 2990 solaris_zone_defunct=no 2991 AC_MSG_RESULT([no]) 2992 ]) 2993 AM_CONDITIONAL(SOLARIS_ZONE_DEFUNCT, test x$solaris_zone_defunct = xyes) 2994 2995 2996 # Solaris-specific check determining if the new shmsys() syscall subcodes 2997 # IPC_XSTAT64, SHMADV, SHM_ADV_GET, SHM_ADV_SET and SHMGET_OSM are available. 2998 # These subcodes were added in Solaris 11 but are missing on illumos. 2999 # 3000 # C-level symbol: SOLARIS_SHM_NEW 3001 # Automake-level symbol: SOLARIS_SHM_NEW 3002 # 3003 AC_MSG_CHECKING([for SHMADV, SHM_ADV_GET, SHM_ADV_SET and SHMGET_OSM (Solaris-specific)]) 3004 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3005 #include <sys/ipc_impl.h> 3006 #include <sys/shm.h> 3007 #include <sys/shm_impl.h> 3008 ]], [[ 3009 return !(IPC_XSTAT64 && SHMADV && SHM_ADV_GET && SHM_ADV_SET && SHMGET_OSM); 3010 ]])], [ 3011 solaris_shm_new=yes 3012 AC_MSG_RESULT([yes]) 3013 AC_DEFINE([SOLARIS_SHM_NEW], 1, 3014 [Define to 1 if you have the `IPC_XSTAT64', `SHMADV', `SHM_ADV_GET', `SHM_ADV_SET' and `SHMGET_OSM' constants.]) 3015 ], [ 3016 solaris_shm_new=no 3017 AC_MSG_RESULT([no]) 3018 ]) 3019 AM_CONDITIONAL(SOLARIS_SHM_NEW, test x$solaris_shm_new = xyes) 3020 3021 3022 # Solaris-specific check determining if prxregset_t is available. Illumos 3023 # currently does not define it on the x86 platform. 3024 # 3025 # C-level symbol: SOLARIS_PRXREGSET_T 3026 # Automake-level symbol: SOLARIS_PRXREGSET_T 3027 # 3028 AC_MSG_CHECKING([for the `prxregset_t' type (Solaris-specific)]) 3029 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3030 #include <sys/procfs_isa.h> 3031 ]], [[ 3032 return !sizeof(prxregset_t); 3033 ]])], [ 3034 solaris_prxregset_t=yes 3035 AC_MSG_RESULT([yes]) 3036 AC_DEFINE([SOLARIS_PRXREGSET_T], 1, 3037 [Define to 1 if you have the `prxregset_t' type.]) 3038 ], [ 3039 solaris_prxregset_t=no 3040 AC_MSG_RESULT([no]) 3041 ]) 3042 AM_CONDITIONAL(SOLARIS_PRXREGSET_T, test x$solaris_prxregset_t = xyes) 3043 3044 3045 # Solaris-specific check determining if the new frealpathat() syscall is 3046 # available. 3047 # 3048 # New syscall (available on Solaris 11.1): 3049 # int frealpathat(int fd, char *path, char *buf, size_t buflen); 3050 # 3051 # C-level symbol: SOLARIS_FREALPATHAT_SYSCALL 3052 # Automake-level symbol: SOLARIS_FREALPATHAT_SYSCALL 3053 # 3054 AC_MSG_CHECKING([for the new `frealpathat' syscall (Solaris-specific)]) 3055 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3056 #include <sys/syscall.h> 3057 ]], [[ 3058 return !SYS_frealpathat; 3059 ]])], [ 3060 solaris_frealpathat_syscall=yes 3061 AC_MSG_RESULT([yes]) 3062 AC_DEFINE([SOLARIS_FREALPATHAT_SYSCALL], 1, 3063 [Define to 1 if you have the new `frealpathat' syscall.]) 3064 ], [ 3065 solaris_frealpathat_syscall=no 3066 AC_MSG_RESULT([no]) 3067 ]) 3068 AM_CONDITIONAL(SOLARIS_FREALPATHAT_SYSCALL, test x$solaris_frealpathat_syscall = xyes) 3069 3070 3071 # Solaris-specific check determining if the new uuidsys() syscall is 3072 # available. 3073 # 3074 # New syscall (available on newer Solaris): 3075 # int uuidsys(struct uuid *uuid); 3076 # 3077 # C-level symbol: SOLARIS_UUIDSYS_SYSCALL 3078 # Automake-level symbol: SOLARIS_UUIDSYS_SYSCALL 3079 # 3080 AC_MSG_CHECKING([for the new `uuidsys' syscall (Solaris-specific)]) 3081 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3082 #include <sys/syscall.h> 3083 ]], [[ 3084 return !SYS_uuidsys; 3085 ]])], [ 3086 solaris_uuidsys_syscall=yes 3087 AC_MSG_RESULT([yes]) 3088 AC_DEFINE([SOLARIS_UUIDSYS_SYSCALL], 1, 3089 [Define to 1 if you have the new `uuidsys' syscall.]) 3090 ], [ 3091 solaris_uuidsys_syscall=no 3092 AC_MSG_RESULT([no]) 3093 ]) 3094 AM_CONDITIONAL(SOLARIS_UUIDSYS_SYSCALL, test x$solaris_uuidsys_syscall = xyes) 3095 3096 3097 # Solaris-specific check determining if the new labelsys() syscall subcode 3098 # TNDB_GET_TNIP is available. This subcode was added in Solaris 11 but is 3099 # missing on illumos. 3100 # 3101 # C-level symbol: SOLARIS_TNDB_GET_TNIP 3102 # Automake-level symbol: SOLARIS_TNDB_GET_TNIP 3103 # 3104 AC_MSG_CHECKING([for TNDB_GET_TNIP (Solaris-specific)]) 3105 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3106 #include <sys/tsol/tndb.h> 3107 ]], [[ 3108 return !TNDB_GET_TNIP; 3109 ]])], [ 3110 solaris_tndb_get_tnip=yes 3111 AC_MSG_RESULT([yes]) 3112 AC_DEFINE([SOLARIS_TNDB_GET_TNIP], 1, 3113 [Define to 1 if you have the `TNDB_GET_TNIP' constant.]) 3114 ], [ 3115 solaris_tndb_get_tnip=no 3116 AC_MSG_RESULT([no]) 3117 ]) 3118 AM_CONDITIONAL(SOLARIS_TNDB_GET_TNIP, test x$solaris_tndb_get_tnip = xyes) 3119 3120 3121 # Solaris-specific check determining if the new labelsys() syscall opcodes 3122 # TSOL_GETCLEARANCE and TSOL_SETCLEARANCE are available. These opcodes were 3123 # added in Solaris 11 but are missing on illumos. 3124 # 3125 # C-level symbol: SOLARIS_TSOL_CLEARANCE 3126 # Automake-level symbol: SOLARIS_TSOL_CLEARANCE 3127 # 3128 AC_MSG_CHECKING([for TSOL_GETCLEARANCE and TSOL_SETCLEARANCE (Solaris-specific)]) 3129 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3130 #include <sys/tsol/tsyscall.h> 3131 ]], [[ 3132 return !(TSOL_GETCLEARANCE && TSOL_SETCLEARANCE); 3133 ]])], [ 3134 solaris_tsol_clearance=yes 3135 AC_MSG_RESULT([yes]) 3136 AC_DEFINE([SOLARIS_TSOL_CLEARANCE], 1, 3137 [Define to 1 if you have the `TSOL_GETCLEARANCE' and `TSOL_SETCLEARANCE' constants.]) 3138 ], [ 3139 solaris_tsol_clearance=no 3140 AC_MSG_RESULT([no]) 3141 ]) 3142 AM_CONDITIONAL(SOLARIS_TSOL_CLEARANCE, test x$solaris_tsol_clearance = xyes) 3143 3144 3145 # Solaris-specific check determining if the new pset() syscall subcode 3146 # PSET_GET_NAME is available. This subcode was added in Solaris 12 but 3147 # is missing on illumos and Solaris 11. 3148 # 3149 # C-level symbol: SOLARIS_PSET_GET_NAME 3150 # Automake-level symbol: SOLARIS_PSET_GET_NAME 3151 # 3152 AC_MSG_CHECKING([for PSET_GET_NAME (Solaris-specific)]) 3153 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3154 #include <sys/pset.h> 3155 ]], [[ 3156 return !(PSET_GET_NAME); 3157 ]])], [ 3158 solaris_pset_get_name=yes 3159 AC_MSG_RESULT([yes]) 3160 AC_DEFINE([SOLARIS_PSET_GET_NAME], 1, 3161 [Define to 1 if you have the `PSET_GET_NAME' constants.]) 3162 ], [ 3163 solaris_pset_get_name=no 3164 AC_MSG_RESULT([no]) 3165 ]) 3166 AM_CONDITIONAL(SOLARIS_PSET_GET_NAME, test x$solaris_pset_get_name = xyes) 3167 3168 3169 # Solaris-specific check determining if the utimesys() syscall is 3170 # available (on illumos and older Solaris). 3171 # 3172 # C-level symbol: SOLARIS_UTIMESYS_SYSCALL 3173 # Automake-level symbol: SOLARIS_UTIMESYS_SYSCALL 3174 # 3175 AC_MSG_CHECKING([for the `utimesys' syscall (Solaris-specific)]) 3176 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3177 #include <sys/syscall.h> 3178 ]], [[ 3179 return !SYS_utimesys; 3180 ]])], [ 3181 solaris_utimesys_syscall=yes 3182 AC_MSG_RESULT([yes]) 3183 AC_DEFINE([SOLARIS_UTIMESYS_SYSCALL], 1, 3184 [Define to 1 if you have the `utimesys' syscall.]) 3185 ], [ 3186 solaris_utimesys_syscall=no 3187 AC_MSG_RESULT([no]) 3188 ]) 3189 AM_CONDITIONAL(SOLARIS_UTIMESYS_SYSCALL, test x$solaris_utimesys_syscall = xyes) 3190 3191 3192 # Solaris-specific check determining if the utimensat() syscall is 3193 # available (on newer Solaris). 3194 # 3195 # C-level symbol: SOLARIS_UTIMENSAT_SYSCALL 3196 # Automake-level symbol: SOLARIS_UTIMENSAT_SYSCALL 3197 # 3198 AC_MSG_CHECKING([for the `utimensat' syscall (Solaris-specific)]) 3199 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3200 #include <sys/syscall.h> 3201 ]], [[ 3202 return !SYS_utimensat; 3203 ]])], [ 3204 solaris_utimensat_syscall=yes 3205 AC_MSG_RESULT([yes]) 3206 AC_DEFINE([SOLARIS_UTIMENSAT_SYSCALL], 1, 3207 [Define to 1 if you have the `utimensat' syscall.]) 3208 ], [ 3209 solaris_utimensat_syscall=no 3210 AC_MSG_RESULT([no]) 3211 ]) 3212 AM_CONDITIONAL(SOLARIS_UTIMENSAT_SYSCALL, test x$solaris_utimensat_syscall = xyes) 3213 3214 3215 # Solaris-specific check determining if the spawn() syscall is available 3216 # (on newer Solaris). 3217 # 3218 # C-level symbol: SOLARIS_SPAWN_SYSCALL 3219 # Automake-level symbol: SOLARIS_SPAWN_SYSCALL 3220 # 3221 AC_MSG_CHECKING([for the `spawn' syscall (Solaris-specific)]) 3222 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3223 #include <sys/syscall.h> 3224 ]], [[ 3225 return !SYS_spawn; 3226 ]])], [ 3227 solaris_spawn_syscall=yes 3228 AC_MSG_RESULT([yes]) 3229 AC_DEFINE([SOLARIS_SPAWN_SYSCALL], 1, 3230 [Define to 1 if you have the `spawn' syscall.]) 3231 ], [ 3232 solaris_spawn_syscall=no 3233 AC_MSG_RESULT([no]) 3234 ]) 3235 AM_CONDITIONAL(SOLARIS_SPAWN_SYSCALL, test x$solaris_spawn_syscall = xyes) 3236 3237 3238 # Solaris-specific check determining whether nscd (name switch cache daemon) 3239 # attaches its door at /system/volatile/name_service_door (Solaris) 3240 # or at /var/run/name_service_door (illumos). 3241 # 3242 # Note that /var/run is a symlink to /system/volatile on Solaris 3243 # but not vice versa on illumos. 3244 # 3245 # C-level symbol: SOLARIS_NSCD_DOOR_SYSTEM_VOLATILE 3246 # Automake-level symbol: SOLARIS_NSCD_DOOR_SYSTEM_VOLATILE 3247 # 3248 AC_MSG_CHECKING([for nscd door location (Solaris-specific)]) 3249 if test -e /system/volatile/name_service_door; then 3250 solaris_nscd_door_system_volatile=yes 3251 AC_MSG_RESULT([/system/volatile/name_service_door]) 3252 AC_DEFINE([SOLARIS_NSCD_DOOR_SYSTEM_VOLATILE], 1, 3253 [Define to 1 if nscd attaches to /system/volatile/name_service_door.]) 3254 else 3255 solaris_nscd_door_system_volatile=no 3256 AC_MSG_RESULT([/var/run/name_service_door]) 3257 fi 3258 AM_CONDITIONAL(SOLARIS_NSCD_DOOR_SYSTEM_VOLATILE, test x$solaris_nscd_door_system_volatile = xyes) 3259 3260 3261 # Solaris-specific check determining if the new gethrt() fasttrap is available. 3262 # 3263 # New fasttrap (available on Solaris 11): 3264 # hrt_t *gethrt(void); 3265 # 3266 # C-level symbol: SOLARIS_GETHRT_FASTTRAP 3267 # Automake-level symbol: SOLARIS_GETHRT_FASTTRAP 3268 # 3269 AC_MSG_CHECKING([for the new `gethrt' fasttrap (Solaris-specific)]) 3270 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3271 #include <sys/trap.h> 3272 ]], [[ 3273 return !T_GETHRT; 3274 ]])], [ 3275 solaris_gethrt_fasttrap=yes 3276 AC_MSG_RESULT([yes]) 3277 AC_DEFINE([SOLARIS_GETHRT_FASTTRAP], 1, 3278 [Define to 1 if you have the new `gethrt' fasttrap.]) 3279 ], [ 3280 solaris_gethrt_fasttrap=no 3281 AC_MSG_RESULT([no]) 3282 ]) 3283 AM_CONDITIONAL(SOLARIS_GETHRT_FASTTRAP, test x$solaris_gethrt_fasttrap = xyes) 3284 3285 3286 # Solaris-specific check determining if the new get_zone_offset() fasttrap 3287 # is available. 3288 # 3289 # New fasttrap (available on Solaris 11): 3290 # zonehrtoffset_t *get_zone_offset(void); 3291 # 3292 # C-level symbol: SOLARIS_GETZONEOFFSET_FASTTRAP 3293 # Automake-level symbol: SOLARIS_GETZONEOFFSET_FASTTRAP 3294 # 3295 AC_MSG_CHECKING([for the new `get_zone_offset' fasttrap (Solaris-specific)]) 3296 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3297 #include <sys/trap.h> 3298 ]], [[ 3299 return !T_GETZONEOFFSET; 3300 ]])], [ 3301 solaris_getzoneoffset_fasttrap=yes 3302 AC_MSG_RESULT([yes]) 3303 AC_DEFINE([SOLARIS_GETZONEOFFSET_FASTTRAP], 1, 3304 [Define to 1 if you have the new `get_zone_offset' fasttrap.]) 3305 ], [ 3306 solaris_getzoneoffset_fasttrap=no 3307 AC_MSG_RESULT([no]) 3308 ]) 3309 AM_CONDITIONAL(SOLARIS_GETZONEOFFSET_FASTTRAP, test x$solaris_getzoneoffset_fasttrap = xyes) 3310 3311 3312 # Solaris-specific check determining if the execve() syscall 3313 # takes fourth argument (flags) or not. 3314 # 3315 # Old syscall (available on illumos): 3316 # int execve(const char *fname, const char **argv, const char **envp); 3317 # 3318 # New syscall (available on Solaris): 3319 # int execve(uintptr_t file, const char **argv, const char **envp, int flags); 3320 # 3321 # If the new syscall is present then it will fail with EINVAL (because flags 3322 # are invalid); if the old syscall is available then it will fail with ENOENT 3323 # (because the file could not be found). 3324 # 3325 # C-level symbol: SOLARIS_EXECVE_SYSCALL_TAKES_FLAGS 3326 # Automake-level symbol: SOLARIS_EXECVE_SYSCALL_TAKES_FLAGS 3327 # 3328 AC_MSG_CHECKING([if the `execve' syscall accepts flags (Solaris-specific)]) 3329 AC_RUN_IFELSE([AC_LANG_PROGRAM([[ 3330 #include <sys/syscall.h> 3331 #include <errno.h> 3332 ]], [[ 3333 errno = 0; 3334 syscall(SYS_execve, "/no/existing/path", 0, 0, 0xdeadbeef, 0, 0); 3335 return !(errno == EINVAL); 3336 ]])], [ 3337 solaris_execve_syscall_takes_flags=yes 3338 AC_MSG_RESULT([yes]) 3339 AC_DEFINE([SOLARIS_EXECVE_SYSCALL_TAKES_FLAGS], 1, 3340 [Define to 1 if you have the new `execve' syscall which accepts flags.]) 3341 ], [ 3342 solaris_execve_syscall_takes_flags=no 3343 AC_MSG_RESULT([no]) 3344 ]) 3345 AM_CONDITIONAL(SOLARIS_EXECVE_SYSCALL_TAKES_FLAGS, 3346 test x$solaris_execve_syscall_takes_flags = xyes) 3347 3348 3349 # Solaris-specific check determining version of the repository cache protocol. 3350 # Every Solaris version uses a different one, ranging from 21 to current 25. 3351 # The check is very ugly, though. 3352 # 3353 # C-level symbol: SOLARIS_REPCACHE_PROTOCOL_VERSION vv 3354 # Automake-level symbol: none 3355 # 3356 AC_PATH_PROG(DIS_PATH, dis, false) 3357 if test "x$DIS_PATH" = "xfalse"; then 3358 AC_MSG_FAILURE([Object code disassembler (`dis') not found.]) 3359 fi 3360 AC_CHECK_LIB(scf, scf_handle_bind, [], [ 3361 AC_MSG_WARN([Function `scf_handle_bind' was not found in `libscf'.]) 3362 AC_MSG_ERROR([Cannot determine version of the repository cache protocol.]) 3363 ]) 3364 3365 AC_MSG_CHECKING([for version of the repository cache protocol (Solaris-specific)]) 3366 if test "X$VGCONF_ARCH_PRI" = "Xamd64"; then 3367 libscf=/usr/lib/64/libscf.so.1 3368 else 3369 libscf=/usr/lib/libscf.so.1 3370 fi 3371 if ! $DIS_PATH -F scf_handle_bind $libscf | grep -q 0x526570; then 3372 AC_MSG_WARN([Function `scf_handle_bind' does not contain repository cache protocol version.]) 3373 AC_MSG_ERROR([Cannot determine version of the repository cache protocol.]) 3374 fi 3375 hex=$( $DIS_PATH -F scf_handle_bind $libscf | sed -n 's/.*0x526570\(..\).*/\1/p' ) 3376 if test -z "$hex"; then 3377 AC_MSG_WARN([Version of the repository cache protocol is empty?!]) 3378 AC_MSG_ERROR([Cannot determine version of the repository cache protocol.]) 3379 fi 3380 version=$( printf "%d\n" 0x$hex ) 3381 AC_MSG_RESULT([$version]) 3382 AC_DEFINE_UNQUOTED([SOLARIS_REPCACHE_PROTOCOL_VERSION], [$version], 3383 [Version number of the repository door cache protocol.]) 3384 3385 3386 # Solaris-specific check determining if "sysstat" segment reservation type 3387 # is available. 3388 # 3389 # New "sysstat" segment reservation (available on Solaris 12): 3390 # - program header type: PT_SUNW_SYSSTAT 3391 # - auxiliary vector entry: AT_SUN_SYSSTAT_ADDR 3392 # 3393 # C-level symbol: SOLARIS_RESERVE_SYSSTAT_ADDR 3394 # Automake-level symbol: SOLARIS_RESERVE_SYSSTAT_ADDR 3395 # 3396 AC_MSG_CHECKING([for the new `sysstat' segment reservation (Solaris-specific)]) 3397 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3398 #include <sys/auxv.h> 3399 ]], [[ 3400 return !AT_SUN_SYSSTAT_ADDR; 3401 ]])], [ 3402 solaris_reserve_sysstat_addr=yes 3403 AC_MSG_RESULT([yes]) 3404 AC_DEFINE([SOLARIS_RESERVE_SYSSTAT_ADDR], 1, 3405 [Define to 1 if you have the new `sysstat' segment reservation.]) 3406 ], [ 3407 solaris_reserve_sysstat_addr=no 3408 AC_MSG_RESULT([no]) 3409 ]) 3410 AM_CONDITIONAL(SOLARIS_RESERVE_SYSSTAT_ADDR, test x$solaris_reserve_sysstat_addr = xyes) 3411 3412 3413 # Solaris-specific check determining if "sysstat_zone" segment reservation type 3414 # is available. 3415 # 3416 # New "sysstat_zone" segment reservation (available on Solaris 12): 3417 # - program header type: PT_SUNW_SYSSTAT_ZONE 3418 # - auxiliary vector entry: AT_SUN_SYSSTAT_ZONE_ADDR 3419 # 3420 # C-level symbol: SOLARIS_RESERVE_SYSSTAT_ZONE_ADDR 3421 # Automake-level symbol: SOLARIS_RESERVE_SYSSTAT_ZONE_ADDR 3422 # 3423 AC_MSG_CHECKING([for the new `sysstat_zone' segment reservation (Solaris-specific)]) 3424 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3425 #include <sys/auxv.h> 3426 ]], [[ 3427 return !AT_SUN_SYSSTAT_ZONE_ADDR; 3428 ]])], [ 3429 solaris_reserve_sysstat_zone_addr=yes 3430 AC_MSG_RESULT([yes]) 3431 AC_DEFINE([SOLARIS_RESERVE_SYSSTAT_ZONE_ADDR], 1, 3432 [Define to 1 if you have the new `sysstat_zone' segment reservation.]) 3433 ], [ 3434 solaris_reserve_sysstat_zone_addr=no 3435 AC_MSG_RESULT([no]) 3436 ]) 3437 AM_CONDITIONAL(SOLARIS_RESERVE_SYSSTAT_ZONE_ADDR, test x$solaris_reserve_sysstat_zone_addr = xyes) 3438 3439 3440 # Solaris-specific check determining if the system_stats() syscall is available 3441 # (on newer Solaris). 3442 # 3443 # C-level symbol: SOLARIS_SYSTEM_STATS_SYSCALL 3444 # Automake-level symbol: SOLARIS_SYSTEM_STATS_SYSCALL 3445 # 3446 AC_MSG_CHECKING([for the `system_stats' syscall (Solaris-specific)]) 3447 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3448 #include <sys/syscall.h> 3449 ]], [[ 3450 return !SYS_system_stats; 3451 ]])], [ 3452 solaris_system_stats_syscall=yes 3453 AC_MSG_RESULT([yes]) 3454 AC_DEFINE([SOLARIS_SYSTEM_STATS_SYSCALL], 1, 3455 [Define to 1 if you have the `system_stats' syscall.]) 3456 ], [ 3457 solaris_system_stats_syscall=no 3458 AC_MSG_RESULT([no]) 3459 ]) 3460 AM_CONDITIONAL(SOLARIS_SYSTEM_STATS_SYSCALL, test x$solaris_system_stats_syscall = xyes) 3461 3462 else 3463 AM_CONDITIONAL(SOLARIS_SUN_STUDIO_AS, false) 3464 AM_CONDITIONAL(SOLARIS_XPG_SYMBOLS_PRESENT, false) 3465 AM_CONDITIONAL(SOLARIS_PROC_CMDLINE, false) 3466 AM_CONDITIONAL(SOLARIS_OLD_SYSCALLS, false) 3467 AM_CONDITIONAL(SOLARIS_LWP_SIGQUEUE_SYSCALL, false) 3468 AM_CONDITIONAL(SOLARIS_LWP_SIGQUEUE_SYSCALL_TAKES_PID, false) 3469 AM_CONDITIONAL(SOLARIS_LWP_NAME_SYSCALL, false) 3470 AM_CONDITIONAL(SOLARIS_ZONE_DEFUNCT, false) 3471 AM_CONDITIONAL(SOLARIS_SHM_NEW, false) 3472 AM_CONDITIONAL(SOLARIS_PRXREGSET_T, false) 3473 AM_CONDITIONAL(SOLARIS_FREALPATHAT_SYSCALL, false) 3474 AM_CONDITIONAL(SOLARIS_UUIDSYS_SYSCALL, false) 3475 AM_CONDITIONAL(SOLARIS_TNDB_GET_TNIP, false) 3476 AM_CONDITIONAL(SOLARIS_TSOL_CLEARANCE, false) 3477 AM_CONDITIONAL(SOLARIS_PSET_GET_NAME, false) 3478 AM_CONDITIONAL(SOLARIS_UTIMESYS_SYSCALL, false) 3479 AM_CONDITIONAL(SOLARIS_UTIMENSAT_SYSCALL, false) 3480 AM_CONDITIONAL(SOLARIS_SPAWN_SYSCALL, false) 3481 AM_CONDITIONAL(SOLARIS_NSCD_DOOR_SYSTEM_VOLATILE, false) 3482 AM_CONDITIONAL(SOLARIS_GETHRT_FASTTRAP, false) 3483 AM_CONDITIONAL(SOLARIS_GETZONEOFFSET_FASTTRAP, false) 3484 AM_CONDITIONAL(SOLARIS_EXECVE_SYSCALL_TAKES_FLAGS, false) 3485 AM_CONDITIONAL(SOLARIS_RESERVE_SYSSTAT_ADDR, false) 3486 AM_CONDITIONAL(SOLARIS_RESERVE_SYSSTAT_ZONE_ADDR, false) 3487 AM_CONDITIONAL(SOLARIS_SYSTEM_STATS_SYSCALL, false) 3488 fi # test "$VGCONF_OS" = "solaris" 3489 3490 3491 #---------------------------------------------------------------------------- 3492 # Checks for C header files. 3493 #---------------------------------------------------------------------------- 3494 3495 AC_HEADER_STDC 3496 AC_CHECK_HEADERS([ \ 3497 asm/unistd.h \ 3498 endian.h \ 3499 mqueue.h \ 3500 sys/endian.h \ 3501 sys/epoll.h \ 3502 sys/eventfd.h \ 3503 sys/klog.h \ 3504 sys/poll.h \ 3505 sys/prctl.h \ 3506 sys/signal.h \ 3507 sys/signalfd.h \ 3508 sys/syscall.h \ 3509 sys/time.h \ 3510 sys/types.h \ 3511 ]) 3512 3513 # Verify whether the <linux/futex.h> header is usable. 3514 AC_MSG_CHECKING([if <linux/futex.h> is usable]) 3515 3516 save_CFLAGS="$CFLAGS" 3517 CFLAGS="$CFLAGS -D__user=" 3518 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 3519 #include <linux/futex.h> 3520 ]], [[ 3521 return FUTEX_WAIT; 3522 ]])], [ 3523 ac_have_usable_linux_futex_h=yes 3524 AC_DEFINE([HAVE_USABLE_LINUX_FUTEX_H], 1, 3525 [Define to 1 if you have a usable <linux/futex.h> header file.]) 3526 AC_MSG_RESULT([yes]) 3527 ], [ 3528 ac_have_usable_linux_futex_h=no 3529 AC_MSG_RESULT([no]) 3530 ]) 3531 CFLAGS="$save_CFLAGS" 3532 3533 3534 #---------------------------------------------------------------------------- 3535 # Checks for typedefs, structures, and compiler characteristics. 3536 #---------------------------------------------------------------------------- 3537 AC_TYPE_UID_T 3538 AC_TYPE_OFF_T 3539 AC_TYPE_SIZE_T 3540 AC_HEADER_TIME 3541 3542 3543 #---------------------------------------------------------------------------- 3544 # Checks for library functions. 3545 #---------------------------------------------------------------------------- 3546 AC_FUNC_MEMCMP 3547 AC_FUNC_MMAP 3548 3549 AC_CHECK_LIB([pthread], [pthread_create]) 3550 AC_CHECK_LIB([rt], [clock_gettime]) 3551 3552 AC_CHECK_FUNCS([ \ 3553 clock_gettime\ 3554 epoll_create \ 3555 epoll_pwait \ 3556 klogctl \ 3557 mallinfo \ 3558 memchr \ 3559 memset \ 3560 mkdir \ 3561 mremap \ 3562 ppoll \ 3563 pthread_barrier_init \ 3564 pthread_condattr_setclock \ 3565 pthread_mutex_timedlock \ 3566 pthread_rwlock_timedrdlock \ 3567 pthread_rwlock_timedwrlock \ 3568 pthread_spin_lock \ 3569 pthread_yield \ 3570 pthread_setname_np \ 3571 readlinkat \ 3572 semtimedop \ 3573 signalfd \ 3574 sigwaitinfo \ 3575 strchr \ 3576 strdup \ 3577 strpbrk \ 3578 strrchr \ 3579 strstr \ 3580 syscall \ 3581 utimensat \ 3582 process_vm_readv \ 3583 process_vm_writev \ 3584 ]) 3585 3586 # AC_CHECK_LIB adds any library found to the variable LIBS, and links these 3587 # libraries with any shared object and/or executable. This is NOT what we 3588 # want for e.g. vgpreload_core-x86-linux.so 3589 LIBS="" 3590 3591 AM_CONDITIONAL([HAVE_PTHREAD_BARRIER], 3592 [test x$ac_cv_func_pthread_barrier_init = xyes]) 3593 AM_CONDITIONAL([HAVE_PTHREAD_MUTEX_TIMEDLOCK], 3594 [test x$ac_cv_func_pthread_mutex_timedlock = xyes]) 3595 AM_CONDITIONAL([HAVE_PTHREAD_SPINLOCK], 3596 [test x$ac_cv_func_pthread_spin_lock = xyes]) 3597 AM_CONDITIONAL([HAVE_PTHREAD_SETNAME_NP], 3598 [test x$ac_cv_func_pthread_setname_np = xyes]) 3599 3600 if test x$VGCONF_PLATFORM_PRI_CAPS = xMIPS32_LINUX \ 3601 -o x$VGCONF_PLATFORM_PRI_CAPS = xMIPS64_LINUX ; then 3602 AC_DEFINE([DISABLE_PTHREAD_SPINLOCK_INTERCEPT], 1, 3603 [Disable intercept pthread_spin_lock() on MIPS32 and MIPS64.]) 3604 fi 3605 3606 #---------------------------------------------------------------------------- 3607 # MPI checks 3608 #---------------------------------------------------------------------------- 3609 # Do we have a useable MPI setup on the primary and/or secondary targets? 3610 # On Linux, by default, assumes mpicc and -m32/-m64 3611 # Note: this is a kludge in that it assumes the specified mpicc 3612 # understands -m32/-m64 regardless of what is specified using 3613 # --with-mpicc=. 3614 AC_PATH_PROG([MPI_CC], [mpicc], [mpicc], 3615 [$PATH:/usr/lib/openmpi/bin:/usr/lib64/openmpi/bin]) 3616 3617 mflag_primary= 3618 if test x$VGCONF_PLATFORM_PRI_CAPS = xX86_LINUX \ 3619 -o x$VGCONF_PLATFORM_PRI_CAPS = xPPC32_LINUX \ 3620 -o x$VGCONF_PLATFORM_PRI_CAPS = xARM_LINUX \ 3621 -o x$VGCONF_PLATFORM_PRI_CAPS = xMIPS32_LINUX \ 3622 -o x$VGCONF_PLATFORM_PRI_CAPS = xMIPS64_LINUX \ 3623 -o x$VGCONF_PLATFORM_PRI_CAPS = xX86_SOLARIS ; then 3624 mflag_primary=$FLAG_M32 3625 elif test x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_LINUX \ 3626 -o x$VGCONF_PLATFORM_PRI_CAPS = xPPC64_LINUX \ 3627 -o x$VGCONF_PLATFORM_PRI_CAPS = xARM64_LINUX \ 3628 -o x$VGCONF_PLATFORM_PRI_CAPS = xS390X_LINUX ; then 3629 mflag_primary=$FLAG_M64 3630 elif test x$VGCONF_PLATFORM_PRI_CAPS = xX86_DARWIN ; then 3631 mflag_primary="$FLAG_M32 -arch i386" 3632 elif test x$VGCONF_PLATFORM_PRI_CAPS = xAMD64_DARWIN ; then 3633 mflag_primary="$FLAG_M64 -arch x86_64" 3634 fi 3635 3636 mflag_secondary= 3637 if test x$VGCONF_PLATFORM_SEC_CAPS = xX86_LINUX \ 3638 -o x$VGCONF_PLATFORM_SEC_CAPS = xPPC32_LINUX \ 3639 -o x$VGCONF_PLATFORM_SEC_CAPS = xX86_SOLARIS ; then 3640 mflag_secondary=$FLAG_M32 3641 elif test x$VGCONF_PLATFORM_SEC_CAPS = xX86_DARWIN ; then 3642 mflag_secondary="$FLAG_M32 -arch i386" 3643 fi 3644 3645 3646 AC_ARG_WITH(mpicc, 3647 [ --with-mpicc= Specify name of MPI2-ised C compiler], 3648 MPI_CC=$withval 3649 ) 3650 AC_SUBST(MPI_CC) 3651 3652 ## We AM_COND_IF here instead of automake "if" in mpi/Makefile.am so that we can 3653 ## use these values in the check for a functioning mpicc. 3654 ## 3655 ## We leave the MPI_FLAG_M3264_ logic in mpi/Makefile.am and assume that 3656 ## mflag_primary/mflag_secondary are sufficient approximations of that behavior 3657 AM_COND_IF([VGCONF_OS_IS_LINUX], 3658 [CFLAGS_MPI="-g -O -fno-omit-frame-pointer -Wall -fpic" 3659 LDFLAGS_MPI="-fpic -shared"]) 3660 AM_COND_IF([VGCONF_OS_IS_DARWIN], 3661 [CFLAGS_MPI="-g -O -fno-omit-frame-pointer -Wall -dynamic" 3662 LDFLAGS_MPI="-dynamic -dynamiclib -all_load"]) 3663 AM_COND_IF([VGCONF_OS_IS_SOLARIS], 3664 [CFLAGS_MPI="-g -O -fno-omit-frame-pointer -Wall -fpic" 3665 LDFLAGS_MPI="-fpic -shared"]) 3666 3667 AC_SUBST([CFLAGS_MPI]) 3668 AC_SUBST([LDFLAGS_MPI]) 3669 3670 3671 ## See if MPI_CC works for the primary target 3672 ## 3673 AC_MSG_CHECKING([primary target for usable MPI2-compliant C compiler and mpi.h]) 3674 saved_CC=$CC 3675 saved_CFLAGS=$CFLAGS 3676 CC=$MPI_CC 3677 CFLAGS="$CFLAGS_MPI $mflag_primary" 3678 saved_LDFLAGS="$LDFLAGS" 3679 LDFLAGS="$LDFLAGS_MPI $mflag_primary" 3680 AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 3681 #include <mpi.h> 3682 #include <stdio.h> 3683 ]], [[ 3684 int ni, na, nd, comb; 3685 int r = MPI_Init(NULL,NULL); 3686 r |= MPI_Type_get_envelope( MPI_INT, &ni, &na, &nd, &comb ); 3687 r |= MPI_Finalize(); 3688 return r; 3689 ]])], [ 3690 ac_have_mpi2_pri=yes 3691 AC_MSG_RESULT([yes, $MPI_CC]) 3692 ], [ 3693 ac_have_mpi2_pri=no 3694 AC_MSG_RESULT([no]) 3695 ]) 3696 CC=$saved_CC 3697 CFLAGS=$saved_CFLAGS 3698 LDFLAGS="$saved_LDFLAGS" 3699 AM_CONDITIONAL(BUILD_MPIWRAP_PRI, test x$ac_have_mpi2_pri = xyes) 3700 3701 ## See if MPI_CC works for the secondary target. Complication: what if 3702 ## there is no secondary target? We need this to then fail. 3703 ## Kludge this by making MPI_CC something which will surely fail in 3704 ## such a case. 3705 ## 3706 AC_MSG_CHECKING([secondary target for usable MPI2-compliant C compiler and mpi.h]) 3707 saved_CC=$CC 3708 saved_CFLAGS=$CFLAGS 3709 saved_LDFLAGS="$LDFLAGS" 3710 LDFLAGS="$LDFLAGS_MPI $mflag_secondary" 3711 if test x$VGCONF_PLATFORM_SEC_CAPS = x ; then 3712 CC="$MPI_CC this will surely fail" 3713 else 3714 CC=$MPI_CC 3715 fi 3716 CFLAGS="$CFLAGS_MPI $mflag_secondary" 3717 AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 3718 #include <mpi.h> 3719 #include <stdio.h> 3720 ]], [[ 3721 int ni, na, nd, comb; 3722 int r = MPI_Init(NULL,NULL); 3723 r |= MPI_Type_get_envelope( MPI_INT, &ni, &na, &nd, &comb ); 3724 r |= MPI_Finalize(); 3725 return r; 3726 ]])], [ 3727 ac_have_mpi2_sec=yes 3728 AC_MSG_RESULT([yes, $MPI_CC]) 3729 ], [ 3730 ac_have_mpi2_sec=no 3731 AC_MSG_RESULT([no]) 3732 ]) 3733 CC=$saved_CC 3734 CFLAGS=$saved_CFLAGS 3735 LDFLAGS="$saved_LDFLAGS" 3736 AM_CONDITIONAL(BUILD_MPIWRAP_SEC, test x$ac_have_mpi2_sec = xyes) 3737 3738 3739 #---------------------------------------------------------------------------- 3740 # Other library checks 3741 #---------------------------------------------------------------------------- 3742 # There now follow some tests for Boost, and OpenMP. These 3743 # tests are present because Drd has some regression tests that use 3744 # these packages. All regression test programs all compiled only 3745 # for the primary target. And so it is important that the configure 3746 # checks that follow, use the correct -m32 or -m64 flag for the 3747 # primary target (called $mflag_primary). Otherwise, we can end up 3748 # in a situation (eg) where, on amd64-linux, the test for Boost checks 3749 # for usable 64-bit Boost facilities, but because we are doing a 32-bit 3750 # only build (meaning, the primary target is x86-linux), the build 3751 # of the regtest programs that use Boost fails, because they are 3752 # build as 32-bit (IN THIS EXAMPLE). 3753 # 3754 # Hence: ALWAYS USE $mflag_primary FOR CONFIGURE TESTS FOR FACILITIES 3755 # NEEDED BY THE REGRESSION TEST PROGRAMS. 3756 3757 3758 # Check whether the boost library 1.35 or later has been installed. 3759 # The Boost.Threads library has undergone a major rewrite in version 1.35.0. 3760 3761 AC_MSG_CHECKING([for boost]) 3762 3763 AC_LANG(C++) 3764 safe_CXXFLAGS=$CXXFLAGS 3765 CXXFLAGS="$mflag_primary" 3766 safe_LIBS="$LIBS" 3767 LIBS="-lboost_thread-mt -lboost_system-mt $LIBS" 3768 3769 AC_LINK_IFELSE([AC_LANG_SOURCE([ 3770 #include <boost/thread.hpp> 3771 static void thread_func(void) 3772 { } 3773 int main(int argc, char** argv) 3774 { 3775 boost::thread t(thread_func); 3776 return 0; 3777 } 3778 ])], 3779 [ 3780 ac_have_boost_1_35=yes 3781 AC_SUBST([BOOST_CFLAGS], []) 3782 AC_SUBST([BOOST_LIBS], ["-lboost_thread-mt -lboost_system-mt"]) 3783 AC_MSG_RESULT([yes]) 3784 ], [ 3785 ac_have_boost_1_35=no 3786 AC_MSG_RESULT([no]) 3787 ]) 3788 3789 LIBS="$safe_LIBS" 3790 CXXFLAGS=$safe_CXXFLAGS 3791 AC_LANG(C) 3792 3793 AM_CONDITIONAL([HAVE_BOOST_1_35], [test x$ac_have_boost_1_35 = xyes]) 3794 3795 3796 # does this compiler support -fopenmp, does it have the include file 3797 # <omp.h> and does it have libgomp ? 3798 3799 AC_MSG_CHECKING([for OpenMP]) 3800 3801 safe_CFLAGS=$CFLAGS 3802 CFLAGS="-fopenmp $mflag_primary -Werror" 3803 3804 AC_LINK_IFELSE([AC_LANG_SOURCE([ 3805 #include <omp.h> 3806 int main(int argc, char** argv) 3807 { 3808 omp_set_dynamic(0); 3809 return 0; 3810 } 3811 ])], 3812 [ 3813 ac_have_openmp=yes 3814 AC_MSG_RESULT([yes]) 3815 ], [ 3816 ac_have_openmp=no 3817 AC_MSG_RESULT([no]) 3818 ]) 3819 CFLAGS=$safe_CFLAGS 3820 3821 AM_CONDITIONAL([HAVE_OPENMP], [test x$ac_have_openmp = xyes]) 3822 3823 3824 # Check for __builtin_popcount 3825 AC_MSG_CHECKING([for __builtin_popcount()]) 3826 AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 3827 ]], [[ 3828 __builtin_popcount(2); 3829 return 0; 3830 ]])], [ 3831 AC_MSG_RESULT([yes]) 3832 AC_DEFINE([HAVE_BUILTIN_POPCOUT], 1, 3833 [Define to 1 if compiler provides __builtin_popcount().]) 3834 ], [ 3835 AC_MSG_RESULT([no]) 3836 ]) 3837 3838 # Check for __builtin_clz 3839 AC_MSG_CHECKING([for __builtin_clz()]) 3840 AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 3841 ]], [[ 3842 __builtin_clz(2); 3843 return 0; 3844 ]])], [ 3845 AC_MSG_RESULT([yes]) 3846 AC_DEFINE([HAVE_BUILTIN_CLZ], 1, 3847 [Define to 1 if compiler provides __builtin_clz().]) 3848 ], [ 3849 AC_MSG_RESULT([no]) 3850 ]) 3851 3852 # Check for __builtin_ctz 3853 AC_MSG_CHECKING([for __builtin_ctz()]) 3854 AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 3855 ]], [[ 3856 __builtin_ctz(2); 3857 return 0; 3858 ]])], [ 3859 AC_MSG_RESULT([yes]) 3860 AC_DEFINE([HAVE_BUILTIN_CTZ], 1, 3861 [Define to 1 if compiler provides __builtin_ctz().]) 3862 ], [ 3863 AC_MSG_RESULT([no]) 3864 ]) 3865 3866 # does this compiler have built-in functions for atomic memory access for the 3867 # primary target ? 3868 AC_MSG_CHECKING([if gcc supports __sync_add_and_fetch for the primary target]) 3869 3870 safe_CFLAGS=$CFLAGS 3871 CFLAGS="$mflag_primary" 3872 3873 AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[ 3874 int variable = 1; 3875 return (__sync_bool_compare_and_swap(&variable, 1, 2) 3876 && __sync_add_and_fetch(&variable, 1) ? 1 : 0) 3877 ]])], [ 3878 ac_have_builtin_atomic_primary=yes 3879 AC_MSG_RESULT([yes]) 3880 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]) 3881 ], [ 3882 ac_have_builtin_atomic_primary=no 3883 AC_MSG_RESULT([no]) 3884 ]) 3885 3886 CFLAGS=$safe_CFLAGS 3887 3888 AM_CONDITIONAL([HAVE_BUILTIN_ATOMIC], 3889 [test x$ac_have_builtin_atomic_primary = xyes]) 3890 3891 3892 # does this compiler have built-in functions for atomic memory access for the 3893 # secondary target ? 3894 3895 if test x$VGCONF_PLATFORM_SEC_CAPS != x; then 3896 3897 AC_MSG_CHECKING([if gcc supports __sync_add_and_fetch for the secondary target]) 3898 3899 safe_CFLAGS=$CFLAGS 3900 CFLAGS="$mflag_secondary" 3901 3902 AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[ 3903 int variable = 1; 3904 return (__sync_add_and_fetch(&variable, 1) ? 1 : 0) 3905 ]])], [ 3906 ac_have_builtin_atomic_secondary=yes 3907 AC_MSG_RESULT([yes]) 3908 ], [ 3909 ac_have_builtin_atomic_secondary=no 3910 AC_MSG_RESULT([no]) 3911 ]) 3912 3913 CFLAGS=$safe_CFLAGS 3914 3915 fi 3916 3917 AM_CONDITIONAL([HAVE_BUILTIN_ATOMIC_SECONDARY], 3918 [test x$ac_have_builtin_atomic_secondary = xyes]) 3919 3920 # does this compiler have built-in functions for atomic memory access on 3921 # 64-bit integers for all targets ? 3922 3923 AC_MSG_CHECKING([if gcc supports __sync_add_and_fetch on uint64_t for all targets]) 3924 3925 AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 3926 #include <stdint.h> 3927 ]], [[ 3928 uint64_t variable = 1; 3929 return __sync_add_and_fetch(&variable, 1) 3930 ]])], [ 3931 ac_have_builtin_atomic64_primary=yes 3932 ], [ 3933 ac_have_builtin_atomic64_primary=no 3934 ]) 3935 3936 if test x$VGCONF_PLATFORM_SEC_CAPS != x; then 3937 3938 safe_CFLAGS=$CFLAGS 3939 CFLAGS="$mflag_secondary" 3940 3941 AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 3942 #include <stdint.h> 3943 ]], [[ 3944 uint64_t variable = 1; 3945 return __sync_add_and_fetch(&variable, 1) 3946 ]])], [ 3947 ac_have_builtin_atomic64_secondary=yes 3948 ], [ 3949 ac_have_builtin_atomic64_secondary=no 3950 ]) 3951 3952 CFLAGS=$safe_CFLAGS 3953 3954 fi 3955 3956 if test x$ac_have_builtin_atomic64_primary = xyes && \ 3957 test x$VGCONF_PLATFORM_SEC_CAPS = x \ 3958 -o x$ac_have_builtin_atomic64_secondary = xyes; then 3959 AC_MSG_RESULT([yes]) 3960 ac_have_builtin_atomic64=yes 3961 else 3962 AC_MSG_RESULT([no]) 3963 ac_have_builtin_atomic64=no 3964 fi 3965 3966 AM_CONDITIONAL([HAVE_BUILTIN_ATOMIC64], 3967 [test x$ac_have_builtin_atomic64 = xyes]) 3968 3969 3970 # does g++ have built-in functions for atomic memory access ? 3971 AC_MSG_CHECKING([if g++ supports __sync_add_and_fetch]) 3972 3973 safe_CXXFLAGS=$CXXFLAGS 3974 CXXFLAGS="$mflag_primary" 3975 3976 AC_LANG_PUSH(C++) 3977 AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[ 3978 int variable = 1; 3979 return (__sync_bool_compare_and_swap(&variable, 1, 2) 3980 && __sync_add_and_fetch(&variable, 1) ? 1 : 0) 3981 ]])], [ 3982 ac_have_builtin_atomic_cxx=yes 3983 AC_MSG_RESULT([yes]) 3984 AC_DEFINE(HAVE_BUILTIN_ATOMIC_CXX, 1, [Define to 1 if g++ supports __sync_bool_compare_and_swap() and __sync_add_and_fetch()]) 3985 ], [ 3986 ac_have_builtin_atomic_cxx=no 3987 AC_MSG_RESULT([no]) 3988 ]) 3989 AC_LANG_POP(C++) 3990 3991 CXXFLAGS=$safe_CXXFLAGS 3992 3993 AM_CONDITIONAL([HAVE_BUILTIN_ATOMIC_CXX], [test x$ac_have_builtin_atomic_cxx = xyes]) 3994 3995 3996 if test x$ac_have_usable_linux_futex_h = xyes \ 3997 -a x$ac_have_builtin_atomic_primary = xyes; then 3998 ac_enable_linux_ticket_lock_primary=yes 3999 fi 4000 AM_CONDITIONAL([ENABLE_LINUX_TICKET_LOCK_PRIMARY], 4001 [test x$ac_enable_linux_ticket_lock_primary = xyes]) 4002 4003 if test x$VGCONF_PLATFORM_SEC_CAPS != x \ 4004 -a x$ac_have_usable_linux_futex_h = xyes \ 4005 -a x$ac_have_builtin_atomic_secondary = xyes; then 4006 ac_enable_linux_ticket_lock_secondary=yes 4007 fi 4008 AM_CONDITIONAL([ENABLE_LINUX_TICKET_LOCK_SECONDARY], 4009 [test x$ac_enable_linux_ticket_lock_secondary = xyes]) 4010 4011 4012 # does libstdc++ support annotating shared pointers ? 4013 AC_MSG_CHECKING([if libstdc++ supports annotating shared pointers]) 4014 4015 safe_CXXFLAGS=$CXXFLAGS 4016 CXXFLAGS="-std=c++0x" 4017 4018 AC_LANG_PUSH(C++) 4019 AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 4020 #include <memory> 4021 ]], [[ 4022 std::shared_ptr<int> p 4023 ]])], [ 4024 ac_have_shared_ptr=yes 4025 ], [ 4026 ac_have_shared_ptr=no 4027 ]) 4028 if test x$ac_have_shared_ptr = xyes; then 4029 # If compilation of the program below fails because of a syntax error 4030 # triggered by substituting one of the annotation macros then that 4031 # means that libstdc++ supports these macros. 4032 AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 4033 #define _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(a) (a)---- 4034 #define _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(a) (a)---- 4035 #include <memory> 4036 ]], [[ 4037 std::shared_ptr<int> p 4038 ]])], [ 4039 ac_have_shared_pointer_annotation=no 4040 AC_MSG_RESULT([no]) 4041 ], [ 4042 ac_have_shared_pointer_annotation=yes 4043 AC_MSG_RESULT([yes]) 4044 AC_DEFINE(HAVE_SHARED_POINTER_ANNOTATION, 1, 4045 [Define to 1 if libstd++ supports annotating shared pointers]) 4046 ]) 4047 else 4048 ac_have_shared_pointer_annotation=no 4049 AC_MSG_RESULT([no]) 4050 fi 4051 AC_LANG_POP(C++) 4052 4053 CXXFLAGS=$safe_CXXFLAGS 4054 4055 AM_CONDITIONAL([HAVE_SHARED_POINTER_ANNOTATION], 4056 [test x$ac_have_shared_pointer_annotation = xyes]) 4057 4058 4059 #---------------------------------------------------------------------------- 4060 # Ok. We're done checking. 4061 #---------------------------------------------------------------------------- 4062 4063 # Nb: VEX/Makefile is generated from Makefile.vex.in. 4064 AC_CONFIG_FILES([ 4065 Makefile 4066 VEX/Makefile:Makefile.vex.in 4067 valgrind.spec 4068 valgrind.pc 4069 glibc-2.X.supp 4070 docs/Makefile 4071 tests/Makefile 4072 tests/vg_regtest 4073 perf/Makefile 4074 perf/vg_perf 4075 gdbserver_tests/Makefile 4076 gdbserver_tests/solaris/Makefile 4077 include/Makefile 4078 auxprogs/Makefile 4079 mpi/Makefile 4080 coregrind/Makefile 4081 memcheck/Makefile 4082 memcheck/tests/Makefile 4083 memcheck/tests/common/Makefile 4084 memcheck/tests/amd64/Makefile 4085 memcheck/tests/x86/Makefile 4086 memcheck/tests/linux/Makefile 4087 memcheck/tests/darwin/Makefile 4088 memcheck/tests/solaris/Makefile 4089 memcheck/tests/amd64-linux/Makefile 4090 memcheck/tests/x86-linux/Makefile 4091 memcheck/tests/amd64-solaris/Makefile 4092 memcheck/tests/x86-solaris/Makefile 4093 memcheck/tests/ppc32/Makefile 4094 memcheck/tests/ppc64/Makefile 4095 memcheck/tests/s390x/Makefile 4096 memcheck/tests/vbit-test/Makefile 4097 cachegrind/Makefile 4098 cachegrind/tests/Makefile 4099 cachegrind/tests/x86/Makefile 4100 cachegrind/cg_annotate 4101 cachegrind/cg_diff 4102 callgrind/Makefile 4103 callgrind/callgrind_annotate 4104 callgrind/callgrind_control 4105 callgrind/tests/Makefile 4106 helgrind/Makefile 4107 helgrind/tests/Makefile 4108 massif/Makefile 4109 massif/tests/Makefile 4110 massif/ms_print 4111 lackey/Makefile 4112 lackey/tests/Makefile 4113 none/Makefile 4114 none/tests/Makefile 4115 none/tests/scripts/Makefile 4116 none/tests/amd64/Makefile 4117 none/tests/ppc32/Makefile 4118 none/tests/ppc64/Makefile 4119 none/tests/x86/Makefile 4120 none/tests/arm/Makefile 4121 none/tests/arm64/Makefile 4122 none/tests/s390x/Makefile 4123 none/tests/mips32/Makefile 4124 none/tests/mips64/Makefile 4125 none/tests/tilegx/Makefile 4126 none/tests/linux/Makefile 4127 none/tests/darwin/Makefile 4128 none/tests/solaris/Makefile 4129 none/tests/amd64-linux/Makefile 4130 none/tests/x86-linux/Makefile 4131 none/tests/amd64-darwin/Makefile 4132 none/tests/x86-darwin/Makefile 4133 none/tests/amd64-solaris/Makefile 4134 none/tests/x86-solaris/Makefile 4135 exp-sgcheck/Makefile 4136 exp-sgcheck/tests/Makefile 4137 drd/Makefile 4138 drd/scripts/download-and-build-splash2 4139 drd/tests/Makefile 4140 exp-bbv/Makefile 4141 exp-bbv/tests/Makefile 4142 exp-bbv/tests/x86/Makefile 4143 exp-bbv/tests/x86-linux/Makefile 4144 exp-bbv/tests/amd64-linux/Makefile 4145 exp-bbv/tests/ppc32-linux/Makefile 4146 exp-bbv/tests/arm-linux/Makefile 4147 exp-dhat/Makefile 4148 exp-dhat/tests/Makefile 4149 shared/Makefile 4150 solaris/Makefile 4151 ]) 4152 AC_CONFIG_FILES([coregrind/link_tool_exe_linux], 4153 [chmod +x coregrind/link_tool_exe_linux]) 4154 AC_CONFIG_FILES([coregrind/link_tool_exe_darwin], 4155 [chmod +x coregrind/link_tool_exe_darwin]) 4156 AC_CONFIG_FILES([coregrind/link_tool_exe_solaris], 4157 [chmod +x coregrind/link_tool_exe_solaris]) 4158 AC_OUTPUT 4159 4160 cat<<EOF 4161 4162 Maximum build arch: ${ARCH_MAX} 4163 Primary build arch: ${VGCONF_ARCH_PRI} 4164 Secondary build arch: ${VGCONF_ARCH_SEC} 4165 Build OS: ${VGCONF_OS} 4166 Primary build target: ${VGCONF_PLATFORM_PRI_CAPS} 4167 Secondary build target: ${VGCONF_PLATFORM_SEC_CAPS} 4168 Platform variant: ${VGCONF_PLATVARIANT} 4169 Primary -DVGPV string: -DVGPV_${VGCONF_ARCH_PRI}_${VGCONF_OS}_${VGCONF_PLATVARIANT}=1 4170 Default supp files: ${DEFAULT_SUPP} 4171 4172 EOF 4173
