Diff
Not logged in

Differences From Artifact [cf02446f5d]:

To Artifact [8355caf3a7]:


   622    622   ac_subst_vars='LTLIBOBJS
   623    623   LIBOBJS
   624    624   cfgoutputs_out
   625    625   cfgoutputs_in
   626    626   cfghdrs_out
   627    627   cfghdrs_in
   628    628   enable_zone_allocator
          629  +enable_thp
   629    630   enable_tls
   630    631   enable_lazy_lock
   631         -TESTLIBS
   632    632   jemalloc_version_gid
   633    633   jemalloc_version_nrev
   634    634   jemalloc_version_bugfix
   635    635   jemalloc_version_minor
   636    636   jemalloc_version_major
   637    637   jemalloc_version
   638    638   enable_cache_oblivious
................................................................................
   654    654   LD
   655    655   RANLIB
   656    656   INSTALL_DATA
   657    657   INSTALL_SCRIPT
   658    658   INSTALL_PROGRAM
   659    659   enable_autogen
   660    660   RPATH_EXTRA
          661  +LM
   661    662   CC_MM
   662    663   AROUT
   663    664   ARFLAGS
   664    665   MKLIB
          666  +TEST_LD_MODE
   665    667   LDTARGET
   666    668   CTARGET
   667    669   PIC_CFLAGS
   668    670   SOREV
   669    671   EXTRA_LDFLAGS
   670    672   DSO_LDFLAGS
          673  +link_whole_archive
   671    674   libprefix
   672    675   exe
   673    676   a
   674    677   o
   675    678   importlib
   676    679   so
   677    680   LD_PRELOAD_VAR
................................................................................
   685    688   build_os
   686    689   build_vendor
   687    690   build_cpu
   688    691   build
   689    692   EGREP
   690    693   GREP
   691    694   CPP
          695  +EXTRA_CFLAGS
          696  +SPECIFIED_CFLAGS
          697  +CONFIGURE_CFLAGS
   692    698   OBJEXT
   693    699   EXEEXT
   694    700   ac_ct_CC
   695    701   CPPFLAGS
   696    702   LDFLAGS
   697    703   CFLAGS
   698    704   CC
................................................................................
   725    731   pdfdir
   726    732   dvidir
   727    733   htmldir
   728    734   infodir
   729    735   docdir
   730    736   oldincludedir
   731    737   includedir
          738  +runstatedir
   732    739   localstatedir
   733    740   sharedstatedir
   734    741   sysconfdir
   735    742   datadir
   736    743   datarootdir
   737    744   libexecdir
   738    745   sbindir
................................................................................
   778    785   enable_xmalloc
   779    786   enable_cache_oblivious
   780    787   with_lg_tiny_min
   781    788   with_lg_quantum
   782    789   with_lg_page
   783    790   with_lg_page_sizes
   784    791   with_lg_size_class_group
          792  +with_version
          793  +enable_syscall
   785    794   enable_lazy_lock
   786    795   enable_tls
          796  +enable_thp
   787    797   enable_zone_allocator
   788    798   '
   789    799         ac_precious_vars='build_alias
   790    800   host_alias
   791    801   target_alias
   792    802   CC
   793    803   CFLAGS
................................................................................
   829    839   sbindir='${exec_prefix}/sbin'
   830    840   libexecdir='${exec_prefix}/libexec'
   831    841   datarootdir='${prefix}/share'
   832    842   datadir='${datarootdir}'
   833    843   sysconfdir='${prefix}/etc'
   834    844   sharedstatedir='${prefix}/com'
   835    845   localstatedir='${prefix}/var'
          846  +runstatedir='${localstatedir}/run'
   836    847   includedir='${prefix}/include'
   837    848   oldincludedir='/usr/include'
   838    849   docdir='${datarootdir}/doc/${PACKAGE}'
   839    850   infodir='${datarootdir}/info'
   840    851   htmldir='${docdir}'
   841    852   dvidir='${docdir}'
   842    853   pdfdir='${docdir}'
................................................................................
  1080   1091       ac_prev=psdir ;;
  1081   1092     -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
  1082   1093       psdir=$ac_optarg ;;
  1083   1094   
  1084   1095     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
  1085   1096     | -silent | --silent | --silen | --sile | --sil)
  1086   1097       silent=yes ;;
         1098  +
         1099  +  -runstatedir | --runstatedir | --runstatedi | --runstated \
         1100  +  | --runstate | --runstat | --runsta | --runst | --runs \
         1101  +  | --run | --ru | --r)
         1102  +    ac_prev=runstatedir ;;
         1103  +  -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
         1104  +  | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
         1105  +  | --run=* | --ru=* | --r=*)
         1106  +    runstatedir=$ac_optarg ;;
  1087   1107   
  1088   1108     -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
  1089   1109       ac_prev=sbindir ;;
  1090   1110     -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
  1091   1111     | --sbi=* | --sb=*)
  1092   1112       sbindir=$ac_optarg ;;
  1093   1113   
................................................................................
  1218   1238     esac
  1219   1239   fi
  1220   1240   
  1221   1241   # Check all directory arguments for consistency.
  1222   1242   for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
  1223   1243   		datadir sysconfdir sharedstatedir localstatedir includedir \
  1224   1244   		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
  1225         -		libdir localedir mandir
         1245  +		libdir localedir mandir runstatedir
  1226   1246   do
  1227   1247     eval ac_val=\$$ac_var
  1228   1248     # Remove trailing slashes.
  1229   1249     case $ac_val in
  1230   1250       */ )
  1231   1251         ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
  1232   1252         eval $ac_var=\$ac_val;;
................................................................................
  1371   1391   Fine tuning of the installation directories:
  1372   1392     --bindir=DIR            user executables [EPREFIX/bin]
  1373   1393     --sbindir=DIR           system admin executables [EPREFIX/sbin]
  1374   1394     --libexecdir=DIR        program executables [EPREFIX/libexec]
  1375   1395     --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
  1376   1396     --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
  1377   1397     --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
         1398  +  --runstatedir=DIR       modifiable per-process data [LOCALSTATEDIR/run]
  1378   1399     --libdir=DIR            object code libraries [EPREFIX/lib]
  1379   1400     --includedir=DIR        C header files [PREFIX/include]
  1380   1401     --oldincludedir=DIR     C header files for non-gcc [/usr/include]
  1381   1402     --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
  1382   1403     --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
  1383   1404     --infodir=DIR           info documentation [DATAROOTDIR/info]
  1384   1405     --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
................................................................................
  1422   1443                             and redzones
  1423   1444     --enable-utrace         Enable utrace(2)-based tracing
  1424   1445     --disable-valgrind      Disable support for Valgrind
  1425   1446     --enable-xmalloc        Support xmalloc option
  1426   1447     --disable-cache-oblivious
  1427   1448                             Disable support for cache-oblivious allocation
  1428   1449                             alignment
         1450  +  --disable-syscall       Disable use of syscall(2)
  1429   1451     --enable-lazy-lock      Enable lazy locking (only lock when multi-threaded)
  1430   1452     --disable-tls           Disable thread-local storage (__thread keyword)
         1453  +  --disable-thp           Disable transparent huge page supprot
  1431   1454     --disable-zone-allocator
  1432   1455                             Disable zone allocator for Darwin
  1433   1456   
  1434   1457   Optional Packages:
  1435   1458     --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
  1436   1459     --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
  1437   1460     --with-xslroot=<path>   XSL stylesheet root path
................................................................................
  1455   1478                             Base 2 log of minimum allocation alignment
  1456   1479     --with-lg-page=<lg-page>
  1457   1480                             Base 2 log of system page size
  1458   1481     --with-lg-page-sizes=<lg-page-sizes>
  1459   1482                             Base 2 logs of system page sizes to support
  1460   1483     --with-lg-size-class-group=<lg-size-class-group>
  1461   1484                             Base 2 log of size classes per doubling
         1485  +  --with-version=<major>.<minor>.<bugfix>-<nrev>-g<gid>
         1486  +                          Version string
  1462   1487   
  1463   1488   Some influential environment variables:
  1464   1489     CC          C compiler command
  1465   1490     CFLAGS      C compiler flags
  1466   1491     LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
  1467   1492                 nonstandard directory <lib dir>
  1468   1493     LIBS        libraries to pass to the linker, e.g. -l<library>
................................................................................
  2518   2543   
  2519   2544   
  2520   2545   
  2521   2546   
  2522   2547   
  2523   2548   
  2524   2549   
         2550  +CONFIGURE_CFLAGS=
         2551  +SPECIFIED_CFLAGS="${CFLAGS}"
         2552  +
         2553  +
         2554  +
         2555  +
         2556  +
         2557  +
         2558  +
  2525   2559   
  2526   2560   CONFIG=`echo ${ac_configure_args} | sed -e 's#'"'"'\([^ ]*\)'"'"'#\1#g'`
  2527   2561   
  2528   2562   
  2529   2563   rev=2
  2530   2564   
  2531   2565   
................................................................................
  3418   3452   fi
  3419   3453   
  3420   3454   ac_ext=c
  3421   3455   ac_cpp='$CPP $CPPFLAGS'
  3422   3456   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
  3423   3457   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
  3424   3458   ac_compiler_gnu=$ac_cv_c_compiler_gnu
         3459  +
  3425   3460   
  3426   3461   if test "x$GCC" != "xyes" ; then
  3427   3462   
  3428   3463   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler is MSVC" >&5
  3429   3464   $as_echo_n "checking whether compiler is MSVC... " >&6; }
  3430   3465   if ${je_cv_msvc+:} false; then :
  3431   3466     $as_echo_n "(cached) " >&6
................................................................................
  3452   3487   fi
  3453   3488   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  3454   3489   fi
  3455   3490   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $je_cv_msvc" >&5
  3456   3491   $as_echo "$je_cv_msvc" >&6; }
  3457   3492   fi
  3458   3493   
  3459         -if test "x$CFLAGS" = "x" ; then
  3460         -  no_CFLAGS="yes"
  3461         -  if test "x$GCC" = "xyes" ; then
         3494  +je_cv_cray_prgenv_wrapper=""
         3495  +if test "x${PE_ENV}" != "x" ; then
         3496  +  case "${CC}" in
         3497  +    CC|cc)
         3498  +	je_cv_cray_prgenv_wrapper="yes"
         3499  +	;;
         3500  +    *)
         3501  +       ;;
         3502  +  esac
         3503  +fi
         3504  +
         3505  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler is cray" >&5
         3506  +$as_echo_n "checking whether compiler is cray... " >&6; }
         3507  +if ${je_cv_cray+:} false; then :
         3508  +  $as_echo_n "(cached) " >&6
         3509  +else
         3510  +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         3511  +/* end confdefs.h.  */
         3512  +
         3513  +int
         3514  +main ()
         3515  +{
         3516  +
         3517  +#ifndef _CRAYC
         3518  +  int fail-1;
         3519  +#endif
         3520  +
         3521  +  ;
         3522  +  return 0;
         3523  +}
         3524  +_ACEOF
         3525  +if ac_fn_c_try_compile "$LINENO"; then :
         3526  +  je_cv_cray=yes
         3527  +else
         3528  +  je_cv_cray=no
         3529  +fi
         3530  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         3531  +fi
         3532  +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $je_cv_cray" >&5
         3533  +$as_echo "$je_cv_cray" >&6; }
         3534  +
         3535  +if test "x${je_cv_cray}" = "xyes" ; then
         3536  +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether cray compiler version is 8.4" >&5
         3537  +$as_echo_n "checking whether cray compiler version is 8.4... " >&6; }
         3538  +if ${je_cv_cray_84+:} false; then :
         3539  +  $as_echo_n "(cached) " >&6
         3540  +else
         3541  +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         3542  +/* end confdefs.h.  */
         3543  +
         3544  +int
         3545  +main ()
         3546  +{
         3547  +
         3548  +#if !(_RELEASE_MAJOR == 8 && _RELEASE_MINOR == 4)
         3549  +  int fail-1;
         3550  +#endif
         3551  +
         3552  +  ;
         3553  +  return 0;
         3554  +}
         3555  +_ACEOF
         3556  +if ac_fn_c_try_compile "$LINENO"; then :
         3557  +  je_cv_cray_84=yes
         3558  +else
         3559  +  je_cv_cray_84=no
         3560  +fi
         3561  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         3562  +fi
         3563  +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $je_cv_cray_84" >&5
         3564  +$as_echo "$je_cv_cray_84" >&6; }
         3565  +fi
         3566  +
         3567  +if test "x$GCC" = "xyes" ; then
         3568  +
         3569  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -std=gnu11" >&5
         3570  +$as_echo_n "checking whether compiler supports -std=gnu11... " >&6; }
         3571  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         3572  +T_APPEND_V=-std=gnu11
         3573  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         3574  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         3575  +else
         3576  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         3577  +fi
         3578  +
         3579  +
         3580  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         3581  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         3582  +else
         3583  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         3584  +fi
         3585  +
         3586  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         3587  +/* end confdefs.h.  */
         3588  +
         3589  +
         3590  +int
         3591  +main ()
         3592  +{
         3593  +
         3594  +    return 0;
         3595  +
         3596  +  ;
         3597  +  return 0;
         3598  +}
         3599  +_ACEOF
         3600  +if ac_fn_c_try_compile "$LINENO"; then :
         3601  +  je_cv_cflags_added=-std=gnu11
         3602  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         3603  +$as_echo "yes" >&6; }
         3604  +else
         3605  +  je_cv_cflags_added=
         3606  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         3607  +$as_echo "no" >&6; }
         3608  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         3609  +
         3610  +fi
         3611  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         3612  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         3613  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         3614  +else
         3615  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         3616  +fi
         3617  +
         3618  +
         3619  +  if test "x$je_cv_cflags_added" = "x-std=gnu11" ; then
         3620  +    cat >>confdefs.h <<_ACEOF
         3621  +#define JEMALLOC_HAS_RESTRICT 1
         3622  +_ACEOF
         3623  +
         3624  +  else
  3462   3625   
  3463   3626   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -std=gnu99" >&5
  3464   3627   $as_echo_n "checking whether compiler supports -std=gnu99... " >&6; }
  3465         -TCFLAGS="${CFLAGS}"
  3466         -if test "x${CFLAGS}" = "x" ; then
  3467         -  CFLAGS="-std=gnu99"
  3468         -else
  3469         -  CFLAGS="${CFLAGS} -std=gnu99"
  3470         -fi
  3471         -cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  3472         -/* end confdefs.h.  */
  3473         -
  3474         -
  3475         -int
  3476         -main ()
  3477         -{
  3478         -
  3479         -    return 0;
  3480         -
  3481         -  ;
  3482         -  return 0;
  3483         -}
  3484         -_ACEOF
  3485         -if ac_fn_c_try_compile "$LINENO"; then :
  3486         -  je_cv_cflags_appended=-std=gnu99
  3487         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  3488         -$as_echo "yes" >&6; }
  3489         -else
  3490         -  je_cv_cflags_appended=
  3491         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  3492         -$as_echo "no" >&6; }
  3493         -              CFLAGS="${TCFLAGS}"
  3494         -
  3495         -fi
  3496         -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  3497         -
  3498         -    if test "x$je_cv_cflags_appended" = "x-std=gnu99" ; then
         3628  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         3629  +T_APPEND_V=-std=gnu99
         3630  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         3631  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         3632  +else
         3633  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         3634  +fi
         3635  +
         3636  +
         3637  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         3638  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         3639  +else
         3640  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         3641  +fi
         3642  +
         3643  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         3644  +/* end confdefs.h.  */
         3645  +
         3646  +
         3647  +int
         3648  +main ()
         3649  +{
         3650  +
         3651  +    return 0;
         3652  +
         3653  +  ;
         3654  +  return 0;
         3655  +}
         3656  +_ACEOF
         3657  +if ac_fn_c_try_compile "$LINENO"; then :
         3658  +  je_cv_cflags_added=-std=gnu99
         3659  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         3660  +$as_echo "yes" >&6; }
         3661  +else
         3662  +  je_cv_cflags_added=
         3663  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         3664  +$as_echo "no" >&6; }
         3665  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         3666  +
         3667  +fi
         3668  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         3669  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         3670  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         3671  +else
         3672  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         3673  +fi
         3674  +
         3675  +
         3676  +    if test "x$je_cv_cflags_added" = "x-std=gnu99" ; then
  3499   3677         cat >>confdefs.h <<_ACEOF
  3500   3678   #define JEMALLOC_HAS_RESTRICT 1
  3501   3679   _ACEOF
  3502   3680   
  3503   3681       fi
         3682  +  fi
  3504   3683   
  3505   3684   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Wall" >&5
  3506   3685   $as_echo_n "checking whether compiler supports -Wall... " >&6; }
  3507         -TCFLAGS="${CFLAGS}"
  3508         -if test "x${CFLAGS}" = "x" ; then
  3509         -  CFLAGS="-Wall"
  3510         -else
  3511         -  CFLAGS="${CFLAGS} -Wall"
  3512         -fi
  3513         -cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  3514         -/* end confdefs.h.  */
  3515         -
  3516         -
  3517         -int
  3518         -main ()
  3519         -{
  3520         -
  3521         -    return 0;
  3522         -
  3523         -  ;
  3524         -  return 0;
  3525         -}
  3526         -_ACEOF
  3527         -if ac_fn_c_try_compile "$LINENO"; then :
  3528         -  je_cv_cflags_appended=-Wall
  3529         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  3530         -$as_echo "yes" >&6; }
  3531         -else
  3532         -  je_cv_cflags_appended=
  3533         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  3534         -$as_echo "no" >&6; }
  3535         -              CFLAGS="${TCFLAGS}"
  3536         -
  3537         -fi
  3538         -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         3686  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         3687  +T_APPEND_V=-Wall
         3688  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         3689  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         3690  +else
         3691  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         3692  +fi
         3693  +
         3694  +
         3695  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         3696  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         3697  +else
         3698  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         3699  +fi
         3700  +
         3701  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         3702  +/* end confdefs.h.  */
         3703  +
         3704  +
         3705  +int
         3706  +main ()
         3707  +{
         3708  +
         3709  +    return 0;
         3710  +
         3711  +  ;
         3712  +  return 0;
         3713  +}
         3714  +_ACEOF
         3715  +if ac_fn_c_try_compile "$LINENO"; then :
         3716  +  je_cv_cflags_added=-Wall
         3717  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         3718  +$as_echo "yes" >&6; }
         3719  +else
         3720  +  je_cv_cflags_added=
         3721  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         3722  +$as_echo "no" >&6; }
         3723  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         3724  +
         3725  +fi
         3726  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         3727  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         3728  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         3729  +else
         3730  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         3731  +fi
         3732  +
  3539   3733   
  3540   3734   
  3541   3735   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Werror=declaration-after-statement" >&5
  3542   3736   $as_echo_n "checking whether compiler supports -Werror=declaration-after-statement... " >&6; }
  3543         -TCFLAGS="${CFLAGS}"
  3544         -if test "x${CFLAGS}" = "x" ; then
  3545         -  CFLAGS="-Werror=declaration-after-statement"
  3546         -else
  3547         -  CFLAGS="${CFLAGS} -Werror=declaration-after-statement"
  3548         -fi
  3549         -cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  3550         -/* end confdefs.h.  */
  3551         -
  3552         -
  3553         -int
  3554         -main ()
  3555         -{
  3556         -
  3557         -    return 0;
  3558         -
  3559         -  ;
  3560         -  return 0;
  3561         -}
  3562         -_ACEOF
  3563         -if ac_fn_c_try_compile "$LINENO"; then :
  3564         -  je_cv_cflags_appended=-Werror=declaration-after-statement
  3565         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  3566         -$as_echo "yes" >&6; }
  3567         -else
  3568         -  je_cv_cflags_appended=
  3569         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  3570         -$as_echo "no" >&6; }
  3571         -              CFLAGS="${TCFLAGS}"
  3572         -
  3573         -fi
  3574         -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         3737  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         3738  +T_APPEND_V=-Werror=declaration-after-statement
         3739  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         3740  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         3741  +else
         3742  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         3743  +fi
         3744  +
         3745  +
         3746  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         3747  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         3748  +else
         3749  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         3750  +fi
         3751  +
         3752  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         3753  +/* end confdefs.h.  */
         3754  +
         3755  +
         3756  +int
         3757  +main ()
         3758  +{
         3759  +
         3760  +    return 0;
         3761  +
         3762  +  ;
         3763  +  return 0;
         3764  +}
         3765  +_ACEOF
         3766  +if ac_fn_c_try_compile "$LINENO"; then :
         3767  +  je_cv_cflags_added=-Werror=declaration-after-statement
         3768  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         3769  +$as_echo "yes" >&6; }
         3770  +else
         3771  +  je_cv_cflags_added=
         3772  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         3773  +$as_echo "no" >&6; }
         3774  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         3775  +
         3776  +fi
         3777  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         3778  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         3779  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         3780  +else
         3781  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         3782  +fi
         3783  +
  3575   3784   
  3576   3785   
  3577   3786   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Wshorten-64-to-32" >&5
  3578   3787   $as_echo_n "checking whether compiler supports -Wshorten-64-to-32... " >&6; }
  3579         -TCFLAGS="${CFLAGS}"
  3580         -if test "x${CFLAGS}" = "x" ; then
  3581         -  CFLAGS="-Wshorten-64-to-32"
  3582         -else
  3583         -  CFLAGS="${CFLAGS} -Wshorten-64-to-32"
  3584         -fi
  3585         -cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  3586         -/* end confdefs.h.  */
  3587         -
  3588         -
  3589         -int
  3590         -main ()
  3591         -{
  3592         -
  3593         -    return 0;
  3594         -
  3595         -  ;
  3596         -  return 0;
  3597         -}
  3598         -_ACEOF
  3599         -if ac_fn_c_try_compile "$LINENO"; then :
  3600         -  je_cv_cflags_appended=-Wshorten-64-to-32
  3601         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  3602         -$as_echo "yes" >&6; }
  3603         -else
  3604         -  je_cv_cflags_appended=
  3605         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  3606         -$as_echo "no" >&6; }
  3607         -              CFLAGS="${TCFLAGS}"
  3608         -
  3609         -fi
  3610         -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         3788  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         3789  +T_APPEND_V=-Wshorten-64-to-32
         3790  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         3791  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         3792  +else
         3793  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         3794  +fi
         3795  +
         3796  +
         3797  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         3798  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         3799  +else
         3800  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         3801  +fi
         3802  +
         3803  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         3804  +/* end confdefs.h.  */
         3805  +
         3806  +
         3807  +int
         3808  +main ()
         3809  +{
         3810  +
         3811  +    return 0;
         3812  +
         3813  +  ;
         3814  +  return 0;
         3815  +}
         3816  +_ACEOF
         3817  +if ac_fn_c_try_compile "$LINENO"; then :
         3818  +  je_cv_cflags_added=-Wshorten-64-to-32
         3819  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         3820  +$as_echo "yes" >&6; }
         3821  +else
         3822  +  je_cv_cflags_added=
         3823  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         3824  +$as_echo "no" >&6; }
         3825  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         3826  +
         3827  +fi
         3828  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         3829  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         3830  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         3831  +else
         3832  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         3833  +fi
         3834  +
         3835  +
         3836  +
         3837  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Wsign-compare" >&5
         3838  +$as_echo_n "checking whether compiler supports -Wsign-compare... " >&6; }
         3839  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         3840  +T_APPEND_V=-Wsign-compare
         3841  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         3842  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         3843  +else
         3844  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         3845  +fi
         3846  +
         3847  +
         3848  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         3849  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         3850  +else
         3851  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         3852  +fi
         3853  +
         3854  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         3855  +/* end confdefs.h.  */
         3856  +
         3857  +
         3858  +int
         3859  +main ()
         3860  +{
         3861  +
         3862  +    return 0;
         3863  +
         3864  +  ;
         3865  +  return 0;
         3866  +}
         3867  +_ACEOF
         3868  +if ac_fn_c_try_compile "$LINENO"; then :
         3869  +  je_cv_cflags_added=-Wsign-compare
         3870  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         3871  +$as_echo "yes" >&6; }
         3872  +else
         3873  +  je_cv_cflags_added=
         3874  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         3875  +$as_echo "no" >&6; }
         3876  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         3877  +
         3878  +fi
         3879  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         3880  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         3881  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         3882  +else
         3883  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         3884  +fi
         3885  +
  3611   3886   
  3612   3887   
  3613   3888   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -pipe" >&5
  3614   3889   $as_echo_n "checking whether compiler supports -pipe... " >&6; }
  3615         -TCFLAGS="${CFLAGS}"
  3616         -if test "x${CFLAGS}" = "x" ; then
  3617         -  CFLAGS="-pipe"
  3618         -else
  3619         -  CFLAGS="${CFLAGS} -pipe"
  3620         -fi
  3621         -cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  3622         -/* end confdefs.h.  */
  3623         -
  3624         -
  3625         -int
  3626         -main ()
  3627         -{
  3628         -
  3629         -    return 0;
  3630         -
  3631         -  ;
  3632         -  return 0;
  3633         -}
  3634         -_ACEOF
  3635         -if ac_fn_c_try_compile "$LINENO"; then :
  3636         -  je_cv_cflags_appended=-pipe
  3637         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  3638         -$as_echo "yes" >&6; }
  3639         -else
  3640         -  je_cv_cflags_appended=
  3641         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  3642         -$as_echo "no" >&6; }
  3643         -              CFLAGS="${TCFLAGS}"
  3644         -
  3645         -fi
  3646         -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         3890  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         3891  +T_APPEND_V=-pipe
         3892  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         3893  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         3894  +else
         3895  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         3896  +fi
         3897  +
         3898  +
         3899  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         3900  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         3901  +else
         3902  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         3903  +fi
         3904  +
         3905  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         3906  +/* end confdefs.h.  */
         3907  +
         3908  +
         3909  +int
         3910  +main ()
         3911  +{
         3912  +
         3913  +    return 0;
         3914  +
         3915  +  ;
         3916  +  return 0;
         3917  +}
         3918  +_ACEOF
         3919  +if ac_fn_c_try_compile "$LINENO"; then :
         3920  +  je_cv_cflags_added=-pipe
         3921  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         3922  +$as_echo "yes" >&6; }
         3923  +else
         3924  +  je_cv_cflags_added=
         3925  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         3926  +$as_echo "no" >&6; }
         3927  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         3928  +
         3929  +fi
         3930  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         3931  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         3932  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         3933  +else
         3934  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         3935  +fi
         3936  +
  3647   3937   
  3648   3938   
  3649   3939   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -g3" >&5
  3650   3940   $as_echo_n "checking whether compiler supports -g3... " >&6; }
  3651         -TCFLAGS="${CFLAGS}"
  3652         -if test "x${CFLAGS}" = "x" ; then
  3653         -  CFLAGS="-g3"
  3654         -else
  3655         -  CFLAGS="${CFLAGS} -g3"
  3656         -fi
  3657         -cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  3658         -/* end confdefs.h.  */
  3659         -
  3660         -
  3661         -int
  3662         -main ()
  3663         -{
  3664         -
  3665         -    return 0;
  3666         -
  3667         -  ;
  3668         -  return 0;
  3669         -}
  3670         -_ACEOF
  3671         -if ac_fn_c_try_compile "$LINENO"; then :
  3672         -  je_cv_cflags_appended=-g3
  3673         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  3674         -$as_echo "yes" >&6; }
  3675         -else
  3676         -  je_cv_cflags_appended=
  3677         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  3678         -$as_echo "no" >&6; }
  3679         -              CFLAGS="${TCFLAGS}"
  3680         -
  3681         -fi
  3682         -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  3683         -
  3684         -  elif test "x$je_cv_msvc" = "xyes" ; then
  3685         -    CC="$CC -nologo"
         3941  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         3942  +T_APPEND_V=-g3
         3943  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         3944  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         3945  +else
         3946  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         3947  +fi
         3948  +
         3949  +
         3950  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         3951  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         3952  +else
         3953  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         3954  +fi
         3955  +
         3956  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         3957  +/* end confdefs.h.  */
         3958  +
         3959  +
         3960  +int
         3961  +main ()
         3962  +{
         3963  +
         3964  +    return 0;
         3965  +
         3966  +  ;
         3967  +  return 0;
         3968  +}
         3969  +_ACEOF
         3970  +if ac_fn_c_try_compile "$LINENO"; then :
         3971  +  je_cv_cflags_added=-g3
         3972  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         3973  +$as_echo "yes" >&6; }
         3974  +else
         3975  +  je_cv_cflags_added=
         3976  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         3977  +$as_echo "no" >&6; }
         3978  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         3979  +
         3980  +fi
         3981  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         3982  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         3983  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         3984  +else
         3985  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         3986  +fi
         3987  +
         3988  +
         3989  +elif test "x$je_cv_msvc" = "xyes" ; then
         3990  +  CC="$CC -nologo"
  3686   3991   
  3687   3992   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Zi" >&5
  3688   3993   $as_echo_n "checking whether compiler supports -Zi... " >&6; }
  3689         -TCFLAGS="${CFLAGS}"
  3690         -if test "x${CFLAGS}" = "x" ; then
  3691         -  CFLAGS="-Zi"
  3692         -else
  3693         -  CFLAGS="${CFLAGS} -Zi"
  3694         -fi
  3695         -cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  3696         -/* end confdefs.h.  */
  3697         -
  3698         -
  3699         -int
  3700         -main ()
  3701         -{
  3702         -
  3703         -    return 0;
  3704         -
  3705         -  ;
  3706         -  return 0;
  3707         -}
  3708         -_ACEOF
  3709         -if ac_fn_c_try_compile "$LINENO"; then :
  3710         -  je_cv_cflags_appended=-Zi
  3711         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  3712         -$as_echo "yes" >&6; }
  3713         -else
  3714         -  je_cv_cflags_appended=
  3715         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  3716         -$as_echo "no" >&6; }
  3717         -              CFLAGS="${TCFLAGS}"
  3718         -
  3719         -fi
  3720         -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         3994  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         3995  +T_APPEND_V=-Zi
         3996  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         3997  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         3998  +else
         3999  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         4000  +fi
         4001  +
         4002  +
         4003  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         4004  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         4005  +else
         4006  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         4007  +fi
         4008  +
         4009  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         4010  +/* end confdefs.h.  */
         4011  +
         4012  +
         4013  +int
         4014  +main ()
         4015  +{
         4016  +
         4017  +    return 0;
         4018  +
         4019  +  ;
         4020  +  return 0;
         4021  +}
         4022  +_ACEOF
         4023  +if ac_fn_c_try_compile "$LINENO"; then :
         4024  +  je_cv_cflags_added=-Zi
         4025  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         4026  +$as_echo "yes" >&6; }
         4027  +else
         4028  +  je_cv_cflags_added=
         4029  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         4030  +$as_echo "no" >&6; }
         4031  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         4032  +
         4033  +fi
         4034  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         4035  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         4036  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         4037  +else
         4038  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         4039  +fi
         4040  +
  3721   4041   
  3722   4042   
  3723   4043   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -MT" >&5
  3724   4044   $as_echo_n "checking whether compiler supports -MT... " >&6; }
  3725         -TCFLAGS="${CFLAGS}"
  3726         -if test "x${CFLAGS}" = "x" ; then
  3727         -  CFLAGS="-MT"
  3728         -else
  3729         -  CFLAGS="${CFLAGS} -MT"
  3730         -fi
  3731         -cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  3732         -/* end confdefs.h.  */
  3733         -
  3734         -
  3735         -int
  3736         -main ()
  3737         -{
  3738         -
  3739         -    return 0;
  3740         -
  3741         -  ;
  3742         -  return 0;
  3743         -}
  3744         -_ACEOF
  3745         -if ac_fn_c_try_compile "$LINENO"; then :
  3746         -  je_cv_cflags_appended=-MT
  3747         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  3748         -$as_echo "yes" >&6; }
  3749         -else
  3750         -  je_cv_cflags_appended=
  3751         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  3752         -$as_echo "no" >&6; }
  3753         -              CFLAGS="${TCFLAGS}"
  3754         -
  3755         -fi
  3756         -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         4045  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         4046  +T_APPEND_V=-MT
         4047  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         4048  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         4049  +else
         4050  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         4051  +fi
         4052  +
         4053  +
         4054  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         4055  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         4056  +else
         4057  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         4058  +fi
         4059  +
         4060  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         4061  +/* end confdefs.h.  */
         4062  +
         4063  +
         4064  +int
         4065  +main ()
         4066  +{
         4067  +
         4068  +    return 0;
         4069  +
         4070  +  ;
         4071  +  return 0;
         4072  +}
         4073  +_ACEOF
         4074  +if ac_fn_c_try_compile "$LINENO"; then :
         4075  +  je_cv_cflags_added=-MT
         4076  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         4077  +$as_echo "yes" >&6; }
         4078  +else
         4079  +  je_cv_cflags_added=
         4080  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         4081  +$as_echo "no" >&6; }
         4082  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         4083  +
         4084  +fi
         4085  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         4086  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         4087  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         4088  +else
         4089  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         4090  +fi
         4091  +
  3757   4092   
  3758   4093   
  3759   4094   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -W3" >&5
  3760   4095   $as_echo_n "checking whether compiler supports -W3... " >&6; }
  3761         -TCFLAGS="${CFLAGS}"
  3762         -if test "x${CFLAGS}" = "x" ; then
  3763         -  CFLAGS="-W3"
  3764         -else
  3765         -  CFLAGS="${CFLAGS} -W3"
  3766         -fi
  3767         -cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  3768         -/* end confdefs.h.  */
  3769         -
  3770         -
  3771         -int
  3772         -main ()
  3773         -{
  3774         -
  3775         -    return 0;
  3776         -
  3777         -  ;
  3778         -  return 0;
  3779         -}
  3780         -_ACEOF
  3781         -if ac_fn_c_try_compile "$LINENO"; then :
  3782         -  je_cv_cflags_appended=-W3
  3783         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  3784         -$as_echo "yes" >&6; }
  3785         -else
  3786         -  je_cv_cflags_appended=
  3787         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  3788         -$as_echo "no" >&6; }
  3789         -              CFLAGS="${TCFLAGS}"
  3790         -
  3791         -fi
  3792         -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         4096  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         4097  +T_APPEND_V=-W3
         4098  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         4099  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         4100  +else
         4101  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         4102  +fi
         4103  +
         4104  +
         4105  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         4106  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         4107  +else
         4108  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         4109  +fi
         4110  +
         4111  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         4112  +/* end confdefs.h.  */
         4113  +
         4114  +
         4115  +int
         4116  +main ()
         4117  +{
         4118  +
         4119  +    return 0;
         4120  +
         4121  +  ;
         4122  +  return 0;
         4123  +}
         4124  +_ACEOF
         4125  +if ac_fn_c_try_compile "$LINENO"; then :
         4126  +  je_cv_cflags_added=-W3
         4127  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         4128  +$as_echo "yes" >&6; }
         4129  +else
         4130  +  je_cv_cflags_added=
         4131  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         4132  +$as_echo "no" >&6; }
         4133  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         4134  +
         4135  +fi
         4136  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         4137  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         4138  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         4139  +else
         4140  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         4141  +fi
         4142  +
  3793   4143   
  3794   4144   
  3795   4145   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -FS" >&5
  3796   4146   $as_echo_n "checking whether compiler supports -FS... " >&6; }
  3797         -TCFLAGS="${CFLAGS}"
  3798         -if test "x${CFLAGS}" = "x" ; then
  3799         -  CFLAGS="-FS"
  3800         -else
  3801         -  CFLAGS="${CFLAGS} -FS"
  3802         -fi
  3803         -cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  3804         -/* end confdefs.h.  */
  3805         -
  3806         -
  3807         -int
  3808         -main ()
  3809         -{
  3810         -
  3811         -    return 0;
  3812         -
  3813         -  ;
  3814         -  return 0;
  3815         -}
  3816         -_ACEOF
  3817         -if ac_fn_c_try_compile "$LINENO"; then :
  3818         -  je_cv_cflags_appended=-FS
  3819         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  3820         -$as_echo "yes" >&6; }
  3821         -else
  3822         -  je_cv_cflags_appended=
  3823         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  3824         -$as_echo "no" >&6; }
  3825         -              CFLAGS="${TCFLAGS}"
  3826         -
  3827         -fi
  3828         -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  3829         -
  3830         -    CPPFLAGS="$CPPFLAGS -I${srcdir}/include/msvc_compat"
  3831         -  fi
  3832         -fi
  3833         -if test "x$EXTRA_CFLAGS" != "x" ; then
  3834         -
  3835         -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports $EXTRA_CFLAGS" >&5
  3836         -$as_echo_n "checking whether compiler supports $EXTRA_CFLAGS... " >&6; }
  3837         -TCFLAGS="${CFLAGS}"
  3838         -if test "x${CFLAGS}" = "x" ; then
  3839         -  CFLAGS="$EXTRA_CFLAGS"
  3840         -else
  3841         -  CFLAGS="${CFLAGS} $EXTRA_CFLAGS"
  3842         -fi
  3843         -cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  3844         -/* end confdefs.h.  */
  3845         -
  3846         -
  3847         -int
  3848         -main ()
  3849         -{
  3850         -
  3851         -    return 0;
  3852         -
  3853         -  ;
  3854         -  return 0;
  3855         -}
  3856         -_ACEOF
  3857         -if ac_fn_c_try_compile "$LINENO"; then :
  3858         -  je_cv_cflags_appended=$EXTRA_CFLAGS
  3859         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  3860         -$as_echo "yes" >&6; }
  3861         -else
  3862         -  je_cv_cflags_appended=
  3863         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  3864         -$as_echo "no" >&6; }
  3865         -              CFLAGS="${TCFLAGS}"
  3866         -
  3867         -fi
  3868         -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  3869         -
  3870         -fi
         4147  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         4148  +T_APPEND_V=-FS
         4149  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         4150  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         4151  +else
         4152  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         4153  +fi
         4154  +
         4155  +
         4156  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         4157  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         4158  +else
         4159  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         4160  +fi
         4161  +
         4162  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         4163  +/* end confdefs.h.  */
         4164  +
         4165  +
         4166  +int
         4167  +main ()
         4168  +{
         4169  +
         4170  +    return 0;
         4171  +
         4172  +  ;
         4173  +  return 0;
         4174  +}
         4175  +_ACEOF
         4176  +if ac_fn_c_try_compile "$LINENO"; then :
         4177  +  je_cv_cflags_added=-FS
         4178  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         4179  +$as_echo "yes" >&6; }
         4180  +else
         4181  +  je_cv_cflags_added=
         4182  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         4183  +$as_echo "no" >&6; }
         4184  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         4185  +
         4186  +fi
         4187  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         4188  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         4189  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         4190  +else
         4191  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         4192  +fi
         4193  +
         4194  +
         4195  +  T_APPEND_V=-I${srcdir}/include/msvc_compat
         4196  +  if test "x${CPPFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         4197  +  CPPFLAGS="${CPPFLAGS}${T_APPEND_V}"
         4198  +else
         4199  +  CPPFLAGS="${CPPFLAGS} ${T_APPEND_V}"
         4200  +fi
         4201  +
         4202  +
         4203  +fi
         4204  +if test "x$je_cv_cray" = "xyes" ; then
         4205  +    if test "x$je_cv_cray_84" = "xyes" ; then
         4206  +
         4207  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -hipa2" >&5
         4208  +$as_echo_n "checking whether compiler supports -hipa2... " >&6; }
         4209  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         4210  +T_APPEND_V=-hipa2
         4211  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         4212  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         4213  +else
         4214  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         4215  +fi
         4216  +
         4217  +
         4218  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         4219  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         4220  +else
         4221  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         4222  +fi
         4223  +
         4224  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         4225  +/* end confdefs.h.  */
         4226  +
         4227  +
         4228  +int
         4229  +main ()
         4230  +{
         4231  +
         4232  +    return 0;
         4233  +
         4234  +  ;
         4235  +  return 0;
         4236  +}
         4237  +_ACEOF
         4238  +if ac_fn_c_try_compile "$LINENO"; then :
         4239  +  je_cv_cflags_added=-hipa2
         4240  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         4241  +$as_echo "yes" >&6; }
         4242  +else
         4243  +  je_cv_cflags_added=
         4244  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         4245  +$as_echo "no" >&6; }
         4246  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         4247  +
         4248  +fi
         4249  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         4250  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         4251  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         4252  +else
         4253  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         4254  +fi
         4255  +
         4256  +
         4257  +
         4258  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -hnognu" >&5
         4259  +$as_echo_n "checking whether compiler supports -hnognu... " >&6; }
         4260  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         4261  +T_APPEND_V=-hnognu
         4262  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         4263  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         4264  +else
         4265  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         4266  +fi
         4267  +
         4268  +
         4269  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         4270  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         4271  +else
         4272  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         4273  +fi
         4274  +
         4275  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         4276  +/* end confdefs.h.  */
         4277  +
         4278  +
         4279  +int
         4280  +main ()
         4281  +{
         4282  +
         4283  +    return 0;
         4284  +
         4285  +  ;
         4286  +  return 0;
         4287  +}
         4288  +_ACEOF
         4289  +if ac_fn_c_try_compile "$LINENO"; then :
         4290  +  je_cv_cflags_added=-hnognu
         4291  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         4292  +$as_echo "yes" >&6; }
         4293  +else
         4294  +  je_cv_cflags_added=
         4295  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         4296  +$as_echo "no" >&6; }
         4297  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         4298  +
         4299  +fi
         4300  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         4301  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         4302  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         4303  +else
         4304  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         4305  +fi
         4306  +
         4307  +
         4308  +  fi
         4309  +  if test "x$enable_cc_silence" != "xno" ; then
         4310  +
         4311  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -hnomessage=128" >&5
         4312  +$as_echo_n "checking whether compiler supports -hnomessage=128... " >&6; }
         4313  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         4314  +T_APPEND_V=-hnomessage=128
         4315  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         4316  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         4317  +else
         4318  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         4319  +fi
         4320  +
         4321  +
         4322  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         4323  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         4324  +else
         4325  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         4326  +fi
         4327  +
         4328  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         4329  +/* end confdefs.h.  */
         4330  +
         4331  +
         4332  +int
         4333  +main ()
         4334  +{
         4335  +
         4336  +    return 0;
         4337  +
         4338  +  ;
         4339  +  return 0;
         4340  +}
         4341  +_ACEOF
         4342  +if ac_fn_c_try_compile "$LINENO"; then :
         4343  +  je_cv_cflags_added=-hnomessage=128
         4344  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         4345  +$as_echo "yes" >&6; }
         4346  +else
         4347  +  je_cv_cflags_added=
         4348  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         4349  +$as_echo "no" >&6; }
         4350  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         4351  +
         4352  +fi
         4353  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         4354  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         4355  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         4356  +else
         4357  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         4358  +fi
         4359  +
         4360  +
         4361  +
         4362  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -hnomessage=1357" >&5
         4363  +$as_echo_n "checking whether compiler supports -hnomessage=1357... " >&6; }
         4364  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         4365  +T_APPEND_V=-hnomessage=1357
         4366  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         4367  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         4368  +else
         4369  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         4370  +fi
         4371  +
         4372  +
         4373  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         4374  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         4375  +else
         4376  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         4377  +fi
         4378  +
         4379  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         4380  +/* end confdefs.h.  */
         4381  +
         4382  +
         4383  +int
         4384  +main ()
         4385  +{
         4386  +
         4387  +    return 0;
         4388  +
         4389  +  ;
         4390  +  return 0;
         4391  +}
         4392  +_ACEOF
         4393  +if ac_fn_c_try_compile "$LINENO"; then :
         4394  +  je_cv_cflags_added=-hnomessage=1357
         4395  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         4396  +$as_echo "yes" >&6; }
         4397  +else
         4398  +  je_cv_cflags_added=
         4399  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         4400  +$as_echo "no" >&6; }
         4401  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         4402  +
         4403  +fi
         4404  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         4405  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         4406  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         4407  +else
         4408  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         4409  +fi
         4410  +
         4411  +
         4412  +  fi
         4413  +fi
         4414  +
         4415  +
         4416  +
  3871   4417   ac_ext=c
  3872   4418   ac_cpp='$CPP $CPPFLAGS'
  3873   4419   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
  3874   4420   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
  3875   4421   ac_compiler_gnu=$ac_cv_c_compiler_gnu
  3876   4422   { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
  3877   4423   $as_echo_n "checking how to run the C preprocessor... " >&6; }
................................................................................
  4493   5039     cat >>confdefs.h <<_ACEOF
  4494   5040   #define JEMALLOC_BIG_ENDIAN
  4495   5041   _ACEOF
  4496   5042   
  4497   5043   fi
  4498   5044   
  4499   5045   if test "x${je_cv_msvc}" = "xyes" -a "x${ac_cv_header_inttypes_h}" = "xno"; then
  4500         -  CPPFLAGS="$CPPFLAGS -I${srcdir}/include/msvc_compat/C99"
         5046  +  T_APPEND_V=-I${srcdir}/include/msvc_compat/C99
         5047  +  if test "x${CPPFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         5048  +  CPPFLAGS="${CPPFLAGS}${T_APPEND_V}"
         5049  +else
         5050  +  CPPFLAGS="${CPPFLAGS} ${T_APPEND_V}"
         5051  +fi
         5052  +
         5053  +
  4501   5054   fi
  4502   5055   
  4503   5056   if test "x${je_cv_msvc}" = "xyes" ; then
  4504   5057     LG_SIZEOF_PTR=LG_SIZEOF_PTR_WIN
  4505   5058     { $as_echo "$as_me:${as_lineno-$LINENO}: result: Using a predefined value for sizeof(void *): 4 for 32-bit, 8 for 64-bit" >&5
  4506   5059   $as_echo "Using a predefined value for sizeof(void *): 4 for 32-bit, 8 for 64-bit" >&6; }
  4507   5060   else
................................................................................
  4900   5453   LD_PRELOAD_VAR="LD_PRELOAD"
  4901   5454   so="so"
  4902   5455   importlib="${so}"
  4903   5456   o="$ac_objext"
  4904   5457   a="a"
  4905   5458   exe="$ac_exeext"
  4906   5459   libprefix="lib"
         5460  +link_whole_archive="0"
  4907   5461   DSO_LDFLAGS='-shared -Wl,-soname,$(@F)'
  4908   5462   RPATH='-Wl,-rpath,$(1)'
  4909   5463   SOREV="${so}.${rev}"
  4910   5464   PIC_CFLAGS='-fPIC -DPIC'
  4911   5465   CTARGET='-o $@'
  4912   5466   LDTARGET='-o $@'
         5467  +TEST_LD_MODE=
  4913   5468   EXTRA_LDFLAGS=
  4914   5469   ARFLAGS='crus'
  4915   5470   AROUT=' $@'
  4916   5471   CC_MM=1
         5472  +
         5473  +if test "x$je_cv_cray_prgenv_wrapper" = "xyes" ; then
         5474  +  TEST_LD_MODE='-dynamic'
         5475  +fi
         5476  +
         5477  +if test "x${je_cv_cray}" = "xyes" ; then
         5478  +  CC_MM=
         5479  +fi
  4917   5480   
  4918   5481   
  4919   5482   
  4920   5483   
  4921   5484   if test -n "$ac_tool_prefix"; then
  4922   5485     # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
  4923   5486   set dummy ${ac_tool_prefix}ar; ac_word=$2
................................................................................
  5011   5574   fi
  5012   5575   
  5013   5576   
  5014   5577   default_munmap="1"
  5015   5578   maps_coalesce="1"
  5016   5579   case "${host}" in
  5017   5580     *-*-darwin* | *-*-ios*)
  5018         -	CFLAGS="$CFLAGS"
  5019   5581   	abi="macho"
  5020         -	$as_echo "#define JEMALLOC_PURGE_MADVISE_FREE  " >>confdefs.h
  5021         -
  5022   5582   	RPATH=""
  5023   5583   	LD_PRELOAD_VAR="DYLD_INSERT_LIBRARIES"
  5024   5584   	so="dylib"
  5025   5585   	importlib="${so}"
  5026   5586   	force_tls="0"
  5027   5587   	DSO_LDFLAGS='-shared -Wl,-install_name,$(LIBDIR)/$(@F)'
  5028   5588   	SOREV="${rev}.${so}"
  5029   5589   	sbrk_deprecated="1"
  5030   5590   	;;
  5031   5591     *-*-freebsd*)
  5032         -	CFLAGS="$CFLAGS"
  5033   5592   	abi="elf"
  5034         -	$as_echo "#define JEMALLOC_PURGE_MADVISE_FREE  " >>confdefs.h
         5593  +	$as_echo "#define JEMALLOC_SYSCTL_VM_OVERCOMMIT  " >>confdefs.h
  5035   5594   
  5036   5595   	force_lazy_lock="1"
  5037   5596   	;;
  5038   5597     *-*-dragonfly*)
  5039         -	CFLAGS="$CFLAGS"
  5040   5598   	abi="elf"
  5041         -	$as_echo "#define JEMALLOC_PURGE_MADVISE_FREE  " >>confdefs.h
  5042         -
  5043   5599   	;;
  5044   5600     *-*-openbsd*)
  5045         -	CFLAGS="$CFLAGS"
  5046   5601   	abi="elf"
  5047         -	$as_echo "#define JEMALLOC_PURGE_MADVISE_FREE  " >>confdefs.h
  5048         -
  5049   5602   	force_tls="0"
  5050   5603   	;;
  5051   5604     *-*-bitrig*)
  5052         -	CFLAGS="$CFLAGS"
         5605  +	abi="elf"
         5606  +	;;
         5607  +  *-*-linux-android)
         5608  +		T_APPEND_V=-D_GNU_SOURCE
         5609  +  if test "x${CPPFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         5610  +  CPPFLAGS="${CPPFLAGS}${T_APPEND_V}"
         5611  +else
         5612  +  CPPFLAGS="${CPPFLAGS} ${T_APPEND_V}"
         5613  +fi
         5614  +
         5615  +
  5053   5616   	abi="elf"
  5054         -	$as_echo "#define JEMALLOC_PURGE_MADVISE_FREE  " >>confdefs.h
         5617  +	$as_echo "#define JEMALLOC_HAS_ALLOCA_H 1" >>confdefs.h
  5055   5618   
         5619  +	$as_echo "#define JEMALLOC_PROC_SYS_VM_OVERCOMMIT_MEMORY  " >>confdefs.h
         5620  +
         5621  +	$as_echo "#define JEMALLOC_THREADED_INIT  " >>confdefs.h
         5622  +
         5623  +	$as_echo "#define JEMALLOC_C11ATOMICS 1" >>confdefs.h
         5624  +
         5625  +	force_tls="0"
         5626  +	default_munmap="0"
  5056   5627   	;;
  5057         -  *-*-linux*)
  5058         -	CFLAGS="$CFLAGS"
  5059         -	CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
         5628  +  *-*-linux* | *-*-kfreebsd*)
         5629  +		T_APPEND_V=-D_GNU_SOURCE
         5630  +  if test "x${CPPFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         5631  +  CPPFLAGS="${CPPFLAGS}${T_APPEND_V}"
         5632  +else
         5633  +  CPPFLAGS="${CPPFLAGS} ${T_APPEND_V}"
         5634  +fi
         5635  +
         5636  +
  5060   5637   	abi="elf"
  5061   5638   	$as_echo "#define JEMALLOC_HAS_ALLOCA_H 1" >>confdefs.h
  5062   5639   
  5063         -	$as_echo "#define JEMALLOC_PURGE_MADVISE_DONTNEED  " >>confdefs.h
         5640  +	$as_echo "#define JEMALLOC_PROC_SYS_VM_OVERCOMMIT_MEMORY  " >>confdefs.h
  5064   5641   
  5065   5642   	$as_echo "#define JEMALLOC_THREADED_INIT  " >>confdefs.h
  5066   5643   
  5067   5644   	$as_echo "#define JEMALLOC_USE_CXX_THROW  " >>confdefs.h
  5068   5645   
  5069   5646   	default_munmap="0"
  5070   5647   	;;
................................................................................
  5084   5661   {
  5085   5662   
  5086   5663     ;
  5087   5664     return 0;
  5088   5665   }
  5089   5666   _ACEOF
  5090   5667   if ac_fn_c_try_compile "$LINENO"; then :
  5091         -  CFLAGS="$CFLAGS"; abi="elf"
         5668  +  abi="elf"
  5092   5669   else
  5093   5670     abi="aout"
  5094   5671   fi
  5095   5672   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  5096   5673   	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $abi" >&5
  5097   5674   $as_echo "$abi" >&6; }
  5098         -	$as_echo "#define JEMALLOC_PURGE_MADVISE_FREE  " >>confdefs.h
  5099         -
  5100   5675   	;;
  5101   5676     *-*-solaris2*)
  5102         -	CFLAGS="$CFLAGS"
  5103   5677   	abi="elf"
  5104         -	$as_echo "#define JEMALLOC_PURGE_MADVISE_FREE  " >>confdefs.h
  5105         -
  5106   5678   	RPATH='-Wl,-R,$(1)'
  5107         -		CPPFLAGS="$CPPFLAGS -D_POSIX_PTHREAD_SEMANTICS"
  5108         -	LIBS="$LIBS -lposix4 -lsocket -lnsl"
         5679  +		T_APPEND_V=-D_POSIX_PTHREAD_SEMANTICS
         5680  +  if test "x${CPPFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         5681  +  CPPFLAGS="${CPPFLAGS}${T_APPEND_V}"
         5682  +else
         5683  +  CPPFLAGS="${CPPFLAGS} ${T_APPEND_V}"
         5684  +fi
         5685  +
         5686  +
         5687  +	T_APPEND_V=-lposix4 -lsocket -lnsl
         5688  +  if test "x${LIBS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         5689  +  LIBS="${LIBS}${T_APPEND_V}"
         5690  +else
         5691  +  LIBS="${LIBS} ${T_APPEND_V}"
         5692  +fi
         5693  +
         5694  +
  5109   5695   	;;
  5110   5696     *-ibm-aix*)
  5111   5697   	if "$LG_SIZEOF_PTR" = "8"; then
  5112   5698   	  	  LD_PRELOAD_VAR="LDR_PRELOAD64"
  5113   5699   	else
  5114   5700   	  	  LD_PRELOAD_VAR="LDR_PRELOAD"
  5115   5701   	fi
  5116   5702   	abi="xcoff"
  5117   5703   	;;
  5118   5704     *-*-mingw* | *-*-cygwin*)
  5119   5705   	abi="pecoff"
  5120   5706   	force_tls="0"
  5121         -	force_lazy_lock="1"
  5122   5707   	maps_coalesce="0"
  5123   5708   	RPATH=""
  5124   5709   	so="dll"
  5125   5710   	if test "x$je_cv_msvc" = "xyes" ; then
  5126   5711   	  importlib="lib"
  5127   5712   	  DSO_LDFLAGS="-LD"
  5128   5713   	  EXTRA_LDFLAGS="-link -DEBUG"
................................................................................
  5131   5716   	  AR='lib'
  5132   5717   	  ARFLAGS='-nologo -out:'
  5133   5718   	  AROUT='$@'
  5134   5719   	  CC_MM=
  5135   5720           else
  5136   5721   	  importlib="${so}"
  5137   5722   	  DSO_LDFLAGS="-shared"
         5723  +	  link_whole_archive="1"
  5138   5724   	fi
  5139   5725   	a="lib"
  5140   5726   	libprefix=""
  5141   5727   	SOREV="${so}"
  5142   5728   	PIC_CFLAGS=""
  5143   5729   	;;
  5144   5730     *)
................................................................................
  5211   5797   
  5212   5798   
  5213   5799   
  5214   5800   
  5215   5801   
  5216   5802   
  5217   5803   
         5804  +
         5805  +
         5806  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing log" >&5
         5807  +$as_echo_n "checking for library containing log... " >&6; }
         5808  +if ${ac_cv_search_log+:} false; then :
         5809  +  $as_echo_n "(cached) " >&6
         5810  +else
         5811  +  ac_func_search_save_LIBS=$LIBS
         5812  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         5813  +/* end confdefs.h.  */
         5814  +
         5815  +/* Override any GCC internal prototype to avoid an error.
         5816  +   Use char because int might match the return type of a GCC
         5817  +   builtin and then its argument prototype would still apply.  */
         5818  +#ifdef __cplusplus
         5819  +extern "C"
         5820  +#endif
         5821  +char log ();
         5822  +int
         5823  +main ()
         5824  +{
         5825  +return log ();
         5826  +  ;
         5827  +  return 0;
         5828  +}
         5829  +_ACEOF
         5830  +for ac_lib in '' m; do
         5831  +  if test -z "$ac_lib"; then
         5832  +    ac_res="none required"
         5833  +  else
         5834  +    ac_res=-l$ac_lib
         5835  +    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
         5836  +  fi
         5837  +  if ac_fn_c_try_link "$LINENO"; then :
         5838  +  ac_cv_search_log=$ac_res
         5839  +fi
         5840  +rm -f core conftest.err conftest.$ac_objext \
         5841  +    conftest$ac_exeext
         5842  +  if ${ac_cv_search_log+:} false; then :
         5843  +  break
         5844  +fi
         5845  +done
         5846  +if ${ac_cv_search_log+:} false; then :
         5847  +
         5848  +else
         5849  +  ac_cv_search_log=no
         5850  +fi
         5851  +rm conftest.$ac_ext
         5852  +LIBS=$ac_func_search_save_LIBS
         5853  +fi
         5854  +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_log" >&5
         5855  +$as_echo "$ac_cv_search_log" >&6; }
         5856  +ac_res=$ac_cv_search_log
         5857  +if test "$ac_res" != no; then :
         5858  +  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
         5859  +
         5860  +else
         5861  +  as_fn_error $? "Missing math functions" "$LINENO" 5
         5862  +fi
         5863  +
         5864  +if test "x$ac_cv_search_log" != "xnone required" ; then
         5865  +  LM="$ac_cv_search_log"
         5866  +else
         5867  +  LM=
         5868  +fi
         5869  +
         5870  +
  5218   5871   
  5219   5872   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether __attribute__ syntax is compilable" >&5
  5220   5873   $as_echo_n "checking whether __attribute__ syntax is compilable... " >&6; }
  5221   5874   if ${je_cv_attribute+:} false; then :
  5222   5875     $as_echo_n "(cached) " >&6
  5223   5876   else
  5224   5877     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
................................................................................
  5246   5899   if test "x${je_cv_attribute}" = "xyes" ; then
  5247   5900     $as_echo "#define JEMALLOC_HAVE_ATTR  " >>confdefs.h
  5248   5901   
  5249   5902     if test "x${GCC}" = "xyes" -a "x${abi}" = "xelf"; then
  5250   5903   
  5251   5904   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -fvisibility=hidden" >&5
  5252   5905   $as_echo_n "checking whether compiler supports -fvisibility=hidden... " >&6; }
  5253         -TCFLAGS="${CFLAGS}"
  5254         -if test "x${CFLAGS}" = "x" ; then
  5255         -  CFLAGS="-fvisibility=hidden"
  5256         -else
  5257         -  CFLAGS="${CFLAGS} -fvisibility=hidden"
  5258         -fi
  5259         -cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  5260         -/* end confdefs.h.  */
  5261         -
  5262         -
  5263         -int
  5264         -main ()
  5265         -{
  5266         -
  5267         -    return 0;
  5268         -
  5269         -  ;
  5270         -  return 0;
  5271         -}
  5272         -_ACEOF
  5273         -if ac_fn_c_try_compile "$LINENO"; then :
  5274         -  je_cv_cflags_appended=-fvisibility=hidden
  5275         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  5276         -$as_echo "yes" >&6; }
  5277         -else
  5278         -  je_cv_cflags_appended=
  5279         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  5280         -$as_echo "no" >&6; }
  5281         -              CFLAGS="${TCFLAGS}"
  5282         -
  5283         -fi
  5284         -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  5285         -
  5286         -  fi
  5287         -fi
  5288         -SAVED_CFLAGS="${CFLAGS}"
         5906  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         5907  +T_APPEND_V=-fvisibility=hidden
         5908  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         5909  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         5910  +else
         5911  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         5912  +fi
         5913  +
         5914  +
         5915  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         5916  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         5917  +else
         5918  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         5919  +fi
         5920  +
         5921  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         5922  +/* end confdefs.h.  */
         5923  +
         5924  +
         5925  +int
         5926  +main ()
         5927  +{
         5928  +
         5929  +    return 0;
         5930  +
         5931  +  ;
         5932  +  return 0;
         5933  +}
         5934  +_ACEOF
         5935  +if ac_fn_c_try_compile "$LINENO"; then :
         5936  +  je_cv_cflags_added=-fvisibility=hidden
         5937  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         5938  +$as_echo "yes" >&6; }
         5939  +else
         5940  +  je_cv_cflags_added=
         5941  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         5942  +$as_echo "no" >&6; }
         5943  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         5944  +
         5945  +fi
         5946  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         5947  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         5948  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         5949  +else
         5950  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         5951  +fi
         5952  +
         5953  +
         5954  +  fi
         5955  +fi
         5956  +SAVED_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         5957  +
  5289   5958   
  5290   5959   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Werror" >&5
  5291   5960   $as_echo_n "checking whether compiler supports -Werror... " >&6; }
  5292         -TCFLAGS="${CFLAGS}"
  5293         -if test "x${CFLAGS}" = "x" ; then
  5294         -  CFLAGS="-Werror"
  5295         -else
  5296         -  CFLAGS="${CFLAGS} -Werror"
  5297         -fi
  5298         -cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  5299         -/* end confdefs.h.  */
  5300         -
  5301         -
  5302         -int
  5303         -main ()
  5304         -{
  5305         -
  5306         -    return 0;
  5307         -
  5308         -  ;
  5309         -  return 0;
  5310         -}
  5311         -_ACEOF
  5312         -if ac_fn_c_try_compile "$LINENO"; then :
  5313         -  je_cv_cflags_appended=-Werror
  5314         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  5315         -$as_echo "yes" >&6; }
  5316         -else
  5317         -  je_cv_cflags_appended=
  5318         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  5319         -$as_echo "no" >&6; }
  5320         -              CFLAGS="${TCFLAGS}"
  5321         -
  5322         -fi
  5323         -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         5961  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         5962  +T_APPEND_V=-Werror
         5963  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         5964  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         5965  +else
         5966  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         5967  +fi
         5968  +
         5969  +
         5970  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         5971  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         5972  +else
         5973  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         5974  +fi
         5975  +
         5976  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         5977  +/* end confdefs.h.  */
         5978  +
         5979  +
         5980  +int
         5981  +main ()
         5982  +{
         5983  +
         5984  +    return 0;
         5985  +
         5986  +  ;
         5987  +  return 0;
         5988  +}
         5989  +_ACEOF
         5990  +if ac_fn_c_try_compile "$LINENO"; then :
         5991  +  je_cv_cflags_added=-Werror
         5992  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         5993  +$as_echo "yes" >&6; }
         5994  +else
         5995  +  je_cv_cflags_added=
         5996  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         5997  +$as_echo "no" >&6; }
         5998  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         5999  +
         6000  +fi
         6001  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         6002  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6003  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6004  +else
         6005  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6006  +fi
         6007  +
         6008  +
         6009  +
         6010  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -herror_on_warning" >&5
         6011  +$as_echo_n "checking whether compiler supports -herror_on_warning... " >&6; }
         6012  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         6013  +T_APPEND_V=-herror_on_warning
         6014  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         6015  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         6016  +else
         6017  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         6018  +fi
         6019  +
         6020  +
         6021  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6022  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6023  +else
         6024  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6025  +fi
         6026  +
         6027  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         6028  +/* end confdefs.h.  */
         6029  +
         6030  +
         6031  +int
         6032  +main ()
         6033  +{
         6034  +
         6035  +    return 0;
         6036  +
         6037  +  ;
         6038  +  return 0;
         6039  +}
         6040  +_ACEOF
         6041  +if ac_fn_c_try_compile "$LINENO"; then :
         6042  +  je_cv_cflags_added=-herror_on_warning
         6043  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         6044  +$as_echo "yes" >&6; }
         6045  +else
         6046  +  je_cv_cflags_added=
         6047  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         6048  +$as_echo "no" >&6; }
         6049  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         6050  +
         6051  +fi
         6052  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         6053  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6054  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6055  +else
         6056  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6057  +fi
         6058  +
  5324   6059   
  5325   6060   
  5326   6061   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether tls_model attribute is compilable" >&5
  5327   6062   $as_echo_n "checking whether tls_model attribute is compilable... " >&6; }
  5328   6063   if ${je_cv_tls_model+:} false; then :
  5329   6064     $as_echo_n "(cached) " >&6
  5330   6065   else
................................................................................
  5348   6083   fi
  5349   6084   rm -f core conftest.err conftest.$ac_objext \
  5350   6085       conftest$ac_exeext conftest.$ac_ext
  5351   6086   fi
  5352   6087   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $je_cv_tls_model" >&5
  5353   6088   $as_echo "$je_cv_tls_model" >&6; }
  5354   6089   
  5355         -CFLAGS="${SAVED_CFLAGS}"
         6090  +CONFIGURE_CFLAGS="${SAVED_CONFIGURE_CFLAGS}"
         6091  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6092  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6093  +else
         6094  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6095  +fi
         6096  +
         6097  +
  5356   6098   if test "x${je_cv_tls_model}" = "xyes" ; then
  5357   6099     $as_echo "#define JEMALLOC_TLS_MODEL __attribute__((tls_model(\"initial-exec\")))" >>confdefs.h
  5358   6100   
  5359   6101   else
  5360   6102     $as_echo "#define JEMALLOC_TLS_MODEL  " >>confdefs.h
  5361   6103   
  5362   6104   fi
  5363         -SAVED_CFLAGS="${CFLAGS}"
         6105  +SAVED_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         6106  +
  5364   6107   
  5365   6108   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Werror" >&5
  5366   6109   $as_echo_n "checking whether compiler supports -Werror... " >&6; }
  5367         -TCFLAGS="${CFLAGS}"
  5368         -if test "x${CFLAGS}" = "x" ; then
  5369         -  CFLAGS="-Werror"
  5370         -else
  5371         -  CFLAGS="${CFLAGS} -Werror"
  5372         -fi
  5373         -cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  5374         -/* end confdefs.h.  */
  5375         -
  5376         -
  5377         -int
  5378         -main ()
  5379         -{
  5380         -
  5381         -    return 0;
  5382         -
  5383         -  ;
  5384         -  return 0;
  5385         -}
  5386         -_ACEOF
  5387         -if ac_fn_c_try_compile "$LINENO"; then :
  5388         -  je_cv_cflags_appended=-Werror
  5389         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  5390         -$as_echo "yes" >&6; }
  5391         -else
  5392         -  je_cv_cflags_appended=
  5393         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  5394         -$as_echo "no" >&6; }
  5395         -              CFLAGS="${TCFLAGS}"
  5396         -
  5397         -fi
  5398         -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         6110  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         6111  +T_APPEND_V=-Werror
         6112  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         6113  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         6114  +else
         6115  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         6116  +fi
         6117  +
         6118  +
         6119  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6120  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6121  +else
         6122  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6123  +fi
         6124  +
         6125  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         6126  +/* end confdefs.h.  */
         6127  +
         6128  +
         6129  +int
         6130  +main ()
         6131  +{
         6132  +
         6133  +    return 0;
         6134  +
         6135  +  ;
         6136  +  return 0;
         6137  +}
         6138  +_ACEOF
         6139  +if ac_fn_c_try_compile "$LINENO"; then :
         6140  +  je_cv_cflags_added=-Werror
         6141  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         6142  +$as_echo "yes" >&6; }
         6143  +else
         6144  +  je_cv_cflags_added=
         6145  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         6146  +$as_echo "no" >&6; }
         6147  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         6148  +
         6149  +fi
         6150  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         6151  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6152  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6153  +else
         6154  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6155  +fi
         6156  +
         6157  +
         6158  +
         6159  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -herror_on_warning" >&5
         6160  +$as_echo_n "checking whether compiler supports -herror_on_warning... " >&6; }
         6161  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         6162  +T_APPEND_V=-herror_on_warning
         6163  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         6164  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         6165  +else
         6166  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         6167  +fi
         6168  +
         6169  +
         6170  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6171  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6172  +else
         6173  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6174  +fi
         6175  +
         6176  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         6177  +/* end confdefs.h.  */
         6178  +
         6179  +
         6180  +int
         6181  +main ()
         6182  +{
         6183  +
         6184  +    return 0;
         6185  +
         6186  +  ;
         6187  +  return 0;
         6188  +}
         6189  +_ACEOF
         6190  +if ac_fn_c_try_compile "$LINENO"; then :
         6191  +  je_cv_cflags_added=-herror_on_warning
         6192  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         6193  +$as_echo "yes" >&6; }
         6194  +else
         6195  +  je_cv_cflags_added=
         6196  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         6197  +$as_echo "no" >&6; }
         6198  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         6199  +
         6200  +fi
         6201  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         6202  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6203  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6204  +else
         6205  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6206  +fi
         6207  +
  5399   6208   
  5400   6209   
  5401   6210   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether alloc_size attribute is compilable" >&5
  5402   6211   $as_echo_n "checking whether alloc_size attribute is compilable... " >&6; }
  5403   6212   if ${je_cv_alloc_size+:} false; then :
  5404   6213     $as_echo_n "(cached) " >&6
  5405   6214   else
................................................................................
  5421   6230   fi
  5422   6231   rm -f core conftest.err conftest.$ac_objext \
  5423   6232       conftest$ac_exeext conftest.$ac_ext
  5424   6233   fi
  5425   6234   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $je_cv_alloc_size" >&5
  5426   6235   $as_echo "$je_cv_alloc_size" >&6; }
  5427   6236   
  5428         -CFLAGS="${SAVED_CFLAGS}"
         6237  +CONFIGURE_CFLAGS="${SAVED_CONFIGURE_CFLAGS}"
         6238  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6239  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6240  +else
         6241  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6242  +fi
         6243  +
         6244  +
  5429   6245   if test "x${je_cv_alloc_size}" = "xyes" ; then
  5430   6246     $as_echo "#define JEMALLOC_HAVE_ATTR_ALLOC_SIZE  " >>confdefs.h
  5431   6247   
  5432   6248   fi
  5433         -SAVED_CFLAGS="${CFLAGS}"
         6249  +SAVED_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         6250  +
  5434   6251   
  5435   6252   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Werror" >&5
  5436   6253   $as_echo_n "checking whether compiler supports -Werror... " >&6; }
  5437         -TCFLAGS="${CFLAGS}"
  5438         -if test "x${CFLAGS}" = "x" ; then
  5439         -  CFLAGS="-Werror"
  5440         -else
  5441         -  CFLAGS="${CFLAGS} -Werror"
  5442         -fi
  5443         -cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  5444         -/* end confdefs.h.  */
  5445         -
  5446         -
  5447         -int
  5448         -main ()
  5449         -{
  5450         -
  5451         -    return 0;
  5452         -
  5453         -  ;
  5454         -  return 0;
  5455         -}
  5456         -_ACEOF
  5457         -if ac_fn_c_try_compile "$LINENO"; then :
  5458         -  je_cv_cflags_appended=-Werror
  5459         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  5460         -$as_echo "yes" >&6; }
  5461         -else
  5462         -  je_cv_cflags_appended=
         6254  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         6255  +T_APPEND_V=-Werror
         6256  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         6257  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         6258  +else
         6259  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         6260  +fi
         6261  +
         6262  +
         6263  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6264  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6265  +else
         6266  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6267  +fi
         6268  +
         6269  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         6270  +/* end confdefs.h.  */
         6271  +
         6272  +
         6273  +int
         6274  +main ()
         6275  +{
         6276  +
         6277  +    return 0;
         6278  +
         6279  +  ;
         6280  +  return 0;
         6281  +}
         6282  +_ACEOF
         6283  +if ac_fn_c_try_compile "$LINENO"; then :
         6284  +  je_cv_cflags_added=-Werror
         6285  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         6286  +$as_echo "yes" >&6; }
         6287  +else
         6288  +  je_cv_cflags_added=
         6289  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         6290  +$as_echo "no" >&6; }
         6291  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         6292  +
         6293  +fi
         6294  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         6295  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6296  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6297  +else
         6298  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6299  +fi
         6300  +
         6301  +
         6302  +
         6303  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -herror_on_warning" >&5
         6304  +$as_echo_n "checking whether compiler supports -herror_on_warning... " >&6; }
         6305  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         6306  +T_APPEND_V=-herror_on_warning
         6307  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         6308  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         6309  +else
         6310  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         6311  +fi
         6312  +
         6313  +
         6314  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6315  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6316  +else
         6317  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6318  +fi
         6319  +
         6320  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         6321  +/* end confdefs.h.  */
         6322  +
         6323  +
         6324  +int
         6325  +main ()
         6326  +{
         6327  +
         6328  +    return 0;
         6329  +
         6330  +  ;
         6331  +  return 0;
         6332  +}
         6333  +_ACEOF
         6334  +if ac_fn_c_try_compile "$LINENO"; then :
         6335  +  je_cv_cflags_added=-herror_on_warning
         6336  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         6337  +$as_echo "yes" >&6; }
         6338  +else
         6339  +  je_cv_cflags_added=
  5463   6340                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  5464   6341   $as_echo "no" >&6; }
  5465         -              CFLAGS="${TCFLAGS}"
         6342  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
  5466   6343   
  5467   6344   fi
  5468   6345   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         6346  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6347  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6348  +else
         6349  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6350  +fi
         6351  +
  5469   6352   
  5470   6353   
  5471   6354   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether format(gnu_printf, ...) attribute is compilable" >&5
  5472   6355   $as_echo_n "checking whether format(gnu_printf, ...) attribute is compilable... " >&6; }
  5473   6356   if ${je_cv_format_gnu_printf+:} false; then :
  5474   6357     $as_echo_n "(cached) " >&6
  5475   6358   else
................................................................................
  5491   6374   fi
  5492   6375   rm -f core conftest.err conftest.$ac_objext \
  5493   6376       conftest$ac_exeext conftest.$ac_ext
  5494   6377   fi
  5495   6378   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $je_cv_format_gnu_printf" >&5
  5496   6379   $as_echo "$je_cv_format_gnu_printf" >&6; }
  5497   6380   
  5498         -CFLAGS="${SAVED_CFLAGS}"
         6381  +CONFIGURE_CFLAGS="${SAVED_CONFIGURE_CFLAGS}"
         6382  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6383  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6384  +else
         6385  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6386  +fi
         6387  +
         6388  +
  5499   6389   if test "x${je_cv_format_gnu_printf}" = "xyes" ; then
  5500   6390     $as_echo "#define JEMALLOC_HAVE_ATTR_FORMAT_GNU_PRINTF  " >>confdefs.h
  5501   6391   
  5502   6392   fi
  5503         -SAVED_CFLAGS="${CFLAGS}"
         6393  +SAVED_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         6394  +
  5504   6395   
  5505   6396   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Werror" >&5
  5506   6397   $as_echo_n "checking whether compiler supports -Werror... " >&6; }
  5507         -TCFLAGS="${CFLAGS}"
  5508         -if test "x${CFLAGS}" = "x" ; then
  5509         -  CFLAGS="-Werror"
  5510         -else
  5511         -  CFLAGS="${CFLAGS} -Werror"
  5512         -fi
  5513         -cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  5514         -/* end confdefs.h.  */
  5515         -
  5516         -
  5517         -int
  5518         -main ()
  5519         -{
  5520         -
  5521         -    return 0;
  5522         -
  5523         -  ;
  5524         -  return 0;
  5525         -}
  5526         -_ACEOF
  5527         -if ac_fn_c_try_compile "$LINENO"; then :
  5528         -  je_cv_cflags_appended=-Werror
         6398  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         6399  +T_APPEND_V=-Werror
         6400  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         6401  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         6402  +else
         6403  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         6404  +fi
         6405  +
         6406  +
         6407  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6408  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6409  +else
         6410  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6411  +fi
         6412  +
         6413  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         6414  +/* end confdefs.h.  */
         6415  +
         6416  +
         6417  +int
         6418  +main ()
         6419  +{
         6420  +
         6421  +    return 0;
         6422  +
         6423  +  ;
         6424  +  return 0;
         6425  +}
         6426  +_ACEOF
         6427  +if ac_fn_c_try_compile "$LINENO"; then :
         6428  +  je_cv_cflags_added=-Werror
         6429  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         6430  +$as_echo "yes" >&6; }
         6431  +else
         6432  +  je_cv_cflags_added=
         6433  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         6434  +$as_echo "no" >&6; }
         6435  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         6436  +
         6437  +fi
         6438  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         6439  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6440  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6441  +else
         6442  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6443  +fi
         6444  +
         6445  +
         6446  +
         6447  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -herror_on_warning" >&5
         6448  +$as_echo_n "checking whether compiler supports -herror_on_warning... " >&6; }
         6449  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         6450  +T_APPEND_V=-herror_on_warning
         6451  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         6452  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         6453  +else
         6454  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         6455  +fi
         6456  +
         6457  +
         6458  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6459  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6460  +else
         6461  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6462  +fi
         6463  +
         6464  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         6465  +/* end confdefs.h.  */
         6466  +
         6467  +
         6468  +int
         6469  +main ()
         6470  +{
         6471  +
         6472  +    return 0;
         6473  +
         6474  +  ;
         6475  +  return 0;
         6476  +}
         6477  +_ACEOF
         6478  +if ac_fn_c_try_compile "$LINENO"; then :
         6479  +  je_cv_cflags_added=-herror_on_warning
  5529   6480                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  5530   6481   $as_echo "yes" >&6; }
  5531   6482   else
  5532         -  je_cv_cflags_appended=
         6483  +  je_cv_cflags_added=
  5533   6484                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  5534   6485   $as_echo "no" >&6; }
  5535         -              CFLAGS="${TCFLAGS}"
         6486  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
  5536   6487   
  5537   6488   fi
  5538   6489   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         6490  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6491  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6492  +else
         6493  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6494  +fi
         6495  +
  5539   6496   
  5540   6497   
  5541   6498   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether format(printf, ...) attribute is compilable" >&5
  5542   6499   $as_echo_n "checking whether format(printf, ...) attribute is compilable... " >&6; }
  5543   6500   if ${je_cv_format_printf+:} false; then :
  5544   6501     $as_echo_n "(cached) " >&6
  5545   6502   else
................................................................................
  5561   6518   fi
  5562   6519   rm -f core conftest.err conftest.$ac_objext \
  5563   6520       conftest$ac_exeext conftest.$ac_ext
  5564   6521   fi
  5565   6522   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $je_cv_format_printf" >&5
  5566   6523   $as_echo "$je_cv_format_printf" >&6; }
  5567   6524   
  5568         -CFLAGS="${SAVED_CFLAGS}"
         6525  +CONFIGURE_CFLAGS="${SAVED_CONFIGURE_CFLAGS}"
         6526  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6527  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6528  +else
         6529  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6530  +fi
         6531  +
         6532  +
  5569   6533   if test "x${je_cv_format_printf}" = "xyes" ; then
  5570   6534     $as_echo "#define JEMALLOC_HAVE_ATTR_FORMAT_PRINTF  " >>confdefs.h
  5571   6535   
  5572   6536   fi
  5573   6537   
  5574   6538   
  5575   6539   # Check whether --with-rpath was given.
................................................................................
  5903   6867   if test "x$enable_code_coverage" = "x1" ; then
  5904   6868     deoptimize="no"
  5905   6869     echo "$CFLAGS $EXTRA_CFLAGS" | grep '\-O' >/dev/null || deoptimize="yes"
  5906   6870     if test "x${deoptimize}" = "xyes" ; then
  5907   6871   
  5908   6872   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -O0" >&5
  5909   6873   $as_echo_n "checking whether compiler supports -O0... " >&6; }
  5910         -TCFLAGS="${CFLAGS}"
  5911         -if test "x${CFLAGS}" = "x" ; then
  5912         -  CFLAGS="-O0"
         6874  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         6875  +T_APPEND_V=-O0
         6876  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         6877  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
  5913   6878   else
  5914         -  CFLAGS="${CFLAGS} -O0"
         6879  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
  5915   6880   fi
         6881  +
         6882  +
         6883  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6884  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6885  +else
         6886  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6887  +fi
         6888  +
  5916   6889   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  5917   6890   /* end confdefs.h.  */
  5918   6891   
  5919   6892   
  5920   6893   int
  5921   6894   main ()
  5922   6895   {
................................................................................
  5924   6897       return 0;
  5925   6898   
  5926   6899     ;
  5927   6900     return 0;
  5928   6901   }
  5929   6902   _ACEOF
  5930   6903   if ac_fn_c_try_compile "$LINENO"; then :
  5931         -  je_cv_cflags_appended=-O0
         6904  +  je_cv_cflags_added=-O0
  5932   6905                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  5933   6906   $as_echo "yes" >&6; }
  5934   6907   else
  5935         -  je_cv_cflags_appended=
         6908  +  je_cv_cflags_added=
  5936   6909                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  5937   6910   $as_echo "no" >&6; }
  5938         -              CFLAGS="${TCFLAGS}"
         6911  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
  5939   6912   
  5940   6913   fi
  5941   6914   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         6915  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6916  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6917  +else
         6918  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6919  +fi
         6920  +
  5942   6921   
  5943   6922     fi
  5944   6923   
  5945   6924   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -fprofile-arcs -ftest-coverage" >&5
  5946   6925   $as_echo_n "checking whether compiler supports -fprofile-arcs -ftest-coverage... " >&6; }
  5947         -TCFLAGS="${CFLAGS}"
  5948         -if test "x${CFLAGS}" = "x" ; then
  5949         -  CFLAGS="-fprofile-arcs -ftest-coverage"
         6926  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         6927  +T_APPEND_V=-fprofile-arcs -ftest-coverage
         6928  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         6929  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
  5950   6930   else
  5951         -  CFLAGS="${CFLAGS} -fprofile-arcs -ftest-coverage"
         6931  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
  5952   6932   fi
         6933  +
         6934  +
         6935  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6936  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6937  +else
         6938  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6939  +fi
         6940  +
  5953   6941   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  5954   6942   /* end confdefs.h.  */
  5955   6943   
  5956   6944   
  5957   6945   int
  5958   6946   main ()
  5959   6947   {
................................................................................
  5961   6949       return 0;
  5962   6950   
  5963   6951     ;
  5964   6952     return 0;
  5965   6953   }
  5966   6954   _ACEOF
  5967   6955   if ac_fn_c_try_compile "$LINENO"; then :
  5968         -  je_cv_cflags_appended=-fprofile-arcs -ftest-coverage
         6956  +  je_cv_cflags_added=-fprofile-arcs -ftest-coverage
  5969   6957                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  5970   6958   $as_echo "yes" >&6; }
  5971   6959   else
  5972         -  je_cv_cflags_appended=
         6960  +  je_cv_cflags_added=
  5973   6961                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  5974   6962   $as_echo "no" >&6; }
  5975         -              CFLAGS="${TCFLAGS}"
         6963  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
  5976   6964   
  5977   6965   fi
  5978   6966   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         6967  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         6968  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         6969  +else
         6970  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         6971  +fi
         6972  +
  5979   6973   
  5980   6974     EXTRA_LDFLAGS="$EXTRA_LDFLAGS -fprofile-arcs -ftest-coverage"
  5981   6975     $as_echo "#define JEMALLOC_CODE_COVERAGE  " >>confdefs.h
  5982   6976   
  5983   6977   fi
  5984   6978   
  5985   6979   
................................................................................
  6199   7193   fi
  6200   7194   
  6201   7195   if test "x$enable_ivsalloc" = "x1" ; then
  6202   7196     $as_echo "#define JEMALLOC_IVSALLOC  " >>confdefs.h
  6203   7197   
  6204   7198   fi
  6205   7199   
  6206         -if test "x$enable_debug" = "x0" -a "x$no_CFLAGS" = "xyes" ; then
  6207         -    optimize="no"
  6208         -  echo "$CFLAGS $EXTRA_CFLAGS" | grep '\-O' >/dev/null || optimize="yes"
  6209         -  if test "x${optimize}" = "xyes" ; then
  6210         -    if test "x$GCC" = "xyes" ; then
         7200  +if test "x$enable_debug" = "x0" ; then
         7201  +  if test "x$GCC" = "xyes" ; then
  6211   7202   
  6212   7203   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -O3" >&5
  6213   7204   $as_echo_n "checking whether compiler supports -O3... " >&6; }
  6214         -TCFLAGS="${CFLAGS}"
  6215         -if test "x${CFLAGS}" = "x" ; then
  6216         -  CFLAGS="-O3"
         7205  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         7206  +T_APPEND_V=-O3
         7207  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         7208  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
  6217   7209   else
  6218         -  CFLAGS="${CFLAGS} -O3"
         7210  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
  6219   7211   fi
         7212  +
         7213  +
         7214  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         7215  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         7216  +else
         7217  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         7218  +fi
         7219  +
         7220  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         7221  +/* end confdefs.h.  */
         7222  +
         7223  +
         7224  +int
         7225  +main ()
         7226  +{
         7227  +
         7228  +    return 0;
         7229  +
         7230  +  ;
         7231  +  return 0;
         7232  +}
         7233  +_ACEOF
         7234  +if ac_fn_c_try_compile "$LINENO"; then :
         7235  +  je_cv_cflags_added=-O3
         7236  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         7237  +$as_echo "yes" >&6; }
         7238  +else
         7239  +  je_cv_cflags_added=
         7240  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         7241  +$as_echo "no" >&6; }
         7242  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         7243  +
         7244  +fi
         7245  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         7246  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         7247  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         7248  +else
         7249  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         7250  +fi
         7251  +
         7252  +
         7253  +
         7254  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -funroll-loops" >&5
         7255  +$as_echo_n "checking whether compiler supports -funroll-loops... " >&6; }
         7256  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         7257  +T_APPEND_V=-funroll-loops
         7258  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         7259  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         7260  +else
         7261  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         7262  +fi
         7263  +
         7264  +
         7265  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         7266  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         7267  +else
         7268  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         7269  +fi
         7270  +
  6220   7271   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  6221   7272   /* end confdefs.h.  */
  6222   7273   
  6223   7274   
  6224   7275   int
  6225   7276   main ()
  6226   7277   {
................................................................................
  6228   7279       return 0;
  6229   7280   
  6230   7281     ;
  6231   7282     return 0;
  6232   7283   }
  6233   7284   _ACEOF
  6234   7285   if ac_fn_c_try_compile "$LINENO"; then :
  6235         -  je_cv_cflags_appended=-O3
         7286  +  je_cv_cflags_added=-funroll-loops
  6236   7287                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  6237   7288   $as_echo "yes" >&6; }
  6238   7289   else
  6239         -  je_cv_cflags_appended=
         7290  +  je_cv_cflags_added=
  6240   7291                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  6241   7292   $as_echo "no" >&6; }
  6242         -              CFLAGS="${TCFLAGS}"
         7293  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
  6243   7294   
  6244   7295   fi
  6245   7296   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         7297  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         7298  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         7299  +else
         7300  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         7301  +fi
  6246   7302   
  6247   7303   
  6248         -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -funroll-loops" >&5
  6249         -$as_echo_n "checking whether compiler supports -funroll-loops... " >&6; }
  6250         -TCFLAGS="${CFLAGS}"
  6251         -if test "x${CFLAGS}" = "x" ; then
  6252         -  CFLAGS="-funroll-loops"
         7304  +  elif test "x$je_cv_msvc" = "xyes" ; then
         7305  +
         7306  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -O2" >&5
         7307  +$as_echo_n "checking whether compiler supports -O2... " >&6; }
         7308  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         7309  +T_APPEND_V=-O2
         7310  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         7311  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
  6253   7312   else
  6254         -  CFLAGS="${CFLAGS} -funroll-loops"
         7313  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
  6255   7314   fi
         7315  +
         7316  +
         7317  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         7318  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         7319  +else
         7320  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         7321  +fi
         7322  +
  6256   7323   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  6257   7324   /* end confdefs.h.  */
  6258   7325   
  6259   7326   
  6260   7327   int
  6261   7328   main ()
  6262   7329   {
................................................................................
  6264   7331       return 0;
  6265   7332   
  6266   7333     ;
  6267   7334     return 0;
  6268   7335   }
  6269   7336   _ACEOF
  6270   7337   if ac_fn_c_try_compile "$LINENO"; then :
  6271         -  je_cv_cflags_appended=-funroll-loops
         7338  +  je_cv_cflags_added=-O2
  6272   7339                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  6273   7340   $as_echo "yes" >&6; }
  6274   7341   else
  6275         -  je_cv_cflags_appended=
         7342  +  je_cv_cflags_added=
  6276   7343                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  6277   7344   $as_echo "no" >&6; }
  6278         -              CFLAGS="${TCFLAGS}"
         7345  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
  6279   7346   
  6280   7347   fi
  6281   7348   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         7349  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         7350  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         7351  +else
         7352  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         7353  +fi
  6282   7354   
  6283         -    elif test "x$je_cv_msvc" = "xyes" ; then
  6284   7355   
  6285         -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -O2" >&5
  6286         -$as_echo_n "checking whether compiler supports -O2... " >&6; }
  6287         -TCFLAGS="${CFLAGS}"
  6288         -if test "x${CFLAGS}" = "x" ; then
  6289         -  CFLAGS="-O2"
         7356  +  else
         7357  +
         7358  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -O" >&5
         7359  +$as_echo_n "checking whether compiler supports -O... " >&6; }
         7360  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         7361  +T_APPEND_V=-O
         7362  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         7363  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
  6290   7364   else
  6291         -  CFLAGS="${CFLAGS} -O2"
         7365  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
  6292   7366   fi
         7367  +
         7368  +
         7369  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         7370  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         7371  +else
         7372  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         7373  +fi
         7374  +
  6293   7375   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  6294   7376   /* end confdefs.h.  */
  6295   7377   
  6296   7378   
  6297   7379   int
  6298   7380   main ()
  6299   7381   {
................................................................................
  6301   7383       return 0;
  6302   7384   
  6303   7385     ;
  6304   7386     return 0;
  6305   7387   }
  6306   7388   _ACEOF
  6307   7389   if ac_fn_c_try_compile "$LINENO"; then :
  6308         -  je_cv_cflags_appended=-O2
         7390  +  je_cv_cflags_added=-O
  6309   7391                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  6310   7392   $as_echo "yes" >&6; }
  6311   7393   else
  6312         -  je_cv_cflags_appended=
         7394  +  je_cv_cflags_added=
  6313   7395                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  6314   7396   $as_echo "no" >&6; }
  6315         -              CFLAGS="${TCFLAGS}"
         7397  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
  6316   7398   
  6317   7399   fi
  6318   7400   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  6319         -
  6320         -    else
  6321         -
  6322         -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -O" >&5
  6323         -$as_echo_n "checking whether compiler supports -O... " >&6; }
  6324         -TCFLAGS="${CFLAGS}"
  6325         -if test "x${CFLAGS}" = "x" ; then
  6326         -  CFLAGS="-O"
         7401  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         7402  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
  6327   7403   else
  6328         -  CFLAGS="${CFLAGS} -O"
         7404  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
  6329   7405   fi
  6330         -cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  6331         -/* end confdefs.h.  */
  6332   7406   
  6333   7407   
  6334         -int
  6335         -main ()
  6336         -{
  6337         -
  6338         -    return 0;
  6339         -
  6340         -  ;
  6341         -  return 0;
  6342         -}
  6343         -_ACEOF
  6344         -if ac_fn_c_try_compile "$LINENO"; then :
  6345         -  je_cv_cflags_appended=-O
  6346         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  6347         -$as_echo "yes" >&6; }
  6348         -else
  6349         -  je_cv_cflags_appended=
  6350         -              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  6351         -$as_echo "no" >&6; }
  6352         -              CFLAGS="${TCFLAGS}"
  6353         -
  6354         -fi
  6355         -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  6356         -
  6357         -    fi
  6358   7408     fi
  6359   7409   fi
  6360   7410   
  6361   7411   # Check whether --enable-stats was given.
  6362   7412   if test "${enable_stats+set}" = set; then :
  6363   7413     enableval=$enable_stats; if test "x$enable_stats" = "xno" ; then
  6364   7414     enable_stats="0"
................................................................................
  6474   7524   rm -f core conftest.err conftest.$ac_objext \
  6475   7525       conftest$ac_exeext conftest.$ac_ext
  6476   7526   LIBS=$ac_check_lib_save_LIBS
  6477   7527   fi
  6478   7528   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_unwind_unw_backtrace" >&5
  6479   7529   $as_echo "$ac_cv_lib_unwind_unw_backtrace" >&6; }
  6480   7530   if test "x$ac_cv_lib_unwind_unw_backtrace" = xyes; then :
  6481         -  LIBS="$LIBS $LUNWIND"
         7531  +  T_APPEND_V=$LUNWIND
         7532  +  if test "x${LIBS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         7533  +  LIBS="${LIBS}${T_APPEND_V}"
         7534  +else
         7535  +  LIBS="${LIBS} ${T_APPEND_V}"
         7536  +fi
         7537  +
         7538  +
  6482   7539   else
  6483   7540     enable_prof_libunwind="0"
  6484   7541   fi
  6485   7542   
  6486   7543     else
  6487         -    LIBS="$LIBS $LUNWIND"
         7544  +    T_APPEND_V=$LUNWIND
         7545  +  if test "x${LIBS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         7546  +  LIBS="${LIBS}${T_APPEND_V}"
         7547  +else
         7548  +  LIBS="${LIBS} ${T_APPEND_V}"
         7549  +fi
         7550  +
         7551  +
  6488   7552     fi
  6489   7553     if test "x${enable_prof_libunwind}" = "x1" ; then
  6490   7554       backtrace_method="libunwind"
  6491   7555       $as_echo "#define JEMALLOC_PROF_LIBUNWIND  " >>confdefs.h
  6492   7556   
  6493   7557     fi
  6494   7558   fi
................................................................................
  6555   7619   rm -f core conftest.err conftest.$ac_objext \
  6556   7620       conftest$ac_exeext conftest.$ac_ext
  6557   7621   LIBS=$ac_check_lib_save_LIBS
  6558   7622   fi
  6559   7623   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gcc__Unwind_Backtrace" >&5
  6560   7624   $as_echo "$ac_cv_lib_gcc__Unwind_Backtrace" >&6; }
  6561   7625   if test "x$ac_cv_lib_gcc__Unwind_Backtrace" = xyes; then :
  6562         -  LIBS="$LIBS -lgcc"
         7626  +  T_APPEND_V=-lgcc
         7627  +  if test "x${LIBS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         7628  +  LIBS="${LIBS}${T_APPEND_V}"
         7629  +else
         7630  +  LIBS="${LIBS} ${T_APPEND_V}"
         7631  +fi
         7632  +
         7633  +
  6563   7634   else
  6564   7635     enable_prof_libgcc="0"
  6565   7636   fi
  6566   7637   
  6567   7638     if test "x${enable_prof_libgcc}" = "x1" ; then
  6568   7639       backtrace_method="libgcc"
  6569   7640       $as_echo "#define JEMALLOC_PROF_LIBGCC  " >>confdefs.h
................................................................................
  6587   7658   fi
  6588   7659   
  6589   7660   if test "x$backtrace_method" = "x" -a "x$enable_prof_gcc" = "x1" \
  6590   7661        -a "x$GCC" = "xyes" ; then
  6591   7662   
  6592   7663   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -fno-omit-frame-pointer" >&5
  6593   7664   $as_echo_n "checking whether compiler supports -fno-omit-frame-pointer... " >&6; }
  6594         -TCFLAGS="${CFLAGS}"
  6595         -if test "x${CFLAGS}" = "x" ; then
  6596         -  CFLAGS="-fno-omit-frame-pointer"
         7665  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         7666  +T_APPEND_V=-fno-omit-frame-pointer
         7667  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         7668  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
  6597   7669   else
  6598         -  CFLAGS="${CFLAGS} -fno-omit-frame-pointer"
         7670  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
  6599   7671   fi
         7672  +
         7673  +
         7674  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         7675  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         7676  +else
         7677  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         7678  +fi
         7679  +
  6600   7680   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  6601   7681   /* end confdefs.h.  */
  6602   7682   
  6603   7683   
  6604   7684   int
  6605   7685   main ()
  6606   7686   {
................................................................................
  6608   7688       return 0;
  6609   7689   
  6610   7690     ;
  6611   7691     return 0;
  6612   7692   }
  6613   7693   _ACEOF
  6614   7694   if ac_fn_c_try_compile "$LINENO"; then :
  6615         -  je_cv_cflags_appended=-fno-omit-frame-pointer
         7695  +  je_cv_cflags_added=-fno-omit-frame-pointer
  6616   7696                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  6617   7697   $as_echo "yes" >&6; }
  6618   7698   else
  6619         -  je_cv_cflags_appended=
         7699  +  je_cv_cflags_added=
  6620   7700                 { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  6621   7701   $as_echo "no" >&6; }
  6622         -              CFLAGS="${TCFLAGS}"
         7702  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
  6623   7703   
  6624   7704   fi
  6625   7705   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         7706  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         7707  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         7708  +else
         7709  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         7710  +fi
         7711  +
  6626   7712   
  6627   7713     backtrace_method="gcc intrinsics"
  6628   7714     $as_echo "#define JEMALLOC_PROF_GCC  " >>confdefs.h
  6629   7715   
  6630   7716   else
  6631   7717     enable_prof_gcc="0"
  6632   7718   fi
................................................................................
  6636   7722     enable_prof="0"
  6637   7723   fi
  6638   7724   { $as_echo "$as_me:${as_lineno-$LINENO}: checking configured backtracing method" >&5
  6639   7725   $as_echo_n "checking configured backtracing method... " >&6; }
  6640   7726   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $backtrace_method" >&5
  6641   7727   $as_echo "$backtrace_method" >&6; }
  6642   7728   if test "x$enable_prof" = "x1" ; then
  6643         -  if test "x$abi" != "xpecoff"; then
  6644         -        LIBS="$LIBS -lm"
  6645         -  fi
         7729  +    T_APPEND_V=$LM
         7730  +  if test "x${LIBS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         7731  +  LIBS="${LIBS}${T_APPEND_V}"
         7732  +else
         7733  +  LIBS="${LIBS} ${T_APPEND_V}"
         7734  +fi
         7735  +
         7736  +
  6646   7737   
  6647   7738     $as_echo "#define JEMALLOC_PROF  " >>confdefs.h
  6648   7739   
  6649   7740   fi
  6650   7741   
  6651   7742   
  6652   7743   # Check whether --enable-tcache was given.
................................................................................
  6885   7976   
  6886   7977   if test "x$enable_cache_oblivious" = "x1" ; then
  6887   7978     $as_echo "#define JEMALLOC_CACHE_OBLIVIOUS  " >>confdefs.h
  6888   7979   
  6889   7980   fi
  6890   7981   
  6891   7982   
         7983  +
         7984  +
         7985  +
         7986  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a program using __builtin_unreachable is compilable" >&5
         7987  +$as_echo_n "checking whether a program using __builtin_unreachable is compilable... " >&6; }
         7988  +if ${je_cv_gcc_builtin_unreachable+:} false; then :
         7989  +  $as_echo_n "(cached) " >&6
         7990  +else
         7991  +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         7992  +/* end confdefs.h.  */
         7993  +
         7994  +void foo (void) {
         7995  +  __builtin_unreachable();
         7996  +}
         7997  +
         7998  +int
         7999  +main ()
         8000  +{
         8001  +
         8002  +	{
         8003  +		foo();
         8004  +	}
         8005  +
         8006  +  ;
         8007  +  return 0;
         8008  +}
         8009  +_ACEOF
         8010  +if ac_fn_c_try_link "$LINENO"; then :
         8011  +  je_cv_gcc_builtin_unreachable=yes
         8012  +else
         8013  +  je_cv_gcc_builtin_unreachable=no
         8014  +fi
         8015  +rm -f core conftest.err conftest.$ac_objext \
         8016  +    conftest$ac_exeext conftest.$ac_ext
         8017  +fi
         8018  +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $je_cv_gcc_builtin_unreachable" >&5
         8019  +$as_echo "$je_cv_gcc_builtin_unreachable" >&6; }
         8020  +
         8021  +if test "x${je_cv_gcc_builtin_unreachable}" = "xyes" ; then
         8022  +  $as_echo "#define JEMALLOC_INTERNAL_UNREACHABLE __builtin_unreachable" >>confdefs.h
         8023  +
         8024  +else
         8025  +  $as_echo "#define JEMALLOC_INTERNAL_UNREACHABLE abort" >>confdefs.h
         8026  +
         8027  +fi
         8028  +
  6892   8029   
  6893   8030   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a program using __builtin_ffsl is compilable" >&5
  6894   8031   $as_echo_n "checking whether a program using __builtin_ffsl is compilable... " >&6; }
  6895   8032   if ${je_cv_gcc_builtin_ffsl+:} false; then :
  6896   8033     $as_echo_n "(cached) " >&6
  6897   8034   else
  6898   8035     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
................................................................................
  7111   8248     withval=$with_lg_size_class_group; LG_SIZE_CLASS_GROUP="$with_lg_size_class_group"
  7112   8249   else
  7113   8250     LG_SIZE_CLASS_GROUP="2"
  7114   8251   fi
  7115   8252   
  7116   8253   
  7117   8254   
  7118         -if test "x`test ! \"${srcroot}\" && cd \"${srcroot}\"; git rev-parse --is-inside-work-tree 2>/dev/null`" = "xtrue" ; then
  7119         -        rm -f "${objroot}VERSION"
  7120         -  for pattern in '[0-9].[0-9].[0-9]' '[0-9].[0-9].[0-9][0-9]' \
  7121         -                 '[0-9].[0-9][0-9].[0-9]' '[0-9].[0-9][0-9].[0-9][0-9]' \
  7122         -                 '[0-9][0-9].[0-9].[0-9]' '[0-9][0-9].[0-9].[0-9][0-9]' \
  7123         -                 '[0-9][0-9].[0-9][0-9].[0-9]' \
  7124         -                 '[0-9][0-9].[0-9][0-9].[0-9][0-9]'; do
  7125         -    if test ! -e "${objroot}VERSION" ; then
  7126         -      (test ! "${srcroot}" && cd "${srcroot}"; git describe --long --abbrev=40 --match="${pattern}") > "${objroot}VERSION.tmp" 2>/dev/null
  7127         -      if test $? -eq 0 ; then
  7128         -        mv "${objroot}VERSION.tmp" "${objroot}VERSION"
  7129         -        break
  7130         -      fi
         8255  +
         8256  +# Check whether --with-version was given.
         8257  +if test "${with_version+set}" = set; then :
         8258  +  withval=$with_version;
         8259  +    echo "${with_version}" | grep '^[0-9]\+\.[0-9]\+\.[0-9]\+-[0-9]\+-g[0-9a-f]\+$' 2>&1 1>/dev/null
         8260  +    if test $? -ne 0 ; then
         8261  +      as_fn_error $? "${with_version} does not match <major>.<minor>.<bugfix>-<nrev>-g<gid>" "$LINENO" 5
         8262  +    fi
         8263  +    echo "$with_version" > "${objroot}VERSION"
         8264  +
         8265  +else
         8266  +
         8267  +        if test "x`test ! \"${srcroot}\" && cd \"${srcroot}\"; git rev-parse --is-inside-work-tree 2>/dev/null`" = "xtrue" ; then
         8268  +                        for pattern in '[0-9].[0-9].[0-9]' '[0-9].[0-9].[0-9][0-9]' \
         8269  +                     '[0-9].[0-9][0-9].[0-9]' '[0-9].[0-9][0-9].[0-9][0-9]' \
         8270  +                     '[0-9][0-9].[0-9].[0-9]' '[0-9][0-9].[0-9].[0-9][0-9]' \
         8271  +                     '[0-9][0-9].[0-9][0-9].[0-9]' \
         8272  +                     '[0-9][0-9].[0-9][0-9].[0-9][0-9]'; do
         8273  +        (test ! "${srcroot}" && cd "${srcroot}"; git describe --long --abbrev=40 --match="${pattern}") > "${objroot}VERSION.tmp" 2>/dev/null
         8274  +        if test $? -eq 0 ; then
         8275  +          mv "${objroot}VERSION.tmp" "${objroot}VERSION"
         8276  +          break
         8277  +        fi
         8278  +      done
  7131   8279       fi
  7132         -  done
         8280  +    rm -f "${objroot}VERSION.tmp"
         8281  +
  7133   8282   fi
  7134         -rm -f "${objroot}VERSION.tmp"
         8283  +
         8284  +
  7135   8285   if test ! -e "${objroot}VERSION" ; then
  7136   8286     if test ! -e "${srcroot}VERSION" ; then
  7137   8287       { $as_echo "$as_me:${as_lineno-$LINENO}: result: Missing VERSION file, and unable to generate it; creating bogus VERSION" >&5
  7138   8288   $as_echo "Missing VERSION file, and unable to generate it; creating bogus VERSION" >&6; }
  7139   8289       echo "0.0.0-0-g0000000000000000000000000000000000000000" > "${objroot}VERSION"
  7140   8290     else
  7141   8291       cp ${srcroot}VERSION ${objroot}VERSION
................................................................................
  7203   8353   rm -f core conftest.err conftest.$ac_objext \
  7204   8354       conftest$ac_exeext conftest.$ac_ext
  7205   8355   LIBS=$ac_check_lib_save_LIBS
  7206   8356   fi
  7207   8357   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pthread_pthread_create" >&5
  7208   8358   $as_echo "$ac_cv_lib_pthread_pthread_create" >&6; }
  7209   8359   if test "x$ac_cv_lib_pthread_pthread_create" = xyes; then :
  7210         -  LIBS="$LIBS -lpthread"
         8360  +  T_APPEND_V=-lpthread
         8361  +  if test "x${LIBS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         8362  +  LIBS="${LIBS}${T_APPEND_V}"
         8363  +else
         8364  +  LIBS="${LIBS} ${T_APPEND_V}"
         8365  +fi
         8366  +
         8367  +
  7211   8368   else
  7212   8369     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing pthread_create" >&5
  7213   8370   $as_echo_n "checking for library containing pthread_create... " >&6; }
  7214   8371   if ${ac_cv_search_pthread_create+:} false; then :
  7215   8372     $as_echo_n "(cached) " >&6
  7216   8373   else
  7217   8374     ac_func_search_save_LIBS=$LIBS
................................................................................
  7265   8422   
  7266   8423   else
  7267   8424     as_fn_error $? "libpthread is missing" "$LINENO" 5
  7268   8425   fi
  7269   8426   
  7270   8427   fi
  7271   8428   
         8429  +
         8430  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether pthread_atfork(3) is compilable" >&5
         8431  +$as_echo_n "checking whether pthread_atfork(3) is compilable... " >&6; }
         8432  +if ${je_cv_pthread_atfork+:} false; then :
         8433  +  $as_echo_n "(cached) " >&6
         8434  +else
         8435  +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         8436  +/* end confdefs.h.  */
         8437  +
         8438  +#include <pthread.h>
         8439  +
         8440  +int
         8441  +main ()
         8442  +{
         8443  +
         8444  +  pthread_atfork((void *)0, (void *)0, (void *)0);
         8445  +
         8446  +  ;
         8447  +  return 0;
         8448  +}
         8449  +_ACEOF
         8450  +if ac_fn_c_try_link "$LINENO"; then :
         8451  +  je_cv_pthread_atfork=yes
         8452  +else
         8453  +  je_cv_pthread_atfork=no
         8454  +fi
         8455  +rm -f core conftest.err conftest.$ac_objext \
         8456  +    conftest$ac_exeext conftest.$ac_ext
         8457  +fi
         8458  +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $je_cv_pthread_atfork" >&5
         8459  +$as_echo "$je_cv_pthread_atfork" >&6; }
         8460  +
         8461  +  if test "x${je_cv_pthread_atfork}" = "xyes" ; then
         8462  +    $as_echo "#define JEMALLOC_HAVE_PTHREAD_ATFORK  " >>confdefs.h
         8463  +
         8464  +  fi
  7272   8465   fi
  7273   8466   
  7274         -CPPFLAGS="$CPPFLAGS -D_REENTRANT"
         8467  +T_APPEND_V=-D_REENTRANT
         8468  +  if test "x${CPPFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         8469  +  CPPFLAGS="${CPPFLAGS}${T_APPEND_V}"
         8470  +else
         8471  +  CPPFLAGS="${CPPFLAGS} ${T_APPEND_V}"
         8472  +fi
  7275   8473   
  7276         -SAVED_LIBS="${LIBS}"
  7277         -LIBS=
         8474  +
         8475  +
  7278   8476   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing clock_gettime" >&5
  7279   8477   $as_echo_n "checking for library containing clock_gettime... " >&6; }
  7280   8478   if ${ac_cv_search_clock_gettime+:} false; then :
  7281   8479     $as_echo_n "(cached) " >&6
  7282   8480   else
  7283   8481     ac_func_search_save_LIBS=$LIBS
  7284   8482   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
................................................................................
  7324   8522   LIBS=$ac_func_search_save_LIBS
  7325   8523   fi
  7326   8524   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_clock_gettime" >&5
  7327   8525   $as_echo "$ac_cv_search_clock_gettime" >&6; }
  7328   8526   ac_res=$ac_cv_search_clock_gettime
  7329   8527   if test "$ac_res" != no; then :
  7330   8528     test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
  7331         -  TESTLIBS="${LIBS}"
  7332         -fi
  7333         -
  7334         -
  7335         -LIBS="${SAVED_LIBS}"
         8529  +
         8530  +fi
         8531  +
         8532  +
         8533  +if test "x$je_cv_cray_prgenv_wrapper" = "xyes" ; then
         8534  +  if test "$ac_cv_search_clock_gettime" != "-lrt"; then
         8535  +    SAVED_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         8536  +
         8537  +
         8538  +    unset ac_cv_search_clock_gettime
         8539  +
         8540  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -dynamic" >&5
         8541  +$as_echo_n "checking whether compiler supports -dynamic... " >&6; }
         8542  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         8543  +T_APPEND_V=-dynamic
         8544  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         8545  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         8546  +else
         8547  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         8548  +fi
         8549  +
         8550  +
         8551  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         8552  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         8553  +else
         8554  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         8555  +fi
         8556  +
         8557  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         8558  +/* end confdefs.h.  */
         8559  +
         8560  +
         8561  +int
         8562  +main ()
         8563  +{
         8564  +
         8565  +    return 0;
         8566  +
         8567  +  ;
         8568  +  return 0;
         8569  +}
         8570  +_ACEOF
         8571  +if ac_fn_c_try_compile "$LINENO"; then :
         8572  +  je_cv_cflags_added=-dynamic
         8573  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         8574  +$as_echo "yes" >&6; }
         8575  +else
         8576  +  je_cv_cflags_added=
         8577  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         8578  +$as_echo "no" >&6; }
         8579  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         8580  +
         8581  +fi
         8582  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         8583  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         8584  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         8585  +else
         8586  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         8587  +fi
         8588  +
         8589  +
         8590  +    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing clock_gettime" >&5
         8591  +$as_echo_n "checking for library containing clock_gettime... " >&6; }
         8592  +if ${ac_cv_search_clock_gettime+:} false; then :
         8593  +  $as_echo_n "(cached) " >&6
         8594  +else
         8595  +  ac_func_search_save_LIBS=$LIBS
         8596  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         8597  +/* end confdefs.h.  */
         8598  +
         8599  +/* Override any GCC internal prototype to avoid an error.
         8600  +   Use char because int might match the return type of a GCC
         8601  +   builtin and then its argument prototype would still apply.  */
         8602  +#ifdef __cplusplus
         8603  +extern "C"
         8604  +#endif
         8605  +char clock_gettime ();
         8606  +int
         8607  +main ()
         8608  +{
         8609  +return clock_gettime ();
         8610  +  ;
         8611  +  return 0;
         8612  +}
         8613  +_ACEOF
         8614  +for ac_lib in '' rt; do
         8615  +  if test -z "$ac_lib"; then
         8616  +    ac_res="none required"
         8617  +  else
         8618  +    ac_res=-l$ac_lib
         8619  +    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
         8620  +  fi
         8621  +  if ac_fn_c_try_link "$LINENO"; then :
         8622  +  ac_cv_search_clock_gettime=$ac_res
         8623  +fi
         8624  +rm -f core conftest.err conftest.$ac_objext \
         8625  +    conftest$ac_exeext
         8626  +  if ${ac_cv_search_clock_gettime+:} false; then :
         8627  +  break
         8628  +fi
         8629  +done
         8630  +if ${ac_cv_search_clock_gettime+:} false; then :
         8631  +
         8632  +else
         8633  +  ac_cv_search_clock_gettime=no
         8634  +fi
         8635  +rm conftest.$ac_ext
         8636  +LIBS=$ac_func_search_save_LIBS
         8637  +fi
         8638  +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_clock_gettime" >&5
         8639  +$as_echo "$ac_cv_search_clock_gettime" >&6; }
         8640  +ac_res=$ac_cv_search_clock_gettime
         8641  +if test "$ac_res" != no; then :
         8642  +  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
         8643  +
         8644  +fi
         8645  +
         8646  +
         8647  +    CONFIGURE_CFLAGS="${SAVED_CONFIGURE_CFLAGS}"
         8648  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         8649  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         8650  +else
         8651  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         8652  +fi
         8653  +
         8654  +
         8655  +  fi
         8656  +fi
         8657  +
         8658  +
         8659  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether clock_gettime(CLOCK_MONOTONIC_COARSE, ...) is compilable" >&5
         8660  +$as_echo_n "checking whether clock_gettime(CLOCK_MONOTONIC_COARSE, ...) is compilable... " >&6; }
         8661  +if ${je_cv_clock_monotonic_coarse+:} false; then :
         8662  +  $as_echo_n "(cached) " >&6
         8663  +else
         8664  +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         8665  +/* end confdefs.h.  */
         8666  +
         8667  +#include <time.h>
         8668  +
         8669  +int
         8670  +main ()
         8671  +{
         8672  +
         8673  +	struct timespec ts;
         8674  +
         8675  +	clock_gettime(CLOCK_MONOTONIC_COARSE, &ts);
         8676  +
         8677  +  ;
         8678  +  return 0;
         8679  +}
         8680  +_ACEOF
         8681  +if ac_fn_c_try_link "$LINENO"; then :
         8682  +  je_cv_clock_monotonic_coarse=yes
         8683  +else
         8684  +  je_cv_clock_monotonic_coarse=no
         8685  +fi
         8686  +rm -f core conftest.err conftest.$ac_objext \
         8687  +    conftest$ac_exeext conftest.$ac_ext
         8688  +fi
         8689  +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $je_cv_clock_monotonic_coarse" >&5
         8690  +$as_echo "$je_cv_clock_monotonic_coarse" >&6; }
         8691  +
         8692  +if test "x${je_cv_clock_monotonic_coarse}" = "xyes" ; then
         8693  +  $as_echo "#define JEMALLOC_HAVE_CLOCK_MONOTONIC_COARSE 1" >>confdefs.h
         8694  +
         8695  +fi
         8696  +
         8697  +
         8698  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether clock_gettime(CLOCK_MONOTONIC, ...) is compilable" >&5
         8699  +$as_echo_n "checking whether clock_gettime(CLOCK_MONOTONIC, ...) is compilable... " >&6; }
         8700  +if ${je_cv_clock_monotonic+:} false; then :
         8701  +  $as_echo_n "(cached) " >&6
         8702  +else
         8703  +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         8704  +/* end confdefs.h.  */
         8705  +
         8706  +#include <unistd.h>
         8707  +#include <time.h>
         8708  +
         8709  +int
         8710  +main ()
         8711  +{
         8712  +
         8713  +	struct timespec ts;
         8714  +
         8715  +	clock_gettime(CLOCK_MONOTONIC, &ts);
         8716  +#if !defined(_POSIX_MONOTONIC_CLOCK) || _POSIX_MONOTONIC_CLOCK < 0
         8717  +#  error _POSIX_MONOTONIC_CLOCK missing/invalid
         8718  +#endif
         8719  +
         8720  +  ;
         8721  +  return 0;
         8722  +}
         8723  +_ACEOF
         8724  +if ac_fn_c_try_link "$LINENO"; then :
         8725  +  je_cv_clock_monotonic=yes
         8726  +else
         8727  +  je_cv_clock_monotonic=no
         8728  +fi
         8729  +rm -f core conftest.err conftest.$ac_objext \
         8730  +    conftest$ac_exeext conftest.$ac_ext
         8731  +fi
         8732  +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $je_cv_clock_monotonic" >&5
         8733  +$as_echo "$je_cv_clock_monotonic" >&6; }
         8734  +
         8735  +if test "x${je_cv_clock_monotonic}" = "xyes" ; then
         8736  +  $as_echo "#define JEMALLOC_HAVE_CLOCK_MONOTONIC 1" >>confdefs.h
         8737  +
         8738  +fi
         8739  +
         8740  +
         8741  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether mach_absolute_time() is compilable" >&5
         8742  +$as_echo_n "checking whether mach_absolute_time() is compilable... " >&6; }
         8743  +if ${je_cv_mach_absolute_time+:} false; then :
         8744  +  $as_echo_n "(cached) " >&6
         8745  +else
         8746  +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         8747  +/* end confdefs.h.  */
         8748  +
         8749  +#include <mach/mach_time.h>
         8750  +
         8751  +int
         8752  +main ()
         8753  +{
         8754  +
         8755  +	mach_absolute_time();
         8756  +
         8757  +  ;
         8758  +  return 0;
         8759  +}
         8760  +_ACEOF
         8761  +if ac_fn_c_try_link "$LINENO"; then :
         8762  +  je_cv_mach_absolute_time=yes
         8763  +else
         8764  +  je_cv_mach_absolute_time=no
         8765  +fi
         8766  +rm -f core conftest.err conftest.$ac_objext \
         8767  +    conftest$ac_exeext conftest.$ac_ext
         8768  +fi
         8769  +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $je_cv_mach_absolute_time" >&5
         8770  +$as_echo "$je_cv_mach_absolute_time" >&6; }
         8771  +
         8772  +if test "x${je_cv_mach_absolute_time}" = "xyes" ; then
         8773  +  $as_echo "#define JEMALLOC_HAVE_MACH_ABSOLUTE_TIME 1" >>confdefs.h
         8774  +
         8775  +fi
         8776  +
         8777  +# Check whether --enable-syscall was given.
         8778  +if test "${enable_syscall+set}" = set; then :
         8779  +  enableval=$enable_syscall; if test "x$enable_syscall" = "xno" ; then
         8780  +  enable_syscall="0"
         8781  +else
         8782  +  enable_syscall="1"
         8783  +fi
         8784  +
         8785  +else
         8786  +  enable_syscall="1"
         8787  +
         8788  +fi
         8789  +
         8790  +if test "x$enable_syscall" = "x1" ; then
         8791  +      SAVED_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         8792  +
         8793  +
         8794  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Werror" >&5
         8795  +$as_echo_n "checking whether compiler supports -Werror... " >&6; }
         8796  +T_CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}"
         8797  +T_APPEND_V=-Werror
         8798  +  if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         8799  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS}${T_APPEND_V}"
         8800  +else
         8801  +  CONFIGURE_CFLAGS="${CONFIGURE_CFLAGS} ${T_APPEND_V}"
         8802  +fi
         8803  +
         8804  +
         8805  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         8806  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         8807  +else
         8808  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         8809  +fi
         8810  +
         8811  +cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         8812  +/* end confdefs.h.  */
         8813  +
         8814  +
         8815  +int
         8816  +main ()
         8817  +{
         8818  +
         8819  +    return 0;
         8820  +
         8821  +  ;
         8822  +  return 0;
         8823  +}
         8824  +_ACEOF
         8825  +if ac_fn_c_try_compile "$LINENO"; then :
         8826  +  je_cv_cflags_added=-Werror
         8827  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
         8828  +$as_echo "yes" >&6; }
         8829  +else
         8830  +  je_cv_cflags_added=
         8831  +              { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
         8832  +$as_echo "no" >&6; }
         8833  +              CONFIGURE_CFLAGS="${T_CONFIGURE_CFLAGS}"
         8834  +
         8835  +fi
         8836  +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
         8837  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         8838  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         8839  +else
         8840  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         8841  +fi
         8842  +
         8843  +
         8844  +
         8845  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether syscall(2) is compilable" >&5
         8846  +$as_echo_n "checking whether syscall(2) is compilable... " >&6; }
         8847  +if ${je_cv_syscall+:} false; then :
         8848  +  $as_echo_n "(cached) " >&6
         8849  +else
         8850  +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         8851  +/* end confdefs.h.  */
         8852  +
         8853  +#include <sys/syscall.h>
         8854  +#include <unistd.h>
         8855  +
         8856  +int
         8857  +main ()
         8858  +{
         8859  +
         8860  +	syscall(SYS_write, 2, "hello", 5);
         8861  +
         8862  +  ;
         8863  +  return 0;
         8864  +}
         8865  +_ACEOF
         8866  +if ac_fn_c_try_link "$LINENO"; then :
         8867  +  je_cv_syscall=yes
         8868  +else
         8869  +  je_cv_syscall=no
         8870  +fi
         8871  +rm -f core conftest.err conftest.$ac_objext \
         8872  +    conftest$ac_exeext conftest.$ac_ext
         8873  +fi
         8874  +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $je_cv_syscall" >&5
         8875  +$as_echo "$je_cv_syscall" >&6; }
         8876  +
         8877  +  CONFIGURE_CFLAGS="${SAVED_CONFIGURE_CFLAGS}"
         8878  +if test "x${CONFIGURE_CFLAGS}" = "x" -o "x${SPECIFIED_CFLAGS}" = "x" ; then
         8879  +  CFLAGS="${CONFIGURE_CFLAGS}${SPECIFIED_CFLAGS}"
         8880  +else
         8881  +  CFLAGS="${CONFIGURE_CFLAGS} ${SPECIFIED_CFLAGS}"
         8882  +fi
         8883  +
         8884  +
         8885  +  if test "x$je_cv_syscall" = "xyes" ; then
         8886  +    $as_echo "#define JEMALLOC_USE_SYSCALL  " >>confdefs.h
         8887  +
         8888  +  fi
         8889  +fi
  7336   8890   
  7337   8891   ac_fn_c_check_func "$LINENO" "secure_getenv" "ac_cv_func_secure_getenv"
  7338   8892   if test "x$ac_cv_func_secure_getenv" = xyes; then :
  7339   8893     have_secure_getenv="1"
  7340   8894   else
  7341   8895     have_secure_getenv="0"
  7342   8896   
................................................................................
  7396   8950   fi
  7397   8951   
  7398   8952   else
  7399   8953     enable_lazy_lock=""
  7400   8954   
  7401   8955   fi
  7402   8956   
  7403         -if test "x$enable_lazy_lock" = "x" -a "x${force_lazy_lock}" = "x1" ; then
  7404         -  { $as_echo "$as_me:${as_lineno-$LINENO}: result: Forcing lazy-lock to avoid allocator/threading bootstrap issues" >&5
         8957  +if test "x${enable_lazy_lock}" = "x" ; then
         8958  +  if test "x${force_lazy_lock}" = "x1" ; then
         8959  +    { $as_echo "$as_me:${as_lineno-$LINENO}: result: Forcing lazy-lock to avoid allocator/threading bootstrap issues" >&5
  7405   8960   $as_echo "Forcing lazy-lock to avoid allocator/threading bootstrap issues" >&6; }
  7406         -  enable_lazy_lock="1"
         8961  +    enable_lazy_lock="1"
         8962  +  else
         8963  +    enable_lazy_lock="0"
         8964  +  fi
         8965  +fi
         8966  +if test "x${enable_lazy_lock}" = "x1" -a "x${abi}" = "xpecoff" ; then
         8967  +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: Forcing no lazy-lock because thread creation monitoring is unimplemented" >&5
         8968  +$as_echo "Forcing no lazy-lock because thread creation monitoring is unimplemented" >&6; }
         8969  +  enable_lazy_lock="0"
  7407   8970   fi
  7408   8971   if test "x$enable_lazy_lock" = "x1" ; then
  7409   8972     if test "x$abi" != "xpecoff" ; then
  7410   8973       for ac_header in dlfcn.h
  7411   8974   do :
  7412   8975     ac_fn_c_check_header_mongrel "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_includes_default"
  7413   8976   if test "x$ac_cv_header_dlfcn_h" = xyes; then :
................................................................................
  7458   9021   rm -f core conftest.err conftest.$ac_objext \
  7459   9022       conftest$ac_exeext conftest.$ac_ext
  7460   9023   LIBS=$ac_check_lib_save_LIBS
  7461   9024   fi
  7462   9025   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlsym" >&5
  7463   9026   $as_echo "$ac_cv_lib_dl_dlsym" >&6; }
  7464   9027   if test "x$ac_cv_lib_dl_dlsym" = xyes; then :
  7465         -  LIBS="$LIBS -ldl"
         9028  +  T_APPEND_V=-ldl
         9029  +  if test "x${LIBS}" = "x" -o "x${T_APPEND_V}" = "x" ; then
         9030  +  LIBS="${LIBS}${T_APPEND_V}"
         9031  +else
         9032  +  LIBS="${LIBS} ${T_APPEND_V}"
         9033  +fi
         9034  +
         9035  +
  7466   9036   else
  7467   9037     as_fn_error $? "libdl is missing" "$LINENO" 5
  7468   9038   fi
  7469   9039   
  7470   9040   
  7471   9041   fi
  7472   9042   
  7473   9043     fi
  7474   9044     $as_echo "#define JEMALLOC_LAZY_LOCK  " >>confdefs.h
  7475   9045   
  7476         -else
  7477         -  enable_lazy_lock="0"
  7478   9046   fi
  7479   9047   
  7480   9048   
  7481   9049   # Check whether --enable-tls was given.
  7482   9050   if test "${enable_tls+set}" = set; then :
  7483   9051     enableval=$enable_tls; if test "x$enable_tls" = "xno" ; then
  7484   9052     enable_tls="0"
................................................................................
  7707   9275   
  7708   9276   #include <sys/mman.h>
  7709   9277   
  7710   9278   int
  7711   9279   main ()
  7712   9280   {
  7713   9281   
  7714         -	{
  7715         -		madvise((void *)0, 0, 0);
  7716         -	}
         9282  +	madvise((void *)0, 0, 0);
  7717   9283   
  7718   9284     ;
  7719   9285     return 0;
  7720   9286   }
  7721   9287   _ACEOF
  7722   9288   if ac_fn_c_try_link "$LINENO"; then :
  7723   9289     je_cv_madvise=yes
................................................................................
  7729   9295   fi
  7730   9296   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $je_cv_madvise" >&5
  7731   9297   $as_echo "$je_cv_madvise" >&6; }
  7732   9298   
  7733   9299   if test "x${je_cv_madvise}" = "xyes" ; then
  7734   9300     $as_echo "#define JEMALLOC_HAVE_MADVISE  " >>confdefs.h
  7735   9301   
         9302  +
         9303  +
         9304  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether madvise(..., MADV_FREE) is compilable" >&5
         9305  +$as_echo_n "checking whether madvise(..., MADV_FREE) is compilable... " >&6; }
         9306  +if ${je_cv_madv_free+:} false; then :
         9307  +  $as_echo_n "(cached) " >&6
         9308  +else
         9309  +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         9310  +/* end confdefs.h.  */
         9311  +
         9312  +#include <sys/mman.h>
         9313  +
         9314  +int
         9315  +main ()
         9316  +{
         9317  +
         9318  +	madvise((void *)0, 0, MADV_FREE);
         9319  +
         9320  +  ;
         9321  +  return 0;
         9322  +}
         9323  +_ACEOF
         9324  +if ac_fn_c_try_link "$LINENO"; then :
         9325  +  je_cv_madv_free=yes
         9326  +else
         9327  +  je_cv_madv_free=no
  7736   9328   fi
         9329  +rm -f core conftest.err conftest.$ac_objext \
         9330  +    conftest$ac_exeext conftest.$ac_ext
         9331  +fi
         9332  +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $je_cv_madv_free" >&5
         9333  +$as_echo "$je_cv_madv_free" >&6; }
         9334  +
         9335  +  if test "x${je_cv_madv_free}" = "xyes" ; then
         9336  +    $as_echo "#define JEMALLOC_PURGE_MADVISE_FREE  " >>confdefs.h
         9337  +
         9338  +  fi
         9339  +
         9340  +
         9341  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether madvise(..., MADV_DONTNEED) is compilable" >&5
         9342  +$as_echo_n "checking whether madvise(..., MADV_DONTNEED) is compilable... " >&6; }
         9343  +if ${je_cv_madv_dontneed+:} false; then :
         9344  +  $as_echo_n "(cached) " >&6
         9345  +else
         9346  +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         9347  +/* end confdefs.h.  */
         9348  +
         9349  +#include <sys/mman.h>
         9350  +
         9351  +int
         9352  +main ()
         9353  +{
         9354  +
         9355  +	madvise((void *)0, 0, MADV_DONTNEED);
         9356  +
         9357  +  ;
         9358  +  return 0;
         9359  +}
         9360  +_ACEOF
         9361  +if ac_fn_c_try_link "$LINENO"; then :
         9362  +  je_cv_madv_dontneed=yes
         9363  +else
         9364  +  je_cv_madv_dontneed=no
         9365  +fi
         9366  +rm -f core conftest.err conftest.$ac_objext \
         9367  +    conftest$ac_exeext conftest.$ac_ext
         9368  +fi
         9369  +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $je_cv_madv_dontneed" >&5
         9370  +$as_echo "$je_cv_madv_dontneed" >&6; }
         9371  +
         9372  +  if test "x${je_cv_madv_dontneed}" = "xyes" ; then
         9373  +    $as_echo "#define JEMALLOC_PURGE_MADVISE_DONTNEED  " >>confdefs.h
         9374  +
         9375  +  fi
         9376  +
         9377  +
         9378  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether madvise(..., MADV_[NO]HUGEPAGE) is compilable" >&5
         9379  +$as_echo_n "checking whether madvise(..., MADV_[NO]HUGEPAGE) is compilable... " >&6; }
         9380  +if ${je_cv_thp+:} false; then :
         9381  +  $as_echo_n "(cached) " >&6
         9382  +else
         9383  +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         9384  +/* end confdefs.h.  */
         9385  +
         9386  +#include <sys/mman.h>
         9387  +
         9388  +int
         9389  +main ()
         9390  +{
         9391  +
         9392  +	madvise((void *)0, 0, MADV_HUGEPAGE);
         9393  +	madvise((void *)0, 0, MADV_NOHUGEPAGE);
         9394  +
         9395  +  ;
         9396  +  return 0;
         9397  +}
         9398  +_ACEOF
         9399  +if ac_fn_c_try_link "$LINENO"; then :
         9400  +  je_cv_thp=yes
         9401  +else
         9402  +  je_cv_thp=no
         9403  +fi
         9404  +rm -f core conftest.err conftest.$ac_objext \
         9405  +    conftest$ac_exeext conftest.$ac_ext
         9406  +fi
         9407  +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $je_cv_thp" >&5
         9408  +$as_echo "$je_cv_thp" >&6; }
         9409  +
         9410  +  if test "x${je_cv_thp}" = "xyes" ; then
         9411  +    $as_echo "#define JEMALLOC_HAVE_MADVISE_HUGE  " >>confdefs.h
         9412  +
         9413  +  fi
         9414  +fi
         9415  +
         9416  +# Check whether --enable-thp was given.
         9417  +if test "${enable_thp+set}" = set; then :
         9418  +  enableval=$enable_thp; if test "x$enable_thp" = "xno" -o "x${je_cv_thp}" != "xyes" ; then
         9419  +  enable_thp="0"
         9420  +else
         9421  +  enable_thp="1"
         9422  +fi
         9423  +
         9424  +else
         9425  +  if test "x${je_cv_thp}" = "xyes" ; then
         9426  +  enable_thp="1"
         9427  +else
         9428  +  enable_thp="0"
         9429  +fi
         9430  +
         9431  +fi
         9432  +
         9433  +if test "x$enable_thp" = "x1" ; then
         9434  +  $as_echo "#define JEMALLOC_THP  " >>confdefs.h
         9435  +
         9436  +fi
         9437  +
  7737   9438   
  7738   9439   
  7739   9440   
  7740   9441   
  7741   9442   if test "x${je_cv_atomic9}" != "xyes" -a "x${je_cv_osatomic}" != "xyes" ; then
  7742   9443   
  7743   9444     { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to force 32-bit __sync_{add,sub}_and_fetch()" >&5
................................................................................
  7870   9571   
  7871   9572   if test "x${je_cv_builtin_clz}" = "xyes" ; then
  7872   9573     $as_echo "#define JEMALLOC_HAVE_BUILTIN_CLZ  " >>confdefs.h
  7873   9574   
  7874   9575   fi
  7875   9576   
  7876   9577   
         9578  +
         9579  +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether Darwin os_unfair_lock_*() is compilable" >&5
         9580  +$as_echo_n "checking whether Darwin os_unfair_lock_*() is compilable... " >&6; }
         9581  +if ${je_cv_os_unfair_lock+:} false; then :
         9582  +  $as_echo_n "(cached) " >&6
         9583  +else
         9584  +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
         9585  +/* end confdefs.h.  */
         9586  +
         9587  +#include <os/lock.h>
         9588  +#include <AvailabilityMacros.h>
         9589  +
         9590  +int
         9591  +main ()
         9592  +{
         9593  +
         9594  +	#if MAC_OS_X_VERSION_MIN_REQUIRED < 101200
         9595  +	#error "os_unfair_lock is not supported"
         9596  +	#else
         9597  +	os_unfair_lock lock = OS_UNFAIR_LOCK_INIT;
         9598  +	os_unfair_lock_lock(&lock);
         9599  +	os_unfair_lock_unlock(&lock);
         9600  +	#endif
         9601  +
         9602  +  ;
         9603  +  return 0;
         9604  +}
         9605  +_ACEOF
         9606  +if ac_fn_c_try_link "$LINENO"; then :
         9607  +  je_cv_os_unfair_lock=yes
         9608  +else
         9609  +  je_cv_os_unfair_lock=no
         9610  +fi
         9611  +rm -f core conftest.err conftest.$ac_objext \
         9612  +    conftest$ac_exeext conftest.$ac_ext
         9613  +fi
         9614  +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $je_cv_os_unfair_lock" >&5
         9615  +$as_echo "$je_cv_os_unfair_lock" >&6; }
         9616  +
         9617  +if test "x${je_cv_os_unfair_lock}" = "xyes" ; then
         9618  +  $as_echo "#define JEMALLOC_OS_UNFAIR_LOCK  " >>confdefs.h
         9619  +
         9620  +fi
         9621  +
         9622  +
  7877   9623   
  7878   9624   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether Darwin OSSpin*() is compilable" >&5
  7879   9625   $as_echo_n "checking whether Darwin OSSpin*() is compilable... " >&6; }
  7880   9626   if ${je_cv_osspin+:} false; then :
  7881   9627     $as_echo_n "(cached) " >&6
  7882   9628   else
  7883   9629     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
................................................................................
  7935   9681   
  7936   9682   if test "x${enable_zone_allocator}" = "x1" ; then
  7937   9683     if test "x${abi}" != "xmacho"; then
  7938   9684       as_fn_error $? "--enable-zone-allocator is only supported on Darwin" "$LINENO" 5
  7939   9685     fi
  7940   9686     $as_echo "#define JEMALLOC_ZONE  " >>confdefs.h
  7941   9687   
  7942         -
  7943         -        { $as_echo "$as_me:${as_lineno-$LINENO}: checking malloc zone version" >&5
  7944         -$as_echo_n "checking malloc zone version... " >&6; }
  7945         -
  7946         -
  7947         -  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  7948         -/* end confdefs.h.  */
  7949         -#include <malloc/malloc.h>
  7950         -int
  7951         -main ()
  7952         -{
  7953         -static int foo[sizeof(malloc_zone_t) == sizeof(void *) * 14 ? 1 : -1]
  7954         -
  7955         -  ;
  7956         -  return 0;
  7957         -}
  7958         -_ACEOF
  7959         -if ac_fn_c_try_compile "$LINENO"; then :
  7960         -  JEMALLOC_ZONE_VERSION=3
  7961         -else
  7962         -
  7963         -  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  7964         -/* end confdefs.h.  */
  7965         -#include <malloc/malloc.h>
  7966         -int
  7967         -main ()
  7968         -{
  7969         -static int foo[sizeof(malloc_zone_t) == sizeof(void *) * 15 ? 1 : -1]
  7970         -
  7971         -  ;
  7972         -  return 0;
  7973         -}
  7974         -_ACEOF
  7975         -if ac_fn_c_try_compile "$LINENO"; then :
  7976         -  JEMALLOC_ZONE_VERSION=5
  7977         -else
  7978         -
  7979         -  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  7980         -/* end confdefs.h.  */
  7981         -#include <malloc/malloc.h>
  7982         -int
  7983         -main ()
  7984         -{
  7985         -static int foo[sizeof(malloc_zone_t) == sizeof(void *) * 16 ? 1 : -1]
  7986         -
  7987         -  ;
  7988         -  return 0;
  7989         -}
  7990         -_ACEOF
  7991         -if ac_fn_c_try_compile "$LINENO"; then :
  7992         -
  7993         -    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  7994         -/* end confdefs.h.  */
  7995         -#include <malloc/malloc.h>
  7996         -int
  7997         -main ()
  7998         -{
  7999         -static int foo[sizeof(malloc_introspection_t) == sizeof(void *) * 9 ? 1 : -1]
  8000         -
  8001         -  ;
  8002         -  return 0;
  8003         -}
  8004         -_ACEOF
  8005         -if ac_fn_c_try_compile "$LINENO"; then :
  8006         -  JEMALLOC_ZONE_VERSION=6
  8007         -else
  8008         -
  8009         -    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  8010         -/* end confdefs.h.  */
  8011         -#include <malloc/malloc.h>
  8012         -int
  8013         -main ()
  8014         -{
  8015         -static int foo[sizeof(malloc_introspection_t) == sizeof(void *) * 13 ? 1 : -1]
  8016         -
  8017         -  ;
  8018         -  return 0;
  8019         -}
  8020         -_ACEOF
  8021         -if ac_fn_c_try_compile "$LINENO"; then :
  8022         -  JEMALLOC_ZONE_VERSION=7
  8023         -else
  8024         -  JEMALLOC_ZONE_VERSION=
  8025         -
  8026         -fi
  8027         -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  8028         -fi
  8029         -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  8030         -else
  8031         -
  8032         -  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  8033         -/* end confdefs.h.  */
  8034         -#include <malloc/malloc.h>
  8035         -int
  8036         -main ()
  8037         -{
  8038         -static int foo[sizeof(malloc_zone_t) == sizeof(void *) * 17 ? 1 : -1]
  8039         -
  8040         -  ;
  8041         -  return 0;
  8042         -}
  8043         -_ACEOF
  8044         -if ac_fn_c_try_compile "$LINENO"; then :
  8045         -  JEMALLOC_ZONE_VERSION=8
  8046         -else
  8047         -
  8048         -  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  8049         -/* end confdefs.h.  */
  8050         -#include <malloc/malloc.h>
  8051         -int
  8052         -main ()
  8053         -{
  8054         -static int foo[sizeof(malloc_zone_t) > sizeof(void *) * 17 ? 1 : -1]
  8055         -
  8056         -  ;
  8057         -  return 0;
  8058         -}
  8059         -_ACEOF
  8060         -if ac_fn_c_try_compile "$LINENO"; then :
  8061         -  JEMALLOC_ZONE_VERSION=9
  8062         -else
  8063         -  JEMALLOC_ZONE_VERSION=
  8064         -
  8065         -fi
  8066         -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  8067         -fi
  8068         -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  8069         -fi
  8070         -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  8071         -fi
  8072         -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  8073         -fi
  8074         -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  8075         -  if test "x${JEMALLOC_ZONE_VERSION}" = "x"; then
  8076         -    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
  8077         -$as_echo "unsupported" >&6; }
  8078         -    as_fn_error $? "Unsupported malloc zone version" "$LINENO" 5
  8079         -  fi
  8080         -  if test "${JEMALLOC_ZONE_VERSION}" = 9; then
  8081         -    JEMALLOC_ZONE_VERSION=8
  8082         -    { $as_echo "$as_me:${as_lineno-$LINENO}: result: > 8" >&5
  8083         -$as_echo "> 8" >&6; }
  8084         -  else
  8085         -    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JEMALLOC_ZONE_VERSION" >&5
  8086         -$as_echo "$JEMALLOC_ZONE_VERSION" >&6; }
  8087         -  fi
  8088         -  cat >>confdefs.h <<_ACEOF
  8089         -#define JEMALLOC_ZONE_VERSION $JEMALLOC_ZONE_VERSION
  8090         -_ACEOF
  8091         -
  8092   9688   fi
  8093   9689   
  8094   9690   
  8095   9691   
  8096   9692   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether glibc malloc hook is compilable" >&5
  8097   9693   $as_echo_n "checking whether glibc malloc hook is compilable... " >&6; }
  8098   9694   if ${je_cv_glibc_malloc_hook+:} false; then :
................................................................................
  9771  11367   $as_echo "library revision   : ${rev}" >&6; }
  9772  11368   { $as_echo "$as_me:${as_lineno-$LINENO}: result: " >&5
  9773  11369   $as_echo "" >&6; }
  9774  11370   { $as_echo "$as_me:${as_lineno-$LINENO}: result: CONFIG             : ${CONFIG}" >&5
  9775  11371   $as_echo "CONFIG             : ${CONFIG}" >&6; }
  9776  11372   { $as_echo "$as_me:${as_lineno-$LINENO}: result: CC                 : ${CC}" >&5
  9777  11373   $as_echo "CC                 : ${CC}" >&6; }
  9778         -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: CFLAGS             : ${CFLAGS}" >&5
  9779         -$as_echo "CFLAGS             : ${CFLAGS}" >&6; }
        11374  +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: CONFIGURE_CFLAGS   : ${CONFIGURE_CFLAGS}" >&5
        11375  +$as_echo "CONFIGURE_CFLAGS   : ${CONFIGURE_CFLAGS}" >&6; }
        11376  +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: SPECIFIED_CFLAGS   : ${SPECIFIED_CFLAGS}" >&5
        11377  +$as_echo "SPECIFIED_CFLAGS   : ${SPECIFIED_CFLAGS}" >&6; }
        11378  +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: EXTRA_CFLAGS       : ${EXTRA_CFLAGS}" >&5
        11379  +$as_echo "EXTRA_CFLAGS       : ${EXTRA_CFLAGS}" >&6; }
  9780  11380   { $as_echo "$as_me:${as_lineno-$LINENO}: result: CPPFLAGS           : ${CPPFLAGS}" >&5
  9781  11381   $as_echo "CPPFLAGS           : ${CPPFLAGS}" >&6; }
  9782  11382   { $as_echo "$as_me:${as_lineno-$LINENO}: result: LDFLAGS            : ${LDFLAGS}" >&5
  9783  11383   $as_echo "LDFLAGS            : ${LDFLAGS}" >&6; }
  9784  11384   { $as_echo "$as_me:${as_lineno-$LINENO}: result: EXTRA_LDFLAGS      : ${EXTRA_LDFLAGS}" >&5
  9785  11385   $as_echo "EXTRA_LDFLAGS      : ${EXTRA_LDFLAGS}" >&6; }
  9786  11386   { $as_echo "$as_me:${as_lineno-$LINENO}: result: LIBS               : ${LIBS}" >&5
  9787  11387   $as_echo "LIBS               : ${LIBS}" >&6; }
  9788         -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: TESTLIBS           : ${TESTLIBS}" >&5
  9789         -$as_echo "TESTLIBS           : ${TESTLIBS}" >&6; }
  9790  11388   { $as_echo "$as_me:${as_lineno-$LINENO}: result: RPATH_EXTRA        : ${RPATH_EXTRA}" >&5
  9791  11389   $as_echo "RPATH_EXTRA        : ${RPATH_EXTRA}" >&6; }
  9792  11390   { $as_echo "$as_me:${as_lineno-$LINENO}: result: " >&5
  9793  11391   $as_echo "" >&6; }
  9794  11392   { $as_echo "$as_me:${as_lineno-$LINENO}: result: XSLTPROC           : ${XSLTPROC}" >&5
  9795  11393   $as_echo "XSLTPROC           : ${XSLTPROC}" >&6; }
  9796  11394   { $as_echo "$as_me:${as_lineno-$LINENO}: result: XSLROOT            : ${XSLROOT}" >&5
................................................................................
  9847  11445   $as_echo "prof-libunwind     : ${enable_prof_libunwind}" >&6; }
  9848  11446   { $as_echo "$as_me:${as_lineno-$LINENO}: result: prof-libgcc        : ${enable_prof_libgcc}" >&5
  9849  11447   $as_echo "prof-libgcc        : ${enable_prof_libgcc}" >&6; }
  9850  11448   { $as_echo "$as_me:${as_lineno-$LINENO}: result: prof-gcc           : ${enable_prof_gcc}" >&5
  9851  11449   $as_echo "prof-gcc           : ${enable_prof_gcc}" >&6; }
  9852  11450   { $as_echo "$as_me:${as_lineno-$LINENO}: result: tcache             : ${enable_tcache}" >&5
  9853  11451   $as_echo "tcache             : ${enable_tcache}" >&6; }
        11452  +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: thp                : ${enable_thp}" >&5
        11453  +$as_echo "thp                : ${enable_thp}" >&6; }
  9854  11454   { $as_echo "$as_me:${as_lineno-$LINENO}: result: fill               : ${enable_fill}" >&5
  9855  11455   $as_echo "fill               : ${enable_fill}" >&6; }
  9856  11456   { $as_echo "$as_me:${as_lineno-$LINENO}: result: utrace             : ${enable_utrace}" >&5
  9857  11457   $as_echo "utrace             : ${enable_utrace}" >&6; }
  9858  11458   { $as_echo "$as_me:${as_lineno-$LINENO}: result: valgrind           : ${enable_valgrind}" >&5
  9859  11459   $as_echo "valgrind           : ${enable_valgrind}" >&6; }
  9860  11460   { $as_echo "$as_me:${as_lineno-$LINENO}: result: xmalloc            : ${enable_xmalloc}" >&5