diff options
Diffstat (limited to 'erts/configure.in')
| -rw-r--r-- | erts/configure.in | 3772 |
1 files changed, 3772 insertions, 0 deletions
diff --git a/erts/configure.in b/erts/configure.in new file mode 100644 index 0000000000..895a357023 --- /dev/null +++ b/erts/configure.in @@ -0,0 +1,3772 @@ +dnl Process this file with autoconf to produce a configure script. -*-m4-*- + +dnl %CopyrightBegin% +dnl +dnl Copyright Ericsson AB 1997-2009. All Rights Reserved. +dnl +dnl The contents of this file are subject to the Erlang Public License, +dnl Version 1.1, (the "License"); you may not use this file except in +dnl compliance with the License. You should have received a copy of the +dnl Erlang Public License along with this software. If not, it can be +dnl retrieved online at http://www.erlang.org/. +dnl +dnl Software distributed under the License is distributed on an "AS IS" +dnl basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +dnl the License for the specific language governing rights and limitations +dnl under the License. +dnl +dnl %CopyrightEnd% + +dnl The string "FIXME convbreak" means that there is a break of +dnl autoconf convention that should be cleaned up. + +AC_INIT(vsn.mk) +AC_PREREQ(2.59) + +if test "x$no_recursion" != "xyes" -a "x$OVERRIDE_CONFIG_CACHE" = "x"; then + # We do not want to use a common cache! + cache_file=/dev/null +fi + +dnl How to set srcdir absolute is taken from the GNU Emacs distribution +#### Make srcdir absolute, if it isn't already. It's important to +#### avoid running the path through pwd unnecessary, since pwd can +#### give you automounter prefixes, which can go away. +case "${srcdir}" in + /* ) ;; + . ) + ## We may be able to use the $PWD environment variable to make this + ## absolute. But sometimes PWD is inaccurate. + ## Make sure CDPATH doesn't affect cd (in case PWD is relative). + CDPATH= + if test "${PWD}" != "" && test "`(cd ${PWD} ; sh -c pwd)`" = "`pwd`" ; + then + srcdir="$PWD" + else + srcdir="`(cd ${srcdir}; pwd)`" + fi + ;; + * ) srcdir="`(cd ${srcdir}; pwd)`" ;; +esac + +## Now, make sure that ERL_TOP is set and is the same as srcdir +## +if test -z "$ERL_TOP" || test ! -d $ERL_TOP ; then + AC_MSG_ERROR(You need to set the environment variable ERL_TOP!) +fi +if test x"${ERL_TOP}/erts" != x"$srcdir"; then + AC_MSG_ERROR([You need to run configure with argument --srcdir=${ERL_TOP}/erts]) +fi +erl_top=${ERL_TOP} + +# echo XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX +# echo X +# echo "X srcdir = $srcdir" +# echo "X ERL_TOP = $ERL_TOP" +# echo X +# echo XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX + +AC_CONFIG_AUX_DIRS($srcdir/autoconf) + +dnl ---------------------------------------------------------------------- +dnl Figure out what system we are running on. +dnl ---------------------------------------------------------------------- + +# +# To configure for free source run ./configure --host=free_source +# +dnl +dnl AC_CANONICAL_HOST does not like free_source as a host specification, +dnl so we make a little special case. +dnl +if test "X$host" != "Xfree_source" -a "X$host" != "Xwin32"; then + AC_CANONICAL_HOST +else + host_os=$host +fi +AC_ISC_POSIX + +AC_CONFIG_HEADER($host/config.h:config.h.in include/internal/$host/ethread_header_config.h:include/internal/ethread_header_config.h.in include/$host/erl_int_sizes_config.h:include/erl_int_sizes_config.h.in) +dnl ---------------------------------------------------------------------- +dnl Optional features. +dnl ---------------------------------------------------------------------- +enable_child_waiter_thread=no +ENABLE_ALLOC_TYPE_VARS= +AC_SUBST(ENABLE_ALLOC_TYPE_VARS) + +AC_ARG_WITH(xcomp-conf, +[ --with-xcompconf=PATH path to cross compilation configuration]) +if test "x$with_xcompconf" != "xno" -a "x$with_xcompconf" != "x" ; then + . $with_xcompconf +fi + + +AC_ARG_ENABLE(threads, +[ --enable-threads enable async thread support + --disable-threads disable async thread support], +[ case "$enableval" in + no) enable_threads=no ;; + *) enable_threads=yes ;; + esac ], enable_threads=unknown) + +AC_ARG_ENABLE(smp-support, +[ --enable-smp-support enable smp support + --disable-smp-support disable smp support], +[ case "$enableval" in + no) enable_smp_support=no ;; + *) enable_smp_support=yes ;; + esac ], enable_smp_support=unknown) + +AC_ARG_WITH(termcap, +[ --with-termcap use termcap (default) + --without-termcap do not use any termcap libraries (ncurses,curses,termcap,termlib)], +[], +[with_termcap=yes]) + + +AC_ARG_ENABLE(hybrid-heap, +[ --enable-hybrid-heap enable hybrid heap + --disable-hybrid-heap disable hybrid heap], +[ case "$enableval" in + no) enable_hybrid_heap=no ;; + *) enable_hybrid_heap=yes ;; + esac ], enable_hybrid_heap=unknown) + +AC_ARG_ENABLE(lock-checking, +[ --enable-lock-checking enable lock checking], +[ case "$enableval" in + no) enable_lock_check=no ;; + *) enable_lock_check=yes ;; + esac +], + enable_lock_check=no) + +AC_ARG_ENABLE(lock-counter, +[ --enable-lock-counter enable lock counters + --disable-lock-counter disable lock counters], +[ case "$enableval" in + no) enable_lock_count=no ;; + *) enable_lock_count=yes ;; + esac ], enable_lock_count=no) + +AC_ARG_ENABLE(kernel-poll, +[ --enable-kernel-poll enable kernel poll support + --disable-kernel-poll disable kernel poll support], +[ case "$enableval" in + no) enable_kernel_poll=no ;; + *) enable_kernel_poll=yes ;; + esac ], enable_kernel_poll=unknown) + + +AC_ARG_ENABLE(sctp, +[ --enable-sctp enable sctp support + --disable-sctp disable sctp support], +[ case "$enableval" in + no) enable_sctp=no ;; + *) enable_sctp=yes ;; + esac ], enable_sctp=unknown) + +AC_ARG_ENABLE(hipe, +[ --enable-hipe enable hipe support + --disable-hipe disable hipe support]) + +AC_ARG_ENABLE(native-libs, +[ --enable-native-libs compile Erlang libraries to native code]) + +AC_ARG_ENABLE(tsp, +[ --enable-tsp compile tsp app]) + +AC_ARG_ENABLE(elib-malloc, +[ --enable-elib-malloc use elib_malloc instead of normal malloc]) + +AC_ARG_ENABLE(fp-exceptions, +[ --enable-fp-exceptions Use hardware floating point exceptions (default if hipe enabled)], +[ case "$enableval" in + no) enable_fp_exceptions=no ;; + *) enable_fp_exceptions=yes ;; + esac +],enable_fp_exceptions=auto) + +AC_ARG_ENABLE(darwin-universal, +[ --enable-darwin-universal build universal binaries on darwin i386], +[ case "$enableval" in + no) enable_darwin_universal=no ;; + *) enable_darwin_univeral=yes ;; + esac +],enable_darwin_universal=no) + + +AC_ARG_ENABLE(darwin-64bit, +[ --enable-darwin-64bit build 64bit binaries on darwin], +[ case "$enableval" in + no) enable_darwin_64bit=no ;; + *) enable_darwin_64bit=yes ;; + esac +],enable_darwin_64bit=no) + +AC_ARG_ENABLE(m64-build, +[ --enable-m64-build build 64bit binaries using the -m64 flag to (g)cc], +[ case "$enableval" in + no) enable_m64_build=no ;; + *) enable_m64_build=yes ;; + esac +],enable_m64_build=no) + +AC_ARG_ENABLE(fixalloc, +[ --disable-fixalloc disable the use of fix_alloc]) +if test x${enable_fixalloc} = xno ; then + AC_DEFINE(NO_FIX_ALLOC,[], + [Define if you don't want the fix allocator in Erlang]) +fi + +AC_SUBST(PERFCTR_PATH) +AC_ARG_WITH(perfctr, +[ --with-perfctr=PATH specify location of perfctr include and lib + --without-perfctr don't use perfctr (default)]) + +if test "x$with_perfctr" = "xno" -o "x$with_perfctr" = "x" ; then + PERFCTR_PATH= +else + if test ! -f "$with_perfctr/usr.lib/libperfctr.a" ; then + AC_MSG_ERROR(Invalid path to option --with-perfctr=PATH) + fi + PERFCTR_PATH="$with_perfctr" + AC_DEFINE(USE_PERFCTR,[1], + [Define to enable hrvtime() on Linux systems with perfctr extension]) +fi + +AC_ARG_ENABLE(clock-gettime, +[ --enable-clock-gettime Use clock-gettime for time correction], +[ case "$enableval" in + no) clock_gettime_correction=no ;; + *) clock_gettime_correction=yes ;; + esac ], clock_gettime_correction=unknown) + +AC_ARG_ENABLE(native-ethr-impls, +[ --enable-native-ethr-impls enable native ethread implementations + --disable-native-ethr-impls disable native ethread implementations], +[ case "$enableval" in + no) disable_native_ethr_impls=yes ;; + *) disable_native_ethr_impls=no ;; + esac ], disable_native_ethr_impls=no) + +dnl Defined in libraries/megaco/configure.in but we need it here +dnl also in order to show it to the "top user" + +AC_ARG_ENABLE(megaco_flex_scanner_lineno, +[ --disable-megaco-flex-scanner-lineno disable megaco flex scanner lineno]) + +dnl Magic test for clearcase. +OTP_RELEASE= +if test "${ERLANG_COMMERCIAL_BUILD}" != ""; then + OTP_EXTRA_FLAGS=-DOTP_RELEASE + OTP_RELEASE=yes +else + OTP_EXTRA_FLAGS= +fi +AC_SUBST(OTP_RELEASE) + +dnl OK, we might have darwin switches off different kinds, lets +dnl check it all before continuing. +TMPSYS=`uname -s`-`uname -m` +if test X${enable_darwin_universal} = Xyes; then + if test X${enable_darwin_64bit} = Xyes; then + AC_MSG_ERROR([--enable-darwin-universal and --enable-darwin-64bit mutually exclusive]) + fi + enable_hipe=no + case $CFLAGS in + *-arch\ ppc*) + ;; + *) + CFLAGS="-arch ppc $CFLAGS" + ;; + esac + case $CFLAGS in + *-arch\ i386*) + ;; + *) + CFLAGS="-arch i386 $CFLAGS" + ;; + esac +fi +if test X${enable_darwin_64bit} = Xyes; then + case "$TMPSYS" in + Darwin-i386|Darwin-x86_64) + ;; + Darwin*) + AC_MSG_ERROR([--enable-darwin-64bit only supported on x86 hosts]) + ;; + *) + AC_MSG_ERROR([--enable-darwin-64bit only supported on Darwin]) + ;; + esac +fi +if test X${enable_darwin_64bit} = Xyes -o X${enable_m64_build} = Xyes; then + enable_hipe=no + case $CFLAGS in + *-m64*) + ;; + *) + CFLAGS="-m64 $CFLAGS" + ;; + esac +else + case $host_os in + darwin*) + case $CFLAGS in + *-m32*) + ;; + *) + CFLAGS="-m32 $CFLAGS" + ;; + esac + ;; + *) + ;; + esac +fi + + +dnl ---------------------------------------------------------------------- +dnl Checks for programs. +dnl ---------------------------------------------------------------------- + +AC_PROG_CC + +dnl --------------------------------------------------------------------- +dnl Special stuff regarding CFLAGS and details in the environment... +dnl --------------------------------------------------------------------- + +dnl NOTE: CPPFLAGS will be included in CFLAGS at the end +case $host_os in + linux*) CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE";; + win32) + # The ethread library requires _WIN32_WINNT of at least 0x0403. + # -D_WIN32_WINNT=* from CPPFLAGS is saved in ETHR_DEFS. + CPPFLAGS="$CPPFLAGS -D_WIN32_WINNT=0x0500 -DWINVER=0x0500" + # _USE_32BIT_TIME_T is needed when using VC++ 2005 (ctime() will fail + # otherwise since we pass it a 32-bit value). + # + # FIXME: Use time_t all the way and remove _USE_32BIT_TIME_T. + AC_MSG_WARN([Reverting to 32-bit time_t]) + CPPFLAGS="$CPPFLAGS -D_USE_32BIT_TIME_T" + ;; + *) + ;; +esac + + + +MIXED_CYGWIN=no + +AC_MSG_CHECKING(for mixed cygwin and native VC++ environment) +if test "X$host" = "Xwin32" -a "x$GCC" != x"yes"; then + if test -x /usr/bin/cygpath; then + CFLAGS="-O2" + MIXED_CYGWIN=yes + AC_MSG_RESULT([yes]) + MIXED_CYGWIN_VC=yes + CPPFLAGS="$CPPFLAGS -DERTS_MIXED_CYGWIN_VC" + else + AC_MSG_RESULT([undeterminable]) + AC_MSG_ERROR(Seems to be mixed windows but not with cygwin, cannot handle this!) + fi +else + AC_MSG_RESULT([no]) + MIXED_CYGWIN_VC=no +fi +AC_SUBST(MIXED_CYGWIN_VC) + +AC_MSG_CHECKING(for mixed cygwin and native MinGW environment) +if test "X$host" = "Xwin32" -a "x$GCC" = x"yes"; then + if test -x /usr/bin/cygpath; then + CFLAGS="-O2" + MIXED_CYGWIN=yes + AC_MSG_RESULT([yes]) + MIXED_CYGWIN_MINGW=yes + CPPFLAGS="$CPPFLAGS -DERTS_MIXED_CYGWIN_MINGW" + else + AC_MSG_RESULT([undeterminable]) + AC_MSG_ERROR(Seems to be mixed windows but not with cygwin, cannot handle this!) + fi +else + AC_MSG_RESULT([no]) + MIXED_CYGWIN_MINGW=no +fi +AC_SUBST(MIXED_CYGWIN_MINGW) + +AC_MSG_CHECKING(if we mix cygwin with any native compiler) +if test "X$MIXED_CYGWIN" = "Xyes" ; then + AC_MSG_RESULT([yes]) +else + AC_MSG_RESULT([no]) +fi + +AC_SUBST(MIXED_CYGWIN) + +dnl +dnl Flags to the C compiler +dnl +dnl Make sure we find config.h +dnl + +extra_flags="-I${ERL_TOP}/erts/$host $OTP_EXTRA_FLAGS" +CFLAGS="$CFLAGS $extra_flags" +DEBUG_CFLAGS="-g $CPPFLAGS $extra_flags" +DEBUG_FLAGS=-g + +CFLAG_RUNTIME_LIBRARY_PATH="-Wl,-R" +case $host_os in + darwin*) + CFLAG_RUNTIME_LIBRARY_PATH= + CFLAGS="$CFLAGS -no-cpp-precomp" + ;; + win32) + CFLAG_RUNTIME_LIBRARY_PATH= + ;; + osf*) + CFLAG_RUNTIME_LIBRARY_PATH="-Wl,-rpath," + ;; + *) + ;; +esac + + +dnl +dnl Use the getconf utility if it exists +dnl to find large file support flags. +dnl +if type getconf >/dev/null 2>&1; then + CFLAGS="$CFLAGS `getconf LFS_CFLAGS 2>/dev/null`" + DEBUG_CFLAGS="$DEBUG_CFLAGS `getconf LFS_CFLAGS 2>/dev/null`" + LDFLAGS="$LDFLAGS `getconf LFS_LDFLAGS 2>/dev/null`" + LIBS="$LIBS `getconf LFS_LIBS 2>/dev/null`" +fi + +if test "x$GCC" = xyes; then + # until the emulator can handle this, I suggest we turn it off! + #WFLAGS="-Wall -Wshadow -Wcast-qual -Wmissing-declarations" + WFLAGS="-Wall -Wstrict-prototypes -Wmissing-prototypes" + + saved_CFLAGS=$CFLAGS + CFLAGS="$CFLAGS -Wdeclaration-after-statement" + AC_TRY_COMPILE([],[;], warn_decl_after_st=true, warn_decl_after_st=false) + if test "X$warn_decl_after_st" = "Xtrue"; then + WFLAGS="$WFLAGS -Wdeclaration-after-statement" + fi + CFLAGS=$saved_CFLAGS +else + WFLAGS="" +fi +dnl DEBUG_FLAGS is obsolete (I hope) +AC_SUBST(DEBUG_FLAGS) +AC_SUBST(DEBUG_CFLAGS) +AC_SUBST(WFLAGS) +AC_SUBST(CFLAG_RUNTIME_LIBRARY_PATH) + +AC_CHECK_SIZEOF(void *, $erl_xcomp_void_p) # Needed for ARCH and smp checks below + +dnl +dnl Figure out operating system and cpu architecture +dnl + +if test "x$erl_xcomp_os" != "x"; then + chk_opsys_=$erl_xcomp_os +else + if test "x$host_os" = "xwin32"; then + chk_opsys_=win32 + else + chk_opsys_=`uname -s` + if test "x$chk_opsys_" = "xSunOS"; then + chk_opsys_=$chk_opsys_`uname -r` + fi + fi +fi +case $chk_opsys_ in + win32) OPSYS=win32;; + solaris2.*|SunOS5.*) OPSYS=sol2;; + linux|Linux) OPSYS=linux;; + darwin|Darwin) OPSYS=darwin;; + freebsd|FreeBSD) OPSYS=freebsd;; + *) OPSYS=noopsys +esac + +if test "x$erl_xcomp_hw" != "x"; then + chk_arch_=$erl_xcomp_hw +else + chk_arch_=`uname -m` +fi +case $chk_arch_ in + sun4u) ARCH=ultrasparc;; + sparc64) ARCH=sparc64;; + sun4v) ARCH=ultrasparc;; + i86pc) ARCH=x86;; + i386) ARCH=x86;; + i486) ARCH=x86;; + i586) ARCH=x86;; + i686) ARCH=x86;; + x86_64) ARCH=amd64;; + amd64) ARCH=amd64;; + macppc) ARCH=ppc;; + ppc) ARCH=ppc;; + ppc64) ARCH=ppc64;; + "Power Macintosh") ARCH=ppc;; + armv5b) ARCH=arm;; + armv5teb) ARCH=arm;; + armv5tel) ARCH=arm;; + tile) ARCH=tile;; + *) ARCH=noarch;; +esac + +dnl +dnl Convert between x86 and amd64 based on the compiler's mode. +dnl Ditto between ultrasparc and sparc64. +dnl +AC_MSG_CHECKING(whether compilation mode forces ARCH adjustment) +case "$ARCH-$ac_cv_sizeof_void_p" in +i386-8) + AC_MSG_RESULT(yes: adjusting ARCH=x86 to ARCH=amd64) + ARCH=amd64 + ;; +x86-8) + AC_MSG_RESULT(yes: adjusting ARCH=x86 to ARCH=amd64) + ARCH=amd64 + ;; +amd64-4) + AC_MSG_RESULT(yes: adjusting ARCH=amd64 to ARCH=x86) + ARCH=x86 + ;; +ultrasparc-8) + AC_MSG_RESULT(yes: adjusting ARCH=ultrasparc to ARCH=sparc64) + ARCH=sparc64 + ;; +sparc64-4) + AC_MSG_RESULT(yes: adjusting ARCH=sparc64 to ARCH=ultrasparc) + ARCH=ultrasparc + ;; +ppc64-4) + AC_MSG_RESULT(yes: adjusting ARCH=ppc64 to ARCH=ppc) + ARCH=ppc + ;; +*) + AC_MSG_RESULT(no) + ;; +esac + +AC_SUBST(OPSYS) +AC_SUBST(ARCH) + +dnl Check consistency of os and darwin-switches + + +dnl Take care of LDFLAGS on darwin, and disable common_test as it +dnl has a build/configure system re rx-lib that is not compatible +dnl First remove common_tests skip file. + +dnl Adjust LDFLAGS to allow 64bit linkage on DARWIN +case $ARCH-$OPSYS in + amd64-darwin*) + AC_MSG_NOTICE([Adjusting LDFLAGS to cope with 64bit Darwin]) + case $LDFLAGS in + *-m64*) + ;; + *) + LDFLAGS="-m64 $LDFLAGS" + ;; + esac + ;; + *-darwin*) + if test X${enable_darwin_universal} = Xyes; then + AC_MSG_NOTICE([Adjusting LDFLAGS for universal binaries]) + + case $LDFLAGS in + *-arch\ ppc*) + ;; + *) + LDFLAGS="-arch ppc $LDFLAGS" + ;; + esac + case $LDFLAGS in + *-arch\ i386*) + ;; + *) + LDFLAGS="-arch i386 $LDFLAGS" + ;; + esac + else + case $LDFLAGS in + *-m32*) + ;; + *) + LDFLAGS="-m32 $LDFLAGS" + ;; + esac + fi + ;; + *) + if test X${enable_m64_build} = Xyes; then + AC_MSG_NOTICE([Adjusting LDFLAGS to use -m64]) + case $LDFLAGS in + *-m64*) + ;; + *) + LDFLAGS="-m64 $LDFLAGS" + ;; + esac + fi + ;; +esac + +AC_MSG_CHECKING(if VM has to be linked with Carbon framework) +case $ARCH-$OPSYS in + amd64-darwin*) + LIBCARBON= + AC_MSG_RESULT([no]) + ;; + *-darwin*) + LIBCARBON="-framework Carbon " + AC_MSG_RESULT([yes]) + ;; + *) + LIBCARBON= + AC_MSG_RESULT([no]) + ;; +esac + +AC_SUBST(LIBCARBON) + +dnl some tests below will call this if we haven't already - and autoconf +dnl can't handle those tests being done conditionally at runtime +AC_PROG_CPP + +AC_PROG_RANLIB + +AC_PROG_YACC +LM_PROG_PERL5 +if test "$ac_cv_path_PERL" = false; then + AC_MSG_ERROR([Perl version 5 is required to build the emulator!]) +fi +AC_PROG_LN_S + + +AC_CHECK_PROG(AR, ar, ar, false) +if test "$ac_cv_prog_AR" = false; then + AC_MSG_ERROR([No 'ar' command found in PATH]) +fi + +_search_path=/bin:/usr/bin:/usr/local/bin:$PATH + +AC_PATH_PROG(RM, rm, false, $_search_path) +if test "$ac_cv_path_RM" = false; then + AC_MSG_ERROR([No 'rm' command found]) +fi + +AC_PATH_PROG(MKDIR, mkdir, false, $_search_path) +if test "$ac_cv_path_MKDIR" = false; then + AC_MSG_ERROR([No 'mkdir' command found]) +fi + +_search_path= + +# +# Get programs needed for building the documentation +# + +## Delete previous failed configure results +if test -f doc/CONF_INFO; then + rm doc/CONF_INFO +fi + +AC_CHECK_PROGS(XSLTPROC, xsltproc) +if test -z "$XSLTPROC"; then + echo "xsltproc" >> doc/CONF_INFO + AC_MSG_WARN([No 'xsltproc' command found: the documentation can not be built]) +fi + +AC_CHECK_PROGS(FOP, fop) +if test -z "$FOP"; then + echo "fop" >> doc/CONF_INFO + AC_MSG_WARN([No 'fop' command found: the documentation can not be built]) +fi + +dnl +dnl We can live with Solaris /usr/ucb/install +dnl +case $host in + *-*-solaris*|free_source) + if test -x /usr/ucb/install; then + INSTALL="/usr/ucb/install -c" + fi + ;; + *) + ;; +esac +AC_PROG_INSTALL +LM_PROG_INSTALL_DIR + +case $host_os in + darwin*) + dnl Need to preserve modification time on archives; + dnl otherwise, ranlib has to be run on archives + dnl again after installation. + INSTALL_DATA="$INSTALL_DATA -p";; + *) + ;; +esac + +dnl +dnl Fix for Tilera install permissions +dnl + +case $build in + *tile*) + INSTALL_PROGRAM="$INSTALL_PROGRAM -m755" + INSTALL_SCRIPT="$INSTALL_SCRIPT -m755" + ;; + *) + ;; +esac + +dnl ---------------------------------------------------------------------- +dnl Misc. things (some of them should go away) +dnl ---------------------------------------------------------------------- + +dnl +dnl An attempt to allow cross compiling. This is not the right way, +dnl nor does it work currently. Some makefiles still needs these +dnl variables, so we leave them in for now. +dnl +HCC='$(CC)' AC_SUBST(HCC) +HCFLAGS="" AC_SUBST(HCFLAGS) +HCFLAGS="$HCFLAGS -I${ERL_TOP}/erts/$host" +vxworks_reclaim="" AC_SUBST(vxworks_reclaim) +LD='$(CC)' AC_SUBST(LD) + + +dnl Check for cygwin and object/exe files extension +dnl AC_CYGWIN is deprecated +AC_EXEEXT +AC_OBJEXT + +dnl This is the os flavour, should be unix, vxworks or win32 +if test "X$host" = "Xwin32"; then + ERLANG_OSTYPE=win32 +else + ERLANG_OSTYPE=unix +fi + +AC_SUBST(ERLANG_OSTYPE) + +dnl Which sysv4 would this be, and what is it for??? +dnl XXX: replace with feature tests. +case $host_os in + sysv4*) + AC_DEFINE(SOCKOPT_CONNECT_STAT,[],[Obscure SYSV feature]) + AC_DEFINE(NO_PRAGMA_WEAK,[],[Obscure SYSV feature]) + LIBS="$LIBS -lgen -lc -L /usr/ucblib -lucb" + ;; +esac + +# Check how to export functions from the emulator executable, needed +# when dynamically loaded drivers are loaded (so that they can find +# emulator functions). +# OS'es with ELF executables using the GNU linker (Linux and recent *BSD, +# in rare cases Solaris) typically need '-Wl,-export-dynamic' (i.e. pass +# -export-dynamic to the linker - also known as -rdynamic and some other +# variants); some sysVr4 system(s) instead need(s) '-Wl,-Bexport'. +# AIX 4.x (perhaps only for x>=2) wants -Wl,-bexpall,-brtl and doesn't +# reliably return an error for others, thus we separate it out. +# Otherwise we assume that if the linker accepts the flag, it is needed. +AC_MSG_CHECKING(for extra flags needed to export symbols) +DEXPORT="" +case $host_os in + aix4*) + DEXPORT=-Wl,-bexpall,-brtl + ;; + bsdi*) + DEXPORT="-rdynamic " + ;; + win32) + DEXPORT="" + ;; + *) + save_ldflags="$LDFLAGS" + LDFLAGS=-Wl,-export-dynamic + AC_TRY_LINK(,,[DEXPORT=-Wl,-export-dynamic], [ + LDFLAGS=-Wl,-Bexport + AC_TRY_LINK(,,[DEXPORT=-Wl,-Bexport], + AC_MSG_RESULT(none))]) + LDFLAGS="$save_ldflags" + ;; +esac +AC_SUBST(DEXPORT) +case "x$DEXPORT" in + "x") + AC_MSG_RESULT([none]);; + *) + AC_MSG_RESULT([$DEXPORT]);; +esac + +# Check for Solaris/ultrasparc /dev/perfmon interface +# (also needs gcc specific asm instructions) +case "${host}:${GCC}" in + sparc-*-solaris*:yes) + AC_DEFINE(HAVE_SOLARIS_SPARC_PERFMON,[1], + [define if you have the Solaris/ultrasparc /dev/perfmon interface]) + ;; + *) + ;; +esac + + +dnl ---------------------------------------------------------------------- +dnl Checks for libraries. +dnl ---------------------------------------------------------------------- + +AC_CHECK_LIB(m, sin) +AC_CHECK_LIB(dl, dlopen) +AC_CHECK_LIB(inet, main) +AC_CHECK_LIB(util, openpty) + +dnl Try to find a thread library. +dnl +dnl ETHR_LIB_NAME, ETHR_LIBS, ETHR_X_LIBS, ETHR_THR_LIB_BASE and ETHR_DEFS +dnl are set by ERL_FIND_ETHR_LIB +ERL_FIND_ETHR_LIB + +if test "X$ETHR_LIB_NAME" = "X"; then + found_threads=no +else + found_threads=yes +fi + + +ERTS_BUILD_SMP_EMU=$enable_smp_support +AC_MSG_CHECKING(whether an emulator with smp support should be built) +case $ERTS_BUILD_SMP_EMU in + yes) + AC_MSG_RESULT(yes; enabled by user) + ;; + no) + AC_MSG_RESULT(no; disabled by user) + ;; + unknown) + AC_TRY_COMPILE([],[ + #if __GNUC__ >= 3 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95) + ; + #else + #error old or no gcc + #endif + ], + gcc_smp=okgcc, + gcc_smp=oldornogcc) + ERTS_BUILD_SMP_EMU=yes + case "$enable_threads-$gcc_smp-$found_threads-$host_os" in + + no-*) + AC_MSG_RESULT(no; threads disabled by user) + ERTS_BUILD_SMP_EMU=no + ;; + + *-okgcc-yes-*) + AC_MSG_RESULT(yes) + ERTS_BUILD_SMP_EMU=yes + ;; + + *-win32) + AC_MSG_RESULT(yes) + ERTS_BUILD_SMP_EMU=yes + ;; + + *-oldornogcc-*) + AC_MSG_RESULT(no; old gcc or no gcc found) + ERTS_BUILD_SMP_EMU=no + ;; + + *) + AC_MSG_RESULT(no) + ERTS_BUILD_SMP_EMU=no + ;; + esac + ;; +esac + +if test $ERTS_BUILD_SMP_EMU = yes; then + + if test $found_threads = no; then + AC_MSG_ERROR([cannot build smp enabled emulator since no thread library was found]) + fi + + AC_DEFINE(ERTS_HAVE_SMP_EMU, 1, [Define if the smp emulator is built]) + enable_threads=force +fi + +AC_SUBST(ERTS_BUILD_SMP_EMU) + + + +# +# Figure out if the emulator should use threads. The default is set above +# in the enable_threads variable. It can have the following values: +# +# no single-threaded emulator requested +# yes multi-threaded emulator requested +# force multi-threaded emulator required +# +# EMU_THR_LIB_NAME, EMU_THR_LIBS, EMU_THR_X_LIBS, and EMU_THR_DEFS is +# used by the emulator, and can (but should not) be used by applications +# that only require thread support when the emulator has thread support. +# Other applications should use ETHR_LIB_NAME, ETHR_LIBS, ETHR_X_LIBS, +# and ETHR_DEFS. +# +AC_MSG_CHECKING(whether the emulator should use threads) + +EMU_THR_LIB_NAME= +EMU_THR_X_LIBS= +EMU_THR_LIBS= +EMU_THR_DEFS= +emu_threads=no + +case "$enable_threads"-"$host_os" in + *-win32) + # The windows erlang emulator can never run without threads. + # It has to be enabled or the emulator will crash. Until that + # is fixed we force threads on win32. + enable_threads=force ;; + yes-osf*) + # The emulator hang when threads are enabled on osf + AC_MSG_ERROR(unresolved problems exist with threads on this platform) ;; + *) ;; +esac + +case "$enable_threads"-"$found_threads" in + force-yes) + emu_threads=yes + AC_MSG_RESULT(yes; thread support required and therefore forced) ;; + yes-yes) + emu_threads=yes + AC_MSG_RESULT(yes; enabled by user) ;; + unknown-yes) + case $host_os in + solaris*|linux*|darwin*|win32) + emu_threads=yes + AC_MSG_RESULT(yes; default on this platform) + ;; + *) + AC_MSG_RESULT(no; default on this platform) + ;; + esac + ;; + no-yes) + AC_MSG_RESULT(no; thread support found but disabled by user) ;; + unknown-no|no-no) + AC_MSG_RESULT(no) ;; + force-no) + AC_MSG_ERROR(thread support required but not found) ;; + yes-no) + AC_MSG_ERROR(thread support enabled by user but not found) ;; + *) + AC_MSG_ERROR(internal error) ;; +esac + +if test $emu_threads != yes; then + enable_lock_check=no + enable_lock_count=no +else + # Threads enabled for emulator + EMU_THR_LIB_NAME=$ETHR_LIB_NAME + EMU_THR_X_LIBS=$ETHR_X_LIBS + EMU_THR_LIBS=$ETHR_LIBS + EMU_THR_DEFS=$ETHR_DEFS + ENABLE_ALLOC_TYPE_VARS="$ENABLE_ALLOC_TYPE_VARS threads" + AC_MSG_CHECKING(whether lock checking should be enabled) + AC_MSG_RESULT($enable_lock_check) + if test "x$enable_lock_check" != "xno"; then + EMU_THR_DEFS="$EMU_THR_DEFS -DERTS_ENABLE_LOCK_CHECK" + fi + + AC_MSG_CHECKING(whether lock counters should be enabled) + AC_MSG_RESULT($enable_lock_count) + if test "x$enable_lock_count" != "xno"; then + EMU_THR_DEFS="$EMU_THR_DEFS -DERTS_ENABLE_LOCK_COUNT" + fi + + disable_child_waiter_thread=no + case $host_os in + solaris*) + enable_child_waiter_thread=yes + ;; + linux*) + AC_DEFINE(USE_RECURSIVE_MALLOC_MUTEX,[1], + [Define if malloc should use a recursive mutex]) + AC_MSG_CHECKING([whether dlopen() needs to be called before first call to dlerror()]) + if test "x$ETHR_THR_LIB_BASE_NAME" != "xnptl"; then + AC_DEFINE(ERTS_NEED_DLOPEN_BEFORE_DLERROR,[1], + [Define if dlopen() needs to be called before first call to dlerror()]) + AC_MSG_RESULT(yes) + else + AC_MSG_RESULT(no) + fi + if test "x$ETHR_THR_LIB_BASE_NAME" != "xnptl"; then + # Child waiter thread cannot be enabled + disable_child_waiter_thread=yes + enable_child_waiter_thread=no + fi + ;; + win32) + # Child waiter thread cannot be enabled + disable_child_waiter_thread=yes + enable_child_waiter_thread=no + ;; + *) + ;; + esac + + # Remove -D_WIN32_WINNT*, -DWINVER* and -D_GNU_SOURCE from EMU_THR_DEFS + # (defined in CFLAGS). Note that we want to keep these flags + # in ETHR_DEFS, but not in EMU_THR_DEFS. + new_emu_thr_defs= + for thr_def in $EMU_THR_DEFS; do + case $thr_def in + -D_GNU_SOURCE*|-D_WIN32_WINNT*|-DWINVER*) + ;; + *) + new_emu_thr_defs="$new_emu_thr_defs $thr_def" + ;; + esac + done + EMU_THR_DEFS=$new_emu_thr_defs + + AC_MSG_CHECKING(whether the child waiter thread should be enabled) + if test $enable_child_waiter_thread = yes; then + AC_DEFINE(ENABLE_CHILD_WAITER_THREAD,[1], + [Define if you want to enable child waiter thread]) + AC_MSG_RESULT(yes) + else + case $ERTS_BUILD_SMP_EMU-$disable_child_waiter_thread in + yes-no) + AC_MSG_RESULT([yes on SMP build, but not on non-SMP build]);; + *-yes) + AC_DEFINE(DISABLE_CHILD_WAITER_THREAD,[1], + [Define if you want to disable child waiter thread]) + AC_MSG_RESULT(no);; + *) + AC_MSG_RESULT(no);; + esac + fi +fi + +AC_SUBST(EMU_THR_LIB_NAME) +AC_SUBST(EMU_THR_X_LIBS) +AC_SUBST(EMU_THR_LIBS) +AC_SUBST(EMU_THR_DEFS) + +if test "x$enable_lock_check" = "xno"; then + EMU_LOCK_CHECKING=no +else + EMU_LOCK_CHECKING=yes +fi + +AC_SUBST(EMU_LOCK_CHECKING) + +ERTS_INTERNAL_X_LIBS= + +AC_CHECK_LIB(kstat, kstat_open, +[AC_DEFINE(HAVE_KSTAT, 1, [Define if you have kstat]) +ERTS_INTERNAL_X_LIBS="$ERTS_INTERNAL_X_LIBS -lkstat"]) + +AC_SUBST(ERTS_INTERNAL_X_LIBS) + +dnl THR_LIBS and THR_DEFS are only used by odbc +THR_LIBS=$ETHR_X_LIBS +THR_DEFS=$ETHR_DEFS + +AC_SUBST(THR_LIBS) +AC_SUBST(THR_DEFS) + +dnl ---------------------------------------------------------------------- +dnl Try to figure out where to get the termcap functions from. +dnl We use tgetent(), tgetflag(), tgetnum(), tgetstr() and tputs() +dnl ---------------------------------------------------------------------- + +TERMCAP_LIB= + +if test "x$with_termcap" != "xno" && + test "X$host" != "Xwin32"; then + # try these libs + termcap_libs="ncurses curses termcap termlib" + + for termcap_lib in $termcap_libs; do + AC_CHECK_LIB($termcap_lib, tgetent, TERMCAP_LIB="-l$termcap_lib") + if test "x$TERMCAP_LIB" != "x"; then + break + fi + done + + if test "x$TERMCAP_LIB" = "x"; then + AC_MSG_ERROR([No curses library functions found]) + fi +fi + +AC_SUBST(TERMCAP_LIB) + +if test "x$TERMCAP_LIB" != "x"; then + + AC_DEFINE(HAVE_TERMCAP, 1, [Define if termcap functions exists]) +fi + +dnl ------------- +dnl zlib +dnl ------------- + +AC_ARG_ENABLE(shared-zlib, +[ --enable-shared-zlib enable using shared zlib library + --disable-shared-zlib disable shared zlib, compile own zlib source (default)], +[ case "$enableval" in + no) enable_shared_zlib=no ;; + *) enable_shared_zlib=yes ;; + esac ], enable_shared_zlib=no) + +Z_LIB= + +if test "x$enable_shared_zlib" = "xyes" ; then + AC_CHECK_LIB(z, adler32_combine, + [Z_LIB="-lz" + AC_DEFINE(HAVE_LIBZ, 1, [Define to 1 if you have the `z' library (-lz).])], + [AC_MSG_ERROR([cannot find any shared zlib])]) +else + AC_MSG_NOTICE([Using own zlib source]) +fi + +AC_SUBST(Z_LIB) + +dnl +dnl This test kindly borrowed from Tcl +dnl +#-------------------------------------------------------------------- +# Check for the existence of the -lsocket and -lnsl libraries. +# The order here is important, so that they end up in the right +# order in the command line generated by make. Here are some +# special considerations: +# 1. Use "connect" and "accept" to check for -lsocket, and +# "gethostbyname" to check for -lnsl. +# 2. Use each function name only once: can't redo a check because +# autoconf caches the results of the last check and won't redo it. +# 3. Use -lnsl and -lsocket only if they supply procedures that +# aren't already present in the normal libraries. This is because +# IRIX 5.2 has libraries, but they aren't needed and they're +# bogus: they goof up name resolution if used. +# 4. On some SVR4 systems, can't use -lsocket without -lnsl too. +# To get around this problem, check for both libraries together +# if -lsocket doesn't work by itself. +#-------------------------------------------------------------------- + +erl_checkBoth=0 +AC_CHECK_FUNC(connect, erl_checkSocket=0, erl_checkSocket=1) +if test "$erl_checkSocket" = 1; then + AC_CHECK_LIB(socket, main, LIBS="$LIBS -lsocket", erl_checkBoth=1) +fi +if test "$erl_checkBoth" = 1; then + tk_oldLibs=$LIBS + LIBS="$LIBS -lsocket -lnsl" + AC_CHECK_FUNC(accept, erl_checkNsl=0, [LIBS=$tk_oldLibs]) +fi +AC_CHECK_FUNC(gethostbyname, , AC_CHECK_LIB(nsl, main, [LIBS="$LIBS -lnsl"])) +AC_CHECK_FUNC(gethostbyname_r,have_gethostbyname_r=yes) + +dnl +dnl These gethostbyname thingies use old style AC_DEFINE for BC with ancient +dnl autoconf... +dnl + +if test "$have_gethostbyname_r" = yes; then + # OK, so we have gethostbyname_r() - but do we know how to call it...? + # (if not, HAVE_GETHOSTBYNAME_R will not be defined at all) + case $host_os in + solaris2*) + AC_DEFINE(HAVE_GETHOSTBYNAME_R, GHBN_R_SOLARIS, + [Define to flavour of gethostbyname_r]) + ;; + aix4*) + # AIX version also needs "struct hostent_data" defn + AC_TRY_COMPILE([#include <netdb.h>], + [struct hostent_data hd;], + AC_DEFINE(HAVE_GETHOSTBYNAME_R, GHBN_R_AIX, + [Define to flavour of gethostbyname_r])) + ;; + *) + AC_EGREP_CPP(yes,[#include <stdio.h> + #ifdef __GLIBC__ + yes + #endif + ], AC_DEFINE(HAVE_GETHOSTBYNAME_R, GHBN_R_GLIBC, + [Define to flavour of gethostbyname_r])) + ;; + esac +fi + +AC_MSG_CHECKING(for working posix_openpt implementation) +AC_TRY_LINK([ +#define _XOPEN_SOURCE 600 +#include <stdlib.h> +#include <fcntl.h> +], +[ + int mfd = posix_openpt(O_RDWR); + ptsname(mfd); + grantpt(mfd); + unlockpt(mfd); + return mfd; +], working_posix_openpt=yes, working_posix_openpt=no) + +if test "X$working_posix_openpt" = "Xyes"; then + AC_DEFINE(HAVE_WORKING_POSIX_OPENPT, [1], + [Define if you have a working posix_openpt implementation]) + AC_MSG_RESULT(yes) +else + AC_MSG_RESULT(no) +fi + +dnl Check for usage of sockaddr_in in netdb.h +dnl somewhat ugly check, I check for presence of the string and that +dnl compilation works. If either fails I assume it's not needed. +dnl Seems only to be needed on a patched version of solaris2.5.1, with +dnl netdb.h version 1.18. +AC_MSG_CHECKING([if netdb.h requires netinet/in.h to be previously included]) +AC_EGREP_CPP(sockaddr_in, + [#include <netdb.h>], + AC_TRY_COMPILE([#include <netinet/in.h> + #include <netdb.h>], + [return 0;], + need_in_h=yes, + need_in_h=no), + need_in_h=no) + +if test $need_in_h = yes; then + AC_DEFINE(NETDB_H_NEEDS_IN_H,[1], + [Define if netdb.h needs struct sockaddr_in ans in.h CAN be included before]) + AC_MSG_RESULT(yes) +else + AC_MSG_RESULT(no) +fi + +dnl Check for type socklen_t +dnl +AC_MSG_CHECKING([for socklen_t]) +AC_TRY_COMPILE( [#include <sys/socket.h>], + [socklen_t test;], + have_socklen_t=yes, + have_socklen_t=no), + +if test $have_socklen_t = yes; then + AC_DEFINE(HAVE_SOCKLEN_T,[1],[Define if we have socklen_t]) + AC_MSG_RESULT(yes) +else + AC_MSG_RESULT(no) +fi + + +dnl h_errno isn't always declared in netdb.h, and with some definitions +dnl (e.g. function call for thread-safe) a simple 'extern int' may conflict +dnl (we do assume that h_errno exists at all...) +AC_CACHE_CHECK([for h_errno declaration in netdb.h], + ac_cv_decl_h_errno, +[AC_TRY_COMPILE([#include <netdb.h>], [int err = h_errno;], + ac_cv_decl_h_errno=yes, ac_cv_decl_h_errno=no)]) +if test $ac_cv_decl_h_errno = yes; then + AC_DEFINE(H_ERRNO_DECLARED,[1], + [define if h_errno is declared (in some way) in a system header file]) +fi + + +dnl ---------------------------------------------------------------------- +dnl Checks for header files. +dnl ---------------------------------------------------------------------- + +dnl We sometimes need EMU_THR_DEFS in order to find certain headers. +saved_cppflags=$CPPFLAGS +CPPFLAGS="$CPPFLAGS $EMU_THR_DEFS" + +AC_HEADER_DIRENT +AC_HEADER_STDC +AC_HEADER_SYS_WAIT +AC_HEADER_TIME + +dnl Interactive UX needs <net/errno.h> for socket related error codes. +dnl Some Linuxes needs <sys/socketio.h> instead of <sys/sockio.h> +dnl +AC_CHECK_HEADERS(fcntl.h limits.h unistd.h syslog.h dlfcn.h ieeefp.h \ + sys/stropts.h sys/sysctl.h \ + sys/ioctl.h sys/time.h sys/uio.h \ + sys/socket.h sys/sockio.h sys/socketio.h \ + net/errno.h malloc.h mach-o/dyld.h arpa/nameser.h \ + pty.h util.h utmp.h langinfo.h) + +AC_CHECK_HEADER(sys/resource.h, + [AC_DEFINE(HAVE_SYS_RESOURCE_H, 1, + [Define to 1 if you have the <sys/resource.h> header file]) + AC_CHECK_DECLS([getrlimit, setrlimit, RLIMIT_STACK], + [],[], + [#include <sys/resource.h>])], + [],[]) + +dnl Check if we have kernel poll support +have_kernel_poll=no +AC_CHECK_HEADER(sys/event.h, have_kernel_poll=kqueue) +AC_CHECK_HEADER(sys/epoll.h, have_kernel_poll=epoll) +AC_CHECK_HEADER(sys/devpoll.h, have_kernel_poll=/dev/poll) + +dnl Check for kernel SCTP support +AC_SUBST(LIBSCTP) +if test "x$enable_sctp" == "xyes" ; then + AC_CHECK_HEADER(netinet/sctp.h, + [LIBSCTP=libsctp.so.1 + AC_DEFINE(HAVE_SCTP_H, [1], + [Define to 1 if you have the <netinet/sctp.h> header file])], + [], + [#if HAVE_SYS_SOCKET_H + #include <sys/socket.h> + #endif + ]) + AC_CHECK_DECLS([SCTP_UNORDERED, SCTP_ADDR_OVER, SCTP_ABORT, + SCTP_EOF, SCTP_SENDALL, SCTP_ADDR_CONFIRMED], [], [], + [#if HAVE_SYS_SOCKET_H + #include <sys/socket.h> + #endif + #include <netinet/sctp.h> + ]) + AC_CHECK_MEMBERS([struct sctp_paddrparams.spp_pathmtu, + struct sctp_paddrparams.spp_sackdelay, + struct sctp_paddrparams.spp_flags, + struct sctp_remote_error.sre_data, + struct sctp_send_failed.ssf_data], [], [], + [#if HAVE_SYS_SOCKET_H + #include <sys/socket.h> + #endif + #include <netinet/sctp.h> + ]) +fi + +HAVE_VALGRIND=no +AC_CHECK_HEADER(valgrind/valgrind.h, HAVE_VALGRIND=yes) +AC_SUBST(HAVE_VALGRIND) + +LM_DECL_SO_BSDCOMPAT +LM_DECL_INADDR_LOOPBACK +LM_DECL_SYS_ERRLIST + +AC_CACHE_CHECK([if windows.h includes winsock2.h], + erts_cv_windows_h_includes_winsock2_h, + AC_TRY_COMPILE([#include <windows.h> + ], + [#ifndef _WINSOCK2API_ + #error winsock2.h not included + #endif + int i = 1; + ], + erts_cv_windows_h_includes_winsock2_h=yes, + erts_cv_windows_h_includes_winsock2_h=no)) +if test $erts_cv_windows_h_includes_winsock2_h = yes; then + AC_DEFINE(WINDOWS_H_INCLUDES_WINSOCK2_H, 1, \ +[Define if windows.h includes winsock2.h]) +fi + +dnl restore CPPFLAGS +CPPFLAGS=$saved_cppflags + +dnl ---------------------------------------------------------------------- +dnl Checks for typedefs, structures, and compiler characteristics. +dnl ---------------------------------------------------------------------- + +AC_C_CONST +AC_TYPE_SIGNAL +AC_TYPE_OFF_T +AC_TYPE_PID_T +AC_TYPE_SIZE_T + +AC_STRUCT_TM +LM_STRUCT_SOCKADDR_SA_LEN +LM_STRUCT_EXCEPTION + +AC_CHECK_SIZEOF(char, 1) +AC_CHECK_SIZEOF(short, $erl_xcomp_short) +AC_CHECK_SIZEOF(int, $erl_xcomp_int) +AC_CHECK_SIZEOF(long, $erl_xcomp_long) +AC_CHECK_SIZEOF(void *, $erl_xcomp_void_p) +AC_CHECK_SIZEOF(long long, $erl_xcomp_long_long) + +BITS64= + +if test $ac_cv_sizeof_void_p = 8; then + BITS64=yes +fi +AC_SUBST(BITS64) + +if test "x$ac_compiler_gnu" = "xyes"; then +AC_MSG_CHECKING([if we should add -fno-tree-copyrename to CFLAGS for computed gotos to work properly]) +AC_TRY_COMPILE([],[ + #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) + ; + #else + #error old and ok + #endif + ], + no_tree_copyrename=yes, + no_tree_copyrename=no) + +if test "x$no_tree_copyrename" = "xyes"; then + CFLAGS="$CFLAGS -fno-tree-copyrename" + AC_MSG_RESULT(yes, adjusting CFLAGS) +else + AC_MSG_RESULT(no) +fi + + + +AC_MSG_CHECKING([for broken gcc-4.3.0 compiler]) +AC_TRY_RUN([ +/* pr36339.c */ +extern void abort (void); + +typedef unsigned long my_uintptr_t; + +int check_a(my_uintptr_t tagged_ptr); + +int __attribute__((noinline)) try_a(my_uintptr_t x) +{ + my_uintptr_t heap[2]; + my_uintptr_t *hp = heap; + + hp[0] = x; + hp[1] = 0; + return check_a((my_uintptr_t)(void*)((char*)hp + 1)); +} + +int __attribute__((noinline)) check_a(my_uintptr_t tagged_ptr) +{ + my_uintptr_t *hp = (my_uintptr_t*)(void*)((char*)tagged_ptr - 1); + + if (hp[0] == 42 && hp[1] == 0) + return 0; + return -1; +} + +int main(void) +{ + if (try_a(42) < 0) + abort (); + return 0; +} +],AC_MSG_RESULT(no) +,AC_MSG_RESULT(yes) +AC_MSG_ERROR([This gcc miscompiles the Erlang runtime system; please use a different version]) +,AC_MSG_RESULT(no)) +fi + +dnl AC_CHECK_SIZEOF(size_t, 4)dnl Assumes all cross compiling is to 32bit uP +dnl +dnl The disabled one above does not include stddef.h, alas! +dnl +AC_CACHE_CHECK([size of size_t], ac_cv_sizeof_size_t, +AC_TRY_RUN([ +#include <sys/types.h> +#include <stdio.h> +#include <stdlib.h> +#include <stddef.h> +int main(int argc, char **argv) { + FILE *f = fopen("conftestval", "w"); + if (! f) + exit(1); /* Failed */ + fprintf(f, "%d\n", (int) sizeof(size_t)); + exit(0); /* OK */ +} +], ac_cv_sizeof_size_t=`cat conftestval` +, ac_cv_sizeof_size_t=0 +, ac_cv_sizeof_size_t=$erl_xcomp_sizeof_size_t)) +AC_DEFINE_UNQUOTED(SIZEOF_SIZE_T, $ac_cv_sizeof_size_t, [The number of bytes in a size_t]) + +dnl A standard size check does not include sys/types.h +dnl +AC_CACHE_CHECK([size of off_t], ac_cv_sizeof_off_t, +AC_TRY_RUN([ +#include <sys/types.h> +#include <stdio.h> +#include <stdlib.h> +#include <stddef.h> +int main(int argc, char **argv) { + FILE *f = fopen("conftestval", "w"); + if (! f) + exit(1); /* Failed */ + fprintf(f, "%d\n", (int) sizeof(off_t)); + exit(0); /* OK */ +} +], ac_cv_sizeof_off_t=`cat conftestval` +, ac_cv_sizeof_off_t=0 +, ac_cv_sizeof_off_t=$erl_xcomp_sizeof_off_t)) +AC_DEFINE_UNQUOTED(SIZEOF_OFF_T, $ac_cv_sizeof_off_t, + [The number of bytes in an off_t]) + +AC_MSG_CHECKING([int/long/void*/size_t sizes]) +AC_TRY_RUN([ +#include <stdlib.h> +#include <stddef.h> +int main(int argc, char **argv) { + if (sizeof(void *) >= 4 && + sizeof(void *) == sizeof(size_t) && + (sizeof(void *) == sizeof(int) || sizeof(void *) == sizeof(long))) { + exit(0); /* OK */ + } + exit(1); /* Failed */ +} +],AC_MSG_RESULT(ok) +,AC_MSG_RESULT(failed) +AC_MSG_ERROR([Cannot handle this combination of int/long/void*/size_t sizes]) +,AC_MSG_RESULT(ok)) + +if test "x$erl_xcomp_bigendian" != "x"; then + ac_cv_c_bigendian=$erl_xcomp_bigendian +fi + +AC_C_BIGENDIAN + +dnl ---------------------------------------------------------------------- +dnl Checks for library functions. +dnl ---------------------------------------------------------------------- + +dnl We may need the thread library and thread flags in order to find right stuff +saved_cppflags=$CPPFLAGS +CPPFLAGS="$CPPFLAGS $EMU_THR_DEFS" +saved_libs=$LIBS +LIBS="$LIBS $EMU_THR_X_LIBS" + +dnl Check if we have these, in which case we'll try to build +dnl inet_gethost with ipv6 support. +AC_CHECK_FUNC(getaddrinfo, have_getaddrinfo=yes, have_getaddrinfo=no) +if test $have_getaddrinfo = yes; then + AC_MSG_CHECKING([whether getaddrinfo accepts enough flags]) + AC_TRY_RUN([ +#include <stdlib.h> +#include <string.h> +#include <sys/socket.h> +#include <netdb.h> +int main(int argc, char **argv) { + struct addrinfo hints, *ai; + memset(&hints, 0, sizeof(hints)); + hints.ai_flags = (AI_CANONNAME|AI_V4MAPPED|AI_ADDRCONFIG); + hints.ai_socktype = SOCK_STREAM; + hints.ai_family = AF_INET6; + if (getaddrinfo("::", NULL, &hints, &ai) == 0) { + freeaddrinfo(ai); + exit(0); + } else { + exit(1); + } +} + ],, have_getaddrinfo=no, + if test "x$erl_xcomp_getaddrinfo" != "x"; then + have_getaddrinfo=$erl_xcomp_getaddrinfo + else + have_getaddrinfo=no + fi) + if test $have_getaddrinfo = yes; then + AC_MSG_RESULT(yes) + AC_DEFINE(HAVE_GETADDRINFO, [1], + [Define to 1 if you have a good `getaddrinfo' function.]) + else + AC_MSG_RESULT(no) + fi +fi +AC_CHECK_FUNCS([getnameinfo getipnodebyname getipnodebyaddr gethostbyname2]) + +AC_CHECK_FUNCS([ieee_handler fpsetmask finite isnan isinf res_gethostbyname dlopen \ + pread pwrite writev memmove strerror strerror_r strncasecmp \ + gethrtime localtime_r gmtime_r mremap memcpy mallopt \ + sbrk _sbrk __sbrk brk _brk __brk \ + flockfile fstat strlcpy strlcat setsid posix2time setlocale nl_langinfo]) +if test "X$host" = "Xwin32"; then + ac_cv_func_setvbuf_reversed=yes +fi +AC_FUNC_SETVBUF_REVERSED + +disable_vfork=false +if test "x$EMU_THR_LIB_NAME" != "x"; then + AC_MSG_CHECKING([if vfork is known to hang multithreaded applications]) + case $host_os in + osf*) + AC_MSG_RESULT(yes) + disable_vfork=true;; + *) + AC_MSG_RESULT(no);; + esac +fi + +if test $disable_vfork = false; then + AC_FUNC_VFORK + if test $ac_cv_func_vfork_works = no; then + disable_vfork=true + fi +fi + +if test $disable_vfork = true; then + AC_DEFINE(DISABLE_VFORK, 1, [Define if you want to disable vfork.]) +fi + +AC_FUNC_VPRINTF +AC_FUNC_MMAP + +dnl The AC_DEFINEs are necessary for autoheader to work. :-( +dnl for gzio +LM_CHECK_FUNC_DECL(fread, [extern int fread();],, + AC_DEFINE(HAVE_CONFLICTING_FREAD_DECLARATION,[1],[Define if you have a decl of fread that conflicts with int fread])) + +dnl Checking with TRY_LINK since putc_unlocked might be (probably is) a macro +AC_CACHE_CHECK([for putc_unlocked], + erts_cv_putc_unlocked, + AC_TRY_LINK([#include <stdio.h>], + [int res = putc_unlocked('x',stdout);], + erts_cv_putc_unlocked=yes, + erts_cv_putc_unlocked=no)) +if test $erts_cv_putc_unlocked = yes; then + AC_DEFINE(HAVE_PUTC_UNLOCKED, 1, [Define if you have putc_unlocked]) +fi + +dnl Checking with TRY_LINK since fwrite_unlocked might be a macro +AC_CACHE_CHECK([for fwrite_unlocked], + erts_cv_fwrite_unlocked, + AC_TRY_LINK([#include <stdio.h>], + [size_t res = fwrite_unlocked(NULL,sizeof(char),0,stdout);], + erts_cv_fwrite_unlocked=yes, + erts_cv_fwrite_unlocked=no)) +if test $erts_cv_fwrite_unlocked = yes; then + AC_DEFINE(HAVE_FWRITE_UNLOCKED, 1, [Define if you have fwrite_unlocked]) +fi + +dnl Need by run_erl. +AC_CHECK_FUNCS([openpty]) + +dnl ---------------------------------------------------------------------- +dnl Checks for features/quirks in the system that affects Erlang. +dnl ---------------------------------------------------------------------- + +AC_MSG_CHECKING([for sched_getaffinity/sched_setaffinity]) +AC_TRY_COMPILE([#include <sched.h>], +[ +#ifndef CPU_SETSIZE +#error no CPU_SETSIZE +#endif + int res; + cpu_set_t cpuset; + CPU_ZERO(&cpuset); + CPU_SET(1, &cpuset); + res = sched_setaffinity(0, sizeof(cpu_set_t), &cpuset); + res = sched_getaffinity(0, sizeof(cpu_set_t), &cpuset); + res = CPU_ISSET(1, &cpuset); + CPU_CLR(1, &cpuset); +], + sched_xetaffinity=yes, + sched_xetaffinity=no) +AC_MSG_RESULT([$sched_xetaffinity]) +if test $sched_xetaffinity = yes; then + AC_DEFINE(HAVE_SCHED_xETAFFINITY, 1, [Define if you have sched_getaffinity/sched_setaffinity]) +fi + + +AC_MSG_CHECKING([for pset functionality]) +AC_TRY_COMPILE([#include <sys/pset.h>], +[ + int res; + psetid_t id = PS_MYID; + int type = PS_PRIVATE; + uint_t numcpus = 1024; + processorid_t cpulist[1024]; + + res = pset_info(id, &type, &numcpus, &cpulist[0]); +], + pset_functionality=yes, + pset_functionality=no) +AC_MSG_RESULT([$pset_functionality]) +if test $pset_functionality = yes; then + AC_DEFINE(HAVE_PSET, 1, [Define if you have pset functionality]) +fi + +AC_MSG_CHECKING([for processor_bind functionality]) +AC_TRY_COMPILE([ +#include <sys/types.h> +#include <sys/processor.h> +#include <sys/procset.h> +], +[ + int res = processor_bind(P_LWPID, P_MYID, PBIND_NONE, NULL); +], + processor_bind_functionality=yes, + processor_bind_functionality=no) +AC_MSG_RESULT([$processor_bind_functionality]) +if test $processor_bind_functionality = yes; then + AC_DEFINE(HAVE_PROCESSOR_BIND, 1, [Define if you have processor_bind functionality]) +fi + + +AC_CACHE_CHECK([for 'end' symbol], + erts_cv_have_end_symbol, + [AC_TRY_LINK([], + [extern char end; {char *x = &end; *x= 0;}], + erts_cv_have_end_symbol=yes, + erts_cv_have_end_symbol=no)]) +if test $erts_cv_have_end_symbol = yes; then + AC_DEFINE(HAVE_END_SYMBOL, 1, [Define if you have the 'end' symbol]) +fi + +AC_CACHE_CHECK([for '_end' symbol], + erts_cv_have__end_symbol, + [AC_TRY_LINK([], + [extern char _end; {char *x = &_end; *x= 0;}], + erts_cv_have__end_symbol=yes, + erts_cv_have__end_symbol=no)]) +if test $erts_cv_have__end_symbol = yes; then + AC_DEFINE(HAVE__END_SYMBOL, 1, [Define if you have the '_end' symbol]) +fi + +AC_CACHE_CHECK([if __after_morecore_hook can track malloc()s core memory use], + erts_cv___after_morecore_hook_can_track_malloc, + [AC_TRY_RUN([ +#include <stdlib.h> +#ifdef HAVE_MALLOC_H +# include <malloc.h> +#endif +#if defined(HAVE_END_SYMBOL) +extern char end; +#elif defined(HAVE__END_SYMBOL) +extern char _end; +#endif +#ifndef USE_THREADS +#undef ETHR_PTHREADS +#endif + +#ifdef ETHR_PTHREADS +# ifdef ETHR_HAVE_PTHREAD_H +# include <pthread.h> +# else +# ifdef ETHR_HAVE_MIT_PTHREAD_H +# include <pthread/mit/pthread.h> +# endif +# endif +# define N_THR 5 +#else +# define N_THR 1 +#endif + +static char *heap_start = NULL; +static char *heap_end = NULL; + +void update_heap_size(void) +{ + heap_end = (char *) sbrk(0); +} + +void init_hook(void) +{ +#if defined(HAVE_END_SYMBOL) + heap_start = &end; +#elif defined(HAVE__END_SYMBOL) + heap_start = &_end; +#else + heap_start = sbrk(0); +#endif + __after_morecore_hook = update_heap_size; +} + +void (*__malloc_initialize_hook) (void) = init_hook; + +static int +check_malloc(int size) +{ + char *p = (char *) malloc(size); + if (!heap_start || !heap_end) return 0; + if (!p) return 0; + if (p < heap_start || heap_end <= p) return 0; + if (p + size < heap_start || heap_end < p + size) return 0; + return 1; +} + +#ifdef ETHR_PTHREADS +pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; +#endif + +static void * +do_tests(void *vresp) +{ + int i, ok = 0; +#ifdef ETHR_PTHREADS + if (pthread_mutex_lock(&mutex) != 0) + return NULL; +#endif + + for (i = 0; i < 10; i++) + if (!check_malloc(1000)) + goto failed; + for (i = 0; i < 100; i++) + if (!check_malloc(1)) + goto failed; + if (!check_malloc(1024*1024+1)) + goto failed; + if (!check_malloc(10*1024*1024+1)) + goto failed; + ok = 1; + + failed: +#ifdef ETHR_PTHREADS + if (pthread_mutex_unlock(&mutex) != 0) + return NULL; +#endif + if (ok) + *((int *) vresp) = 0; + return NULL; +} + + +int main(void) +{ + int res[N_THR], i; +#ifdef ETHR_PTHREADS + pthread_t tid[N_THR]; +#endif + +#if defined(HAVE_MALLOPT) && defined(M_MMAP_MAX) + (void) mallopt(M_MMAP_MAX, 0); +#endif + + for (i = 0; i < N_THR; i++) + res[i] = 1; +#ifdef ETHR_PTHREADS + for (i = 1; i < N_THR; i++) + if (pthread_create(&tid[i], NULL, do_tests, &res[i]) != 0) + return 1; +#endif + (void) do_tests(&res[0]); +#ifdef ETHR_PTHREADS + for (i = 1; i < N_THR; i++) + if (pthread_join(tid[i], NULL) != 0) + return 1; +#endif + for (i = 0; i < N_THR; i++) + if (res[i]) + return 1; + return 0; +} + ], + erts_cv___after_morecore_hook_can_track_malloc=yes, + erts_cv___after_morecore_hook_can_track_malloc=no, + if test "x$erl_xcomp_after_morecore_hook" != "x"; then + erts_cv___after_morecore_hook_can_track_malloc=$erl_xcomp_after_morecore_hook + fi)]) + +if test "x$erts_cv___after_morecore_hook_can_track_malloc" = "xyes"; then + AC_DEFINE(ERTS___AFTER_MORECORE_HOOK_CAN_TRACK_MALLOC, 1, \ +[Define if __after_morecore_hook can track malloc()s core memory use.]) +fi + +if test "x$ac_cv_func_sbrk" = "xyes"; then + AC_CACHE_CHECK([types of sbrk()s return value and argument], + erts_cv_sbrk_ret_arg_types, + [ + + erts_cv_sbrk_ret_arg_types=unknown + ret_types="void *,char *" + arg_types="intptr_t,ptrdiff_t,int,long" + save_ifs="$IFS"; IFS="," + for rtype in $ret_types; do + for atype in $arg_types; do + IFS=$save_ifs + AC_TRY_COMPILE([#include <sys/types.h> + #include <unistd.h>], + [$rtype sbrk($atype incr);], + [erts_cv_sbrk_ret_arg_types="$rtype,$atype"]) + IFS="," + if test "$erts_cv_sbrk_ret_arg_types" != "unknown"; then + break 2 + fi + done + done + IFS=$save_ifs]) + + if test "$erts_cv_sbrk_ret_arg_types" != "unknown"; then + save_ifs="$IFS"; IFS="," + read ret_type arg_type <<EOF +$erts_cv_sbrk_ret_arg_types +EOF + IFS=$save_ifs + AC_DEFINE_UNQUOTED(SBRK_RET_TYPE, $ret_type, \ +[Define the sbrk() return type.]) + AC_DEFINE_UNQUOTED(SBRK_ARG_TYPE, $arg_type, \ +[Define the sbrk() argument type.]) + fi +fi + +if test $ac_cv_func_brk = yes; then + AC_CACHE_CHECK([types of brk()s return value and argument], + erts_cv_brk_ret_arg_types, + [ + + erts_cv_brk_ret_arg_types=unknown + ret_types="int,long,char *,void *" + arg_types="void *,const void *,char *,const char *" + save_ifs="$IFS"; IFS="," + for rtype in $ret_types; do + for atype in $arg_types; do + IFS=$save_ifs + AC_TRY_COMPILE([#include <sys/types.h> + #include <unistd.h>], + [$rtype brk($atype endds);], + [erts_cv_brk_ret_arg_types="$rtype,$atype"]) + IFS="," + if test "$erts_cv_brk_ret_arg_types" != "unknown"; then + break 2 + fi + done + done + IFS=$save_ifs]) + + if test "$erts_cv_brk_ret_arg_types" != "unknown"; then + save_ifs="$IFS"; IFS="," + read ret_type arg_type <<EOF +$erts_cv_brk_ret_arg_types +EOF + IFS=$save_ifs + AC_DEFINE_UNQUOTED(BRK_RET_TYPE, $ret_type, \ +[Define the brk() return type.]) + AC_DEFINE_UNQUOTED(BRK_ARG_TYPE, $arg_type, \ +[Define the brk() argument type.]) + fi + +fi + +if test $ac_cv_func_sbrk = yes; then + + AC_CACHE_CHECK([if sbrk()/brk() wrappers can track malloc()s core memory use], + erts_cv_brk_wrappers_can_track_malloc, + [AC_TRY_RUN([ +#include <stdlib.h> +#include <sys/types.h> +#include <unistd.h> +#ifdef HAVE_DLFCN_H +# include <dlfcn.h> +#endif + +/* + * Our implementation requires that we have sbrk(), and 'end' or '_end'. + */ + +#if !defined(HAVE_SBRK) +# error no sbrk() +#endif +#if defined(HAVE_END_SYMBOL) +extern char end; +#elif defined(HAVE__END_SYMBOL) +extern char _end; +#else +# error no 'end' nor '_end' +#endif + +#ifndef USE_THREADS +#undef ETHR_PTHREADS +#endif + +#ifdef ETHR_PTHREADS +# ifdef ETHR_HAVE_PTHREAD_H +# include <pthread.h> +# else +# ifdef ETHR_HAVE_MIT_PTHREAD_H +# include <pthread/mit/pthread.h> +# endif +# endif +# define N_THR 5 +#else +# define N_THR 1 +#endif + +#define SBRK_IMPL(RET_TYPE, SBRK, ARG_TYPE) \ +RET_TYPE SBRK (ARG_TYPE); \ +static RET_TYPE (*real_ ## SBRK)(ARG_TYPE) = NULL; \ +RET_TYPE \ +SBRK (ARG_TYPE arg) \ +{ \ + RET_TYPE res; \ + if (!real_ ## SBRK) real_ ## SBRK = dlsym(RTLD_NEXT, #SBRK); \ + res = (*real_ ## SBRK)(arg); \ + if (res != (RET_TYPE) -1) heap_end = (char *) (*real_ ## SBRK)(0); \ + return res; \ +} + +#define BRK_IMPL(RET_TYPE, BRK, ARG_TYPE) \ +RET_TYPE BRK (ARG_TYPE); \ +static RET_TYPE (*real_ ## BRK)(ARG_TYPE) = NULL; \ +RET_TYPE \ +BRK (ARG_TYPE arg) \ +{ \ + RET_TYPE res; \ + if (!real_ ## BRK) real_ ## BRK = dlsym(RTLD_NEXT, #BRK); \ + res = (*real_ ## BRK)(arg); \ + if (res != (RET_TYPE) -1) heap_end = (char *) arg; \ + return res; \ +} + +static char *heap_start = NULL; +static char *heap_end = NULL; + +SBRK_IMPL(SBRK_RET_TYPE, sbrk, SBRK_ARG_TYPE) +#ifdef HAVE_BRK + BRK_IMPL(BRK_RET_TYPE, brk, BRK_ARG_TYPE) +#endif + +#ifdef HAVE__SBRK + SBRK_IMPL(SBRK_RET_TYPE, _sbrk, SBRK_ARG_TYPE) +#endif +#ifdef HAVE__BRK + BRK_IMPL(BRK_RET_TYPE, _brk, BRK_ARG_TYPE) +#endif + +#ifdef HAVE___SBRK + SBRK_IMPL(SBRK_RET_TYPE, __sbrk, SBRK_ARG_TYPE) +#endif +#ifdef HAVE___BRK + BRK_IMPL(BRK_RET_TYPE, __brk, BRK_ARG_TYPE) +#endif + +static int +check_malloc(int size) +{ + char *p = (char *) malloc(size); + if (!heap_start || !heap_end) return 0; + if (!p) return 0; + if (p < heap_start || heap_end <= p) return 0; + if (p + size < heap_start || heap_end < p + size) return 0; + return 1; +} + +#ifdef ETHR_PTHREADS +pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; +#endif + +static void * +do_tests(void *vresp) +{ + int i, ok = 0; +#ifdef ETHR_PTHREADS + if (pthread_mutex_lock(&mutex) != 0) + return NULL; +#endif + + for (i = 0; i < 10; i++) + if (!check_malloc(1000)) + goto failed; + for (i = 0; i < 100; i++) + if (!check_malloc(1)) + goto failed; + if (!check_malloc(1024*1024+1)) + goto failed; + if (!check_malloc(10*1024*1024+1)) + goto failed; + ok = 1; + + failed: +#ifdef ETHR_PTHREADS + if (pthread_mutex_unlock(&mutex) != 0) + return NULL; +#endif + if (ok) + *((int *) vresp) = 0; + return NULL; +} + + +int main(void) +{ + int res[N_THR], i; +#ifdef ETHR_PTHREADS + pthread_t tid[N_THR]; +#endif +#if defined(HAVE_END_SYMBOL) + heap_start = &end; +#elif defined(HAVE__END_SYMBOL) + heap_start = &_end; +#endif + +#if defined(HAVE_MALLOPT) && defined(M_MMAP_MAX) + (void) mallopt(M_MMAP_MAX, 0); +#endif + + for (i = 0; i < N_THR; i++) + res[i] = 1; +#ifdef ETHR_PTHREADS + for (i = 1; i < N_THR; i++) + if (pthread_create(&tid[i], NULL, do_tests, &res[i]) != 0) + return 1; +#endif + (void) do_tests(&res[0]); +#ifdef ETHR_PTHREADS + for (i = 1; i < N_THR; i++) + if (pthread_join(tid[i], NULL) != 0) + return 1; +#endif + for (i = 0; i < N_THR; i++) + if (res[i]) + return 1; + return 0; +} + ], + erts_cv_brk_wrappers_can_track_malloc=yes, + erts_cv_brk_wrappers_can_track_malloc=no, + erts_cv_brk_wrappers_can_track_malloc=no)]) + if test $erts_cv_brk_wrappers_can_track_malloc = yes; then + AC_DEFINE(ERTS_BRK_WRAPPERS_CAN_TRACK_MALLOC, 1, \ +[Define if sbrk()/brk() wrappers can track malloc()s core memory use]) + fi +fi + +dnl Restore LIBS +LIBS=$saved_libs +dnl restore CPPFLAGS +CPPFLAGS=$saved_cppflags + +LM_SYS_IPV6 +LM_SYS_MULTICAST +ERL_TIME_CORRECTION +AC_CHECK_PROG(M4, m4, m4) +dnl check to auto-enable hipe here... +if test X${enable_hipe} != Xno; then + if test -z "$M4"; then + enable_hipe=no + AC_MSG_NOTICE([HiPE disabled as no valid m4 is found in PATH]) + else + case "$ARCH-$OPSYS" in + x86-linux|amd64-linux|ppc-linux|ppc-darwin|arm-linux|amd64-freebsd|x86-freebsd|x86-sol2|amd64-sol2|ultrasparc-linux) + enable_hipe=yes + ;; + esac + fi +fi +if test X${enable_fp_exceptions} = Xauto ; then + if test X${enable_hipe} = Xyes; then + enable_fp_exceptions=yes + else + enable_fp_exceptions=no + AC_MSG_NOTICE([Floating point exceptions disabled by default in this configuration]) + fi +fi + +if test X${enable_fp_exceptions} != Xyes ; then + AC_DEFINE(NO_FPE_SIGNALS,[],[Define if floating points exceptions are non-existing/not reliable]) + FPE=unreliable +else + + AC_MSG_CHECKING([for unreliable floating point execptions]) + + + AC_TRY_RUN([ +/* fpe-test.c */ +#include <stdio.h> +#include <signal.h> +#include <stdlib.h> + +volatile int erl_fp_exception; + +/* + * We expect a single SIGFPE in this test program. + * Getting many more indicates an inadequate SIGFPE handler, + * e.g. using the generic handler on x86. + */ +static void new_fp_exception(void) +{ + if (++erl_fp_exception > 50) { + fprintf(stderr, "SIGFPE loop detected, bailing out\n"); + exit(1); + } +} + +/* Is there no standard identifier for Darwin/MacOSX ? */ +#if defined(__APPLE__) && defined(__MACH__) && !defined(__DARWIN__) +#define __DARWIN__ 1 +#endif + +/* + * Implement unmask_fpe() and check_fpe() based on CPU/OS combination + */ + +#if (defined(__i386__) || defined(__x86_64__)) && defined(__GNUC__) && !defined(__CYGWIN__) + +static void unmask_x87(void) +{ + unsigned short cw; + __asm__ __volatile__("fstcw %0" : "=m"(cw)); + cw &= ~(0x01|0x04|0x08); /* unmask IM, ZM, OM */ + __asm__ __volatile__("fldcw %0" : : "m"(cw)); +} + +static void unmask_sse2(void) +{ + unsigned int mxcsr; + __asm__ __volatile__("stmxcsr %0" : "=m"(mxcsr)); + mxcsr &= ~(0x003F|0x0680); /* clear exn flags, unmask OM, ZM, IM (not PM, UM, DM) */ + __asm__ __volatile__("ldmxcsr %0" : : "m"(mxcsr)); +} + +#if defined(__x86_64__) + +static inline int cpu_has_sse2(void) { return 1; } + +#else /* !__x86_64__ */ + +/* + * Check if an x86-32 processor has SSE2. + */ +static unsigned int xor_eflags(unsigned int mask) +{ + unsigned int eax, edx; + + eax = mask; /* eax = mask */ + __asm__("pushfl\n\t" + "popl %0\n\t" /* edx = original EFLAGS */ + "xorl %0, %1\n\t" /* eax = mask ^ EFLAGS */ + "pushl %1\n\t" + "popfl\n\t" /* new EFLAGS = mask ^ original EFLAGS */ + "pushfl\n\t" + "popl %1\n\t" /* eax = new EFLAGS */ + "xorl %0, %1\n\t" /* eax = new EFLAGS ^ old EFLAGS */ + "pushl %0\n\t" + "popfl" /* restore original EFLAGS */ + : "=d"(edx), "=a"(eax) + : "1"(eax)); + return eax; +} + +static __inline__ unsigned int cpuid_eax(unsigned int op) +{ + unsigned int eax, save_ebx; + + /* In PIC mode i386 reserves EBX. So we must save + and restore it ourselves to not upset gcc. */ + __asm__( + "movl %%ebx, %1\n\t" + "cpuid\n\t" + "movl %1, %%ebx" + : "=a"(eax), "=m"(save_ebx) + : "0"(op) + : "cx", "dx"); + return eax; +} + +static __inline__ unsigned int cpuid_edx(unsigned int op) +{ + unsigned int eax, edx, save_ebx; + + /* In PIC mode i386 reserves EBX. So we must save + and restore it ourselves to not upset gcc. */ + __asm__( + "movl %%ebx, %2\n\t" + "cpuid\n\t" + "movl %2, %%ebx" + : "=a"(eax), "=d"(edx), "=m"(save_ebx) + : "0"(op) + : "cx"); + return edx; +} + +/* The AC bit, bit #18, is a new bit introduced in the EFLAGS + * register on the Intel486 processor to generate alignment + * faults. This bit cannot be set on the Intel386 processor. + */ +static __inline__ int is_386(void) +{ + return ((xor_eflags(1<<18) >> 18) & 1) == 0; +} + +/* Newer x86 processors have a CPUID instruction, as indicated by + * the ID bit (#21) in EFLAGS being modifiable. + */ +static __inline__ int has_CPUID(void) +{ + return (xor_eflags(1<<21) >> 21) & 1; +} + +static int cpu_has_sse2(void) +{ + unsigned int maxlev, features; + static int has_sse2 = -1; + + if (has_sse2 >= 0) + return has_sse2; + has_sse2 = 0; + + if (is_386()) + return 0; + if (!has_CPUID()) + return 0; + maxlev = cpuid_eax(0); + /* Intel A-step Pentium had a preliminary version of CPUID. + It also didn't have SSE2. */ + if ((maxlev & 0xFFFFFF00) == 0x0500) + return 0; + /* If max level is zero then CPUID cannot report any features. */ + if (maxlev == 0) + return 0; + features = cpuid_edx(1); + has_sse2 = (features & (1 << 26)) != 0; + + return has_sse2; +} +#endif /* !__x86_64__ */ + +static void unmask_fpe(void) +{ + unmask_x87(); + if (cpu_has_sse2()) + unmask_sse2(); +} + +static __inline__ int check_fpe(double f) +{ + __asm__ __volatile__("fwait" : "=m"(erl_fp_exception) : "m"(f)); + if (!erl_fp_exception) + return 0; + __asm__ __volatile__("fninit"); + unmask_fpe(); + return 1; +} + +#elif defined(__sparc__) && defined(__linux__) + +#if defined(__arch64__) +#define LDX "ldx" +#define STX "stx" +#else +#define LDX "ld" +#define STX "st" +#endif + +static void unmask_fpe(void) +{ + unsigned long fsr; + + __asm__(STX " %%fsr, %0" : "=m"(fsr)); + fsr &= ~(0x1FUL << 23); /* clear FSR[TEM] field */ + fsr |= (0x1AUL << 23); /* enable NV, OF, DZ exceptions */ + __asm__ __volatile__(LDX " %0, %%fsr" : : "m"(fsr)); +} + +static __inline__ int check_fpe(double f) +{ + __asm__ __volatile__("" : "=m"(erl_fp_exception) : "em"(f)); + return erl_fp_exception; +} + +#elif (defined(__powerpc__) && defined(__linux__)) || (defined(__ppc__) && defined(__DARWIN__)) + +#if defined(__linux__) + +#include <sys/prctl.h> + +static void set_fpexc_precise(void) +{ + if (prctl(PR_SET_FPEXC, PR_FP_EXC_PRECISE) < 0) { + perror("PR_SET_FPEXC"); + exit(1); + } +} + +#elif defined(__DARWIN__) + +#include <mach/mach.h> +#include <pthread.h> + +/* + * FE0 FE1 MSR bits + * 0 0 floating-point exceptions disabled + * 0 1 floating-point imprecise nonrecoverable + * 1 0 floating-point imprecise recoverable + * 1 1 floating-point precise mode + * + * Apparently: + * - Darwin 5.5 (MacOS X <= 10.1) starts with FE0 == FE1 == 0, + * and resets FE0 and FE1 to 0 after each SIGFPE. + * - Darwin 6.0 (MacOS X 10.2) starts with FE0 == FE1 == 1, + * and does not reset FE0 or FE1 after a SIGFPE. + */ +#define FE0_MASK (1<<11) +#define FE1_MASK (1<<8) + +/* a thread cannot get or set its own MSR bits */ +static void *fpu_fpe_enable(void *arg) +{ + thread_t t = *(thread_t*)arg; + struct ppc_thread_state state; + unsigned int state_size = PPC_THREAD_STATE_COUNT; + + if (thread_get_state(t, PPC_THREAD_STATE, (natural_t*)&state, &state_size) != KERN_SUCCESS) { + perror("thread_get_state"); + exit(1); + } + if ((state.srr1 & (FE1_MASK|FE0_MASK)) != (FE1_MASK|FE0_MASK)) { +#if 0 + /* This would also have to be performed in the SIGFPE handler + to work around the MSR reset older Darwin releases do. */ + state.srr1 |= (FE1_MASK|FE0_MASK); + thread_set_state(t, PPC_THREAD_STATE, (natural_t*)&state, state_size); +#else + fprintf(stderr, "srr1 == 0x%08x, your Darwin is too old\n", state.srr1); + exit(1); +#endif + } + return NULL; /* Ok, we appear to be on Darwin 6.0 or later */ +} + +static void set_fpexc_precise(void) +{ + thread_t self = mach_thread_self(); + pthread_t enabler; + + if (pthread_create(&enabler, NULL, fpu_fpe_enable, &self)) { + perror("pthread_create"); + } else if (pthread_join(enabler, NULL)) { + perror("pthread_join"); + } +} + +#endif + +static void set_fpscr(unsigned int fpscr) +{ + union { + double d; + unsigned int fpscr[2]; + } u; + u.fpscr[0] = 0xFFF80000; + u.fpscr[1] = fpscr; + __asm__ __volatile__("mtfsf 255,%0" : : "f"(u.d)); +} + +static void unmask_fpe(void) +{ + set_fpexc_precise(); + set_fpscr(0x80|0x40|0x10); /* VE, OE, ZE; not UE or XE */ +} + +static __inline__ int check_fpe(double f) +{ + __asm__ __volatile__("" : "=m"(erl_fp_exception) : "fm"(f)); + return erl_fp_exception; +} + +#else + +#include <ieeefp.h> + +#define unmask_fpe() fpsetmask(FP_X_INV | FP_X_OFL | FP_X_DZ) + +static __inline__ int check_fpe(double f) +{ + __asm__ __volatile__("" : "=m"(erl_fp_exception) : "g"(f)); + return erl_fp_exception; +} + +#endif + +/* + * Implement SIGFPE handler based on CPU/OS combination + */ + +#if (defined(__linux__) && (defined(__i386__) || defined(__x86_64__) || defined(__sparc__) || defined(__powerpc__))) || (defined(__DARWIN__) && (defined(__i386__) || defined(__x86_64__) || defined(__ppc__))) || (defined(__FreeBSD__) && (defined(__i386__) || defined(__x86_64__))) || (defined(__OpenBSD__) && defined(__x86_64__)) || (defined(__sun__) && defined(__x86_64__)) + +#if defined(__linux__) && defined(__i386__) +#if !defined(X86_FXSR_MAGIC) +#define X86_FXSR_MAGIC 0x0000 +#endif +#elif defined(__FreeBSD__) && defined(__i386__) +#include <sys/types.h> +#include <machine/npx.h> +#elif defined(__FreeBSD__) && defined(__x86_64__) +#include <sys/types.h> +#include <machine/fpu.h> +#elif defined(__DARWIN__) +#include <machine/signal.h> +#elif defined(__OpenBSD__) && defined(__x86_64__) +#include <sys/types.h> +#include <machine/fpu.h> +#endif +#if !(defined(__OpenBSD__) && defined(__x86_64__)) +#include <ucontext.h> +#endif +#include <string.h> + +static void fpe_sig_action(int sig, siginfo_t *si, void *puc) +{ + ucontext_t *uc = puc; +#if defined(__linux__) +#if defined(__x86_64__) + mcontext_t *mc = &uc->uc_mcontext; + fpregset_t fpstate = mc->fpregs; + fpstate->mxcsr = 0x1F80; + fpstate->swd &= ~0xFF; +#elif defined(__i386__) + mcontext_t *mc = &uc->uc_mcontext; + fpregset_t fpstate = mc->fpregs; + if ((fpstate->status >> 16) == X86_FXSR_MAGIC) + ((struct _fpstate*)fpstate)->mxcsr = 0x1F80; + fpstate->sw &= ~0xFF; +#elif defined(__sparc__) && defined(__arch64__) + /* on SPARC the 3rd parameter points to a sigcontext not a ucontext */ + struct sigcontext *sc = (struct sigcontext*)puc; + sc->sigc_regs.tpc = sc->sigc_regs.tnpc; + sc->sigc_regs.tnpc += 4; +#elif defined(__sparc__) + /* on SPARC the 3rd parameter points to a sigcontext not a ucontext */ + struct sigcontext *sc = (struct sigcontext*)puc; + sc->si_regs.pc = sc->si_regs.npc; + sc->si_regs.npc = (unsigned long)sc->si_regs.npc + 4; +#elif defined(__powerpc__) +#if defined(__powerpc64__) + mcontext_t *mc = &uc->uc_mcontext; + unsigned long *regs = &mc->gp_regs[0]; +#else + mcontext_t *mc = uc->uc_mcontext.uc_regs; + unsigned long *regs = &mc->gregs[0]; +#endif + regs[PT_NIP] += 4; + regs[PT_FPSCR] = 0x80|0x40|0x10; /* VE, OE, ZE; not UE or XE */ +#endif +#elif defined(__DARWIN__) +#if defined(__x86_64__) + mcontext_t mc = uc->uc_mcontext; + struct __darwin_x86_float_state64 *fpstate = &mc->__fs; + fpstate->__fpu_mxcsr = 0x1F80; + *(unsigned short *)&fpstate->__fpu_fsw &= ~0xFF; +#elif defined(__i386__) + mcontext_t mc = uc->uc_mcontext; + struct __darwin_i386_float_state *fpstate = &mc->__fs; + fpstate->__fpu_mxcsr = 0x1F80; + *(unsigned short *)&fpstate->__fpu_fsw &= ~0xFF; +#elif defined(__ppc__) + mcontext_t mc = uc->uc_mcontext; + mc->ss.srr0 += 4; + mc->fs.fpscr = 0x80|0x40|0x10; +#endif +#elif defined(__FreeBSD__) && defined(__x86_64__) + mcontext_t *mc = &uc->uc_mcontext; + struct savefpu *savefpu = (struct savefpu*)&mc->mc_fpstate; + struct envxmm *envxmm = &savefpu->sv_env; + envxmm->en_mxcsr = 0x1F80; + envxmm->en_sw &= ~0xFF; +#elif defined(__FreeBSD__) && defined(__i386__) + mcontext_t *mc = &uc->uc_mcontext; + union savefpu *savefpu = (union savefpu*)&mc->mc_fpstate; + if (mc->mc_fpformat == _MC_FPFMT_XMM) { + struct envxmm *envxmm = &savefpu->sv_xmm.sv_env; + envxmm->en_mxcsr = 0x1F80; + envxmm->en_sw &= ~0xFF; + } else { + struct env87 *env87 = &savefpu->sv_87.sv_env; + env87->en_sw &= ~0xFF; + } +#elif defined(__OpenBSD__) && defined(__x86_64__) + struct fxsave64 *fxsave = uc->sc_fpstate; + fxsave->fx_mxcsr = 0x1F80; + fxsave->fx_fsw &= ~0xFF; +#elif defined(__sun__) && defined(__x86_64__) + mcontext_t *mc = &uc->uc_mcontext; + struct fpchip_state *fpstate = &mc->fpregs.fp_reg_set.fpchip_state; + fpstate->mxcsr = 0x1F80; + fpstate->sw &= ~0xFF; +#endif + new_fp_exception(); +} + +static void catch_sigfpe(void) +{ + struct sigaction act; + + memset(&act, 0, sizeof act); + act.sa_sigaction = fpe_sig_action; + act.sa_flags = SA_SIGINFO; + sigaction(SIGFPE, &act, NULL); +} + +#else + +static void fpe_sig_handler(int sig) +{ + new_fp_exception(); +} + +static void catch_sigfpe(void) +{ + signal(SIGFPE, fpe_sig_handler); +} + +#endif + +/* + * Generic test code + */ + +static void do_init(void) +{ + catch_sigfpe(); + unmask_fpe(); +} + +double a = 3.23e133; +double b = 3.57e257; +double res; + +void do_fmul(void) +{ + res = a * b; +} + +int do_check(void) +{ + if (check_fpe(res)) { + fprintf(stderr, "res = %g, FPE worked\n", res); + return 0; + } else { + fprintf(stderr, "res = %g, FPE failed\n", res); + return 1; + } +} + +int main(int argc, const char **argv) +{ + if (argc == 3) { + a = atof(argv[1]); + b = atof(argv[2]); + } + do_init(); + do_fmul(); + return do_check(); +} +], erl_ok=reliable, erl_ok=unreliable, erl_ok=unreliable) + if test $erl_ok = unreliable; then + AC_DEFINE(NO_FPE_SIGNALS,[], + [Define if floating points exceptions are non-existing/not reliable]) + AC_MSG_RESULT([unreliable; testing in software instead]) + FPE=unreliable + else + AC_MSG_RESULT(reliable) + FPE=reliable + fi +fi + +case $ARCH-$OPSYS in + amd64-darwin*|x86-darwin*) + AC_MSG_CHECKING([For modern (leopard) style mcontext_t]) + AC_TRY_COMPILE([ + #include <stdlib.h> + #include <sys/types.h> + #include <unistd.h> + #include <mach/mach.h> + #include <pthread.h> + #include <machine/signal.h> + #include <ucontext.h> + ],[ + #if defined(__APPLE__) && defined(__MACH__) && !defined(__DARWIN__) + #define __DARWIN__ 1 + #endif + + #ifndef __DARWIN__ + #error inpossible + #else + + mcontext_t mc = NULL; + int x = mc->__fs.__fpu_mxcsr; + + #endif + ],darwin_mcontext_leopard=yes, + darwin_mcontext_leopard=no) + if test X"$darwin_mcontext_leopard" = X"yes"; then + AC_DEFINE(DARWIN_MODERN_MCONTEXT,[],[Modern style mcontext_t in MacOSX]) + AC_MSG_RESULT(yes) + else + AC_MSG_RESULT(no) + fi + ;; + *) + darwin_mcontext_leopard=no + ;; +esac + + + + + + +dnl +dnl Some operating systems allow you to redefine FD_SETSIZE to be able +dnl to select on more than the default number of file descriptors. +dnl We first discovered this in BSD/OS where the default is ridiculously +dnl low (256). But since we use a lot of file descriptors we found the +dnl need to go over the limit in other os's as well. Since FD_SETSIZE +dnl must be defined before pulling in sys/types.h the actual number +dnl of file descriptors is set in acconfig.h and will thus be in config.h +dnl which *always* should be included first. +dnl + +AC_MSG_CHECKING([whether to redefine FD_SETSIZE]) +case $host_os in + bsdi*) + AC_DEFINE(REDEFINE_FD_SETSIZE,[],[Define if you wish to redefine FD_SETSIZE to be able to select on more fd]) + AC_MSG_RESULT(yes) + ;; + *) + AC_MSG_RESULT(no) + ;; +esac + + + +dnl ---------------------------------------------------------------------- +dnl Tests related to configurable options given on command line +dnl (using the --disable, --enable and --with switches). +dnl ---------------------------------------------------------------------- + +# +# Check if we should compile TSP app +# + +TSP_APP= +if test X${enable_tsp} = Xyes; then + TSP_APP=tsp +fi +AC_SUBST(TSP_APP) + +# +# Check if we should build hybrid emulator +# + +AC_MSG_CHECKING([whether a hybrid heap emulator should be built]) +case $enable_hybrid_heap-$host_os in + yes-*) + AC_MSG_RESULT([yes; enabled by user]) + ERTS_BUILD_HYBRID_EMU=yes;; + no-*) + AC_MSG_RESULT([no; disabled by user]) + ERTS_BUILD_HYBRID_EMU=no;; + *-win32|*-vxworks|*-ose) # vxworks and ose have their own "configure scripts"... + AC_MSG_RESULT([no; default on this platform]) + ERTS_BUILD_HYBRID_EMU=no;; + *) + AC_MSG_RESULT([yes; default on this platform]) + ERTS_BUILD_HYBRID_EMU=yes;; +esac + + +if test $ERTS_BUILD_HYBRID_EMU = yes; then + AC_DEFINE(ERTS_HAVE_HYBRID_EMU, 1, [Define if the hybrid emulator is built]) +fi + +AC_SUBST(ERTS_BUILD_HYBRID_EMU) + +# +# Check if we should enable HiPE. +# + +HIPE_ENABLED= +HIPE_HELPERS= + +dnl if not disabled, autoenable HiPE on known supported platforms +dnl done up where floating point is checked, need to descide there already... + +if test X${enable_hipe} = Xyes; then + if test X$ac_cv_sizeof_void_p != X4 -a X$ARCH != Xamd64 -a X$ARCH != Xppc64; then + AC_MSG_WARN([HiPE is not supported in 64-bit builds]) + elif test X$FPE != Xreliable -a X$ARCH != Xarm; then + AC_MSG_WARN([HiPE is not supported on $ARCH without reliable floating-point exceptions]) + else + HIPE_ENABLED=yes + AC_DEFINE(HIPE,[1],[Define to enable HiPE]) + HIPE_HELPERS="xmerl syntax_tools edoc" + ENABLE_ALLOC_TYPE_VARS="$ENABLE_ALLOC_TYPE_VARS hipe" + fi +fi +AC_SUBST(HIPE_HELPERS) +AC_SUBST(HIPE_ENABLED) + +# +# Check if Erlang libraries should be compiled to native code. +# +NATIVE_LIBS_ENABLED= +if test X${enable_native_libs} = Xyes -a X${HIPE_ENABLED} = Xyes; then + NATIVE_LIBS_ENABLED=yes +fi +AC_SUBST(NATIVE_LIBS_ENABLED) + +# +# Check if HiPE should use a standard installation of perfctr. +# +AC_SUBST(USE_PERFCTR) +if test "x$HIPE_ENABLED" = "xyes" ; then + if test "x$with_perfctr" = "x" ; then + AC_CHECK_LIB(perfctr, vperfctr_info, [USE_PERFCTR=1 + AC_DEFINE(USE_PERFCTR,[1],[Define to enable hrvtime() on Linux systems with perfctr extension])]) + elif test "x$with_perfctr" != "xno" ; then + USE_PERFCTR=1 + fi +fi + +# +# Check if we should use elib_malloc. +# + +if test X${enable_elib_malloc} = Xyes; then + AC_DEFINE(ENABLE_ELIB_MALLOC,[],[Define to enable use of elib_malloc (a malloc() replacement)]) + AC_DEFINE(ELIB_HEAP_SBRK,[],[Elib sbrk]) + AC_DEFINE(ELIB_ALLOC_IS_CLIB,[],[Use elib malloc as clib]) + AC_DEFINE(ELIB_SORTED_BLOCKS,[],[Define to enable the use of sorted blocks when using elib_malloc]) +fi + +# +# Check for working poll(). +# +AC_MSG_CHECKING([for working poll()]) +if test "x$erl_xcomp_poll" != "x"; then + poll_works=$erl_xcomp_poll +else +AC_TRY_RUN([ +#include <poll.h> +main() +{ +#ifdef _POLL_EMUL_H_ + exit(1); /* Implemented using select() -- fail */ +#else + struct pollfd fds[1]; + int fd; + fd = open("/dev/null", 1); + fds[0].fd = fd; + fds[0].events = POLLIN; + fds[0].revents = 0; + if (poll(fds, 1, 0) < 0 || (fds[0].revents & POLLNVAL) != 0) { + exit(1); /* Does not work for devices -- fail */ + } + exit(0); +#endif +} +], poll_works=true, poll_works=false, poll_works=false) +fi +case $poll_works in +true) + AC_DEFINE(ERTS_USE_POLL, 1, [Define if poll() should be used instead of select()]) + AC_MSG_RESULT(ok) + ;; +*) + # + # The USE_SELECT define is used by the ssl application (should not + # be used by erts). + # + AC_DEFINE(USE_SELECT, 1, [Define if select() should be used instead of poll()]) + AC_MSG_RESULT(broken or based on select()) + ;; +esac + +# +# If kqueue() found, check that it can be selected or polled on... +# +if test $have_kernel_poll = kqueue; then + if test $poll_works = true; then + kqueue_with=poll + else + kqueue_with=select + fi + AC_MSG_CHECKING([whether kqueue() fd can be ${kqueue_with}()ed on]) + AC_TRY_RUN([ +#include <stdlib.h> +#include <sys/types.h> +#include <sys/event.h> +#include <sys/time.h> +#ifdef ERTS_USE_POLL +#include <poll.h> +#else +#include <unistd.h> +#endif +int main(void) { + int kq = kqueue(); + if (kq < 0) return 2; + { +#ifdef ERTS_USE_POLL + struct pollfd pfds = {kq, POLLIN, 0}; + if (poll(&pfds, 1, 0) < 0) return 1; +#else + struct timeval tv = {0, 0}; + fd_set set; FD_ZERO(&set); FD_SET(kq, &set); + if (select(kq+1, &set, NULL, NULL, &tv) < 0) return 1; +#endif + } + return 0; +} + ], ok_kqueue=true, ok_kqueue=false, ok_kqueue=false) + if test $ok_kqueue = true; then + AC_MSG_RESULT(yes); + else + AC_MSG_RESULT(no); + have_kernel_poll=no + fi +fi + +# +# If epoll() found, check that it is level triggered. +# +if test $have_kernel_poll = epoll; then + AC_MSG_CHECKING([whether epoll is level triggered]) + AC_TRY_COMPILE([#include <sys/epoll.h>],[ + #ifdef EPOLLET + /* Edge triggered option exist, assume level triggered + is default */ + ; + #else + /* No edge triggered option exist; assume edge + triggered only */ + #error No EPOLLET + #endif + ], + level_triggered_epoll=yes, + [level_triggered_epoll=no + have_kernel_poll=no]) + AC_MSG_RESULT([$level_triggered_epoll]) +fi +# +# Check if we should enable kernel poll support +# +AC_MSG_CHECKING(whether kernel poll support should be enabled) +ERTS_ENABLE_KERNEL_POLL=no +case $enable_kernel_poll-$have_kernel_poll in + no-*) + AC_MSG_RESULT(no; disabled by user);; + yes-no) + AC_MSG_ERROR(no; kernel poll support requested but not found);; + *-no) + AC_MSG_RESULT(no);; + *) + case $have_kernel_poll in + epoll) + AC_DEFINE(HAVE_SYS_EPOLL_H, 1, [Define if you have the <sys/epoll.h> header file.]);; + /dev/poll) + AC_DEFINE(HAVE_SYS_DEVPOLL_H, 1, [Define if you have <sys/devpoll.h> header file.]);; + kqueue) + AC_DEFINE(HAVE_SYS_EVENT_H, 1, [Define if you have <sys/event.h> header file.]);; + *) + AC_MSG_ERROR(configure.in need to be updated);; + esac + ERTS_ENABLE_KERNEL_POLL=yes + AC_DEFINE(ERTS_ENABLE_KERNEL_POLL, 1, [Define if you have kernel poll and want to use it]) + AC_MSG_RESULT([yes; $have_kernel_poll]);; +esac +AC_SUBST(ERTS_ENABLE_KERNEL_POLL) + +AC_MSG_CHECKING([whether putenv() stores a copy of the key-value pair]) +AC_TRY_RUN([ +#include <stdlib.h> +int main(void) { + int i; + char *env; + char buf[10]; + for (i = 0; i < 7; i++) + buf[i] = 'X'; + buf[i] = '\0'; + buf[3] = '='; + if (putenv(buf) != 0) + return 1; + for (i = 4; i < 7; i++) + buf[i] = 'Y'; + env = getenv("XXX"); + if (!env) + return 2; + for (i = 0; i < 3; i++) + if (env[i] != 'X') + return 3; + for (i = 0; i < 3; i++) + buf[i] = 'Y'; + env = getenv("XXX"); + if (!env) + return 4; + for (i = 0; i < 3; i++) + if (env[i] != 'X') + return 5; + return 0; +} +], copying_putenv=yes, copying_putenv=no, copying_putenv=no) +if test $copying_putenv = yes; then + AC_DEFINE(HAVE_COPYING_PUTENV,[1],[Define if you have a putenv() that stores a copy of the key-value pair]) +fi +AC_MSG_RESULT($copying_putenv) + +dnl ---------------------------------------------------------------------- +dnl Stuff that should be moved into their respective application +dnl ---------------------------------------------------------------------- + +dnl crypto +#-------------------------------------------------------------------- +# Dynamic Erlang Drivers +# +# Linking to produce dynamic Erlang drivers to be loaded by Erlang's +# Dynamic Driver Loader and Linker (DDLL). Below the prefix DED is an +# abbreviation for `Dynamic Erlang Driver'. +# +# For DED we need something quite sloppy, which allows undefined references +# (notably driver functions) in the resulting shared library. +# Example of Makefile rule (and settings of macros): +# +# LIBS = @LIBS@ +# LD = @DED_LD@ +# LDFLAGS = @DED_LDFLAGS@ +# soname = @ldsoname@ +# +# my_drv.so: my_drv.o my_utils.o +# $(LD) $(LDFLAGS) $(soname) $@ -o $@ $^ -lc $(LIBS) +# +#-------------------------------------------------------------------- + +DED_INCLUDE="-I${ERL_TOP}/erts/emulator/beam -I${ERL_TOP}/erts/include -I${ERL_TOP}/erts/include/$host" + +DED_CFLAGS="$DED_INCLUDE $CFLAGS $CPPFLAGS $EMU_THR_DEFS" +if test "x$GCC" = xyes; then + DED_CFLAGS="$DED_CFLAGS -fPIC" +fi + +STATIC_CFLAGS="" + +# If DED_LD is set in environment, we expect all DED variables to be specified +# (cross compiling) +if test "x$DED_LD" = "x"; then + +if test "x$LD" = "x"; then + DED_LD=ld +else + DED_LD=$LD +fi +DED_LD_FLAG_RUNTIME_LIBRARY_PATH="-R" + +case $host_os in + win32) + DED_LD=ld.sh + DED_LDFLAGS="-dll" + DED_LD_FLAG_RUNTIME_LIBRARY_PATH= + ;; + solaris2*|sysv4*) + DED_LDFLAGS="-G" + if test X${enable_m64_build} = Xyes; then + DED_LDFLAGS="-64 $DED_LDFLAGS" + fi + ;; + aix4*) + DED_LDFLAGS="-G -bnoentry -bexpall" + ;; + freebsd2*) + # Non-ELF GNU linker + DED_LDFLAGS="-Bshareable" + ;; + darwin*) + # Mach-O linker: a shared lib and a loadable + # object file is not the same thing. + DED_LDFLAGS="-bundle -flat_namespace -undefined suppress" + case $ARCH in + amd64) + DED_LDFLAGS="-m64 $DED_LDFLAGS" + ;; + *) + if test X${enable_darwin_universal} != Xyes; then + DED_LDFLAGS="-m32 $DED_LDFLAGS" + fi + ;; + esac + if test X${enable_darwin_universal} = Xyes; then + DED_LDFLAGS="-arch ppc -arch i386 $DED_LDFLAGS" + fi + DED_CFLAGS="$DED_CFLAGS -fno-common" + DED_LD="$CC" + DED_LD_FLAG_RUNTIME_LIBRARY_PATH= + STATIC_CFLAGS="-mdynamic-no-pic" + ;; + linux*) + DED_LD="$CC" + DED_LDFLAGS="-shared -Wl,-Bsymbolic" + DED_LD_FLAG_RUNTIME_LIBRARY_PATH= + if test X${enable_m64_build} = Xyes; then + DED_LDFLAGS="-m64 $DED_LDFLAGS" + fi + ;; + freebsd*) + DED_LD="$CC" + DED_LDFLAGS="-shared" + if test X${enable_m64_build} = Xyes; then + DED_LDFLAGS="-m64 $DED_LDFLAGS" + fi + ;; + osf*) + # NOTE! Whitespace after -rpath is important. + DED_LD_FLAG_RUNTIME_LIBRARY_PATH="-rpath " + DED_LDFLAGS="-shared -expect_unresolved '*'" + ;; + *) + # assume GNU linker and ELF + DED_LDFLAGS="-shared" + # GNU linker has no option for 64bit build, should not propagate -m64 + ;; +esac + +fi + +AC_MSG_CHECKING(for compiler flags for loadable drivers) +AC_MSG_RESULT([$DED_CFLAGS]) +AC_MSG_CHECKING(for linker for loadable drivers) +AC_MSG_RESULT([$DED_LD]) +AC_MSG_CHECKING(for linker flags for loadable drivers) +AC_MSG_RESULT([$DED_LDFLAGS]) +AC_MSG_CHECKING(for 'runtime library path' linker flag) +if test "x$DED_LD_FLAG_RUNTIME_LIBRARY_PATH" != "x"; then + AC_MSG_RESULT([$DED_LD_FLAG_RUNTIME_LIBRARY_PATH]) +else + AC_MSG_RESULT([not found]) +fi + +AC_SUBST(DED_CFLAGS) +AC_SUBST(DED_LD) +AC_SUBST(DED_LDFLAGS) +AC_SUBST(DED_LD_FLAG_RUNTIME_LIBRARY_PATH) +AC_SUBST(STATIC_CFLAGS) + +dnl +dnl We should look for a compiler that handles jump tables, for beam_emu +dnl to be optimized +dnl + +LM_FIND_EMU_CC + +dnl +dnl SSL, SSH and CRYPTO need the OpenSSL libraries +dnl +dnl Check flags --with-ssl, --without-ssl --with-ssl=PATH. +dnl If no option is given or --with-ssl is set without a path then we +dnl search for OpenSSL libraries and header files in the standard locations. +dnl If set to --without-ssl we disable the use of SSL, SSH and CRYPTO. +dnl If set to --with-ssl=PATH we use that path as the prefix, i.e. we +dnl use "PATH/include" and "PATH/lib". + +AC_SUBST(SSL_INCLUDE) +AC_SUBST(SSL_ROOT) +AC_SUBST(SSL_LIBDIR) +AC_SUBST(SSL_DYNAMIC_ONLY) +AC_SUBST(SSL_LINK_WITH_KERBEROS) +AC_SUBST(STATIC_KERBEROS_LIBS) +AC_SUBST(SSL_LINK_WITH_ZLIB) +AC_SUBST(STATIC_ZLIB_LIBS) +AC_SUBST(OPENSSL_CMD) + +AC_ARG_WITH(ssl-zlib, +[ --with-ssl-zlib=PATH specify location of ZLib to be used by OpenSSL + --with-ssl-zlib link SSL with Zlib (default if found) + --without-ssl-zlib don't link SSL with ZLib]) + + +if test "x$with_ssl_zlib" = "xno"; then + SSL_LINK_WITH_ZLIB=no + STATIC_ZLIB_LIBS= +elif test "x$with_ssl_zlib" = "xyes" -o "x$with_ssl_zlib" = "x" ;then + if test "x$MIXED_CYGWIN" = "xyes"; then + SSL_LINK_WITH_ZLIB=no + STATIC_ZLIB_LIBS= + else + SSL_LINK_WITH_ZLIB=no + STATIC_ZLIB_LIBS= + AC_MSG_CHECKING(for static ZLib to be used by SSL in standard locations) + for dir in /usr/local /usr/sfw /usr /usr/pkg \ + /usr/local/openssl /usr/lib/openssl /usr/openssl \ + /usr/local/ssl /usr/lib/ssl /usr/ssl + do + if test "x$ac_cv_sizeof_void_p" = "x8"; then + if test -f "$dir/lib64/libz.a"; then + SSL_LINK_WITH_ZLIB=yes + STATIC_ZLIB_LIBS="$dir/lib64/libz.a" + break + elif test -f "$dir/lib/64/libz.a"; then + SSL_LINK_WITH_ZLIB=yes + STATIC_ZLIB_LIBS="$dir/lib/64/libz.a" + break + fi + fi + if test -f "$dir/lib/libz.a"; then + SSL_LINK_WITH_ZLIB=yes + STATIC_ZLIB_LIBS="$dir/lib/libz.a" + break + fi + done + if test "x$SSL_LINK_WITH_ZLIB" = "xno"; then + AC_MSG_RESULT([no]) + else + AC_MSG_RESULT([$STATIC_ZLIB_LIBS]) + fi + fi +else + SSL_LINK_WITH_ZLIB=no + STATIC_ZLIB_LIBS= + if test -f "$with_ssl_zlib/libz.a"; then + SSL_LINK_WITH_ZLIB=yes + STATIC_ZLIB_LIBS=$with_ssl_zlib/libz.a + elif test -f "$with_ssl_zlib/lib/libz.a"; then + SSL_LINK_WITH_ZLIB=yes + STATIC_ZLIB_LIBS=$with_ssl_zlib/lib/libz.a + fi + if test "x$ac_cv_sizeof_void_p" = "x8"; then + if test -f "$with_ssl_zlib/lib64/libz.a"; then + SSL_LINK_WITH_ZLIB=yes + STATIC_ZLIB_LIBS=$with_ssl_zlib/lib64/libz.a + elif test -f "$with_ssl_zlib/lib/64/libz.a"; then + SSL_LINK_WITH_ZLIB=yes + STATIC_ZLIB_LIBS=$with_ssl_zlib/lib/64/libz.a + fi + fi + if test "x$SSL_LINK_WITH_ZLIB" = "xno"; then + AC_MSG_ERROR(Invalid path to option --with-ssl-zlib=PATH) + fi +fi + + +AC_ARG_WITH(ssl, +[ --with-ssl=PATH specify location of OpenSSL include and lib + --with-ssl use SSL (default) + --without-ssl don't use SSL]) + +AC_ARG_ENABLE(dynamic-ssl-lib, +[ --enable-dynamic-ssl-lib enable using dynamic openssl libraries + --disable-dynamic-ssl-lib disable using dynamic openssl libraries], +[ case "$enableval" in + no) enable_dynamic_ssl=no ;; + *) enable_dynamic_ssl=yes ;; + esac ], enable_dynamic_ssl=yes) + +#---------------------------------------------------------------------- +# We actually might do the SSL tests twice due to late discovery of +# kerberos problems with static linking, in case we redo it all trying +# dynamic SSL libraries instead. +#---------------------------------------------------------------------- + +ssl_done=no + +while test "x$ssl_done" != "xyes"; do + +ssl_done=yes # Default only one run + +# Remove all SKIP files from previous runs +for a in ssl crypto ssh; do + /bin/rm -f $ERL_TOP/lib/$a/SKIP +done + +SSL_DYNAMIC_ONLY=$enable_dynamic_ssl + +if test "x$with_ssl" = "xno"; then + SSL_APP= + CRYPTO_APP= + SSH_APP= + for a in ssl crypto ssh; do + echo "User gave --without-ssl option" > $ERL_TOP/lib/$a/SKIP + done +elif test "x$with_ssl" = "xyes" -o "x$with_ssl" = "x" ;then + # On windows, we could try to find the installation + # of Shining Light OpenSSL, which can be found by poking in + # the uninstall section in the registry, it's worth a try... + extra_dir="" + if test "x$MIXED_CYGWIN" = "xyes"; then + AC_CHECK_PROG(REGTOOL, regtool, regtool, false) + if test "$ac_cv_prog_REGTOOL" != false; then + wrp="/machine/software/microsoft/windows/currentversion/" + urp="uninstall/openssl_is1/inno setup: app path" + rp="$wrp$urp" + if regtool -q get "$rp" > /dev/null; then + ssl_install_dir=`regtool -q get "$rp"` + # Try hard to get rid of spaces... + if cygpath -d "$ssl_install_dir" > /dev/null 2>&1; then + ssl_install_dir=`cygpath -d "$ssl_install_dir"` + fi + extra_dir=`cygpath $ssl_install_dir` + fi + fi + fi + # We search for OpenSSL in the common OS standard locations. + SSL_APP=ssl + CRYPTO_APP=crypto + SSH_APP=ssh + + AC_MSG_CHECKING(for OpenSSL >= 0.9.7 in standard locations) + for dir in $extra_dir /cygdrive/c/OpenSSL \ + /usr/local /usr/sfw /opt/local /usr /usr/pkg \ + /usr/local/openssl /usr/lib/openssl /usr/openssl \ + /usr/local/ssl /usr/lib/ssl /usr/ssl + do + if test -f $dir/include/openssl/opensslv.h; then + is_real_ssl=yes + SSL_ROOT="$dir" + if test "x$MIXED_CYGWIN" = "xyes" ; then + if test -f "$dir/lib/VC/ssleay32.lib" -o \ + -f "$dir/lib/VC/openssl.lib"; then + SSL_LIBDIR="$dir/lib/VC" + elif test -f "$dir/lib/ssleay32.lib" -o \ + -f "$dir/lib/openssl.lib"; then + SSL_LIBDIR="$dir/lib" + else + is_real_ssl=no + fi + else + if test "x$ac_cv_sizeof_void_p" = "x8"; then + if test -f "$dir/lib64/libcrypto.a"; then + SSL_LIBDIR="$dir/lib64" + elif test -f "$dir/lib/64/libcrypto.a"; then + SSL_LIBDIR="$dir/lib/64" + elif test -f "$dir/lib64/libcrypto.so"; then + SSL_LIBDIR="$dir/lib64" + elif test -f "$dir/lib/64/libcrypto.so"; then + SSL_LIBDIR="$dir/lib/64" + else + SSL_LIBDIR="$dir/lib" + fi + else + SSL_LIBDIR="$dir/lib" + fi + fi + if test '!' -f $SSL_LIBDIR/libcrypto.a; then + SSL_DYNAMIC_ONLY=yes + fi + SSL_BINDIR="$dir/bin" +dnl Should one use EXEEXT or ac_exeext? + if test -f "$SSL_BINDIR/openssl$EXEEXT"; then + if "$SSL_BINDIR/openssl" version > /dev/null 2>&1; then + OPENSSL_CMD="$SSL_BINDIR/openssl" + else + is_real_ssl=no + fi + else + is_real_ssl=no + fi + if test "x$is_real_ssl" = "xyes" ; then + SSL_INCLUDE="-I$dir/include" + old_CPPFLAGS=$CPPFLAGS + CPPFLAGS=$SSL_INCLUDE + AC_EGREP_CPP(yes,[ +#include <openssl/opensslv.h> +#if OPENSSL_VERSION_NUMBER >= 0x0090700fL + yes +#endif + ],[ + ssl_found=yes + ],[ + SSL_APP= + ssl_found=no + ]) + CPPFLAGS=$old_CPPFLAGS + if test "x$ssl_found" = "xyes"; then + if test "x$MIXED_CYGWIN" = "xyes" ; then + ssl_linkable=yes + else + saveCFLAGS="$CFLAGS" + saveLDFLAGS="$LDFLAGS" + saveLIBS="$LIBS" + CFLAGS="$CFLAGS $SSL_INCLUDE" + LDFLAGS="$LDFLAGS -L$SSL_LIBDIR" + LIBS="-lcrypto" + AC_TRY_LINK([ + #include <stdio.h> + #include <openssl/hmac.h>], + [ + HMAC_CTX hc; + HMAC_CTX_init(&hc); + ], + [ssl_linkable=yes], + [ssl_linkable=no]) + CFLAGS="$saveCFLAGS" + LDFLAGS="$saveLDFLAGS" + LIBS="$saveLIBS" + fi + fi + if test "x$ssl_found" = "xyes" -a "x$ssl_linkable" = "xyes" ; then + AC_MSG_RESULT([$dir]) + break; + fi + fi + fi + done + + if test "x$ssl_found" != "xyes" ; then + dnl + dnl If no SSL found above, check whether we are running on OpenBSD. + dnl + case $host_os in + openbsd*) + if test -f /usr/include/openssl/opensslv.h; then + # Trust OpenBSD to have everything the in the correct locations. + ssl_found=yes + ssl_linkable=yes + SSL_ROOT="/usr/sbin" + AC_MSG_RESULT([$SSL_ROOT]) + SSL_LIB="/usr/lib" + SSL_BINDIR="/usr/sbin" + OPENSSL_CMD="$SSL_BINDIR/openssl" + dnl OpenBSD requires us to link with -L and -l + SSL_DYNAMIC_ONLY="yes" + fi + ;; + esac + fi +dnl Now, certain linuxes have a 64bit libcrypto +dnl that cannot build shared libraries (i.e. not PIC) +dnl One could argue that this is wrong, but +dnl so it is - be adoptable + if test "x$ssl_found" = "xyes" -a "x$ssl_linkable" = "xyes" -a "x$SSL_DYNAMIC_ONLY" != "xyes" ; then + case $host_os in + linux*) + saveCFLAGS="$CFLAGS" + saveLDFLAGS="$LDFLAGS" + saveLIBS="$LIBS" + CFLAGS="$DED_CFLAGS $SSL_INCLUDE" + LDFLAGS="$DED_LDFLAGS" + LIBS="$SSL_LIBDIR/libcrypto.a $STATIC_ZLIB_LIBS" + AC_TRY_LINK([ + #include <stdio.h> + #include <openssl/hmac.h>], + [ + HMAC_CTX hc; + HMAC_CTX_init(&hc); + ], + [ssl_dyn_linkable=yes], + [ssl_dyn_linkable=no]) + CFLAGS="$saveCFLAGS" + LDFLAGS="$saveLDFLAGS" + LIBS="$saveLIBS" + if test "x$ssl_dyn_linkable" != "xyes"; then + SSL_DYNAMIC_ONLY=yes + AC_MSG_WARN([SSL will be linked against dynamic lib as static lib is not purely relocatable]) + fi + ;; + esac + fi + + + + + if test "x$ssl_found" != "xyes" -o "x$ssl_linkable" != "xyes"; then + if test "x$ssl_found" = "xyes"; then + AC_MSG_RESULT([found; but not usable]) + else + AC_MSG_RESULT([no]) + fi + SSL_APP= + CRYPTO_APP= + SSH_APP= + AC_MSG_WARN([No (usable) OpenSSL found, skipping ssl, ssh and crypto applications]) + + for a in ssl crypto ssh; do + echo "No usable OpenSSL found" > $ERL_TOP/lib/$a/SKIP + done + fi +else + # Option given with PATH to package + if test ! -d "$with_ssl" ; then + AC_MSG_ERROR(Invalid path to option --with-ssl=PATH) + fi + SSL_ROOT="$with_ssl" + if test "x$MIXED_CYGWIN" = "xyes" -a -d "$with_ssl/lib/VC"; then + SSL_LIBDIR="$with_ssl/lib/VC" + elif test "x$ac_cv_sizeof_void_p" = "x8"; then + if test -f "$with_ssl/lib64/libcrypto.a"; then + SSL_LIBDIR="$with_ssl/lib64" + elif test -f "$with_ssl/lib/64/libcrypto.a"; then + SSL_LIBDIR="$with_ssl/lib/64" + elif test -f "$with_ssl/lib64/libcrypto.so"; then + SSL_LIBDIR="$with_ssl/lib64" + elif test -f "$with_ssl/lib/64/libcrypto.so"; then + SSL_LIBDIR="$with_ssl/lib/64" + else + SSL_LIBDIR="$with_ssl/lib" + fi + else + SSL_LIBDIR="$with_ssl/lib" + fi + if test '!' -f $SSL_LIBDIR/libcrypto.a; then + SSL_DYNAMIC_ONLY=yes + fi + SSL_INCLUDE="-I$with_ssl/include" + OPENSSL_CMD="$with_ssl/bin/openssl" + SSL_APP=ssl + CRYPTO_APP=crypto + SSH_APP=ssh +fi + +if test "x$SSL_APP" != "x" ; then + dnl We found openssl, now check if we use kerberos 5 support + AC_MSG_CHECKING(for OpenSSL kerberos 5 support) + old_CPPFLAGS=$CPPFLAGS + CPPFLAGS=$SSL_INCLUDE + AC_EGREP_CPP(yes,[ +#include <openssl/opensslconf.h> +#ifndef OPENSSL_NO_KRB5 + yes +#endif + ],[ + AC_MSG_RESULT([yes]) + ssl_krb5_enabled=yes + if test "x$SSL_DYNAMIC_ONLY" != "xyes"; then + if test -f $SSL_LIBDIR/libkrb5.a; then + SSL_LINK_WITH_KERBEROS=yes + STATIC_KERBEROS_LIBS="$SSL_LIBDIR/libkrb5.a" + if test -f $SSL_LIBDIR/libkrb5support.a; then + STATIC_KERBEROS_LIBS="$STATIC_KERBEROS_LIBS $SSL_LIBDIR/libkrb5support.a" + fi + if test -f $SSL_LIBDIR/libk5crypto.a; then + STATIC_KERBEROS_LIBS="$STATIC_KERBEROS_LIBS $SSL_LIBDIR/libk5crypto.a" + fi + if test -f $SSL_LIBDIR/libresolv.a; then + STATIC_KERBEROS_LIBS="$STATIC_KERBEROS_LIBS $SSL_LIBDIR/libresolv.a" + fi + if test -f $SSL_LIBDIR/libcom_err.a; then + STATIC_KERBEROS_LIBS="$STATIC_KERBEROS_LIBS $SSL_LIBDIR/libcom_err.a" + fi + else + AC_MSG_WARN([Kerberos needed but no kerberos static libraries found]) + AC_MSG_WARN([Rescanning for dynamic SSL libraries]) + enable_dynamic_ssl=yes + ssl_done=no + SSL_LINK_WITH_KERBEROS=no + STATIC_KERBEROS_LIBS="" + ssl_krb5_enabled=no + SSL_WITH_KERBEROS=no + fi + else + SSL_LINK_WITH_KERBEROS=no + STATIC_KERBEROS_LIBS="" + fi + ],[ + AC_MSG_RESULT([no]) + ssl_krb5_enabled=no + SSL_WITH_KERBEROS=no + ]) + CPPFLAGS=$old_CPPFLAGS + SSL_KRB5_INCLUDE= + if test "x$ssl_krb5_enabled" = "xyes" ; then + AC_MSG_CHECKING(for krb5.h in standard locations) + for dir in $extra_dir $SSL_ROOT/include $SSL_ROOT/include/openssl \ + $SSL_ROOT/include/kerberos /cygdrive/c/kerberos/include \ + /usr/local/kerberos/include /usr/kerberos/include \ + /usr/include + do + if test -f "$dir/krb5.h" ; then + SSL_KRB5_INCLUDE="$dir" + break + fi + done + if test "x$SSL_KRB5_INCLUDE" = "x" ; then + AC_MSG_RESULT([not found]) + SSL_APP= + CRYPTO_APP= + SSH_APP= + AC_MSG_WARN([OpenSSL is configured for kerberos but no krb5.h found]) + for a in ssl crypto ssh ; do + echo "OpenSSL is configured for kerberos but no krb5.h found" > $ERL_TOP/lib/$a/SKIP + done + else + AC_MSG_RESULT([found in $SSL_KRB5_INCLUDE]) + SSL_INCLUDE="$SSL_INCLUDE -I$SSL_KRB5_INCLUDE" + fi + fi +fi + +done # while test ssl_done != yes + +#-------------------------------------------------------------------- +# Os mon stuff. +#-------------------------------------------------------------------- +AC_SUBST(os_mon_programs) +AC_SUBST(CPU_SUP_LIBS) + +AC_CHECK_LIB(kstat, kstat_open, [ + os_mon_programs="$os_mon_programs cpu_sup" + CPU_SUP_LIBS="$CPU_SUP_LIBS -lkstat" + ]) + +case $host_os in + solaris2*) + os_mon_programs="$os_mon_programs ferrule mod_syslog" ;; + linux*) + os_mon_programs="$os_mon_programs cpu_sup" ;; +esac + + +dnl +dnl Then there are a number of apps which needs a java compiler... +dnl +need_java="jinterface ic/java_src" + +# Remove all SKIP files from previous runs +for a in $need_java ; do + /bin/rm -f $ERL_TOP/lib/$a/SKIP +done + +AC_CHECK_PROGS(JAVAC, javac.sh javac guavac gcj jikes bock) +if test -n "$JAVAC"; then + dnl Make sure it's at least JDK 1.5 + AC_CACHE_CHECK(for JDK version 1.5, + ac_cv_prog_javac_ver_1_5, + [ERL_TRY_LINK_JAVA([], [for (String i : args);], + ac_cv_prog_javac_ver_1_5=yes, ac_cv_prog_javac_ver_1_5=no)]) + if test $ac_cv_prog_javac_ver_1_5 = no; then + unset -v JAVAC + fi +fi +if test -z "$JAVAC"; then + AC_MSG_WARN([Could not find any usable java compiler, will skip: jinterface]) + + for a in $need_java ; do + echo "No Java compiler found" > $ERL_TOP/lib/$a/SKIP + done +fi + +dnl +dnl Orber has a c++ example, this isn't the right way to check for +dnl it, but.... +dnl +CXXFLAGS= +AC_SUBST(CXXFLAGS) +dnl this deliberately does not believe that 'gcc' is a C++ compiler +AC_CHECK_PROGS(CXX, $CCC c++ g++ CC cxx cc++ cl, false) + +# Remove SKIP file from previous run +/bin/rm -f $ERL_TOP/lib/orber/SKIP + +if test "$CXX" = false; then + echo "No C++ compiler found" > $ERL_TOP/lib/orber/SKIP +fi + +dnl ---------------------------------------------------------------------- +dnl Include CPPFLAGS in CFLAGS +dnl ---------------------------------------------------------------------- +CFLAGS="$CFLAGS $CPPFLAGS" + +# +# Currently if we compile for 64 bits we want to compile +# some external port programs using 32 bits +# + +# If not defined we trust the C compiler in $CC to do 32 bits +if test -z "$CC32"; then + CC32="$CC" +fi + +if test -z "$CFLAGS32"; then + if test $ac_cv_sizeof_void_p != 4; then + # We are compiling default 64 bits and use -m32 for 32 bit compilations + CFLAGS32="$CFLAGS -m32" + else + CFLAGS32="$CFLAGS" + fi +fi + +AC_SUBST(CC32) +AC_SUBST(CFLAGS32) + +dnl +dnl ERTS_EMU_CMDLINE_FLAGS will force modification of config.h when +dnl the emulator command line flags are modified by configure, which +dnl in turn will make 'make' detect that files depending on config.h +dnl needs to be rebuilt. +dnl + +AC_DEFINE_UNQUOTED(ERTS_EMU_CMDLINE_FLAGS, +"$STATIC_CFLAGS $CFLAGS $DEBUG_CFLAGS $EMU_THR_DEFS $DEFS $WFLAGS", +[The only reason ERTS_EMU_CMDLINE_FLAGS exists is to force modification of config.h when the emulator command line flags are modified by configure]) + +dnl ---------------------------------------------------------------------- +dnl Directories needed for the build +dnl ---------------------------------------------------------------------- + +erts=${erl_top}/erts + +erts_dirs=" + $erts/obj $erts/obj.debug + + $erts/obj/$host + $erts/obj.debug/$host + +" +for d in ${erl_top}/bin ${erl_top}/bin/$host $erts_dirs ; +do + if test ! -d $d; then + mkdir -p 1>/dev/null 2>&1 $d + fi +done + +dnl --------------------------------------------------------------------- +dnl Autoheader macro for adding code at top and bottom of config.h.in +dnl --------------------------------------------------------------------- +AH_TOP([ +#define GHBN_R_SOLARIS 2 +#define GHBN_R_AIX 3 +#define GHBN_R_GLIBC 4 +]) + +AH_BOTTOM([ +/* Redefine in6_addr. XXX this should be moved to the files where it's used? */ +#ifdef HAVE_IN_ADDR6_STRUCT +#define in6_addr in_addr6 +#endif + +/* Define a reasonable default for INADDR_LOOPBACK */ +/* XXX this should be moved to the files where it's used? */ +#ifdef HAVE_NO_INADDR_LOOPBACK +#define INADDR_LOOPBACK (u_long)0x7F000001 +#endif + +#ifdef REDEFINE_FD_SETSIZE +#define FD_SETSIZE 1024 +#endif + +#ifdef HAVE_GETHRVTIME_PROCFS_IOCTL +#define HAVE_GETHRVTIME +#endif + +#ifndef HAVE_FINITE +# if defined(HAVE_ISINF) && defined(HAVE_ISNAN) +# define USE_ISINF_ISNAN +# endif +#endif + +#if defined(DEBUG) && defined(USE_THREADS) && !defined(ERTS_ENABLE_LOCK_CHECK) +#define ERTS_ENABLE_LOCK_CHECK 1 +#endif +]) + + +dnl ---------------------------------------------------------------------- +dnl Output the result. +dnl ---------------------------------------------------------------------- + +dnl Note that the output files are relative to $srcdir + +AC_OUTPUT( + emulator/$host/Makefile:emulator/Makefile.in + emulator/zlib/$host/Makefile:emulator/zlib/Makefile.in + emulator/pcre/$host/Makefile:emulator/pcre/Makefile.in + epmd/src/$host/Makefile:epmd/src/Makefile.in + etc/common/$host/Makefile:etc/common/Makefile.in + include/internal/$host/ethread.mk:include/internal/ethread.mk.in + include/internal/$host/erts_internal.mk:include/internal/erts_internal.mk.in + lib_src/$host/Makefile:lib_src/Makefile.in + Makefile:Makefile.in + ../make/$host/otp.mk:../make/otp.mk.in + ../make/$host/otp_ded.mk:../make/otp_ded.mk.in +dnl +dnl The ones below should be moved to their respective lib +dnl + ../lib/ic/c_src/$host/Makefile:../lib/ic/c_src/Makefile.in + ../lib/os_mon/c_src/$host/Makefile:../lib/os_mon/c_src/Makefile.in + ../lib/ssl/c_src/$host/Makefile:../lib/ssl/c_src/Makefile.in + ../lib/ssl/examples/certs/$host/Makefile:../lib/ssl/examples/certs/Makefile.in + ../lib/crypto/c_src/$host/Makefile:../lib/crypto/c_src/Makefile.in + ../lib/orber/c_src/$host/Makefile:../lib/orber/c_src/Makefile.in + ../lib/runtime_tools/c_src/$host/Makefile:../lib/runtime_tools/c_src/Makefile.in + ../lib/tools/c_src/$host/Makefile:../lib/tools/c_src/Makefile.in + ../lib/asn1/c_src/$host/Makefile:../lib/asn1/c_src/Makefile.in + ) + |