2832 lines
77 KiB
Plaintext
2832 lines
77 KiB
Plaintext
dnl // Process this file with autoconf to produce a configure script.
|
|
|
|
AC_PREREQ(2.50)
|
|
AC_INIT(bochs.h)
|
|
AC_REVISION([[$Id: configure.in,v 1.327 2006-09-24 17:15:02 sshwarts Exp $]])
|
|
AC_CONFIG_HEADER(config.h)
|
|
AC_CONFIG_HEADER(ltdlconf.h)
|
|
|
|
dnl // Put Bochs version information right here so that it gets substituted
|
|
dnl // into all the right places.
|
|
VERSION="2.3.cvs"
|
|
VER_STRING="2.3.cvs"
|
|
REL_STRING="Build from CVS snapshot, after release 2.3"
|
|
|
|
changequote(<<, >>)
|
|
changequote([, ])
|
|
|
|
dnl Detect host and target
|
|
AC_CANONICAL_HOST
|
|
AC_CANONICAL_TARGET
|
|
|
|
AC_MSG_CHECKING(if you are configuring for another platform)
|
|
if test "$cross_compiling" = yes -o "$target_os" = "windows"; then
|
|
AC_MSG_RESULT(yes)
|
|
cross_configure=1
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
cross_configure=0
|
|
fi
|
|
|
|
# this case statement defines the compile flags which are needed to
|
|
# compile bochs on a platform. Don't put things like optimization settings
|
|
# into the configure.in file, since people will want to be able to change
|
|
# those settings by defining CFLAGS and CXXFLAGS before running configure.
|
|
NO_LT=0
|
|
need_dlcompat_for_plugins=0
|
|
case "$target" in
|
|
*-pc-windows* | *-pc-winnt*)
|
|
DEFAULT_GUI=win32 # default to win32 gui
|
|
;;
|
|
*-pc-cygwin* | *-pc-mingw32*)
|
|
NO_LT=1 # do not use libtool at all on cygwin
|
|
if test "$with_term" = yes; then
|
|
# ncurses won't compile with -mno-cygwin or -DWIN32
|
|
# also, I can't get it to link without this -DBROKEN_LINKER=1 hack.
|
|
# see /usr/include/curses.h for details.
|
|
ADD_FLAGS="-DBROKEN_LINKER=1"
|
|
else
|
|
# default case
|
|
ADD_FLAGS="-mno-cygwin -DWIN32" # required for cygwin compile+win32 gui
|
|
DEFAULT_GUI=win32 # default to win32 gui
|
|
fi
|
|
;;
|
|
*-macosx* | *-darwin*)
|
|
ADD_FLAGS="-fpascal-strings -fno-common -arch ppc -Wno-four-char-constants -Wno-unknown-pragmas -Dmacintosh" # required for macosx compile
|
|
DEFAULT_GUI=carbon # default to carbon
|
|
need_dlcompat_for_plugins=1
|
|
;;
|
|
*-macos*)
|
|
DEFAULT_GUI=macos # macos defaults to macos
|
|
;;
|
|
*-beos*)
|
|
ADD_FLAGS="-Wno-multichar"
|
|
DEFAULT_GUI=beos # beos defaults to beos
|
|
;;
|
|
*-amigaos* | *-morphos*)
|
|
DEFAULT_GUI=amigaos # amigaos or morphos defaults to amigaos gui
|
|
;;
|
|
*-solaris*)
|
|
ADD_FLAGS="-D_XOPEN_SOURCE_EXTENDED=1 -D__EXTENSIONS__" # required for correct function prototypes
|
|
DEFAULT_GUI=x11
|
|
;;
|
|
*)
|
|
DEFAULT_GUI=x11
|
|
;;
|
|
esac
|
|
if test "${ADD_FLAGS:+set}" = set; then
|
|
CFLAGS="$CFLAGS $ADD_FLAGS"
|
|
CXXFLAGS="$CXXFLAGS $ADD_FLAGS"
|
|
CPPFLAGS="$CPPFLAGS $ADD_FLAGS"
|
|
fi
|
|
|
|
AC_MSG_CHECKING(for standard CFLAGS on this platform)
|
|
AC_MSG_RESULT($ADD_FLAGS)
|
|
|
|
dnl // make sure X Windows is default if no other chosen
|
|
if (test "$with_sdl" != yes) && \
|
|
(test "$with_svga" != yes) && \
|
|
(test "$with_x11" != yes) && \
|
|
(test "$with_beos" != yes) && \
|
|
(test "$with_win32" != yes) && \
|
|
(test "$with_nogui" != yes) && \
|
|
(test "$with_term" != yes) && \
|
|
(test "$with_rfb" != yes) && \
|
|
(test "$with_amigaos" != yes) && \
|
|
(test "$with_carbon" != yes) && \
|
|
(test "$with_wx" != yes) && \
|
|
(test "$with_macos" != yes); then
|
|
# use DEFAULT_GUI. Set the appropriate variable.
|
|
# DEFAULT_GUI must be set to one of the names above. Otherwise, no
|
|
# valid $with_* variable will be set and who knows what will happen?
|
|
eval "with_${DEFAULT_GUI}=yes"
|
|
fi
|
|
|
|
AC_PROG_CC
|
|
AC_PROG_CXX
|
|
AC_PROG_MAKE_SET
|
|
|
|
dnl------------ libtool configuration
|
|
dnl Configure libtool, and default to shared libraries. Libtool will only be
|
|
dnl used for compiling and linking plugins.
|
|
AC_DISABLE_STATIC
|
|
dnl Check for dlopen support
|
|
AC_LIBTOOL_DLOPEN
|
|
dnl Configure libtool
|
|
AC_PROG_LIBTOOL
|
|
dnl Configure the ltdl library. This must go after AC_PROG_LIBTOOL or
|
|
dnl else it disables shared libraries somehow. The values from this macro
|
|
dnl are written to ltdlconf.h.
|
|
AC_LIB_LTDL
|
|
|
|
AC_PATH_XTRA
|
|
|
|
AC_C_BIGENDIAN
|
|
AC_C_INLINE
|
|
AC_CHECK_SIZEOF(unsigned char)
|
|
AC_CHECK_SIZEOF(unsigned short)
|
|
AC_CHECK_SIZEOF(unsigned int)
|
|
AC_CHECK_SIZEOF(unsigned long)
|
|
AC_CHECK_SIZEOF(unsigned long long)
|
|
AC_CHECK_SIZEOF(int *)
|
|
AC_CHECK_FUNCS(getenv, AC_DEFINE(BX_HAVE_GETENV))
|
|
AC_CHECK_FUNCS(setenv, AC_DEFINE(BX_HAVE_SETENV))
|
|
AC_CHECK_FUNCS(select, AC_DEFINE(BX_HAVE_SELECT))
|
|
AC_CHECK_FUNCS(snprintf, AC_DEFINE(BX_HAVE_SNPRINTF))
|
|
AC_CHECK_FUNCS(vsnprintf, AC_DEFINE(BX_HAVE_VSNPRINTF))
|
|
AC_CHECK_FUNCS(strtoull, AC_DEFINE(BX_HAVE_STRTOULL))
|
|
AC_CHECK_FUNCS(strtouq, AC_DEFINE(BX_HAVE_STRTOUQ))
|
|
AC_CHECK_FUNCS(strdup, AC_DEFINE(BX_HAVE_STRDUP))
|
|
AC_CHECK_FUNCS(strrev, AC_DEFINE(BX_HAVE_STRREV))
|
|
AC_CHECK_FUNCS(sleep, AC_DEFINE(BX_HAVE_SLEEP))
|
|
AC_CHECK_FUNCS(usleep, AC_DEFINE(BX_HAVE_USLEEP))
|
|
AC_CHECK_FUNCS(nanosleep, AC_DEFINE(BX_HAVE_NANOSLEEP))
|
|
AC_CHECK_FUNCS(abort, AC_DEFINE(BX_HAVE_ABORT))
|
|
AC_CHECK_FUNCS(gettimeofday, AC_DEFINE(BX_HAVE_GETTIMEOFDAY))
|
|
AC_CHECK_TYPE(socklen_t, AC_DEFINE(BX_HAVE_SOCKLEN_T), , [#include <sys/types.h>
|
|
#include <sys/socket.h>])
|
|
AC_CHECK_MEMBER(struct sockaddr_in.sin_len, AC_DEFINE(BX_HAVE_SOCKADDR_IN_SIN_LEN), , [#include <sys/socket.h>
|
|
#include <netinet/in.h> ])
|
|
AC_CHECK_FUNCS(mkstemp, AC_DEFINE(BX_HAVE_MKSTEMP))
|
|
AC_CHECK_HEADER(sys/mman.h, AC_DEFINE(BX_HAVE_SYS_MMAN_H))
|
|
AC_CHECK_FUNCS(timelocal, AC_DEFINE(BX_HAVE_TIMELOCAL))
|
|
AC_CHECK_FUNCS(gmtime, AC_DEFINE(BX_HAVE_GMTIME))
|
|
AC_CHECK_FUNCS(mktime, AC_DEFINE(BX_HAVE_MKTIME))
|
|
|
|
dnl As of autoconf 2.53, the standard largefile test fails for Linux/gcc.
|
|
dnl It does not put the largefiles arguments into CFLAGS, even though Linux/gcc
|
|
dnl does need them. Since wxWidgets had already solved this exact problem,
|
|
dnl Bryce asked Vadim Zeitlin of the wxWidgets project if Bochs could grab
|
|
dnl their largefile test, and he said it was fine. The re-implemented
|
|
dnl AC_SYS_LARGEFILE test can be found in aclocal.m4.
|
|
AC_SYS_LARGEFILE
|
|
|
|
dnl This logic came from wxWidgets as well. Bryce added the CFLAGS and
|
|
dnl CXXFLAGS lines, since Bochs makefiles don't use CPPFLAGS at all.
|
|
dnl
|
|
dnl we need to define _FILE_OFFSET_BITS or _LARGE_FILES on the compiler command
|
|
dnl line because otherwise the system headers risk being included before
|
|
dnl config.h which defines these constants leading to inconsistent
|
|
dnl sizeof(off_t) in different source files of the same program and linking
|
|
dnl problems
|
|
if test "x$wx_largefile" = "xyes"; then
|
|
if test "x$ac_cv_sys_file_offset_bits" = "x64"; then
|
|
BX_LARGEFILE_FLAGS="-D_FILE_OFFSET_BITS=64 -D_LARGE_FILES"
|
|
else
|
|
BX_LARGEFILE_FLAGS="-D_LARGE_FILES"
|
|
fi
|
|
CPPFLAGS="$CPPFLAGS $BX_LARGEFILE_FLAGS"
|
|
CFLAGS="$CFLAGS $BX_LARGEFILE_FLAGS"
|
|
CXXFLAGS="$CXXFLAGS $BX_LARGEFILE_FLAGS"
|
|
fi
|
|
dnl ---end of largefile tests
|
|
|
|
dnl Add the -lm library if math functions cannot be used without it.
|
|
dnl This check is important on cygwin because of the bizarre way that they
|
|
dnl have organized functions into libraries. On cygwin, both libc.a and
|
|
dnl libm.a are symbolic links to a single lib libcygwin.a. This means that
|
|
dnl 1) linking with -lm is not necessary, and
|
|
dnl 2) linking with -lm is dangerous if the order of libraries is wrong
|
|
dnl In particular, if you compile any program with -mno-cygwin and link with
|
|
dnl -lm, it will crash instantly when it is run. This happens because the
|
|
dnl linker incorrectly links the Cygwin libm.a (==libcygwin.a), which replaces
|
|
dnl the ___main function instead of allowing it to be defined by
|
|
dnl /usr/lib/mingw/libmingw32.a as it should be.
|
|
dnl
|
|
dnl On MacOS X, this test will find that -lm is unnecessary and leave it out.
|
|
dnl
|
|
dnl Just check a few math functions. If they are all found without
|
|
dnl -lm, then we must not need -lm.
|
|
have_cos=0
|
|
have_floor=0
|
|
AC_CHECK_FUNCS(cos, have_cos=1)
|
|
AC_CHECK_FUNCS(floor, have_floor=1)
|
|
AC_MSG_CHECKING(if math functions link without -lm)
|
|
if test "$have_cos" = 1 -a "$have_floor" = 1; then
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
LIBS="$LIBS -lm"
|
|
# use different functions to bypass configure caching
|
|
have_sin=0
|
|
have_ceil=0
|
|
AC_CHECK_FUNCS(sin, have_sin=1)
|
|
AC_CHECK_FUNCS(ceil, have_ceil=1)
|
|
AC_MSG_CHECKING(if math functions link with -lm)
|
|
if test "$have_sin" = 1 -a "$have_ceil" = 1; then
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
# not sure we should warn the user, crash, etc.
|
|
# expect link failure
|
|
fi
|
|
fi
|
|
|
|
AC_MSG_CHECKING(for struct timeval)
|
|
AC_TRY_COMPILE([#include <sys/time.h>],
|
|
[struct timeval x;],
|
|
[
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_HAVE_STRUCT_TIMEVAL, 1)
|
|
],
|
|
AC_MSG_RESULT(no))
|
|
|
|
AC_MSG_CHECKING(if compiler allows empty structs)
|
|
AC_TRY_COMPILE([], [typedef struct { } junk;],
|
|
AC_MSG_RESULT(yes),
|
|
[
|
|
AC_DEFINE(BX_NO_EMPTY_STRUCTS)
|
|
AC_MSG_RESULT(no)
|
|
])
|
|
|
|
AC_MSG_CHECKING(if compiler allows __attribute__)
|
|
AC_TRY_COMPILE([], [typedef struct { } __attribute__ ((packed)) junk;],
|
|
AC_MSG_RESULT(yes),
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_NO_ATTRIBUTES)
|
|
])
|
|
|
|
AC_LANG_SAVE
|
|
AC_LANG_CPLUSPLUS
|
|
AC_MSG_CHECKING(for hash_map)
|
|
AC_TRY_COMPILE([#include <hash_map>], [],
|
|
[
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_HAVE_HASH_MAP)
|
|
], AC_MSG_RESULT(no))
|
|
AC_MSG_CHECKING(for hash_map.h)
|
|
AC_TRY_COMPILE([#include <hash_map.h>], [],
|
|
[
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_HAVE_HASH_MAP_H)
|
|
], AC_MSG_RESULT(no))
|
|
AC_MSG_CHECKING(for set)
|
|
AC_TRY_COMPILE([#include <set>], [],
|
|
[
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_HAVE_SET)
|
|
], AC_MSG_RESULT(no))
|
|
AC_MSG_CHECKING(for set.h)
|
|
AC_TRY_COMPILE([#include <set.h>], [],
|
|
[
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_HAVE_SET_H)
|
|
], AC_MSG_RESULT(no))
|
|
AC_LANG_RESTORE
|
|
|
|
dnl Implement a check for each gui library to see if has a chance of compiling.
|
|
if test "$with_all_libs" = yes; then
|
|
if test "$cross_configure" = 1; then
|
|
AC_MSG_WARN([[Using --with-all-libs while cross configuring is very unlikely to be what you want. You should specify the --with-* args yourself.]])
|
|
fi
|
|
if test "$with_beos" != yes; then
|
|
can_compile_beos=1
|
|
AC_CHECK_HEADER([app/Application.h], [], [ can_compile_beos=0 ])
|
|
AC_CHECK_HEADER([interface/Window.h], [], [ can_compile_beos=0 ])
|
|
AC_CHECK_HEADER([interface/View.h], [], [ can_compile_beos=0 ])
|
|
if test $can_compile_beos = 1; then
|
|
with_beos=yes
|
|
fi
|
|
fi
|
|
|
|
if test "$with_amigaos" != yes; then
|
|
can_compile_amigaos=1
|
|
AC_CHECK_HEADER([proto/intuition.h], [], [ can_compile_amigaos=0 ])
|
|
AC_CHECK_HEADER([intuition/intuitionbase.h], [], [ can_compile_amigaos=0 ])
|
|
AC_CHECK_HEADER([cybergraphx/cybergraphics.h], [], [ can_compile_amigaos=0 ])
|
|
AC_CHECK_HEADER([devices/trackdisk.h], [], [ can_compile_amigaos=0 ])
|
|
if test $can_compile_amigaos = 1; then
|
|
with_amigaos=yes
|
|
fi
|
|
fi
|
|
|
|
if test "$with_macos" != yes; then
|
|
can_compile_macos=1
|
|
AC_CHECK_HEADER([Quickdraw.h], [], [ can_compile_macos=0 ])
|
|
AC_CHECK_HEADER([Dialogs.h], [], [ can_compile_macos=0 ])
|
|
if test $can_compile_macos = 1; then
|
|
with_macos=yes
|
|
fi
|
|
fi
|
|
|
|
if test "$with_carbon" != yes; then
|
|
can_compile_carbon=1
|
|
AC_CHECK_HEADER([Carbon.h], [], [ can_compile_carbon=0 ])
|
|
AC_CHECK_HEADER([ApplicationServices/ApplicationServices.h], [], [ can_compile_carbon=0 ])
|
|
if test $can_compile_carbon = 1; then
|
|
with_carbon=yes
|
|
fi
|
|
fi
|
|
|
|
if test "$with_win32" != yes; then
|
|
can_compile_win32=1
|
|
AC_CHECK_HEADER([windows.h], [], [ can_compile_win32=0 ])
|
|
AC_CHECK_HEADER([commctrl.h], [], [ can_compile_win32=0 ])
|
|
if test $can_compile_win32 = 1; then
|
|
with_win32=yes
|
|
fi
|
|
fi
|
|
|
|
if test "$with_sdl" != yes; then
|
|
can_compile_sdl=1
|
|
AC_CHECK_HEADER([SDL/SDL.h], [], [ can_compile_sdl=0 ])
|
|
AC_CHECK_HEADER([SDL/SDL_main.h], [], [ can_compile_sdl=0 ])
|
|
if test $can_compile_sdl = 1; then
|
|
with_sdl=yes
|
|
fi
|
|
fi
|
|
|
|
if test "$with_svga" != yes; then
|
|
can_compile_svga=1
|
|
AC_CHECK_HEADER([vga.h], [], [ can_compile_svga=0 ])
|
|
AC_CHECK_HEADER([vgagl.h], [], [ can_compile_svga=0 ])
|
|
if test $can_compile_svga = 1; then
|
|
with_svga=yes
|
|
fi
|
|
fi
|
|
|
|
if test "$with_x11" != yes; then
|
|
can_compile_x11=1
|
|
AC_CHECK_HEADER([X11/Xlib.h], [], [ can_compile_x11=0 ])
|
|
AC_CHECK_HEADER([X11/Xutil.h], [], [ can_compile_x11=0 ])
|
|
if test $can_compile_x11 = 1; then
|
|
with_x11=yes
|
|
fi
|
|
fi
|
|
|
|
if test "$with_rfb" != yes; then
|
|
can_compile_rfb=1
|
|
case $target in
|
|
*-pc-windows* | *-pc-winnt* | *-pc-cygwin* | *-pc-mingw32*)
|
|
AC_CHECK_HEADER([winsock.h], [], [ can_compile_rfb=0 ])
|
|
AC_CHECK_HEADER([process.h], [], [ can_compile_rfb=0 ])
|
|
;;
|
|
*)
|
|
AC_CHECK_HEADER([sys/socket.h], [], [ can_compile_rfb=0 ])
|
|
AC_CHECK_HEADER([netinet/tcp.h], [], [ can_compile_rfb=0 ])
|
|
AC_CHECK_HEADER([pthread.h], [], [ can_compile_rfb=0 ])
|
|
;;
|
|
esac
|
|
if test $can_compile_rfb = 1; then
|
|
with_rfb=yes
|
|
fi
|
|
fi
|
|
|
|
if test "$with_term" != yes; then
|
|
can_compile_term=1
|
|
AC_CHECK_HEADER([curses.h], [], [ can_compile_term=0 ])
|
|
AC_CHECK_HEADER([signal.h], [], [ can_compile_term=0 ])
|
|
if test $can_compile_term = 1; then
|
|
with_term=yes
|
|
fi
|
|
fi
|
|
|
|
if test "$with_nogui" != yes; then
|
|
with_nogui=yes
|
|
fi
|
|
fi # end of if $with_all_libs = yes
|
|
|
|
AC_MSG_CHECKING(for new PIT model)
|
|
AC_ARG_ENABLE(new-pit,
|
|
[ --enable-new-pit use Greg Alexander's new PIT model],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_USE_NEW_PIT, 1)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_USE_NEW_PIT, 0)
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_USE_NEW_PIT, 1)
|
|
]
|
|
)
|
|
AC_SUBST(BX_USE_NEW_PIT)
|
|
|
|
AC_MSG_CHECKING(for idle hack)
|
|
AC_ARG_ENABLE(idle-hack,
|
|
[ --enable-idle-hack use Roland Mainz's idle hack],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_USE_IDLE_HACK, 1)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_USE_IDLE_HACK, 0)
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_USE_IDLE_HACK, 0)
|
|
]
|
|
)
|
|
AC_SUBST(BX_USE_IDLE_HACK)
|
|
|
|
AC_CHECK_HEADER(dlfcn.h, AC_DEFINE(BX_HAVE_DLFCN_H, 1))
|
|
AC_CHECK_HEADER(assert.h, AC_DEFINE(HAVE_ASSERT_H, 1))
|
|
|
|
AC_MSG_CHECKING(for plugins support)
|
|
AC_ARG_ENABLE(plugins,
|
|
[ --enable-plugins enable plugins],
|
|
[if test "$enableval" = yes; then
|
|
bx_plugins=1
|
|
else
|
|
bx_plugins=0
|
|
fi],
|
|
[
|
|
bx_plugins=0
|
|
]
|
|
)
|
|
|
|
if test "$bx_plugins" = 1; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_PLUGINS, 1)
|
|
GUI_NON_PLUGIN_OBJS='$(OBJS_THAT_CANNOT_BE_PLUGINS)'
|
|
GUI_PLUGIN_OBJS='$(OBJS_THAT_CAN_BE_PLUGINS)'
|
|
DEFINE_PLUGIN_PATH='-DBX_PLUGIN_PATH="\"${plugdir}\""'
|
|
# and the $(OBJS_THAT_SUPPORT_OTHER_PLUGINS) will be built and linked
|
|
# by special link rules for the plugins that they support.
|
|
LIBS="$LIBS $LIBADD_DL"
|
|
PLUGIN_VAR='ltdl.o'
|
|
PLUGIN_TARGET=bochs_plugins
|
|
INSTALL_PLUGINS_VAR=install_libtool_plugins
|
|
NONPLUGIN_GUI_LINK_OPTS=''
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
bx_plugins=0
|
|
AC_DEFINE(BX_PLUGINS, 0)
|
|
GUI_NON_PLUGIN_OBJS='$(OBJS_THAT_CANNOT_BE_PLUGINS) $(OBJS_THAT_CAN_BE_PLUGINS) $(OBJS_THAT_SUPPORT_OTHER_PLUGINS)'
|
|
GUI_PLUGIN_OBJS=''
|
|
NONPLUGIN_GUI_LINK_OPTS='$(GUI_LINK_OPTS)'
|
|
fi
|
|
AC_SUBST(DEFINE_PLUGIN_PATH)
|
|
AC_SUBST(NONPLUGIN_GUI_LINK_OPTS)
|
|
|
|
# copy gui variables into iodev variables. Later, we will add to the gui
|
|
# objs list, according to which display libraries are enabled.
|
|
IODEV_NON_PLUGIN_OBJS=$GUI_NON_PLUGIN_OBJS
|
|
IODEV_PLUGIN_OBJS=$GUI_PLUGIN_OBJS
|
|
|
|
# on MacOSX if they enabled plugins, make sure that dlopen() was found.
|
|
# It is provided by a library called dlcompat.
|
|
if test "$bx_plugins" = 1 -a "$need_dlcompat_for_plugins" = 1; then
|
|
have_dlopen=0
|
|
AC_CHECK_LIB(dl, dlopen, [have_dlopen=1])
|
|
AC_MSG_CHECKING(if you have dlcompat, required for MacOSX plugins)
|
|
if test "$have_dlopen" = 0; then
|
|
AC_MSG_RESULT(no)
|
|
AC_MSG_ERROR([To use plugins on MacOSX you must use a library called dlcompat. The configure script was not able to find dlcompat. If it is already installed then you must set up your environment variables to point to it, as is done in .conf.macosx. If you cannot resolve this, you should turn off plugins.])
|
|
else
|
|
AC_MSG_RESULT(yes)
|
|
fi
|
|
fi
|
|
|
|
AC_MSG_CHECKING(if compiler allows blank labels)
|
|
AC_TRY_COMPILE([], [ { label1: } ],
|
|
AC_MSG_RESULT(yes),
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_NO_BLANK_LABELS)
|
|
])
|
|
|
|
AC_MSG_CHECKING(if compiler allows LL for 64-bit constants)
|
|
AC_TRY_COMPILE([], [ { 42LL; } ],
|
|
AC_MSG_RESULT(yes),
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_64BIT_CONSTANTS_USE_LL, 0)
|
|
])
|
|
|
|
use_x86_64=0
|
|
AC_MSG_CHECKING(for x86-64 support)
|
|
AC_ARG_ENABLE(x86-64,
|
|
[ --enable-x86-64 compile in support for x86-64 instructions],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
OBJS64='$(OBJS64)'
|
|
AC_DEFINE(BX_SUPPORT_X86_64, 1)
|
|
use_x86_64=1
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
OBJS64=''
|
|
AC_DEFINE(BX_SUPPORT_X86_64, 0)
|
|
fi
|
|
],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
OBJS64=''
|
|
AC_DEFINE(BX_SUPPORT_X86_64, 0)
|
|
]
|
|
)
|
|
AC_SUBST(OBJS64)
|
|
|
|
use_smp=0
|
|
AC_MSG_CHECKING(for SMP support)
|
|
AC_ARG_ENABLE(smp,
|
|
[ --enable-smp compile in support for SMP configurations],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_SMP, 1)
|
|
AC_DEFINE(BX_USE_CPU_SMF, 0)
|
|
use_smp=1
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_SMP, 0)
|
|
fi
|
|
],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_SMP, 0)
|
|
]
|
|
)
|
|
|
|
AC_MSG_CHECKING(for cpu level)
|
|
AC_ARG_ENABLE(cpu-level,
|
|
[ --enable-cpu-level select cpu level (3,4,5,6)],
|
|
[case "$enableval" in
|
|
3)
|
|
AC_MSG_RESULT(3)
|
|
AC_DEFINE(BX_CPU_LEVEL, 3)
|
|
AC_DEFINE(BX_CPU_LEVEL_HACKED, 3)
|
|
;;
|
|
4)
|
|
AC_MSG_RESULT(4)
|
|
AC_DEFINE(BX_CPU_LEVEL, 4)
|
|
AC_DEFINE(BX_CPU_LEVEL_HACKED, 4)
|
|
;;
|
|
5)
|
|
AC_MSG_RESULT(5)
|
|
AC_DEFINE(BX_CPU_LEVEL, 5)
|
|
AC_DEFINE(BX_CPU_LEVEL_HACKED, 5)
|
|
;;
|
|
6)
|
|
AC_MSG_RESULT(6)
|
|
AC_DEFINE(BX_CPU_LEVEL, 6)
|
|
AC_DEFINE(BX_CPU_LEVEL_HACKED, 6)
|
|
;;
|
|
*)
|
|
echo " "
|
|
echo "ERROR: you must supply a valid CPU level to --enable-cpu-level"
|
|
exit 1
|
|
;;
|
|
esac
|
|
bx_cpu_level=$enableval
|
|
if test "$use_smp" = 1 -a "$enableval" -lt 6; then
|
|
echo "ERROR: with >1 processor, use --enable-cpu-level=6"
|
|
exit 1
|
|
fi
|
|
],
|
|
[
|
|
# for multiprocessors or x86-64, cpu level must be 6
|
|
if test "$use_smp" = 1 -o "$use_x86_64" = 1; then
|
|
AC_MSG_RESULT(6)
|
|
AC_DEFINE(BX_CPU_LEVEL, 6)
|
|
AC_DEFINE(BX_CPU_LEVEL_HACKED, 6)
|
|
bx_cpu_level=6
|
|
else
|
|
AC_MSG_RESULT(5)
|
|
AC_DEFINE(BX_CPU_LEVEL, 5)
|
|
AC_DEFINE(BX_CPU_LEVEL_HACKED, 5)
|
|
bx_cpu_level=5
|
|
fi
|
|
]
|
|
)
|
|
|
|
|
|
AC_MSG_CHECKING(for APIC support)
|
|
AC_ARG_ENABLE(apic,
|
|
[ --enable-apic enable APIC support],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_APIC, 1)
|
|
IOAPIC_OBJS='ioapic.o'
|
|
APIC_OBJS='apic.o'
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
if test "$use_smp" = 1; then
|
|
echo "ERROR: With SMP configuration you must use --enable-apic"
|
|
exit 1
|
|
fi
|
|
AC_DEFINE(BX_SUPPORT_APIC, 0)
|
|
IOAPIC_OBJS=''
|
|
APIC_OBJS=''
|
|
fi
|
|
],
|
|
[
|
|
if test "$use_smp" = 1 -o "$bx_cpu_level" -gt 5; then
|
|
# enable APIC by default, if SMP configuration or if cpulevel>5
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_APIC, 1)
|
|
IOAPIC_OBJS='ioapic.o'
|
|
APIC_OBJS='apic.o'
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_APIC, 0)
|
|
IOAPIC_OBJS=''
|
|
APIC_OBJS=''
|
|
fi
|
|
]
|
|
)
|
|
AC_SUBST(IOAPIC_OBJS)
|
|
AC_SUBST(APIC_OBJS)
|
|
|
|
AC_CHECK_HEADER(zlib.h, [AC_CHECK_LIB(z, gzopen, AC_DEFINE(BX_HAVE_ZLIB,1))] )
|
|
|
|
AC_MSG_CHECKING(for compressed hard disk image support)
|
|
AC_ARG_ENABLE(compressed-hd,
|
|
[ --enable-compressed-hd allows compressed (zlib) hard disk image (not implemented yet)],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_COMPRESSED_HD_SUPPORT, 1)
|
|
LIBS="$LIBS -lz"
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_COMPRESSED_HD_SUPPORT, 0)
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_COMPRESSED_HD_SUPPORT, 0)
|
|
]
|
|
)
|
|
AC_SUBST(BX_COMPRESSED_HD_SUPPORT)
|
|
|
|
AC_MSG_CHECKING(for NE2000 support)
|
|
AC_ARG_ENABLE(ne2000,
|
|
[ --enable-ne2000 enable limited ne2000 support],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_NE2K, 1)
|
|
NE2K_OBJS='ne2k.o'
|
|
networking=yes
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_NE2K, 0)
|
|
NE2K_OBJS=''
|
|
networking=no
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_NE2K, 0)
|
|
NE2K_OBJS=''
|
|
networking=no
|
|
]
|
|
)
|
|
AC_SUBST(NE2K_OBJS)
|
|
|
|
AC_MSG_CHECKING(for i440FX PCI support)
|
|
AC_ARG_ENABLE(pci,
|
|
[ --enable-pci enable limited i440FX PCI support],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_PCI, 1)
|
|
pci=1
|
|
PCI_OBJ='pci.o pci2isa.o pci_ide.o pcivga.o acpi.o'
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_PCI, 0)
|
|
pci=0
|
|
PCI_OBJ=''
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_PCI, 0)
|
|
pci=0
|
|
PCI_OBJ=''
|
|
]
|
|
)
|
|
AC_SUBST(PCI_OBJ)
|
|
|
|
#
|
|
# PCI host device support
|
|
#
|
|
AC_MSG_CHECKING(for PCI host device mapping support)
|
|
AC_ARG_ENABLE(pcidev,
|
|
[ --enable-pcidev enable PCI host device mapping support (linux host only)],
|
|
[
|
|
if test "$enableval" = "yes"; then
|
|
AC_MSG_RESULT(yes)
|
|
if test "$pci" != "1"; then
|
|
AC_MSG_ERROR([PCI host device mapping requires PCI support])
|
|
fi
|
|
case "$target" in
|
|
*-linux*)
|
|
AC_MSG_NOTICE([Linux detected as host for PCI host device mapping])
|
|
linux_version=`uname -r`
|
|
case "$linux_version" in
|
|
2.4*)
|
|
PCIDEV_MODULE_MAKE_ALL="all-kernel24"
|
|
KERNEL_MODULE_SUFFIX="o"
|
|
;;
|
|
2.6*)
|
|
PCIDEV_MODULE_MAKE_ALL="all-kernel26"
|
|
KERNEL_MODULE_SUFFIX="ko"
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR([Linux kernel 2.4 or 2.6 is required])
|
|
;;
|
|
esac
|
|
KERNELDIR="/lib/modules/$linux_version/build"
|
|
LSMOD="lsmod"
|
|
INSMOD="insmod"
|
|
RMMOD="rmmod"
|
|
DEPMOD="depmod"
|
|
AC_SUBST(KERNELDIR)
|
|
AC_SUBST(LSMOD)
|
|
AC_SUBST(INSMOD)
|
|
AC_SUBST(RMMOD)
|
|
AC_SUBST(DEPMOD)
|
|
AC_SUBST(PCIDEV_MODULE_MAKE_ALL)
|
|
AC_SUBST(KERNEL_MODULE_SUFFIX)
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR([PCI host device mapping requires Linux as host])
|
|
;;
|
|
esac
|
|
AC_DEFINE(BX_SUPPORT_PCIDEV, 1)
|
|
PCI_OBJ="$PCI_OBJ pcidev.o"
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_PCIDEV, 0)
|
|
fi
|
|
],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_PCIDEV, 0)
|
|
]
|
|
)
|
|
|
|
AC_MSG_CHECKING(for limited USB support)
|
|
AC_ARG_ENABLE(usb,
|
|
[ --enable-usb enable limited USB support],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_PCIUSB, 1)
|
|
PCI_OBJ="$PCI_OBJ pciusb.o"
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_PCIUSB, 0)
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_PCIUSB, 0)
|
|
]
|
|
)
|
|
|
|
AC_MSG_CHECKING(for PCI pseudo NIC support)
|
|
AC_ARG_ENABLE(pnic,
|
|
[ --enable-pnic enable PCI pseudo NIC support],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_PCIPNIC, 1)
|
|
PCI_OBJ="$PCI_OBJ pcipnic.o"
|
|
networking=yes
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_PCIPNIC, 0)
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_PCIPNIC, 0)
|
|
]
|
|
)
|
|
|
|
NETLOW_OBJS=''
|
|
if test "$networking" = yes; then
|
|
NETLOW_OBJS='eth.o eth_null.o eth_vnet.o'
|
|
AC_CHECK_HEADER(net/bpf.h, NETLOW_OBJS="$NETLOW_OBJS eth_fbsd.o")
|
|
AC_CHECK_HEADER(netpacket/packet.h, NETLOW_OBJS="$NETLOW_OBJS eth_linux.o")
|
|
case "$target" in
|
|
*-pc-windows* | *-pc-winnt* | *-pc-cygwin* | *-pc-mingw32*)
|
|
NETLOW_OBJS="$NETLOW_OBJS eth_win32.o"
|
|
;;
|
|
*-macosx* | *-darwin*)
|
|
NETLOW_OBJS="$NETLOW_OBJS eth_tuntap.o"
|
|
AC_DEFINE(HAVE_TUNTAP, 1)
|
|
;;
|
|
*)
|
|
AC_CHECK_HEADER(net/if.h, [
|
|
use_ethertap=yes
|
|
AC_DEFINE(BX_HAVE_NET_IF_H, 1)
|
|
], [],
|
|
[
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
])
|
|
AC_CHECK_HEADER(linux/netlink.h, [
|
|
use_ethertap=yes
|
|
], [],
|
|
[
|
|
#include <asm/types.h>
|
|
#include <sys/socket.h>
|
|
])
|
|
|
|
if test "$use_ethertap" = yes; then
|
|
NETLOW_OBJS="$NETLOW_OBJS eth_tap.o eth_vde.o"
|
|
AC_DEFINE(HAVE_ETHERTAP, 1)
|
|
AC_DEFINE(HAVE_VDE, 1)
|
|
fi
|
|
|
|
AC_CHECK_HEADER(net/if_tun.h, [
|
|
use_tuntap=yes
|
|
], [],
|
|
[
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <net/if.h>
|
|
])
|
|
AC_CHECK_HEADER(linux/if_tun.h, [
|
|
use_tuntap=yes
|
|
], [],
|
|
[
|
|
#include <asm/types.h>
|
|
#include <sys/socket.h>
|
|
])
|
|
if test "$use_tuntap" = yes; then
|
|
NETLOW_OBJS="$NETLOW_OBJS eth_tuntap.o"
|
|
AC_DEFINE(HAVE_TUNTAP, 1)
|
|
fi
|
|
|
|
;;
|
|
esac
|
|
AC_DEFINE(BX_NETWORKING, 1)
|
|
else
|
|
AC_DEFINE(BX_NETWORKING, 0)
|
|
fi
|
|
|
|
AC_SUBST(NETLOW_OBJS)
|
|
|
|
|
|
AC_MSG_CHECKING(for 4Meg pages support)
|
|
AC_ARG_ENABLE(4meg-pages,
|
|
[ --enable-4meg-pages support 4Megabyte pages extensions],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_4MEG_PAGES, 1)
|
|
support_4M_pages=1
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_4MEG_PAGES, 0)
|
|
support_4M_pages=0
|
|
fi],
|
|
[
|
|
if test "$bx_cpu_level" -gt 4; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_4MEG_PAGES, 1)
|
|
support_4M_pages=1
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_4MEG_PAGES, 0)
|
|
support_4M_pages=0
|
|
fi
|
|
]
|
|
)
|
|
|
|
|
|
AC_MSG_CHECKING(for PAE support)
|
|
AC_ARG_ENABLE(pae,
|
|
[ --enable-pae support Physical Address Extensions],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_PAE, 1)
|
|
support_pae=1
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_PAE, 0)
|
|
support_pae=0
|
|
fi],
|
|
[
|
|
if test "$bx_cpu_level" -gt 5; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_PAE, 1)
|
|
support_pae=1
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_PAE, 0)
|
|
support_pae=0
|
|
fi
|
|
]
|
|
)
|
|
|
|
AC_MSG_CHECKING(for global pages support)
|
|
AC_ARG_ENABLE(global-pages,
|
|
[ --enable-global-pages support for global pages in PDE/PTE],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_GLOBAL_PAGES, 1)
|
|
support_global_pages=1
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_GLOBAL_PAGES, 0)
|
|
support_global_pages=0
|
|
fi],
|
|
[
|
|
if test "$bx_cpu_level" -gt 5; then
|
|
# enable by default
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_GLOBAL_PAGES, 1)
|
|
support_global_pages=1
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_GLOBAL_PAGES, 0)
|
|
support_global_pages=0
|
|
fi
|
|
]
|
|
)
|
|
|
|
if test "$bx_cpu_level" -lt 4 -a "$support_4M_pages" = 1; then
|
|
AC_MSG_ERROR([for 4M paging support the CPU level must be >= 4])
|
|
fi
|
|
|
|
if test "$bx_cpu_level" -lt 5 -a "$support_pae" = 1; then
|
|
AC_MSG_ERROR([for PAE support the CPU level must be >= 5])
|
|
fi
|
|
|
|
if test "$bx_cpu_level" -lt 5 -a "$support_global_pages" = 1; then
|
|
AC_MSG_ERROR([for Global Pages support the CPU level must be >= 5])
|
|
fi
|
|
|
|
AC_MSG_CHECKING(for guest to host TLB support)
|
|
AC_ARG_ENABLE(guest2host-tlb,
|
|
[ --enable-guest2host-tlb support guest to host addr TLB for speed],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
speedup_guest2host_tlb=1
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
speedup_guest2host_tlb=0
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
speedup_guest2host_tlb=0
|
|
]
|
|
)
|
|
|
|
AC_MSG_CHECKING(for repeated IO and mem copy speedups)
|
|
AC_ARG_ENABLE(repeat-speedups,
|
|
[ --enable-repeat-speedups support repeated IO and mem copy speedups],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
speedup_repeat=1
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
speedup_repeat=0
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
speedup_repeat=0
|
|
]
|
|
)
|
|
|
|
AC_MSG_CHECKING(for instruction cache support)
|
|
AC_ARG_ENABLE(icache,
|
|
[ --enable-icache support instruction cache],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
speedup_iCache=1
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
speedup_iCache=0
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
speedup_iCache=0
|
|
]
|
|
)
|
|
|
|
AC_MSG_CHECKING(for gcc fast function calls optimization)
|
|
AC_ARG_ENABLE(fast-function-calls,
|
|
[ --enable-fast-function-calls support for fast function calls (gcc on x86 only)],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
speedup_fastcall=1
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
speedup_fastcall=0
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
speedup_fastcall=0
|
|
]
|
|
)
|
|
|
|
AC_MSG_CHECKING(for host specific inline assembly accelerations)
|
|
AC_ARG_ENABLE(host-specific-asms,
|
|
[ --enable-host-specific-asms support for host specific inline assembly],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
speedup_host_specific_asms=1
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
speedup_host_specific_asms=0
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(yes)
|
|
speedup_host_specific_asms=1
|
|
]
|
|
)
|
|
|
|
AC_MSG_CHECKING(whether to ignore bad MSR references)
|
|
AC_ARG_ENABLE(ignore-bad-msr,
|
|
[ --enable-ignore-bad-msr ignore bad MSR references ],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_IGNORE_BAD_MSR, 1)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_IGNORE_BAD_MSR, 0)
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_IGNORE_BAD_MSR, 1)
|
|
]
|
|
)
|
|
|
|
AC_MSG_CHECKING(for port e9 hack)
|
|
AC_ARG_ENABLE(port-e9-hack,
|
|
[ --enable-port-e9-hack writes to port e9 go to console],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_PORT_E9_HACK, 1)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_PORT_E9_HACK, 0)
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_PORT_E9_HACK, 1)
|
|
]
|
|
)
|
|
|
|
AC_MSG_CHECKING(show IPS)
|
|
AC_ARG_ENABLE(show-ips,
|
|
[ --enable-show-ips show IPS in Bochs log file],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SHOW_IPS, 1)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SHOW_IPS, 0)
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SHOW_IPS, 0)
|
|
]
|
|
)
|
|
|
|
AC_MSG_CHECKING(save/restore support)
|
|
AC_ARG_ENABLE(save-restore,
|
|
[ --enable-save-restore support for simulation save and restore],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_SAVE_RESTORE, 1)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_SAVE_RESTORE, 0)
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_SAVE_RESTORE, 1)
|
|
]
|
|
)
|
|
|
|
AC_MSG_CHECKING(for use of .cpp as suffix)
|
|
AC_ARG_ENABLE(cpp,
|
|
[ --enable-cpp use .cpp as C++ suffix],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
SUFFIX_LINE='.SUFFIXES: .cpp'
|
|
CPP_SUFFIX='cpp'
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
SUFFIX_LINE='.SUFFIXES: .cc'
|
|
CPP_SUFFIX='cc'
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
SUFFIX_LINE='.SUFFIXES: .cc'
|
|
CPP_SUFFIX='cc'
|
|
]
|
|
)
|
|
AC_SUBST(SUFFIX_LINE)
|
|
AC_SUBST(CPP_SUFFIX)
|
|
|
|
if test "$enable_cpp" = yes; then
|
|
echo "moving .cc source files to .cpp"
|
|
sourcefiles=`find . -name "*.cc" -print`
|
|
if test "$sourcefiles" != ""; then
|
|
for ccname in $sourcefiles
|
|
do
|
|
cppname=`echo $ccname | sed -e "s/\.cc$/.cpp/"`
|
|
echo "mv $ccname $cppname"
|
|
mv $ccname $cppname
|
|
done
|
|
else
|
|
echo "no more .cc source files to rename"
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
AC_MSG_CHECKING(for Bochs internal debugger support)
|
|
AC_ARG_ENABLE(debugger,
|
|
[ --enable-debugger compile in support for Bochs internal debugger],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_DEBUGGER, 1)
|
|
DEBUGGER_VAR='$(DEBUGGER_LIB)'
|
|
bx_debugger=1
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_DEBUGGER, 0)
|
|
DEBUGGER_VAR=''
|
|
bx_debugger=0
|
|
fi
|
|
],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_DEBUGGER, 0)
|
|
DEBUGGER_VAR=''
|
|
bx_debugger=0
|
|
]
|
|
)
|
|
AC_SUBST(DEBUGGER_VAR)
|
|
|
|
AC_MSG_CHECKING(for external debugger)
|
|
EXT_DEBUG_OBJS=''
|
|
AC_ARG_ENABLE(external-debugger,
|
|
[ --enable-external-debugger enable external debugger support (win32 only)],
|
|
[if test "$enableval" = yes; then
|
|
case $target in
|
|
*-pc-windows* | *-cygwin* | *-mingw32*)
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_EXTERNAL_DEBUGGER, 1)
|
|
EXT_DEBUG_OBJS=extdb.o
|
|
;;
|
|
*)
|
|
echo "ERROR: external debugger is currently supported on win32 only"
|
|
exit 1
|
|
;;
|
|
esac
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
])
|
|
AC_SUBST(BX_EXTERNAL_DEBUGGER)
|
|
|
|
AC_MSG_CHECKING(for magic breakpoints)
|
|
AC_ARG_ENABLE(magic-breakpoints,
|
|
[ --enable-magic-breakpoints enable magic debugger breakpoints],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_MAGIC_BREAKPOINT, 1)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_MAGIC_BREAKPOINT, 0)
|
|
fi],
|
|
[
|
|
if test "$bx_debugger" = 1; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_MAGIC_BREAKPOINT, 1)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_MAGIC_BREAKPOINT, 0)
|
|
fi
|
|
])
|
|
AC_SUBST(BX_MAGIC_BREAKPOINT)
|
|
|
|
AC_MSG_CHECKING(for disassembler support)
|
|
AC_ARG_ENABLE(disasm,
|
|
[ --enable-disasm compile in support for disassembler],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_DISASM, 1)
|
|
DISASM_VAR='$(DISASM_LIB)'
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
if test "$bx_debugger" = 1; then
|
|
echo "ERROR: debugger is enabled, so --enable-disasm is required"
|
|
exit 1
|
|
fi
|
|
AC_DEFINE(BX_DISASM, 0)
|
|
DISASM_VAR=''
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_DISASM, 1)
|
|
DISASM_VAR='$(DISASM_LIB)'
|
|
])
|
|
AC_SUBST(DISASM_VAR)
|
|
|
|
AC_MSG_CHECKING(for ALL optimizations enabled)
|
|
AC_ARG_ENABLE(all-optimizations,
|
|
[ --enable-all-optimizations compile in all possible optimizations],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
speedups_all=1
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
speedups_all=0
|
|
fi
|
|
],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
speedups_all=0
|
|
]
|
|
)
|
|
|
|
#
|
|
# Optimizations section. Decide what the status of various optimizations
|
|
# should be based on configure choices and other factors.
|
|
#
|
|
|
|
if test "$speedups_all" = 1; then
|
|
# Configure requested to force all options enabled.
|
|
speedup_guest2host_tlb=1
|
|
speedup_repeat=1
|
|
speedup_iCache=1
|
|
speedup_host_specific_asms=1
|
|
speedup_fastcall=1
|
|
fi
|
|
|
|
if test "$speedup_guest2host_tlb" = 1; then
|
|
AC_DEFINE(BX_SupportGuest2HostTLB, 1)
|
|
else
|
|
AC_DEFINE(BX_SupportGuest2HostTLB, 0)
|
|
fi
|
|
|
|
if test "$speedup_repeat" = 1; then
|
|
AC_DEFINE(BX_SupportRepeatSpeedups, 1)
|
|
else
|
|
AC_DEFINE(BX_SupportRepeatSpeedups, 0)
|
|
fi
|
|
|
|
if test "$speedup_iCache" = 1; then
|
|
AC_DEFINE(BX_SUPPORT_ICACHE, 1)
|
|
else
|
|
AC_DEFINE(BX_SUPPORT_ICACHE, 0)
|
|
fi
|
|
|
|
if test "$speedup_host_specific_asms" = 1; then
|
|
AC_DEFINE(BX_SupportHostAsms, 1)
|
|
else
|
|
AC_DEFINE(BX_SupportHostAsms, 0)
|
|
fi
|
|
|
|
if test "$speedup_fastcall" = 1; then
|
|
AC_DEFINE(BX_FAST_FUNC_CALL, 1)
|
|
else
|
|
AC_DEFINE(BX_FAST_FUNC_CALL, 0)
|
|
fi
|
|
|
|
|
|
READLINE_LIB=""
|
|
rl_without_curses_ok=no
|
|
rl_with_curses_ok=no
|
|
|
|
AC_MSG_CHECKING(whether user wants readline)
|
|
AC_ARG_ENABLE(readline,
|
|
[ --enable-readline use readline library, if available],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
want_readline=yes
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
want_readline=no
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(yes)
|
|
want_readline=yes
|
|
]
|
|
)
|
|
|
|
use_readline=0
|
|
AC_MSG_CHECKING(whether to use readline)
|
|
if test "$want_readline" = yes; then
|
|
if test "$bx_debugger" = 1; then
|
|
|
|
AC_MSG_CHECKING(if readline works without -lcurses)
|
|
OLD_LIBS=$LIBS
|
|
LIBS="$LIBS -lreadline"
|
|
AC_TRY_RUN([
|
|
#include <stdio.h>
|
|
#include <readline/readline.h>
|
|
int main() { rl_initialize(); exit(0); }
|
|
],
|
|
[ AC_MSG_RESULT(yes)
|
|
rl_without_curses_ok=yes ],
|
|
[ AC_MSG_RESULT(no) ]
|
|
)
|
|
AC_MSG_CHECKING(if readline works with -lcurses)
|
|
LIBS="$LIBS -lcurses"
|
|
AC_TRY_RUN([
|
|
#include <stdio.h>
|
|
#include <readline/readline.h>
|
|
int main() { rl_initialize(); exit(0); }
|
|
],
|
|
[AC_MSG_RESULT(yes)
|
|
rl_with_curses_ok=yes ],
|
|
[ AC_MSG_RESULT(no) ]
|
|
)
|
|
LIBS=$OLD_LIBS
|
|
|
|
if test "$rl_without_curses_ok" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(HAVE_LIBREADLINE, 1)
|
|
READLINE_LIB="-lreadline"
|
|
use_readline=1
|
|
elif test "$rl_with_curses_ok" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(HAVE_LIBREADLINE, 1)
|
|
READLINE_LIB="-lreadline -lcurses"
|
|
use_readline=1
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
echo WARNING: The readline library was disabled because it was not found.
|
|
fi
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
AC_SUBST(READLINE_LIB)
|
|
|
|
AC_CHECK_HEADER(readline/history.h,
|
|
AC_DEFINE(HAVE_READLINE_HISTORY_H)
|
|
)
|
|
|
|
INSTRUMENT_DIR='instrument/stubs'
|
|
|
|
AC_MSG_CHECKING(for instrumentation support)
|
|
AC_ARG_ENABLE(instrumentation,
|
|
[ --enable-instrumentation compile in support for instrumentation],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_INSTRUMENTATION, 1)
|
|
INSTRUMENT_VAR='$(INSTRUMENT_LIB)'
|
|
elif test "$enableval" = no; then
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_INSTRUMENTATION, 0)
|
|
INSTRUMENT_VAR=''
|
|
else
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_INSTRUMENTATION, 1)
|
|
INSTRUMENT_DIR=$enableval
|
|
INSTRUMENT_VAR='$(INSTRUMENT_LIB)'
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_INSTRUMENTATION, 0)
|
|
INSTRUMENT_VAR=''
|
|
]
|
|
)
|
|
AC_SUBST(INSTRUMENT_DIR)
|
|
AC_SUBST(INSTRUMENT_VAR)
|
|
|
|
dnl // serial mode 'socket' needs wsock32.dll in non-plugin mode
|
|
if test "$bx_plugins" = 0; then
|
|
case $target in
|
|
*-pc-windows*)
|
|
DEVICE_LINK_OPTS="$DEVICE_LINK_OPTS wsock32.lib"
|
|
;;
|
|
*-cygwin* | *-mingw32*)
|
|
DEVICE_LINK_OPTS="$DEVICE_LINK_OPTS -lwsock32"
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
AC_MSG_CHECKING(for raw serial support)
|
|
AC_ARG_ENABLE(raw-serial,
|
|
[ --enable-raw-serial use raw serial port access],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(USE_RAW_SERIAL, 1)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(USE_RAW_SERIAL, 0)
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(USE_RAW_SERIAL, 0)
|
|
]
|
|
)
|
|
|
|
AC_MSG_CHECKING(for VESA BIOS extensions)
|
|
AC_ARG_ENABLE(vbe,
|
|
[ --enable-vbe use VESA BIOS extensions],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_VBE, 1)
|
|
if test "$pci" = 1; then
|
|
AC_DEFINE(BX_SUPPORT_PCIVGA, 1)
|
|
fi
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_VBE, 0)
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_VBE, 0)
|
|
]
|
|
)
|
|
|
|
AC_MSG_CHECKING(for CLGD54XX emulation)
|
|
AC_ARG_ENABLE(clgd54xx,
|
|
[ --enable-clgd54xx enable CLGD54XX emulation],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_CLGD54XX, 1)
|
|
if test "$pci" = 1; then
|
|
AC_DEFINE(BX_SUPPORT_CLGD54XX_PCI, 1)
|
|
fi
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_CLGD54XX, 0)
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_CLGD54XX, 0)
|
|
]
|
|
)
|
|
|
|
support_fpu=1
|
|
AC_MSG_CHECKING(for FPU emulation)
|
|
FPU_VAR=''
|
|
FPU_GLUE_OBJ=''
|
|
AC_ARG_ENABLE(fpu,
|
|
[ --enable-fpu compile in FPU emulation],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_FPU, 1)
|
|
FPU_VAR='$(FPU_LIB)'
|
|
FPU_GLUE_OBJ='$(FPU_GLUE_OBJ)'
|
|
elif test "$enableval" = no; then
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_FPU, 0)
|
|
support_fpu=0
|
|
else
|
|
echo " "
|
|
echo "ERROR: --enable-fpu does not accept a path"
|
|
exit 1
|
|
fi
|
|
],
|
|
[
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_FPU, 1)
|
|
FPU_VAR='$(FPU_LIB)'
|
|
FPU_GLUE_OBJ='$(FPU_GLUE_OBJ)'
|
|
]
|
|
)
|
|
AC_SUBST(FPU_VAR)
|
|
AC_SUBST(FPU_GLUE_OBJ)
|
|
|
|
AC_MSG_CHECKING(for VME support)
|
|
AC_ARG_ENABLE(vme,
|
|
[ --enable-vme virtual 8086 mode extensions],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_VME, 1)
|
|
elif test "$enableval" = no; then
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_VME, 0)
|
|
fi
|
|
],
|
|
[
|
|
if test "$bx_cpu_level" -ge 5; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_VME, 1)
|
|
fi
|
|
]
|
|
)
|
|
|
|
support_mmx=1
|
|
AC_MSG_CHECKING(for MMX support)
|
|
AC_ARG_ENABLE(mmx,
|
|
[ --enable-mmx MMX support],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_MMX, 1)
|
|
elif test "$enableval" = no; then
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_MMX, 0)
|
|
support_mmx=0
|
|
fi
|
|
],
|
|
[
|
|
if test "$bx_cpu_level" -ge 5; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_MMX, 1)
|
|
fi
|
|
]
|
|
)
|
|
|
|
AC_MSG_CHECKING(for 3DNow! support)
|
|
AC_ARG_ENABLE(3dnow,
|
|
[ --enable-3dnow 3DNow! support],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_3DNOW, 1)
|
|
elif test "$enableval" = no; then
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_3DNOW, 0)
|
|
fi
|
|
],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_3DNOW, 0)
|
|
]
|
|
)
|
|
|
|
support_sse=0
|
|
AC_MSG_CHECKING(for SSE support)
|
|
AC_ARG_ENABLE(sse,
|
|
[ --enable-sse SSE support (--enable-sse=[no|1|2|3|4])],
|
|
[case "$enableval" in
|
|
no | 0)
|
|
support_sse=0
|
|
AC_MSG_RESULT(no)
|
|
;;
|
|
yes | 1)
|
|
support_sse=1
|
|
AC_MSG_RESULT(SSE1)
|
|
;;
|
|
2)
|
|
support_sse=2
|
|
AC_MSG_RESULT(SSE2)
|
|
;;
|
|
3)
|
|
support_sse=3
|
|
AC_MSG_RESULT(SSE3)
|
|
;;
|
|
4)
|
|
support_sse=4
|
|
AC_MSG_RESULT(SSE4)
|
|
;;
|
|
*)
|
|
echo "ERROR: --enable-sse=$enableval not understood. Use --enable-sse=[no|1|2|3|4]"
|
|
exit 1
|
|
;;
|
|
esac
|
|
],
|
|
[
|
|
if test "$use_x86_64" = 1; then
|
|
support_sse=2
|
|
AC_MSG_RESULT(SSE2)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
]
|
|
)
|
|
|
|
if test "$support_sse" -gt 0 -a "$bx_cpu_level" -lt 6; then
|
|
AC_MSG_ERROR([for SSE support the CPU level must be set to 6])
|
|
fi
|
|
|
|
if test "$support_sse" -lt 2 -a "$use_x86_64" = 1; then
|
|
AC_MSG_ERROR([x86-64 needs SSE2 support])
|
|
fi
|
|
|
|
if test "$support_sse" = 4; then
|
|
AC_DEFINE(BX_SUPPORT_SSE, 4)
|
|
elif test "$support_sse" = 3; then
|
|
AC_DEFINE(BX_SUPPORT_SSE, 3)
|
|
elif test "$support_sse" = 2; then
|
|
AC_DEFINE(BX_SUPPORT_SSE, 2)
|
|
elif test "$support_sse" = 1; then
|
|
AC_DEFINE(BX_SUPPORT_SSE, 1)
|
|
else
|
|
AC_DEFINE(BX_SUPPORT_SSE, 0)
|
|
fi
|
|
|
|
AC_MSG_CHECKING(for DAZ support)
|
|
AC_ARG_ENABLE(daz,
|
|
[ --enable-daz denormals-are-zeroes support],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_DAZ, 1)
|
|
elif test "$enableval" = no; then
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_DAZ, 0)
|
|
fi
|
|
],
|
|
[
|
|
if test "$support_sse" -ge 2; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_DAZ, 1)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_DAZ, 0)
|
|
fi
|
|
]
|
|
)
|
|
|
|
AC_MSG_CHECKING(for SEP support)
|
|
AC_ARG_ENABLE(sep,
|
|
[ --enable-sep SYSENTER/SYSEXIT support],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_SEP, 1)
|
|
elif test "$enableval" = no; then
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_SEP, 0)
|
|
fi
|
|
],
|
|
[
|
|
if test "$bx_cpu_level" -ge 6 -a "$support_mmx" = 1; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_SEP, 1)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_SEP, 0)
|
|
fi
|
|
]
|
|
)
|
|
|
|
AC_MSG_CHECKING(for x86 debugger support)
|
|
AC_ARG_ENABLE(x86-debugger,
|
|
[ --enable-x86-debugger x86 debugger support],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_X86_DEBUGGER, 1)
|
|
elif test "$enableval" = no; then
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_X86_DEBUGGER, 0)
|
|
else
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_X86_DEBUGGER, 1)
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_X86_DEBUGGER, 0)
|
|
]
|
|
)
|
|
|
|
AC_CHECK_HEADER(IOKit/storage/IOCDMedia.h,
|
|
can_use_osx_cdrom=yes
|
|
)
|
|
|
|
AC_MSG_CHECKING(for CDROM support)
|
|
AC_ARG_ENABLE(cdrom,
|
|
[ --enable-cdrom CDROM support],
|
|
[if test "$enableval" = no; then
|
|
bx_cdrom=0
|
|
else
|
|
bx_cdrom=1
|
|
fi],
|
|
[ bx_cdrom=1 ]
|
|
)
|
|
|
|
if test "$bx_cdrom" = 1; then
|
|
AC_MSG_RESULT(yes)
|
|
CDROM_OBJS='cdrom.o'
|
|
if test "$with_amigaos" = yes; then
|
|
# use the amiga cdrom file instead.
|
|
CDROM_OBJS="cdrom_amigaos.o"
|
|
elif test "$can_use_osx_cdrom" = yes; then
|
|
# use cdrom_osx
|
|
AC_MSG_RESULT(Using OSX IOKit CD Interface)
|
|
CDROM_OBJS="cdrom.o"
|
|
EXTRA_LINK_OPTS="${EXTRA_LINK_OPTS} -framework IOKit -framework CoreFoundation "'$(GUI_LINK_OPTS)'
|
|
fi
|
|
case $target in
|
|
*-beos*)
|
|
# use the beos cdrom file instead
|
|
CDROM_OBJS="$CDROM_OBJS cdrom_beos.o"
|
|
esac
|
|
AC_DEFINE(BX_SUPPORT_CDROM, 1)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
CDROM_OBJS=''
|
|
AC_DEFINE(BX_SUPPORT_CDROM, 0)
|
|
fi
|
|
|
|
AC_SUBST(CDROM_OBJS)
|
|
|
|
|
|
AC_MSG_CHECKING(for Sound Blaster 16 support)
|
|
SB16_OBJS=''
|
|
SOUNDLOW_OBJS=''
|
|
GAME_OBJS=''
|
|
gameport_present=0
|
|
AC_ARG_ENABLE(sb16,
|
|
[ --enable-sb16=xxx Sound Blaster 16 Support (xxx=dummy|win|linux|freebsd|osx)],
|
|
[if test "$enableval" = no; then
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_SB16, 0)
|
|
else
|
|
case "$enableval" in
|
|
dummy)
|
|
SOUNDLOW_OBJS=''
|
|
AC_DEFINE(BX_SOUND_OUTPUT_C, bx_sound_output_c)
|
|
AC_MSG_RESULT(dummy)
|
|
;;
|
|
freebsd|linux)
|
|
SOUNDLOW_OBJS='soundlnx.o'
|
|
AC_DEFINE(BX_SOUND_OUTPUT_C, bx_sound_linux_c)
|
|
AC_MSG_RESULT(linux)
|
|
;;
|
|
win)
|
|
SOUNDLOW_OBJS='soundwin.o'
|
|
AC_DEFINE(BX_SOUND_OUTPUT_C, bx_sound_windows_c)
|
|
AC_MSG_RESULT(win)
|
|
case $target in
|
|
*-pc-windows*)
|
|
DEVICE_LINK_OPTS="$DEVICE_LINK_OPTS winmm.lib"
|
|
;;
|
|
*)
|
|
DEVICE_LINK_OPTS="$DEVICE_LINK_OPTS -lwinmm"
|
|
;;
|
|
esac
|
|
;;
|
|
osx)
|
|
SOUNDLOW_OBJS='soundosx.o'
|
|
AC_DEFINE(BX_SOUND_OUTPUT_C, bx_sound_osx_c)
|
|
AC_MSG_RESULT(osx)
|
|
DEVICE_LINK_OPTS="$DEVICE_LINK_OPTS -framework AudioUnit -framework AudioToolbox"
|
|
;;
|
|
yes)
|
|
case "$target" in
|
|
*-linux* | *-freebsd*)
|
|
SOUNDLOW_OBJS='soundlnx.o'
|
|
AC_DEFINE(BX_SOUND_OUTPUT_C, bx_sound_linux_c)
|
|
AC_MSG_RESULT(linux)
|
|
;;
|
|
*-pc-windows*)
|
|
SOUNDLOW_OBJS='soundwin.o'
|
|
AC_DEFINE(BX_SOUND_OUTPUT_C, bx_sound_windows_c)
|
|
AC_MSG_RESULT(win)
|
|
DEVICE_LINK_OPTS="$DEVICE_LINK_OPTS winmm.lib"
|
|
;;
|
|
*-cygwin* | *-mingw32*)
|
|
SOUNDLOW_OBJS='soundwin.o'
|
|
AC_DEFINE(BX_SOUND_OUTPUT_C, bx_sound_windows_c)
|
|
AC_MSG_RESULT(win)
|
|
DEVICE_LINK_OPTS="$DEVICE_LINK_OPTS -lwinmm"
|
|
;;
|
|
*-macosx* | *-macos*)
|
|
SOUNDLOW_OBJS='soundosx.o'
|
|
AC_DEFINE(BX_SOUND_OUTPUT_C, bx_sound_osx_c)
|
|
AC_MSG_RESULT(osx)
|
|
DEVICE_LINK_OPTS="$DEVICE_LINK_OPTS -framework AudioUnit -framework AudioToolbox"
|
|
;;
|
|
*)
|
|
SOUNDLOW_OBJS=''
|
|
AC_DEFINE(BX_SOUND_OUTPUT_C, bx_sound_output_c)
|
|
AC_MSG_RESULT(dummy)
|
|
;;
|
|
esac
|
|
;;
|
|
*)
|
|
echo " "
|
|
echo \!\!\!Error\!\!\!
|
|
echo "You must pass one of dummy, linux, win, freebsd, osx to --enable-sb16"
|
|
exit 1 ;;
|
|
esac
|
|
SB16_OBJS='sb16.o'
|
|
AC_DEFINE(BX_SUPPORT_SB16, 1)
|
|
GAME_OBJS='gameport.o'
|
|
gameport_present=1
|
|
fi],
|
|
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_SB16, 0)
|
|
]
|
|
)
|
|
AC_SUBST(SB16_OBJS)
|
|
AC_SUBST(SOUNDLOW_OBJS)
|
|
|
|
|
|
AC_MSG_CHECKING(for standard PC gameport support)
|
|
AC_ARG_ENABLE(gameport,
|
|
[ --enable-gameport enable standard PC gameport support],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_GAMEPORT, 1)
|
|
if test "$gameport_present" = 0; then
|
|
GAME_OBJS='gameport.o'
|
|
case $target in
|
|
*-cygwin* | *-mingw32*)
|
|
DEVICE_LINK_OPTS="$DEVICE_LINK_OPTS -lwinmm"
|
|
;;
|
|
esac
|
|
fi
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
GAME_OBJS=''
|
|
AC_DEFINE(BX_SUPPORT_GAMEPORT, 0)
|
|
fi],
|
|
[
|
|
if test "$gameport_present" = 1; then
|
|
AC_DEFINE(BX_SUPPORT_GAMEPORT, 1)
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_DEFINE(BX_SUPPORT_GAMEPORT, 0)
|
|
AC_MSG_RESULT(no)
|
|
fi]
|
|
)
|
|
AC_SUBST(GAME_OBJS)
|
|
|
|
|
|
AC_MSG_CHECKING(for gdb stub enable)
|
|
AC_ARG_ENABLE(gdb-stub,
|
|
[ --enable-gdb-stub enable gdb stub support],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_GDBSTUB, 1)
|
|
GDBSTUB_VAR='$(GDBSTUB_OBJS)'
|
|
if test "$bx_debugger" = 1; then
|
|
AC_MSG_ERROR([[--enable-debugger and --enable-gdb-stub are mutually exclusive]])
|
|
fi
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_GDBSTUB, 0)
|
|
GDBSTUB_VAR=''
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_GDBSTUB, 0)
|
|
GDBSTUB_VAR=''
|
|
]
|
|
)
|
|
AC_SUBST(GDBSTUB_VAR)
|
|
|
|
|
|
AC_MSG_CHECKING(for I/O Interface to the debugger)
|
|
IODEBUG_OBJS=''
|
|
AC_ARG_ENABLE(iodebug,
|
|
[ --enable-iodebug enable I/O interface to debugger],
|
|
[if test "$enableval" = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_IODEBUG, 1)
|
|
IODEBUG_OBJS='iodebug.o'
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_DEFINE(BX_SUPPORT_IODEBUG, 0)
|
|
fi
|
|
],
|
|
[
|
|
if test "" = 1; then
|
|
# enable by default if debugger is on
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(BX_SUPPORT_IODEBUG, 1)
|
|
IODEBUG_OBJS='iodebug.o'
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
]
|
|
)
|
|
AC_SUBST(IODEBUG_OBJS)
|
|
|
|
|
|
AC_PATH_PROG(DOCBOOK2HTML, docbook2html, not_found)
|
|
AC_MSG_CHECKING(whether to build docbook documentation)
|
|
build_docbook=0
|
|
AC_ARG_ENABLE(docbook,
|
|
[ --enable-docbook build the Docbook documentation],
|
|
[
|
|
if test "$enableval" = yes; then build_docbook=1; fi
|
|
],
|
|
[
|
|
dnl Not specified. If they have docbook2html, then yes.
|
|
if test "$DOCBOOK2HTML" != not_found; then build_docbook=1; fi
|
|
]
|
|
)
|
|
|
|
if test $build_docbook = 1; then
|
|
AC_MSG_RESULT(yes)
|
|
BUILD_DOCBOOK_VAR=build_docbook
|
|
INSTALL_DOCBOOK_VAR=install_docbook
|
|
if test "$DOCBOOK2HTML" = not_found; then
|
|
echo "ERROR: docbook2html must be installed to build the documentation"
|
|
exit 1
|
|
fi
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
AC_SUBST(BUILD_DOCBOOK_VAR)
|
|
AC_SUBST(INSTALL_DOCBOOK_VAR)
|
|
AC_SUBST(DOCBOOK2HTML)
|
|
|
|
PRIMARY_TARGET='bochs'
|
|
PLUGIN_LIBNAME_TRANSFORMATION='%.o=libbx_%.la'
|
|
|
|
AC_DEFINE(BX_PROVIDE_DEVICE_MODELS, 1)
|
|
IODEV_LIB_VAR='iodev/libiodev.a'
|
|
AC_DEFINE(BX_PROVIDE_CPU_MEMORY, 1)
|
|
NONINLINE_VAR='$(NONINLINE_OBJS)'
|
|
|
|
AC_SUBST(IODEV_LIB_VAR)
|
|
AC_SUBST(EXTRA_BX_OBJS)
|
|
AC_SUBST(NONINLINE_VAR)
|
|
AC_SUBST(INLINE_VAR)
|
|
AC_SUBST(EXTERNAL_DEPENDENCY)
|
|
AC_SUBST(EXT_DEBUG_OBJS)
|
|
AC_SUBST(RC_CMD)
|
|
|
|
|
|
AC_ARG_WITH(x11,
|
|
[ --with-x11 use X11 GUI],
|
|
)
|
|
|
|
AC_ARG_WITH(beos,
|
|
[ --with-beos use BeOS GUI],
|
|
)
|
|
|
|
AC_ARG_WITH(win32,
|
|
[ --with-win32 use Win32 GUI],
|
|
)
|
|
|
|
AC_ARG_WITH(macos,
|
|
[ --with-macos use Macintosh/CodeWarrior environment],
|
|
)
|
|
|
|
AC_ARG_WITH(carbon,
|
|
[ --with-carbon compile for MacOS X with Carbon GUI],
|
|
)
|
|
|
|
AC_ARG_WITH(nogui,
|
|
[ --with-nogui no native GUI, just use blank stubs],
|
|
)
|
|
|
|
AC_ARG_WITH(term,
|
|
[ --with-term textmode terminal environment],
|
|
)
|
|
|
|
AC_ARG_WITH(rfb,
|
|
[ --with-rfb use RFB protocol, works with VNC viewer],
|
|
)
|
|
|
|
AC_ARG_WITH(amigaos,
|
|
[ --with-amigaos use AmigaOS (or MorphOS) GUI],
|
|
)
|
|
|
|
AC_ARG_WITH(sdl,
|
|
[ --with-sdl use SDL libraries],
|
|
)
|
|
|
|
AC_ARG_WITH(svga,
|
|
[ --with-svga use SVGALib libraries],
|
|
)
|
|
|
|
AC_ARG_WITH(wx,
|
|
[ --with-wx use wxWidgets libraries],
|
|
)
|
|
|
|
AC_ARG_WITH(all-libs,
|
|
[ --with-all-libs compile all guis that Bochs supports],
|
|
)
|
|
|
|
dnl // DASH is option prefix for your platform
|
|
dnl // SLASH is directory for your platform
|
|
dnl // CXXFP is C++ File Prefix; the flag that tells the compiler
|
|
dnl // this is a C++ source file
|
|
dnl // CFP is C File Prefix; the flag that tells the compiler
|
|
dnl // this is a C source file
|
|
dnl // OFP is Object File Prefix; the flag that tells the compiler
|
|
dnl // generate an object file with this name
|
|
DASH="-"
|
|
SLASH="/"
|
|
CXXFP=""
|
|
CFP=""
|
|
OFP="-o "
|
|
MAKELIB="ar rv \$@"
|
|
RMCOMMAND="rm -f "
|
|
# first define link variables without libtool
|
|
LINK="\$(CXX) -o \$@ \$(CXXFLAGS) \$(LDFLAGS)"
|
|
LINK_CONSOLE="\$(CXX) -o \$@ \$(CXXFLAGS_CONSOLE) \$(LDFLAGS)"
|
|
# unless NO_LT is set, add libtool to the front of the link command
|
|
if test "$NO_LT" != 1; then
|
|
LINK="\$(LIBTOOL) --mode=link $LINK"
|
|
LINK_CONSOLE="\$(LIBTOOL) --mode=link $LINK_CONSOLE"
|
|
fi
|
|
EXE=""
|
|
COMMAND_SEPARATOR="&& \\"
|
|
CD_UP_ONE="echo done"
|
|
CD_UP_TWO="echo done"
|
|
CD_UP_THREE="echo done"
|
|
|
|
INSTALL_TARGET=install_unix
|
|
INSTALL_LIST_FOR_PLATFORM=
|
|
|
|
# check for existence of and usable version of wxWidgets. This comes
|
|
# early so that it could affect which one gets chosen.
|
|
if test x$WX_CONFIG = x; then
|
|
AC_CHECK_PROG(WX_CONFIG, [ wx-config --version ], wx-config, not_found)
|
|
fi
|
|
AC_MSG_CHECKING(for wxWidgets configuration script)
|
|
AC_MSG_RESULT($WX_CONFIG)
|
|
|
|
ok_wx_version=0
|
|
wx_multi_lib=0
|
|
wx_needs_gtk2=0
|
|
AC_MSG_CHECKING(for wxWidgets library version)
|
|
if test x$WX_CONFIG != xnot_found; then
|
|
WX_VERSION=`$WX_CONFIG --version`
|
|
WX_BASENAME=`$WX_CONFIG --basename`
|
|
[
|
|
# test that version >= 2.3.2. Anybody have a better way to do this? Yuck.
|
|
case x$WX_VERSION in
|
|
x2.[012]*) ;; # less than version 2.3.x
|
|
x2.3.[01]) ;; # less than version 2.3.2
|
|
x2.3.[2-4]*) ok_wx_version=1 ;; # 2.3.2 or greater
|
|
x2.[4-5]*) ok_wx_version=1 ;; # version 2.4 / 2.5
|
|
x2.[6-9]*) # version 2.6 or greater
|
|
ok_wx_version=1
|
|
wx_multi_lib=1
|
|
case x$WX_BASENAME in
|
|
xwx_gtk2|xwx_gtk2u) wx_needs_gtk2=1 ;;
|
|
*) ;;
|
|
esac
|
|
;;
|
|
x[3-9]*) ok_wx_version=1 ;; # version 3 or greater
|
|
*) ;; # who knows?
|
|
esac
|
|
]
|
|
fi
|
|
AC_MSG_RESULT($WX_VERSION)
|
|
if test "$cross_configure" = 0; then
|
|
if test "$ok_wx_version" = 1; then
|
|
# detected a usable version
|
|
if test "$with_all_libs" = yes; then
|
|
with_wx=yes
|
|
fi
|
|
else
|
|
AC_MSG_WARN([Bochs for wxWidgets cannot be compiled here, disabling it])
|
|
with_wx=no
|
|
fi
|
|
fi
|
|
|
|
AC_MSG_CHECKING(for default gui on this platform)
|
|
AC_MSG_RESULT($DEFAULT_GUI)
|
|
|
|
display_libs=""
|
|
|
|
# the $with_* variable tells the gui library to use, but does NOT necessarily
|
|
# indicate the platform. Settings that depend on the platform should be
|
|
# handled later.
|
|
|
|
XPM_LIB=''
|
|
if test "$with_x11" = yes; then
|
|
display_libs="$display_libs X11"
|
|
if test "$no_x" = yes; then
|
|
echo ERROR: X windows gui was selected, but X windows libraries were not found.
|
|
exit 1
|
|
fi
|
|
AC_DEFINE(BX_WITH_X11, 1)
|
|
SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_X11)"
|
|
GUI_CFLAGS="$GUI_CFLAGS \$(X_CFLAGS)"
|
|
GUI_CXXFLAGS="$GUI_CXXFLAGS \$(X_CFLAGS)"
|
|
GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_X)"
|
|
check_xpm=0
|
|
AC_MSG_CHECKING(whether user wants XPM support)
|
|
AC_ARG_ENABLE(xpm,
|
|
[ --enable-xpm enable the check for XPM support],
|
|
[if test "$enableval" = yes; then
|
|
check_xpm=0
|
|
AC_MSG_RESULT(yes)
|
|
check_xpm=1
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
check_xpm=0
|
|
fi],
|
|
[
|
|
AC_MSG_RESULT(yes)
|
|
check_xpm=1
|
|
]
|
|
)
|
|
if test $check_xpm = 1; then
|
|
AC_CHECK_HEADER(X11/xpm.h, [
|
|
AC_DEFINE(BX_HAVE_XPM_H)
|
|
XPM_LIB='-lXpm'
|
|
])
|
|
fi
|
|
fi
|
|
AC_SUBST(XPM_LIB)
|
|
|
|
if test "$with_beos" = yes; then
|
|
display_libs="$display_libs beos"
|
|
AC_DEFINE(BX_WITH_BEOS, 1)
|
|
SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_BEOS)"
|
|
GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_BEOS)"
|
|
fi
|
|
|
|
if test "$with_sdl" = yes; then
|
|
display_libs="$display_libs sdl"
|
|
AC_DEFINE(BX_WITH_SDL, 1)
|
|
SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_SDL)"
|
|
# GUI_*FLAGS are added to the compilation of every bochs file, not just
|
|
# the files in gui/*.cc.
|
|
SDL_CFLAGS=`sdl-config --cflags`
|
|
GUI_CFLAGS="$GUI_CFLAGS $SDL_CFLAGS"
|
|
GUI_CXXFLAGS="$GUI_CXXFLAGS $SDL_CFLAGS"
|
|
GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_SDL)"
|
|
if test "$with_win32" != yes -a "$with_wx" != yes; then
|
|
case $target in
|
|
*-pc-windows*)
|
|
RC_CMD="rc /fo"
|
|
EXTRA_BX_OBJS="$EXTRA_BX_OBJS win32res.o"
|
|
;;
|
|
*-cygwin* | *-mingw32*)
|
|
RC_CMD="windres -o "
|
|
EXTRA_BX_OBJS="$EXTRA_BX_OBJS win32res.o"
|
|
;;
|
|
esac
|
|
fi
|
|
fi
|
|
|
|
if test "$with_svga" = yes; then
|
|
display_libs="$display_libs svga"
|
|
AC_DEFINE(BX_WITH_SVGA, 1)
|
|
SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_SVGA)"
|
|
# GUI_*FLAGS are added to the compilation of every bochs file, not just
|
|
# the files in gui/*.cc.
|
|
GUI_CFLAGS="$GUI_CFLAGS"
|
|
GUI_CXXFLAGS="$GUI_CXXFLAGS"
|
|
GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_SVGA)"
|
|
fi
|
|
|
|
if test "$with_rfb" = yes; then
|
|
display_libs="$display_libs rfb"
|
|
AC_DEFINE(BX_WITH_RFB, 1)
|
|
SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_RFB)"
|
|
GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_RFB)"
|
|
fi
|
|
|
|
if test "$with_amigaos" = yes; then
|
|
display_libs="$display_libs amigaos"
|
|
AC_DEFINE(BX_WITH_AMIGAOS, 1)
|
|
SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_AMIGAOS)"
|
|
GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_AMIGAOS)"
|
|
fi
|
|
|
|
if test "$with_win32" = yes; then
|
|
display_libs="$display_libs win32"
|
|
AC_DEFINE(BX_WITH_WIN32, 1)
|
|
SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_WIN32)"
|
|
case $target in
|
|
*-pc-windows*)
|
|
if test "$with_wx" != yes; then
|
|
RC_CMD="rc /fo"
|
|
EXTRA_BX_OBJS="$EXTRA_BX_OBJS win32res.o"
|
|
fi
|
|
GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_WIN32_VCPP)"
|
|
;;
|
|
*-cygwin* | *-mingw32*)
|
|
if test "$with_wx" != yes; then
|
|
RC_CMD="windres -o "
|
|
EXTRA_BX_OBJS="$EXTRA_BX_OBJS win32res.o"
|
|
fi
|
|
GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_WIN32)"
|
|
;;
|
|
*) echo Unsupported compile setup: GUI library is win32, but target is neither windows nor cygwin.
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
if test "$with_macos" = yes; then
|
|
display_libs="$display_libs macos"
|
|
AC_DEFINE(BX_WITH_MACOS, 1)
|
|
SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_MACOS)"
|
|
GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_MACOS)"
|
|
fi
|
|
|
|
if test "$with_carbon" = yes; then
|
|
display_libs="$display_libs carbon"
|
|
AC_DEFINE(BX_WITH_CARBON, 1)
|
|
SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_CARBON)"
|
|
GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_CARBON)"
|
|
if test "$bx_plugins" = 1; then
|
|
PRIMARY_TARGET=bochs.app/.build_plugins # only for carbon application
|
|
else
|
|
PRIMARY_TARGET=bochs.app/.build # only for carbon application
|
|
fi
|
|
INSTALL_TARGET='install_macosx'
|
|
fi
|
|
|
|
if test "$with_term" = yes; then
|
|
display_libs="$display_libs term"
|
|
AC_DEFINE(BX_WITH_TERM, 1)
|
|
SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_TERM)"
|
|
GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_TERM)"
|
|
use_curses=yes
|
|
fi
|
|
|
|
if test "$with_wx" = yes; then
|
|
display_libs="$display_libs wxWidgets"
|
|
if test "$cross_configure" = 1; then
|
|
true # do not insist, if configuring for another machine
|
|
else
|
|
if test x$ok_wx_version != x1; then
|
|
echo ERROR: A usable version of wxWidgets was not found.
|
|
echo Upgrade the library or choose another gui.
|
|
exit 1
|
|
fi
|
|
fi
|
|
AC_DEFINE(BX_WITH_WX, 1)
|
|
SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_WX)"
|
|
SPECIFIC_GUI_SUPPORT_OBJS="$SPECIFIC_GUI_SUPPORT_OBJS \$(GUI_OBJS_WX_SUPPORT)"
|
|
WX_CFLAGS="`$WX_CONFIG --cflags`"
|
|
WX_CXXFLAGS="`$WX_CONFIG --cxxflags`"
|
|
if test "$wx_multi_lib" = 1; then
|
|
GUI_LINK_OPTS_WX="`$WX_CONFIG --libs core,base`"
|
|
else
|
|
GUI_LINK_OPTS_WX="`$WX_CONFIG --libs`"
|
|
fi
|
|
if test "$wx_needs_gtk2" = 1; then
|
|
PKG_CHECK_MODULES([GTK], [gtk+-2.0], [
|
|
WX_CFLAGS="$WX_CFLAGS $GTK_CFLAGS"
|
|
WX_CXXFLAGS="$WX_CXXFLAGS $GTK_CFLAGS"
|
|
])
|
|
else
|
|
# if gtk-config exists, then add it to the cflags.
|
|
gtkconf=`gtk-config --cflags`
|
|
if test $? = 0; then
|
|
# gtk-config was found and returned 0, so it must return valid output
|
|
WX_CFLAGS="$WX_CFLAGS $gtkconf"
|
|
WX_CXXFLAGS="$WX_CXXFLAGS $gtkconf"
|
|
fi
|
|
fi
|
|
# GUI_C*FLAGS are added to the compilation of every bochs file, not just
|
|
# the files in gui/*.cc. They are not used when building other things
|
|
# such as bximage.
|
|
GUI_CFLAGS="$GUI_CFLAGS $WX_CFLAGS"
|
|
GUI_CXXFLAGS="$GUI_CXXFLAGS $WX_CXXFLAGS"
|
|
GUI_LINK_OPTS="$GUI_LINK_OPTS \$(GUI_LINK_OPTS_WX)"
|
|
# using debugger with readline is failing due to thread/signal handler
|
|
# problems.
|
|
case $target in
|
|
*-pc-windows* | *-cygwin* | *-mingw32*)
|
|
EXTRA_BX_OBJS="$EXTRA_BX_OBJS wxbochs_resources.o"
|
|
GUI_LINK_OPTS_WX="$GUI_LINK_OPTS_WX --subsystem,windows -mwindows"
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
if test "$with_nogui" = yes; then
|
|
display_libs="$display_libs nogui"
|
|
AC_DEFINE(BX_WITH_NOGUI, 1)
|
|
SPECIFIC_GUI_OBJS="$SPECIFIC_GUI_OBJS \$(GUI_OBJS_NOGUI)"
|
|
fi
|
|
|
|
AC_MSG_CHECKING(for display libraries)
|
|
AC_MSG_RESULT($display_libs)
|
|
|
|
if test "$display_libs" = ""; then
|
|
echo "No display libraries were selected. Use --with-* options to enable"
|
|
echo "individual display libraries, or --with-all-libs to detect the ones"
|
|
echo "that Bochs supports."
|
|
exit 1
|
|
fi
|
|
|
|
dnl To use wxWidgets you must select it as both the configuration interface
|
|
dnl and the display library. In the simplest case where the user has
|
|
dnl only configured with --with-wx, set both defaults to wxWidgets.
|
|
dnl Without this setting, the config interface would default to the text
|
|
dnl mode config interface, and then the wxWidgets display library would not
|
|
dnl be usable.
|
|
if test "$display_libs" = " wxWidgets"; then
|
|
AC_MSG_CHECKING(for default configuration interface)
|
|
AC_MSG_RESULT(wxWidgets)
|
|
AC_MSG_CHECKING(for default display library)
|
|
AC_MSG_RESULT(wxWidgets)
|
|
AC_DEFINE(BX_DEFAULT_CONFIG_INTERFACE, "wx")
|
|
AC_DEFINE(BX_DEFAULT_DISPLAY_LIBRARY, "wx")
|
|
AC_DEFINE(BX_USE_TEXTCONFIG, 0)
|
|
else
|
|
AC_DEFINE(BX_USE_TEXTCONFIG, 1)
|
|
fi
|
|
|
|
if test "$bx_plugins" = 1; then
|
|
# every item in this list will be compiled as a plugin. Do not include
|
|
# support objs; they will be mentioned in plugin-specific makefile rules.
|
|
GUI_PLUGIN_OBJS="$GUI_PLUGIN_OBJS $SPECIFIC_GUI_OBJS"
|
|
else
|
|
# include support objs
|
|
GUI_NON_PLUGIN_OBJS="$GUI_NON_PLUGIN_OBJS $SPECIFIC_GUI_OBJS $SPECIFIC_GUI_SUPPORT_OBJS"
|
|
fi
|
|
|
|
AC_SUBST(GUI_CFLAGS)
|
|
AC_SUBST(GUI_CXXFLAGS)
|
|
AC_SUBST(WX_CONFIG)
|
|
AC_SUBST(WX_CFLAGS)
|
|
AC_SUBST(WX_CXXFLAGS)
|
|
|
|
AC_CHECK_PROGS(WGET, wget curl fetch, not_found)
|
|
if test "$WGET" = not_found; then
|
|
AC_MSG_WARN([cannot find wget (or equivalent) command])
|
|
fi
|
|
# everybody has to re-invent the wheel. differently.
|
|
test "${WGET}" = "curl" && WGET="curl -O"
|
|
|
|
# modify settings based on target platform
|
|
case "$target" in
|
|
*-macosx*)
|
|
AC_DEFINE(BX_HAVE_STRDUP, 0)
|
|
;;
|
|
*-macos*)
|
|
AC_DEFINE(BX_HAVE_STRDUP, 0)
|
|
AC_DEFINE(BX_PLUGINS, 0)
|
|
AC_DEFINE(BX_HAVE_DLFCN_H, 0)
|
|
AC_DEFINE(BX_HAVE_SOCKLEN_T, 0)
|
|
AC_DEFINE(BX_HAVE_SELECT, 0)
|
|
AC_DEFINE(BX_HAVE_GETTIMEOFDAY, 0)
|
|
AC_DEFINE(BX_NO_ATTRIBUTES, 1)
|
|
AC_DEFINE(HAVE_TUNTAP, 0)
|
|
AC_DEFINE(HAVE_ETHERTAP, 0)
|
|
AC_DEFINE(BX_HAVE_HASH_MAP, 0)
|
|
;;
|
|
*-pc-windows*)
|
|
INSTALL_TARGET='install_win32'
|
|
CC="cl"
|
|
CXX="$CC"
|
|
#C_OPT="/Zi" # for debugging
|
|
C_OPT="/Ox" # optimize for speed
|
|
CFLAGS="/nologo /G6 /MT /W3 /GX- /DNDEBUG /DWIN32 /D_WINDOWS $C_OPT"
|
|
CXXFLAGS="$CFLAGS"
|
|
DASH="/"
|
|
SLASH="\\"
|
|
CXXFP="/Tp"
|
|
CFP="/Tc"
|
|
OFP="/Fo"
|
|
MAKE=nmake
|
|
MAKELIB="lib /nologo /subsystem:console /machine:I386 /verbose /out:\$@"
|
|
RMCOMMAND="-del"
|
|
RANLIB="echo"
|
|
#L_OPT="/debug" # for debugging
|
|
L_OPT="" # no debug info
|
|
LINK="link $L_OPT /nologo /subsystem:console /incremental:no /machine:I386 /out:\$@ "
|
|
LINK_CONSOLE=$LINK
|
|
EXE=".exe"
|
|
PRIMARY_TARGET="bochs.exe"
|
|
BXIMAGE_LINK_OPTS="user32.lib"
|
|
# also compile niclist if networking is on
|
|
if test "$networking" = yes; then
|
|
PRIMARY_TARGET="$PRIMARY_TARGET niclist.exe"
|
|
fi
|
|
COMMAND_SEPARATOR=""
|
|
CD_UP_ONE="cd .."
|
|
CD_UP_TWO="cd ..\.."
|
|
CD_UP_THREE="cd ..\..\.."
|
|
have_gettimeofday=0 # even though it may exist in build environment
|
|
AC_DEFINE(BX_64BIT_CONSTANTS_USE_LL, 0)
|
|
AC_DEFINE(inline, __inline)
|
|
AC_DEFINE(BX_NO_EMPTY_STRUCTS, 1)
|
|
AC_DEFINE(BX_NO_ATTRIBUTES, 1)
|
|
AC_DEFINE(BX_HAVE_HASH_MAP, 0)
|
|
AC_DEFINE(BX_HAVE_HASH_MAP_H, 0)
|
|
AC_DEFINE(BX_HAVE_STRTOULL, 0)
|
|
AC_DEFINE(BX_HAVE_STRTOUQ, 0)
|
|
AC_DEFINE(HAVE_LIBREADLINE, 0)
|
|
AC_DEFINE(BX_HAVE_GETTIMEOFDAY, 0)
|
|
AC_DEFINE(BX_HAVE_DLFCN_H, 0)
|
|
AC_DEFINE(BX_HAVE_MKSTEMP, 0)
|
|
AC_DEFINE(BX_HAVE_SYS_MMAN_H, 0)
|
|
AC_DEFINE(BX_HAVE_USLEEP, 0)
|
|
AC_DEFINE(HAVE_ETHERTAP, 0)
|
|
AC_DEFINE(BX_HAVE_SELECT, 1)
|
|
AC_DEFINE(BX_HAVE_SOCKLEN_T, 0)
|
|
;;
|
|
*-pc-cygwin*)
|
|
EXE=".exe"
|
|
PRIMARY_TARGET="bochs.exe"
|
|
BXIMAGE_LINK_OPTS="-luser32"
|
|
if test "$networking" = yes; then
|
|
PRIMARY_TARGET="$PRIMARY_TARGET niclist.exe"
|
|
fi
|
|
AC_DEFINE(BX_HAVE_SELECT, 1)
|
|
;;
|
|
*-pc-mingw*)
|
|
BXIMAGE_LINK_OPTS="-luser32"
|
|
if test "$networking" = yes; then
|
|
PRIMARY_TARGET="$PRIMARY_TARGET niclist"
|
|
fi
|
|
AC_DEFINE(BX_HAVE_SELECT, 1)
|
|
;;
|
|
*-beos*)
|
|
PRIMARY_TARGET=.bochs_beos_target
|
|
;;
|
|
esac
|
|
|
|
DIALOG_OBJS=""
|
|
EXPORT_DYNAMIC="-export-dynamic"
|
|
case $target in
|
|
*-pc-windows* | *-pc-winnt* | *-cygwin* | *-mingw*)
|
|
if test "$bx_plugins" = 1; then
|
|
AC_CHECK_LIB(mingwex, opendir, LIBS="$LIBS -lmingwex")
|
|
# set variables for building DLL plugins
|
|
PRIMARY_TARGET=".win32_dll_plugin_target"
|
|
PLUGIN_LIBNAME_TRANSFORMATION='%.o=bx_%.dll'
|
|
INSTALL_PLUGINS_VAR=install_dll_plugins
|
|
else
|
|
if test "$with_win32" != yes; then
|
|
LIBS="$LIBS -lcomctl32"
|
|
fi
|
|
fi
|
|
DIALOG_OBJS="win32dialog.o"
|
|
EXPORT_DYNAMIC=""
|
|
;;
|
|
esac
|
|
AC_SUBST(DIALOG_OBJS)
|
|
AC_SUBST(EXPORT_DYNAMIC)
|
|
|
|
if test "$use_curses" = yes -a "$cross_configure" = 0; then
|
|
AC_CHECK_LIB(curses, mvaddch, GUI_LINK_OPTS_TERM='-lcurses')
|
|
AC_CHECK_LIB(ncurses, mvaddch, GUI_LINK_OPTS_TERM='-lncurses')
|
|
AC_CHECK_LIB(termlib, mvaddch, GUI_LINK_OPTS_TERM='-ltermlib')
|
|
AC_CHECK_LIB(pdcurses, mvaddch, GUI_LINK_OPTS_TERM='-lpdcurses')
|
|
if test "$GUI_LINK_OPTS_TERM" = ""; then
|
|
echo Curses library not found: tried curses, ncurses, termlib and pdcurses.
|
|
exit 1
|
|
fi
|
|
fi
|
|
|
|
if test "$with_term" = yes; then
|
|
old_LIBS="$LIBS"
|
|
LIBS="$LIBS $GUI_LINK_OPTS_TERM"
|
|
AC_CHECK_FUNCS(color_set, AC_DEFINE(BX_HAVE_COLOR_SET, 1))
|
|
AC_CHECK_FUNCS(mvhline, AC_DEFINE(BX_HAVE_MVHLINE, 1))
|
|
AC_CHECK_FUNCS(mvvline, AC_DEFINE(BX_HAVE_MVVLINE, 1))
|
|
LIBS="$old_LIBS"
|
|
fi
|
|
|
|
if test "$with_rfb" = yes; then
|
|
# we need the socket function
|
|
case $target in
|
|
*-pc-windows*)
|
|
# is this okay without a check ?
|
|
RFB_LIBS="$RFB_LIBS wsock32.lib"
|
|
have_socket=yes
|
|
;;
|
|
*-pc-winnt* | *-pc-cygwin* | *-pc-mingw32*)
|
|
# is this okay without a check ?
|
|
RFB_LIBS="$RFB_LIBS -lwsock32"
|
|
have_socket=yes
|
|
;;
|
|
*)
|
|
AC_CHECK_FUNCS(socket, have_socket=yes)
|
|
if test "$have_socket" != yes; then
|
|
AC_CHECK_LIB(socket, socket,
|
|
[
|
|
RFB_LIBS="$RFB_LIBS -lsocket"
|
|
have_socket=yes
|
|
])
|
|
fi
|
|
;;
|
|
esac
|
|
if test "$have_socket" != yes; then
|
|
echo 'ERROR: socket function required for RFB compile'
|
|
exit 1
|
|
fi
|
|
fi
|
|
|
|
# The ACX_PTHREAD function was written by
|
|
# Steven G. Johnson <stevenj@alum.mit.edu> and
|
|
# Alejandro Forero Cuervo <bachue@bachue.com>
|
|
# I found it in the ac-archive project on Source Forge.
|
|
|
|
AC_DEFUN([ACX_PTHREAD], [
|
|
AC_REQUIRE([AC_CANONICAL_HOST])
|
|
acx_pthread_ok=no
|
|
|
|
# First, check if the POSIX threads header, pthread.h, is available.
|
|
# If it isn't, don't bother looking for the threads libraries.
|
|
AC_CHECK_HEADER(pthread.h, , acx_pthread_ok=noheader)
|
|
|
|
# We must check for the threads library under a number of different
|
|
# names; the ordering is very important because some systems
|
|
# (e.g. DEC) have both -lpthread and -lpthreads, where one of the
|
|
# libraries is broken (non-POSIX).
|
|
|
|
# First of all, check if the user has set any of the PTHREAD_LIBS,
|
|
# etcetera environment variables, and if threads linking works using
|
|
# them:
|
|
if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then
|
|
save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
|
|
CXXFLAGS="$CXXFLAGS $PTHREAD_CFLAGS"
|
|
save_LIBS="$LIBS"
|
|
LIBS="$PTHREAD_LIBS $LIBS"
|
|
AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS])
|
|
AC_TRY_LINK_FUNC(pthread_join, acx_pthread_ok=yes)
|
|
AC_MSG_RESULT($acx_pthread_ok)
|
|
if test x"$acx_pthread_ok" = xno; then
|
|
PTHREAD_LIBS=""
|
|
PTHREAD_CFLAGS=""
|
|
fi
|
|
LIBS="$save_LIBS"
|
|
CFLAGS="$save_CFLAGS"
|
|
fi
|
|
|
|
# Create a list of thread flags to try. Items starting with a "-" are
|
|
# C compiler flags, and other items are library names, except for "none"
|
|
# which indicates that we try without any flags at all.
|
|
|
|
acx_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mthreads pthread --thread-safe -mt"
|
|
|
|
# The ordering *is* (sometimes) important. Some notes on the
|
|
# individual items follow:
|
|
|
|
# pthreads: AIX (must check this before -lpthread)
|
|
# none: in case threads are in libc; should be tried before -Kthread and
|
|
# other compiler flags to prevent continual compiler warnings
|
|
# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h)
|
|
# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)
|
|
# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)
|
|
# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads)
|
|
# -pthreads: Solaris/gcc
|
|
# -mthreads: Mingw32/gcc, Lynx/gcc
|
|
# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it
|
|
# doesn't hurt to check since this sometimes defines pthreads too;
|
|
# also defines -D_REENTRANT)
|
|
# pthread: Linux, etcetera
|
|
# --thread-safe: KAI C++
|
|
|
|
case "${host_cpu}-${host_os}" in
|
|
*solaris*)
|
|
|
|
# On Solaris (at least, for some versions), libc contains stubbed
|
|
# (non-functional) versions of the pthreads routines, so link-based
|
|
# tests will erroneously succeed. (We need to link with -pthread or
|
|
# -lpthread.) (The stubs are missing pthread_cleanup_push, or rather
|
|
# a function called by this macro, so we could check for that, but
|
|
# who knows whether they'll stub that too in a future libc.) So,
|
|
# we'll just look for -pthreads and -lpthread first:
|
|
|
|
acx_pthread_flags="-pthread -pthreads pthread -mt $acx_pthread_flags"
|
|
;;
|
|
esac
|
|
|
|
if test x"$acx_pthread_ok" = xno; then
|
|
for flag in $acx_pthread_flags; do
|
|
|
|
case $flag in
|
|
none)
|
|
AC_MSG_CHECKING([whether pthreads work without any flags])
|
|
;;
|
|
|
|
-*)
|
|
AC_MSG_CHECKING([whether pthreads work with $flag])
|
|
PTHREAD_CFLAGS="$flag"
|
|
;;
|
|
|
|
*)
|
|
AC_MSG_CHECKING([for the pthreads library -l$flag])
|
|
PTHREAD_LIBS="-l$flag"
|
|
;;
|
|
esac
|
|
|
|
save_LIBS="$LIBS"
|
|
save_CFLAGS="$CFLAGS"
|
|
LIBS="$PTHREAD_LIBS $LIBS"
|
|
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
|
|
|
|
# Check for various functions. We must include pthread.h,
|
|
# since some functions may be macros. (On the Sequent, we
|
|
# need a special flag -Kthread to make this header compile.)
|
|
# We check for pthread_join because it is in -lpthread on IRIX
|
|
# while pthread_create is in libc. We check for pthread_attr_init
|
|
# due to DEC craziness with -lpthreads. We check for
|
|
# pthread_cleanup_push because it is one of the few pthread
|
|
# functions on Solaris that doesn't have a non-functional libc stub.
|
|
# We try pthread_create on general principles.
|
|
AC_TRY_LINK([#include <pthread.h>],
|
|
[pthread_t th; pthread_join(th, 0);
|
|
pthread_attr_init(0); pthread_cleanup_push(0, 0);
|
|
pthread_create(0,0,0,0); pthread_cleanup_pop(0); ],
|
|
[acx_pthread_ok=yes])
|
|
|
|
LIBS="$save_LIBS"
|
|
CFLAGS="$save_CFLAGS"
|
|
|
|
AC_MSG_RESULT($acx_pthread_ok)
|
|
if test "x$acx_pthread_ok" = xyes; then
|
|
break;
|
|
fi
|
|
|
|
PTHREAD_LIBS=""
|
|
PTHREAD_CFLAGS=""
|
|
done
|
|
fi
|
|
|
|
# Various other checks:
|
|
if test "x$acx_pthread_ok" = xyes; then
|
|
save_LIBS="$LIBS"
|
|
LIBS="$PTHREAD_LIBS $LIBS"
|
|
save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
|
|
|
|
# Detect AIX lossage: threads are created detached by default
|
|
# and the JOINABLE attribute has a nonstandard name (UNDETACHED).
|
|
AC_MSG_CHECKING([for joinable pthread attribute])
|
|
AC_TRY_LINK([#include <pthread.h>],
|
|
[int attr=PTHREAD_CREATE_JOINABLE;],
|
|
ok=PTHREAD_CREATE_JOINABLE, ok=unknown)
|
|
if test x"$ok" = xunknown; then
|
|
AC_TRY_LINK([#include <pthread.h>],
|
|
[int attr=PTHREAD_CREATE_UNDETACHED;],
|
|
ok=PTHREAD_CREATE_UNDETACHED, ok=unknown)
|
|
fi
|
|
if test x"$ok" != xPTHREAD_CREATE_JOINABLE; then
|
|
AC_DEFINE(PTHREAD_CREATE_JOINABLE, $ok,
|
|
[Define to the necessary symbol if this constant
|
|
uses a non-standard name on your system.])
|
|
fi
|
|
AC_MSG_RESULT(${ok})
|
|
if test x"$ok" = xunknown; then
|
|
AC_MSG_WARN([we do not know how to create joinable pthreads])
|
|
fi
|
|
|
|
AC_MSG_CHECKING([if more special flags are required for pthreads])
|
|
flag=no
|
|
case "${host_cpu}-${host_os}" in
|
|
*-aix* | *-freebsd*) flag="-D_THREAD_SAFE";;
|
|
*solaris* | alpha*-osf*) flag="-D_REENTRANT";;
|
|
esac
|
|
AC_MSG_RESULT(${flag})
|
|
if test "x$flag" != xno; then
|
|
PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS"
|
|
fi
|
|
|
|
LIBS="$save_LIBS"
|
|
CFLAGS="$save_CFLAGS"
|
|
|
|
# More AIX lossage: must compile with cc_r
|
|
AC_CHECK_PROG(PTHREAD_CC, cc_r, cc_r, ${CC})
|
|
else
|
|
PTHREAD_CC="$CC"
|
|
fi
|
|
|
|
AC_SUBST(PTHREAD_LIBS)
|
|
AC_SUBST(PTHREAD_CFLAGS)
|
|
AC_SUBST(PTHREAD_CC)
|
|
|
|
# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
|
|
if test x"$acx_pthread_ok" = xyes; then
|
|
ifelse([$1],,AC_DEFINE(HAVE_PTHREAD,1,[Define if you have POSIX threads libraries and header files.]),[$1])
|
|
:
|
|
else
|
|
acx_pthread_ok=no
|
|
$2
|
|
fi
|
|
|
|
])dnl ACX_PTHREAD
|
|
|
|
pthread_ok=no
|
|
ACX_PTHREAD([
|
|
pthread_ok=yes
|
|
#echo Using PTHREAD_LIBS=$PTHREAD_LIBS
|
|
#echo Using PTHREAD_CFLAGS=$PTHREAD_CFLAGS
|
|
#echo Using PTHREAD_CC=$PTHREAD_CC
|
|
])
|
|
|
|
|
|
# since RFB (usually) needs pthread library, check that it was found.
|
|
# But on win32 platforms, the pthread library is not needed.
|
|
if test "$with_rfb" = yes -a "$cross_configure" = 0; then
|
|
if test "$pthread_ok" = yes; then
|
|
RFB_LIBS="$RFB_LIBS $PTHREAD_LIBS"
|
|
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
|
|
CXXFLAGS="$CXXFLAGS $PTHREAD_CFLAGS"
|
|
CC="$PTHREAD_CC"
|
|
else
|
|
case "$target" in
|
|
*-pc-windows* | *-pc-winnt* | *-cygwin* | *-mingw*)
|
|
# pthread not needed for win32 platform
|
|
;;
|
|
*)
|
|
echo ERROR: --with-rfb requires the pthread library, which could not be found.; exit 1
|
|
esac
|
|
fi
|
|
fi
|
|
|
|
dnl // DEPRECATED configure options - force users to remove them
|
|
|
|
AC_MSG_CHECKING(for specified CMOS start time (deprecated))
|
|
AC_ARG_ENABLE(time0,
|
|
[ --enable-time0=n start at n (deprecated)],
|
|
[AC_MSG_RESULT($enableval)
|
|
AC_MSG_ERROR([deprecated option - use runtime option 'clock' instead])
|
|
],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
])
|
|
|
|
AC_MSG_CHECKING(for configuration interface (deprecated))
|
|
AC_ARG_ENABLE(config-interface,
|
|
[ --enable-config-interface turns on/off configuration interface (deprecated)],
|
|
[AC_MSG_RESULT($enableval)
|
|
AC_MSG_ERROR([deprecated option - configuration interface is always enabled])
|
|
],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
])
|
|
|
|
AC_MSG_CHECKING(for control panel (deprecated))
|
|
AC_ARG_ENABLE(control-panel,
|
|
[ --enable-control-panel turns on/off contol panel (deprecated)],
|
|
[AC_MSG_RESULT($enableval)
|
|
AC_MSG_ERROR([deprecated option - configuration interface is always enabled])
|
|
],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
])
|
|
|
|
AC_MSG_CHECKING(for VGA emulation (deprecated))
|
|
AC_ARG_ENABLE(vga,
|
|
[ --enable-vga use VGA emulation (deprecated)],
|
|
[AC_MSG_RESULT($enableval)
|
|
AC_MSG_ERROR([deprecated option - standard VGA emulation is always enabled])
|
|
],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
])
|
|
|
|
AC_MSG_CHECKING(for number of processors (deprecated))
|
|
AC_ARG_ENABLE(processors,
|
|
[ --enable-processors select number of processors (deprecated)],
|
|
[AC_MSG_RESULT($enableval)
|
|
AC_MSG_ERROR([deprecated - use option --enable-smp instead])
|
|
],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
])
|
|
|
|
AC_MSG_CHECKING(whether to reset on triple fault (deprecated))
|
|
AC_ARG_ENABLE(reset-on-triple-fault,
|
|
[ --enable-reset-on-triple-fault reset when cpu detects a triple fault (deprecated)],
|
|
[AC_MSG_RESULT($enableval)
|
|
AC_MSG_ERROR([deprecated - could be configured directly from .bochsrc instead])
|
|
],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
])
|
|
|
|
AC_MSG_CHECKING(PNI support (deprecated))
|
|
AC_ARG_ENABLE(--enable-pni,
|
|
[ --enable-pni PNI support (deprecated)],
|
|
[AC_MSG_RESULT($enableval)
|
|
AC_MSG_ERROR([deprecated - use --enable-sse=3 instead])
|
|
],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
])
|
|
|
|
# Create some subdirectories for when you run configure from some other
|
|
# directory.
|
|
if test ! -d instrument; then mkdir instrument; fi
|
|
if test ! -d build; then mkdir build; fi
|
|
if test ! -d build/linux; then mkdir build/linux; fi
|
|
if test ! -d build/win32; then mkdir build/win32; fi
|
|
if test ! -d build/win32/nsis; then mkdir build/win32/nsis; fi
|
|
|
|
AC_SUBST(INSTALL_TARGET)
|
|
AC_SUBST(INSTALL_LIST_FOR_PLATFORM)
|
|
AC_SUBST(RFB_LIBS)
|
|
AC_SUBST(GUI_OBJS)
|
|
AC_SUBST(DEVICE_LINK_OPTS)
|
|
AC_SUBST(GUI_LINK_OPTS)
|
|
AC_SUBST(GUI_LINK_OPTS_TERM)
|
|
AC_SUBST(GUI_LINK_OPTS_WX)
|
|
AC_SUBST(BXIMAGE_LINK_OPTS)
|
|
AC_SUBST(DASH)
|
|
AC_SUBST(SLASH)
|
|
AC_SUBST(CXXFP)
|
|
AC_SUBST(CFP)
|
|
AC_SUBST(OFP)
|
|
AC_SUBST(MAKELIB)
|
|
AC_SUBST(RMCOMMAND)
|
|
AC_SUBST(LINK)
|
|
AC_SUBST(LINK_CONSOLE)
|
|
AC_SUBST(EXE)
|
|
AC_SUBST(PRIMARY_TARGET)
|
|
AC_SUBST(PLUGIN_LIBNAME_TRANSFORMATION)
|
|
AC_SUBST(COMMAND_SEPARATOR)
|
|
AC_SUBST(CD_UP_ONE)
|
|
AC_SUBST(CD_UP_TWO)
|
|
AC_SUBST(CD_UP_THREE)
|
|
AC_SUBST(VERSION)
|
|
AC_SUBST(VER_STRING)
|
|
AC_SUBST(REL_STRING)
|
|
AC_SUBST(EXTRA_LINK_OPTS)
|
|
AC_SUBST(GUI_NON_PLUGIN_OBJS)
|
|
AC_SUBST(GUI_PLUGIN_OBJS)
|
|
AC_SUBST(IODEV_NON_PLUGIN_OBJS)
|
|
AC_SUBST(IODEV_PLUGIN_OBJS)
|
|
AC_SUBST(PLUGIN_VAR)
|
|
AC_SUBST(PLUGIN_TARGET)
|
|
AC_SUBST(INSTALL_PLUGINS_VAR)
|
|
|
|
AC_PATH_PROG(GZIP, gzip)
|
|
AC_PATH_PROG(TAR, tar)
|
|
|
|
AC_OUTPUT(Makefile iodev/Makefile bx_debug/Makefile bios/Makefile \
|
|
cpu/Makefile memory/Makefile gui/Makefile \
|
|
disasm/Makefile ${INSTRUMENT_DIR}/Makefile misc/Makefile \
|
|
fpu/Makefile doc/docbook/Makefile \
|
|
build/linux/bochs-dlx \
|
|
bxversion.h build/macosx/Info.plist \
|
|
build/win32/nsis/Makefile build/win32/nsis/bochs.nsi \
|
|
host/linux/pcidev/Makefile)
|