dnl Process this file with autoconf to produce a configure script.

AC_PREREQ(2.63)

AC_INIT([Makefile.in])

AC_CONFIG_AUX_DIR([build-aux])

dnl ============================================================================

dnl Custom macro definitions.

dnl JE_CONCAT_VVV(r, a, b)

dnl

dnl Set $r to the concatenation of $a and $b, with a space separating them iff

dnl both $a and $b are non-empty.

AC_DEFUN([JE_CONCAT_VVV],

if test "x[$]{$2}" = "x" -o "x[$]{$3}" = "x" ; then

  $1="[$]{$2}[$]{$3}"

else

  $1="[$]{$2} [$]{$3}"

fi

)

dnl JE_APPEND_VS(a, b)

dnl

dnl Set $a to the concatenation of $a and b, with a space separating them iff

dnl both $a and b are non-empty.

AC_DEFUN([JE_APPEND_VS],

  T_APPEND_V=$2

  JE_CONCAT_VVV($1, $1, T_APPEND_V)

)

CONFIGURE_CFLAGS=

SPECIFIED_CFLAGS="${CFLAGS}"

dnl JE_CFLAGS_ADD(cflag)

dnl

dnl CFLAGS is the concatenation of CONFIGURE_CFLAGS and SPECIFIED_CFLAGS

dnl (ignoring EXTRA_CFLAGS, which does not impact configure tests.  This macro

dnl appends to CONFIGURE_CFLAGS and regenerates CFLAGS.

AC_DEFUN([JE_CFLAGS_ADD],

[

AC_MSG_CHECKING([whether compiler supports $1])

T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"

JE_APPEND_VS(CONFIGURE_CFLAGS, $1)

JE_CONCAT_VVV(CFLAGS, CONFIGURE_CFLAGS, SPECIFIED_CFLAGS)

AC_COMPILE_IFELSE([AC_LANG_PROGRAM(

[[

]], [[

    return 0;

]])],

              [je_cv_cflags_added=$1]

              AC_MSG_RESULT([yes]),

              [je_cv_cflags_added=]

              AC_MSG_RESULT([no])

              [CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"]

)

JE_CONCAT_VVV(CFLAGS, CONFIGURE_CFLAGS, SPECIFIED_CFLAGS)

])

dnl JE_CFLAGS_SAVE()

dnl JE_CFLAGS_RESTORE()

dnl

dnl Save/restore CFLAGS.  Nesting is not supported.

AC_DEFUN([JE_CFLAGS_SAVE],

SAVED_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"

)

AC_DEFUN([JE_CFLAGS_RESTORE],

CONFIGURE_CFLAGS="${SAVED_CONFIGURE_CFLAGS}"

JE_CONCAT_VVV(CFLAGS, CONFIGURE_CFLAGS, SPECIFIED_CFLAGS)

)

CONFIGURE_CXXFLAGS=

SPECIFIED_CXXFLAGS="${CXXFLAGS}"

dnl JE_CXXFLAGS_ADD(cxxflag)

AC_DEFUN([JE_CXXFLAGS_ADD],

[

AC_MSG_CHECKING([whether compiler supports $1])

T_CONFIGURE_CXXFLAGS="${CONFIGURE_CXXFLAGS}"

JE_APPEND_VS(CONFIGURE_CXXFLAGS, $1)

JE_CONCAT_VVV(CXXFLAGS, CONFIGURE_CXXFLAGS, SPECIFIED_CXXFLAGS)

AC_LANG_PUSH([C++])

AC_COMPILE_IFELSE([AC_LANG_PROGRAM(

[[

]], [[

    return 0;

]])],

              [je_cv_cxxflags_added=$1]

              AC_MSG_RESULT([yes]),

              [je_cv_cxxflags_added=]

              AC_MSG_RESULT([no])

              [CONFIGURE_CXXFLAGS="${T_CONFIGURE_CXXFLAGS}"]

)

AC_LANG_POP([C++])

JE_CONCAT_VVV(CXXFLAGS, CONFIGURE_CXXFLAGS, SPECIFIED_CXXFLAGS)

])

dnl JE_COMPILABLE(label, hcode, mcode, rvar)

dnl

dnl Use AC_LINK_IFELSE() rather than AC_COMPILE_IFELSE() so that linker errors

dnl cause failure.

AC_DEFUN([JE_COMPILABLE],

[

AC_CACHE_CHECK([whether $1 is compilable],

               [$4],

               [AC_LINK_IFELSE([AC_LANG_PROGRAM([$2],

                                                [$3])],

                               [$4=yes],

                               [$4=no])])

])

dnl ============================================================================

CONFIG=`echo ${ac_configure_args} | sed -e 's#'"'"'\([^ ]*\)'"'"'#\1#g'`

AC_SUBST([CONFIG])

dnl Library revision.

rev=2

AC_SUBST([rev])

srcroot=$srcdir

if test "x${srcroot}" = "x." ; then

  srcroot=""

else

  srcroot="${srcroot}/"

fi

AC_SUBST([srcroot])

abs_srcroot="`cd \"${srcdir}\"; pwd`/"

AC_SUBST([abs_srcroot])

objroot=""

AC_SUBST([objroot])

abs_objroot="`pwd`/"

AC_SUBST([abs_objroot])

dnl Munge install path variables.

if test "x$prefix" = "xNONE" ; then

  prefix="/usr/local"

fi

if test "x$exec_prefix" = "xNONE" ; then

  exec_prefix=$prefix

fi

PREFIX=$prefix

AC_SUBST([PREFIX])

BINDIR=`eval echo $bindir`

BINDIR=`eval echo $BINDIR`

AC_SUBST([BINDIR])

INCLUDEDIR=`eval echo $includedir`

INCLUDEDIR=`eval echo $INCLUDEDIR`

AC_SUBST([INCLUDEDIR])

LIBDIR=`eval echo $libdir`

LIBDIR=`eval echo $LIBDIR`

AC_SUBST([LIBDIR])

DATADIR=`eval echo $datadir`

DATADIR=`eval echo $DATADIR`

AC_SUBST([DATADIR])

MANDIR=`eval echo $mandir`

MANDIR=`eval echo $MANDIR`

AC_SUBST([MANDIR])

dnl Support for building documentation.

AC_PATH_PROG([XSLTPROC], [xsltproc], [false], [$PATH])

if test -d "/usr/share/xml/docbook/stylesheet/docbook-xsl" ; then

  DEFAULT_XSLROOT="/usr/share/xml/docbook/stylesheet/docbook-xsl"

elif test -d "/usr/share/sgml/docbook/xsl-stylesheets" ; then

  DEFAULT_XSLROOT="/usr/share/sgml/docbook/xsl-stylesheets"

else

  dnl Documentation building will fail if this default gets used.

  DEFAULT_XSLROOT=""

fi

AC_ARG_WITH([xslroot],

  [AS_HELP_STRING([--with-xslroot=<path>], [XSL stylesheet root path])], [

if test "x$with_xslroot" = "xno" ; then

  XSLROOT="${DEFAULT_XSLROOT}"

else

  XSLROOT="${with_xslroot}"

fi

],

  XSLROOT="${DEFAULT_XSLROOT}"

)

if test "x$XSLTPROC" = "xfalse" ; then

  XSLROOT=""

fi

AC_SUBST([XSLROOT])

dnl If CFLAGS isn't defined, set CFLAGS to something reasonable.  Otherwise,

dnl just prevent autoconf from molesting CFLAGS.

CFLAGS=$CFLAGS

AC_PROG_CC

if test "x$GCC" != "xyes" ; then

  AC_CACHE_CHECK([whether compiler is MSVC],

                 [je_cv_msvc],

                 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],

                                                     [

#ifndef _MSC_VER

  int fail[-1];

#endif

])],

                               [je_cv_msvc=yes],

                               [je_cv_msvc=no])])

fi

dnl check if a cray prgenv wrapper compiler is being used

je_cv_cray_prgenv_wrapper=""

if test "x${PE_ENV}" != "x" ; then

  case "${CC}" in

    CC|cc)

	je_cv_cray_prgenv_wrapper="yes"

	;;

    *)

       ;;

  esac

fi

AC_CACHE_CHECK([whether compiler is cray],

              [je_cv_cray],

              [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],

                                                  [

#ifndef _CRAYC

  int fail[-1];

#endif

])],

                            [je_cv_cray=yes],

                            [je_cv_cray=no])])

if test "x${je_cv_cray}" = "xyes" ; then

  AC_CACHE_CHECK([whether cray compiler version is 8.4],

                [je_cv_cray_84],

                [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],

                                                      [

#if !(_RELEASE_MAJOR == 8 && _RELEASE_MINOR == 4)

  int fail[-1];

#endif

])],

                              [je_cv_cray_84=yes],

                              [je_cv_cray_84=no])])

fi

if test "x$GCC" = "xyes" ; then

  JE_CFLAGS_ADD([-std=gnu11])

  if test "x$je_cv_cflags_added" = "x-std=gnu11" ; then

    AC_DEFINE_UNQUOTED([JEMALLOC_HAS_RESTRICT])

  else

    JE_CFLAGS_ADD([-std=gnu99])

    if test "x$je_cv_cflags_added" = "x-std=gnu99" ; then

      AC_DEFINE_UNQUOTED([JEMALLOC_HAS_RESTRICT])

    fi

  fi

  JE_CFLAGS_ADD([-Wall])

  JE_CFLAGS_ADD([-Wextra])

  JE_CFLAGS_ADD([-Wshorten-64-to-32])

  JE_CFLAGS_ADD([-Wsign-compare])

  JE_CFLAGS_ADD([-Wundef])

  JE_CFLAGS_ADD([-Wno-format-zero-length])

  JE_CFLAGS_ADD([-pipe])

  JE_CFLAGS_ADD([-g3])

elif test "x$je_cv_msvc" = "xyes" ; then

  CC="$CC -nologo"

  JE_CFLAGS_ADD([-Zi])

  JE_CFLAGS_ADD([-MT])

  JE_CFLAGS_ADD([-W3])

  JE_CFLAGS_ADD([-FS])

  JE_APPEND_VS(CPPFLAGS, -I${srcdir}/include/msvc_compat)

fi

if test "x$je_cv_cray" = "xyes" ; then

  dnl cray compiler 8.4 has an inlining bug

  if test "x$je_cv_cray_84" = "xyes" ; then

    JE_CFLAGS_ADD([-hipa2])

    JE_CFLAGS_ADD([-hnognu])

  fi

  dnl ignore unreachable code warning

  JE_CFLAGS_ADD([-hnomessage=128])

  dnl ignore redefinition of "malloc", "free", etc warning

  JE_CFLAGS_ADD([-hnomessage=1357])

fi

AC_SUBST([CONFIGURE_CFLAGS])

AC_SUBST([SPECIFIED_CFLAGS])

AC_SUBST([EXTRA_CFLAGS])

AC_PROG_CPP

AC_ARG_ENABLE([cxx],

  [AS_HELP_STRING([--disable-cxx], [Disable C++ integration])],

if test "x$enable_cxx" = "xno" ; then

  enable_cxx="0"

else

  enable_cxx="1"

fi

,

enable_cxx="1"

)

if test "x$enable_cxx" = "x1" ; then

  dnl Require at least c++14, which is the first version to support sized

  dnl deallocation.  C++ support is not compiled otherwise.

  m4_include([m4/ax_cxx_compile_stdcxx.m4])

  AX_CXX_COMPILE_STDCXX([14], [noext], [optional])

  if test "x${HAVE_CXX14}" = "x1" ; then

    JE_CXXFLAGS_ADD([-Wall])

    JE_CXXFLAGS_ADD([-Wextra])

    JE_CXXFLAGS_ADD([-g3])

    SAVED_LIBS="${LIBS}"

    JE_APPEND_VS(LIBS, -lstdc++)

    JE_COMPILABLE([libstdc++ linkage], [

#include <stdlib.h>

], [[

	int *arr = (int *)malloc(sizeof(int) * 42);

	if (arr == NULL)

		return 1;

]], [je_cv_libstdcxx])

    if test "x${je_cv_libstdcxx}" = "xno" ; then

      LIBS="${SAVED_LIBS}"

    fi

  else

    enable_cxx="0"

  fi

fi

AC_SUBST([enable_cxx])

AC_SUBST([CONFIGURE_CXXFLAGS])

AC_SUBST([SPECIFIED_CXXFLAGS])

AC_SUBST([EXTRA_CXXFLAGS])

AC_C_BIGENDIAN([ac_cv_big_endian=1], [ac_cv_big_endian=0])

if test "x${ac_cv_big_endian}" = "x1" ; then

  AC_DEFINE_UNQUOTED([JEMALLOC_BIG_ENDIAN], [ ])

fi

if test "x${je_cv_msvc}" = "xyes" -a "x${ac_cv_header_inttypes_h}" = "xno"; then

  JE_APPEND_VS(CPPFLAGS, -I${srcdir}/include/msvc_compat/C99)

fi

if test "x${je_cv_msvc}" = "xyes" ; then

  LG_SIZEOF_PTR=LG_SIZEOF_PTR_WIN

  AC_MSG_RESULT([Using a predefined value for sizeof(void *): 4 for 32-bit, 8 for 64-bit])

else

  AC_CHECK_SIZEOF([void *])

  if test "x${ac_cv_sizeof_void_p}" = "x8" ; then

    LG_SIZEOF_PTR=3

  elif test "x${ac_cv_sizeof_void_p}" = "x4" ; then

    LG_SIZEOF_PTR=2

  else

    AC_MSG_ERROR([Unsupported pointer size: ${ac_cv_sizeof_void_p}])

  fi

fi

AC_DEFINE_UNQUOTED([LG_SIZEOF_PTR], [$LG_SIZEOF_PTR])

AC_CHECK_SIZEOF([int])

if test "x${ac_cv_sizeof_int}" = "x8" ; then

  LG_SIZEOF_INT=3

elif test "x${ac_cv_sizeof_int}" = "x4" ; then

  LG_SIZEOF_INT=2

else

  AC_MSG_ERROR([Unsupported int size: ${ac_cv_sizeof_int}])

fi

AC_DEFINE_UNQUOTED([LG_SIZEOF_INT], [$LG_SIZEOF_INT])

AC_CHECK_SIZEOF([long])

if test "x${ac_cv_sizeof_long}" = "x8" ; then

  LG_SIZEOF_LONG=3

elif test "x${ac_cv_sizeof_long}" = "x4" ; then

  LG_SIZEOF_LONG=2

else

  AC_MSG_ERROR([Unsupported long size: ${ac_cv_sizeof_long}])

fi

AC_DEFINE_UNQUOTED([LG_SIZEOF_LONG], [$LG_SIZEOF_LONG])

AC_CHECK_SIZEOF([long long])

if test "x${ac_cv_sizeof_long_long}" = "x8" ; then

  LG_SIZEOF_LONG_LONG=3

elif test "x${ac_cv_sizeof_long_long}" = "x4" ; then

  LG_SIZEOF_LONG_LONG=2

else

  AC_MSG_ERROR([Unsupported long long size: ${ac_cv_sizeof_long_long}])

fi

AC_DEFINE_UNQUOTED([LG_SIZEOF_LONG_LONG], [$LG_SIZEOF_LONG_LONG])

AC_CHECK_SIZEOF([intmax_t])

if test "x${ac_cv_sizeof_intmax_t}" = "x16" ; then

  LG_SIZEOF_INTMAX_T=4

elif test "x${ac_cv_sizeof_intmax_t}" = "x8" ; then

  LG_SIZEOF_INTMAX_T=3

elif test "x${ac_cv_sizeof_intmax_t}" = "x4" ; then

  LG_SIZEOF_INTMAX_T=2

else

  AC_MSG_ERROR([Unsupported intmax_t size: ${ac_cv_sizeof_intmax_t}])

fi

AC_DEFINE_UNQUOTED([LG_SIZEOF_INTMAX_T], [$LG_SIZEOF_INTMAX_T])

AC_CANONICAL_HOST

dnl CPU-specific settings.

CPU_SPINWAIT=""

case "${host_cpu}" in

  i686|x86_64)

	HAVE_CPU_SPINWAIT=1

	if test "x${je_cv_msvc}" = "xyes" ; then

	    AC_CACHE_VAL([je_cv_pause_msvc],

	      [JE_COMPILABLE([pause instruction MSVC], [],

					[[_mm_pause(); return 0;]],

					[je_cv_pause_msvc])])

	    if test "x${je_cv_pause_msvc}" = "xyes" ; then

		CPU_SPINWAIT='_mm_pause()'

	    fi

	else

	    AC_CACHE_VAL([je_cv_pause],

	      [JE_COMPILABLE([pause instruction], [],

					[[__asm__ volatile("pause"); return 0;]],

					[je_cv_pause])])

	    if test "x${je_cv_pause}" = "xyes" ; then

		CPU_SPINWAIT='__asm__ volatile("pause")'

	    fi

	fi

	;;

  *)

	HAVE_CPU_SPINWAIT=0

	;;

esac

AC_DEFINE_UNQUOTED([HAVE_CPU_SPINWAIT], [$HAVE_CPU_SPINWAIT])

AC_DEFINE_UNQUOTED([CPU_SPINWAIT], [$CPU_SPINWAIT])

AC_ARG_WITH([lg_vaddr],

  [AS_HELP_STRING([--with-lg-vaddr=<lg-vaddr>], [Number of significant virtual address bits])],

  [LG_VADDR="$with_lg_vaddr"], [LG_VADDR="detect"])

case "${host_cpu}" in

  aarch64)

    if test "x$LG_VADDR" = "xdetect"; then

      AC_MSG_CHECKING([number of significant virtual address bits])

      if test "x${LG_SIZEOF_PTR}" = "x2" ; then

        #aarch64 ILP32

        LG_VADDR=32

      else

        #aarch64 LP64

        LG_VADDR=48

      fi

      AC_MSG_RESULT([$LG_VADDR])

    fi

    ;;

  x86_64)

    if test "x$LG_VADDR" = "xdetect"; then

      AC_CACHE_CHECK([number of significant virtual address bits],

                     [je_cv_lg_vaddr],

                     AC_RUN_IFELSE([AC_LANG_PROGRAM(

[[

#include <stdio.h>

#ifdef _WIN32

#include <limits.h>

#include <intrin.h>

typedef unsigned __int32 uint32_t;

#else

#include <stdint.h>

#endif

]], [[

	uint32_t r[[4]];

	uint32_t eax_in = 0x80000008U;

#ifdef _WIN32

	__cpuid((int *)r, (int)eax_in);

#else

	asm volatile ("cpuid"

	    : "=a" (r[[0]]), "=b" (r[[1]]), "=c" (r[[2]]), "=d" (r[[3]])

	    : "a" (eax_in), "c" (0)

	);

#endif

	uint32_t eax_out = r[[0]];

	uint32_t vaddr = ((eax_out & 0x0000ff00U) >> 8);

	FILE *f = fopen("conftest.out", "w");

	if (f == NULL) {

		return 1;

	}

	if (vaddr > (sizeof(void *) << 3)) {

		vaddr = sizeof(void *) << 3;

	}

	fprintf(f, "%u", vaddr);

	fclose(f);

	return 0;

]])],

                   [je_cv_lg_vaddr=`cat conftest.out`],

                   [je_cv_lg_vaddr=error],

                   [je_cv_lg_vaddr=57]))

      if test "x${je_cv_lg_vaddr}" != "x" ; then

        LG_VADDR="${je_cv_lg_vaddr}"

      fi

      if test "x${LG_VADDR}" != "xerror" ; then

        AC_DEFINE_UNQUOTED([LG_VADDR], [$LG_VADDR])

      else

        AC_MSG_ERROR([cannot determine number of significant virtual address bits])

      fi

    fi

    ;;

  *)

    if test "x$LG_VADDR" = "xdetect"; then

      AC_MSG_CHECKING([number of significant virtual address bits])

      if test "x${LG_SIZEOF_PTR}" = "x3" ; then

        LG_VADDR=64

      elif test "x${LG_SIZEOF_PTR}" = "x2" ; then

        LG_VADDR=32

      elif test "x${LG_SIZEOF_PTR}" = "xLG_SIZEOF_PTR_WIN" ; then

        LG_VADDR="(1U << (LG_SIZEOF_PTR_WIN+3))"

      else

        AC_MSG_ERROR([Unsupported lg(pointer size): ${LG_SIZEOF_PTR}])

      fi

      AC_MSG_RESULT([$LG_VADDR])

    fi

    ;;

esac

AC_DEFINE_UNQUOTED([LG_VADDR], [$LG_VADDR])

LD_PRELOAD_VAR="LD_PRELOAD"

so="so"

importlib="${so}"

o="$ac_objext"

a="a"

exe="$ac_exeext"

libprefix="lib"

link_whole_archive="0"

DSO_LDFLAGS='-shared -Wl,-soname,$(@F)'

RPATH='-Wl,-rpath,$(1)'

SOREV="${so}.${rev}"

PIC_CFLAGS='-fPIC -DPIC'

CTARGET='-o $@'

LDTARGET='-o $@'

TEST_LD_MODE=

EXTRA_LDFLAGS=

ARFLAGS='crus'

AROUT=' $@'

CC_MM=1

if test "x$je_cv_cray_prgenv_wrapper" = "xyes" ; then

  TEST_LD_MODE='-dynamic'

fi

if test "x${je_cv_cray}" = "xyes" ; then

  CC_MM=

fi

AN_MAKEVAR([AR], [AC_PROG_AR])

AN_PROGRAM([ar], [AC_PROG_AR])

AC_DEFUN([AC_PROG_AR], [AC_CHECK_TOOL(AR, ar, :)])

AC_PROG_AR

AN_MAKEVAR([NM], [AC_PROG_NM])

AN_PROGRAM([nm], [AC_PROG_NM])

AC_DEFUN([AC_PROG_NM], [AC_CHECK_TOOL(NM, nm, :)])

AC_PROG_NM

AC_PROG_AWK

dnl ============================================================================

dnl jemalloc version.

dnl

AC_ARG_WITH([version],

  [AS_HELP_STRING([--with-version=<major>.<minor>.<bugfix>-<nrev>-g<gid>],

   [Version string])],

  [

    echo "${with_version}" | grep ['^[0-9]\+\.[0-9]\+\.[0-9]\+-[0-9]\+-g[0-9a-f]\+$'] 2>&1 1>/dev/null

    if test $? -eq 0 ; then

      echo "$with_version" > "${objroot}VERSION"

    else

      echo "${with_version}" | grep ['^VERSION$'] 2>&1 1>/dev/null

      if test $? -ne 0 ; then

        AC_MSG_ERROR([${with_version} does not match <major>.<minor>.<bugfix>-<nrev>-g<gid> or VERSION])

      fi

    fi

  ], [

    dnl Set VERSION if source directory is inside a git repository.

    if test "x`test ! \"${srcroot}\" && cd \"${srcroot}\"; git rev-parse --is-inside-work-tree 2>/dev/null`" = "xtrue" ; then

      dnl Pattern globs aren't powerful enough to match both single- and

      dnl double-digit version numbers, so iterate over patterns to support up

      dnl to version 99.99.99 without any accidental matches.

      for pattern in ['[0-9].[0-9].[0-9]' '[0-9].[0-9].[0-9][0-9]' \

                     '[0-9].[0-9][0-9].[0-9]' '[0-9].[0-9][0-9].[0-9][0-9]' \

                     '[0-9][0-9].[0-9].[0-9]' '[0-9][0-9].[0-9].[0-9][0-9]' \

                     '[0-9][0-9].[0-9][0-9].[0-9]' \

                     '[0-9][0-9].[0-9][0-9].[0-9][0-9]']; do

        (test ! "${srcroot}" && cd "${srcroot}"; git describe --long --abbrev=40 --match="${pattern}") > "${objroot}VERSION.tmp" 2>/dev/null

        if test $? -eq 0 ; then

          mv "${objroot}VERSION.tmp" "${objroot}VERSION"

          break

        fi

      done

    fi

    rm -f "${objroot}VERSION.tmp"

  ])

if test ! -e "${objroot}VERSION" ; then

  if test ! -e "${srcroot}VERSION" ; then

    AC_MSG_RESULT(

      [Missing VERSION file, and unable to generate it; creating bogus VERSION])

    echo "0.0.0-0-g0000000000000000000000000000000000000000" > "${objroot}VERSION"

  else

    cp ${srcroot}VERSION ${objroot}VERSION

  fi

fi

jemalloc_version=`cat "${objroot}VERSION"`

jemalloc_version_major=`echo ${jemalloc_version} | tr ".g-" " " | awk '{print [$]1}'`

jemalloc_version_minor=`echo ${jemalloc_version} | tr ".g-" " " | awk '{print [$]2}'`

jemalloc_version_bugfix=`echo ${jemalloc_version} | tr ".g-" " " | awk '{print [$]3}'`

jemalloc_version_nrev=`echo ${jemalloc_version} | tr ".g-" " " | awk '{print [$]4}'`

jemalloc_version_gid=`echo ${jemalloc_version} | tr ".g-" " " | awk '{print [$]5}'`

AC_SUBST([jemalloc_version])

AC_SUBST([jemalloc_version_major])

AC_SUBST([jemalloc_version_minor])

AC_SUBST([jemalloc_version_bugfix])

AC_SUBST([jemalloc_version_nrev])

AC_SUBST([jemalloc_version_gid])

dnl Platform-specific settings.  abi and RPATH can probably be determined

dnl programmatically, but doing so is error-prone, which makes it generally

dnl not worth the trouble.

dnl

dnl Define cpp macros in CPPFLAGS, rather than doing AC_DEFINE(macro), since the

dnl definitions need to be seen before any headers are included, which is a pain

dnl to make happen otherwise.

default_retain="0"

maps_coalesce="1"

DUMP_SYMS="${NM} -a"

SYM_PREFIX=""

case "${host}" in

  *-*-darwin* | *-*-ios*)

	abi="macho"

	RPATH=""

	LD_PRELOAD_VAR="DYLD_INSERT_LIBRARIES"

	so="dylib"

	importlib="${so}"

	force_tls="0"

	DSO_LDFLAGS='-shared -Wl,-install_name,$(LIBDIR)/$(@F)'

	SOREV="${rev}.${so}"

	sbrk_deprecated="1"

	SYM_PREFIX="_"

	;;

  *-*-freebsd*)

	abi="elf"

	AC_DEFINE([JEMALLOC_SYSCTL_VM_OVERCOMMIT], [ ])

	force_lazy_lock="1"

	;;

  *-*-dragonfly*)

	abi="elf"

	;;

  *-*-openbsd*)

	abi="elf"

	force_tls="0"

	;;

  *-*-bitrig*)

	abi="elf"

	;;

  *-*-linux-android)

	dnl syscall(2) and secure_getenv(3) are exposed by _GNU_SOURCE.

	JE_APPEND_VS(CPPFLAGS, -D_GNU_SOURCE)

	abi="elf"

	AC_DEFINE([JEMALLOC_PURGE_MADVISE_DONTNEED_ZEROS], [ ])

	AC_DEFINE([JEMALLOC_HAS_ALLOCA_H])

	AC_DEFINE([JEMALLOC_PROC_SYS_VM_OVERCOMMIT_MEMORY], [ ])

	AC_DEFINE([JEMALLOC_THREADED_INIT], [ ])

	AC_DEFINE([JEMALLOC_C11_ATOMICS])

	force_tls="0"

	if test "${LG_SIZEOF_PTR}" = "3"; then

	  default_retain="1"

	fi

	;;

  *-*-linux*)

	dnl syscall(2) and secure_getenv(3) are exposed by _GNU_SOURCE.

	JE_APPEND_VS(CPPFLAGS, -D_GNU_SOURCE)

	abi="elf"

	AC_DEFINE([JEMALLOC_PURGE_MADVISE_DONTNEED_ZEROS], [ ])

	AC_DEFINE([JEMALLOC_HAS_ALLOCA_H])

	AC_DEFINE([JEMALLOC_PROC_SYS_VM_OVERCOMMIT_MEMORY], [ ])

	AC_DEFINE([JEMALLOC_THREADED_INIT], [ ])

	AC_DEFINE([JEMALLOC_USE_CXX_THROW], [ ])

	if test "${LG_SIZEOF_PTR}" = "3"; then

	  default_retain="1"

	fi

	;;

  *-*-kfreebsd*)

	dnl syscall(2) and secure_getenv(3) are exposed by _GNU_SOURCE.

	JE_APPEND_VS(CPPFLAGS, -D_GNU_SOURCE)

	abi="elf"

	AC_DEFINE([JEMALLOC_HAS_ALLOCA_H])

	AC_DEFINE([JEMALLOC_SYSCTL_VM_OVERCOMMIT], [ ])

	AC_DEFINE([JEMALLOC_THREADED_INIT], [ ])

	AC_DEFINE([JEMALLOC_USE_CXX_THROW], [ ])

	;;

  *-*-netbsd*)

	AC_MSG_CHECKING([ABI])

        AC_COMPILE_IFELSE([AC_LANG_PROGRAM(

[[#ifdef __ELF__

/* ELF */

#else

#error aout

#endif

]])],

                          [abi="elf"],

                          [abi="aout"])

	AC_MSG_RESULT([$abi])

	;;

  *-*-solaris2*)

	abi="elf"

	RPATH='-Wl,-R,$(1)'

	dnl Solaris needs this for sigwait().

	JE_APPEND_VS(CPPFLAGS, -D_POSIX_PTHREAD_SEMANTICS)

	JE_APPEND_VS(LIBS, -lposix4 -lsocket -lnsl)

	;;

  *-ibm-aix*)

	if test "${LG_SIZEOF_PTR}" = "3"; then

	  dnl 64bit AIX

	  LD_PRELOAD_VAR="LDR_PRELOAD64"

	else

	  dnl 32bit AIX

	  LD_PRELOAD_VAR="LDR_PRELOAD"

	fi

	abi="xcoff"

	;;

  *-*-mingw* | *-*-cygwin*)

	abi="pecoff"

	force_tls="0"

	maps_coalesce="0"

	RPATH=""

	so="dll"

	if test "x$je_cv_msvc" = "xyes" ; then

	  importlib="lib"

	  DSO_LDFLAGS="-LD"

	  EXTRA_LDFLAGS="-link -DEBUG"

	  CTARGET='-Fo$@'

	  LDTARGET='-Fe$@'

	  AR='lib'

	  ARFLAGS='-nologo -out:'

	  AROUT='$@'

	  CC_MM=

        else

	  importlib="${so}"

	  DSO_LDFLAGS="-shared"

	  link_whole_archive="1"

	fi

	case "${host}" in

	  *-*-cygwin*)

	    DUMP_SYMS="dumpbin /SYMBOLS"

	    ;;

	  *)

	    ;;

	esac

	a="lib"

	libprefix=""

	SOREV="${so}"

	PIC_CFLAGS=""

	if test "${LG_SIZEOF_PTR}" = "3"; then

	  default_retain="1"

	fi

	;;

  *)

	AC_MSG_RESULT([Unsupported operating system: ${host}])

	abi="elf"

	;;

esac

JEMALLOC_USABLE_SIZE_CONST=const

AC_CHECK_HEADERS([malloc.h], [

  AC_MSG_CHECKING([whether malloc_usable_size definition can use const argument])

  AC_COMPILE_IFELSE([AC_LANG_PROGRAM(

    [#include <malloc.h>

     #include <stddef.h>

    size_t malloc_usable_size(const void *ptr);

    ],

    [])],[

                AC_MSG_RESULT([yes])

         ],[

                JEMALLOC_USABLE_SIZE_CONST=

                AC_MSG_RESULT([no])

         ])

])

AC_DEFINE_UNQUOTED([JEMALLOC_USABLE_SIZE_CONST], [$JEMALLOC_USABLE_SIZE_CONST])

AC_SUBST([abi])

AC_SUBST([RPATH])

AC_SUBST([LD_PRELOAD_VAR])

AC_SUBST([so])

AC_SUBST([importlib])

AC_SUBST([o])

AC_SUBST([a])

AC_SUBST([exe])

AC_SUBST([libprefix])

AC_SUBST([link_whole_archive])

AC_SUBST([DSO_LDFLAGS])

AC_SUBST([EXTRA_LDFLAGS])

AC_SUBST([SOREV])

AC_SUBST([PIC_CFLAGS])

AC_SUBST([CTARGET])

AC_SUBST([LDTARGET])

AC_SUBST([TEST_LD_MODE])

AC_SUBST([MKLIB])

AC_SUBST([ARFLAGS])

AC_SUBST([AROUT])

AC_SUBST([DUMP_SYMS])

AC_SUBST([CC_MM])

dnl Determine whether libm must be linked to use e.g. log(3).

AC_SEARCH_LIBS([log], [m], , [AC_MSG_ERROR([Missing math functions])])

if test "x$ac_cv_search_log" != "xnone required" ; then

  LM="$ac_cv_search_log"

else

  LM=

fi

AC_SUBST(LM)

JE_COMPILABLE([__attribute__ syntax],

              [static __attribute__((unused)) void foo(void){}],

              [],

              [je_cv_attribute])

if test "x${je_cv_attribute}" = "xyes" ; then

  AC_DEFINE([JEMALLOC_HAVE_ATTR], [ ])

  if test "x${GCC}" = "xyes" -a "x${abi}" = "xelf"; then

    JE_CFLAGS_ADD([-fvisibility=hidden])

    JE_CXXFLAGS_ADD([-fvisibility=hidden])

  fi

fi

dnl Check for tls_model attribute support (clang 3.0 still lacks support).

JE_CFLAGS_SAVE()

JE_CFLAGS_ADD([-Werror])

JE_CFLAGS_ADD([-herror_on_warning])

JE_COMPILABLE([tls_model attribute], [],

              [static __thread int

               __attribute__((tls_model("initial-exec"), unused)) foo;

               foo = 0;],

              [je_cv_tls_model])

JE_CFLAGS_RESTORE()

dnl (Setting of JEMALLOC_TLS_MODEL is done later, after we've checked for

dnl --disable-initial-exec-tls)

dnl Check for alloc_size attribute support.

JE_CFLAGS_SAVE()

JE_CFLAGS_ADD([-Werror])

JE_CFLAGS_ADD([-herror_on_warning])

JE_COMPILABLE([alloc_size attribute], [#include <stdlib.h>],

              [void *foo(size_t size) __attribute__((alloc_size(1)));],

              [je_cv_alloc_size])

JE_CFLAGS_RESTORE()

if test "x${je_cv_alloc_size}" = "xyes" ; then

  AC_DEFINE([JEMALLOC_HAVE_ATTR_ALLOC_SIZE], [ ])

fi

dnl Check for format(gnu_printf, ...) attribute support.

JE_CFLAGS_SAVE()

JE_CFLAGS_ADD([-Werror])

JE_CFLAGS_ADD([-herror_on_warning])

JE_COMPILABLE([format(gnu_printf, ...) attribute], [#include <stdlib.h>],

              [void *foo(const char *format, ...) __attribute__((format(gnu_printf, 1, 2)));],

              [je_cv_format_gnu_printf])

JE_CFLAGS_RESTORE()

if test "x${je_cv_format_gnu_printf}" = "xyes" ; then

  AC_DEFINE([JEMALLOC_HAVE_ATTR_FORMAT_GNU_PRINTF], [ ])

fi

dnl Check for format(printf, ...) attribute support.

JE_CFLAGS_SAVE()

JE_CFLAGS_ADD([-Werror])

JE_CFLAGS_ADD([-herror_on_warning])

JE_COMPILABLE([format(printf, ...) attribute], [#include <stdlib.h>],

              [void *foo(const char *format, ...) __attribute__((format(printf, 1, 2)));],

              [je_cv_format_printf])

JE_CFLAGS_RESTORE()

if test "x${je_cv_format_printf}" = "xyes" ; then

  AC_DEFINE([JEMALLOC_HAVE_ATTR_FORMAT_PRINTF], [ ])

fi

dnl Check for format_arg(...) attribute support.

JE_CFLAGS_SAVE()

JE_CFLAGS_ADD([-Werror])

JE_CFLAGS_ADD([-herror_on_warning])

JE_COMPILABLE([format(printf, ...) attribute], [#include <stdlib.h>],

              [const char * __attribute__((__format_arg__(1))) foo(const char *format);],

              [je_cv_format_arg])

JE_CFLAGS_RESTORE()

if test "x${je_cv_format_arg}" = "xyes" ; then

  AC_DEFINE([JEMALLOC_HAVE_ATTR_FORMAT_ARG], [ ])

fi

dnl Support optional additions to rpath.

AC_ARG_WITH([rpath],

  [AS_HELP_STRING([--with-rpath=<rpath>], [Colon-separated rpath (ELF systems only)])],

if test "x$with_rpath" = "xno" ; then

  RPATH_EXTRA=

else

  RPATH_EXTRA="`echo $with_rpath | tr \":\" \" \"`"

fi,

  RPATH_EXTRA=

)

AC_SUBST([RPATH_EXTRA])