blob: 04cefe958063eb7ecd1339eac6253329ebfeae94 [file] [log] [blame]
Jason Evansb7924f52009-06-23 19:01:18 -07001dnl Process this file with autoconf to produce a configure script.
2AC_INIT([Makefile.in])
3
Jason Evansf3340ca2009-06-30 16:17:05 -07004dnl ============================================================================
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
Jason Evans6684cac2012-03-05 12:15:36 -080017AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
Jason Evansf3340ca2009-06-30 16:17:05 -070018[[
19]], [[
20 return 0;
21]])],
Jason Evans99b0fbb2014-02-24 16:08:38 -080022 [je_cv_cflags_appended=$1]
Jason Evansf3340ca2009-06-30 16:17:05 -070023 AC_MSG_RESULT([yes]),
Jason Evans99b0fbb2014-02-24 16:08:38 -080024 [je_cv_cflags_appended=]
Jason Evansf3340ca2009-06-30 16:17:05 -070025 AC_MSG_RESULT([no])
26 [CFLAGS="${TCFLAGS}"]
27)
28])
29
30dnl JE_COMPILABLE(label, hcode, mcode, rvar)
Jason Evans4c2faa82012-03-13 11:09:23 -070031dnl
Jason Evansf3e139a2012-03-19 09:54:20 -070032dnl Use AC_LINK_IFELSE() rather than AC_COMPILE_IFELSE() so that linker errors
Jason Evans4c2faa82012-03-13 11:09:23 -070033dnl cause failure.
Jason Evansf3340ca2009-06-30 16:17:05 -070034AC_DEFUN([JE_COMPILABLE],
35[
Jason Evans6684cac2012-03-05 12:15:36 -080036AC_CACHE_CHECK([whether $1 is compilable],
37 [$4],
Jason Evansf3e139a2012-03-19 09:54:20 -070038 [AC_LINK_IFELSE([AC_LANG_PROGRAM([$2],
39 [$3])],
40 [$4=yes],
41 [$4=no])])
Jason Evansf3340ca2009-06-30 16:17:05 -070042])
43
44dnl ============================================================================
45
Jason Evansf576c632011-11-01 22:27:41 -070046dnl Library revision.
Jason Evans9790b962014-04-14 22:32:31 -070047rev=2
Jason Evansf576c632011-11-01 22:27:41 -070048AC_SUBST([rev])
49
Jason Evansb7924f52009-06-23 19:01:18 -070050srcroot=$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
Jason Evansaee7fd22010-11-24 22:00:02 -080090dnl Support for building documentation.
Jason Evans7329a4f2013-01-22 10:53:29 -080091AC_PATH_PROG([XSLTPROC], [xsltproc], [false], [$PATH])
Jason Evans7091b412012-03-19 09:36:44 -070092if 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
Jason Evansaee7fd22010-11-24 22:00:02 -0800100AC_ARG_WITH([xslroot],
Jason Evans7091b412012-03-19 09:36:44 -0700101 [AS_HELP_STRING([--with-xslroot=<path>], [XSL stylesheet root path])], [
Jason Evansaee7fd22010-11-24 22:00:02 -0800102if test "x$with_xslroot" = "xno" ; then
Jason Evans7091b412012-03-19 09:36:44 -0700103 XSLROOT="${DEFAULT_XSLROOT}"
Jason Evansaee7fd22010-11-24 22:00:02 -0800104else
105 XSLROOT="${with_xslroot}"
Jason Evans7091b412012-03-19 09:36:44 -0700106fi
107],
108 XSLROOT="${DEFAULT_XSLROOT}"
Jason Evansaee7fd22010-11-24 22:00:02 -0800109)
110AC_SUBST([XSLROOT])
111
Jason Evansf3340ca2009-06-30 16:17:05 -0700112dnl If CFLAGS isn't defined, set CFLAGS to something reasonable. Otherwise,
113dnl just prevent autoconf from molesting CFLAGS.
Jason Evansb7924f52009-06-23 19:01:18 -0700114CFLAGS=$CFLAGS
115AC_PROG_CC
Mike Hommeyfd97b1d2012-04-30 12:38:31 +0200116if 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
Jason Evansb7924f52009-06-23 19:01:18 -0700129if test "x$CFLAGS" = "x" ; then
130 no_CFLAGS="yes"
Jason Evanscfeccd32010-03-03 15:48:20 -0800131 if test "x$GCC" = "xyes" ; then
132 JE_CFLAGS_APPEND([-std=gnu99])
Jason Evans99b0fbb2014-02-24 16:08:38 -0800133 if test "x$je_cv_cflags_appended" = "x-std=gnu99" ; then
134 AC_DEFINE_UNQUOTED([JEMALLOC_HAS_RESTRICT])
135 fi
Jason Evanscfeccd32010-03-03 15:48:20 -0800136 JE_CFLAGS_APPEND([-Wall])
137 JE_CFLAGS_APPEND([-pipe])
138 JE_CFLAGS_APPEND([-g3])
Mike Hommeyfd97b1d2012-04-30 12:38:31 +0200139 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"
Jason Evanscfeccd32010-03-03 15:48:20 -0800145 fi
Jason Evansb7924f52009-06-23 19:01:18 -0700146fi
147dnl Append EXTRA_CFLAGS to CFLAGS, if defined.
148if test "x$EXTRA_CFLAGS" != "x" ; then
Jason Evansf3340ca2009-06-30 16:17:05 -0700149 JE_CFLAGS_APPEND([$EXTRA_CFLAGS])
Jason Evansb7924f52009-06-23 19:01:18 -0700150fi
151AC_PROG_CPP
152
Jason Evansdf3f2702014-03-30 16:27:08 -0700153AC_C_BIGENDIAN([ac_cv_big_endian=1], [ac_cv_big_endian=0])
154if test "x${ac_cv_big_endian}" = "x1" ; then
155 AC_DEFINE_UNQUOTED([JEMALLOC_BIG_ENDIAN], [ ])
156fi
157
Jason Evansb7924f52009-06-23 19:01:18 -0700158AC_CHECK_SIZEOF([void *])
159if test "x${ac_cv_sizeof_void_p}" = "x8" ; then
Jason Evans94ad2b52009-12-29 00:09:15 -0800160 LG_SIZEOF_PTR=3
Jason Evansb7924f52009-06-23 19:01:18 -0700161elif test "x${ac_cv_sizeof_void_p}" = "x4" ; then
Jason Evans94ad2b52009-12-29 00:09:15 -0800162 LG_SIZEOF_PTR=2
Jason Evansb7924f52009-06-23 19:01:18 -0700163else
164 AC_MSG_ERROR([Unsupported pointer size: ${ac_cv_sizeof_void_p}])
165fi
Jason Evans94ad2b52009-12-29 00:09:15 -0800166AC_DEFINE_UNQUOTED([LG_SIZEOF_PTR], [$LG_SIZEOF_PTR])
167
168AC_CHECK_SIZEOF([int])
169if test "x${ac_cv_sizeof_int}" = "x8" ; then
170 LG_SIZEOF_INT=3
171elif test "x${ac_cv_sizeof_int}" = "x4" ; then
172 LG_SIZEOF_INT=2
173else
174 AC_MSG_ERROR([Unsupported int size: ${ac_cv_sizeof_int}])
175fi
176AC_DEFINE_UNQUOTED([LG_SIZEOF_INT], [$LG_SIZEOF_INT])
Jason Evansb7924f52009-06-23 19:01:18 -0700177
Jason Evans84c8eef2011-03-16 10:30:13 -0700178AC_CHECK_SIZEOF([long])
179if test "x${ac_cv_sizeof_long}" = "x8" ; then
180 LG_SIZEOF_LONG=3
181elif test "x${ac_cv_sizeof_long}" = "x4" ; then
182 LG_SIZEOF_LONG=2
183else
184 AC_MSG_ERROR([Unsupported long size: ${ac_cv_sizeof_long}])
185fi
186AC_DEFINE_UNQUOTED([LG_SIZEOF_LONG], [$LG_SIZEOF_LONG])
187
Jason Evansd81e4bd2012-03-06 14:57:45 -0800188AC_CHECK_SIZEOF([intmax_t])
189if test "x${ac_cv_sizeof_intmax_t}" = "x16" ; then
190 LG_SIZEOF_INTMAX_T=4
191elif test "x${ac_cv_sizeof_intmax_t}" = "x8" ; then
192 LG_SIZEOF_INTMAX_T=3
193elif test "x${ac_cv_sizeof_intmax_t}" = "x4" ; then
194 LG_SIZEOF_INTMAX_T=2
195else
Mike Hommey14103d32012-04-20 08:38:39 +0200196 AC_MSG_ERROR([Unsupported intmax_t size: ${ac_cv_sizeof_intmax_t}])
Jason Evansd81e4bd2012-03-06 14:57:45 -0800197fi
198AC_DEFINE_UNQUOTED([LG_SIZEOF_INTMAX_T], [$LG_SIZEOF_INTMAX_T])
199
Jason Evansb7924f52009-06-23 19:01:18 -0700200AC_CANONICAL_HOST
201dnl CPU-specific settings.
202CPU_SPINWAIT=""
203case "${host_cpu}" in
204 i[[345]]86)
205 ;;
Jason Evanscb657e32014-02-25 11:21:41 -0800206 i686|x86_64)
207 JE_COMPILABLE([pause instruction], [],
208 [[__asm__ volatile("pause"); return 0;]],
209 [je_cv_pause])
210 if test "x${je_cv_pause}" = "xyes" ; then
Jason Evansf3340ca2009-06-30 16:17:05 -0700211 CPU_SPINWAIT='__asm__ volatile("pause")'
212 fi
Jason Evanscb657e32014-02-25 11:21:41 -0800213 dnl emmintrin.h fails to compile unless MMX, SSE, and SSE2 are
214 dnl supported.
215 JE_COMPILABLE([SSE2 intrinsics], [
216#include <emmintrin.h>
217], [], [je_cv_sse2])
218 if test "x${je_cv_sse2}" = "xyes" ; then
219 AC_DEFINE_UNQUOTED([HAVE_SSE2], [ ])
Jason Evansf3340ca2009-06-30 16:17:05 -0700220 fi
Jason Evans80061b62013-12-09 13:21:08 -0800221 ;;
222 powerpc)
223 AC_DEFINE_UNQUOTED([HAVE_ALTIVEC], [ ])
Jason Evansb7924f52009-06-23 19:01:18 -0700224 ;;
225 *)
226 ;;
227esac
228AC_DEFINE_UNQUOTED([CPU_SPINWAIT], [$CPU_SPINWAIT])
229
Antony Dovgal2bd3cbc2011-10-13 09:33:33 +0400230LD_PRELOAD_VAR="LD_PRELOAD"
Jason Evansf576c632011-11-01 22:27:41 -0700231so="so"
Mike Hommeyfd97b1d2012-04-30 12:38:31 +0200232importlib="${so}"
Mike Hommey7cdea392012-04-30 12:38:27 +0200233o="$ac_objext"
Mike Hommey5bee66d2012-04-16 16:30:24 +0200234a="a"
Mike Hommey7cdea392012-04-30 12:38:27 +0200235exe="$ac_exeext"
Mike Hommeya19e87f2012-04-21 21:27:46 -0700236libprefix="lib"
Mike Hommeyfa08da72012-04-16 16:30:25 +0200237DSO_LDFLAGS='-shared -Wl,-soname,$(@F)'
238RPATH='-Wl,-rpath,$(1)'
Mike Hommey7cdea392012-04-30 12:38:27 +0200239SOREV="${so}.${rev}"
Mike Hommey188da7c2012-04-18 18:29:41 +0200240PIC_CFLAGS='-fPIC -DPIC'
Mike Hommeyfd97b1d2012-04-30 12:38:31 +0200241CTARGET='-o $@'
242LDTARGET='-o $@'
243EXTRA_LDFLAGS=
Jason Evans80ddf492013-08-20 11:48:19 +0100244ARFLAGS='crus'
245AROUT=' $@'
Mike Hommey79c4bca2012-05-02 21:30:51 +0200246CC_MM=1
Jason Evans7372b152012-02-10 20:22:09 -0800247
Jory A. Prattad505e02013-08-11 09:44:59 -0500248AN_MAKEVAR([AR], [AC_PROG_AR])
249AN_PROGRAM([ar], [AC_PROG_AR])
250AC_DEFUN([AC_PROG_AR], [AC_CHECK_TOOL(AR, ar, :)])
251AC_PROG_AR
252
Jason Evansb7924f52009-06-23 19:01:18 -0700253dnl Platform-specific settings. abi and RPATH can probably be determined
254dnl programmatically, but doing so is error-prone, which makes it generally
255dnl not worth the trouble.
256dnl
257dnl Define cpp macros in CPPFLAGS, rather than doing AC_DEFINE(macro), since the
258dnl definitions need to be seen before any headers are included, which is a pain
259dnl to make happen otherwise.
Jason Evans59ae2762012-04-16 17:52:27 -0700260default_munmap="1"
Jason Evans247d1242012-10-09 16:20:10 -0700261JEMALLOC_USABLE_SIZE_CONST="const"
Jason Evansb7924f52009-06-23 19:01:18 -0700262case "${host}" in
263 *-*-darwin*)
Mike Hommeya6770a72012-05-03 14:12:49 +0200264 CFLAGS="$CFLAGS"
Jason Evansb7924f52009-06-23 19:01:18 -0700265 abi="macho"
Jason Evanse24c7af2012-03-19 10:21:17 -0700266 AC_DEFINE([JEMALLOC_PURGE_MADVISE_FREE], [ ])
Jason Evansb7924f52009-06-23 19:01:18 -0700267 RPATH=""
Antony Dovgal2bd3cbc2011-10-13 09:33:33 +0400268 LD_PRELOAD_VAR="DYLD_INSERT_LIBRARIES"
Jason Evansf576c632011-11-01 22:27:41 -0700269 so="dylib"
Mike Hommeyfd97b1d2012-04-30 12:38:31 +0200270 importlib="${so}"
Jason Evansb80581d2012-03-23 16:17:43 -0700271 force_tls="0"
Mike Hommeyfa08da72012-04-16 16:30:25 +0200272 DSO_LDFLAGS='-shared -Wl,-dylib_install_name,$(@F)'
Mike Hommey7cdea392012-04-30 12:38:27 +0200273 SOREV="${rev}.${so}"
Jason Evans66688532013-12-03 21:49:36 -0800274 sbrk_deprecated="1"
Jason Evansb7924f52009-06-23 19:01:18 -0700275 ;;
276 *-*-freebsd*)
277 CFLAGS="$CFLAGS"
278 abi="elf"
Jason Evanse24c7af2012-03-19 10:21:17 -0700279 AC_DEFINE([JEMALLOC_PURGE_MADVISE_FREE], [ ])
Jason Evansfd4fcef2012-03-23 17:40:58 -0700280 force_lazy_lock="1"
Jason Evansb7924f52009-06-23 19:01:18 -0700281 ;;
282 *-*-linux*)
283 CFLAGS="$CFLAGS"
284 CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
285 abi="elf"
Garrett Cooper13e4e242012-12-02 17:58:40 -0800286 AC_DEFINE([JEMALLOC_HAS_ALLOCA_H])
Jason Evanse24c7af2012-03-19 10:21:17 -0700287 AC_DEFINE([JEMALLOC_PURGE_MADVISE_DONTNEED], [ ])
Jason Evans02b23122012-04-05 11:06:23 -0700288 AC_DEFINE([JEMALLOC_THREADED_INIT], [ ])
Jason Evans247d1242012-10-09 16:20:10 -0700289 JEMALLOC_USABLE_SIZE_CONST=""
Jason Evans59ae2762012-04-16 17:52:27 -0700290 default_munmap="0"
Jason Evansb7924f52009-06-23 19:01:18 -0700291 ;;
292 *-*-netbsd*)
293 AC_MSG_CHECKING([ABI])
294 AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
295[[#ifdef __ELF__
296/* ELF */
297#else
298#error aout
299#endif
300]])],
301 [CFLAGS="$CFLAGS"; abi="elf"],
302 [abi="aout"])
303 AC_MSG_RESULT([$abi])
Jason Evanse24c7af2012-03-19 10:21:17 -0700304 AC_DEFINE([JEMALLOC_PURGE_MADVISE_FREE], [ ])
Jason Evansb7924f52009-06-23 19:01:18 -0700305 ;;
306 *-*-solaris2*)
307 CFLAGS="$CFLAGS"
308 abi="elf"
George Koladdd6bd42014-02-12 23:05:45 +0000309 AC_DEFINE([JEMALLOC_PURGE_MADVISE_FREE], [ ])
Mike Hommeyfa08da72012-04-16 16:30:25 +0200310 RPATH='-Wl,-R,$(1)'
Jason Evansb7924f52009-06-23 19:01:18 -0700311 dnl Solaris needs this for sigwait().
312 CPPFLAGS="$CPPFLAGS -D_POSIX_PTHREAD_SEMANTICS"
313 LIBS="$LIBS -lposix4 -lsocket -lnsl"
314 ;;
Antony Dovgal2bd3cbc2011-10-13 09:33:33 +0400315 *-ibm-aix*)
316 if "$LG_SIZEOF_PTR" = "8"; then
317 dnl 64bit AIX
318 LD_PRELOAD_VAR="LDR_PRELOAD64"
319 else
320 dnl 32bit AIX
321 LD_PRELOAD_VAR="LDR_PRELOAD"
322 fi
323 abi="xcoff"
Antony Dovgal2bd3cbc2011-10-13 09:33:33 +0400324 ;;
Mike Hommeya19e87f2012-04-21 21:27:46 -0700325 *-*-mingw*)
326 abi="pecoff"
327 force_tls="0"
328 RPATH=""
329 so="dll"
Mike Hommeyfd97b1d2012-04-30 12:38:31 +0200330 if test "x$je_cv_msvc" = "xyes" ; then
331 importlib="lib"
332 DSO_LDFLAGS="-LD"
333 EXTRA_LDFLAGS="-link -DEBUG"
334 CTARGET='-Fo$@'
335 LDTARGET='-Fe$@'
Jory A. Prattad505e02013-08-11 09:44:59 -0500336 AR='lib'
337 ARFLAGS='-nologo -out:'
Jason Evans80ddf492013-08-20 11:48:19 +0100338 AROUT='$@'
Mike Hommey79c4bca2012-05-02 21:30:51 +0200339 CC_MM=
Mike Hommeyfd97b1d2012-04-30 12:38:31 +0200340 else
341 importlib="${so}"
342 DSO_LDFLAGS="-shared"
343 fi
Mike Hommeya19e87f2012-04-21 21:27:46 -0700344 a="lib"
345 libprefix=""
Mike Hommey7cdea392012-04-30 12:38:27 +0200346 SOREV="${so}"
Mike Hommeya19e87f2012-04-21 21:27:46 -0700347 PIC_CFLAGS=""
348 ;;
Jason Evansb7924f52009-06-23 19:01:18 -0700349 *)
350 AC_MSG_RESULT([Unsupported operating system: ${host}])
351 abi="elf"
Jason Evansb7924f52009-06-23 19:01:18 -0700352 ;;
353esac
Jason Evans247d1242012-10-09 16:20:10 -0700354AC_DEFINE_UNQUOTED([JEMALLOC_USABLE_SIZE_CONST], [$JEMALLOC_USABLE_SIZE_CONST])
Jason Evansb7924f52009-06-23 19:01:18 -0700355AC_SUBST([abi])
356AC_SUBST([RPATH])
Antony Dovgal2bd3cbc2011-10-13 09:33:33 +0400357AC_SUBST([LD_PRELOAD_VAR])
Jason Evansf576c632011-11-01 22:27:41 -0700358AC_SUBST([so])
Mike Hommeyfd97b1d2012-04-30 12:38:31 +0200359AC_SUBST([importlib])
Mike Hommey5bee66d2012-04-16 16:30:24 +0200360AC_SUBST([o])
361AC_SUBST([a])
362AC_SUBST([exe])
Mike Hommeya19e87f2012-04-21 21:27:46 -0700363AC_SUBST([libprefix])
Mike Hommeyfa08da72012-04-16 16:30:25 +0200364AC_SUBST([DSO_LDFLAGS])
Mike Hommeyfd97b1d2012-04-30 12:38:31 +0200365AC_SUBST([EXTRA_LDFLAGS])
Mike Hommey85221d52012-04-18 18:29:40 +0200366AC_SUBST([SOREV])
Mike Hommey188da7c2012-04-18 18:29:41 +0200367AC_SUBST([PIC_CFLAGS])
Mike Hommeyfd97b1d2012-04-30 12:38:31 +0200368AC_SUBST([CTARGET])
369AC_SUBST([LDTARGET])
370AC_SUBST([MKLIB])
Jason Evans80ddf492013-08-20 11:48:19 +0100371AC_SUBST([ARFLAGS])
372AC_SUBST([AROUT])
Mike Hommey79c4bca2012-05-02 21:30:51 +0200373AC_SUBST([CC_MM])
Mike Hommeyfd97b1d2012-04-30 12:38:31 +0200374
Jason Evansfa5d2452011-03-15 10:25:59 -0700375JE_COMPILABLE([__attribute__ syntax],
376 [static __attribute__((unused)) void foo(void){}],
377 [],
Jason Evans6684cac2012-03-05 12:15:36 -0800378 [je_cv_attribute])
379if test "x${je_cv_attribute}" = "xyes" ; then
Jason Evansfa5d2452011-03-15 10:25:59 -0700380 AC_DEFINE([JEMALLOC_HAVE_ATTR], [ ])
381 if test "x${GCC}" = "xyes" -a "x${abi}" = "xelf"; then
382 JE_CFLAGS_APPEND([-fvisibility=hidden])
383 fi
384fi
Jason Evans3cc1f1a2012-04-03 22:30:05 -0700385dnl Check for tls_model attribute support (clang 3.0 still lacks support).
386SAVED_CFLAGS="${CFLAGS}"
387JE_CFLAGS_APPEND([-Werror])
388JE_COMPILABLE([tls_model attribute], [],
389 [static __thread int
390 __attribute__((tls_model("initial-exec"))) foo;
391 foo = 0;],
392 [je_cv_tls_model])
393CFLAGS="${SAVED_CFLAGS}"
394if test "x${je_cv_tls_model}" = "xyes" ; then
395 AC_DEFINE([JEMALLOC_TLS_MODEL],
396 [__attribute__((tls_model("initial-exec")))])
397else
398 AC_DEFINE([JEMALLOC_TLS_MODEL], [ ])
399fi
Jason Evansfa5d2452011-03-15 10:25:59 -0700400
Jason Evansb7924f52009-06-23 19:01:18 -0700401dnl Support optional additions to rpath.
402AC_ARG_WITH([rpath],
Jason Evans90895cf2009-12-29 00:09:15 -0800403 [AS_HELP_STRING([--with-rpath=<rpath>], [Colon-separated rpath (ELF systems only)])],
Jason Evansb7924f52009-06-23 19:01:18 -0700404if test "x$with_rpath" = "xno" ; then
405 RPATH_EXTRA=
406else
407 RPATH_EXTRA="`echo $with_rpath | tr \":\" \" \"`"
408fi,
409 RPATH_EXTRA=
410)
411AC_SUBST([RPATH_EXTRA])
412
413dnl Disable rules that do automatic regeneration of configure output by default.
414AC_ARG_ENABLE([autogen],
Jason Evans78d815c2010-01-17 14:06:20 -0800415 [AS_HELP_STRING([--enable-autogen], [Automatically regenerate configure output])],
Jason Evansb7924f52009-06-23 19:01:18 -0700416if test "x$enable_autogen" = "xno" ; then
417 enable_autogen="0"
418else
419 enable_autogen="1"
420fi
421,
422enable_autogen="0"
423)
424AC_SUBST([enable_autogen])
425
426AC_PROG_INSTALL
427AC_PROG_RANLIB
Jason Evans7329a4f2013-01-22 10:53:29 -0800428AC_PATH_PROG([LD], [ld], [false], [$PATH])
429AC_PATH_PROG([AUTOCONF], [autoconf], [false], [$PATH])
Jason Evansb7924f52009-06-23 19:01:18 -0700430
Jason Evansd82a5e62013-12-12 22:35:52 -0800431public_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"
Jason Evans7e77eaf2012-03-02 17:47:37 -0800432
433dnl Check for allocator-related functions that should be wrapped.
434AC_CHECK_FUNC([memalign],
Jason Evanse24c7af2012-03-19 10:21:17 -0700435 [AC_DEFINE([JEMALLOC_OVERRIDE_MEMALIGN], [ ])
Jason Evans7e77eaf2012-03-02 17:47:37 -0800436 public_syms="${public_syms} memalign"])
437AC_CHECK_FUNC([valloc],
Jason Evanse24c7af2012-03-19 10:21:17 -0700438 [AC_DEFINE([JEMALLOC_OVERRIDE_VALLOC], [ ])
Jason Evans7e77eaf2012-03-02 17:47:37 -0800439 public_syms="${public_syms} valloc"])
440
Jason Evans748dfac2013-12-06 18:27:33 -0800441dnl Do not compute test code coverage by default.
442GCOV_FLAGS=
443AC_ARG_ENABLE([code-coverage],
444 [AS_HELP_STRING([--enable-code-coverage],
445 [Enable code coverage])],
446[if test "x$enable_code_coverage" = "xno" ; then
447 enable_code_coverage="0"
448else
449 enable_code_coverage="1"
450fi
451],
452[enable_code_coverage="0"]
453)
454if test "x$enable_code_coverage" = "x1" ; then
455 deoptimize="no"
456 echo "$CFLAGS $EXTRA_CFLAGS" | grep '\-O' >/dev/null || deoptimize="yes"
457 if test "x${deoptimize}" = "xyes" ; then
458 JE_CFLAGS_APPEND([-O0])
459 fi
460 JE_CFLAGS_APPEND([-fprofile-arcs -ftest-coverage])
461 EXTRA_LDFLAGS="$EXTRA_LDFLAGS -fprofile-arcs -ftest-coverage"
462 AC_DEFINE([JEMALLOC_CODE_COVERAGE], [ ])
463fi
464AC_SUBST([enable_code_coverage])
465
Jason Evans0a5489e2012-03-01 17:19:20 -0800466dnl Perform no name mangling by default.
467AC_ARG_WITH([mangling],
468 [AS_HELP_STRING([--with-mangling=<map>], [Mangle symbols in <map>])],
469 [mangling_map="$with_mangling"], [mangling_map=""])
Jason Evans0a5489e2012-03-01 17:19:20 -0800470
Jason Evans90895cf2009-12-29 00:09:15 -0800471dnl Do not prefix public APIs by default.
472AC_ARG_WITH([jemalloc_prefix],
473 [AS_HELP_STRING([--with-jemalloc-prefix=<prefix>], [Prefix to prepend to all public APIs])],
Jason Evansb0fd5012010-01-17 01:49:20 -0800474 [JEMALLOC_PREFIX="$with_jemalloc_prefix"],
Mike Hommey7cdea392012-04-30 12:38:27 +0200475 [if test "x$abi" != "xmacho" -a "x$abi" != "xpecoff"; then
Jason Evans2dbecf12010-09-05 10:35:13 -0700476 JEMALLOC_PREFIX=""
477else
478 JEMALLOC_PREFIX="je_"
479fi]
Jason Evans90895cf2009-12-29 00:09:15 -0800480)
481if test "x$JEMALLOC_PREFIX" != "x" ; then
Jason Evanse7339702010-10-23 18:37:06 -0700482 JEMALLOC_CPREFIX=`echo ${JEMALLOC_PREFIX} | tr "a-z" "A-Z"`
483 AC_DEFINE_UNQUOTED([JEMALLOC_PREFIX], ["$JEMALLOC_PREFIX"])
484 AC_DEFINE_UNQUOTED([JEMALLOC_CPREFIX], ["$JEMALLOC_CPREFIX"])
Jason Evans90895cf2009-12-29 00:09:15 -0800485fi
486
Mike Hommey99066602012-11-19 10:55:26 +0100487AC_ARG_WITH([export],
488 [AS_HELP_STRING([--without-export], [disable exporting jemalloc public APIs])],
489 [if test "x$with_export" = "xno"; then
Jason Evans2625c892013-01-22 16:46:27 -0800490 AC_DEFINE([JEMALLOC_EXPORT],[])
Mike Hommey99066602012-11-19 10:55:26 +0100491fi]
492)
493
Jason Evans86abd0d2013-11-30 15:25:42 -0800494dnl Mangle library-private APIs.
Jason Evans746e77a2011-07-30 16:40:52 -0700495AC_ARG_WITH([private_namespace],
496 [AS_HELP_STRING([--with-private-namespace=<prefix>], [Prefix to prepend to all library-private APIs])],
Jason Evans86abd0d2013-11-30 15:25:42 -0800497 [JEMALLOC_PRIVATE_NAMESPACE="${with_private_namespace}je_"],
498 [JEMALLOC_PRIVATE_NAMESPACE="je_"]
Jason Evans746e77a2011-07-30 16:40:52 -0700499)
Jason Evans86abd0d2013-11-30 15:25:42 -0800500AC_DEFINE_UNQUOTED([JEMALLOC_PRIVATE_NAMESPACE], [$JEMALLOC_PRIVATE_NAMESPACE])
501private_namespace="$JEMALLOC_PRIVATE_NAMESPACE"
502AC_SUBST([private_namespace])
Jason Evans746e77a2011-07-30 16:40:52 -0700503
Jason Evansb0fd5012010-01-17 01:49:20 -0800504dnl Do not add suffix to installed files by default.
505AC_ARG_WITH([install_suffix],
506 [AS_HELP_STRING([--with-install-suffix=<suffix>], [Suffix to append to all installed files])],
507 [INSTALL_SUFFIX="$with_install_suffix"],
508 [INSTALL_SUFFIX=]
509)
510install_suffix="$INSTALL_SUFFIX"
511AC_SUBST([install_suffix])
512
Jason Evans86abd0d2013-11-30 15:25:42 -0800513dnl Substitute @je_@ in jemalloc_protos.h.in, primarily to make generation of
514dnl jemalloc_protos_jet.h easy.
515je_="je_"
516AC_SUBST([je_])
517
Jason Evansaee7fd22010-11-24 22:00:02 -0800518cfgoutputs_in="${srcroot}Makefile.in"
519cfgoutputs_in="${cfgoutputs_in} ${srcroot}doc/html.xsl.in"
520cfgoutputs_in="${cfgoutputs_in} ${srcroot}doc/manpages.xsl.in"
521cfgoutputs_in="${cfgoutputs_in} ${srcroot}doc/jemalloc.xml.in"
Jason Evans86abd0d2013-11-30 15:25:42 -0800522cfgoutputs_in="${cfgoutputs_in} ${srcroot}include/jemalloc/jemalloc_macros.h.in"
523cfgoutputs_in="${cfgoutputs_in} ${srcroot}include/jemalloc/jemalloc_protos.h.in"
Jason Evans0656ec02010-04-07 23:37:35 -0700524cfgoutputs_in="${cfgoutputs_in} ${srcroot}include/jemalloc/internal/jemalloc_internal.h.in"
Jason Evans86abd0d2013-11-30 15:25:42 -0800525cfgoutputs_in="${cfgoutputs_in} ${srcroot}test/test.sh.in"
526cfgoutputs_in="${cfgoutputs_in} ${srcroot}test/include/test/jemalloc_test.h.in"
Jason Evansb0fd5012010-01-17 01:49:20 -0800527
Jason Evansaee7fd22010-11-24 22:00:02 -0800528cfgoutputs_out="Makefile"
529cfgoutputs_out="${cfgoutputs_out} doc/html.xsl"
530cfgoutputs_out="${cfgoutputs_out} doc/manpages.xsl"
Jason Evans86abd0d2013-11-30 15:25:42 -0800531cfgoutputs_out="${cfgoutputs_out} doc/jemalloc.xml"
532cfgoutputs_out="${cfgoutputs_out} include/jemalloc/jemalloc_macros.h"
533cfgoutputs_out="${cfgoutputs_out} include/jemalloc/jemalloc_protos.h"
Jason Evans376b1522010-02-11 14:45:59 -0800534cfgoutputs_out="${cfgoutputs_out} include/jemalloc/internal/jemalloc_internal.h"
Jason Evans86abd0d2013-11-30 15:25:42 -0800535cfgoutputs_out="${cfgoutputs_out} test/test.sh"
536cfgoutputs_out="${cfgoutputs_out} test/include/test/jemalloc_test.h"
Jason Evansb0fd5012010-01-17 01:49:20 -0800537
Jason Evansaee7fd22010-11-24 22:00:02 -0800538cfgoutputs_tup="Makefile"
539cfgoutputs_tup="${cfgoutputs_tup} doc/html.xsl:doc/html.xsl.in"
540cfgoutputs_tup="${cfgoutputs_tup} doc/manpages.xsl:doc/manpages.xsl.in"
Jason Evans86abd0d2013-11-30 15:25:42 -0800541cfgoutputs_tup="${cfgoutputs_tup} doc/jemalloc.xml:doc/jemalloc.xml.in"
542cfgoutputs_tup="${cfgoutputs_tup} include/jemalloc/jemalloc_macros.h:include/jemalloc/jemalloc_macros.h.in"
543cfgoutputs_tup="${cfgoutputs_tup} include/jemalloc/jemalloc_protos.h:include/jemalloc/jemalloc_protos.h.in"
Jason Evans376b1522010-02-11 14:45:59 -0800544cfgoutputs_tup="${cfgoutputs_tup} include/jemalloc/internal/jemalloc_internal.h"
Jason Evans86abd0d2013-11-30 15:25:42 -0800545cfgoutputs_tup="${cfgoutputs_tup} test/test.sh:test/test.sh.in"
546cfgoutputs_tup="${cfgoutputs_tup} test/include/test/jemalloc_test.h:test/include/test/jemalloc_test.h.in"
Jason Evansb0fd5012010-01-17 01:49:20 -0800547
Jason Evans0656ec02010-04-07 23:37:35 -0700548cfghdrs_in="${srcroot}include/jemalloc/jemalloc_defs.h.in"
Jason Evans86abd0d2013-11-30 15:25:42 -0800549cfghdrs_in="${cfghdrs_in} ${srcroot}include/jemalloc/internal/jemalloc_internal_defs.h.in"
550cfghdrs_in="${cfghdrs_in} ${srcroot}include/jemalloc/internal/private_namespace.sh"
551cfghdrs_in="${cfghdrs_in} ${srcroot}include/jemalloc/internal/private_unnamespace.sh"
Jason Evansf234dc52014-01-16 17:38:01 -0800552cfghdrs_in="${cfghdrs_in} ${srcroot}include/jemalloc/internal/private_symbols.txt"
Jason Evans86abd0d2013-11-30 15:25:42 -0800553cfghdrs_in="${cfghdrs_in} ${srcroot}include/jemalloc/internal/public_namespace.sh"
554cfghdrs_in="${cfghdrs_in} ${srcroot}include/jemalloc/internal/public_unnamespace.sh"
Jason Evansb1726102012-02-28 16:50:47 -0800555cfghdrs_in="${cfghdrs_in} ${srcroot}include/jemalloc/internal/size_classes.sh"
Jason Evansf234dc52014-01-16 17:38:01 -0800556cfghdrs_in="${cfghdrs_in} ${srcroot}include/jemalloc/jemalloc_rename.sh"
557cfghdrs_in="${cfghdrs_in} ${srcroot}include/jemalloc/jemalloc_mangle.sh"
Jason Evansdc1bed62013-12-05 21:43:46 -0800558cfghdrs_in="${cfghdrs_in} ${srcroot}include/jemalloc/jemalloc.sh"
Jason Evans80061b62013-12-09 13:21:08 -0800559cfghdrs_in="${cfghdrs_in} ${srcroot}test/include/test/jemalloc_test_defs.h.in"
Jason Evansb0fd5012010-01-17 01:49:20 -0800560
Jason Evans86abd0d2013-11-30 15:25:42 -0800561cfghdrs_out="include/jemalloc/jemalloc_defs.h"
562cfghdrs_out="${cfghdrs_out} include/jemalloc/jemalloc${install_suffix}.h"
Jason Evans86abd0d2013-11-30 15:25:42 -0800563cfghdrs_out="${cfghdrs_out} include/jemalloc/internal/private_namespace.h"
564cfghdrs_out="${cfghdrs_out} include/jemalloc/internal/private_unnamespace.h"
Jason Evansf234dc52014-01-16 17:38:01 -0800565cfghdrs_out="${cfghdrs_out} include/jemalloc/internal/public_symbols.txt"
Jason Evans86abd0d2013-11-30 15:25:42 -0800566cfghdrs_out="${cfghdrs_out} include/jemalloc/internal/public_namespace.h"
567cfghdrs_out="${cfghdrs_out} include/jemalloc/internal/public_unnamespace.h"
Jason Evansb1726102012-02-28 16:50:47 -0800568cfghdrs_out="${cfghdrs_out} include/jemalloc/internal/size_classes.h"
Jason Evansf234dc52014-01-16 17:38:01 -0800569cfghdrs_out="${cfghdrs_out} include/jemalloc/jemalloc_protos_jet.h"
570cfghdrs_out="${cfghdrs_out} include/jemalloc/jemalloc_rename.h"
571cfghdrs_out="${cfghdrs_out} include/jemalloc/jemalloc_mangle.h"
572cfghdrs_out="${cfghdrs_out} include/jemalloc/jemalloc_mangle_jet.h"
573cfghdrs_out="${cfghdrs_out} include/jemalloc/internal/jemalloc_internal_defs.h"
Jason Evans80061b62013-12-09 13:21:08 -0800574cfghdrs_out="${cfghdrs_out} test/include/test/jemalloc_test_defs.h"
Jason Evansb0fd5012010-01-17 01:49:20 -0800575
Jason Evans86abd0d2013-11-30 15:25:42 -0800576cfghdrs_tup="include/jemalloc/jemalloc_defs.h:include/jemalloc/jemalloc_defs.h.in"
577cfghdrs_tup="${cfghdrs_tup} include/jemalloc/internal/jemalloc_internal_defs.h:${srcroot}include/jemalloc/internal/jemalloc_internal_defs.h.in"
Jason Evans80061b62013-12-09 13:21:08 -0800578cfghdrs_tup="${cfghdrs_tup} test/include/test/jemalloc_test_defs.h:${srcroot}test/include/test/jemalloc_test_defs.h.in"
Jason Evansb0fd5012010-01-17 01:49:20 -0800579
Jason Evans355b4382010-09-20 19:20:48 -0700580dnl Do not silence irrelevant compiler warnings by default, since enabling this
581dnl option incurs a performance penalty.
582AC_ARG_ENABLE([cc-silence],
583 [AS_HELP_STRING([--enable-cc-silence],
584 [Silence irrelevant compiler warnings])],
585[if test "x$enable_cc_silence" = "xno" ; then
586 enable_cc_silence="0"
587else
588 enable_cc_silence="1"
589fi
590],
591[enable_cc_silence="0"]
592)
593if test "x$enable_cc_silence" = "x1" ; then
Jason Evanse24c7af2012-03-19 10:21:17 -0700594 AC_DEFINE([JEMALLOC_CC_SILENCE], [ ])
Jason Evans355b4382010-09-20 19:20:48 -0700595fi
596
Jason Evansb7924f52009-06-23 19:01:18 -0700597dnl Do not compile with debugging by default.
598AC_ARG_ENABLE([debug],
Mike Hommey5135e342012-12-06 22:16:26 +0100599 [AS_HELP_STRING([--enable-debug], [Build debugging code (implies --enable-ivsalloc)])],
Jason Evansb7924f52009-06-23 19:01:18 -0700600[if test "x$enable_debug" = "xno" ; then
601 enable_debug="0"
602else
603 enable_debug="1"
604fi
605],
606[enable_debug="0"]
607)
608if test "x$enable_debug" = "x1" ; then
609 AC_DEFINE([JEMALLOC_DEBUG], [ ])
Mike Hommey5135e342012-12-06 22:16:26 +0100610 enable_ivsalloc="1"
Jason Evansb7924f52009-06-23 19:01:18 -0700611fi
612AC_SUBST([enable_debug])
613
Mike Hommey5135e342012-12-06 22:16:26 +0100614dnl Do not validate pointers by default.
615AC_ARG_ENABLE([ivsalloc],
616 [AS_HELP_STRING([--enable-ivsalloc], [Validate pointers passed through the public API])],
617[if test "x$enable_ivsalloc" = "xno" ; then
618 enable_ivsalloc="0"
619else
620 enable_ivsalloc="1"
621fi
622],
623[enable_ivsalloc="0"]
624)
625if test "x$enable_ivsalloc" = "x1" ; then
626 AC_DEFINE([JEMALLOC_IVSALLOC], [ ])
627fi
628
Jason Evansb7924f52009-06-23 19:01:18 -0700629dnl Only optimize if not debugging.
630if test "x$enable_debug" = "x0" -a "x$no_CFLAGS" = "xyes" ; then
631 dnl Make sure that an optimization flag was not specified in EXTRA_CFLAGS.
Jason Evansf3340ca2009-06-30 16:17:05 -0700632 optimize="no"
Jason Evans748dfac2013-12-06 18:27:33 -0800633 echo "$CFLAGS $EXTRA_CFLAGS" | grep '\-O' >/dev/null || optimize="yes"
Jason Evansf3340ca2009-06-30 16:17:05 -0700634 if test "x${optimize}" = "xyes" ; then
635 if test "x$GCC" = "xyes" ; then
636 JE_CFLAGS_APPEND([-O3])
637 JE_CFLAGS_APPEND([-funroll-loops])
Mike Hommeyfd97b1d2012-04-30 12:38:31 +0200638 elif test "x$je_cv_msvc" = "xyes" ; then
639 JE_CFLAGS_APPEND([-O2])
Jason Evansf3340ca2009-06-30 16:17:05 -0700640 else
641 JE_CFLAGS_APPEND([-O])
642 fi
Jason Evansb7924f52009-06-23 19:01:18 -0700643 fi
644fi
645
Jason Evansd073a322012-02-28 20:41:16 -0800646dnl Enable statistics calculation by default.
Jason Evansb7924f52009-06-23 19:01:18 -0700647AC_ARG_ENABLE([stats],
Jason Evans777c1912012-02-28 20:49:22 -0800648 [AS_HELP_STRING([--disable-stats],
649 [Disable statistics calculation/reporting])],
Jason Evansb7924f52009-06-23 19:01:18 -0700650[if test "x$enable_stats" = "xno" ; then
651 enable_stats="0"
652else
653 enable_stats="1"
654fi
655],
Jason Evansd073a322012-02-28 20:41:16 -0800656[enable_stats="1"]
Jason Evansb7924f52009-06-23 19:01:18 -0700657)
658if test "x$enable_stats" = "x1" ; then
659 AC_DEFINE([JEMALLOC_STATS], [ ])
660fi
661AC_SUBST([enable_stats])
662
Jason Evans6109fe02010-02-10 10:37:56 -0800663dnl Do not enable profiling by default.
664AC_ARG_ENABLE([prof],
665 [AS_HELP_STRING([--enable-prof], [Enable allocation profiling])],
666[if test "x$enable_prof" = "xno" ; then
667 enable_prof="0"
668else
669 enable_prof="1"
670fi
671],
672[enable_prof="0"]
673)
Jason Evans77f350b2011-03-15 22:23:12 -0700674if test "x$enable_prof" = "x1" ; then
675 backtrace_method=""
Jason Evansb27805b2010-02-10 18:15:53 -0800676else
Jason Evans77f350b2011-03-15 22:23:12 -0700677 backtrace_method="N/A"
Jason Evansb27805b2010-02-10 18:15:53 -0800678fi
Jason Evans77f350b2011-03-15 22:23:12 -0700679
Jason Evans6109fe02010-02-10 10:37:56 -0800680AC_ARG_ENABLE([prof-libunwind],
681 [AS_HELP_STRING([--enable-prof-libunwind], [Use libunwind for backtracing])],
682[if test "x$enable_prof_libunwind" = "xno" ; then
683 enable_prof_libunwind="0"
684else
685 enable_prof_libunwind="1"
686fi
687],
688[enable_prof_libunwind="0"]
689)
Jason Evansca6bd4f2010-03-02 14:12:58 -0800690AC_ARG_WITH([static_libunwind],
691 [AS_HELP_STRING([--with-static-libunwind=<libunwind.a>],
692 [Path to static libunwind library; use rather than dynamically linking])],
693if test "x$with_static_libunwind" = "xno" ; then
694 LUNWIND="-lunwind"
695else
696 if test ! -f "$with_static_libunwind" ; then
697 AC_MSG_ERROR([Static libunwind not found: $with_static_libunwind])
698 fi
699 LUNWIND="$with_static_libunwind"
700fi,
701 LUNWIND="-lunwind"
702)
Jason Evans77f350b2011-03-15 22:23:12 -0700703if test "x$backtrace_method" = "x" -a "x$enable_prof_libunwind" = "x1" ; then
704 AC_CHECK_HEADERS([libunwind.h], , [enable_prof_libunwind="0"])
705 if test "x$LUNWIND" = "x-lunwind" ; then
706 AC_CHECK_LIB([unwind], [backtrace], [LIBS="$LIBS $LUNWIND"],
707 [enable_prof_libunwind="0"])
708 else
709 LIBS="$LIBS $LUNWIND"
710 fi
711 if test "x${enable_prof_libunwind}" = "x1" ; then
712 backtrace_method="libunwind"
713 AC_DEFINE([JEMALLOC_PROF_LIBUNWIND], [ ])
714 fi
715fi
716
717AC_ARG_ENABLE([prof-libgcc],
718 [AS_HELP_STRING([--disable-prof-libgcc],
719 [Do not use libgcc for backtracing])],
720[if test "x$enable_prof_libgcc" = "xno" ; then
721 enable_prof_libgcc="0"
722else
723 enable_prof_libgcc="1"
724fi
725],
726[enable_prof_libgcc="1"]
727)
728if test "x$backtrace_method" = "x" -a "x$enable_prof_libgcc" = "x1" \
729 -a "x$GCC" = "xyes" ; then
730 AC_CHECK_HEADERS([unwind.h], , [enable_prof_libgcc="0"])
731 AC_CHECK_LIB([gcc], [_Unwind_Backtrace], [LIBS="$LIBS -lgcc"], [enable_prof_libgcc="0"])
Jason Evans77f350b2011-03-15 22:23:12 -0700732 if test "x${enable_prof_libgcc}" = "x1" ; then
733 backtrace_method="libgcc"
734 AC_DEFINE([JEMALLOC_PROF_LIBGCC], [ ])
735 fi
736else
737 enable_prof_libgcc="0"
738fi
739
740AC_ARG_ENABLE([prof-gcc],
741 [AS_HELP_STRING([--disable-prof-gcc],
742 [Do not use gcc intrinsics for backtracing])],
743[if test "x$enable_prof_gcc" = "xno" ; then
744 enable_prof_gcc="0"
745else
746 enable_prof_gcc="1"
747fi
748],
749[enable_prof_gcc="1"]
750)
751if test "x$backtrace_method" = "x" -a "x$enable_prof_gcc" = "x1" \
752 -a "x$GCC" = "xyes" ; then
Jason Evanse181f5a2014-03-30 18:58:32 -0700753 JE_CFLAGS_APPEND([-fno-omit-frame-pointer])
Jason Evans77f350b2011-03-15 22:23:12 -0700754 backtrace_method="gcc intrinsics"
755 AC_DEFINE([JEMALLOC_PROF_GCC], [ ])
756else
757 enable_prof_gcc="0"
758fi
759
760if test "x$backtrace_method" = "x" ; then
761 backtrace_method="none (disabling profiling)"
762 enable_prof="0"
763fi
764AC_MSG_CHECKING([configured backtracing method])
765AC_MSG_RESULT([$backtrace_method])
Jason Evans2dbecf12010-09-05 10:35:13 -0700766if test "x$enable_prof" = "x1" ; then
Jason Evans6716aa82012-04-23 13:04:55 -0700767 if test "x${force_tls}" = "x0" ; then
768 AC_MSG_ERROR([Heap profiling requires TLS]);
769 fi
770 force_tls="1"
Jason Evansd37d5ad2013-12-05 23:01:50 -0800771
772 if test "x$abi" != "xpecoff"; then
773 dnl Heap profiling uses the log(3) function.
774 LIBS="$LIBS -lm"
775 fi
776
Jason Evans2dbecf12010-09-05 10:35:13 -0700777 AC_DEFINE([JEMALLOC_PROF], [ ])
Jason Evans2dbecf12010-09-05 10:35:13 -0700778fi
779AC_SUBST([enable_prof])
Jason Evans2dbecf12010-09-05 10:35:13 -0700780
Jason Evans84cbbcb2009-12-29 00:09:15 -0800781dnl Enable thread-specific caching by default.
782AC_ARG_ENABLE([tcache],
783 [AS_HELP_STRING([--disable-tcache], [Disable per thread caches])],
784[if test "x$enable_tcache" = "xno" ; then
785 enable_tcache="0"
Jason Evansb7924f52009-06-23 19:01:18 -0700786else
Jason Evans84cbbcb2009-12-29 00:09:15 -0800787 enable_tcache="1"
Jason Evansb7924f52009-06-23 19:01:18 -0700788fi
789],
Jason Evans84cbbcb2009-12-29 00:09:15 -0800790[enable_tcache="1"]
Jason Evansb7924f52009-06-23 19:01:18 -0700791)
Jason Evans2dbecf12010-09-05 10:35:13 -0700792if test "x$enable_tcache" = "x1" ; then
793 AC_DEFINE([JEMALLOC_TCACHE], [ ])
794fi
795AC_SUBST([enable_tcache])
Jason Evansb7924f52009-06-23 19:01:18 -0700796
Jason Evans2e671ff2012-05-09 16:12:00 -0700797dnl Disable mremap() for huge realloc() by default.
798AC_ARG_ENABLE([mremap],
799 [AS_HELP_STRING([--enable-mremap], [Enable mremap(2) for huge realloc()])],
800[if test "x$enable_mremap" = "xno" ; then
801 enable_mremap="0"
802else
803 enable_mremap="1"
804fi
805],
806[enable_mremap="0"]
807)
808if test "x$enable_mremap" = "x1" ; then
809 JE_COMPILABLE([mremap(...MREMAP_FIXED...)], [
Jason Evansa4f124f2013-12-08 22:28:27 -0800810#define _GNU_SOURCE
Jason Evans2e671ff2012-05-09 16:12:00 -0700811#include <sys/mman.h>
812], [
813void *p = mremap((void *)0, 0, 0, MREMAP_MAYMOVE|MREMAP_FIXED, (void *)0);
814], [je_cv_mremap_fixed])
815 if test "x${je_cv_mremap_fixed}" = "xno" ; then
816 enable_mremap="0"
817 fi
818fi
819if test "x$enable_mremap" = "x1" ; then
820 AC_DEFINE([JEMALLOC_MREMAP], [ ])
821fi
822AC_SUBST([enable_mremap])
823
Jason Evans59ae2762012-04-16 17:52:27 -0700824dnl Enable VM deallocation via munmap() by default.
825AC_ARG_ENABLE([munmap],
826 [AS_HELP_STRING([--disable-munmap], [Disable VM deallocation via munmap(2)])],
827[if test "x$enable_munmap" = "xno" ; then
828 enable_munmap="0"
829else
830 enable_munmap="1"
831fi
832],
833[enable_munmap="${default_munmap}"]
834)
835if test "x$enable_munmap" = "x1" ; then
836 AC_DEFINE([JEMALLOC_MUNMAP], [ ])
837fi
838AC_SUBST([enable_munmap])
839
Jason Evansb7924f52009-06-23 19:01:18 -0700840dnl Do not enable allocation from DSS by default.
841AC_ARG_ENABLE([dss],
842 [AS_HELP_STRING([--enable-dss], [Enable allocation from DSS])],
843[if test "x$enable_dss" = "xno" ; then
844 enable_dss="0"
845else
846 enable_dss="1"
847fi
848],
849[enable_dss="0"]
850)
Mike Hommey83c324a2012-04-12 10:13:03 +0200851dnl Check whether the BSD/SUSv1 sbrk() exists. If not, disable DSS support.
852AC_CHECK_FUNC([sbrk], [have_sbrk="1"], [have_sbrk="0"])
853if test "x$have_sbrk" = "x1" ; then
Jason Evans66688532013-12-03 21:49:36 -0800854 if test "x$sbrk_deprecated" == "x1" ; then
855 AC_MSG_RESULT([Disabling dss allocation because sbrk is deprecated])
856 enable_dss="0"
857 else
858 AC_DEFINE([JEMALLOC_HAVE_SBRK], [ ])
859 fi
Mike Hommey83c324a2012-04-12 10:13:03 +0200860else
861 enable_dss="0"
862fi
863
Jason Evansb7924f52009-06-23 19:01:18 -0700864if test "x$enable_dss" = "x1" ; then
865 AC_DEFINE([JEMALLOC_DSS], [ ])
866fi
867AC_SUBST([enable_dss])
868
Jason Evans777c1912012-02-28 20:49:22 -0800869dnl Support the junk/zero filling option by default.
Jason Evansb7924f52009-06-23 19:01:18 -0700870AC_ARG_ENABLE([fill],
Jason Evans122449b2012-04-06 00:35:09 -0700871 [AS_HELP_STRING([--disable-fill],
872 [Disable support for junk/zero filling, quarantine, and redzones])],
Jason Evansb7924f52009-06-23 19:01:18 -0700873[if test "x$enable_fill" = "xno" ; then
874 enable_fill="0"
875else
876 enable_fill="1"
877fi
878],
Jason Evans777c1912012-02-28 20:49:22 -0800879[enable_fill="1"]
Jason Evansb7924f52009-06-23 19:01:18 -0700880)
881if test "x$enable_fill" = "x1" ; then
882 AC_DEFINE([JEMALLOC_FILL], [ ])
883fi
884AC_SUBST([enable_fill])
885
Jason Evansb1476112012-04-05 13:36:17 -0700886dnl Disable utrace(2)-based tracing by default.
887AC_ARG_ENABLE([utrace],
888 [AS_HELP_STRING([--enable-utrace], [Enable utrace(2)-based tracing])],
889[if test "x$enable_utrace" = "xno" ; then
890 enable_utrace="0"
891else
892 enable_utrace="1"
893fi
894],
895[enable_utrace="0"]
896)
897JE_COMPILABLE([utrace(2)], [
898#include <sys/types.h>
899#include <sys/param.h>
900#include <sys/time.h>
901#include <sys/uio.h>
902#include <sys/ktrace.h>
903], [
904 utrace((void *)0, 0);
905], [je_cv_utrace])
906if test "x${je_cv_utrace}" = "xno" ; then
907 enable_utrace="0"
908fi
909if test "x$enable_utrace" = "x1" ; then
910 AC_DEFINE([JEMALLOC_UTRACE], [ ])
911fi
912AC_SUBST([enable_utrace])
913
Jason Evans122449b2012-04-06 00:35:09 -0700914dnl Support Valgrind by default.
915AC_ARG_ENABLE([valgrind],
916 [AS_HELP_STRING([--disable-valgrind], [Disable support for Valgrind])],
917[if test "x$enable_valgrind" = "xno" ; then
918 enable_valgrind="0"
919else
920 enable_valgrind="1"
921fi
922],
923[enable_valgrind="1"]
924)
925if test "x$enable_valgrind" = "x1" ; then
926 JE_COMPILABLE([valgrind], [
927#include <valgrind/valgrind.h>
928#include <valgrind/memcheck.h>
929
Mike Hommey7bfecf42012-04-30 15:15:15 +0200930#if !defined(VALGRIND_RESIZEINPLACE_BLOCK)
Jason Evans122449b2012-04-06 00:35:09 -0700931# error "Incompatible Valgrind version"
932#endif
933], [], [je_cv_valgrind])
934 if test "x${je_cv_valgrind}" = "xno" ; then
935 enable_valgrind="0"
936 fi
937 if test "x$enable_valgrind" = "x1" ; then
938 AC_DEFINE([JEMALLOC_VALGRIND], [ ])
939 fi
940fi
941AC_SUBST([enable_valgrind])
942
Jason Evansb7924f52009-06-23 19:01:18 -0700943dnl Do not support the xmalloc option by default.
944AC_ARG_ENABLE([xmalloc],
945 [AS_HELP_STRING([--enable-xmalloc], [Support xmalloc option])],
946[if test "x$enable_xmalloc" = "xno" ; then
947 enable_xmalloc="0"
948else
949 enable_xmalloc="1"
950fi
951],
952[enable_xmalloc="0"]
953)
954if test "x$enable_xmalloc" = "x1" ; then
955 AC_DEFINE([JEMALLOC_XMALLOC], [ ])
956fi
957AC_SUBST([enable_xmalloc])
958
Jason Evans6684cac2012-03-05 12:15:36 -0800959AC_CACHE_CHECK([STATIC_PAGE_SHIFT],
960 [je_cv_static_page_shift],
961 AC_RUN_IFELSE([AC_LANG_PROGRAM(
Mike Hommeya19e87f2012-04-21 21:27:46 -0700962[[
Mike Hommeyfd97b1d2012-04-30 12:38:31 +0200963#include <strings.h>
Mike Hommeya19e87f2012-04-21 21:27:46 -0700964#ifdef _WIN32
965#include <windows.h>
966#else
Jason Evansb7924f52009-06-23 19:01:18 -0700967#include <unistd.h>
Mike Hommeya19e87f2012-04-21 21:27:46 -0700968#endif
969#include <stdio.h>
Jason Evans6684cac2012-03-05 12:15:36 -0800970]],
971[[
Garrett Cooper72c1e592012-12-02 17:57:28 -0800972 int result;
Jason Evansb7924f52009-06-23 19:01:18 -0700973 FILE *f;
974
Mike Hommeya19e87f2012-04-21 21:27:46 -0700975#ifdef _WIN32
976 SYSTEM_INFO si;
977 GetSystemInfo(&si);
978 result = si.dwPageSize;
979#else
Jason Evansb7924f52009-06-23 19:01:18 -0700980 result = sysconf(_SC_PAGESIZE);
Mike Hommeya19e87f2012-04-21 21:27:46 -0700981#endif
Jason Evansb7924f52009-06-23 19:01:18 -0700982 if (result == -1) {
983 return 1;
984 }
Mike Hommeya19e87f2012-04-21 21:27:46 -0700985 result = ffsl(result) - 1;
986
Jason Evansb7924f52009-06-23 19:01:18 -0700987 f = fopen("conftest.out", "w");
988 if (f == NULL) {
989 return 1;
990 }
Garrett Cooper72c1e592012-12-02 17:57:28 -0800991 fprintf(f, "%d\n", result);
Jason Evans3cc1f1a2012-04-03 22:30:05 -0700992 fclose(f);
Jason Evansb7924f52009-06-23 19:01:18 -0700993
994 return 0;
995]])],
Jason Evans6684cac2012-03-05 12:15:36 -0800996 [je_cv_static_page_shift=`cat conftest.out`],
997 [je_cv_static_page_shift=undefined]))
998
999if test "x$je_cv_static_page_shift" != "xundefined"; then
1000 AC_DEFINE_UNQUOTED([STATIC_PAGE_SHIFT], [$je_cv_static_page_shift])
1001else
1002 AC_MSG_ERROR([cannot determine value for STATIC_PAGE_SHIFT])
1003fi
Jason Evansb7924f52009-06-23 19:01:18 -07001004
1005dnl ============================================================================
1006dnl jemalloc configuration.
1007dnl
Jason Evansa40bc7a2010-03-02 13:01:16 -08001008
1009dnl Set VERSION if source directory has an embedded git repository.
Jason Evans955851f2011-03-31 22:38:51 -07001010if test -d "${srcroot}.git" ; then
Jason Evans79d660d2010-09-17 17:38:24 -07001011 git describe --long --abbrev=40 > ${srcroot}VERSION
Jason Evansa40bc7a2010-03-02 13:01:16 -08001012fi
Jason Evansb7924f52009-06-23 19:01:18 -07001013jemalloc_version=`cat ${srcroot}VERSION`
Jason Evansa40bc7a2010-03-02 13:01:16 -08001014jemalloc_version_major=`echo ${jemalloc_version} | tr ".g-" " " | awk '{print [$]1}'`
1015jemalloc_version_minor=`echo ${jemalloc_version} | tr ".g-" " " | awk '{print [$]2}'`
1016jemalloc_version_bugfix=`echo ${jemalloc_version} | tr ".g-" " " | awk '{print [$]3}'`
1017jemalloc_version_nrev=`echo ${jemalloc_version} | tr ".g-" " " | awk '{print [$]4}'`
1018jemalloc_version_gid=`echo ${jemalloc_version} | tr ".g-" " " | awk '{print [$]5}'`
Jason Evansb7924f52009-06-23 19:01:18 -07001019AC_SUBST([jemalloc_version])
Jason Evansa40bc7a2010-03-02 13:01:16 -08001020AC_SUBST([jemalloc_version_major])
1021AC_SUBST([jemalloc_version_minor])
1022AC_SUBST([jemalloc_version_bugfix])
1023AC_SUBST([jemalloc_version_nrev])
1024AC_SUBST([jemalloc_version_gid])
Jason Evansb7924f52009-06-23 19:01:18 -07001025
1026dnl ============================================================================
1027dnl Configure pthreads.
1028
Mike Hommeya19e87f2012-04-21 21:27:46 -07001029if test "x$abi" != "xpecoff" ; then
1030 AC_CHECK_HEADERS([pthread.h], , [AC_MSG_ERROR([pthread.h is missing])])
1031 dnl Some systems may embed pthreads functionality in libc; check for libpthread
1032 dnl first, but try libc too before failing.
1033 AC_CHECK_LIB([pthread], [pthread_create], [LIBS="$LIBS -lpthread"],
1034 [AC_SEARCH_LIBS([pthread_create], , ,
1035 AC_MSG_ERROR([libpthread is missing]))])
1036fi
Jason Evansb7924f52009-06-23 19:01:18 -07001037
1038CPPFLAGS="$CPPFLAGS -D_REENTRANT"
1039
Jason Evanscd9a1342012-03-21 18:33:03 -07001040dnl Check whether the BSD-specific _malloc_thread_cleanup() exists. If so, use
1041dnl it rather than pthreads TSD cleanup functions to support cleanup during
1042dnl thread exit, in order to avoid pthreads library recursion during
1043dnl bootstrapping.
Jason Evanscd9a1342012-03-21 18:33:03 -07001044AC_CHECK_FUNC([_malloc_thread_cleanup],
1045 [have__malloc_thread_cleanup="1"],
1046 [have__malloc_thread_cleanup="0"]
1047 )
1048if test "x$have__malloc_thread_cleanup" = "x1" ; then
1049 AC_DEFINE([JEMALLOC_MALLOC_THREAD_CLEANUP], [ ])
1050 force_tls="1"
1051fi
1052
Jason Evans41b6afb2012-02-02 22:04:57 -08001053dnl Check whether the BSD-specific _pthread_mutex_init_calloc_cb() exists. If
1054dnl so, mutex initialization causes allocation, and we need to implement this
1055dnl callback function in order to prevent recursive allocation.
1056AC_CHECK_FUNC([_pthread_mutex_init_calloc_cb],
1057 [have__pthread_mutex_init_calloc_cb="1"],
1058 [have__pthread_mutex_init_calloc_cb="0"]
1059 )
1060if test "x$have__pthread_mutex_init_calloc_cb" = "x1" ; then
1061 AC_DEFINE([JEMALLOC_MUTEX_INIT_CB])
1062fi
1063
Jason Evans0fee70d2012-02-13 12:36:11 -08001064dnl Disable lazy locking by default.
Jason Evansb7924f52009-06-23 19:01:18 -07001065AC_ARG_ENABLE([lazy_lock],
Jason Evans0fee70d2012-02-13 12:36:11 -08001066 [AS_HELP_STRING([--enable-lazy-lock],
1067 [Enable lazy locking (only lock when multi-threaded)])],
Jason Evansb7924f52009-06-23 19:01:18 -07001068[if test "x$enable_lazy_lock" = "xno" ; then
1069 enable_lazy_lock="0"
1070else
1071 enable_lazy_lock="1"
1072fi
1073],
Jason Evans0fee70d2012-02-13 12:36:11 -08001074[enable_lazy_lock="0"]
Jason Evansb7924f52009-06-23 19:01:18 -07001075)
Jason Evansfd4fcef2012-03-23 17:40:58 -07001076if test "x$enable_lazy_lock" = "x0" -a "x${force_lazy_lock}" = "x1" ; then
1077 AC_MSG_RESULT([Forcing lazy-lock to avoid allocator/threading bootstrap issues])
1078 enable_lazy_lock="1"
1079fi
Jason Evansb7924f52009-06-23 19:01:18 -07001080if test "x$enable_lazy_lock" = "x1" ; then
Mike Hommeya19e87f2012-04-21 21:27:46 -07001081 if test "x$abi" != "xpecoff" ; then
1082 AC_CHECK_HEADERS([dlfcn.h], , [AC_MSG_ERROR([dlfcn.h is missing])])
1083 AC_CHECK_FUNC([dlsym], [],
1084 [AC_CHECK_LIB([dl], [dlsym], [LIBS="$LIBS -ldl"],
1085 [AC_MSG_ERROR([libdl is missing])])
1086 ])
1087 fi
Jason Evansb7924f52009-06-23 19:01:18 -07001088 AC_DEFINE([JEMALLOC_LAZY_LOCK], [ ])
1089fi
1090AC_SUBST([enable_lazy_lock])
1091
Jason Evans78d815c2010-01-17 14:06:20 -08001092AC_ARG_ENABLE([tls],
1093 [AS_HELP_STRING([--disable-tls], [Disable thread-local storage (__thread keyword)])],
1094if test "x$enable_tls" = "xno" ; then
1095 enable_tls="0"
1096else
1097 enable_tls="1"
1098fi
1099,
1100enable_tls="1"
1101)
Jason Evanscd9a1342012-03-21 18:33:03 -07001102if test "x${enable_tls}" = "x0" -a "x${force_tls}" = "x1" ; then
1103 AC_MSG_RESULT([Forcing TLS to avoid allocator/threading bootstrap issues])
1104 enable_tls="1"
1105fi
Jason Evansb80581d2012-03-23 16:17:43 -07001106if test "x${enable_tls}" = "x1" -a "x${force_tls}" = "x0" ; then
1107 AC_MSG_RESULT([Forcing no TLS to avoid allocator/threading bootstrap issues])
1108 enable_tls="0"
1109fi
Jason Evans78d815c2010-01-17 14:06:20 -08001110if test "x${enable_tls}" = "x1" ; then
1111AC_MSG_CHECKING([for TLS])
Jason Evans6684cac2012-03-05 12:15:36 -08001112AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
Jason Evans78d815c2010-01-17 14:06:20 -08001113[[
1114 __thread int x;
1115]], [[
1116 x = 42;
1117
1118 return 0;
1119]])],
1120 AC_MSG_RESULT([yes]),
1121 AC_MSG_RESULT([no])
1122 enable_tls="0")
1123fi
Jason Evansb267d0f2010-08-13 15:42:29 -07001124AC_SUBST([enable_tls])
Jason Evanse24c7af2012-03-19 10:21:17 -07001125if test "x${enable_tls}" = "x1" ; then
1126 AC_DEFINE_UNQUOTED([JEMALLOC_TLS], [ ])
Jason Evanscd9a1342012-03-21 18:33:03 -07001127elif test "x${force_tls}" = "x1" ; then
1128 AC_MSG_ERROR([Failed to configure TLS, which is mandatory for correct function])
Jason Evans78d815c2010-01-17 14:06:20 -08001129fi
1130
Jason Evans2dbecf12010-09-05 10:35:13 -07001131dnl ============================================================================
Jason Evans84c8eef2011-03-16 10:30:13 -07001132dnl Check for ffsl(3), and fail if not found. This function exists on all
1133dnl platforms that jemalloc currently has a chance of functioning on without
1134dnl modification.
Jason Evans4c2faa82012-03-13 11:09:23 -07001135JE_COMPILABLE([a program using ffsl], [
Garrett Cooper72c1e592012-12-02 17:57:28 -08001136#include <stdio.h>
Jason Evans382132e2012-04-04 15:25:43 -07001137#include <strings.h>
Jason Evans4c2faa82012-03-13 11:09:23 -07001138#include <string.h>
1139], [
1140 {
1141 int rv = ffsl(0x08);
Garrett Cooper72c1e592012-12-02 17:57:28 -08001142 printf("%d\n", rv);
Jason Evans4c2faa82012-03-13 11:09:23 -07001143 }
1144], [je_cv_function_ffsl])
Jason Evans6684cac2012-03-05 12:15:36 -08001145if test "x${je_cv_function_ffsl}" != "xyes" ; then
1146 AC_MSG_ERROR([Cannot build without ffsl(3)])
1147fi
Jason Evans84c8eef2011-03-16 10:30:13 -07001148
1149dnl ============================================================================
Jason Evansb57d3ec2012-04-17 13:17:54 -07001150dnl Check for atomic(9) operations as provided on FreeBSD.
1151
1152JE_COMPILABLE([atomic(9)], [
1153#include <sys/types.h>
1154#include <machine/atomic.h>
1155#include <inttypes.h>
1156], [
1157 {
1158 uint32_t x32 = 0;
1159 volatile uint32_t *x32p = &x32;
1160 atomic_fetchadd_32(x32p, 1);
1161 }
1162 {
1163 unsigned long xlong = 0;
1164 volatile unsigned long *xlongp = &xlong;
1165 atomic_fetchadd_long(xlongp, 1);
1166 }
1167], [je_cv_atomic9])
1168if test "x${je_cv_atomic9}" = "xyes" ; then
1169 AC_DEFINE([JEMALLOC_ATOMIC9])
1170fi
1171
1172dnl ============================================================================
Jason Evans763baa62011-03-18 19:10:31 -07001173dnl Check for atomic(3) operations as provided on Darwin.
1174
1175JE_COMPILABLE([Darwin OSAtomic*()], [
1176#include <libkern/OSAtomic.h>
1177#include <inttypes.h>
1178], [
1179 {
1180 int32_t x32 = 0;
1181 volatile int32_t *x32p = &x32;
1182 OSAtomicAdd32(1, x32p);
1183 }
1184 {
1185 int64_t x64 = 0;
1186 volatile int64_t *x64p = &x64;
1187 OSAtomicAdd64(1, x64p);
1188 }
Jason Evans6684cac2012-03-05 12:15:36 -08001189], [je_cv_osatomic])
1190if test "x${je_cv_osatomic}" = "xyes" ; then
Jason Evanse24c7af2012-03-19 10:21:17 -07001191 AC_DEFINE([JEMALLOC_OSATOMIC], [ ])
Jason Evans763baa62011-03-18 19:10:31 -07001192fi
1193
1194dnl ============================================================================
Mike Hommeyc1e567b2012-03-26 17:03:41 +02001195dnl Check whether __sync_{add,sub}_and_fetch() are available despite
1196dnl __GCC_HAVE_SYNC_COMPARE_AND_SWAP_n macros being undefined.
1197
1198AC_DEFUN([JE_SYNC_COMPARE_AND_SWAP_CHECK],[
1199 AC_CACHE_CHECK([whether to force $1-bit __sync_{add,sub}_and_fetch()],
1200 [je_cv_sync_compare_and_swap_$2],
Mike Hommey2cfe6d62012-03-27 15:03:07 +02001201 [AC_LINK_IFELSE([AC_LANG_PROGRAM([
1202 #include <stdint.h>
1203 ],
1204 [
1205 #ifndef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_$2
1206 {
1207 uint$1_t x$1 = 0;
1208 __sync_add_and_fetch(&x$1, 42);
1209 __sync_sub_and_fetch(&x$1, 1);
1210 }
1211 #else
1212 #error __GCC_HAVE_SYNC_COMPARE_AND_SWAP_$2 is defined, no need to force
1213 #endif
1214 ])],
Mike Hommeyc1e567b2012-03-26 17:03:41 +02001215 [je_cv_sync_compare_and_swap_$2=yes],
1216 [je_cv_sync_compare_and_swap_$2=no])])
1217
1218 if test "x${je_cv_sync_compare_and_swap_$2}" = "xyes" ; then
1219 AC_DEFINE([JE_FORCE_SYNC_COMPARE_AND_SWAP_$2], [ ])
1220 fi
1221])
1222
Jason Evansb57d3ec2012-04-17 13:17:54 -07001223if test "x${je_cv_atomic9}" != "xyes" -a "x${je_cv_osatomic}" != "xyes" ; then
Mike Hommeyc1e567b2012-03-26 17:03:41 +02001224 JE_SYNC_COMPARE_AND_SWAP_CHECK(32, 4)
1225 JE_SYNC_COMPARE_AND_SWAP_CHECK(64, 8)
1226fi
1227
1228dnl ============================================================================
Jason Evans893a0ed2011-03-18 19:30:18 -07001229dnl Check for spinlock(3) operations as provided on Darwin.
1230
1231JE_COMPILABLE([Darwin OSSpin*()], [
1232#include <libkern/OSAtomic.h>
1233#include <inttypes.h>
1234], [
1235 OSSpinLock lock = 0;
1236 OSSpinLockLock(&lock);
1237 OSSpinLockUnlock(&lock);
Jason Evans6684cac2012-03-05 12:15:36 -08001238], [je_cv_osspin])
1239if test "x${je_cv_osspin}" = "xyes" ; then
Jason Evanse24c7af2012-03-19 10:21:17 -07001240 AC_DEFINE([JEMALLOC_OSSPIN], [ ])
Jason Evans893a0ed2011-03-18 19:30:18 -07001241fi
1242
1243dnl ============================================================================
Jason Evans2dbecf12010-09-05 10:35:13 -07001244dnl Darwin-related configuration.
Jason Evans78d815c2010-01-17 14:06:20 -08001245
Mike Hommeyd0357f72012-11-26 18:52:41 +01001246AC_ARG_ENABLE([zone-allocator],
1247 [AS_HELP_STRING([--disable-zone-allocator],
1248 [Disable zone allocator for Darwin])],
1249[if test "x$enable_zone_allocator" = "xno" ; then
1250 enable_zone_allocator="0"
1251else
1252 enable_zone_allocator="1"
1253fi
1254],
1255[if test "x${abi}" = "xmacho"; then
1256 enable_zone_allocator="1"
1257fi
1258]
1259)
1260AC_SUBST([enable_zone_allocator])
1261
1262if test "x${enable_zone_allocator}" = "x1" ; then
1263 if test "x${abi}" != "xmacho"; then
1264 AC_MSG_ERROR([--enable-zone-allocator is only supported on Darwin])
1265 fi
Jason Evanse24c7af2012-03-19 10:21:17 -07001266 AC_DEFINE([JEMALLOC_IVSALLOC], [ ])
1267 AC_DEFINE([JEMALLOC_ZONE], [ ])
Jason Evans6109fe02010-02-10 10:37:56 -08001268
Jason Evans2dbecf12010-09-05 10:35:13 -07001269 dnl The szone version jumped from 3 to 6 between the OS X 10.5.x and 10.6
1270 dnl releases. malloc_zone_t and malloc_introspection_t have new fields in
1271 dnl 10.6, which is the only source-level indication of the change.
1272 AC_MSG_CHECKING([malloc zone version])
Mike Hommey154829d2012-03-20 18:01:38 +01001273 AC_DEFUN([JE_ZONE_PROGRAM],
1274 [AC_LANG_PROGRAM(
1275 [#include <malloc/malloc.h>],
1276 [static foo[[sizeof($1) $2 sizeof(void *) * $3 ? 1 : -1]]]
1277 )])
Jason Evans2dbecf12010-09-05 10:35:13 -07001278
Mike Hommey154829d2012-03-20 18:01:38 +01001279 AC_COMPILE_IFELSE([JE_ZONE_PROGRAM(malloc_zone_t,==,14)],[JEMALLOC_ZONE_VERSION=3],[
1280 AC_COMPILE_IFELSE([JE_ZONE_PROGRAM(malloc_zone_t,==,15)],[JEMALLOC_ZONE_VERSION=5],[
1281 AC_COMPILE_IFELSE([JE_ZONE_PROGRAM(malloc_zone_t,==,16)],[
1282 AC_COMPILE_IFELSE([JE_ZONE_PROGRAM(malloc_introspection_t,==,9)],[JEMALLOC_ZONE_VERSION=6],[
1283 AC_COMPILE_IFELSE([JE_ZONE_PROGRAM(malloc_introspection_t,==,13)],[JEMALLOC_ZONE_VERSION=7],[JEMALLOC_ZONE_VERSION=]
1284 )])],[
1285 AC_COMPILE_IFELSE([JE_ZONE_PROGRAM(malloc_zone_t,==,17)],[JEMALLOC_ZONE_VERSION=8],[
1286 AC_COMPILE_IFELSE([JE_ZONE_PROGRAM(malloc_zone_t,>,17)],[JEMALLOC_ZONE_VERSION=9],[JEMALLOC_ZONE_VERSION=]
1287 )])])])])
1288 if test "x${JEMALLOC_ZONE_VERSION}" = "x"; then
1289 AC_MSG_RESULT([unsupported])
1290 AC_MSG_ERROR([Unsupported malloc zone version])
1291 fi
1292 if test "${JEMALLOC_ZONE_VERSION}" = 9; then
1293 JEMALLOC_ZONE_VERSION=8
1294 AC_MSG_RESULT([> 8])
1295 else
1296 AC_MSG_RESULT([$JEMALLOC_ZONE_VERSION])
1297 fi
1298 AC_DEFINE_UNQUOTED(JEMALLOC_ZONE_VERSION, [$JEMALLOC_ZONE_VERSION])
Jason Evansb27805b2010-02-10 18:15:53 -08001299fi
1300
Jason Evansb7924f52009-06-23 19:01:18 -07001301dnl ============================================================================
1302dnl Check for typedefs, structures, and compiler characteristics.
1303AC_HEADER_STDBOOL
1304
Jason Evans748dfac2013-12-06 18:27:33 -08001305dnl ============================================================================
1306dnl Define commands that generate output files.
1307
Jason Evans86abd0d2013-11-30 15:25:42 -08001308AC_CONFIG_COMMANDS([include/jemalloc/internal/private_namespace.h], [
1309 mkdir -p "${objroot}include/jemalloc/internal"
1310 "${srcdir}/include/jemalloc/internal/private_namespace.sh" "${srcdir}/include/jemalloc/internal/private_symbols.txt" > "${objroot}include/jemalloc/internal/private_namespace.h"
Jason Evansf234dc52014-01-16 17:38:01 -08001311], [
1312 srcdir="${srcdir}"
1313 objroot="${objroot}"
Jason Evans86abd0d2013-11-30 15:25:42 -08001314])
1315AC_CONFIG_COMMANDS([include/jemalloc/internal/private_unnamespace.h], [
1316 mkdir -p "${objroot}include/jemalloc/internal"
1317 "${srcdir}/include/jemalloc/internal/private_unnamespace.sh" "${srcdir}/include/jemalloc/internal/private_symbols.txt" > "${objroot}include/jemalloc/internal/private_unnamespace.h"
Jason Evansf234dc52014-01-16 17:38:01 -08001318], [
1319 srcdir="${srcdir}"
1320 objroot="${objroot}"
1321])
1322AC_CONFIG_COMMANDS([include/jemalloc/internal/public_symbols.txt], [
1323 f="${objroot}include/jemalloc/internal/public_symbols.txt"
1324 mkdir -p "${objroot}include/jemalloc/internal"
1325 cp /dev/null "${f}"
1326 for nm in `echo ${mangling_map} |tr ',' ' '` ; do
1327 n=`echo ${nm} |tr ':' ' ' |awk '{print $[]1}'`
1328 m=`echo ${nm} |tr ':' ' ' |awk '{print $[]2}'`
1329 echo "${n}:${m}" >> "${f}"
1330 dnl Remove name from public_syms so that it isn't redefined later.
1331 public_syms=`for sym in ${public_syms}; do echo "${sym}"; done |grep -v "^${n}\$" |tr '\n' ' '`
1332 done
1333 for sym in ${public_syms} ; do
1334 n="${sym}"
1335 m="${JEMALLOC_PREFIX}${sym}"
1336 echo "${n}:${m}" >> "${f}"
1337 done
1338], [
1339 srcdir="${srcdir}"
1340 objroot="${objroot}"
1341 mangling_map="${mangling_map}"
1342 public_syms="${public_syms}"
1343 JEMALLOC_PREFIX="${JEMALLOC_PREFIX}"
Jason Evans86abd0d2013-11-30 15:25:42 -08001344])
1345AC_CONFIG_COMMANDS([include/jemalloc/internal/public_namespace.h], [
1346 mkdir -p "${objroot}include/jemalloc/internal"
Jason Evansf234dc52014-01-16 17:38:01 -08001347 "${srcdir}/include/jemalloc/internal/public_namespace.sh" "${objroot}include/jemalloc/internal/public_symbols.txt" > "${objroot}include/jemalloc/internal/public_namespace.h"
1348], [
1349 srcdir="${srcdir}"
1350 objroot="${objroot}"
Jason Evans86abd0d2013-11-30 15:25:42 -08001351])
1352AC_CONFIG_COMMANDS([include/jemalloc/internal/public_unnamespace.h], [
1353 mkdir -p "${objroot}include/jemalloc/internal"
Jason Evansf234dc52014-01-16 17:38:01 -08001354 "${srcdir}/include/jemalloc/internal/public_unnamespace.sh" "${objroot}include/jemalloc/internal/public_symbols.txt" > "${objroot}include/jemalloc/internal/public_unnamespace.h"
1355], [
1356 srcdir="${srcdir}"
1357 objroot="${objroot}"
Jason Evans86abd0d2013-11-30 15:25:42 -08001358])
Jason Evansb1726102012-02-28 16:50:47 -08001359AC_CONFIG_COMMANDS([include/jemalloc/internal/size_classes.h], [
Jason Evans86abd0d2013-11-30 15:25:42 -08001360 mkdir -p "${objroot}include/jemalloc/internal"
Jason Evansb1726102012-02-28 16:50:47 -08001361 "${srcdir}/include/jemalloc/internal/size_classes.sh" > "${objroot}include/jemalloc/internal/size_classes.h"
Jason Evansf234dc52014-01-16 17:38:01 -08001362], [
1363 srcdir="${srcdir}"
1364 objroot="${objroot}"
Jason Evansb1726102012-02-28 16:50:47 -08001365])
Jason Evans86abd0d2013-11-30 15:25:42 -08001366AC_CONFIG_COMMANDS([include/jemalloc/jemalloc_protos_jet.h], [
1367 mkdir -p "${objroot}include/jemalloc"
1368 cat "${srcdir}/include/jemalloc/jemalloc_protos.h.in" | sed -e 's/@je_@/jet_/g' > "${objroot}include/jemalloc/jemalloc_protos_jet.h"
Jason Evansf234dc52014-01-16 17:38:01 -08001369], [
1370 srcdir="${srcdir}"
1371 objroot="${objroot}"
1372])
1373AC_CONFIG_COMMANDS([include/jemalloc/jemalloc_rename.h], [
1374 mkdir -p "${objroot}include/jemalloc"
1375 "${srcdir}/include/jemalloc/jemalloc_rename.sh" "${objroot}include/jemalloc/internal/public_symbols.txt" > "${objroot}include/jemalloc/jemalloc_rename.h"
1376], [
1377 srcdir="${srcdir}"
1378 objroot="${objroot}"
1379])
1380AC_CONFIG_COMMANDS([include/jemalloc/jemalloc_mangle.h], [
1381 mkdir -p "${objroot}include/jemalloc"
1382 "${srcdir}/include/jemalloc/jemalloc_mangle.sh" "${objroot}include/jemalloc/internal/public_symbols.txt" je_ > "${objroot}include/jemalloc/jemalloc_mangle.h"
1383], [
1384 srcdir="${srcdir}"
1385 objroot="${objroot}"
1386])
1387AC_CONFIG_COMMANDS([include/jemalloc/jemalloc_mangle_jet.h], [
1388 mkdir -p "${objroot}include/jemalloc"
1389 "${srcdir}/include/jemalloc/jemalloc_mangle.sh" "${objroot}include/jemalloc/internal/public_symbols.txt" jet_ > "${objroot}include/jemalloc/jemalloc_mangle_jet.h"
1390], [
1391 srcdir="${srcdir}"
1392 objroot="${objroot}"
Jason Evans86abd0d2013-11-30 15:25:42 -08001393])
1394AC_CONFIG_COMMANDS([include/jemalloc/jemalloc.h], [
1395 mkdir -p "${objroot}include/jemalloc"
1396 "${srcdir}/include/jemalloc/jemalloc.sh" "${objroot}" > "${objroot}include/jemalloc/jemalloc${install_suffix}.h"
Jason Evansf234dc52014-01-16 17:38:01 -08001397], [
1398 srcdir="${srcdir}"
1399 objroot="${objroot}"
1400 install_suffix="${install_suffix}"
Jason Evans86abd0d2013-11-30 15:25:42 -08001401])
Jason Evansb1726102012-02-28 16:50:47 -08001402
Jason Evansb7924f52009-06-23 19:01:18 -07001403dnl Process .in files.
Jason Evansb0fd5012010-01-17 01:49:20 -08001404AC_SUBST([cfghdrs_in])
1405AC_SUBST([cfghdrs_out])
Jason Evans0656ec02010-04-07 23:37:35 -07001406AC_CONFIG_HEADERS([$cfghdrs_tup])
Jason Evansb7924f52009-06-23 19:01:18 -07001407
1408dnl ============================================================================
1409dnl Generate outputs.
Jason Evans748dfac2013-12-06 18:27:33 -08001410
Antony Dovgal2bd3cbc2011-10-13 09:33:33 +04001411AC_CONFIG_FILES([$cfgoutputs_tup config.stamp bin/jemalloc.sh])
Jason Evansb0fd5012010-01-17 01:49:20 -08001412AC_SUBST([cfgoutputs_in])
1413AC_SUBST([cfgoutputs_out])
Jason Evansb7924f52009-06-23 19:01:18 -07001414AC_OUTPUT
1415
1416dnl ============================================================================
1417dnl Print out the results of configuration.
1418AC_MSG_RESULT([===============================================================================])
Jason Evansf576c632011-11-01 22:27:41 -07001419AC_MSG_RESULT([jemalloc version : ${jemalloc_version}])
1420AC_MSG_RESULT([library revision : ${rev}])
Jason Evansb7924f52009-06-23 19:01:18 -07001421AC_MSG_RESULT([])
1422AC_MSG_RESULT([CC : ${CC}])
1423AC_MSG_RESULT([CPPFLAGS : ${CPPFLAGS}])
1424AC_MSG_RESULT([CFLAGS : ${CFLAGS}])
1425AC_MSG_RESULT([LDFLAGS : ${LDFLAGS}])
Jason Evans748dfac2013-12-06 18:27:33 -08001426AC_MSG_RESULT([EXTRA_LDFLAGS : ${EXTRA_LDFLAGS}])
Jason Evansb7924f52009-06-23 19:01:18 -07001427AC_MSG_RESULT([LIBS : ${LIBS}])
1428AC_MSG_RESULT([RPATH_EXTRA : ${RPATH_EXTRA}])
1429AC_MSG_RESULT([])
Jason Evansaee7fd22010-11-24 22:00:02 -08001430AC_MSG_RESULT([XSLTPROC : ${XSLTPROC}])
1431AC_MSG_RESULT([XSLROOT : ${XSLROOT}])
1432AC_MSG_RESULT([])
Jason Evansb7924f52009-06-23 19:01:18 -07001433AC_MSG_RESULT([PREFIX : ${PREFIX}])
1434AC_MSG_RESULT([BINDIR : ${BINDIR}])
Jason Evans662a0172009-07-01 19:24:31 -07001435AC_MSG_RESULT([INCLUDEDIR : ${INCLUDEDIR}])
1436AC_MSG_RESULT([LIBDIR : ${LIBDIR}])
Jason Evansb7924f52009-06-23 19:01:18 -07001437AC_MSG_RESULT([DATADIR : ${DATADIR}])
1438AC_MSG_RESULT([MANDIR : ${MANDIR}])
1439AC_MSG_RESULT([])
1440AC_MSG_RESULT([srcroot : ${srcroot}])
1441AC_MSG_RESULT([abs_srcroot : ${abs_srcroot}])
1442AC_MSG_RESULT([objroot : ${objroot}])
1443AC_MSG_RESULT([abs_objroot : ${abs_objroot}])
1444AC_MSG_RESULT([])
Jason Evans90895cf2009-12-29 00:09:15 -08001445AC_MSG_RESULT([JEMALLOC_PREFIX : ${JEMALLOC_PREFIX}])
Jason Evans746e77a2011-07-30 16:40:52 -07001446AC_MSG_RESULT([JEMALLOC_PRIVATE_NAMESPACE])
1447AC_MSG_RESULT([ : ${JEMALLOC_PRIVATE_NAMESPACE}])
Jason Evansb0fd5012010-01-17 01:49:20 -08001448AC_MSG_RESULT([install_suffix : ${install_suffix}])
Jason Evansb7924f52009-06-23 19:01:18 -07001449AC_MSG_RESULT([autogen : ${enable_autogen}])
Jason Evans355b4382010-09-20 19:20:48 -07001450AC_MSG_RESULT([cc-silence : ${enable_cc_silence}])
Jason Evansb7924f52009-06-23 19:01:18 -07001451AC_MSG_RESULT([debug : ${enable_debug}])
Jason Evans748dfac2013-12-06 18:27:33 -08001452AC_MSG_RESULT([code-coverage : ${enable_code_coverage}])
Jason Evansb7924f52009-06-23 19:01:18 -07001453AC_MSG_RESULT([stats : ${enable_stats}])
Jason Evans6109fe02010-02-10 10:37:56 -08001454AC_MSG_RESULT([prof : ${enable_prof}])
1455AC_MSG_RESULT([prof-libunwind : ${enable_prof_libunwind}])
Jason Evans77f350b2011-03-15 22:23:12 -07001456AC_MSG_RESULT([prof-libgcc : ${enable_prof_libgcc}])
1457AC_MSG_RESULT([prof-gcc : ${enable_prof_gcc}])
Jason Evans84cbbcb2009-12-29 00:09:15 -08001458AC_MSG_RESULT([tcache : ${enable_tcache}])
Jason Evansb7924f52009-06-23 19:01:18 -07001459AC_MSG_RESULT([fill : ${enable_fill}])
Jason Evansb1476112012-04-05 13:36:17 -07001460AC_MSG_RESULT([utrace : ${enable_utrace}])
Jason Evans122449b2012-04-06 00:35:09 -07001461AC_MSG_RESULT([valgrind : ${enable_valgrind}])
1462AC_MSG_RESULT([xmalloc : ${enable_xmalloc}])
Jason Evans2e671ff2012-05-09 16:12:00 -07001463AC_MSG_RESULT([mremap : ${enable_mremap}])
Jason Evans59ae2762012-04-16 17:52:27 -07001464AC_MSG_RESULT([munmap : ${enable_munmap}])
Jason Evansb7924f52009-06-23 19:01:18 -07001465AC_MSG_RESULT([dss : ${enable_dss}])
Jason Evansb7924f52009-06-23 19:01:18 -07001466AC_MSG_RESULT([lazy_lock : ${enable_lazy_lock}])
Jason Evans2dbecf12010-09-05 10:35:13 -07001467AC_MSG_RESULT([tls : ${enable_tls}])
Jason Evansb7924f52009-06-23 19:01:18 -07001468AC_MSG_RESULT([===============================================================================])