configure.ac revision 99b0fbbe6975bf2af1387f75d961ad84fb108276
1dnl Process this file with autoconf to produce a configure script. 2AC_INIT([Makefile.in]) 3 4dnl ============================================================================ 5dnl Custom macro definitions. 6 7dnl JE_CFLAGS_APPEND(cflag) 8AC_DEFUN([JE_CFLAGS_APPEND], 9[ 10AC_MSG_CHECKING([whether compiler supports $1]) 11TCFLAGS="${CFLAGS}" 12if test "x${CFLAGS}" = "x" ; then 13 CFLAGS="$1" 14else 15 CFLAGS="${CFLAGS} $1" 16fi 17AC_COMPILE_IFELSE([AC_LANG_PROGRAM( 18[[ 19]], [[ 20 return 0; 21]])], 22 [je_cv_cflags_appended=$1] 23 AC_MSG_RESULT([yes]), 24 [je_cv_cflags_appended=] 25 AC_MSG_RESULT([no]) 26 [CFLAGS="${TCFLAGS}"] 27) 28]) 29 30dnl JE_COMPILABLE(label, hcode, mcode, rvar) 31dnl 32dnl Use AC_LINK_IFELSE() rather than AC_COMPILE_IFELSE() so that linker errors 33dnl cause failure. 34AC_DEFUN([JE_COMPILABLE], 35[ 36AC_CACHE_CHECK([whether $1 is compilable], 37 [$4], 38 [AC_LINK_IFELSE([AC_LANG_PROGRAM([$2], 39 [$3])], 40 [$4=yes], 41 [$4=no])]) 42]) 43 44dnl ============================================================================ 45 46dnl Library revision. 47rev=1 48AC_SUBST([rev]) 49 50srcroot=$srcdir 51if test "x${srcroot}" = "x." ; then 52 srcroot="" 53else 54 srcroot="${srcroot}/" 55fi 56AC_SUBST([srcroot]) 57abs_srcroot="`cd \"${srcdir}\"; pwd`/" 58AC_SUBST([abs_srcroot]) 59 60objroot="" 61AC_SUBST([objroot]) 62abs_objroot="`pwd`/" 63AC_SUBST([abs_objroot]) 64 65dnl Munge install path variables. 66if test "x$prefix" = "xNONE" ; then 67 prefix="/usr/local" 68fi 69if test "x$exec_prefix" = "xNONE" ; then 70 exec_prefix=$prefix 71fi 72PREFIX=$prefix 73AC_SUBST([PREFIX]) 74BINDIR=`eval echo $bindir` 75BINDIR=`eval echo $BINDIR` 76AC_SUBST([BINDIR]) 77INCLUDEDIR=`eval echo $includedir` 78INCLUDEDIR=`eval echo $INCLUDEDIR` 79AC_SUBST([INCLUDEDIR]) 80LIBDIR=`eval echo $libdir` 81LIBDIR=`eval echo $LIBDIR` 82AC_SUBST([LIBDIR]) 83DATADIR=`eval echo $datadir` 84DATADIR=`eval echo $DATADIR` 85AC_SUBST([DATADIR]) 86MANDIR=`eval echo $mandir` 87MANDIR=`eval echo $MANDIR` 88AC_SUBST([MANDIR]) 89 90dnl Support for building documentation. 91AC_PATH_PROG([XSLTPROC], [xsltproc], [false], [$PATH]) 92if test -d "/usr/share/xml/docbook/stylesheet/docbook-xsl" ; then 93 DEFAULT_XSLROOT="/usr/share/xml/docbook/stylesheet/docbook-xsl" 94elif test -d "/usr/share/sgml/docbook/xsl-stylesheets" ; then 95 DEFAULT_XSLROOT="/usr/share/sgml/docbook/xsl-stylesheets" 96else 97 dnl Documentation building will fail if this default gets used. 98 DEFAULT_XSLROOT="" 99fi 100AC_ARG_WITH([xslroot], 101 [AS_HELP_STRING([--with-xslroot=<path>], [XSL stylesheet root path])], [ 102if test "x$with_xslroot" = "xno" ; then 103 XSLROOT="${DEFAULT_XSLROOT}" 104else 105 XSLROOT="${with_xslroot}" 106fi 107], 108 XSLROOT="${DEFAULT_XSLROOT}" 109) 110AC_SUBST([XSLROOT]) 111 112dnl If CFLAGS isn't defined, set CFLAGS to something reasonable. Otherwise, 113dnl just prevent autoconf from molesting CFLAGS. 114CFLAGS=$CFLAGS 115AC_PROG_CC 116if test "x$GCC" != "xyes" ; then 117 AC_CACHE_CHECK([whether compiler is MSVC], 118 [je_cv_msvc], 119 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], 120 [ 121#ifndef _MSC_VER 122 int fail[-1]; 123#endif 124])], 125 [je_cv_msvc=yes], 126 [je_cv_msvc=no])]) 127fi 128 129if test "x$CFLAGS" = "x" ; then 130 no_CFLAGS="yes" 131 if test "x$GCC" = "xyes" ; then 132 JE_CFLAGS_APPEND([-std=gnu99]) 133 if test "x$je_cv_cflags_appended" = "x-std=gnu99" ; then 134 AC_DEFINE_UNQUOTED([JEMALLOC_HAS_RESTRICT]) 135 fi 136 JE_CFLAGS_APPEND([-Wall]) 137 JE_CFLAGS_APPEND([-pipe]) 138 JE_CFLAGS_APPEND([-g3]) 139 elif test "x$je_cv_msvc" = "xyes" ; then 140 CC="$CC -nologo" 141 JE_CFLAGS_APPEND([-Zi]) 142 JE_CFLAGS_APPEND([-MT]) 143 JE_CFLAGS_APPEND([-W3]) 144 CPPFLAGS="$CPPFLAGS -I${srcroot}/include/msvc_compat" 145 fi 146fi 147dnl Append EXTRA_CFLAGS to CFLAGS, if defined. 148if test "x$EXTRA_CFLAGS" != "x" ; then 149 JE_CFLAGS_APPEND([$EXTRA_CFLAGS]) 150fi 151AC_PROG_CPP 152 153AC_CHECK_SIZEOF([void *]) 154if test "x${ac_cv_sizeof_void_p}" = "x8" ; then 155 LG_SIZEOF_PTR=3 156elif test "x${ac_cv_sizeof_void_p}" = "x4" ; then 157 LG_SIZEOF_PTR=2 158else 159 AC_MSG_ERROR([Unsupported pointer size: ${ac_cv_sizeof_void_p}]) 160fi 161AC_DEFINE_UNQUOTED([LG_SIZEOF_PTR], [$LG_SIZEOF_PTR]) 162 163AC_CHECK_SIZEOF([int]) 164if test "x${ac_cv_sizeof_int}" = "x8" ; then 165 LG_SIZEOF_INT=3 166elif test "x${ac_cv_sizeof_int}" = "x4" ; then 167 LG_SIZEOF_INT=2 168else 169 AC_MSG_ERROR([Unsupported int size: ${ac_cv_sizeof_int}]) 170fi 171AC_DEFINE_UNQUOTED([LG_SIZEOF_INT], [$LG_SIZEOF_INT]) 172 173AC_CHECK_SIZEOF([long]) 174if test "x${ac_cv_sizeof_long}" = "x8" ; then 175 LG_SIZEOF_LONG=3 176elif test "x${ac_cv_sizeof_long}" = "x4" ; then 177 LG_SIZEOF_LONG=2 178else 179 AC_MSG_ERROR([Unsupported long size: ${ac_cv_sizeof_long}]) 180fi 181AC_DEFINE_UNQUOTED([LG_SIZEOF_LONG], [$LG_SIZEOF_LONG]) 182 183AC_CHECK_SIZEOF([intmax_t]) 184if test "x${ac_cv_sizeof_intmax_t}" = "x16" ; then 185 LG_SIZEOF_INTMAX_T=4 186elif test "x${ac_cv_sizeof_intmax_t}" = "x8" ; then 187 LG_SIZEOF_INTMAX_T=3 188elif test "x${ac_cv_sizeof_intmax_t}" = "x4" ; then 189 LG_SIZEOF_INTMAX_T=2 190else 191 AC_MSG_ERROR([Unsupported intmax_t size: ${ac_cv_sizeof_intmax_t}]) 192fi 193AC_DEFINE_UNQUOTED([LG_SIZEOF_INTMAX_T], [$LG_SIZEOF_INTMAX_T]) 194 195AC_CANONICAL_HOST 196dnl CPU-specific settings. 197CPU_SPINWAIT="" 198case "${host_cpu}" in 199 i[[345]]86) 200 ;; 201 i686) 202 JE_COMPILABLE([__asm__], [], [[__asm__ volatile("pause"); return 0;]], 203 [je_cv_asm]) 204 if test "x${je_cv_asm}" = "xyes" ; then 205 CPU_SPINWAIT='__asm__ volatile("pause")' 206 fi 207 AC_DEFINE_UNQUOTED([HAVE_SSE2], [ ]) 208 ;; 209 x86_64) 210 JE_COMPILABLE([__asm__ syntax], [], 211 [[__asm__ volatile("pause"); return 0;]], [je_cv_asm]) 212 if test "x${je_cv_asm}" = "xyes" ; then 213 CPU_SPINWAIT='__asm__ volatile("pause")' 214 fi 215 AC_DEFINE_UNQUOTED([HAVE_SSE2], [ ]) 216 ;; 217 powerpc) 218 AC_DEFINE_UNQUOTED([HAVE_ALTIVEC], [ ]) 219 ;; 220 *) 221 ;; 222esac 223AC_DEFINE_UNQUOTED([CPU_SPINWAIT], [$CPU_SPINWAIT]) 224 225LD_PRELOAD_VAR="LD_PRELOAD" 226so="so" 227importlib="${so}" 228o="$ac_objext" 229a="a" 230exe="$ac_exeext" 231libprefix="lib" 232DSO_LDFLAGS='-shared -Wl,-soname,$(@F)' 233RPATH='-Wl,-rpath,$(1)' 234SOREV="${so}.${rev}" 235PIC_CFLAGS='-fPIC -DPIC' 236CTARGET='-o $@' 237LDTARGET='-o $@' 238EXTRA_LDFLAGS= 239ARFLAGS='crus' 240AROUT=' $@' 241CC_MM=1 242 243AN_MAKEVAR([AR], [AC_PROG_AR]) 244AN_PROGRAM([ar], [AC_PROG_AR]) 245AC_DEFUN([AC_PROG_AR], [AC_CHECK_TOOL(AR, ar, :)]) 246AC_PROG_AR 247 248dnl Platform-specific settings. abi and RPATH can probably be determined 249dnl programmatically, but doing so is error-prone, which makes it generally 250dnl not worth the trouble. 251dnl 252dnl Define cpp macros in CPPFLAGS, rather than doing AC_DEFINE(macro), since the 253dnl definitions need to be seen before any headers are included, which is a pain 254dnl to make happen otherwise. 255default_munmap="1" 256JEMALLOC_USABLE_SIZE_CONST="const" 257case "${host}" in 258 *-*-darwin*) 259 CFLAGS="$CFLAGS" 260 abi="macho" 261 AC_DEFINE([JEMALLOC_PURGE_MADVISE_FREE], [ ]) 262 RPATH="" 263 LD_PRELOAD_VAR="DYLD_INSERT_LIBRARIES" 264 so="dylib" 265 importlib="${so}" 266 force_tls="0" 267 DSO_LDFLAGS='-shared -Wl,-dylib_install_name,$(@F)' 268 SOREV="${rev}.${so}" 269 sbrk_deprecated="1" 270 ;; 271 *-*-freebsd*) 272 CFLAGS="$CFLAGS" 273 abi="elf" 274 AC_DEFINE([JEMALLOC_PURGE_MADVISE_FREE], [ ]) 275 force_lazy_lock="1" 276 ;; 277 *-*-linux*) 278 CFLAGS="$CFLAGS" 279 CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE" 280 abi="elf" 281 AC_DEFINE([JEMALLOC_HAS_ALLOCA_H]) 282 AC_DEFINE([JEMALLOC_PURGE_MADVISE_DONTNEED], [ ]) 283 AC_DEFINE([JEMALLOC_THREADED_INIT], [ ]) 284 JEMALLOC_USABLE_SIZE_CONST="" 285 default_munmap="0" 286 ;; 287 *-*-netbsd*) 288 AC_MSG_CHECKING([ABI]) 289 AC_COMPILE_IFELSE([AC_LANG_PROGRAM( 290[[#ifdef __ELF__ 291/* ELF */ 292#else 293#error aout 294#endif 295]])], 296 [CFLAGS="$CFLAGS"; abi="elf"], 297 [abi="aout"]) 298 AC_MSG_RESULT([$abi]) 299 AC_DEFINE([JEMALLOC_PURGE_MADVISE_FREE], [ ]) 300 ;; 301 *-*-solaris2*) 302 CFLAGS="$CFLAGS" 303 abi="elf" 304 AC_DEFINE([JEMALLOC_PURGE_MADVISE_FREE], [ ]) 305 RPATH='-Wl,-R,$(1)' 306 dnl Solaris needs this for sigwait(). 307 CPPFLAGS="$CPPFLAGS -D_POSIX_PTHREAD_SEMANTICS" 308 LIBS="$LIBS -lposix4 -lsocket -lnsl" 309 ;; 310 *-ibm-aix*) 311 if "$LG_SIZEOF_PTR" = "8"; then 312 dnl 64bit AIX 313 LD_PRELOAD_VAR="LDR_PRELOAD64" 314 else 315 dnl 32bit AIX 316 LD_PRELOAD_VAR="LDR_PRELOAD" 317 fi 318 abi="xcoff" 319 ;; 320 *-*-mingw*) 321 abi="pecoff" 322 force_tls="0" 323 RPATH="" 324 so="dll" 325 if test "x$je_cv_msvc" = "xyes" ; then 326 importlib="lib" 327 DSO_LDFLAGS="-LD" 328 EXTRA_LDFLAGS="-link -DEBUG" 329 CTARGET='-Fo$@' 330 LDTARGET='-Fe$@' 331 AR='lib' 332 ARFLAGS='-nologo -out:' 333 AROUT='$@' 334 CC_MM= 335 else 336 importlib="${so}" 337 DSO_LDFLAGS="-shared" 338 fi 339 a="lib" 340 libprefix="" 341 SOREV="${so}" 342 PIC_CFLAGS="" 343 ;; 344 *) 345 AC_MSG_RESULT([Unsupported operating system: ${host}]) 346 abi="elf" 347 ;; 348esac 349AC_DEFINE_UNQUOTED([JEMALLOC_USABLE_SIZE_CONST], [$JEMALLOC_USABLE_SIZE_CONST]) 350AC_SUBST([abi]) 351AC_SUBST([RPATH]) 352AC_SUBST([LD_PRELOAD_VAR]) 353AC_SUBST([so]) 354AC_SUBST([importlib]) 355AC_SUBST([o]) 356AC_SUBST([a]) 357AC_SUBST([exe]) 358AC_SUBST([libprefix]) 359AC_SUBST([DSO_LDFLAGS]) 360AC_SUBST([EXTRA_LDFLAGS]) 361AC_SUBST([SOREV]) 362AC_SUBST([PIC_CFLAGS]) 363AC_SUBST([CTARGET]) 364AC_SUBST([LDTARGET]) 365AC_SUBST([MKLIB]) 366AC_SUBST([ARFLAGS]) 367AC_SUBST([AROUT]) 368AC_SUBST([CC_MM]) 369 370JE_COMPILABLE([__attribute__ syntax], 371 [static __attribute__((unused)) void foo(void){}], 372 [], 373 [je_cv_attribute]) 374if test "x${je_cv_attribute}" = "xyes" ; then 375 AC_DEFINE([JEMALLOC_HAVE_ATTR], [ ]) 376 if test "x${GCC}" = "xyes" -a "x${abi}" = "xelf"; then 377 JE_CFLAGS_APPEND([-fvisibility=hidden]) 378 fi 379fi 380dnl Check for tls_model attribute support (clang 3.0 still lacks support). 381SAVED_CFLAGS="${CFLAGS}" 382JE_CFLAGS_APPEND([-Werror]) 383JE_COMPILABLE([tls_model attribute], [], 384 [static __thread int 385 __attribute__((tls_model("initial-exec"))) foo; 386 foo = 0;], 387 [je_cv_tls_model]) 388CFLAGS="${SAVED_CFLAGS}" 389if test "x${je_cv_tls_model}" = "xyes" ; then 390 AC_DEFINE([JEMALLOC_TLS_MODEL], 391 [__attribute__((tls_model("initial-exec")))]) 392else 393 AC_DEFINE([JEMALLOC_TLS_MODEL], [ ]) 394fi 395 396dnl Support optional additions to rpath. 397AC_ARG_WITH([rpath], 398 [AS_HELP_STRING([--with-rpath=<rpath>], [Colon-separated rpath (ELF systems only)])], 399if test "x$with_rpath" = "xno" ; then 400 RPATH_EXTRA= 401else 402 RPATH_EXTRA="`echo $with_rpath | tr \":\" \" \"`" 403fi, 404 RPATH_EXTRA= 405) 406AC_SUBST([RPATH_EXTRA]) 407 408dnl Disable rules that do automatic regeneration of configure output by default. 409AC_ARG_ENABLE([autogen], 410 [AS_HELP_STRING([--enable-autogen], [Automatically regenerate configure output])], 411if test "x$enable_autogen" = "xno" ; then 412 enable_autogen="0" 413else 414 enable_autogen="1" 415fi 416, 417enable_autogen="0" 418) 419AC_SUBST([enable_autogen]) 420 421AC_PROG_INSTALL 422AC_PROG_RANLIB 423AC_PATH_PROG([LD], [ld], [false], [$PATH]) 424AC_PATH_PROG([AUTOCONF], [autoconf], [false], [$PATH]) 425 426public_syms="malloc_conf malloc_message malloc calloc posix_memalign aligned_alloc realloc free mallocx rallocx xallocx sallocx dallocx nallocx mallctl mallctlnametomib mallctlbymib malloc_stats_print malloc_usable_size" 427 428dnl Check for allocator-related functions that should be wrapped. 429AC_CHECK_FUNC([memalign], 430 [AC_DEFINE([JEMALLOC_OVERRIDE_MEMALIGN], [ ]) 431 public_syms="${public_syms} memalign"]) 432AC_CHECK_FUNC([valloc], 433 [AC_DEFINE([JEMALLOC_OVERRIDE_VALLOC], [ ]) 434 public_syms="${public_syms} valloc"]) 435 436dnl Support the experimental API by default. 437AC_ARG_ENABLE([experimental], 438 [AS_HELP_STRING([--disable-experimental], 439 [Disable support for the experimental API])], 440[if test "x$enable_experimental" = "xno" ; then 441 enable_experimental="0" 442else 443 enable_experimental="1" 444fi 445], 446[enable_experimental="1"] 447) 448if test "x$enable_experimental" = "x1" ; then 449 AC_DEFINE([JEMALLOC_EXPERIMENTAL], [ ]) 450 public_syms="${public_syms} allocm dallocm nallocm rallocm sallocm" 451fi 452AC_SUBST([enable_experimental]) 453 454dnl Do not compute test code coverage by default. 455GCOV_FLAGS= 456AC_ARG_ENABLE([code-coverage], 457 [AS_HELP_STRING([--enable-code-coverage], 458 [Enable code coverage])], 459[if test "x$enable_code_coverage" = "xno" ; then 460 enable_code_coverage="0" 461else 462 enable_code_coverage="1" 463fi 464], 465[enable_code_coverage="0"] 466) 467if test "x$enable_code_coverage" = "x1" ; then 468 deoptimize="no" 469 echo "$CFLAGS $EXTRA_CFLAGS" | grep '\-O' >/dev/null || deoptimize="yes" 470 if test "x${deoptimize}" = "xyes" ; then 471 JE_CFLAGS_APPEND([-O0]) 472 fi 473 JE_CFLAGS_APPEND([-fprofile-arcs -ftest-coverage]) 474 EXTRA_LDFLAGS="$EXTRA_LDFLAGS -fprofile-arcs -ftest-coverage" 475 AC_DEFINE([JEMALLOC_CODE_COVERAGE], [ ]) 476fi 477AC_SUBST([enable_code_coverage]) 478 479dnl Perform no name mangling by default. 480AC_ARG_WITH([mangling], 481 [AS_HELP_STRING([--with-mangling=<map>], [Mangle symbols in <map>])], 482 [mangling_map="$with_mangling"], [mangling_map=""]) 483 484dnl Do not prefix public APIs by default. 485AC_ARG_WITH([jemalloc_prefix], 486 [AS_HELP_STRING([--with-jemalloc-prefix=<prefix>], [Prefix to prepend to all public APIs])], 487 [JEMALLOC_PREFIX="$with_jemalloc_prefix"], 488 [if test "x$abi" != "xmacho" -a "x$abi" != "xpecoff"; then 489 JEMALLOC_PREFIX="" 490else 491 JEMALLOC_PREFIX="je_" 492fi] 493) 494if test "x$JEMALLOC_PREFIX" != "x" ; then 495 JEMALLOC_CPREFIX=`echo ${JEMALLOC_PREFIX} | tr "a-z" "A-Z"` 496 AC_DEFINE_UNQUOTED([JEMALLOC_PREFIX], ["$JEMALLOC_PREFIX"]) 497 AC_DEFINE_UNQUOTED([JEMALLOC_CPREFIX], ["$JEMALLOC_CPREFIX"]) 498fi 499 500AC_ARG_WITH([export], 501 [AS_HELP_STRING([--without-export], [disable exporting jemalloc public APIs])], 502 [if test "x$with_export" = "xno"; then 503 AC_DEFINE([JEMALLOC_EXPORT],[]) 504fi] 505) 506 507dnl Mangle library-private APIs. 508AC_ARG_WITH([private_namespace], 509 [AS_HELP_STRING([--with-private-namespace=<prefix>], [Prefix to prepend to all library-private APIs])], 510 [JEMALLOC_PRIVATE_NAMESPACE="${with_private_namespace}je_"], 511 [JEMALLOC_PRIVATE_NAMESPACE="je_"] 512) 513AC_DEFINE_UNQUOTED([JEMALLOC_PRIVATE_NAMESPACE], [$JEMALLOC_PRIVATE_NAMESPACE]) 514private_namespace="$JEMALLOC_PRIVATE_NAMESPACE" 515AC_SUBST([private_namespace]) 516 517dnl Do not add suffix to installed files by default. 518AC_ARG_WITH([install_suffix], 519 [AS_HELP_STRING([--with-install-suffix=<suffix>], [Suffix to append to all installed files])], 520 [INSTALL_SUFFIX="$with_install_suffix"], 521 [INSTALL_SUFFIX=] 522) 523install_suffix="$INSTALL_SUFFIX" 524AC_SUBST([install_suffix]) 525 526dnl Substitute @je_@ in jemalloc_protos.h.in, primarily to make generation of 527dnl jemalloc_protos_jet.h easy. 528je_="je_" 529AC_SUBST([je_]) 530 531cfgoutputs_in="${srcroot}Makefile.in" 532cfgoutputs_in="${cfgoutputs_in} ${srcroot}doc/html.xsl.in" 533cfgoutputs_in="${cfgoutputs_in} ${srcroot}doc/manpages.xsl.in" 534cfgoutputs_in="${cfgoutputs_in} ${srcroot}doc/jemalloc.xml.in" 535cfgoutputs_in="${cfgoutputs_in} ${srcroot}include/jemalloc/jemalloc_macros.h.in" 536cfgoutputs_in="${cfgoutputs_in} ${srcroot}include/jemalloc/jemalloc_protos.h.in" 537cfgoutputs_in="${cfgoutputs_in} ${srcroot}include/jemalloc/internal/jemalloc_internal.h.in" 538cfgoutputs_in="${cfgoutputs_in} ${srcroot}test/test.sh.in" 539cfgoutputs_in="${cfgoutputs_in} ${srcroot}test/include/test/jemalloc_test.h.in" 540 541cfgoutputs_out="Makefile" 542cfgoutputs_out="${cfgoutputs_out} doc/html.xsl" 543cfgoutputs_out="${cfgoutputs_out} doc/manpages.xsl" 544cfgoutputs_out="${cfgoutputs_out} doc/jemalloc.xml" 545cfgoutputs_out="${cfgoutputs_out} include/jemalloc/jemalloc_macros.h" 546cfgoutputs_out="${cfgoutputs_out} include/jemalloc/jemalloc_protos.h" 547cfgoutputs_out="${cfgoutputs_out} include/jemalloc/internal/jemalloc_internal.h" 548cfgoutputs_out="${cfgoutputs_out} test/test.sh" 549cfgoutputs_out="${cfgoutputs_out} test/include/test/jemalloc_test.h" 550 551cfgoutputs_tup="Makefile" 552cfgoutputs_tup="${cfgoutputs_tup} doc/html.xsl:doc/html.xsl.in" 553cfgoutputs_tup="${cfgoutputs_tup} doc/manpages.xsl:doc/manpages.xsl.in" 554cfgoutputs_tup="${cfgoutputs_tup} doc/jemalloc.xml:doc/jemalloc.xml.in" 555cfgoutputs_tup="${cfgoutputs_tup} include/jemalloc/jemalloc_macros.h:include/jemalloc/jemalloc_macros.h.in" 556cfgoutputs_tup="${cfgoutputs_tup} include/jemalloc/jemalloc_protos.h:include/jemalloc/jemalloc_protos.h.in" 557cfgoutputs_tup="${cfgoutputs_tup} include/jemalloc/internal/jemalloc_internal.h" 558cfgoutputs_tup="${cfgoutputs_tup} test/test.sh:test/test.sh.in" 559cfgoutputs_tup="${cfgoutputs_tup} test/include/test/jemalloc_test.h:test/include/test/jemalloc_test.h.in" 560 561cfghdrs_in="${srcroot}include/jemalloc/jemalloc_defs.h.in" 562cfghdrs_in="${cfghdrs_in} ${srcroot}include/jemalloc/internal/jemalloc_internal_defs.h.in" 563cfghdrs_in="${cfghdrs_in} ${srcroot}include/jemalloc/internal/private_namespace.sh" 564cfghdrs_in="${cfghdrs_in} ${srcroot}include/jemalloc/internal/private_unnamespace.sh" 565cfghdrs_in="${cfghdrs_in} ${srcroot}include/jemalloc/internal/private_symbols.txt" 566cfghdrs_in="${cfghdrs_in} ${srcroot}include/jemalloc/internal/public_namespace.sh" 567cfghdrs_in="${cfghdrs_in} ${srcroot}include/jemalloc/internal/public_unnamespace.sh" 568cfghdrs_in="${cfghdrs_in} ${srcroot}include/jemalloc/internal/size_classes.sh" 569cfghdrs_in="${cfghdrs_in} ${srcroot}include/jemalloc/jemalloc_rename.sh" 570cfghdrs_in="${cfghdrs_in} ${srcroot}include/jemalloc/jemalloc_mangle.sh" 571cfghdrs_in="${cfghdrs_in} ${srcroot}include/jemalloc/jemalloc.sh" 572cfghdrs_in="${cfghdrs_in} ${srcroot}test/include/test/jemalloc_test_defs.h.in" 573 574cfghdrs_out="include/jemalloc/jemalloc_defs.h" 575cfghdrs_out="${cfghdrs_out} include/jemalloc/jemalloc${install_suffix}.h" 576cfghdrs_out="${cfghdrs_out} include/jemalloc/internal/private_namespace.h" 577cfghdrs_out="${cfghdrs_out} include/jemalloc/internal/private_unnamespace.h" 578cfghdrs_out="${cfghdrs_out} include/jemalloc/internal/public_symbols.txt" 579cfghdrs_out="${cfghdrs_out} include/jemalloc/internal/public_namespace.h" 580cfghdrs_out="${cfghdrs_out} include/jemalloc/internal/public_unnamespace.h" 581cfghdrs_out="${cfghdrs_out} include/jemalloc/internal/size_classes.h" 582cfghdrs_out="${cfghdrs_out} include/jemalloc/jemalloc_protos_jet.h" 583cfghdrs_out="${cfghdrs_out} include/jemalloc/jemalloc_rename.h" 584cfghdrs_out="${cfghdrs_out} include/jemalloc/jemalloc_mangle.h" 585cfghdrs_out="${cfghdrs_out} include/jemalloc/jemalloc_mangle_jet.h" 586cfghdrs_out="${cfghdrs_out} include/jemalloc/internal/jemalloc_internal_defs.h" 587cfghdrs_out="${cfghdrs_out} test/include/test/jemalloc_test_defs.h" 588 589cfghdrs_tup="include/jemalloc/jemalloc_defs.h:include/jemalloc/jemalloc_defs.h.in" 590cfghdrs_tup="${cfghdrs_tup} include/jemalloc/internal/jemalloc_internal_defs.h:${srcroot}include/jemalloc/internal/jemalloc_internal_defs.h.in" 591cfghdrs_tup="${cfghdrs_tup} test/include/test/jemalloc_test_defs.h:${srcroot}test/include/test/jemalloc_test_defs.h.in" 592 593dnl Do not silence irrelevant compiler warnings by default, since enabling this 594dnl option incurs a performance penalty. 595AC_ARG_ENABLE([cc-silence], 596 [AS_HELP_STRING([--enable-cc-silence], 597 [Silence irrelevant compiler warnings])], 598[if test "x$enable_cc_silence" = "xno" ; then 599 enable_cc_silence="0" 600else 601 enable_cc_silence="1" 602fi 603], 604[enable_cc_silence="0"] 605) 606if test "x$enable_cc_silence" = "x1" ; then 607 AC_DEFINE([JEMALLOC_CC_SILENCE], [ ]) 608fi 609 610dnl Do not compile with debugging by default. 611AC_ARG_ENABLE([debug], 612 [AS_HELP_STRING([--enable-debug], [Build debugging code (implies --enable-ivsalloc)])], 613[if test "x$enable_debug" = "xno" ; then 614 enable_debug="0" 615else 616 enable_debug="1" 617fi 618], 619[enable_debug="0"] 620) 621if test "x$enable_debug" = "x1" ; then 622 AC_DEFINE([JEMALLOC_DEBUG], [ ]) 623 enable_ivsalloc="1" 624fi 625AC_SUBST([enable_debug]) 626 627dnl Do not validate pointers by default. 628AC_ARG_ENABLE([ivsalloc], 629 [AS_HELP_STRING([--enable-ivsalloc], [Validate pointers passed through the public API])], 630[if test "x$enable_ivsalloc" = "xno" ; then 631 enable_ivsalloc="0" 632else 633 enable_ivsalloc="1" 634fi 635], 636[enable_ivsalloc="0"] 637) 638if test "x$enable_ivsalloc" = "x1" ; then 639 AC_DEFINE([JEMALLOC_IVSALLOC], [ ]) 640fi 641 642dnl Only optimize if not debugging. 643if test "x$enable_debug" = "x0" -a "x$no_CFLAGS" = "xyes" ; then 644 dnl Make sure that an optimization flag was not specified in EXTRA_CFLAGS. 645 optimize="no" 646 echo "$CFLAGS $EXTRA_CFLAGS" | grep '\-O' >/dev/null || optimize="yes" 647 if test "x${optimize}" = "xyes" ; then 648 if test "x$GCC" = "xyes" ; then 649 JE_CFLAGS_APPEND([-O3]) 650 JE_CFLAGS_APPEND([-funroll-loops]) 651 elif test "x$je_cv_msvc" = "xyes" ; then 652 JE_CFLAGS_APPEND([-O2]) 653 else 654 JE_CFLAGS_APPEND([-O]) 655 fi 656 fi 657fi 658 659dnl Enable statistics calculation by default. 660AC_ARG_ENABLE([stats], 661 [AS_HELP_STRING([--disable-stats], 662 [Disable statistics calculation/reporting])], 663[if test "x$enable_stats" = "xno" ; then 664 enable_stats="0" 665else 666 enable_stats="1" 667fi 668], 669[enable_stats="1"] 670) 671if test "x$enable_stats" = "x1" ; then 672 AC_DEFINE([JEMALLOC_STATS], [ ]) 673fi 674AC_SUBST([enable_stats]) 675 676dnl Do not enable profiling by default. 677AC_ARG_ENABLE([prof], 678 [AS_HELP_STRING([--enable-prof], [Enable allocation profiling])], 679[if test "x$enable_prof" = "xno" ; then 680 enable_prof="0" 681else 682 enable_prof="1" 683fi 684], 685[enable_prof="0"] 686) 687if test "x$enable_prof" = "x1" ; then 688 backtrace_method="" 689else 690 backtrace_method="N/A" 691fi 692 693AC_ARG_ENABLE([prof-libunwind], 694 [AS_HELP_STRING([--enable-prof-libunwind], [Use libunwind for backtracing])], 695[if test "x$enable_prof_libunwind" = "xno" ; then 696 enable_prof_libunwind="0" 697else 698 enable_prof_libunwind="1" 699fi 700], 701[enable_prof_libunwind="0"] 702) 703AC_ARG_WITH([static_libunwind], 704 [AS_HELP_STRING([--with-static-libunwind=<libunwind.a>], 705 [Path to static libunwind library; use rather than dynamically linking])], 706if test "x$with_static_libunwind" = "xno" ; then 707 LUNWIND="-lunwind" 708else 709 if test ! -f "$with_static_libunwind" ; then 710 AC_MSG_ERROR([Static libunwind not found: $with_static_libunwind]) 711 fi 712 LUNWIND="$with_static_libunwind" 713fi, 714 LUNWIND="-lunwind" 715) 716if test "x$backtrace_method" = "x" -a "x$enable_prof_libunwind" = "x1" ; then 717 AC_CHECK_HEADERS([libunwind.h], , [enable_prof_libunwind="0"]) 718 if test "x$LUNWIND" = "x-lunwind" ; then 719 AC_CHECK_LIB([unwind], [backtrace], [LIBS="$LIBS $LUNWIND"], 720 [enable_prof_libunwind="0"]) 721 else 722 LIBS="$LIBS $LUNWIND" 723 fi 724 if test "x${enable_prof_libunwind}" = "x1" ; then 725 backtrace_method="libunwind" 726 AC_DEFINE([JEMALLOC_PROF_LIBUNWIND], [ ]) 727 fi 728fi 729 730AC_ARG_ENABLE([prof-libgcc], 731 [AS_HELP_STRING([--disable-prof-libgcc], 732 [Do not use libgcc for backtracing])], 733[if test "x$enable_prof_libgcc" = "xno" ; then 734 enable_prof_libgcc="0" 735else 736 enable_prof_libgcc="1" 737fi 738], 739[enable_prof_libgcc="1"] 740) 741if test "x$backtrace_method" = "x" -a "x$enable_prof_libgcc" = "x1" \ 742 -a "x$GCC" = "xyes" ; then 743 AC_CHECK_HEADERS([unwind.h], , [enable_prof_libgcc="0"]) 744 AC_CHECK_LIB([gcc], [_Unwind_Backtrace], [LIBS="$LIBS -lgcc"], [enable_prof_libgcc="0"]) 745 dnl The following is conservative, in that it only has entries for CPUs on 746 dnl which jemalloc has been tested. 747 AC_MSG_CHECKING([libgcc-based backtracing reliability on ${host_cpu}]) 748 case "${host_cpu}" in 749 i[[3456]]86) 750 AC_MSG_RESULT([unreliable]) 751 enable_prof_libgcc="0"; 752 ;; 753 x86_64) 754 AC_MSG_RESULT([reliable]) 755 ;; 756 *) 757 AC_MSG_RESULT([unreliable]) 758 enable_prof_libgcc="0"; 759 ;; 760 esac 761 if test "x${enable_prof_libgcc}" = "x1" ; then 762 backtrace_method="libgcc" 763 AC_DEFINE([JEMALLOC_PROF_LIBGCC], [ ]) 764 fi 765else 766 enable_prof_libgcc="0" 767fi 768 769AC_ARG_ENABLE([prof-gcc], 770 [AS_HELP_STRING([--disable-prof-gcc], 771 [Do not use gcc intrinsics for backtracing])], 772[if test "x$enable_prof_gcc" = "xno" ; then 773 enable_prof_gcc="0" 774else 775 enable_prof_gcc="1" 776fi 777], 778[enable_prof_gcc="1"] 779) 780if test "x$backtrace_method" = "x" -a "x$enable_prof_gcc" = "x1" \ 781 -a "x$GCC" = "xyes" ; then 782 backtrace_method="gcc intrinsics" 783 AC_DEFINE([JEMALLOC_PROF_GCC], [ ]) 784else 785 enable_prof_gcc="0" 786fi 787 788if test "x$backtrace_method" = "x" ; then 789 backtrace_method="none (disabling profiling)" 790 enable_prof="0" 791fi 792AC_MSG_CHECKING([configured backtracing method]) 793AC_MSG_RESULT([$backtrace_method]) 794if test "x$enable_prof" = "x1" ; then 795 if test "x${force_tls}" = "x0" ; then 796 AC_MSG_ERROR([Heap profiling requires TLS]); 797 fi 798 force_tls="1" 799 800 if test "x$abi" != "xpecoff"; then 801 dnl Heap profiling uses the log(3) function. 802 LIBS="$LIBS -lm" 803 fi 804 805 AC_DEFINE([JEMALLOC_PROF], [ ]) 806fi 807AC_SUBST([enable_prof]) 808 809dnl Enable thread-specific caching by default. 810AC_ARG_ENABLE([tcache], 811 [AS_HELP_STRING([--disable-tcache], [Disable per thread caches])], 812[if test "x$enable_tcache" = "xno" ; then 813 enable_tcache="0" 814else 815 enable_tcache="1" 816fi 817], 818[enable_tcache="1"] 819) 820if test "x$enable_tcache" = "x1" ; then 821 AC_DEFINE([JEMALLOC_TCACHE], [ ]) 822fi 823AC_SUBST([enable_tcache]) 824 825dnl Disable mremap() for huge realloc() by default. 826AC_ARG_ENABLE([mremap], 827 [AS_HELP_STRING([--enable-mremap], [Enable mremap(2) for huge realloc()])], 828[if test "x$enable_mremap" = "xno" ; then 829 enable_mremap="0" 830else 831 enable_mremap="1" 832fi 833], 834[enable_mremap="0"] 835) 836if test "x$enable_mremap" = "x1" ; then 837 JE_COMPILABLE([mremap(...MREMAP_FIXED...)], [ 838#define _GNU_SOURCE 839#include <sys/mman.h> 840], [ 841void *p = mremap((void *)0, 0, 0, MREMAP_MAYMOVE|MREMAP_FIXED, (void *)0); 842], [je_cv_mremap_fixed]) 843 if test "x${je_cv_mremap_fixed}" = "xno" ; then 844 enable_mremap="0" 845 fi 846fi 847if test "x$enable_mremap" = "x1" ; then 848 AC_DEFINE([JEMALLOC_MREMAP], [ ]) 849fi 850AC_SUBST([enable_mremap]) 851 852dnl Enable VM deallocation via munmap() by default. 853AC_ARG_ENABLE([munmap], 854 [AS_HELP_STRING([--disable-munmap], [Disable VM deallocation via munmap(2)])], 855[if test "x$enable_munmap" = "xno" ; then 856 enable_munmap="0" 857else 858 enable_munmap="1" 859fi 860], 861[enable_munmap="${default_munmap}"] 862) 863if test "x$enable_munmap" = "x1" ; then 864 AC_DEFINE([JEMALLOC_MUNMAP], [ ]) 865fi 866AC_SUBST([enable_munmap]) 867 868dnl Do not enable allocation from DSS by default. 869AC_ARG_ENABLE([dss], 870 [AS_HELP_STRING([--enable-dss], [Enable allocation from DSS])], 871[if test "x$enable_dss" = "xno" ; then 872 enable_dss="0" 873else 874 enable_dss="1" 875fi 876], 877[enable_dss="0"] 878) 879dnl Check whether the BSD/SUSv1 sbrk() exists. If not, disable DSS support. 880AC_CHECK_FUNC([sbrk], [have_sbrk="1"], [have_sbrk="0"]) 881if test "x$have_sbrk" = "x1" ; then 882 if test "x$sbrk_deprecated" == "x1" ; then 883 AC_MSG_RESULT([Disabling dss allocation because sbrk is deprecated]) 884 enable_dss="0" 885 else 886 AC_DEFINE([JEMALLOC_HAVE_SBRK], [ ]) 887 fi 888else 889 enable_dss="0" 890fi 891 892if test "x$enable_dss" = "x1" ; then 893 AC_DEFINE([JEMALLOC_DSS], [ ]) 894fi 895AC_SUBST([enable_dss]) 896 897dnl Support the junk/zero filling option by default. 898AC_ARG_ENABLE([fill], 899 [AS_HELP_STRING([--disable-fill], 900 [Disable support for junk/zero filling, quarantine, and redzones])], 901[if test "x$enable_fill" = "xno" ; then 902 enable_fill="0" 903else 904 enable_fill="1" 905fi 906], 907[enable_fill="1"] 908) 909if test "x$enable_fill" = "x1" ; then 910 AC_DEFINE([JEMALLOC_FILL], [ ]) 911fi 912AC_SUBST([enable_fill]) 913 914dnl Disable utrace(2)-based tracing by default. 915AC_ARG_ENABLE([utrace], 916 [AS_HELP_STRING([--enable-utrace], [Enable utrace(2)-based tracing])], 917[if test "x$enable_utrace" = "xno" ; then 918 enable_utrace="0" 919else 920 enable_utrace="1" 921fi 922], 923[enable_utrace="0"] 924) 925JE_COMPILABLE([utrace(2)], [ 926#include <sys/types.h> 927#include <sys/param.h> 928#include <sys/time.h> 929#include <sys/uio.h> 930#include <sys/ktrace.h> 931], [ 932 utrace((void *)0, 0); 933], [je_cv_utrace]) 934if test "x${je_cv_utrace}" = "xno" ; then 935 enable_utrace="0" 936fi 937if test "x$enable_utrace" = "x1" ; then 938 AC_DEFINE([JEMALLOC_UTRACE], [ ]) 939fi 940AC_SUBST([enable_utrace]) 941 942dnl Support Valgrind by default. 943AC_ARG_ENABLE([valgrind], 944 [AS_HELP_STRING([--disable-valgrind], [Disable support for Valgrind])], 945[if test "x$enable_valgrind" = "xno" ; then 946 enable_valgrind="0" 947else 948 enable_valgrind="1" 949fi 950], 951[enable_valgrind="1"] 952) 953if test "x$enable_valgrind" = "x1" ; then 954 JE_COMPILABLE([valgrind], [ 955#include <valgrind/valgrind.h> 956#include <valgrind/memcheck.h> 957 958#if !defined(VALGRIND_RESIZEINPLACE_BLOCK) 959# error "Incompatible Valgrind version" 960#endif 961], [], [je_cv_valgrind]) 962 if test "x${je_cv_valgrind}" = "xno" ; then 963 enable_valgrind="0" 964 fi 965 if test "x$enable_valgrind" = "x1" ; then 966 AC_DEFINE([JEMALLOC_VALGRIND], [ ]) 967 fi 968fi 969AC_SUBST([enable_valgrind]) 970 971dnl Do not support the xmalloc option by default. 972AC_ARG_ENABLE([xmalloc], 973 [AS_HELP_STRING([--enable-xmalloc], [Support xmalloc option])], 974[if test "x$enable_xmalloc" = "xno" ; then 975 enable_xmalloc="0" 976else 977 enable_xmalloc="1" 978fi 979], 980[enable_xmalloc="0"] 981) 982if test "x$enable_xmalloc" = "x1" ; then 983 AC_DEFINE([JEMALLOC_XMALLOC], [ ]) 984fi 985AC_SUBST([enable_xmalloc]) 986 987AC_CACHE_CHECK([STATIC_PAGE_SHIFT], 988 [je_cv_static_page_shift], 989 AC_RUN_IFELSE([AC_LANG_PROGRAM( 990[[ 991#include <strings.h> 992#ifdef _WIN32 993#include <windows.h> 994#else 995#include <unistd.h> 996#endif 997#include <stdio.h> 998]], 999[[ 1000 int result; 1001 FILE *f; 1002 1003#ifdef _WIN32 1004 SYSTEM_INFO si; 1005 GetSystemInfo(&si); 1006 result = si.dwPageSize; 1007#else 1008 result = sysconf(_SC_PAGESIZE); 1009#endif 1010 if (result == -1) { 1011 return 1; 1012 } 1013 result = ffsl(result) - 1; 1014 1015 f = fopen("conftest.out", "w"); 1016 if (f == NULL) { 1017 return 1; 1018 } 1019 fprintf(f, "%d\n", result); 1020 fclose(f); 1021 1022 return 0; 1023]])], 1024 [je_cv_static_page_shift=`cat conftest.out`], 1025 [je_cv_static_page_shift=undefined])) 1026 1027if test "x$je_cv_static_page_shift" != "xundefined"; then 1028 AC_DEFINE_UNQUOTED([STATIC_PAGE_SHIFT], [$je_cv_static_page_shift]) 1029else 1030 AC_MSG_ERROR([cannot determine value for STATIC_PAGE_SHIFT]) 1031fi 1032 1033dnl ============================================================================ 1034dnl jemalloc configuration. 1035dnl 1036 1037dnl Set VERSION if source directory has an embedded git repository. 1038if test -d "${srcroot}.git" ; then 1039 git describe --long --abbrev=40 > ${srcroot}VERSION 1040fi 1041jemalloc_version=`cat ${srcroot}VERSION` 1042jemalloc_version_major=`echo ${jemalloc_version} | tr ".g-" " " | awk '{print [$]1}'` 1043jemalloc_version_minor=`echo ${jemalloc_version} | tr ".g-" " " | awk '{print [$]2}'` 1044jemalloc_version_bugfix=`echo ${jemalloc_version} | tr ".g-" " " | awk '{print [$]3}'` 1045jemalloc_version_nrev=`echo ${jemalloc_version} | tr ".g-" " " | awk '{print [$]4}'` 1046jemalloc_version_gid=`echo ${jemalloc_version} | tr ".g-" " " | awk '{print [$]5}'` 1047AC_SUBST([jemalloc_version]) 1048AC_SUBST([jemalloc_version_major]) 1049AC_SUBST([jemalloc_version_minor]) 1050AC_SUBST([jemalloc_version_bugfix]) 1051AC_SUBST([jemalloc_version_nrev]) 1052AC_SUBST([jemalloc_version_gid]) 1053 1054dnl ============================================================================ 1055dnl Configure pthreads. 1056 1057if test "x$abi" != "xpecoff" ; then 1058 AC_CHECK_HEADERS([pthread.h], , [AC_MSG_ERROR([pthread.h is missing])]) 1059 dnl Some systems may embed pthreads functionality in libc; check for libpthread 1060 dnl first, but try libc too before failing. 1061 AC_CHECK_LIB([pthread], [pthread_create], [LIBS="$LIBS -lpthread"], 1062 [AC_SEARCH_LIBS([pthread_create], , , 1063 AC_MSG_ERROR([libpthread is missing]))]) 1064fi 1065 1066CPPFLAGS="$CPPFLAGS -D_REENTRANT" 1067 1068dnl Check whether the BSD-specific _malloc_thread_cleanup() exists. If so, use 1069dnl it rather than pthreads TSD cleanup functions to support cleanup during 1070dnl thread exit, in order to avoid pthreads library recursion during 1071dnl bootstrapping. 1072AC_CHECK_FUNC([_malloc_thread_cleanup], 1073 [have__malloc_thread_cleanup="1"], 1074 [have__malloc_thread_cleanup="0"] 1075 ) 1076if test "x$have__malloc_thread_cleanup" = "x1" ; then 1077 AC_DEFINE([JEMALLOC_MALLOC_THREAD_CLEANUP], [ ]) 1078 force_tls="1" 1079fi 1080 1081dnl Check whether the BSD-specific _pthread_mutex_init_calloc_cb() exists. If 1082dnl so, mutex initialization causes allocation, and we need to implement this 1083dnl callback function in order to prevent recursive allocation. 1084AC_CHECK_FUNC([_pthread_mutex_init_calloc_cb], 1085 [have__pthread_mutex_init_calloc_cb="1"], 1086 [have__pthread_mutex_init_calloc_cb="0"] 1087 ) 1088if test "x$have__pthread_mutex_init_calloc_cb" = "x1" ; then 1089 AC_DEFINE([JEMALLOC_MUTEX_INIT_CB]) 1090fi 1091 1092dnl Disable lazy locking by default. 1093AC_ARG_ENABLE([lazy_lock], 1094 [AS_HELP_STRING([--enable-lazy-lock], 1095 [Enable lazy locking (only lock when multi-threaded)])], 1096[if test "x$enable_lazy_lock" = "xno" ; then 1097 enable_lazy_lock="0" 1098else 1099 enable_lazy_lock="1" 1100fi 1101], 1102[enable_lazy_lock="0"] 1103) 1104if test "x$enable_lazy_lock" = "x0" -a "x${force_lazy_lock}" = "x1" ; then 1105 AC_MSG_RESULT([Forcing lazy-lock to avoid allocator/threading bootstrap issues]) 1106 enable_lazy_lock="1" 1107fi 1108if test "x$enable_lazy_lock" = "x1" ; then 1109 if test "x$abi" != "xpecoff" ; then 1110 AC_CHECK_HEADERS([dlfcn.h], , [AC_MSG_ERROR([dlfcn.h is missing])]) 1111 AC_CHECK_FUNC([dlsym], [], 1112 [AC_CHECK_LIB([dl], [dlsym], [LIBS="$LIBS -ldl"], 1113 [AC_MSG_ERROR([libdl is missing])]) 1114 ]) 1115 fi 1116 AC_DEFINE([JEMALLOC_LAZY_LOCK], [ ]) 1117fi 1118AC_SUBST([enable_lazy_lock]) 1119 1120AC_ARG_ENABLE([tls], 1121 [AS_HELP_STRING([--disable-tls], [Disable thread-local storage (__thread keyword)])], 1122if test "x$enable_tls" = "xno" ; then 1123 enable_tls="0" 1124else 1125 enable_tls="1" 1126fi 1127, 1128enable_tls="1" 1129) 1130if test "x${enable_tls}" = "x0" -a "x${force_tls}" = "x1" ; then 1131 AC_MSG_RESULT([Forcing TLS to avoid allocator/threading bootstrap issues]) 1132 enable_tls="1" 1133fi 1134if test "x${enable_tls}" = "x1" -a "x${force_tls}" = "x0" ; then 1135 AC_MSG_RESULT([Forcing no TLS to avoid allocator/threading bootstrap issues]) 1136 enable_tls="0" 1137fi 1138if test "x${enable_tls}" = "x1" ; then 1139AC_MSG_CHECKING([for TLS]) 1140AC_COMPILE_IFELSE([AC_LANG_PROGRAM( 1141[[ 1142 __thread int x; 1143]], [[ 1144 x = 42; 1145 1146 return 0; 1147]])], 1148 AC_MSG_RESULT([yes]), 1149 AC_MSG_RESULT([no]) 1150 enable_tls="0") 1151fi 1152AC_SUBST([enable_tls]) 1153if test "x${enable_tls}" = "x1" ; then 1154 AC_DEFINE_UNQUOTED([JEMALLOC_TLS], [ ]) 1155elif test "x${force_tls}" = "x1" ; then 1156 AC_MSG_ERROR([Failed to configure TLS, which is mandatory for correct function]) 1157fi 1158 1159dnl ============================================================================ 1160dnl Check for ffsl(3), and fail if not found. This function exists on all 1161dnl platforms that jemalloc currently has a chance of functioning on without 1162dnl modification. 1163JE_COMPILABLE([a program using ffsl], [ 1164#include <stdio.h> 1165#include <strings.h> 1166#include <string.h> 1167], [ 1168 { 1169 int rv = ffsl(0x08); 1170 printf("%d\n", rv); 1171 } 1172], [je_cv_function_ffsl]) 1173if test "x${je_cv_function_ffsl}" != "xyes" ; then 1174 AC_MSG_ERROR([Cannot build without ffsl(3)]) 1175fi 1176 1177dnl ============================================================================ 1178dnl Check for atomic(9) operations as provided on FreeBSD. 1179 1180JE_COMPILABLE([atomic(9)], [ 1181#include <sys/types.h> 1182#include <machine/atomic.h> 1183#include <inttypes.h> 1184], [ 1185 { 1186 uint32_t x32 = 0; 1187 volatile uint32_t *x32p = &x32; 1188 atomic_fetchadd_32(x32p, 1); 1189 } 1190 { 1191 unsigned long xlong = 0; 1192 volatile unsigned long *xlongp = &xlong; 1193 atomic_fetchadd_long(xlongp, 1); 1194 } 1195], [je_cv_atomic9]) 1196if test "x${je_cv_atomic9}" = "xyes" ; then 1197 AC_DEFINE([JEMALLOC_ATOMIC9]) 1198fi 1199 1200dnl ============================================================================ 1201dnl Check for atomic(3) operations as provided on Darwin. 1202 1203JE_COMPILABLE([Darwin OSAtomic*()], [ 1204#include <libkern/OSAtomic.h> 1205#include <inttypes.h> 1206], [ 1207 { 1208 int32_t x32 = 0; 1209 volatile int32_t *x32p = &x32; 1210 OSAtomicAdd32(1, x32p); 1211 } 1212 { 1213 int64_t x64 = 0; 1214 volatile int64_t *x64p = &x64; 1215 OSAtomicAdd64(1, x64p); 1216 } 1217], [je_cv_osatomic]) 1218if test "x${je_cv_osatomic}" = "xyes" ; then 1219 AC_DEFINE([JEMALLOC_OSATOMIC], [ ]) 1220fi 1221 1222dnl ============================================================================ 1223dnl Check whether __sync_{add,sub}_and_fetch() are available despite 1224dnl __GCC_HAVE_SYNC_COMPARE_AND_SWAP_n macros being undefined. 1225 1226AC_DEFUN([JE_SYNC_COMPARE_AND_SWAP_CHECK],[ 1227 AC_CACHE_CHECK([whether to force $1-bit __sync_{add,sub}_and_fetch()], 1228 [je_cv_sync_compare_and_swap_$2], 1229 [AC_LINK_IFELSE([AC_LANG_PROGRAM([ 1230 #include <stdint.h> 1231 ], 1232 [ 1233 #ifndef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_$2 1234 { 1235 uint$1_t x$1 = 0; 1236 __sync_add_and_fetch(&x$1, 42); 1237 __sync_sub_and_fetch(&x$1, 1); 1238 } 1239 #else 1240 #error __GCC_HAVE_SYNC_COMPARE_AND_SWAP_$2 is defined, no need to force 1241 #endif 1242 ])], 1243 [je_cv_sync_compare_and_swap_$2=yes], 1244 [je_cv_sync_compare_and_swap_$2=no])]) 1245 1246 if test "x${je_cv_sync_compare_and_swap_$2}" = "xyes" ; then 1247 AC_DEFINE([JE_FORCE_SYNC_COMPARE_AND_SWAP_$2], [ ]) 1248 fi 1249]) 1250 1251if test "x${je_cv_atomic9}" != "xyes" -a "x${je_cv_osatomic}" != "xyes" ; then 1252 JE_SYNC_COMPARE_AND_SWAP_CHECK(32, 4) 1253 JE_SYNC_COMPARE_AND_SWAP_CHECK(64, 8) 1254fi 1255 1256dnl ============================================================================ 1257dnl Check for spinlock(3) operations as provided on Darwin. 1258 1259JE_COMPILABLE([Darwin OSSpin*()], [ 1260#include <libkern/OSAtomic.h> 1261#include <inttypes.h> 1262], [ 1263 OSSpinLock lock = 0; 1264 OSSpinLockLock(&lock); 1265 OSSpinLockUnlock(&lock); 1266], [je_cv_osspin]) 1267if test "x${je_cv_osspin}" = "xyes" ; then 1268 AC_DEFINE([JEMALLOC_OSSPIN], [ ]) 1269fi 1270 1271dnl ============================================================================ 1272dnl Darwin-related configuration. 1273 1274AC_ARG_ENABLE([zone-allocator], 1275 [AS_HELP_STRING([--disable-zone-allocator], 1276 [Disable zone allocator for Darwin])], 1277[if test "x$enable_zone_allocator" = "xno" ; then 1278 enable_zone_allocator="0" 1279else 1280 enable_zone_allocator="1" 1281fi 1282], 1283[if test "x${abi}" = "xmacho"; then 1284 enable_zone_allocator="1" 1285fi 1286] 1287) 1288AC_SUBST([enable_zone_allocator]) 1289 1290if test "x${enable_zone_allocator}" = "x1" ; then 1291 if test "x${abi}" != "xmacho"; then 1292 AC_MSG_ERROR([--enable-zone-allocator is only supported on Darwin]) 1293 fi 1294 AC_DEFINE([JEMALLOC_IVSALLOC], [ ]) 1295 AC_DEFINE([JEMALLOC_ZONE], [ ]) 1296 1297 dnl The szone version jumped from 3 to 6 between the OS X 10.5.x and 10.6 1298 dnl releases. malloc_zone_t and malloc_introspection_t have new fields in 1299 dnl 10.6, which is the only source-level indication of the change. 1300 AC_MSG_CHECKING([malloc zone version]) 1301 AC_DEFUN([JE_ZONE_PROGRAM], 1302 [AC_LANG_PROGRAM( 1303 [#include <malloc/malloc.h>], 1304 [static foo[[sizeof($1) $2 sizeof(void *) * $3 ? 1 : -1]]] 1305 )]) 1306 1307 AC_COMPILE_IFELSE([JE_ZONE_PROGRAM(malloc_zone_t,==,14)],[JEMALLOC_ZONE_VERSION=3],[ 1308 AC_COMPILE_IFELSE([JE_ZONE_PROGRAM(malloc_zone_t,==,15)],[JEMALLOC_ZONE_VERSION=5],[ 1309 AC_COMPILE_IFELSE([JE_ZONE_PROGRAM(malloc_zone_t,==,16)],[ 1310 AC_COMPILE_IFELSE([JE_ZONE_PROGRAM(malloc_introspection_t,==,9)],[JEMALLOC_ZONE_VERSION=6],[ 1311 AC_COMPILE_IFELSE([JE_ZONE_PROGRAM(malloc_introspection_t,==,13)],[JEMALLOC_ZONE_VERSION=7],[JEMALLOC_ZONE_VERSION=] 1312 )])],[ 1313 AC_COMPILE_IFELSE([JE_ZONE_PROGRAM(malloc_zone_t,==,17)],[JEMALLOC_ZONE_VERSION=8],[ 1314 AC_COMPILE_IFELSE([JE_ZONE_PROGRAM(malloc_zone_t,>,17)],[JEMALLOC_ZONE_VERSION=9],[JEMALLOC_ZONE_VERSION=] 1315 )])])])]) 1316 if test "x${JEMALLOC_ZONE_VERSION}" = "x"; then 1317 AC_MSG_RESULT([unsupported]) 1318 AC_MSG_ERROR([Unsupported malloc zone version]) 1319 fi 1320 if test "${JEMALLOC_ZONE_VERSION}" = 9; then 1321 JEMALLOC_ZONE_VERSION=8 1322 AC_MSG_RESULT([> 8]) 1323 else 1324 AC_MSG_RESULT([$JEMALLOC_ZONE_VERSION]) 1325 fi 1326 AC_DEFINE_UNQUOTED(JEMALLOC_ZONE_VERSION, [$JEMALLOC_ZONE_VERSION]) 1327fi 1328 1329dnl ============================================================================ 1330dnl Check for typedefs, structures, and compiler characteristics. 1331AC_HEADER_STDBOOL 1332 1333dnl ============================================================================ 1334dnl Define commands that generate output files. 1335 1336AC_CONFIG_COMMANDS([include/jemalloc/internal/private_namespace.h], [ 1337 mkdir -p "${objroot}include/jemalloc/internal" 1338 "${srcdir}/include/jemalloc/internal/private_namespace.sh" "${srcdir}/include/jemalloc/internal/private_symbols.txt" > "${objroot}include/jemalloc/internal/private_namespace.h" 1339], [ 1340 srcdir="${srcdir}" 1341 objroot="${objroot}" 1342]) 1343AC_CONFIG_COMMANDS([include/jemalloc/internal/private_unnamespace.h], [ 1344 mkdir -p "${objroot}include/jemalloc/internal" 1345 "${srcdir}/include/jemalloc/internal/private_unnamespace.sh" "${srcdir}/include/jemalloc/internal/private_symbols.txt" > "${objroot}include/jemalloc/internal/private_unnamespace.h" 1346], [ 1347 srcdir="${srcdir}" 1348 objroot="${objroot}" 1349]) 1350AC_CONFIG_COMMANDS([include/jemalloc/internal/public_symbols.txt], [ 1351 f="${objroot}include/jemalloc/internal/public_symbols.txt" 1352 mkdir -p "${objroot}include/jemalloc/internal" 1353 cp /dev/null "${f}" 1354 for nm in `echo ${mangling_map} |tr ',' ' '` ; do 1355 n=`echo ${nm} |tr ':' ' ' |awk '{print $[]1}'` 1356 m=`echo ${nm} |tr ':' ' ' |awk '{print $[]2}'` 1357 echo "${n}:${m}" >> "${f}" 1358 dnl Remove name from public_syms so that it isn't redefined later. 1359 public_syms=`for sym in ${public_syms}; do echo "${sym}"; done |grep -v "^${n}\$" |tr '\n' ' '` 1360 done 1361 for sym in ${public_syms} ; do 1362 n="${sym}" 1363 m="${JEMALLOC_PREFIX}${sym}" 1364 echo "${n}:${m}" >> "${f}" 1365 done 1366], [ 1367 srcdir="${srcdir}" 1368 objroot="${objroot}" 1369 mangling_map="${mangling_map}" 1370 public_syms="${public_syms}" 1371 JEMALLOC_PREFIX="${JEMALLOC_PREFIX}" 1372]) 1373AC_CONFIG_COMMANDS([include/jemalloc/internal/public_namespace.h], [ 1374 mkdir -p "${objroot}include/jemalloc/internal" 1375 "${srcdir}/include/jemalloc/internal/public_namespace.sh" "${objroot}include/jemalloc/internal/public_symbols.txt" > "${objroot}include/jemalloc/internal/public_namespace.h" 1376], [ 1377 srcdir="${srcdir}" 1378 objroot="${objroot}" 1379]) 1380AC_CONFIG_COMMANDS([include/jemalloc/internal/public_unnamespace.h], [ 1381 mkdir -p "${objroot}include/jemalloc/internal" 1382 "${srcdir}/include/jemalloc/internal/public_unnamespace.sh" "${objroot}include/jemalloc/internal/public_symbols.txt" > "${objroot}include/jemalloc/internal/public_unnamespace.h" 1383], [ 1384 srcdir="${srcdir}" 1385 objroot="${objroot}" 1386]) 1387AC_CONFIG_COMMANDS([include/jemalloc/internal/size_classes.h], [ 1388 mkdir -p "${objroot}include/jemalloc/internal" 1389 "${srcdir}/include/jemalloc/internal/size_classes.sh" > "${objroot}include/jemalloc/internal/size_classes.h" 1390], [ 1391 srcdir="${srcdir}" 1392 objroot="${objroot}" 1393]) 1394AC_CONFIG_COMMANDS([include/jemalloc/jemalloc_protos_jet.h], [ 1395 mkdir -p "${objroot}include/jemalloc" 1396 cat "${srcdir}/include/jemalloc/jemalloc_protos.h.in" | sed -e 's/@je_@/jet_/g' > "${objroot}include/jemalloc/jemalloc_protos_jet.h" 1397], [ 1398 srcdir="${srcdir}" 1399 objroot="${objroot}" 1400]) 1401AC_CONFIG_COMMANDS([include/jemalloc/jemalloc_rename.h], [ 1402 mkdir -p "${objroot}include/jemalloc" 1403 "${srcdir}/include/jemalloc/jemalloc_rename.sh" "${objroot}include/jemalloc/internal/public_symbols.txt" > "${objroot}include/jemalloc/jemalloc_rename.h" 1404], [ 1405 srcdir="${srcdir}" 1406 objroot="${objroot}" 1407]) 1408AC_CONFIG_COMMANDS([include/jemalloc/jemalloc_mangle.h], [ 1409 mkdir -p "${objroot}include/jemalloc" 1410 "${srcdir}/include/jemalloc/jemalloc_mangle.sh" "${objroot}include/jemalloc/internal/public_symbols.txt" je_ > "${objroot}include/jemalloc/jemalloc_mangle.h" 1411], [ 1412 srcdir="${srcdir}" 1413 objroot="${objroot}" 1414]) 1415AC_CONFIG_COMMANDS([include/jemalloc/jemalloc_mangle_jet.h], [ 1416 mkdir -p "${objroot}include/jemalloc" 1417 "${srcdir}/include/jemalloc/jemalloc_mangle.sh" "${objroot}include/jemalloc/internal/public_symbols.txt" jet_ > "${objroot}include/jemalloc/jemalloc_mangle_jet.h" 1418], [ 1419 srcdir="${srcdir}" 1420 objroot="${objroot}" 1421]) 1422AC_CONFIG_COMMANDS([include/jemalloc/jemalloc.h], [ 1423 mkdir -p "${objroot}include/jemalloc" 1424 "${srcdir}/include/jemalloc/jemalloc.sh" "${objroot}" > "${objroot}include/jemalloc/jemalloc${install_suffix}.h" 1425], [ 1426 srcdir="${srcdir}" 1427 objroot="${objroot}" 1428 install_suffix="${install_suffix}" 1429]) 1430 1431dnl Process .in files. 1432AC_SUBST([cfghdrs_in]) 1433AC_SUBST([cfghdrs_out]) 1434AC_CONFIG_HEADERS([$cfghdrs_tup]) 1435 1436dnl ============================================================================ 1437dnl Generate outputs. 1438 1439AC_CONFIG_FILES([$cfgoutputs_tup config.stamp bin/jemalloc.sh]) 1440AC_SUBST([cfgoutputs_in]) 1441AC_SUBST([cfgoutputs_out]) 1442AC_OUTPUT 1443 1444dnl ============================================================================ 1445dnl Print out the results of configuration. 1446AC_MSG_RESULT([===============================================================================]) 1447AC_MSG_RESULT([jemalloc version : ${jemalloc_version}]) 1448AC_MSG_RESULT([library revision : ${rev}]) 1449AC_MSG_RESULT([]) 1450AC_MSG_RESULT([CC : ${CC}]) 1451AC_MSG_RESULT([CPPFLAGS : ${CPPFLAGS}]) 1452AC_MSG_RESULT([CFLAGS : ${CFLAGS}]) 1453AC_MSG_RESULT([LDFLAGS : ${LDFLAGS}]) 1454AC_MSG_RESULT([EXTRA_LDFLAGS : ${EXTRA_LDFLAGS}]) 1455AC_MSG_RESULT([LIBS : ${LIBS}]) 1456AC_MSG_RESULT([RPATH_EXTRA : ${RPATH_EXTRA}]) 1457AC_MSG_RESULT([]) 1458AC_MSG_RESULT([XSLTPROC : ${XSLTPROC}]) 1459AC_MSG_RESULT([XSLROOT : ${XSLROOT}]) 1460AC_MSG_RESULT([]) 1461AC_MSG_RESULT([PREFIX : ${PREFIX}]) 1462AC_MSG_RESULT([BINDIR : ${BINDIR}]) 1463AC_MSG_RESULT([INCLUDEDIR : ${INCLUDEDIR}]) 1464AC_MSG_RESULT([LIBDIR : ${LIBDIR}]) 1465AC_MSG_RESULT([DATADIR : ${DATADIR}]) 1466AC_MSG_RESULT([MANDIR : ${MANDIR}]) 1467AC_MSG_RESULT([]) 1468AC_MSG_RESULT([srcroot : ${srcroot}]) 1469AC_MSG_RESULT([abs_srcroot : ${abs_srcroot}]) 1470AC_MSG_RESULT([objroot : ${objroot}]) 1471AC_MSG_RESULT([abs_objroot : ${abs_objroot}]) 1472AC_MSG_RESULT([]) 1473AC_MSG_RESULT([JEMALLOC_PREFIX : ${JEMALLOC_PREFIX}]) 1474AC_MSG_RESULT([JEMALLOC_PRIVATE_NAMESPACE]) 1475AC_MSG_RESULT([ : ${JEMALLOC_PRIVATE_NAMESPACE}]) 1476AC_MSG_RESULT([install_suffix : ${install_suffix}]) 1477AC_MSG_RESULT([autogen : ${enable_autogen}]) 1478AC_MSG_RESULT([experimental : ${enable_experimental}]) 1479AC_MSG_RESULT([cc-silence : ${enable_cc_silence}]) 1480AC_MSG_RESULT([debug : ${enable_debug}]) 1481AC_MSG_RESULT([code-coverage : ${enable_code_coverage}]) 1482AC_MSG_RESULT([stats : ${enable_stats}]) 1483AC_MSG_RESULT([prof : ${enable_prof}]) 1484AC_MSG_RESULT([prof-libunwind : ${enable_prof_libunwind}]) 1485AC_MSG_RESULT([prof-libgcc : ${enable_prof_libgcc}]) 1486AC_MSG_RESULT([prof-gcc : ${enable_prof_gcc}]) 1487AC_MSG_RESULT([tcache : ${enable_tcache}]) 1488AC_MSG_RESULT([fill : ${enable_fill}]) 1489AC_MSG_RESULT([utrace : ${enable_utrace}]) 1490AC_MSG_RESULT([valgrind : ${enable_valgrind}]) 1491AC_MSG_RESULT([xmalloc : ${enable_xmalloc}]) 1492AC_MSG_RESULT([mremap : ${enable_mremap}]) 1493AC_MSG_RESULT([munmap : ${enable_munmap}]) 1494AC_MSG_RESULT([dss : ${enable_dss}]) 1495AC_MSG_RESULT([lazy_lock : ${enable_lazy_lock}]) 1496AC_MSG_RESULT([tls : ${enable_tls}]) 1497AC_MSG_RESULT([===============================================================================]) 1498