1dnl $Id: acinclude.m4,v 1.34 2009/10/14 21:12:01 dmh Exp $ 2dnl UD macros for netcdf configure 3 4 5dnl Convert a string to all uppercase. 6dnl 7define([uppercase], 8[translit($1, abcdefghijklmnopqrstuvwxyz, ABCDEFGHIJKLMNOPQRSTUVWXYZ)]) 9 10dnl 11dnl Check for an nm(1) utility. 12dnl 13AC_DEFUN([UD_PROG_NM], 14[ 15 case "${NM-unset}" in 16 unset) AC_CHECK_PROGS(NM, nm, nm) ;; 17 *) AC_CHECK_PROGS(NM, $NM nm, nm) ;; 18 esac 19 AC_MSG_CHECKING(nm flags) 20 case "${NMFLAGS-unset}" in 21 unset) NMFLAGS= ;; 22 esac 23 AC_MSG_RESULT($NMFLAGS) 24 AC_SUBST(NMFLAGS) 25]) 26 27dnl Check for a Fortran type equivalent to a netCDF type. 28dnl 29dnl UD_CHECK_FORTRAN_NCTYPE(forttype, possibs, nctype) 30dnl 31AC_DEFUN([UD_CHECK_FORTRAN_NCTYPE], 32[ 33 AC_MSG_CHECKING(for Fortran-equivalent to netCDF \"$3\") 34 for type in $2; do 35 cat >conftest.f <<EOF 36 $type foo 37 end 38EOF 39 doit='$FC -c ${FFLAGS} conftest.f' 40 if AC_TRY_EVAL(doit); then 41 break; 42 fi 43 done 44 rm -f conftest.f conftest.o 45 AC_DEFINE_UNQUOTED($1, $type, [type definition]) 46 AC_MSG_RESULT($type) 47 $1=$type 48]) 49 50 51dnl Check for a Fortran type equivalent to a C type. 52dnl 53dnl UD_CHECK_FORTRAN_CTYPE(v3forttype, v2forttype, ctype, min, max) 54dnl 55AC_DEFUN([UD_CHECK_FORTRAN_CTYPE], 56[ 57 AC_MSG_CHECKING(for Fortran-equivalent to C \"$3\") 58 cat >conftest.f <<EOF 59 subroutine sub(values, minval, maxval) 60 implicit none 61 $2 values(5), minval, maxval 62 minval = values(2) 63 maxval = values(4) 64 if (values(2) .ge. values(4)) then 65 minval = values(4) 66 maxval = values(2) 67 endif 68 end 69EOF 70 doit='$FC -c ${FFLAGS conftest.f' 71 if AC_TRY_EVAL(doit); then 72 mv conftest.o conftestf.o 73 cat >conftest.c <<EOF 74#include <limits.h> 75#include <float.h> 76void main() 77{ 78$3 values[[]] = {0, $4, 0, $5, 0}; 79$3 minval, maxval; 80void $FCALLSCSUB($3*, $3*, $3*); 81$FCALLSCSUB(values, &minval, &maxval); 82exit(!(minval == $4 && maxval == $5)); 83} 84EOF 85 doit='$CC -o conftest ${CPPFLAGS} ${CFLAGS} ${LDFLAGS} conftest.c conftestf.o ${LIBS}' 86 if AC_TRY_EVAL(doit); then 87 doit=./conftest 88 if AC_TRY_EVAL(doit); then 89 AC_MSG_RESULT($2) 90 $1=$2 91 AC_DEFINE_UNQUOTED($1,$2, [take a guess]) 92 else 93 AC_MSG_RESULT(no equivalent type) 94 unset $1 95 fi 96 else 97 AC_MSG_ERROR(Could not compile-and-link conftest.c and conftestf.o) 98 fi 99 else 100 AC_MSG_ERROR(Could not compile conftest.f) 101 fi 102 rm -f conftest* 103]) 104 105 106dnl Check for a Fortran data type. 107dnl 108dnl UD_CHECK_FORTRAN_TYPE(varname, ftypes) 109dnl 110AC_DEFUN([UD_CHECK_FORTRAN_TYPE], 111[ 112 for ftype in $2; do 113 AC_MSG_CHECKING(for Fortran \"$ftype\") 114 cat >conftest.f <<EOF 115 subroutine sub(value) 116 $ftype value 117 end 118EOF 119 doit='$FC -c ${FFLAGS} conftest.f' 120 if AC_TRY_EVAL(doit); then 121 AC_MSG_RESULT(yes) 122 $1=$ftype 123 AC_DEFINE_UNQUOTED($1, $ftype, [type thing]) 124 break 125 else 126 AC_MSG_RESULT(no) 127 fi 128 done 129 rm -f conftest* 130]) 131 132 133dnl Check for the name format of a Fortran-callable C routine. 134dnl 135dnl UD_CHECK_FCALLSCSUB 136AC_DEFUN([UD_CHECK_FCALLSCSUB], 137[ 138# AC_REQUIRE([UD_PROG_FC]) 139 case "$FC" in 140 '') ;; 141 *) 142 AC_REQUIRE([UD_PROG_NM]) 143 AC_BEFORE([UD_CHECK_FORTRAN_CTYPE]) 144 AC_BEFORE([UD_CHECK_CTYPE_FORTRAN]) 145 AC_MSG_CHECKING(for C-equivalent to Fortran routine \"SUB\") 146 cat >conftest.f <<\EOF 147 call sub() 148 end 149EOF 150 doit='$FC -c ${FFLAGS} conftest.f' 151 if AC_TRY_EVAL(doit); then 152 FCALLSCSUB=`$NM $NMFLAGS conftest.o | awk ' 153 /SUB_/{print "SUB_";exit} 154 /SUB/ {print "SUB"; exit} 155 /sub_/{print "sub_";exit} 156 /sub/ {print "sub"; exit}'` 157 case "$FCALLSCSUB" in 158 '') AC_MSG_ERROR(not found) 159 ;; 160 *) AC_MSG_RESULT($FCALLSCSUB) 161 ;; 162 esac 163 else 164 AC_MSG_ERROR(Could not compile conftest.f) 165 fi 166 rm -f conftest* 167 ;; 168 esac 169]) 170 171 172dnl Check for a C type equivalent to a Fortran type. 173dnl 174dnl UD_CHECK_CTYPE_FORTRAN(ftype, ctypes, fmacro_root) 175dnl 176AC_DEFUN([UD_CHECK_CTYPE_FORTRAN], 177[ 178 cat >conftestf.f <<EOF 179 $1 values(4) 180 data values /-1, -2, -3, -4/ 181 call sub(values) 182 end 183EOF 184 for ctype in $2; do 185 AC_MSG_CHECKING(if Fortran \"$1\" is C \"$ctype\") 186 cat >conftest.c <<EOF 187 #include <stdlib.h> 188 void $FCALLSCSUB(values) 189 $ctype values[[4]]; 190 { 191 exit(values[[1]] != -2 || values[[2]] != -3); 192 } 193EOF 194 doit='$CC -c ${CPPFLAGS} ${CFLAGS} conftest.c' 195 if AC_TRY_EVAL(doit); then 196 doit='$FC ${FFLAGS} -c conftestf.f' 197 if AC_TRY_EVAL(doit); then 198 doit='$FC -o conftest ${FFLAGS} ${LDFLAGS} conftestf.o conftest.o ${FLIBS} ${LIBS}' 199 if AC_TRY_EVAL(doit); then 200 doit=./conftest 201 if AC_TRY_EVAL(doit); then 202 AC_MSG_RESULT(yes) 203 cname=`echo $ctype | tr ' abcdefghijklmnopqrstuvwxyz' \ 204 _ABCDEFGHIJKLMNOPQRSTUVWXYZ` 205 AC_DEFINE_UNQUOTED(NF_$3[]_IS_C_$cname, [1], [fortran to c conversion]) 206 break 207 else 208 AC_MSG_RESULT(no) 209 fi 210 else 211 AC_MSG_ERROR(Could not link conftestf.o and conftest.o) 212 fi 213 else 214 AC_MSG_ERROR(Could not compile conftestf.f) 215 fi 216 else 217 AC_MSG_ERROR(Could not compile conftest.c) 218 fi 219 done 220 rm -f conftest* 221]) 222 223 224dnl Get information about Fortran data types. 225dnl 226AC_DEFUN([UD_FORTRAN_TYPES], 227[ 228# AC_REQUIRE([UD_PROG_FC]) 229 case "$FC" in 230 '') 231 ;; 232 *) 233 AC_REQUIRE([UD_CHECK_FCALLSCSUB]) 234dnl UD_CHECK_FORTRAN_TYPE(NF_INT1_T, byte integer*1 "integer(kind(1))") 235dnl UD_CHECK_FORTRAN_TYPE(NF_INT2_T, integer*2 "integer(kind(2))") 236 UD_CHECK_FORTRAN_TYPE(NF_INT1_T, byte integer*1 "integer(kind=1)" "integer(selected_int_kind(2))") 237 UD_CHECK_FORTRAN_TYPE(NF_INT2_T, integer*2 "integer(kind=2)" "integer(selected_int_kind(4))") 238 UD_CHECK_FORTRAN_TYPE(NF_INT8_T, integer*8 "integer(kind=8)" "integer(selected_int_kind(18))") 239 240 case "${NF_INT1_T}" in 241 '') ;; 242 *) UD_CHECK_CTYPE_FORTRAN($NF_INT1_T, "signed char", INT1) 243 UD_CHECK_CTYPE_FORTRAN($NF_INT1_T, "short", INT1) 244 UD_CHECK_CTYPE_FORTRAN($NF_INT1_T, "int", INT1) 245 UD_CHECK_CTYPE_FORTRAN($NF_INT1_T, "long", INT1) 246 ;; 247 esac 248 case "${NF_INT2_T}" in 249 '') ;; 250 *) UD_CHECK_CTYPE_FORTRAN($NF_INT2_T, short, INT2) 251 UD_CHECK_CTYPE_FORTRAN($NF_INT2_T, int, INT2) 252 UD_CHECK_CTYPE_FORTRAN($NF_INT2_T, long, INT2) 253 ;; 254 esac 255 case "${NF_INT8_T}" in 256 '') ;; 257 *) UD_CHECK_CTYPE_FORTRAN($NF_INT8_T, "short", INT8) 258 UD_CHECK_CTYPE_FORTRAN($NF_INT8_T, "int", INT8) 259 UD_CHECK_CTYPE_FORTRAN($NF_INT8_T, "long long", INT8) 260 ;; 261 esac 262 UD_CHECK_CTYPE_FORTRAN(integer, int long, INT) 263 UD_CHECK_CTYPE_FORTRAN(real, float double, REAL) 264 UD_CHECK_CTYPE_FORTRAN(doubleprecision, double float, DOUBLEPRECISION) 265 266dnl UD_CHECK_FORTRAN_NCTYPE(NCBYTE_T, byte integer*1 integer, byte) 267 UD_CHECK_FORTRAN_NCTYPE(NCBYTE_T, byte integer*1 "integer(kind=1)" "integer(selected_int_kind(2))" integer, byte) 268 269dnl UD_CHECK_FORTRAN_NCTYPE(NCSHORT_T, integer*2 integer, short) 270 UD_CHECK_FORTRAN_NCTYPE(NCSHORT_T, integer*2 "integer(kind=2)" "integer(selected_int_kind(4))" integer, short) 271dnl UD_CHECK_FORTRAN_CTYPE(NF_SHORT_T, $NCSHORT_T, short, SHRT_MIN, SHRT_MAX) 272 273dnl UD_CHECK_FORTRAN_NCTYPE(NCLONG_T, integer*4 integer, long) 274dnl UD_CHECK_FORTRAN_CTYPE(NF_INT_T, integer, int, INT_MIN, INT_MAX) 275 276dnl UD_CHECK_FORTRAN_NCTYPE(NCFLOAT_T, real*4 real, float) 277dnl UD_CHECK_FORTRAN_CTYPE(NF_FLOAT_T, $NCFLOAT_T, float, FLT_MIN, FLT_MAX) 278 279dnl UD_CHECK_FORTRAN_NCTYPE(NCDOUBLE_T, real*8 doubleprecision real, double) 280dnl UD_CHECK_FORTRAN_CTYPE(NF_DOUBLE_T, $NCDOUBLE_T, double, DBL_MIN, DBL_MAX) 281 ;; 282 esac 283]) 284 285AC_DEFUN([AX_F90_MODULE_FLAG],[ 286AC_CACHE_CHECK([fortran 90 modules inclusion flag], 287ax_cv_f90_modflag, 288[AC_LANG_PUSH(Fortran) 289i=0 290while test \( -f tmpdir_$i \) -o \( -d tmpdir_$i \) ; do 291 i=`expr $i + 1` 292done 293mkdir tmpdir_$i 294cd tmpdir_$i 295AC_COMPILE_IFELSE([AC_LANG_SOURCE([module conftest_module 296 contains 297 subroutine conftest_routine 298 write(*,'(a)') 'gotcha!' 299 end subroutine conftest_routine 300 end module conftest_module]) 301 ],[],[]) 302cd .. 303ax_cv_f90_modflag="not found" 304for ax_flag in "-I" "-M" "-p"; do 305 if test "$ax_cv_f90_modflag" = "not found" ; then 306 ax_save_FCFLAGS="$FCFLAGS" 307 FCFLAGS="$ax_save_FCFLAGS ${ax_flag}tmpdir_$i" 308 AC_COMPILE_IFELSE([AC_LANG_SOURCE([program conftest_program 309 use conftest_module 310 call conftest_routine 311 end program conftest_program]) 312 ],[ax_cv_f90_modflag="$ax_flag"],[]) 313 FCFLAGS="$ax_save_FCFLAGS" 314 fi 315done 316rm -fr tmpdir_$i 317if test "$ax_flag" = "not found" ; then 318 AC_MSG_ERROR([unable to find compiler flag for modules inclusion]) 319fi 320AC_LANG_POP(Fortran) 321])]) 322 323 324# =========================================================================== 325# https://www.gnu.org/software/autoconf-archive/ax_valgrind_check.html 326# =========================================================================== 327# 328# SYNOPSIS 329# 330# AX_VALGRIND_DFLT(memcheck|helgrind|drd|sgcheck, on|off) 331# AX_VALGRIND_CHECK() 332# 333# DESCRIPTION 334# 335# AX_VALGRIND_CHECK checks whether Valgrind is present and, if so, allows 336# running `make check` under a variety of Valgrind tools to check for 337# memory and threading errors. 338# 339# Defines VALGRIND_CHECK_RULES which should be substituted in your 340# Makefile; and $enable_valgrind which can be used in subsequent configure 341# output. VALGRIND_ENABLED is defined and substituted, and corresponds to 342# the value of the --enable-valgrind option, which defaults to being 343# enabled if Valgrind is installed and disabled otherwise. Individual 344# Valgrind tools can be disabled via --disable-valgrind-<tool>, the 345# default is configurable via the AX_VALGRIND_DFLT command or is to use 346# all commands not disabled via AX_VALGRIND_DFLT. All AX_VALGRIND_DFLT 347# calls must be made before the call to AX_VALGRIND_CHECK. 348# 349# If unit tests are written using a shell script and automake's 350# LOG_COMPILER system, the $(VALGRIND) variable can be used within the 351# shell scripts to enable Valgrind, as described here: 352# 353# https://www.gnu.org/software/gnulib/manual/html_node/Running-self_002dtests-under-valgrind.html 354# 355# Usage example: 356# 357# configure.ac: 358# 359# AX_VALGRIND_DFLT([sgcheck], [off]) 360# AX_VALGRIND_CHECK 361# 362# in each Makefile.am with tests: 363# 364# @VALGRIND_CHECK_RULES@ 365# VALGRIND_SUPPRESSIONS_FILES = my-project.supp 366# EXTRA_DIST = my-project.supp 367# 368# This results in a "check-valgrind" rule being added. Running `make 369# check-valgrind` in that directory will recursively run the module's test 370# suite (`make check`) once for each of the available Valgrind tools (out 371# of memcheck, helgrind and drd) while the sgcheck will be skipped unless 372# enabled again on the commandline with --enable-valgrind-sgcheck. The 373# results for each check will be output to test-suite-$toolname.log. The 374# target will succeed if there are zero errors and fail otherwise. 375# 376# Alternatively, a "check-valgrind-$TOOL" rule will be added, for $TOOL in 377# memcheck, helgrind, drd and sgcheck. These are useful because often only 378# some of those tools can be ran cleanly on a codebase. 379# 380# The macro supports running with and without libtool. 381# 382# LICENSE 383# 384# Copyright (c) 2014, 2015, 2016 Philip Withnall <philip.withnall@collabora.co.uk> 385# 386# Copying and distribution of this file, with or without modification, are 387# permitted in any medium without royalty provided the copyright notice 388# and this notice are preserved. This file is offered as-is, without any 389# warranty. 390 391# serial-17 392 393dnl Configured tools 394m4_define([valgrind_tool_list], [[memcheck], [helgrind], [drd], [sgcheck]]) 395m4_set_add_all([valgrind_exp_tool_set], [sgcheck]) 396m4_foreach([vgtool], [valgrind_tool_list], 397 [m4_define([en_dflt_valgrind_]vgtool, [on])]) 398 399AC_DEFUN([AX_VALGRIND_DFLT],[ 400 m4_define([en_dflt_valgrind_$1], [$2]) 401])dnl 402 403AM_EXTRA_RECURSIVE_TARGETS([check-valgrind]) 404m4_foreach([vgtool], [valgrind_tool_list], 405 [AM_EXTRA_RECURSIVE_TARGETS([check-valgrind-]vgtool)]) 406 407AC_DEFUN([AX_VALGRIND_CHECK],[ 408 dnl Check for --enable-valgrind 409 AC_ARG_ENABLE([valgrind], 410 [AS_HELP_STRING([--enable-valgrind], [Whether to enable Valgrind on the unit tests])], 411 [enable_valgrind=$enableval],[enable_valgrind=]) 412 413 AS_IF([test "$enable_valgrind" != "no"],[ 414 # Check for Valgrind. 415 AC_CHECK_PROG([VALGRIND],[valgrind],[valgrind]) 416 AS_IF([test "$VALGRIND" = ""],[ 417 AS_IF([test "$enable_valgrind" = "yes"],[ 418 AC_MSG_ERROR([Could not find valgrind; either install it or reconfigure with --disable-valgrind]) 419 ],[ 420 enable_valgrind=no 421 ]) 422 ],[ 423 enable_valgrind=yes 424 ]) 425 ]) 426 427 AM_CONDITIONAL([VALGRIND_ENABLED],[test "$enable_valgrind" = "yes"]) 428 AC_SUBST([VALGRIND_ENABLED],[$enable_valgrind]) 429 430 # Check for Valgrind tools we care about. 431 [valgrind_enabled_tools=] 432 m4_foreach([vgtool],[valgrind_tool_list],[ 433 AC_ARG_ENABLE([valgrind-]vgtool, 434 m4_if(m4_defn([en_dflt_valgrind_]vgtool),[off],dnl 435[AS_HELP_STRING([--enable-valgrind-]vgtool, [Whether to use ]vgtool[ during the Valgrind tests])],dnl 436[AS_HELP_STRING([--disable-valgrind-]vgtool, [Whether to skip ]vgtool[ during the Valgrind tests])]), 437 [enable_valgrind_]vgtool[=$enableval], 438 [enable_valgrind_]vgtool[=]) 439 AS_IF([test "$enable_valgrind" = "no"],[ 440 enable_valgrind_]vgtool[=no], 441 [test "$enable_valgrind_]vgtool[" ]dnl 442m4_if(m4_defn([en_dflt_valgrind_]vgtool), [off], [= "yes"], [!= "no"]),[ 443 AC_CACHE_CHECK([for Valgrind tool ]vgtool, 444 [ax_cv_valgrind_tool_]vgtool,[ 445 ax_cv_valgrind_tool_]vgtool[=no 446 m4_set_contains([valgrind_exp_tool_set],vgtool, 447 [m4_define([vgtoolx],[exp-]vgtool)], 448 [m4_define([vgtoolx],vgtool)]) 449 AS_IF([`$VALGRIND --tool=]vgtoolx[ --help >/dev/null 2>&1`],[ 450 ax_cv_valgrind_tool_]vgtool[=yes 451 ]) 452 ]) 453 AS_IF([test "$ax_cv_valgrind_tool_]vgtool[" = "no"],[ 454 AS_IF([test "$enable_valgrind_]vgtool[" = "yes"],[ 455 AC_MSG_ERROR([Valgrind does not support ]vgtool[; reconfigure with --disable-valgrind-]vgtool) 456 ],[ 457 enable_valgrind_]vgtool[=no 458 ]) 459 ],[ 460 enable_valgrind_]vgtool[=yes 461 ]) 462 ]) 463 AS_IF([test "$enable_valgrind_]vgtool[" = "yes"],[ 464 valgrind_enabled_tools="$valgrind_enabled_tools ]m4_bpatsubst(vgtool,[^exp-])[" 465 ]) 466 AC_SUBST([ENABLE_VALGRIND_]vgtool,[$enable_valgrind_]vgtool) 467 ]) 468 AC_SUBST([valgrind_tools],["]m4_join([ ], valgrind_tool_list)["]) 469 AC_SUBST([valgrind_enabled_tools],[$valgrind_enabled_tools]) 470 471[VALGRIND_CHECK_RULES=' 472# Valgrind check 473# 474# Optional: 475# - VALGRIND_SUPPRESSIONS_FILES: Space-separated list of Valgrind suppressions 476# files to load. (Default: empty) 477# - VALGRIND_FLAGS: General flags to pass to all Valgrind tools. 478# (Default: --num-callers=30) 479# - VALGRIND_$toolname_FLAGS: Flags to pass to Valgrind $toolname (one of: 480# memcheck, helgrind, drd, sgcheck). (Default: various) 481 482# Optional variables 483VALGRIND_SUPPRESSIONS ?= $(addprefix --suppressions=,$(VALGRIND_SUPPRESSIONS_FILES)) 484VALGRIND_FLAGS ?= --num-callers=30 485VALGRIND_memcheck_FLAGS ?= --leak-check=full --show-reachable=no 486VALGRIND_helgrind_FLAGS ?= --history-level=approx 487VALGRIND_drd_FLAGS ?= 488VALGRIND_sgcheck_FLAGS ?= 489 490# Internal use 491valgrind_log_files = $(addprefix test-suite-,$(addsuffix .log,$(valgrind_tools))) 492 493valgrind_memcheck_flags = --tool=memcheck $(VALGRIND_memcheck_FLAGS) 494valgrind_helgrind_flags = --tool=helgrind $(VALGRIND_helgrind_FLAGS) 495valgrind_drd_flags = --tool=drd $(VALGRIND_drd_FLAGS) 496valgrind_sgcheck_flags = --tool=exp-sgcheck $(VALGRIND_sgcheck_FLAGS) 497 498valgrind_quiet = $(valgrind_quiet_$(V)) 499valgrind_quiet_ = $(valgrind_quiet_$(AM_DEFAULT_VERBOSITY)) 500valgrind_quiet_0 = --quiet 501valgrind_v_use = $(valgrind_v_use_$(V)) 502valgrind_v_use_ = $(valgrind_v_use_$(AM_DEFAULT_VERBOSITY)) 503valgrind_v_use_0 = @echo " USE " $(patsubst check-valgrind-%-am,%,$''@):; 504 505# Support running with and without libtool. 506ifneq ($(LIBTOOL),) 507valgrind_lt = $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=execute 508else 509valgrind_lt = 510endif 511 512# Use recursive makes in order to ignore errors during check 513check-valgrind-am: 514ifeq ($(VALGRIND_ENABLED),yes) 515 $(A''M_V_at)$(MAKE) $(AM_MAKEFLAGS) -k \ 516 $(foreach tool, $(valgrind_enabled_tools), check-valgrind-$(tool)) 517else 518 @echo "Need to reconfigure with --enable-valgrind" 519endif 520 521# Valgrind running 522VALGRIND_TESTS_ENVIRONMENT = \ 523 $(TESTS_ENVIRONMENT) \ 524 env VALGRIND=$(VALGRIND) \ 525 G_SLICE=always-malloc,debug-blocks \ 526 G_DEBUG=fatal-warnings,fatal-criticals,gc-friendly 527 528VALGRIND_LOG_COMPILER = \ 529 $(valgrind_lt) \ 530 $(VALGRIND) $(VALGRIND_SUPPRESSIONS) --error-exitcode=1 $(VALGRIND_FLAGS) 531 532define valgrind_tool_rule 533check-valgrind-$(1)-am: 534ifeq ($$(VALGRIND_ENABLED)-$$(ENABLE_VALGRIND_$(1)),yes-yes) 535ifneq ($$(TESTS),) 536 $$(valgrind_v_use)$$(MAKE) check-TESTS \ 537 TESTS_ENVIRONMENT="$$(VALGRIND_TESTS_ENVIRONMENT)" \ 538 LOG_COMPILER="$$(VALGRIND_LOG_COMPILER)" \ 539 LOG_FLAGS="$$(valgrind_$(1)_flags)" \ 540 TEST_SUITE_LOG=test-suite-$(1).log 541endif 542else ifeq ($$(VALGRIND_ENABLED),yes) 543 @echo "Need to reconfigure with --enable-valgrind-$(1)" 544else 545 @echo "Need to reconfigure with --enable-valgrind" 546endif 547endef 548 549$(foreach tool,$(valgrind_tools),$(eval $(call valgrind_tool_rule,$(tool)))) 550 551A''M_DISTCHECK_CONFIGURE_FLAGS ?= 552A''M_DISTCHECK_CONFIGURE_FLAGS += --disable-valgrind 553 554MOSTLYCLEANFILES ?= 555MOSTLYCLEANFILES += $(valgrind_log_files) 556 557.PHONY: check-valgrind $(add-prefix check-valgrind-,$(valgrind_tools)) 558'] 559 560 AC_SUBST([VALGRIND_CHECK_RULES]) 561 m4_ifdef([_AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE([VALGRIND_CHECK_RULES])]) 562]) 563