--- gforth/configure.in 2002/08/16 09:43:48 1.84 +++ gforth/configure.in 2006/05/13 08:01:04 1.163 @@ -1,6 +1,6 @@ dnl Process this file with autoconf to produce a configure script. -#Copyright (C) 1995,1996,1997,1998,2000 Free Software Foundation, Inc. +#Copyright (C) 1995,1996,1997,1998,2000,2003,2004,2005,2006 Free Software Foundation, Inc. #This file is part of Gforth. @@ -18,132 +18,137 @@ dnl Process this file with autoconf to p #along with this program; if not, write to the Free Software #Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. -AC_INIT(engine/engine.c) dnl We use some automake macros here, dnl but don't use automake for creating Makefile.in -AM_INIT_AUTOMAKE(gforth,0.5.9-20010501) +AC_INIT([gforth],[0.6.2-20060409],[https://savannah.gnu.org/bugs/?func=addbug&group=gforth]) +AC_PREREQ(2.54) #snapshots have numbers major.minor.release-YYYYMMDD -#note that lexicographic ordering bust be heeded. +#note that lexicographic ordering must be heeded. #I.e., 0.4.1-YYYYMMDD must not exist before 0.4.1! -UPDATED="15 August 2002" +UPDATED="April 09, 2006" AC_SUBST(UPDATED) -AM_CONFIG_HEADER(engine/config.h) -#AM_CYGWIN32 +AC_CONFIG_HEADERS(engine/config.h) + +#suppress the "-g -O2" default +test "$CFLAGS" || CFLAGS=-O2 AC_ARG_ENABLE(force-reg, -[ --enable-force-reg Use explicit register declarations if they appear in + AC_HELP_STRING([--enable-force-reg], + [ Use explicit register declarations if they appear in + the machine.h file. This can cause a good speedup, + but also incorrect code with some gcc versions on + some processors (default disabled).]), + ,enable_force_reg=no) +test "$enable_force_reg" = "no"|| + AC_DEFINE(FORCE_REG,,[Define if you want to use explicit register declarations for better performance or for more convenient CODE words (does not work with all GCC versions on all machines)]) + +AC_ARG_ENABLE(force-ll, + AC_HELP_STRING([--enable-force-ll], + [ Use explicit long long declarations if they appear in the machine.h file. This can cause a good speedup, but also incorrect code with some gcc versions on - some processors (default disabled).], -AC_DEFINE(FORCE_REG)) + some processors (default disabled).]), + ,enable_force_ll=no) +test "$enable_force_ll" = "no"|| + AC_DEFINE(FORCE_LL,,[Define if you want to use explicit long long declarations for better performance (does not work with all GCC versions on all machines)]) + +AC_ARG_ENABLE(gcc-pr15242-workaround, + AC_HELP_STRING([--disable-gcc-pr15242-workaround],[Disables + dynamic code generation on some versions of gcc + (slowdown~2 on Athlon) and causes slower building + of gforth (but gforth speedups) on others. + (default enabled)]), + ,enable_gcc_pr15242_workaround=yes) +test "$enable_gcc_pr15242_workaround" = "no"|| +AC_DEFINE(GCC_PR15242_WORKAROUND,,[Define if you want to get dynamic code +generation on gccs affected by PR15242]) + +AC_ARG_ENABLE(force-cdiv, + AC_HELP_STRING([--enable-force-cdiv], + [ Use the native C division - symmetric - instead of + floored division (default disabled).]), + ,enable_force_cdiv=no) +test "$enable_force_cdiv" = "no"|| + AC_DEFINE(FORCE_CDIV,,[Define if you want to use explicit symmetric division for better performance]) + +AC_SUBST(PROFEXES) +AC_SUBST(PROFOBJS) +AC_ARG_ENABLE(prof, + AC_HELP_STRING([--enable-prof], + [ Build gforth-prof, which outputs frequently occuring + sequences of primitives.]), + ,enable_prof=no) +if test "$enable_prof" = "no"; then + PROFEXES="gforth-prof\$(EXE)"; PROFOBJS="engine-prof.o main-prof.o profile.o" +fi AC_ARG_WITH(debug, -[ --with-debug specifies option -g to compile with debug info (default) - --without-debug omits the -g switch and creates smaller images on - machines where "strip" has problems with gcc style - debugging informations.], +[ --with-debug specifies option -g to compile with debug info + --without-debug omits the -g switch and creates smaller images on + machines where "strip" has problems with gcc style + debugging informations.], if test "$withval" = "yes"; then DEBUGFLAG=-g; fi) -PEEPHOLE="yes" -AC_ARG_WITH(peephole, -[ --with-peephole Enable peephole optimization (default) - --without-peephole disables peephole optimization. Creates smaller, - but slower images.], -PEEPHOLE="$withval") +dnl PEEPHOLE="yes" +dnl AC_ARG_WITH(peephole, +dnl [ --with-peephole Enable peephole optimization (default) +dnl --without-peephole disables peephole optimization. Creates smaller, +dnl but slower images.], +dnl PEEPHOLE="$withval") + +#variables mentioned in INSTALL +AC_ARG_VAR(CC, [The C compiler (must support GNU C 2.x); gcc-2.95 recommended.]) +AC_ARG_VAR(FORTHSIZES, [Gforth command line options for the default stack and dictionary sizes (see INSTALL).]) +AC_ARG_VAR(STACK_CACHE_DEFAULT_FAST, [number of registers in the default stack cache state for gforth-fast and gforth-native (default 1).]) +AC_ARG_VAR(ac_cv_sizeof_char_p, [sizeof(char *)]) +AC_ARG_VAR(ac_cv_sizeof_char, [sizeof(char)]) +AC_ARG_VAR(ac_cv_sizeof_short, [sizeof(short)]) +AC_ARG_VAR(ac_cv_sizeof_int, [sizeof(int)]) +AC_ARG_VAR(ac_cv_sizeof_long, [sizeof(long)]) +AC_ARG_VAR(ac_cv_sizeof_long_long, [sizeof(long long)]) +AC_ARG_VAR(ac_cv_sizeof_intptr_t, [sizeof(intptr_t)]) +AC_ARG_VAR(ac_cv_sizeof_int128_t, [sizeof(int128_t)]) +AC_ARG_VAR(ac_cv_sizeof_uint128_t, [sizeof(uint128_t)]) +AC_ARG_VAR(ac_cv_c_bigendian, [Is the target big-endian ("yes" or "no")?]) +AC_ARG_VAR(no_dynamic_default, [run gforth with --dynamic (0) or --no-dynamic (1) by default]) +AC_ARG_VAR(skip_code, [assembly code for skipping 16 bytes of code]) + +#set up feature test macros, so the tests get them right: +# turn on all POSIX, SUSv3, and GNU features if available +AC_GNU_SOURCE +dnl AC_DEFINE_UNQUOTED([_GNU_SOURCE],1,[feature test macro]) + +dnl Don't define _POSIX_SOURCE etc. because some OSs (in particular +dnl MacOSX) disable some features then (MacOSX checks for _POSIX_SOURCE, +dnl but not for _XOPEN_SOURCE) +dnl AC_DEFINE_UNQUOTED([_POSIX_SOURCE],1,[feature test macro]) +dnl AC_DEFINE_UNQUOTED([_POSIX_C_SOURCE],199506L,[feature test macro]) +dnl AC_DEFINE_UNQUOTED([_XOPEN_SOURCE],600,[feature test macro]) +# turn on large file support with 64-bit off_t where available +AC_SYS_LARGEFILE +dnl AC_DEFINE_UNQUOTED([_LARGEFILE_SOURCE],1,[feature test macro]) +dnl AC_DEFINE_UNQUOTED([_FILE_OFFSET_BITS],64,[feature test macro]) #currently we force direct threading this way. Eventually we should #setup in the arch and engine files right -CFLAGS=$CFLAGS - AC_PROG_CC -if test "$GCC" = "yes" -then - echo "Fine, gcc is available" -else - cat <<'EOF' -Gforth requires GCC-2.0 or higher (it uses GNU C extensions). -It does not work with other C compilers. Please install the GNU C compiler, -and try again (or search for a binary distribution for your platform). -EOF - exit 1 -fi +test "$GCC" = "yes" || AC_MSG_ERROR(Gforth uses GNU C extensions and requires GCC 2.0 or higher) AC_SUBST(CC) AC_SUBST(DEBUGFLAG) -dnl the following macro produces a warning with autoconf-2.1 -AC_CHECK_SIZEOF(char *) -case "$ac_cv_sizeof_char_p" in - 2) - wordsize=16 - ;; - 4) - wordsize=32 - ;; - 8) - wordsize=64 - ;; -esac +AC_MSG_CHECKING(make type) +make_type=`make -v 2>&1|grep 'ake'|sed 's/ake .*/ake/'` -AC_CHECK_SIZEOF(char) -AC_CHECK_SIZEOF(short) -AC_CHECK_SIZEOF(int) -AC_CHECK_SIZEOF(long) -AC_CHECK_SIZEOF(long long) +GNUMAKE='#' +test "$make_type" = "GNU Make" && GNUMAKE='' -ac_cv_int_type_cell=none -case "$ac_cv_sizeof_char_p" in - $ac_cv_sizeof_int) - ac_cv_int_type_cell=int - ;; - $ac_cv_sizeof_short) - ac_cv_int_type_cell=short - ;; - $ac_cv_sizeof_char) - ac_cv_int_type_cell=char - ;; - $ac_cv_sizeof_long) - ac_cv_int_type_cell=long - ;; - $ac_cv_sizeof_long_long) - ac_cv_int_type_cell="long long" - ;; -esac -if test "$ac_cv_int_type_cell" != int; then - echo "So, sizeof(pointer)!=sizeof(int); looks like a DOS C compiler to me." - echo "Since you don't have a proper C on this machine, that's one more reason" - echo "to use Forth;-)" -fi -AC_DEFINE_UNQUOTED(CELL_TYPE,$ac_cv_int_type_cell) +AC_MSG_RESULT($make_type) -ac_cv_int_type_double_cell=none -case `expr 2 '*' "$ac_cv_sizeof_char_p"` in - $ac_cv_sizeof_short) - ac_cv_int_type_double_cell=short - ;; - $ac_cv_sizeof_int) - ac_cv_int_type_double_cell=int - ;; - $ac_cv_sizeof_long) - ac_cv_int_type_double_cell=long - ;; - $ac_cv_sizeof_long_long) - ac_cv_int_type_double_cell="long long" - ;; -esac -if test "$ac_cv_int_type_double_cell" = none; then - echo "Emulating double-cell arithmetic. This may be slow." - echo "If you find this unacceptable, ask the GCC maintainers to provide proper" - echo 'long longs for your machine (the GCC manual states that they \"are twice as' - echo "long as \`long int\'\")." - LIBOBJS="$LIBOBJS dblsub.o" - AC_DEFINE(BUGGY_LONG_LONG) -else - AC_DEFINE_UNQUOTED(DOUBLE_CELL_TYPE,$ac_cv_int_type_double_cell) -fi +AC_SUBST(GNUMAKE) AC_MSG_CHECKING([whether the linker accepts -export-dynamic]) OLDLDFLAGS=$LDFLAGS @@ -158,10 +163,19 @@ AC_MSG_RESULT($ac_export_dynamic) #gforth will run; the system on which configure will run is the `build' AC_CANONICAL_HOST case "$host_cpu" in + arm*) + machine=arm + CFLAGS="$CFLAGS -fomit-frame-pointer" + if test -z $no_dynamic_default; then + no_dynamic_default=1 + AC_MSG_WARN([No I-cache flush code known, disabling dynamic native code generation]) + fi + ;; hppa*) machine=hppa $srcdir/mkinstalldirs arch/hppa - LIBOBJS="$LIBOBJS ../arch/hppa/cache.o" + AC_LIBOBJ(../arch/hppa/cache) + #-N needed for --dynamic LDFLAGS="$LDFLAGS -Xlinker -N" LIBS="$LIBS -L/lib/pa1.1/" ;; @@ -180,38 +194,46 @@ case "$host_cpu" in machine=386 CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem" CFLAGS_1="$CFLAGS" - CFLAGS="$CFLAGS -mpentium" + CFLAGS="$CFLAGS -march=pentium" AC_TRY_COMPILE(,,,CFLAGS="$CFLAGS_1 -m486") ;; + x86_64) + machine=amd64 + ;; ia64*) machine=ia64 + AC_LIBOBJ(../arch/ia64/flush_icache_block) + test "$skipcode" || skipcode="nop.i 0" + #".skip 16" passes the test below, + # but gives an assembler error in engine ;; m68k) machine=m68k CFLAGS="$CFLAGS -fomit-frame-pointer" if test "$host_os" = "nextstep3" then - LIBOBJS="$LIBOBJS termios.o" + AC_LIBOBJ(termios) fi ;; mips*) machine=mips - #link text and data segment into the same 256M region! - AC_MSG_CHECKING([whether the linker accepts -T]) - OLDLDFLAGS=$LDFLAGS - LDFLAGS="$LDFLAGS -Xlinker -T -Xlinker 10000000" - AC_TRY_LINK(,,ac_link_mips_t=yes,ac_link_mips_t=no) - test $ac_link_mips_t = yes||LDFLAGS=$OLDLDFLAGS - AC_MSG_RESULT($ac_link_mips_t) - fixme #dynamically generated code should be in the same 256MB - # region as the text segment; no indirect threading necessary - test $ac_link_mips_t = yes||(echo cannot link text and data into same 256M region, using indirect threading; AC_DEFINE(INDIRECT_THREADED)) - AC_MSG_CHECKING([whether the linker accepts -D]) - OLDLDFLAGS=$LDFLAGS - LDFLAGS="$LDFLAGS -Xlinker -D -Xlinker 10400000" - AC_TRY_LINK(,,ac_link_mips_d=yes,ac_link_mips_d=no) - test $ac_link_mips_d = yes||LDFLAGS=$OLDLDFLAGS - AC_MSG_RESULT($ac_link_mips_d) + #dynamic native code has the following problems on MIPS: + # + #1) J/JAL seems relocatable, but is are only + #relocatable within a 256MB-segment. While we try to + #get the linker to arrange this, there is no guarantee + #that this will succeed (and if the user uses a lot of + #memory, it is likely to fail). + # + #2) The way we generate dynamic native code may + #violate MIPS architectural restrictions (in + #particular, the delay slots of LW, MFLO, etc.) + # + #Therefore we disable dynamic native code by default: + if test -z $no_dynamic_default; then + no_dynamic_default=1 + AC_MSG_WARN([Disabling default dynamic native code generation (relocation and delay slot issues)]) + fi ;; alpha*) machine=alpha @@ -221,33 +243,286 @@ case "$host_cpu" in power*|rs6000) machine=power $srcdir/mkinstalldirs arch/power - AC_CHECK_FUNC(_sync_cache_range,true,LIBOBJS="$LIBOBJS ../arch/power/_sync_cache_range.o") + AC_CHECK_FUNC(_sync_cache_range,[true],[AC_LIBOBJ(../arch/power/_sync_cache_range)]) + #long long is broken on (at least) gcc-2.95.* for PPC + test x$ac_cv_sizeof_long_long = x && ac_cv_sizeof_long_long=0 ;; *) - echo "Using a generic machine description." - echo "I'll assume that C floats and doubles are represented by IEEE single and" - echo "double numbers. If this is not so, SF@ etc. will not work correctly." - echo "FLUSH-ICACHE will do nothing, so END-CODE may not work properly!" + AC_MSG_WARN([Using a generic machine description]) + AC_MSG_WARN([Assuming C floats and doubles are IEEE floats and doubles (for SF@ DF@ SF! DF!)]) + AC_MSG_WARN([FLUSH-ICACHE will do nothing, so END-CODE may not work properly!]) machine=generic + #I-cache flushing would be needed for dynamic code generation + if test -z $no_dynamic_default; then + no_dynamic_default=1 + AC_MSG_WARN([No I-cache flush code known, disabling dynamic native code generation]) + fi esac AC_SUBST(host) + +test x$STACK_CACHE_DEFAULT_FAST = x && STACK_CACHE_DEFAULT_FAST=1 +AC_DEFINE_UNQUOTED(STACK_CACHE_DEFAULT_FAST, $STACK_CACHE_DEFAULT_FAST, + [number of registers in the default stack cache state for gforth-fast and gforth-native]) + +if test "${enable_force_ll+set}" = set; then + ac_includes_default="$ac_includes_default +#include \"arch/generic/128bit.h\"" +fi + +dnl the following macro produces a warning with autoconf-2.1 +AC_CHECK_SIZEOF(char *) +case "$ac_cv_sizeof_char_p" in + 2) + wordsize=16 + ;; + 4) + wordsize=32 + ;; + 8) + wordsize=64 + ;; +esac + +AC_CHECK_SIZEOF(char) +AC_CHECK_SIZEOF(short) +AC_CHECK_SIZEOF(int) +AC_CHECK_SIZEOF(long) +AC_CHECK_SIZEOF(long long) +AC_CHECK_SIZEOF(intptr_t) +AC_CHECK_SIZEOF(int128_t) +AC_CHECK_SIZEOF(uint128_t) + +AC_MSG_CHECKING([for a C type for cells]) +ac_cv_int_type_cell=none +case "$ac_cv_sizeof_char_p" in + $ac_cv_sizeof_int) + ac_cv_int_type_cell=int + ;; + $ac_cv_sizeof_short) + ac_cv_int_type_cell=short + ;; + $ac_cv_sizeof_char) + ac_cv_int_type_cell=char + ;; + $ac_cv_sizeof_long) + ac_cv_int_type_cell=long + ;; + $ac_cv_sizeof_long_long) + ac_cv_int_type_cell="long long" + ;; + $ac_cv_sizeof_intptr_t) + ac_cv_int_type_cell="intptr_t" + ;; + $ac_cv_sizeof_int128_t) + ac_cv_int_type_cell="int128_t" + ;; +esac +AC_MSG_RESULT($ac_cv_int_type_cell) +AC_DEFINE_UNQUOTED(CELL_TYPE,$ac_cv_int_type_cell,[an integer type that is as long as a pointer]) + +AC_MSG_CHECKING([for a C type for wydes]) +ac_cv_wyde_type_cell=none +case 2 in + $ac_cv_sizeof_int) + ac_cv_wyde_type_cell=int + ;; + $ac_cv_sizeof_short) + ac_cv_wyde_type_cell=short + ;; + $ac_cv_sizeof_char) + ac_cv_wyde_type_cell=char + ;; + $ac_cv_sizeof_long) + ac_cv_wyde_type_cell=long + ;; + $ac_cv_sizeof_long_long) + ac_cv_wyde_type_cell="long long" + ;; + $ac_cv_sizeof_intptr_t) + ac_cv_wyde_type_cell="intptr_t" + ;; + $ac_cv_sizeof_int128_t) + ac_cv_wyde_type_cell="int128_t" + ;; +esac +AC_MSG_RESULT($ac_cv_wyde_type_cell) +AC_DEFINE_UNQUOTED(WYDE_TYPE,$ac_cv_wyde_type_cell,[an integer type that is 2 bytes long]) + +AC_MSG_CHECKING([for a C type for tetrabytes]) +ac_cv_tetrabyte_type_cell=none +case 4 in + $ac_cv_sizeof_int) + ac_cv_tetrabyte_type_cell=int + ;; + $ac_cv_sizeof_short) + ac_cv_tetrabyte_type_cell=short + ;; + $ac_cv_sizeof_char) + ac_cv_tetrabyte_type_cell=char + ;; + $ac_cv_sizeof_long) + ac_cv_tetrabyte_type_cell=long + ;; + $ac_cv_sizeof_long_long) + ac_cv_tetrabyte_type_cell="long long" + ;; + $ac_cv_sizeof_intptr_t) + ac_cv_tetrabyte_type_cell="intptr_t" + ;; + $ac_cv_sizeof_int128_t) + ac_cv_tetrabyte_type_cell="int128_t" + ;; +esac +AC_MSG_RESULT($ac_cv_tetrabyte_type_cell) +AC_DEFINE_UNQUOTED(TETRABYTE_TYPE,$ac_cv_tetrabyte_type_cell,[an integer type that is 4 bytes long]) + +AC_MSG_CHECKING([for a C type for double-cells]) +ac_cv_int_type_double_cell=none +case `expr 2 '*' "$ac_cv_sizeof_char_p"` in + $ac_cv_sizeof_short) + ac_cv_int_type_double_cell=short + ;; + $ac_cv_sizeof_int) + ac_cv_int_type_double_cell=int + ;; + $ac_cv_sizeof_long) + ac_cv_int_type_double_cell=long + ;; + $ac_cv_sizeof_long_long) + ac_cv_int_type_double_cell="long long" + ;; + $ac_cv_sizeof_intptr_t) + ac_cv_int_type_double_cell="intptr_t" + ;; + $ac_cv_sizeof_int128_t) + ac_cv_int_type_double_cell="int128_t" + ;; +esac +AC_MSG_RESULT($ac_cv_int_type_double_cell) + +AC_MSG_CHECKING([for a C type for unsigned double-cells]) +ac_cv_int_type_double_ucell=none +case `expr 2 '*' "$ac_cv_sizeof_char_p"` in + $ac_cv_sizeof_short) + ac_cv_int_type_double_ucell="unsigned short" + ;; + $ac_cv_sizeof_int) + ac_cv_int_type_double_ucell="unsigned int" + ;; + $ac_cv_sizeof_long) + ac_cv_int_type_double_ucell="unsigned long" + ;; + $ac_cv_sizeof_long_long) + ac_cv_int_type_double_ucell="unsigned long long" + ;; + $ac_cv_sizeof_intptr_t) + ac_cv_int_type_double_ucell="unsigned intptr_t" + ;; + $ac_cv_sizeof_uint128_t) + ac_cv_int_type_double_ucell="uint128_t" + ;; +esac +AC_MSG_RESULT($ac_cv_int_type_double_ucell) + +if test "$ac_cv_int_type_double_cell" = none || \ + test "$ac_cv_int_type_double_ucell" = none +then + AC_MSG_WARN([Emulating double-cell arithmetic. This may be slow.]) + AC_LIBOBJ(dblsub) + AC_DEFINE(BUGGY_LONG_LONG,,[define this if there is no working DOUBLE_CELL_TYPE on your machine]) +else + AC_DEFINE_UNQUOTED(DOUBLE_CELL_TYPE,$ac_cv_int_type_double_cell,[an integer type that is twice as long as a pointer]) + AC_DEFINE_UNQUOTED(DOUBLE_UCELL_TYPE,$ac_cv_int_type_double_ucell,[an unsigned integer type that is twice as long as a pointer]) +fi + +AC_TYPE_OFF_T +AC_CHECK_SIZEOF(off_t) +test $ac_cv_sizeof_off_t -gt $ac_cv_sizeof_char_p +ac_small_off_t=$? +AC_DEFINE_UNQUOTED(SMALL_OFF_T,$ac_small_off_t,[1 if off_t fits in a Cell]) + +ENGINE_FLAGS= AC_SUBST(ENGINE_FLAGS) +# Try if GCC understands -fno-gcse + +AC_MSG_CHECKING([if $CC understands -fno-gcse]) +CFLAGS_1="$CFLAGS" +CFLAGS="$CFLAGS -fno-gcse" +AC_TRY_COMPILE(,,ac_nogcse=yes;ENGINE_FLAGS="$ENGINE_FLAGS -fno-gcse",ac_nogcse=no) +CFLAGS="$CFLAGS_1" +AC_MSG_RESULT($ac_nogcse) + +# Try if GCC understands -fno-strict-aliasing +AC_MSG_CHECKING([if $CC understands -fno-strict-aliasing]) +CFLAGS_1="$CFLAGS" +CFLAGS="$CFLAGS -fno-strict-aliasing" +AC_TRY_COMPILE(,,ac_nostrictaliasing=yes;ENGINE_FLAGS="$ENGINE_FLAGS -fno-strict-aliasing",ac_nostrictaliasing=no) +CFLAGS="$CFLAGS_1" +AC_MSG_RESULT($ac_nostrictaliasing) + +# Try if GCC understands -fno-crossjumping +AC_MSG_CHECKING([if $CC understands -fno-crossjumping]) +CFLAGS_1="$CFLAGS" +CFLAGS="$CFLAGS -fno-crossjumping" +AC_TRY_COMPILE(,,ac_nocrossjumping=yes;ENGINE_FLAGS="$ENGINE_FLAGS -fno-crossjumping",ac_nocrossjumping=no) +CFLAGS="$CFLAGS_1" +AC_MSG_RESULT($ac_nocrossjumping) + +# Try if GCC understands -fno-reorder-blocks +AC_MSG_CHECKING([if $CC understands -fno-reorder-blocks]) +CFLAGS_1="$CFLAGS" +CFLAGS="$CFLAGS -fno-reorder-blocks" +AC_TRY_COMPILE(,,ac_noreorder_blocks=yes;ENGINE_FLAGS="$ENGINE_FLAGS -fno-reorder-blocks",ac_noreorder_blocks=no) +CFLAGS="$CFLAGS_1" +AC_MSG_RESULT($ac_noreorder_blocks) + +# Try if GCC understands __attribute__((unused)) +AC_MSG_CHECKING([how to suppress 'unused variable' warnings]) +AC_TRY_COMPILE(,[int __attribute__((unused)) foo;], MAYBE_UNUSED='__attribute__((unused))',) +AC_DEFINE_UNQUOTED(MAYBE_UNUSED,$MAYBE_UNUSED,[attribute for possibly unused variables]) +AC_MSG_RESULT($MAYBE_UNUSED) + AC_CHECK_PROG(asm_fs,asm.fs,arch/$machine/asm.fs,,$srcdir/arch/$machine) AC_SUBST(asm_fs) AC_CHECK_PROG(disasm_fs,disasm.fs,arch/$machine/disasm.fs,,$srcdir/arch/$machine) AC_SUBST(disasm_fs) +AC_PATH_PROG(INSTALL_INFO,install-info,[echo '>>>>Please make info dir entry:'],$PATH:/sbin:/usr/sbin:/usr/local/sbin) + case "$host_os" in - *win32) - EXE=".exe" + *win32*) + # !!!FIXME!!! problems with cygwin and ';' as path separator + DIRSEP="\\\\" + PATHSEP=";" + #we want the builtins of command.com/cmd.exe and its + # handling of .com files. + #$COMSPEC contains the name of the Windows shell; + # the ./ is there, because the bash does not recognize + # absolute DOS filenames + DEFAULTSYSTEMPREFIX="./$COMSPEC /c " + ;; + *darwin*) + #Darwin uses some funny preprocessor by default; eliminate it: + AC_MSG_NOTICE([using -no-cpp-precomp on Darwin]) + CFLAGS="$CFLAGS -no-cpp-precomp" + DIRSEP="/" + PATHSEP=":" + DEFAULTSYSTEMPREFIX="" ;; *) - EXE="" + DIRSEP="/" + PATHSEP=":" + DEFAULTSYSTEMPREFIX="" ;; esac -AC_SUBST(EXE) +AC_SUBST(DIRSEP) +AC_DEFINE_UNQUOTED(DIRSEP,'$DIRSEP',[a directory separator character]) +AC_SUBST(PATHSEP) +AC_DEFINE_UNQUOTED(PATHSEP,'$PATHSEP',[a path separator character]) +AC_SUBST(DEFAULTSYSTEMPREFIX) +AC_DEFINE_UNQUOTED(DEFAULTSYSTEMPREFIX,"$DEFAULTSYSTEMPREFIX",[default for environment variable GFORTHSYSTEMPREFIX]) dnl Now a little support for DOS/DJGCC AC_SUBST(GFORTH_EXE) @@ -259,19 +534,16 @@ GFORTHITC_EXE="" AC_SUBST(GFORTHDITC_EXE) GFORTHDITC_EXE="" -PATHSEP=":" -AC_SUBST(PATHSEP) -AC_DEFINE_UNQUOTED(PATHSEP,'$PATHSEP') - AC_SUBST(FORTHSIZES) -if test "$PEEPHOLE" = "yes" -then - PEEPHOLEFLAG="true" - AC_DEFINE(HAS_PEEPHOLE) -else - PEEPHOLEFLAG="false" -fi +dnl if test "$PEEPHOLE" = "yes" +dnl then +dnl PEEPHOLEFLAG="true" +dnl AC_DEFINE(HAS_PEEPHOLE,,[Define if you want to use peephole optimization]) +dnl else +dnl PEEPHOLEFLAG="false" +dnl fi +PEEPHOLEFLAG="true" AC_SUBST(PEEPHOLEFLAG) dnl copy commands for systems that don't have links @@ -297,30 +569,107 @@ else KERNEL="kernl16l.fi kernl16b.fi kernl32l.fi kernl32b.fi kernl64l.fi kernl64b.fi" fi +#check how to do asm(".skip 16") +echo "CFLAGS=$CFLAGS" +echo "ac_link=$ac_link" +AC_MSG_CHECKING([if and how we can waste code space]) +if test -z "$skipcode"; then + skipcode=no + CFLAGS_1="$CFLAGS" + CFLAGS="$CFLAGS $ENGINE_FLAGS" + for i in ".skip 16" ".block 16" ".org .+16" ".=.+16" ".space 16" + do + AC_TRY_RUN( +[int foo(int,int,int); +main() +{ + exit(foo(0,0,0)!=16); +} +int foo(int x, int y, int z) +{ + static void *labels[]={&&label1, &&label2}; + if (x) { + y++; /* workaround for http://gcc.gnu.org/bugzilla/show_bug.cgi?id=12108 */ + label1: + asm("$i"); /* or ".space 16" or somesuch */ + label2: ; + } + { + if (y) goto *labels[z]; /* workaround for gcc PR12108 */ + return labels[1]-labels[0]; + } +}] + ,skipcode=$i; break + ,,) + done + CFLAGS=$CFLAGS_1 +fi +AC_MSG_RESULT($skipcode) +if test "$skipcode" = no +then + if test -z $no_dynamic_default; then + no_dynamic_default=1 + AC_MSG_WARN(Disabling default dynamic native code generation) + fi + AC_DEFINE_UNQUOTED(SKIP16,((void)0),statement for skipping 16 bytes) +else + AC_DEFINE_UNQUOTED(SKIP16,asm("$skipcode"),statement for skipping 16 bytes) +fi + +test "$no_dynamic_default" || no_dynamic_default=0 +AC_DEFINE_UNQUOTED(NO_DYNAMIC_DEFAULT,$no_dynamic_default,default value for no_dynamic) + dnl Checks for programs. AC_PROG_LN_S -dnl AM_PROG_INSTALL #performed by AM_INIT_AUTOMAKE +AC_PROG_INSTALL +AC_CHECK_PROGS(TEXI2DVI,texi2dvi4a2ps texi2dvi) dnl Checks for library functions dnl This check is just for making later checks link with libm. dnl using sin here is no good idea since it is built-into gcc and typechecked AC_CHECK_LIB(m,asin) AC_CHECK_LIB(dl,dlopen) +dnl check for libffi 2.x +AC_CHECK_LIB(ffi,ffi_call) +if test $ac_cv_lib_ffi_ffi_call = yes +then +LIBFFIFLAG="true" +FFCALLFLAG="false" +OLDCALLFLAG="false" +AC_DEFINE(HAS_LIBFFI,,[define this if you want to use the ffcall interface with libffi 2.0]) +else +dnl check for ffcall libraries +dnl unfortunately, these four calls are separated out into a library each. +AC_CHECK_LIB(avcall,__builtin_avcall) +AC_CHECK_LIB(callback,__vacall_r) +AC_CHECK_LIB(vacall,vacall) +AC_CHECK_LIB(trampoline,alloc_trampoline) +LIBFFIFLAG="false" +FFCALLFLAG="false" +OLDCALLFLAG="true" +test $ac_cv_lib_avcall___builtin_avcall = yes && FFCALLFLAG="true" && OLDCALLFLAG="false" && AC_DEFINE(HAS_FFCALL,,[define this if you want to use the ffcall libraries]) +test $ac_cv_lib_avcall___builtin_avcall = no && AC_DEFINE(HAS_OLDCALL,,[define this if you want to use the old call libraries]) +fi +AC_SUBST(LIBFFIFLAG) +AC_SUBST(FFCALLFLAG) +AC_SUBST(OLDCALLFLAG) if test "$host_os" != "nextstep3" then AC_FUNC_MEMCMP fi AC_REPLACE_FUNCS(memmove strtoul pow10 strerror strsignal atanh) -AC_CHECK_FUNCS(dlopen sys_siglist getrusage) +AC_FUNC_FSEEKO +AC_CHECK_FUNCS(ftello dlopen sys_siglist getrusage) +AC_CHECK_TYPES(stack_t,,,[#include ]) AC_DECL_SYS_SIGLIST -AC_CHECK_FUNC(getopt_long,true,LIBOBJS="$LIBOBJS getopt.o getopt1.o") -AC_CHECK_FUNCS(rint expm1 log1p) -AC_REPLACE_FUNCS(ecvt) +AC_CHECK_FUNC(getopt_long,[true],[AC_LIBOBJ(getopt) AC_LIBOBJ(getopt1)]) +AC_CHECK_FUNCS(expm1 log1p) +AC_REPLACE_FUNCS(rint ecvt) dnl No check for select, because our replacement is no good under dnl anything but DOS AC_CHECK_HEADERS(sys/mman.h fnmatch.h) AC_FUNC_FNMATCH -test $ac_cv_func_fnmatch_works = yes || LIBOBJS="$LIBOBJS fnmatch.o" +test $ac_cv_func_fnmatch_works = yes || AC_LIBOBJ(fnmatch) AC_CHECK_FUNCS(mmap sysconf getpagesize) AM_PATH_LISPDIR @@ -333,17 +682,20 @@ AC_SUBST(kernel_fi) #fi AC_SUBST(machine) -dnl AC_LINK_FILES(arch/$machine,arch/machine) #no longer needed -AC_OUTPUT([ +AC_CONFIG_FILES([ Makefile Makedist gforthmi vmgen machpc.fs +envos.fs engine/Makefile -doc/version.texi ], -echo timestamp > stamp-h +doc/version.texi +build-ec ]) +AC_CONFIG_COMMANDS([stamp-h],[[echo timestamp > stamp-h chmod +x gforthmi chmod +x vmgen -test -d kernel||mkdir kernel) +chmod +x build-ec +test -d kernel||mkdir kernel]],[[]]) +AC_OUTPUT