Diff for /qemu/configure between versions 1.1.1.5 and 1.1.1.10

version 1.1.1.5, 2018/04/24 16:44:57 version 1.1.1.10, 2018/04/24 17:27:58
Line 15  TMPC="${TMPDIR1}/qemu-conf-${RANDOM}-$$- Line 15  TMPC="${TMPDIR1}/qemu-conf-${RANDOM}-$$-
 TMPO="${TMPDIR1}/qemu-conf-${RANDOM}-$$-${RANDOM}.o"  TMPO="${TMPDIR1}/qemu-conf-${RANDOM}-$$-${RANDOM}.o"
 TMPE="${TMPDIR1}/qemu-conf-${RANDOM}-$$-${RANDOM}"  TMPE="${TMPDIR1}/qemu-conf-${RANDOM}-$$-${RANDOM}"
 TMPS="${TMPDIR1}/qemu-conf-${RANDOM}-$$-${RANDOM}.S"  TMPS="${TMPDIR1}/qemu-conf-${RANDOM}-$$-${RANDOM}.S"
   TMPI="${TMPDIR1}/qemu-conf-${RANDOM}-$$-${RANDOM}.i"
   TMPSDLLOG="${TMPDIR1}/qemu-conf-sdl-$$-${RANDOM}.log"
   
   trap "rm -f $TMPC $TMPO $TMPE $TMPS $TMPI $TMPSDLLOG; exit" 0 2 3 15
   
 # default parameters  # default parameters
 prefix=""  prefix=""
Line 22  interp_prefix="/usr/gnemul/qemu-%M" Line 26  interp_prefix="/usr/gnemul/qemu-%M"
 static="no"  static="no"
 cross_prefix=""  cross_prefix=""
 cc="gcc"  cc="gcc"
 gcc3_search="yes"  audio_drv_list=""
 gcc3_list="gcc-3.4 gcc34 gcc-3.3 gcc33 gcc-3.2 gcc32"  audio_card_list="ac97 es1370 sb16"
   audio_possible_cards="ac97 es1370 sb16 cs4231a adlib gus"
 host_cc="gcc"  host_cc="gcc"
 ar="ar"  ar="ar"
 make="make"  make="make"
 install="install"  install="install"
 strip="strip"  strip="strip"
 cpu=`uname -m`  objcopy="objcopy"
   ld="ld"
   
   # parse CC options first
   for opt do
     optarg=`expr "x$opt" : 'x[^=]*=\(.*\)'`
     case "$opt" in
     --cross-prefix=*) cross_prefix="$optarg"
     ;;
     --cc=*) cc="$optarg"
     ;;
     esac
   done
   
   # OS specific
   # Using uname is really, really broken.  Once we have the right set of checks
   # we can eliminate it's usage altogether
   
   cc="${cross_prefix}${cc}"
   ar="${cross_prefix}${ar}"
   strip="${cross_prefix}${strip}"
   objcopy="${cross_prefix}${objcopy}"
   ld="${cross_prefix}${ld}"
   
   # check that the C compiler works.
   cat > $TMPC <<EOF
   int main(void) {}
   EOF
   
   if $cc $ARCH_CFLAGS -c -o $TMPO $TMPC > /dev/null 2> /dev/null ; then
     : C compiler works ok
   else
       echo "ERROR: \"$cc\" either does not exist or does not work"
       exit 1
   fi
   
   check_define() {
   cat > $TMPC <<EOF
   #if !defined($1)
   #error Not defined
   #endif
   int main(void) { return 0; }
   EOF
     $cc $ARCH_CFLAGS -c -o $TMPO $TMPC > /dev/null 2> /dev/null
   }
   
   if check_define __i386__ ; then
     cpu="i386"
   elif check_define __x86_64__ ; then
     cpu="x86_64"
   elif check_define __sparc__ ; then
     # We can't check for 64 bit (when gcc is biarch) or V8PLUSA
     # They must be specified using --sparc_cpu
     if check_define __arch64__ ; then
       cpu="sparc64"
     else
       cpu="sparc"
     fi
   elif check_define _ARCH_PPC ; then
     if check_define _ARCH_PPC64 ; then
       cpu="ppc64"
     else
       cpu="ppc"
     fi
   else
     cpu=`uname -m`
   fi
   
 target_list=""  target_list=""
 case "$cpu" in  case "$cpu" in
   i386|i486|i586|i686|i86pc|BePC)    i386|i486|i586|i686|i86pc|BePC)
     cpu="i386"      cpu="i386"
   ;;    ;;
     x86_64|amd64)
       cpu="x86_64"
     ;;
     alpha)
       cpu="alpha"
     ;;
   armv*b)    armv*b)
     cpu="armv4b"      cpu="armv4b"
   ;;    ;;
   armv*l)    armv*l)
     cpu="armv4l"      cpu="armv4l"
   ;;    ;;
   alpha)    cris)
     cpu="alpha"      cpu="cris"
     ;;
     parisc|parisc64)
       cpu="hppa"
     ;;
     ia64)
       cpu="ia64"
     ;;
     m68k)
       cpu="m68k"
   ;;    ;;
   "Power Macintosh"|ppc|ppc64)    microblaze)
     cpu="powerpc"      cpu="microblaze"
   ;;    ;;
   mips)    mips)
     cpu="mips"      cpu="mips"
   ;;    ;;
   s390)    mips64)
       cpu="mips64"
     ;;
     ppc)
       cpu="ppc"
     ;;
     ppc64)
       cpu="ppc64"
     ;;
     s390*)
     cpu="s390"      cpu="s390"
   ;;    ;;
   sparc|sun4[muv])    sparc|sun4[cdmuv])
     cpu="sparc"      cpu="sparc"
   ;;    ;;
   sparc64)    sparc64)
     cpu="sparc64"      cpu="sparc64"
   ;;    ;;
   ia64)  
     cpu="ia64"  
   ;;  
   m68k)  
     cpu="m68k"  
   ;;  
   x86_64|amd64)  
     cpu="x86_64"  
   ;;  
   *)    *)
     cpu="unknown"      cpu="unknown"
   ;;    ;;
 esac  esac
 gprof="no"  gprof="no"
   debug_tcg="no"
   debug="no"
   sparse="no"
   strip_opt="yes"
 bigendian="no"  bigendian="no"
 mingw32="no"  mingw32="no"
 EXESUF=""  EXESUF=""
 gdbstub="yes"  
 slirp="yes"  slirp="yes"
 adlib="no"  vde="yes"
 oss="no"  
 dsound="no"  
 coreaudio="no"  
 alsa="no"  
 fmod="no"  
 fmod_lib=""  fmod_lib=""
 fmod_inc=""  fmod_inc=""
   oss_lib=""
   vnc_tls="yes"
   vnc_sasl="yes"
 bsd="no"  bsd="no"
 linux="no"  linux="no"
   solaris="no"
 kqemu="no"  kqemu="no"
 profiler="no"  profiler="no"
 cocoa="no"  cocoa="no"
 check_gfx="yes"  
 check_gcc="yes"  
 softmmu="yes"  softmmu="yes"
 linux_user="no"  linux_user="no"
 darwin_user="no"  darwin_user="no"
 build_docs="no"  bsd_user="no"
   build_docs="yes"
 uname_release=""  uname_release=""
   curses="yes"
   curl="yes"
   pthread="yes"
   aio="yes"
   io_thread="no"
   nptl="yes"
   mixemu="no"
   bluez="yes"
   kvm="no"
   kerneldir=""
   aix="no"
   blobs="yes"
   fdt="yes"
   sdl="yes"
   sdl_x11="no"
   xen="yes"
   pkgversion=""
   
 # OS specific  # OS specific
 targetos=`uname -s`  if check_define __linux__ ; then
     targetos="Linux"
   elif check_define _WIN32 ; then
     targetos='MINGW32'
   elif check_define __OpenBSD__ ; then
     targetos='OpenBSD'
   elif check_define __sun__ ; then
     targetos='SunOS'
   else
     targetos=`uname -s`
   fi
 case $targetos in  case $targetos in
 CYGWIN*)  CYGWIN*)
 mingw32="yes"  mingw32="yes"
 OS_CFLAGS="-mno-cygwin"  OS_CFLAGS="-mno-cygwin"
   if [ "$cpu" = "i386" ] ; then
       kqemu="yes"
   fi
   audio_possible_drivers="sdl"
 ;;  ;;
 MINGW32*)  MINGW32*)
 mingw32="yes"  mingw32="yes"
   if [ "$cpu" = "i386" ] ; then
       kqemu="yes"
   fi
   audio_possible_drivers="dsound sdl fmod"
   ;;
   GNU/kFreeBSD)
   audio_drv_list="oss"
   audio_possible_drivers="oss sdl esd pa"
   if [ "$cpu" = "i386" -o "$cpu" = "x86_64" ] ; then
       kqemu="yes"
   fi
 ;;  ;;
 FreeBSD)  FreeBSD)
 bsd="yes"  bsd="yes"
 oss="yes"  audio_drv_list="oss"
   audio_possible_drivers="oss sdl esd pa"
 if [ "$cpu" = "i386" -o "$cpu" = "x86_64" ] ; then  if [ "$cpu" = "i386" -o "$cpu" = "x86_64" ] ; then
     kqemu="yes"      kqemu="yes"
 fi  fi
 ;;  ;;
   DragonFly)
   bsd="yes"
   audio_drv_list="oss"
   audio_possible_drivers="oss sdl esd pa"
   if [ "$cpu" = "i386" -o "$cpu" = "x86_64" ] ; then
       kqemu="yes"
   fi
   aio="no"
   ;;
 NetBSD)  NetBSD)
 bsd="yes"  bsd="yes"
 oss="yes"  audio_drv_list="oss"
   audio_possible_drivers="oss sdl esd"
   oss_lib="-lossaudio"
 ;;  ;;
 OpenBSD)  OpenBSD)
 bsd="yes"  bsd="yes"
 oss="yes"  openbsd="yes"
   audio_drv_list="oss"
   audio_possible_drivers="oss sdl esd"
   oss_lib="-lossaudio"
 ;;  ;;
 Darwin)  Darwin)
 bsd="yes"  bsd="yes"
 darwin="yes"  darwin="yes"
   # on Leopard most of the system is 32-bit, so we have to ask the kernel it if we can run 64-bit userspace code
   if [ "$cpu" = "i386" ] ; then
       is_x86_64=`sysctl -n hw.optional.x86_64`
       [ "$is_x86_64" = "1" ] && cpu=x86_64
   fi
   if [ "$cpu" = "x86_64" ] ; then
       OS_CFLAGS="-arch x86_64"
       LDFLAGS="-arch x86_64"
   else
       OS_CFLAGS="-mdynamic-no-pic"
   fi
 darwin_user="yes"  darwin_user="yes"
 cocoa="yes"  cocoa="yes"
 coreaudio="yes"  audio_drv_list="coreaudio"
 OS_CFLAGS="-mdynamic-no-pic"  audio_possible_drivers="coreaudio sdl fmod"
   OS_LDFLAGS="-framework CoreFoundation -framework IOKit"
 ;;  ;;
 SunOS)  SunOS)
 solaris="yes"      solaris="yes"
       make="gmake"
       install="ginstall"
       needs_libsunmath="no"
       solarisrev=`uname -r | cut -f2 -d.`
       # have to select again, because `uname -m` returns i86pc
       # even on an x86_64 box.
       solariscpu=`isainfo -k`
       if test "${solariscpu}" = "amd64" ; then
           cpu="x86_64"
       fi
       if [ "$cpu" = "i386" -o "$cpu" = "x86_64" ] ; then
           if test "$solarisrev" -le 9 ; then
               if test -f /opt/SUNWspro/prod/lib/libsunmath.so.1; then
                   needs_libsunmath="yes"
               else
                   echo "QEMU will not link correctly on Solaris 8/X86 or 9/x86 without"
                   echo "libsunmath from the Sun Studio compilers tools, due to a lack of"
                   echo "C99 math features in libm.so in Solaris 8/x86 and Solaris 9/x86"
                   echo "Studio 11 can be downloaded from www.sun.com."
                   exit 1
               fi
           fi
           if test "$solarisrev" -ge 9 ; then
               kqemu="yes"
           fi
       fi
       if test -f /usr/include/sys/soundcard.h ; then
           audio_drv_list="oss"
       fi
       audio_possible_drivers="oss sdl"
       OS_CFLAGS=-std=gnu99
   ;;
   AIX)
   aix="yes"
   make="gmake"
 ;;  ;;
 *)  *)
 oss="yes"  audio_drv_list="oss"
   audio_possible_drivers="oss alsa sdl esd pa"
 linux="yes"  linux="yes"
 linux_user="yes"  linux_user="yes"
   usb="linux"
   kvm="yes"
 if [ "$cpu" = "i386" -o "$cpu" = "x86_64" ] ; then  if [ "$cpu" = "i386" -o "$cpu" = "x86_64" ] ; then
     kqemu="yes"      kqemu="yes"
       audio_possible_drivers="$audio_possible_drivers fmod"
 fi  fi
 ;;  ;;
 esac  esac
Line 148  esac Line 344  esac
 if [ "$bsd" = "yes" ] ; then  if [ "$bsd" = "yes" ] ; then
   if [ "$darwin" != "yes" ] ; then    if [ "$darwin" != "yes" ] ; then
     make="gmake"      make="gmake"
       usb="bsd"
   fi    fi
 fi    bsd_user="yes"
   
 if [ "$solaris" = "yes" ] ; then  
     make="gmake"  
     install="ginstall"  
     solarisrev=`uname -r | cut -f2 -d.`  
     if [ "$cpu" = "i386" -o "$cpu" = "x86_64" ] ; then  
         if test "$solarisrev" -gt 10 ; then  
             kqemu="yes"  
         fi  
     fi  
 fi  fi
   
 # find source path  # find source path
 source_path=`dirname "$0"`  source_path=`dirname "$0"`
   source_path_used="no"
   workdir=`pwd`
 if [ -z "$source_path" ]; then  if [ -z "$source_path" ]; then
     source_path=`pwd`      source_path=$workdir
 else  else
     source_path=`cd "$source_path"; pwd`      source_path=`cd "$source_path"; pwd`
 fi  fi
 if test "$source_path" = `pwd` ; then  [ -f "$workdir/vl.c" ] || source_path_used="yes"
     source_path_used="no"  
 else  werror=""
     source_path_used="yes"  
 fi  
   
 for opt do  for opt do
   optarg=`expr "x$opt" : 'x[^=]*=\(.*\)'`    optarg=`expr "x$opt" : 'x[^=]*=\(.*\)'`
Line 187  for opt do Line 374  for opt do
   --source-path=*) source_path="$optarg"    --source-path=*) source_path="$optarg"
   source_path_used="yes"    source_path_used="yes"
   ;;    ;;
   --cross-prefix=*) cross_prefix="$optarg"    --cross-prefix=*)
   ;;    ;;
   --cc=*) cc="$optarg"    --cc=*)
   gcc3_search="no"  
   ;;    ;;
   --host-cc=*) host_cc="$optarg"    --host-cc=*) host_cc="$optarg"
   ;;    ;;
Line 198  for opt do Line 384  for opt do
   ;;    ;;
   --install=*) install="$optarg"    --install=*) install="$optarg"
   ;;    ;;
   --extra-cflags=*) CFLAGS="$optarg"    --extra-cflags=*) EXTRA_CFLAGS="$optarg"
   ;;    ;;
   --extra-ldflags=*) LDFLAGS="$optarg"    --extra-ldflags=*) EXTRA_LDFLAGS="$optarg"
   ;;    ;;
   --cpu=*) cpu="$optarg"    --cpu=*) cpu="$optarg"
   ;;    ;;
Line 212  for opt do Line 398  for opt do
   ;;    ;;
   --disable-sdl) sdl="no"    --disable-sdl) sdl="no"
   ;;    ;;
   --enable-coreaudio) coreaudio="yes"    --fmod-lib=*) fmod_lib="$optarg"
   ;;    ;;
   --enable-alsa) alsa="yes"    --fmod-inc=*) fmod_inc="$optarg"
   ;;    ;;
   --enable-dsound) dsound="yes"    --oss-lib=*) oss_lib="$optarg"
   ;;    ;;
   --enable-fmod) fmod="yes"    --audio-card-list=*) audio_card_list=`echo "$optarg" | sed -e 's/,/ /g'`
   ;;    ;;
   --fmod-lib=*) fmod_lib="$optarg"    --audio-drv-list=*) audio_drv_list="$optarg"
   ;;    ;;
   --fmod-inc=*) fmod_inc="$optarg"    --enable-debug-tcg) debug_tcg="yes"
     ;;
     --disable-debug-tcg) debug_tcg="no"
     ;;
     --enable-debug)
         # Enable debugging options that aren't excessively noisy
         debug_tcg="yes"
         debug="yes"
         strip_opt="no"
     ;;
     --enable-sparse) sparse="yes"
     ;;
     --disable-sparse) sparse="no"
   ;;    ;;
   --enable-mingw32) mingw32="yes" ; cross_prefix="i386-mingw32-" ; user="no"    --disable-strip) strip_opt="no"
     ;;
     --disable-vnc-tls) vnc_tls="no"
     ;;
     --disable-vnc-sasl) vnc_sasl="no"
   ;;    ;;
   --disable-slirp) slirp="no"    --disable-slirp) slirp="no"
   ;;    ;;
   --enable-adlib) adlib="yes"    --disable-vde) vde="no"
   ;;    ;;
   --disable-kqemu) kqemu="no"    --disable-kqemu) kqemu="no"
   ;;    ;;
   --enable-profiler) profiler="yes"    --disable-xen) xen="no"
     ;;
     --disable-brlapi) brlapi="no"
   ;;    ;;
   --enable-cocoa) cocoa="yes" ; coreaudio="yes" ; sdl="no"    --disable-bluez) bluez="no"
   ;;    ;;
   --disable-gfx-check) check_gfx="no"    --disable-kvm) kvm="no"
   ;;    ;;
   --disable-gcc-check) check_gcc="no"    --enable-profiler) profiler="yes"
     ;;
     --enable-cocoa)
         cocoa="yes" ;
         sdl="no" ;
         audio_drv_list="coreaudio `echo $audio_drv_list | sed s,coreaudio,,g`"
   ;;    ;;
   --disable-system) softmmu="no"    --disable-system) softmmu="no"
   ;;    ;;
Line 252  for opt do Line 461  for opt do
   ;;    ;;
   --enable-darwin-user) darwin_user="yes"    --enable-darwin-user) darwin_user="yes"
   ;;    ;;
     --disable-bsd-user) bsd_user="no"
     ;;
     --enable-bsd-user) bsd_user="yes"
     ;;
   --enable-uname-release=*) uname_release="$optarg"    --enable-uname-release=*) uname_release="$optarg"
   ;;    ;;
     --sparc_cpu=*)
         sparc_cpu="$optarg"
         case $sparc_cpu in
           v7|v8) SP_CFLAGS="-m32 -mcpu=${sparc_cpu} -D__sparc_${sparc_cpu}__"; SP_LDFLAGS="-m32"
                    target_arch2="sparc"; cpu="sparc" ;;
           v8plus|v8plusa) SP_CFLAGS="-m32 -mcpu=ultrasparc -D__sparc_${sparc_cpu}__"; SP_LDFLAGS="-m32"
                    target_arch2="sparc"; cpu="sparc" ;;
           v9)    SP_CFLAGS="-m64 -mcpu=ultrasparc -D__sparc_${sparc_cpu}__"; SP_LDFLAGS="-m64"
                    target_arch2="sparc64"; cpu="sparc64" ;;
           *)     echo "undefined SPARC architecture. Exiting";exit 1;;
         esac
     ;;
     --enable-werror) werror="yes"
     ;;
     --disable-werror) werror="no"
     ;;
     --disable-curses) curses="no"
     ;;
     --disable-curl) curl="no"
     ;;
     --disable-nptl) nptl="no"
     ;;
     --enable-mixemu) mixemu="yes"
     ;;
     --disable-pthread) pthread="no"
     ;;
     --disable-aio) aio="no"
     ;;
     --enable-io-thread) io_thread="yes"
     ;;
     --disable-blobs) blobs="no"
     ;;
     --kerneldir=*) kerneldir="$optarg"
     ;;
     --with-pkgversion=*) pkgversion=" ($optarg)"
     ;;
     --disable-docs) build_docs="no"
     ;;
     *) echo "ERROR: unknown option $opt"; show_help="yes"
     ;;
   esac    esac
 done  done
   
 # default flags for all hosts  # default flags for all hosts
 CFLAGS="$CFLAGS -Wall -O2 -g -fno-strict-aliasing"  CFLAGS="$CFLAGS -g -fno-strict-aliasing"
   if test "$debug" = "no" ; then
     CFLAGS="$CFLAGS -O2"
   fi
   CFLAGS="$CFLAGS -Wall -Wundef -Wendif-labels -Wwrite-strings -Wmissing-prototypes -Wstrict-prototypes -Wredundant-decls"
 LDFLAGS="$LDFLAGS -g"  LDFLAGS="$LDFLAGS -g"
   
   # Consult white-list to determine whether to enable werror
   # by default.  Only enable by default for git builds
   if test -z "$werror" ; then
       z_version=`cut -f3 -d. $source_path/VERSION`
       if test "$z_version" = "50" -a \
           "$linux" = "yes" ; then
           werror="yes"
       else
           werror="no"
       fi
   fi
   
   if test "$werror" = "yes" ; then
       CFLAGS="$CFLAGS -Werror"
   fi
   
   if test "$solaris" = "no" ; then
       if ld --version 2>/dev/null | grep "GNU ld" >/dev/null 2>/dev/null ; then
           LDFLAGS="$LDFLAGS -Wl,--warn-common"
       fi
   fi
   
   #
   # If cpu ~= sparc and  sparc_cpu hasn't been defined, plug in the right
   # ARCH_CFLAGS/ARCH_LDFLAGS (assume sparc_v8plus for 32-bit and sparc_v9 for 64-bit)
   #
   case "$cpu" in
       sparc) if test -z "$sparc_cpu" ; then
                  ARCH_CFLAGS="-m32 -mcpu=ultrasparc -D__sparc_v8plus__"
                  ARCH_LDFLAGS="-m32"
              else
                  ARCH_CFLAGS="${SP_CFLAGS}"
                  ARCH_LDFLAGS="${SP_LDFLAGS}"
              fi
              ARCH_CFLAGS="$ARCH_CFLAGS -ffixed-g2 -ffixed-g3"
              if test "$solaris" = "no" ; then
                  ARCH_CFLAGS="$ARCH_CFLAGS -ffixed-g1 -ffixed-g6"
              fi
              ;;
       sparc64) if test -z "$sparc_cpu" ; then
                  ARCH_CFLAGS="-m64 -mcpu=ultrasparc -D__sparc_v9__"
                  ARCH_LDFLAGS="-m64"
              else
                  ARCH_CFLAGS="${SP_CFLAGS}"
                  ARCH_LDFLAGS="${SP_LDFLAGS}"
              fi
              if test "$solaris" = "no" ; then
                  ARCH_CFLAGS="$ARCH_CFLAGS -ffixed-g5 -ffixed-g6 -ffixed-g7"
              else
                  ARCH_CFLAGS="$ARCH_CFLAGS -ffixed-g1 -ffixed-g5 -ffixed-g6 -ffixed-g7"
              fi
              ;;
       s390)
              ARCH_CFLAGS="-march=z900"
              ;;
       i386)
              ARCH_CFLAGS="-m32"
              ARCH_LDFLAGS="-m32"
              ;;
       x86_64)
              ARCH_CFLAGS="-m64"
              ARCH_LDFLAGS="-m64"
              ;;
   esac
   
 if test x"$show_help" = x"yes" ; then  if test x"$show_help" = x"yes" ; then
 cat << EOF  cat << EOF
   
Line 283  echo "  --source-path=PATH       path of Line 605  echo "  --source-path=PATH       path of
 echo "  --cross-prefix=PREFIX    use PREFIX for compile tools [$cross_prefix]"  echo "  --cross-prefix=PREFIX    use PREFIX for compile tools [$cross_prefix]"
 echo "  --cc=CC                  use C compiler CC [$cc]"  echo "  --cc=CC                  use C compiler CC [$cc]"
 echo "  --host-cc=CC             use C compiler CC [$host_cc] for dyngen etc."  echo "  --host-cc=CC             use C compiler CC [$host_cc] for dyngen etc."
   echo "  --extra-cflags=CFLAGS    append extra C compiler flags CFLAGS"
   echo "  --extra-ldflags=LDFLAGS  append extra linker flags LDFLAGS"
 echo "  --make=MAKE              use specified make [$make]"  echo "  --make=MAKE              use specified make [$make]"
 echo "  --install=INSTALL        use specified install [$install]"  echo "  --install=INSTALL        use specified install [$install]"
 echo "  --static                 enable static build [$static]"  echo "  --static                 enable static build [$static]"
   echo "  --enable-debug-tcg       enable TCG debugging"
   echo "  --disable-debug-tcg      disable TCG debugging (default)"
   echo "  --enable-debug           enable common debug build options"
   echo "  --enable-sparse          enable sparse checker"
   echo "  --disable-sparse         disable sparse checker (default)"
   echo "  --disable-strip          disable stripping binaries"
   echo "  --disable-werror         disable compilation abort on warning"
   echo "  --disable-sdl            disable SDL"
 echo "  --enable-cocoa           enable COCOA (Mac OS X only)"  echo "  --enable-cocoa           enable COCOA (Mac OS X only)"
 echo "  --enable-mingw32         enable Win32 cross compilation with mingw32"  echo "  --audio-drv-list=LIST    set audio drivers list:"
 echo "  --enable-adlib           enable Adlib emulation"  echo "                           Available drivers: $audio_possible_drivers"
 echo "  --enable-coreaudio       enable Coreaudio audio driver"  echo "  --audio-card-list=LIST   set list of emulated audio cards [$audio_card_list]"
 echo "  --enable-alsa            enable ALSA audio driver"  echo "                           Available cards: $audio_possible_cards"
 echo "  --enable-fmod            enable FMOD audio driver"  echo "  --enable-mixemu          enable mixer emulation"
 echo "  --enabled-dsound         enable DirectSound audio driver"  echo "  --disable-xen            disable xen backend driver support"
   echo "  --disable-brlapi         disable BrlAPI"
   echo "  --disable-vnc-tls        disable TLS encryption for VNC server"
   echo "  --disable-vnc-sasl       disable SASL encryption for VNC server"
   echo "  --disable-curses         disable curses output"
   echo "  --disable-curl           disable curl connectivity"
   echo "  --disable-bluez          disable bluez stack connectivity"
   echo "  --disable-kvm            disable KVM acceleration support"
   echo "  --disable-nptl           disable usermode NPTL support"
 echo "  --enable-system          enable all system emulation targets"  echo "  --enable-system          enable all system emulation targets"
 echo "  --disable-system         disable all system emulation targets"  echo "  --disable-system         disable all system emulation targets"
 echo "  --enable-linux-user      enable all linux usermode emulation targets"  echo "  --enable-linux-user      enable all linux usermode emulation targets"
 echo "  --disable-linux-user     disable all linux usermode emulation targets"  echo "  --disable-linux-user     disable all linux usermode emulation targets"
 echo "  --enable-darwin-user     enable all darwin usermode emulation targets"  echo "  --enable-darwin-user     enable all darwin usermode emulation targets"
 echo "  --disable-darwin-user    disable all darwin usermode emulation targets"  echo "  --disable-darwin-user    disable all darwin usermode emulation targets"
   echo "  --enable-bsd-user        enable all BSD usermode emulation targets"
   echo "  --disable-bsd-user       disable all BSD usermode emulation targets"
 echo "  --fmod-lib               path to FMOD library"  echo "  --fmod-lib               path to FMOD library"
 echo "  --fmod-inc               path to FMOD includes"  echo "  --fmod-inc               path to FMOD includes"
   echo "  --oss-lib                path to OSS library"
 echo "  --enable-uname-release=R Return R for uname -r in usermode emulation"  echo "  --enable-uname-release=R Return R for uname -r in usermode emulation"
   echo "  --sparc_cpu=V            Build qemu for Sparc architecture v7, v8, v8plus, v8plusa, v9"
   echo "  --disable-vde            disable support for vde network"
   echo "  --disable-pthread        disable pthread support"
   echo "  --disable-aio            disable AIO support"
   echo "  --enable-io-thread       enable IO thread"
   echo "  --disable-blobs          disable installing provided firmware blobs"
   echo "  --kerneldir=PATH         look for kernel includes in PATH"
 echo ""  echo ""
 echo "NOTE: The object files are built at the place where configure is launched"  echo "NOTE: The object files are built at the place where configure is launched"
 exit 1  exit 1
 fi  fi
   
 cc="${cross_prefix}${cc}"  
 ar="${cross_prefix}${ar}"  
 strip="${cross_prefix}${strip}"  
   
 # check that the C compiler works.  
 cat > $TMPC <<EOF  
 int main(void) {}  
 EOF  
   
 if $cc -c -o $TMPO $TMPC 2>/dev/null ; then  
   : C compiler works ok  
 else  
     echo "ERROR: \"$cc\" either does not exist or does not work"  
     exit 1  
 fi  
   
 if test "$mingw32" = "yes" ; then  if test "$mingw32" = "yes" ; then
     linux="no"      linux="no"
     EXESUF=".exe"      EXESUF=".exe"
     oss="no"      oss="no"
     if [ "$cpu" = "i386" ] ; then      linux_user="no"
         kqemu="yes"      bsd_user="no"
     fi      OS_CFLAGS="$OS_CFLAGS -DWIN32_LEAN_AND_MEAN -DWINVER=0x501"
 fi  fi
   
 # Check for gcc4, error if pre-gcc4   if test ! -x "$(which cgcc 2>/dev/null)"; then
 if test "$check_gcc" = "yes" ; then      sparse="no"
     cat > $TMPC <<EOF  
 #if __GNUC__ < 4  
 #error gcc3  
 #endif  
 int main(){return 0;}  
 EOF  
     check_cc() {  
         which "$1" >&/dev/null  
         return $?  
     }  
   
     if "$cc" -o $TMPE $TMPC 2>/dev/null ; then  
         echo "WARNING: \"$cc\" looks like gcc 4.x"  
         found_compat_cc="no"  
         if test "$gcc3_search" = "yes" ; then  
             echo "Looking for gcc 3.x"  
             for compat_cc in $gcc3_list ; do  
                 if check_cc "$compat_cc" ; then  
                     echo "Found \"$compat_cc\""  
                     cc="$compat_cc"  
                     found_compat_cc="yes"  
                     break  
                 fi  
             done  
             if test "$found_compat_cc" = "no" ; then  
                 echo "gcc 3.x not found!"  
             fi  
         fi  
         if test "$found_compat_cc" = "no" ; then  
             echo "QEMU is known to have problems when compiled with gcc 4.x"  
             echo "It is recommended that you use gcc 3.x to build QEMU"  
             echo "To use this compiler anyway, configure with --disable-gcc-check"  
             exit 1;  
         fi  
     fi  
 fi  fi
   
 #  #
 # Solaris specific configure tool chain decisions  # Solaris specific configure tool chain decisions
 #  #
 if test "$solaris" = "yes" ; then  if test "$solaris" = "yes" ; then
   #  
   # gcc for solaris 10/fcs in /usr/sfw/bin doesn't compile qemu correctly  
   # override the check with --disable-gcc-check  
   #   
   if test "$solarisrev" -eq 10 -a "$check_gcc" = "yes" ; then  
     solgcc=`which $cc`  
     if test "$solgcc" = "/usr/sfw/bin/gcc" ; then  
       echo "Solaris 10/FCS gcc in /usr/sfw/bin will not compiled qemu correctly."  
       echo "please get gcc-3.4.3 or later, from www.blastwave.org using pkg-get -i gcc3"  
       echo "or get the latest patch from SunSolve for gcc"  
       exit 1  
     fi  
   fi  
   solinst=`which $install 2> /dev/null | /usr/bin/grep -v "no $install in"`    solinst=`which $install 2> /dev/null | /usr/bin/grep -v "no $install in"`
   if test -z "$solinst" ; then    if test -z "$solinst" ; then
     echo "Solaris install program not found. Use --install=/usr/ucb/install or"      echo "Solaris install program not found. Use --install=/usr/ucb/install or"
Line 409  if test "$solaris" = "yes" ; then Line 695  if test "$solaris" = "yes" ; then
     fi      fi
     exit 1      exit 1
   fi    fi
 fi   fi
   
   
 if test -z "$target_list" ; then  if test -z "$target_list" ; then
 # these targets are portable  # these targets are portable
     if [ "$softmmu" = "yes" ] ; then      if [ "$softmmu" = "yes" ] ; then
         target_list="i386-softmmu ppc-softmmu sparc-softmmu x86_64-softmmu mips-softmmu mipsel-softmmu arm-softmmu"          target_list="\
   i386-softmmu \
   x86_64-softmmu \
   arm-softmmu \
   cris-softmmu \
   m68k-softmmu \
   microblaze-softmmu \
   mips-softmmu \
   mipsel-softmmu \
   mips64-softmmu \
   mips64el-softmmu \
   ppc-softmmu \
   ppcemb-softmmu \
   ppc64-softmmu \
   sh4-softmmu \
   sh4eb-softmmu \
   sparc-softmmu \
   sparc64-softmmu \
   "
     fi      fi
 # the following are Linux specific  # the following are Linux specific
     if [ "$linux_user" = "yes" ] ; then      if [ "$linux_user" = "yes" ] ; then
         target_list="i386-linux-user arm-linux-user armeb-linux-user sparc-linux-user ppc-linux-user mips-linux-user mipsel-linux-user m68k-linux-user $target_list"          target_list="${target_list}\
   i386-linux-user \
   x86_64-linux-user \
   alpha-linux-user \
   arm-linux-user \
   armeb-linux-user \
   cris-linux-user \
   m68k-linux-user \
   microblaze-linux-user \
   mips-linux-user \
   mipsel-linux-user \
   ppc-linux-user \
   ppc64-linux-user \
   ppc64abi32-linux-user \
   sh4-linux-user \
   sh4eb-linux-user \
   sparc-linux-user \
   sparc64-linux-user \
   sparc32plus-linux-user \
   "
     fi      fi
 # the following are Darwin specific  # the following are Darwin specific
     if [ "$darwin_user" = "yes" ] ; then      if [ "$darwin_user" = "yes" ] ; then
         target_list="i386-darwin-user ppc-darwin-user $target_list"          target_list="$target_list i386-darwin-user ppc-darwin-user "
       fi
   # the following are BSD specific
       if [ "$bsd_user" = "yes" ] ; then
           target_list="${target_list}\
   i386-bsd-user \
   x86_64-bsd-user \
   sparc-bsd-user \
   sparc64-bsd-user \
   "
     fi      fi
 else  else
     target_list=`echo "$target_list" | sed -e 's/,/ /g'`      target_list=`echo "$target_list" | sed -e 's/,/ /g'`
Line 445  int main(int argc, char ** argv){ Line 777  int main(int argc, char ** argv){
 }  }
 EOF  EOF
   
 if $cc -o $TMPE $TMPC 2>/dev/null ; then  if $cc $ARCH_CFLAGS -o $TMPE $TMPC > /dev/null 2> /dev/null ; then
 $TMPE && bigendian="yes"  $TMPE && bigendian="yes"
 else  else
 echo big/little test failed  echo big/little test failed
Line 454  fi Line 786  fi
 else  else
   
 # if cross compiling, cannot launch a program, so make a static guess  # if cross compiling, cannot launch a program, so make a static guess
 if test "$cpu" = "powerpc" -o "$cpu" = "mips" -o "$cpu" = "s390" -o "$cpu" = "sparc" -o "$cpu" = "sparc64" -o "$cpu" = "m68k" -o "$cpu" = "armv4b"; then  if test "$cpu" = "armv4b" \
        -o "$cpu" = "hppa" \
        -o "$cpu" = "m68k" \
        -o "$cpu" = "mips" \
        -o "$cpu" = "mips64" \
        -o "$cpu" = "ppc" \
        -o "$cpu" = "ppc64" \
        -o "$cpu" = "s390" \
        -o "$cpu" = "sparc" \
        -o "$cpu" = "sparc64"; then
     bigendian="yes"      bigendian="yes"
 fi  fi
   
Line 462  fi Line 803  fi
   
 # host long bits test  # host long bits test
 hostlongbits="32"  hostlongbits="32"
 if test "$cpu" = "sparc64" -o "$cpu" = "ia64" -o "$cpu" = "x86_64" -o "$cpu" = "alpha"; then  if test "$cpu" = "x86_64" \
        -o "$cpu" = "alpha" \
        -o "$cpu" = "ia64" \
        -o "$cpu" = "sparc64" \
        -o "$cpu" = "ppc64"; then
     hostlongbits="64"      hostlongbits="64"
 fi  fi
   
 # check gcc options support  # Check host NPTL support
 cat > $TMPC <<EOF  cat > $TMPC <<EOF
 int main(void) {  #include <sched.h>
   #include <linux/futex.h>
   void foo()
   {
   #if !defined(CLONE_SETTLS) || !defined(FUTEX_WAIT)
   #error bork
   #endif
 }  }
 EOF  EOF
   
 have_gcc3_options="no"  if $cc $ARCH_CFLAGS -c -o $TMPO $TMPC > /dev/null 2> /dev/null ; then
 if $cc -fno-reorder-blocks -fno-optimize-sibling-calls -o $TMPO $TMPC 2> /dev/null ; then    :
    have_gcc3_options="yes"  else
      nptl="no"
   fi
   
   ##########################################
   # zlib check
   
   cat > $TMPC << EOF
   #include <zlib.h>
   int main(void) { zlibVersion(); return 0; }
   EOF
   if $cc $ARCH_CFLAGS -o $TMPE ${OS_CFLAGS} $TMPC -lz > /dev/null 2> /dev/null ; then
       :
   else
       echo
       echo "Error: zlib check failed"
       echo "Make sure to have the zlib libs and headers installed."
       echo
       exit 1
   fi
   
   ##########################################
   # xen probe
   
   if test "$xen" = "yes" ; then
   cat > $TMPC <<EOF
   #include <xenctrl.h>
   #include <xs.h>
   int main(void) { xs_daemon_open(); xc_interface_open(); return 0; }
   EOF
      if $cc $CFLAGS $ARCH_CFLAGS -c -o $TMPO $TMPC $LDFLAGS -lxenstore -lxenctrl 2> /dev/null > /dev/null ; then
         :
      else
         xen="no"
      fi
 fi  fi
   
 ##########################################  ##########################################
Line 482  fi Line 867  fi
   
 sdl_too_old=no  sdl_too_old=no
   
 if test -z "$sdl" ; then  if test "$sdl" = "yes" ; then
       sdl_config="sdl-config"
       sdl=no
       sdl_static=no
   
 sdl_config="sdl-config"  
 sdl=no  
 sdl_static=no  
   
 if test "$mingw32" = "yes" -a ! -z "$cross_prefix" ; then  
 # win32 cross compilation case  
     sdl_config="i386-mingw32msvc-sdl-config"  
     sdl=yes  
 else  
 # normal SDL probe  
 cat > $TMPC << EOF  cat > $TMPC << EOF
 #include <SDL.h>  #include <SDL.h>
 #undef main /* We don't want SDL to override our main() */  #undef main /* We don't want SDL to override our main() */
 int main( void ) { return SDL_Init (SDL_INIT_VIDEO); }  int main( void ) { return SDL_Init (SDL_INIT_VIDEO); }
 EOF  EOF
       if $cc $ARCH_CFLAGS -o $TMPE ${OS_CFLAGS} `$sdl_config --cflags 2> /dev/null` $TMPC `$sdl_config --libs 2> /dev/null` > $TMPSDLLOG 2>&1 ; then
           _sdlversion=`$sdl_config --version | sed 's/[^0-9]//g'`
           if test "$_sdlversion" -lt 121 ; then
               sdl_too_old=yes
           else
               if test "$cocoa" = "no" ; then
                   sdl=yes
               fi
           fi
   
 if $cc -o $TMPE `$sdl_config --cflags 2> /dev/null` $TMPC `$sdl_config --libs 2> /dev/null` 2> /dev/null ; then          # static link with sdl ?
 _sdlversion=`$sdl_config --version | sed 's/[^0-9]//g'`          if test "$sdl" = "yes" ; then
 if test "$_sdlversion" -lt 121 ; then              aa="no"
 sdl_too_old=yes              `$sdl_config --static-libs 2>/dev/null | grep \\\-laa > /dev/null` && aa="yes"
               sdl_static_libs=`$sdl_config --static-libs 2>/dev/null`
               if [ "$aa" = "yes" ] ; then
                   sdl_static_libs="$sdl_static_libs `aalib-config --static-libs`"
               fi
   
               if $cc -o $TMPE ${OS_CFLAGS} `$sdl_config --cflags 2> /dev/null` $TMPC $sdl_static_libs > /dev/null 2> /dev/null; then
                   sdl_static=yes
               fi
           fi # static link
       fi # sdl compile test
 else  else
  if test "$cocoa" = "no" ; then      # Make sure to disable cocoa if sdl was set
    sdl=yes      if test "$sdl" = "yes" ; then
  fi         cocoa="no"
 fi         audio_drv_list="`echo $audio_drv_list | sed s,coreaudio,,g`"
       fi
   fi # -z $sdl
   
 # static link with sdl ?  
 if test "$sdl" = "yes" ; then  if test "$sdl" = "yes" ; then
 aa="no"  cat > $TMPC <<EOF
 `$sdl_config --static-libs | grep \\\-laa > /dev/null` && aa="yes"  #include <SDL.h>
 sdl_static_libs=`$sdl_config --static-libs`  #if defined(SDL_VIDEO_DRIVER_X11)
 if [ "$aa" = "yes" ] ; then  #include <X11/XKBlib.h>
   sdl_static_libs="$sdl_static_libs `aalib-config --static-libs`"  #else
   #error No x11 support
   #endif
   int main(void) { return 0; }
   EOF
       if $cc $ARCH_CFLAGS -o $TMPE ${OS_CFLAGS} `$sdl_config --cflags 2> /dev/null` $TMPC `$sdl_config --libs 2> /dev/null` > /dev/null 2>&1 ; then
           sdl_x11="yes"
       fi
 fi  fi
   
 if $cc -o $TMPE `$sdl_config --cflags 2> /dev/null` $TMPC $sdl_static_libs 2> /dev/null; then  ##########################################
   sdl_static=yes  # VNC TLS detection
   if test "$vnc_tls" = "yes" ; then
   cat > $TMPC <<EOF
   #include <gnutls/gnutls.h>
   int main(void) { gnutls_session_t s; gnutls_init(&s, GNUTLS_SERVER); return 0; }
   EOF
       vnc_tls_cflags=`pkg-config --cflags gnutls 2> /dev/null`
       vnc_tls_libs=`pkg-config --libs gnutls 2> /dev/null`
       if $cc $ARCH_CFLAGS -o $TMPE ${OS_CFLAGS} $vnc_tls_cflags $TMPC \
              $vnc_tls_libs > /dev/null 2> /dev/null ; then
           :
       else
           vnc_tls="no"
       fi
 fi  fi
   
 fi # static link  ##########################################
   # VNC SASL detection
   if test "$vnc_sasl" = "yes" ; then
   cat > $TMPC <<EOF
   #include <sasl/sasl.h>
   #include <stdio.h>
   int main(void) { sasl_server_init(NULL, "qemu"); return 0; }
   EOF
       # Assuming Cyrus-SASL installed in /usr prefix
       vnc_sasl_cflags=""
       vnc_sasl_libs="-lsasl2"
       if $cc $ARCH_CFLAGS -o $TMPE ${OS_CFLAGS} $vnc_sasl_cflags $TMPC \
              $vnc_sasl_libs 2> /dev/null > /dev/null ; then
           :
       else
           vnc_sasl="no"
       fi
   fi
   
 fi # sdl compile test  ##########################################
   # fnmatch() probe, used for ACL routines
   fnmatch="no"
   cat > $TMPC << EOF
   #include <fnmatch.h>
   int main(void)
   {
       fnmatch("foo", "foo", 0);
       return 0;
   }
   EOF
   if $cc $ARCH_CFLAGS -o $TMPE $TMPC > /dev/null 2> /dev/null ; then
      fnmatch="yes"
   fi
   
 fi # cross compilation  ##########################################
   # vde libraries probe
   if test "$vde" = "yes" ; then
     cat > $TMPC << EOF
   #include <libvdeplug.h>
   int main(void)
   {
       struct vde_open_args a = {0, 0, 0};
       vde_open("", "", &a);
       return 0;
   }
   EOF
       if $cc $ARCH_CFLAGS -o $TMPE $TMPC -lvdeplug > /dev/null 2> /dev/null ; then
           :
       else
           vde="no"
       fi
   fi
   
 else  ##########################################
  # Make sure to disable cocoa if sdl was set  # Sound support libraries probe
  if test "$sdl" = "yes" ; then  
    cocoa="no"  audio_drv_probe()
    coreaudio="no"  {
  fi      drv=$1
 fi # -z $sdl      hdr=$2
       lib=$3
       exp=$4
       cfl=$5
           cat > $TMPC << EOF
   #include <$hdr>
   int main(void) { $exp }
   EOF
       if $cc $ARCH_CFLAGS $cfl -o $TMPE $TMPC $lib > /dev/null 2> /dev/null ; then
           :
       else
           echo
           echo "Error: $drv check failed"
           echo "Make sure to have the $drv libs and headers installed."
           echo
           exit 1
       fi
   }
   
   audio_drv_list=`echo "$audio_drv_list" | sed -e 's/,/ /g'`
   for drv in $audio_drv_list; do
       case $drv in
       alsa)
       audio_drv_probe $drv alsa/asoundlib.h -lasound \
           "snd_pcm_t **handle; return snd_pcm_close(*handle);"
       ;;
   
       fmod)
       if test -z $fmod_lib || test -z $fmod_inc; then
           echo
           echo "Error: You must specify path to FMOD library and headers"
           echo "Example: --fmod-inc=/path/include/fmod --fmod-lib=/path/lib/libfmod-3.74.so"
           echo
           exit 1
       fi
       audio_drv_probe $drv fmod.h $fmod_lib "return FSOUND_GetVersion();" "-I $fmod_inc"
       ;;
   
       esd)
       audio_drv_probe $drv esd.h -lesd 'return esd_play_stream(0, 0, "", 0);'
       ;;
   
       pa)
       audio_drv_probe $drv pulse/simple.h -lpulse-simple \
           "pa_simple *s = NULL; pa_simple_free(s); return 0;"
       ;;
   
       oss|sdl|core|wav|dsound)
       # XXX: Probes for CoreAudio, DirectSound, SDL(?)
       ;;
   
       *)
       echo "$audio_possible_drivers" | grep -q "\<$drv\>" || {
           echo
           echo "Error: Unknown driver '$drv' selected"
           echo "Possible drivers are: $audio_possible_drivers"
           echo
           exit 1
       }
       ;;
       esac
   done
   
   ##########################################
   # BrlAPI probe
   
   if test -z "$brlapi" ; then
       brlapi=no
   cat > $TMPC << EOF
   #include <brlapi.h>
   int main( void ) { return brlapi__openConnection (NULL, NULL, NULL); }
   EOF
       if $cc ${ARCH_CFLAGS} -o $TMPE ${OS_CFLAGS} $TMPC -lbrlapi > /dev/null 2> /dev/null ; then
               brlapi=yes
       fi # brlapi compile test
   fi # -z $brlapi
   
   ##########################################
   # curses probe
   
   if test "$curses" = "yes" ; then
     curses=no
     ncurses=no
     cat > $TMPC << EOF
   #include <curses.h>
   #ifdef __OpenBSD__
   #define resize_term resizeterm
   #endif
   int main(void) { resize_term(0, 0); return curses_version(); }
   EOF
     if $cc $ARCH_CFLAGS -o $TMPE $TMPC -lncurses > /dev/null 2> /dev/null ; then
       curses=yes
       ncurses=yes
     elif $cc $ARCH_CFLAGS -o $TMPE $TMPC -lcurses > /dev/null 2> /dev/null ; then
       curses=yes
     fi
   fi # test "$curses"
   
 ##########################################  ##########################################
 # alsa sound support libraries  # curl probe
   
   if test "$curl" = "yes" ; then
     curl=no
     cat > $TMPC << EOF
   #include <curl/curl.h>
   int main(void) { return curl_easy_init(); }
   EOF
     curl_libs=`curl-config --libs 2>/dev/null`
    if $cc $ARCH_CFLAGS $curl_libs -o $TMPE $TMPC > /dev/null 2> /dev/null ; then
       curl=yes
     fi
   fi # test "$curl"
   
 if test "$alsa" = "yes" ; then  ##########################################
   # bluez support probe
   if test "$bluez" = "yes" ; then
     `pkg-config bluez 2> /dev/null` || bluez="no"
   fi
   if test "$bluez" = "yes" ; then
   cat > $TMPC << EOF    cat > $TMPC << EOF
 #include <alsa/asoundlib.h>  #include <bluetooth/bluetooth.h>
 int main(void) { snd_pcm_t **handle; return snd_pcm_close(*handle); }  int main(void) { return bt_error(0); }
 EOF  EOF
   if $cc -o $TMPE $TMPC -lasound 2> /dev/null ; then    bluez_cflags=`pkg-config --cflags bluez 2> /dev/null`
     bluez_libs=`pkg-config --libs bluez 2> /dev/null`
     if $cc $ARCH_CFLAGS -o $TMPE ${OS_CFLAGS} $bluez_cflags $TMPC \
         $bluez_libs > /dev/null 2> /dev/null ; then
     :      :
   else    else
     echo      bluez="no"
     echo "Error: Could not find alsa"    fi
     echo "Make sure to have the alsa libs and headers installed."  fi
     echo  
     exit 1  ##########################################
   # kvm probe
   if test "$kvm" = "yes" ; then
       cat > $TMPC <<EOF
   #include <linux/kvm.h>
   #if !defined(KVM_API_VERSION) || KVM_API_VERSION < 12 || KVM_API_VERSION > 12
   #error Invalid KVM version
   #endif
   #if !defined(KVM_CAP_USER_MEMORY)
   #error Missing KVM capability KVM_CAP_USER_MEMORY
   #endif
   #if !defined(KVM_CAP_SET_TSS_ADDR)
   #error Missing KVM capability KVM_CAP_SET_TSS_ADDR
   #endif
   #if !defined(KVM_CAP_DESTROY_MEMORY_REGION_WORKS)
   #error Missing KVM capability KVM_CAP_DESTROY_MEMORY_REGION_WORKS
   #endif
   int main(void) { return 0; }
   EOF
     if test "$kerneldir" != "" ; then
         kvm_cflags=-I"$kerneldir"/include
         if test \( "$cpu" = "i386" -o "$cpu" = "x86_64" \) \
            -a -d "$kerneldir/arch/x86/include" ; then
               kvm_cflags="$kvm_cflags -I$kerneldir/arch/x86/include"
           elif test "$cpu" = "ppc" -a -d "$kerneldir/arch/powerpc/include" ; then
               kvm_cflags="$kvm_cflags -I$kerneldir/arch/powerpc/include"
           elif test -d "$kerneldir/arch/$cpu/include" ; then
               kvm_cflags="$kvm_cflags -I$kerneldir/arch/$cpu/include"
         fi
     else
         kvm_cflags=""
     fi
     if $cc $ARCH_CFLAGS -o $TMPE ${OS_CFLAGS} $kvm_cflags $TMPC \
         > /dev/null 2>/dev/null ; then
       :
     else
       kvm="no";
       if [ -x "`which awk 2>/dev/null`" ] && \
          [ -x "`which grep 2>/dev/null`" ]; then
         kvmerr=`LANG=C $cc $ARCH_CFLAGS -o $TMPE ${OS_CFLAGS} $kvm_cflags $TMPC 2>&1 \
           | grep "error: " \
           | awk -F "error: " '{if (NR>1) printf(", "); printf("%s",$2);}'`
         if test "$kvmerr" != "" ; then
           kvm="no - (${kvmerr})\n\
       NOTE: To enable KVM support, update your kernel to 2.6.29+ or install \
   recent kvm-kmod from http://sourceforge.net/projects/kvm."
         fi
       fi
   fi    fi
 fi  fi
   
   ##########################################
   # pthread probe
   PTHREADLIBS_LIST="-lpthread -lpthreadGC2"
   PTHREADLIBS=""
   
   if test "$pthread" = yes; then
     pthread=no
   cat > $TMPC << EOF
   #include <pthread.h>
   int main(void) { pthread_create(0,0,0,0); return 0; }
   EOF
     for pthread_lib in $PTHREADLIBS_LIST; do
       if $cc $ARCH_CFLAGS -o $TMPE $TMPC $pthread_lib 2> /dev/null > /dev/null ; then
         pthread=yes
         PTHREADLIBS="$pthread_lib"
         break
       fi
     done
   fi
   
   if test "$pthread" = no; then
      aio=no
      io_thread=no
   fi
   
   ##########################################
   # iovec probe
   cat > $TMPC <<EOF
   #include <sys/types.h>
   #include <sys/uio.h>
   #include <unistd.h>
   int main(void) { struct iovec iov; return 0; }
   EOF
   iovec=no
   if $cc $ARCH_CFLAGS -o $TMPE $TMPC > /dev/null 2> /dev/null ; then
     iovec=yes
   fi
   
   ##########################################
   # preadv probe
   cat > $TMPC <<EOF
   #include <sys/types.h>
   #include <sys/uio.h>
   #include <unistd.h>
   int main(void) { preadv; }
   EOF
   preadv=no
   if $cc $ARCH_CFLAGS -o $TMPE $TMPC > /dev/null 2> /dev/null ; then
     preadv=yes
   fi
   
   ##########################################
   # fdt probe
   if test "$fdt" = "yes" ; then
       fdt=no
       cat > $TMPC << EOF
   int main(void) { return 0; }
   EOF
     if $cc $ARCH_CFLAGS -o $TMPE ${OS_CFLAGS} $TMPC -lfdt 2> /dev/null > /dev/null ; then
       fdt=yes
     fi
   fi
   
   #
   # Check for xxxat() functions when we are building linux-user
   # emulator.  This is done because older glibc versions don't
   # have syscall stubs for these implemented.
   #
   atfile=no
   cat > $TMPC << EOF
   #define _ATFILE_SOURCE
   #include <sys/types.h>
   #include <fcntl.h>
   #include <unistd.h>
   
   int
   main(void)
   {
           /* try to unlink nonexisting file */
           return (unlinkat(AT_FDCWD, "nonexistent_file", 0));
   }
   EOF
   if $cc $ARCH_CFLAGS -o $TMPE $TMPC 2> /dev/null > /dev/null ; then
     atfile=yes
   fi
   
   # Check for inotify functions when we are building linux-user
   # emulator.  This is done because older glibc versions don't
   # have syscall stubs for these implemented.  In that case we
   # don't provide them even if kernel supports them.
   #
   inotify=no
   cat > $TMPC << EOF
   #include <sys/inotify.h>
   
   int
   main(void)
   {
           /* try to start inotify */
           return inotify_init();
   }
   EOF
   if $cc $ARCH_CFLAGS -o $TMPE $TMPC 2> /dev/null > /dev/null ; then
     inotify=yes
   fi
   
   # check if utimensat and futimens are supported
   utimens=no
   cat > $TMPC << EOF
   #define _ATFILE_SOURCE
   #define _GNU_SOURCE
   #include <stddef.h>
   #include <fcntl.h>
   
   int main(void)
   {
       utimensat(AT_FDCWD, "foo", NULL, 0);
       futimens(0, NULL);
       return 0;
   }
   EOF
   if $cc $ARCH_CFLAGS -o $TMPE $TMPC 2> /dev/null ; then
     utimens=yes
   fi
   
   # check if pipe2 is there
   pipe2=no
   cat > $TMPC << EOF
   #define _GNU_SOURCE
   #include <unistd.h>
   #include <fcntl.h>
   
   int main(void)
   {
       int pipefd[2];
       pipe2(pipefd, O_CLOEXEC);
       return 0;
   }
   EOF
   if $cc $ARCH_CFLAGS -o $TMPE $TMPC 2> /dev/null ; then
     pipe2=yes
   fi
   
   # check if tee/splice is there. vmsplice was added same time.
   splice=no
   cat > $TMPC << EOF
   #define _GNU_SOURCE
   #include <unistd.h>
   #include <fcntl.h>
   #include <limits.h>
   
   int main(void)
   {
       int len, fd;
       len = tee(STDIN_FILENO, STDOUT_FILENO, INT_MAX, SPLICE_F_NONBLOCK);
       splice(STDIN_FILENO, NULL, fd, NULL, len, SPLICE_F_MOVE);
       return 0;
   }
   EOF
   if $cc $ARCH_CFLAGS -o $TMPE $TMPC 2> /dev/null ; then
     splice=yes
   fi
   
 # Check if tools are available to build documentation.  # Check if tools are available to build documentation.
 if [ -x "`which texi2html`" ] && [ -x "`which pod2man`" ]; then  if test "$build_docs" = "yes" -a \( ! -x "`which texi2html 2>/dev/null`" -o ! -x "`which pod2man 2>/dev/null`" \) ; then
   build_docs="yes"    build_docs="no"
 fi  fi
   
 if test "$mingw32" = "yes" ; then  ##########################################
 if test -z "$prefix" ; then  # Do we need librt
     prefix="/c/Program Files/Qemu"  CLOCKLIBS=""
   cat > $TMPC <<EOF
   #include <signal.h>
   #include <time.h>
   int main(void) { clockid_t id; return clock_gettime(id, NULL); }
   EOF
   
   rt=no
   if $cc $ARCH_CFLAGS -o $TMPE $TMPC > /dev/null 2> /dev/null ; then
     :
   elif $cc $ARCH_CFLAGS -o $TMPE $TMPC -lrt > /dev/null 2> /dev/null ; then
     rt=yes
 fi  fi
 mandir="$prefix"  
 datadir="$prefix"  if test "$rt" = "yes" ; then
 docdir="$prefix"    CLOCKLIBS="-lrt"
 bindir="$prefix"  fi
 else  
 if test -z "$prefix" ; then  if test "$mingw32" = "yes" ; then
     prefix="/usr/local"    if test -z "$prefix" ; then
 fi        prefix="c:/Program Files/Qemu"
 mandir="$prefix/share/man"    fi
 datadir="$prefix/share/qemu"    mansuffix=""
 docdir="$prefix/share/doc/qemu"    datasuffix=""
 bindir="$prefix/bin"    docsuffix=""
     binsuffix=""
   else
     if test -z "$prefix" ; then
         prefix="/usr/local"
     fi
     mansuffix="/share/man"
     datasuffix="/share/qemu"
     docsuffix="/share/doc/qemu"
     binsuffix="/bin"
 fi  fi
   
 echo "Install prefix    $prefix"  echo "Install prefix    $prefix"
 echo "BIOS directory    $datadir"  echo "BIOS directory    $prefix$datasuffix"
 echo "binary directory  $bindir"  echo "binary directory  $prefix$binsuffix"
 if test "$mingw32" = "no" ; then  if test "$mingw32" = "no" ; then
 echo "Manual directory  $mandir"  echo "Manual directory  $prefix$mansuffix"
 echo "ELF interp prefix $interp_prefix"  echo "ELF interp prefix $interp_prefix"
 fi  fi
 echo "Source path       $source_path"  echo "Source path       $source_path"
 echo "C compiler        $cc"  echo "C compiler        $cc"
 echo "Host C compiler   $host_cc"  echo "Host C compiler   $host_cc"
   echo "ARCH_CFLAGS       $ARCH_CFLAGS"
 echo "make              $make"  echo "make              $make"
 echo "install           $install"  echo "install           $install"
 echo "host CPU          $cpu"  echo "host CPU          $cpu"
 echo "host big endian   $bigendian"  echo "host big endian   $bigendian"
 echo "target list       $target_list"  echo "target list       $target_list"
   echo "tcg debug enabled $debug_tcg"
 echo "gprof enabled     $gprof"  echo "gprof enabled     $gprof"
   echo "sparse enabled    $sparse"
   echo "strip binaries    $strip_opt"
 echo "profiler          $profiler"  echo "profiler          $profiler"
 echo "static build      $static"  echo "static build      $static"
   echo "-Werror enabled   $werror"
 if test "$darwin" = "yes" ; then  if test "$darwin" = "yes" ; then
     echo "Cocoa support     $cocoa"      echo "Cocoa support     $cocoa"
 fi  fi
Line 604  echo "SDL support       $sdl" Line 1420  echo "SDL support       $sdl"
 if test "$sdl" != "no" ; then  if test "$sdl" != "no" ; then
     echo "SDL static link   $sdl_static"      echo "SDL static link   $sdl_static"
 fi  fi
   echo "curses support    $curses"
   echo "curl support      $curl"
 echo "mingw32 support   $mingw32"  echo "mingw32 support   $mingw32"
 echo "Adlib support     $adlib"  echo "Audio drivers     $audio_drv_list"
 echo "CoreAudio support $coreaudio"  echo "Extra audio cards $audio_card_list"
 echo "ALSA support      $alsa"  echo "Mixer emulation   $mixemu"
 echo "DSound support    $dsound"  echo "VNC TLS support   $vnc_tls"
 if test "$fmod" = "yes"; then  if test "$vnc_tls" = "yes" ; then
     if test -z $fmod_lib || test -z $fmod_inc; then      echo "    TLS CFLAGS    $vnc_tls_cflags"
         echo      echo "    TLS LIBS      $vnc_tls_libs"
         echo "Error: You must specify path to FMOD library and headers"  fi
         echo "Example: --fmod-inc=/path/include/fmod --fmod-lib=/path/lib/libfmod-3.74.so"  echo "VNC SASL support  $vnc_sasl"
         echo  if test "$vnc_sasl" = "yes" ; then
         exit 1      echo "    SASL CFLAGS    $vnc_sasl_cflags"
     fi      echo "    SASL LIBS      $vnc_sasl_libs"
     fmod_support=" (lib='$fmod_lib' include='$fmod_inc')"  fi
 else  if test -n "$sparc_cpu"; then
     fmod_support=""      echo "Target Sparc Arch $sparc_cpu"
 fi  fi
 echo "FMOD support      $fmod $fmod_support"  
 echo "kqemu support     $kqemu"  echo "kqemu support     $kqemu"
   echo "xen support       $xen"
   echo "brlapi support    $brlapi"
 echo "Documentation     $build_docs"  echo "Documentation     $build_docs"
 [ ! -z "$uname_release" ] && \  [ ! -z "$uname_release" ] && \
 echo "uname -r          $uname_release"  echo "uname -r          $uname_release"
   echo "NPTL support      $nptl"
   echo "vde support       $vde"
   echo "AIO support       $aio"
   echo "IO thread         $io_thread"
   echo "Install blobs     $blobs"
   echo -e "KVM support       $kvm"
   echo "fdt support       $fdt"
   echo "preadv support    $preadv"
   
 if test $sdl_too_old = "yes"; then  if test $sdl_too_old = "yes"; then
 echo "-> Your SDL version is too old - please upgrade to have SDL support"  echo "-> Your SDL version is too old - please upgrade to have SDL support"
Line 633  fi Line 1460  fi
 #if test "$sdl_static" = "no"; then  #if test "$sdl_static" = "no"; then
 #  echo "WARNING: cannot compile statically with SDL - qemu-fast won't have a graphical output"  #  echo "WARNING: cannot compile statically with SDL - qemu-fast won't have a graphical output"
 #fi  #fi
 config_mak="config-host.mak"  
 config_h="config-host.h"  
   
 #echo "Creating $config_mak and $config_h"  config_host_mak="config-host.mak"
   config_host_h="config-host.h"
   
 echo "# Automatically generated by configure - do not modify" > $config_mak  #echo "Creating $config_host_mak and $config_host_h"
 echo "# Configured with: $0 $@" >> $config_mak  
 echo "/* Automatically generated by configure - do not modify */" > $config_h  
   
 echo "prefix=$prefix" >> $config_mak  test -f $config_host_h && mv $config_host_h ${config_host_h}~
 echo "bindir=$bindir" >> $config_mak  
 echo "mandir=$mandir" >> $config_mak  echo "# Automatically generated by configure - do not modify" > $config_host_mak
 echo "datadir=$datadir" >> $config_mak  printf "# Configured with:" >> $config_host_mak
 echo "docdir=$docdir" >> $config_mak  printf " '%s'" "$0" "$@" >> $config_host_mak
 echo "#define CONFIG_QEMU_SHAREDIR \"$datadir\"" >> $config_h  echo >> $config_host_mak
 echo "MAKE=$make" >> $config_mak  echo "/* Automatically generated by configure - do not modify */" > $config_host_h
 echo "INSTALL=$install" >> $config_mak  
 echo "CC=$cc" >> $config_mak  echo "prefix=$prefix" >> $config_host_mak
 if test "$have_gcc3_options" = "yes" ; then  echo "bindir=\${prefix}$binsuffix" >> $config_host_mak
   echo "HAVE_GCC3_OPTIONS=yes" >> $config_mak  echo "mandir=\${prefix}$mansuffix" >> $config_host_mak
 fi  echo "datadir=\${prefix}$datasuffix" >> $config_host_mak
 echo "HOST_CC=$host_cc" >> $config_mak  echo "docdir=\${prefix}$docsuffix" >> $config_host_mak
 echo "AR=$ar" >> $config_mak  echo "#define CONFIG_QEMU_SHAREDIR \"$prefix$datasuffix\"" >> $config_host_h
 echo "STRIP=$strip -s -R .comment -R .note" >> $config_mak  echo "MAKE=$make" >> $config_host_mak
 echo "OS_CFLAGS=$OS_CFLAGS" >> $config_mak  echo "INSTALL=$install" >> $config_host_mak
 echo "CFLAGS=$CFLAGS" >> $config_mak  echo "INSTALL_DIR=$install -d -m0755 -p" >> $config_host_mak
 echo "LDFLAGS=$LDFLAGS" >> $config_mak  echo "INSTALL_DATA=$install -m0644 -p" >> $config_host_mak
 echo "EXESUF=$EXESUF" >> $config_mak  echo "INSTALL_PROG=$install -m0755 -p" >> $config_host_mak
 if test "$cpu" = "i386" ; then  echo "CC=$cc" >> $config_host_mak
   echo "ARCH=i386" >> $config_mak  echo "HOST_CC=$host_cc" >> $config_host_mak
   echo "#define HOST_I386 1" >> $config_h  echo "AR=$ar" >> $config_host_mak
 elif test "$cpu" = "x86_64" ; then  echo "OBJCOPY=$objcopy" >> $config_host_mak
   echo "ARCH=x86_64" >> $config_mak  echo "LD=$ld" >> $config_host_mak
   echo "#define HOST_X86_64 1" >> $config_h  echo "CFLAGS=$CFLAGS $OS_CFLAGS $ARCH_CFLAGS $EXTRA_CFLAGS" >> $config_host_mak
 elif test "$cpu" = "armv4b" ; then  echo "LDFLAGS=$LDFLAGS $OS_LDFLAGS $ARCH_LDFLAGS $EXTRA_LDFLAGS" >> $config_host_mak
   echo "ARCH=arm" >> $config_mak  echo "EXESUF=$EXESUF" >> $config_host_mak
   echo "#define HOST_ARM 1" >> $config_h  echo "PTHREADLIBS=$PTHREADLIBS" >> $config_host_mak
 elif test "$cpu" = "armv4l" ; then  echo "CLOCKLIBS=$CLOCKLIBS" >> $config_host_mak
   echo "ARCH=arm" >> $config_mak  case "$cpu" in
   echo "#define HOST_ARM 1" >> $config_h    i386|x86_64|alpha|cris|hppa|ia64|m68k|microbaze|mips|mips64|ppc|ppc64|s390|sparc|sparc64)
 elif test "$cpu" = "powerpc" ; then      ARCH=$cpu
   echo "ARCH=ppc" >> $config_mak    ;;
   echo "#define HOST_PPC 1" >> $config_h    armv4b|armv4l)
 elif test "$cpu" = "mips" ; then      ARCH=arm
   echo "ARCH=mips" >> $config_mak    ;;
   echo "#define HOST_MIPS 1" >> $config_h    *)
 elif test "$cpu" = "s390" ; then      echo "Unsupported CPU = $cpu"
   echo "ARCH=s390" >> $config_mak      exit 1
   echo "#define HOST_S390 1" >> $config_h    ;;
 elif test "$cpu" = "alpha" ; then  esac
   echo "ARCH=alpha" >> $config_mak  echo "ARCH=$ARCH" >> $config_host_mak
   echo "#define HOST_ALPHA 1" >> $config_h  arch_name=`echo $ARCH | tr '[:lower:]' '[:upper:]'`
 elif test "$cpu" = "sparc" ; then  echo "#define HOST_$arch_name 1" >> $config_host_h
   echo "ARCH=sparc" >> $config_mak  
   echo "#define HOST_SPARC 1" >> $config_h  if test "$debug_tcg" = "yes" ; then
 elif test "$cpu" = "sparc64" ; then    echo "#define DEBUG_TCG 1" >> $config_host_h
   echo "ARCH=sparc64" >> $config_mak  fi
   echo "#define HOST_SPARC64 1" >> $config_h  if test "$debug" = "yes" ; then
 elif test "$cpu" = "ia64" ; then    echo "#define DEBUG_EXEC 1" >> $config_host_h
   echo "ARCH=ia64" >> $config_mak  fi
   echo "#define HOST_IA64 1" >> $config_h  if test "$sparse" = "yes" ; then
 elif test "$cpu" = "m68k" ; then    echo "CC      := REAL_CC=\"\$(CC)\" cgcc"       >> $config_host_mak
   echo "ARCH=m68k" >> $config_mak    echo "HOST_CC := REAL_CC=\"\$(HOST_CC)\" cgcc"  >> $config_host_mak
   echo "#define HOST_M68K 1" >> $config_h    echo "CFLAGS  += -Wbitwise -Wno-transparent-union -Wno-old-initializer -Wno-non-pointer-null" >> $config_host_mak
 else  fi
   echo "Unsupported CPU"  if test "$strip_opt" = "yes" ; then
   exit 1    echo "STRIP_OPT=-s" >> $config_host_mak
 fi  fi
 if test "$bigendian" = "yes" ; then  if test "$bigendian" = "yes" ; then
   echo "WORDS_BIGENDIAN=yes" >> $config_mak    echo "WORDS_BIGENDIAN=yes" >> $config_host_mak
   echo "#define WORDS_BIGENDIAN 1" >> $config_h    echo "#define WORDS_BIGENDIAN 1" >> $config_host_h
 fi  fi
 echo "#define HOST_LONG_BITS $hostlongbits" >> $config_h  echo "#define HOST_LONG_BITS $hostlongbits" >> $config_host_h
 if test "$mingw32" = "yes" ; then  if test "$mingw32" = "yes" ; then
   echo "CONFIG_WIN32=yes" >> $config_mak    echo "CONFIG_WIN32=y" >> $config_host_mak
   echo "#define CONFIG_WIN32 1" >> $config_h    echo "#define CONFIG_WIN32 1" >> $config_host_h
 elif test -f "/usr/include/byteswap.h" ; then  else
   echo "#define HAVE_BYTESWAP_H 1" >> $config_h    cat > $TMPC << EOF
   #include <byteswap.h>
   int main(void) { return bswap_32(0); }
   EOF
     if $cc $ARCH_CFLAGS -o $TMPE $TMPC >/dev/null 2> /dev/null ; then
       echo "#define HAVE_BYTESWAP_H 1" >> $config_host_h
     fi
     cat > $TMPC << EOF
   #include <sys/endian.h>
   #include <sys/types.h>
   #include <machine/bswap.h>
   int main(void) { return bswap32(0); }
   EOF
     if $cc $ARCH_CFLAGS -o $TMPE $TMPC >/dev/null 2> /dev/null ; then
       echo "#define HAVE_MACHINE_BSWAP_H 1" >> $config_host_h
     fi
   fi
   
   if [ "$openbsd" = "yes" ] ; then
     echo "#define ENOTSUP 4096" >> $config_host_h
 fi  fi
   
 if test "$darwin" = "yes" ; then  if test "$darwin" = "yes" ; then
   echo "CONFIG_DARWIN=yes" >> $config_mak    echo "CONFIG_DARWIN=y" >> $config_host_mak
   echo "#define CONFIG_DARWIN 1" >> $config_h    echo "#define CONFIG_DARWIN 1" >> $config_host_h
   fi
   
   if test "$aix" = "yes" ; then
     echo "CONFIG_AIX=y" >> $config_host_mak
     echo "#define CONFIG_AIX 1" >> $config_host_h
 fi  fi
   
 if test "$solaris" = "yes" ; then  if test "$solaris" = "yes" ; then
   echo "CONFIG_SOLARIS=yes" >> $config_mak    echo "CONFIG_SOLARIS=y" >> $config_host_mak
   echo "#define HOST_SOLARIS $solarisrev" >> $config_h    echo "#define HOST_SOLARIS $solarisrev" >> $config_host_h
     if test "$needs_libsunmath" = "yes" ; then
       echo "NEEDS_LIBSUNMATH=yes" >> $config_host_mak
       echo "#define NEEDS_LIBSUNMATH 1" >> $config_host_h
     fi
 fi  fi
 if test "$gdbstub" = "yes" ; then  if test -n "$sparc_cpu"; then
   echo "CONFIG_GDBSTUB=yes" >> $config_mak    echo "CONFIG__sparc_${sparc_cpu}__=y" >> $config_host_mak
   echo "#define CONFIG_GDBSTUB 1" >> $config_h    echo "#define __sparc_${sparc_cpu}__ 1" >> $config_host_h
 fi  fi
 if test "$gprof" = "yes" ; then  if test "$gprof" = "yes" ; then
   echo "TARGET_GPROF=yes" >> $config_mak    echo "TARGET_GPROF=yes" >> $config_host_mak
   echo "#define HAVE_GPROF 1" >> $config_h    echo "#define HAVE_GPROF 1" >> $config_host_h
 fi  fi
 if test "$static" = "yes" ; then  if test "$static" = "yes" ; then
   echo "CONFIG_STATIC=yes" >> $config_mak    echo "CONFIG_STATIC=y" >> $config_host_mak
   echo "#define CONFIG_STATIC 1" >> $config_h    echo "#define CONFIG_STATIC 1" >> $config_host_h
 fi  fi
 if test $profiler = "yes" ; then  if test $profiler = "yes" ; then
   echo "#define CONFIG_PROFILER 1" >> $config_h    echo "#define CONFIG_PROFILER 1" >> $config_host_h
 fi  fi
 if test "$slirp" = "yes" ; then  if test "$slirp" = "yes" ; then
   echo "CONFIG_SLIRP=yes" >> $config_mak    echo "CONFIG_SLIRP=y" >> $config_host_mak
   echo "#define CONFIG_SLIRP 1" >> $config_h    echo "#define CONFIG_SLIRP 1" >> $config_host_h
   fi
   if test "$vde" = "yes" ; then
     echo "CONFIG_VDE=y" >> $config_host_mak
     echo "#define CONFIG_VDE 1" >> $config_host_h
     echo "VDE_LIBS=-lvdeplug" >> $config_host_mak
   fi
   for card in $audio_card_list; do
       def=CONFIG_`echo $card | tr '[:lower:]' '[:upper:]'`
       echo "$def=y" >> $config_host_mak
       echo "#define $def 1" >> $config_host_h
   done
   echo "#define AUDIO_DRIVERS \\" >> $config_host_h
   for drv in $audio_drv_list; do
       echo "    &${drv}_audio_driver, \\" >>$config_host_h
       def=CONFIG_`echo $drv | tr '[:lower:]' '[:upper:]'`
       echo "$def=y" >> $config_host_mak
       if test "$drv" = "fmod"; then
           echo "CONFIG_FMOD_LIB=$fmod_lib" >> $config_host_mak
           echo "CONFIG_FMOD_INC=$fmod_inc" >> $config_host_mak
       elif test "$drv" = "oss"; then
           echo "CONFIG_OSS_LIB=$oss_lib" >> $config_host_mak
       fi
   done
   echo "" >>$config_host_h
   if test "$mixemu" = "yes" ; then
     echo "CONFIG_MIXEMU=y" >> $config_host_mak
     echo "#define CONFIG_MIXEMU 1" >> $config_host_h
   fi
   if test "$vnc_tls" = "yes" ; then
     echo "CONFIG_VNC_TLS=y" >> $config_host_mak
     echo "CONFIG_VNC_TLS_CFLAGS=$vnc_tls_cflags" >> $config_host_mak
     echo "CONFIG_VNC_TLS_LIBS=$vnc_tls_libs" >> $config_host_mak
     echo "#define CONFIG_VNC_TLS 1" >> $config_host_h
   fi
   if test "$vnc_sasl" = "yes" ; then
     echo "CONFIG_VNC_SASL=y" >> $config_host_mak
     echo "CONFIG_VNC_SASL_CFLAGS=$vnc_sasl_cflags" >> $config_host_mak
     echo "CONFIG_VNC_SASL_LIBS=$vnc_sasl_libs" >> $config_host_mak
     echo "#define CONFIG_VNC_SASL 1" >> $config_host_h
 fi  fi
 if test "$adlib" = "yes" ; then  if test "$fnmatch" = "yes" ; then
   echo "CONFIG_ADLIB=yes" >> $config_mak    echo "#define HAVE_FNMATCH_H 1" >> $config_host_h
   echo "#define CONFIG_ADLIB 1" >> $config_h  
 fi  
 if test "$oss" = "yes" ; then  
   echo "CONFIG_OSS=yes" >> $config_mak  
   echo "#define CONFIG_OSS 1" >> $config_h  
 fi  
 if test "$coreaudio" = "yes" ; then  
   echo "CONFIG_COREAUDIO=yes" >> $config_mak  
   echo "#define CONFIG_COREAUDIO 1" >> $config_h  
 fi  
 if test "$alsa" = "yes" ; then  
   echo "CONFIG_ALSA=yes" >> $config_mak  
   echo "#define CONFIG_ALSA 1" >> $config_h  
 fi  
 if test "$dsound" = "yes" ; then  
   echo "CONFIG_DSOUND=yes" >> $config_mak  
   echo "#define CONFIG_DSOUND 1" >> $config_h  
 fi  
 if test "$fmod" = "yes" ; then  
   echo "CONFIG_FMOD=yes" >> $config_mak  
   echo "CONFIG_FMOD_LIB=$fmod_lib" >> $config_mak  
   echo "CONFIG_FMOD_INC=$fmod_inc" >> $config_mak  
   echo "#define CONFIG_FMOD 1" >> $config_h  
 fi  fi
 qemu_version=`head $source_path/VERSION`  qemu_version=`head $source_path/VERSION`
 echo "VERSION=$qemu_version" >>$config_mak  echo "VERSION=$qemu_version" >>$config_host_mak
 echo "#define QEMU_VERSION \"$qemu_version\"" >> $config_h  echo "#define QEMU_VERSION \"$qemu_version\"" >> $config_host_h
   
 echo "SRC_PATH=$source_path" >> $config_mak  echo "#define QEMU_PKGVERSION \"$pkgversion\"" >> $config_host_h
   
   echo "SRC_PATH=$source_path" >> $config_host_mak
 if [ "$source_path_used" = "yes" ]; then  if [ "$source_path_used" = "yes" ]; then
   echo "VPATH=$source_path" >> $config_mak    echo "VPATH=$source_path" >> $config_host_mak
 fi  fi
 echo "TARGET_DIRS=$target_list" >> $config_mak  echo "TARGET_DIRS=$target_list" >> $config_host_mak
 if [ "$build_docs" = "yes" ] ; then  if [ "$build_docs" = "yes" ] ; then
   echo "BUILD_DOCS=yes" >> $config_mak    echo "BUILD_DOCS=yes" >> $config_host_mak
   fi
   if test "$static" = "yes"; then
     sdl1=$sdl_static
   else
     sdl1=$sdl
   fi
   if test "$sdl1" = "yes" ; then
     echo "#define CONFIG_SDL 1" >> $config_host_h
     echo "CONFIG_SDL=y" >> $config_host_mak
     if test "$target_softmmu" = "no" -o "$static" = "yes"; then
       echo "SDL_LIBS=$sdl_static_libs" >> $config_host_mak
     elif test "$sdl_x11" = "yes" ; then
       echo "SDL_LIBS=`$sdl_config --libs` -lX11" >> $config_host_mak
     else
       echo "SDL_LIBS=`$sdl_config --libs`" >> $config_host_mak
     fi
     if [ "${aa}" = "yes" ] ; then
       echo "SDL_CFLAGS=`$sdl_config --cflags` `aalib-config --cflags`" >> $config_host_mak
     else
       echo "SDL_CFLAGS=`$sdl_config --cflags`" >> $config_host_mak
     fi
   fi
   if test "$cocoa" = "yes" ; then
     echo "#define CONFIG_COCOA 1" >> $config_host_h
     echo "CONFIG_COCOA=y" >> $config_host_mak
   fi
   if test "$curses" = "yes" ; then
     echo "#define CONFIG_CURSES 1" >> $config_host_h
     echo "CONFIG_CURSES=y" >> $config_host_mak
     if test "$ncurses" = "yes" ; then
       echo "CURSES_LIBS=-lncurses" >> $config_host_mak
     else
       echo "CURSES_LIBS=-lcurses" >> $config_host_mak
     fi
   fi
   if test "$atfile" = "yes" ; then
     echo "#define CONFIG_ATFILE 1" >> $config_host_h
   fi
   if test "$utimens" = "yes" ; then
     echo "#define CONFIG_UTIMENSAT 1" >> $config_host_h
   fi
   if test "$pipe2" = "yes" ; then
     echo "#define CONFIG_PIPE2 1" >> $config_host_h
   fi
   if test "$splice" = "yes" ; then
     echo "#define CONFIG_SPLICE 1" >> $config_host_h
   fi
   if test "$inotify" = "yes" ; then
     echo "#define CONFIG_INOTIFY 1" >> $config_host_h
   fi
   if test "$curl" = "yes" ; then
     echo "CONFIG_CURL=y" >> $config_host_mak
     echo "CURL_LIBS=$curl_libs" >> $config_host_mak
     echo "#define CONFIG_CURL 1" >> $config_host_h
   fi
   if test "$brlapi" = "yes" ; then
     echo "CONFIG_BRLAPI=y" >> $config_host_mak
     echo "#define CONFIG_BRLAPI 1" >> $config_host_h
     echo "BRLAPI_LIBS=-lbrlapi" >> $config_host_mak
   fi
   if test "$bluez" = "yes" ; then
     echo "CONFIG_BLUEZ=y" >> $config_host_mak
     echo "CONFIG_BLUEZ_CFLAGS=$bluez_cflags" >> $config_host_mak
     echo "CONFIG_BLUEZ_LIBS=$bluez_libs" >> $config_host_mak
     echo "#define CONFIG_BLUEZ 1" >> $config_host_h
   fi
   if test "$xen" = "yes" ; then
     echo "XEN_LIBS=-lxenstore -lxenctrl -lxenguest" >> $config_host_mak
   fi
   if test "$aio" = "yes" ; then
     echo "#define CONFIG_AIO 1" >> $config_host_h
     echo "CONFIG_AIO=y" >> $config_host_mak
   fi
   if test "$io_thread" = "yes" ; then
     echo "CONFIG_IOTHREAD=y" >> $config_host_mak
     echo "#define CONFIG_IOTHREAD 1" >> $config_host_h
   fi
   if test "$blobs" = "yes" ; then
     echo "INSTALL_BLOBS=yes" >> $config_host_mak
   fi
   if test "$iovec" = "yes" ; then
     echo "#define HAVE_IOVEC 1" >> $config_host_h
   fi
   if test "$preadv" = "yes" ; then
     echo "#define HAVE_PREADV 1" >> $config_host_h
   fi
   if test "$fdt" = "yes" ; then
     echo "#define HAVE_FDT 1" >> $config_host_h
     echo "FDT_LIBS=-lfdt" >> $config_host_mak
 fi  fi
   
 # XXX: suppress that  # XXX: suppress that
 if [ "$bsd" = "yes" ] ; then  if [ "$bsd" = "yes" ] ; then
   echo "#define O_LARGEFILE 0" >> $config_h    echo "#define O_LARGEFILE 0" >> $config_host_h
   echo "#define MAP_ANONYMOUS MAP_ANON" >> $config_h    echo "#define MAP_ANONYMOUS MAP_ANON" >> $config_host_h
   echo "#define _BSD 1" >> $config_h    echo "#define HOST_BSD 1" >> $config_host_h
 fi  fi
   
 echo "#define CONFIG_UNAME_RELEASE \"$uname_release\"" >> $config_h  echo "#define CONFIG_UNAME_RELEASE \"$uname_release\"" >> $config_host_h
   
   # USB host support
   case "$usb" in
   linux)
     echo "HOST_USB=linux" >> $config_host_mak
   ;;
   bsd)
     echo "HOST_USB=bsd" >> $config_host_mak
   ;;
   *)
     echo "HOST_USB=stub" >> $config_host_mak
   ;;
   esac
   
   # Determine what linker flags to use to force archive inclusion
   check_linker_flags()
   {
       w2=
       if test "$2" ; then
           w2=-Wl,$2
       fi
       $cc $ARCH_CFLAGS -o $TMPE $OS_CFLAGS $TMPC -Wl,$1 ${w2} >/dev/null 2>/dev/null
   }
   
   cat > $TMPC << EOF
   int main(void) { }
   EOF
   if check_linker_flags --whole-archive --no-whole-archive ; then
       # GNU ld
       echo "ARLIBS_BEGIN=-Wl,--whole-archive" >> $config_host_mak
       echo "ARLIBS_END=-Wl,--no-whole-archive" >> $config_host_mak
   elif check_linker_flags -z,allextract -z,defaultextract ; then
       # Solaris ld
       echo "ARLIBS_BEGIN=-Wl,-z,allextract" >> $config_host_mak
       echo "ARLIBS_END=-Wl,-z,defaultextract" >> $config_host_mak
   elif check_linker_flags -all_load ; then
       # Mac OS X
       echo "ARLIBS_BEGIN=-all_load" >> $config_host_mak
       echo "ARLIBS_END=" >> $config_host_mak
   else
       echo "Error: your linker does not support --whole-archive or -z."
       echo "Please report to qemu-devel@nongnu.org"
       exit 1
   fi
   
   if test "$xen" = "yes" ;
       then
       echo "CONFIG_XEN=y" >> $config_host_mak
   fi
   
   tools=
   if test `expr "$target_list" : ".*softmmu.*"` != 0 ; then
     tools="qemu-img\$(EXESUF) $tools"
     if [ "$linux" = "yes" ] ; then
         tools="qemu-nbd\$(EXESUF) qemu-io\$(EXESUF) $tools"
     elif test "$mingw32" = "yes" ; then
         tools="qemu-io\$(EXESUF) $tools"
     fi
   fi
   echo "TOOLS=$tools" >> $config_host_mak
   
   roms=
   if test \( "$cpu" = "i386" -o "$cpu" = "x86_64" \) -a \
           "$targetos" != "Darwin" ; then
     roms="optionrom"
   fi
   echo "ROMS=$roms" >> $config_host_mak
   
   if test -f ${config_host_h}~ ; then
     if cmp -s $config_host_h ${config_host_h}~ ; then
       mv ${config_host_h}~ $config_host_h
     else
       rm ${config_host_h}~
     fi
   fi
   
 for target in $target_list; do  for target in $target_list; do
 target_dir="$target"  target_dir="$target"
 config_mak=$target_dir/config.mak  config_mak=$target_dir/config.mak
 config_h=$target_dir/config.h  config_h=$target_dir/config.h
 target_cpu=`echo $target | cut -d '-' -f 1`  target_arch2=`echo $target | cut -d '-' -f 1`
 target_bigendian="no"  target_bigendian="no"
 [ "$target_cpu" = "armeb" ] && target_bigendian=yes  case "$target_arch2" in
 [ "$target_cpu" = "sparc" ] && target_bigendian=yes    armeb|m68k|microblaze|mips|mipsn32|mips64|ppc|ppcemb|ppc64|ppc64abi32|sh4eb|sparc|sparc64|sparc32plus)
 [ "$target_cpu" = "sparc64" ] && target_bigendian=yes    target_bigendian=yes
 [ "$target_cpu" = "ppc" ] && target_bigendian=yes    ;;
 [ "$target_cpu" = "ppc64" ] && target_bigendian=yes  esac
 [ "$target_cpu" = "mips" ] && target_bigendian=yes  
 [ "$target_cpu" = "sh4eb" ] && target_bigendian=yes  
 [ "$target_cpu" = "m68k" ] && target_bigendian=yes  
 target_softmmu="no"  target_softmmu="no"
 if expr $target : '.*-softmmu' > /dev/null ; then  
   target_softmmu="yes"  
 fi  
 target_user_only="no"  target_user_only="no"
 if expr $target : '.*-user' > /dev/null ; then  
   target_user_only="yes"  
 fi  
   
 target_linux_user="no"  target_linux_user="no"
 if expr $target : '.*-linux-user' > /dev/null ; then  
   target_linux_user="yes"  
 fi  
   
 target_darwin_user="no"  target_darwin_user="no"
 if expr $target : '.*-darwin-user' > /dev/null ; then  target_bsd_user="no"
   target_darwin_user="yes"  case "$target" in
 fi    ${target_arch2}-softmmu)
       target_softmmu="yes"
 if test "$target_user_only" = "no" -a "$check_gfx" = "yes" \      ;;
         -a "$sdl" = "no" -a "$cocoa" = "no" ; then    ${target_arch2}-linux-user)
     echo "ERROR: QEMU requires SDL or Cocoa for graphical output"      target_user_only="yes"
     echo "To build QEMU without graphical output configure with --disable-gfx-check"      target_linux_user="yes"
     echo "Note that this will disable all output from the virtual graphics card."      ;;
     exit 1;    ${target_arch2}-darwin-user)
 fi      target_user_only="yes"
       target_darwin_user="yes"
       ;;
     ${target_arch2}-bsd-user)
       target_user_only="yes"
       target_bsd_user="yes"
       ;;
     *)
       echo "ERROR: Target '$target' not recognised"
       exit 1
       ;;
   esac
   
 #echo "Creating $config_mak, $config_h and $target_dir/Makefile"  #echo "Creating $config_mak, $config_h and $target_dir/Makefile"
   
   test -f $config_h && mv $config_h ${config_h}~
   
 mkdir -p $target_dir  mkdir -p $target_dir
 mkdir -p $target_dir/fpu  mkdir -p $target_dir/fpu
 if test "$target" = "arm-linux-user" -o "$target" = "armeb-linux-user" ; then  mkdir -p $target_dir/tcg
   if test "$target" = "arm-linux-user" -o "$target" = "armeb-linux-user" -o "$target" = "arm-bsd-user" -o "$target" = "armeb-bsd-user" ; then
   mkdir -p $target_dir/nwfpe    mkdir -p $target_dir/nwfpe
 fi  fi
 if test "$target_user_only" = "no" ; then  
   mkdir -p $target_dir/slirp  
 fi  
   
 #  #
 # don't use ln -sf as not all "ln -sf" over write the file/link  # don't use ln -sf as not all "ln -sf" over write the file/link
Line 847  ln -s $source_path/Makefile.target $targ Line 1880  ln -s $source_path/Makefile.target $targ
   
   
 echo "# Automatically generated by configure - do not modify" > $config_mak  echo "# Automatically generated by configure - do not modify" > $config_mak
 echo "/* Automatically generated by configure - do not modify */" > $config_h  
   
   
 echo "include ../config-host.mak" >> $config_mak  echo "include ../config-host.mak" >> $config_mak
 echo "#include \"../config-host.h\"" >> $config_h  
   
 bflt="no"  bflt="no"
 interp_prefix1=`echo "$interp_prefix" | sed "s/%M/$target_cpu/g"`  elfload32="no"
 echo "#define CONFIG_QEMU_PREFIX \"$interp_prefix1\"" >> $config_h  target_nptl="no"
   interp_prefix1=`echo "$interp_prefix" | sed "s/%M/$target_arch2/g"`
 if test "$target_cpu" = "i386" ; then  echo "CONFIG_QEMU_PREFIX=\"$interp_prefix1\"" >> $config_mak
   echo "TARGET_ARCH=i386" >> $config_mak  gdb_xml_files=""
   echo "#define TARGET_ARCH \"i386\"" >> $config_h  
   echo "#define TARGET_I386 1" >> $config_h  TARGET_ARCH="$target_arch2"
   if test $kqemu = "yes" -a "$target_softmmu" = "yes" -a $cpu = "i386" ; then  TARGET_BASE_ARCH=""
     echo "#define USE_KQEMU 1" >> $config_h  TARGET_ABI_DIR=""
   fi  
 elif test "$target_cpu" = "arm" -o "$target_cpu" = "armeb" ; then  case "$target_arch2" in
   echo "TARGET_ARCH=arm" >> $config_mak    i386)
   echo "#define TARGET_ARCH \"arm\"" >> $config_h      target_phys_bits=32
   echo "#define TARGET_ARM 1" >> $config_h    ;;
   bflt="yes"    x86_64)
 elif test "$target_cpu" = "sparc" ; then      TARGET_BASE_ARCH=i386
   echo "TARGET_ARCH=sparc" >> $config_mak      target_phys_bits=64
   echo "#define TARGET_ARCH \"sparc\"" >> $config_h    ;;
   echo "#define TARGET_SPARC 1" >> $config_h    alpha)
 elif test "$target_cpu" = "sparc64" ; then      target_phys_bits=64
   echo "TARGET_ARCH=sparc64" >> $config_mak    ;;
   echo "#define TARGET_ARCH \"sparc64\"" >> $config_h    arm|armeb)
   echo "#define TARGET_SPARC 1" >> $config_h      TARGET_ARCH=arm
   echo "#define TARGET_SPARC64 1" >> $config_h      bflt="yes"
 elif test "$target_cpu" = "ppc" ; then      target_nptl="yes"
   echo "TARGET_ARCH=ppc" >> $config_mak      gdb_xml_files="arm-core.xml arm-vfp.xml arm-vfp3.xml arm-neon.xml"
   echo "#define TARGET_ARCH \"ppc\"" >> $config_h      target_phys_bits=32
   echo "#define TARGET_PPC 1" >> $config_h    ;;
 elif test "$target_cpu" = "ppc64" ; then    cris)
   echo "TARGET_ARCH=ppc64" >> $config_mak      target_nptl="yes"
   echo "#define TARGET_ARCH \"ppc64\"" >> $config_h      target_phys_bits=32
   echo "#define TARGET_PPC 1" >> $config_h    ;;
   echo "#define TARGET_PPC64 1" >> $config_h    m68k)
 elif test "$target_cpu" = "x86_64" ; then      bflt="yes"
   echo "TARGET_ARCH=x86_64" >> $config_mak      gdb_xml_files="cf-core.xml cf-fp.xml"
   echo "#define TARGET_ARCH \"x86_64\"" >> $config_h      target_phys_bits=32
   echo "#define TARGET_I386 1" >> $config_h    ;;
   echo "#define TARGET_X86_64 1" >> $config_h    microblaze)
   if test $kqemu = "yes" -a "$target_softmmu" = "yes" -a $cpu = "x86_64"  ; then      bflt="yes"
     echo "#define USE_KQEMU 1" >> $config_h      target_nptl="yes"
   fi      target_phys_bits=32
 elif test "$target_cpu" = "mips" -o "$target_cpu" = "mipsel" ; then    ;;
   echo "TARGET_ARCH=mips" >> $config_mak    mips|mipsel)
   echo "#define TARGET_ARCH \"mips\"" >> $config_h      TARGET_ARCH=mips
   echo "#define TARGET_MIPS 1" >> $config_h      echo "TARGET_ABI_MIPSO32=y" >> $config_mak
   echo "CONFIG_SOFTFLOAT=yes" >> $config_mak      target_nptl="yes"
   echo "#define CONFIG_SOFTFLOAT 1" >> $config_h      target_phys_bits=64
 elif test "$target_cpu" = "sh4" -o "$target_cpu" = "sh4eb" ; then    ;;
   echo "TARGET_ARCH=sh4" >> $config_mak    mipsn32|mipsn32el)
   echo "#define TARGET_ARCH \"sh4\"" >> $config_h      TARGET_ARCH=mipsn32
   echo "#define TARGET_SH4 1" >> $config_h      TARGET_BASE_ARCH=mips
   bflt="yes"      echo "TARGET_ABI_MIPSN32=y" >> $config_mak
 elif test "$target_cpu" = "m68k" ; then      target_phys_bits=64
   echo "TARGET_ARCH=m68k" >> $config_mak    ;;
   echo "#define TARGET_ARCH \"m68k\"" >> $config_h    mips64|mips64el)
   echo "#define TARGET_M68K 1" >> $config_h      TARGET_ARCH=mips64
   bflt="yes"      TARGET_BASE_ARCH=mips
 else      echo "TARGET_ABI_MIPSN64=y" >> $config_mak
   echo "Unsupported target CPU"      target_phys_bits=64
   exit 1    ;;
 fi    ppc)
       gdb_xml_files="power-core.xml power-fpu.xml power-altivec.xml power-spe.xml"
       target_phys_bits=32
     ;;
     ppcemb)
       TARGET_BASE_ARCH=ppc
       TARGET_ABI_DIR=ppc
       gdb_xml_files="power-core.xml power-fpu.xml power-altivec.xml power-spe.xml"
       target_phys_bits=64
     ;;
     ppc64)
       TARGET_BASE_ARCH=ppc
       TARGET_ABI_DIR=ppc
       gdb_xml_files="power64-core.xml power-fpu.xml power-altivec.xml power-spe.xml"
       target_phys_bits=64
     ;;
     ppc64abi32)
       TARGET_ARCH=ppc64
       TARGET_BASE_ARCH=ppc
       TARGET_ABI_DIR=ppc
       echo "TARGET_ABI32=y" >> $config_mak
       gdb_xml_files="power64-core.xml power-fpu.xml power-altivec.xml power-spe.xml"
       target_phys_bits=64
     ;;
     sh4|sh4eb)
       TARGET_ARCH=sh4
       bflt="yes"
       target_nptl="yes"
       target_phys_bits=32
     ;;
     sparc)
       target_phys_bits=64
     ;;
     sparc64)
       TARGET_BASE_ARCH=sparc
       elfload32="yes"
       target_phys_bits=64
     ;;
     sparc32plus)
       TARGET_ARCH=sparc64
       TARGET_BASE_ARCH=sparc
       TARGET_ABI_DIR=sparc
       echo "TARGET_ABI32=y" >> $config_mak
       target_phys_bits=64
     ;;
     *)
       echo "Unsupported target CPU"
       exit 1
     ;;
   esac
   echo "TARGET_ARCH=$TARGET_ARCH" >> $config_mak
   echo "TARGET_ARCH2=$target_arch2" >> $config_mak
   # TARGET_BASE_ARCH needs to be defined after TARGET_ARCH
   if [ "$TARGET_BASE_ARCH" = "" ]; then
     TARGET_BASE_ARCH=$TARGET_ARCH
   fi
   echo "TARGET_BASE_ARCH=$TARGET_BASE_ARCH" >> $config_mak
   if [ "$TARGET_ABI_DIR" = "" ]; then
     TARGET_ABI_DIR=$TARGET_ARCH
   fi
   echo "TARGET_ABI_DIR=$TARGET_ABI_DIR" >> $config_mak
   if [ $target_phys_bits -lt $hostlongbits ] ; then
     target_phys_bits=$hostlongbits
   fi
   case "$target_arch2" in
     i386|x86_64)
       if test "$xen" = "yes" -a "$target_softmmu" = "yes" ; then
         echo "CONFIG_XEN=y" >> $config_mak
       fi
       if test $kqemu = "yes" -a "$target_softmmu" = "yes"
       then
         echo "CONFIG_KQEMU=y" >> $config_mak
       fi
   esac
   case "$target_arch2" in
     i386|x86_64|ppcemb)
       # Make sure the target and host cpus are compatible
       if test "$kvm" = "yes" -a "$target_softmmu" = "yes" -a \
         \( "$target_arch2" = "$cpu" -o \
         \( "$target_arch2" = "ppcemb" -a "$cpu" = "ppc" \) -o \
         \( "$target_arch2" = "x86_64" -a "$cpu" = "i386"   \) -o \
         \( "$target_arch2" = "i386"   -a "$cpu" = "x86_64" \) \) ; then
         echo "CONFIG_KVM=y" >> $config_mak
         echo "KVM_CFLAGS=$kvm_cflags" >> $config_mak
       fi
   esac
   echo "HWLIB=../libhw$target_phys_bits/libqemuhw$target_phys_bits.a" >> $config_mak
   echo "TARGET_PHYS_ADDR_BITS=$target_phys_bits" >> $config_mak
   echo "subdir-$target: subdir-libhw$target_phys_bits" >> $config_host_mak
 if test "$target_bigendian" = "yes" ; then  if test "$target_bigendian" = "yes" ; then
   echo "TARGET_WORDS_BIGENDIAN=yes" >> $config_mak    echo "TARGET_WORDS_BIGENDIAN=y" >> $config_mak
   echo "#define TARGET_WORDS_BIGENDIAN 1" >> $config_h  
 fi  fi
 if test "$target_softmmu" = "yes" ; then  if test "$target_softmmu" = "yes" ; then
   echo "CONFIG_SOFTMMU=yes" >> $config_mak    echo "CONFIG_SOFTMMU=y" >> $config_mak
   echo "#define CONFIG_SOFTMMU 1" >> $config_h  
 fi  fi
 if test "$target_user_only" = "yes" ; then  if test "$target_user_only" = "yes" ; then
   echo "CONFIG_USER_ONLY=yes" >> $config_mak    echo "CONFIG_USER_ONLY=y" >> $config_mak
   echo "#define CONFIG_USER_ONLY 1" >> $config_h  
 fi  fi
 if test "$target_linux_user" = "yes" ; then  if test "$target_linux_user" = "yes" ; then
   echo "CONFIG_LINUX_USER=yes" >> $config_mak    echo "CONFIG_LINUX_USER=y" >> $config_mak
   echo "#define CONFIG_LINUX_USER 1" >> $config_h  
 fi  fi
 if test "$target_darwin_user" = "yes" ; then  if test "$target_darwin_user" = "yes" ; then
   echo "CONFIG_DARWIN_USER=yes" >> $config_mak    echo "CONFIG_DARWIN_USER=y" >> $config_mak
   echo "#define CONFIG_DARWIN_USER 1" >> $config_h  
 fi  fi
   list=""
   if test ! -z "$gdb_xml_files" ; then
     for x in $gdb_xml_files; do
       list="$list $source_path/gdb-xml/$x"
     done
   fi
   echo "TARGET_XML_FILES=$list" >> $config_mak
   
   case "$target_arch2" in
     arm|armeb|m68k|microblaze|mips|mipsel|mipsn32|mipsn32el|mips64|mips64el|ppc|ppc64|ppc64abi32|ppcemb|sparc|sparc64|sparc32plus)
       echo "CONFIG_SOFTFLOAT=y" >> $config_mak
       ;;
   esac
   
 if test "$target_cpu" = "arm" -o "$target_cpu" = "armeb" -o "$target_cpu" = "sparc" -o "$target_cpu" = "sparc64" -o "$target_cpu" = "m68k"; then  
   echo "CONFIG_SOFTFLOAT=yes" >> $config_mak  
   echo "#define CONFIG_SOFTFLOAT 1" >> $config_h  
 fi  
 if test "$target_user_only" = "yes" -a "$bflt" = "yes"; then  if test "$target_user_only" = "yes" -a "$bflt" = "yes"; then
   echo "TARGET_HAS_BFLT=yes" >> $config_mak    echo "TARGET_HAS_BFLT=y" >> $config_mak
   echo "#define TARGET_HAS_BFLT 1" >> $config_h  
 fi  fi
 # sdl defines  if test "$target_user_only" = "yes" \
           -a "$nptl" = "yes" -a "$target_nptl" = "yes"; then
 if test "$target_user_only" = "no"; then    echo "USE_NPTL=y" >> $config_mak
     if test "$target_softmmu" = "no" -o "$static" = "yes"; then  
         sdl1=$sdl_static  
     else  
         sdl1=$sdl  
     fi  
     if test "$sdl1" = "yes" ; then  
         echo "#define CONFIG_SDL 1" >> $config_h  
         echo "CONFIG_SDL=yes" >> $config_mak  
         if test "$target_softmmu" = "no" -o "$static" = "yes"; then  
             echo "SDL_LIBS=$sdl_static_libs" >> $config_mak  
         else  
             echo "SDL_LIBS=`$sdl_config --libs`" >> $config_mak  
         fi  
         if [ "${aa}" = "yes" ] ; then  
             echo "SDL_CFLAGS=`$sdl_config --cflags` `aalib-config --cflags`" >> $config_mak  
         else  
             echo "SDL_CFLAGS=`$sdl_config --cflags`" >> $config_mak  
         fi  
     fi  
 fi  fi
   # 32 bit ELF loader in addition to native 64 bit loader?
 if test "$cocoa" = "yes" ; then  if test "$target_user_only" = "yes" -a "$elfload32" = "yes"; then
     echo "#define CONFIG_COCOA 1" >> $config_h    echo "TARGET_HAS_ELFLOAD32=y" >> $config_mak
     echo "CONFIG_COCOA=yes" >> $config_mak  fi
   if test "$target_bsd_user" = "yes" ; then
     echo "CONFIG_BSD_USER=y" >> $config_mak
 fi  fi
   
   $source_path/create_config < $config_mak > $config_h
   
   test -f ${config_h}~ && cmp -s $config_h ${config_h}~ && mv ${config_h}~ $config_h
   
 done # for target in $targets  done # for target in $targets
   
 # build tree in object directory if source path is different from current one  # build tree in object directory if source path is different from current one
 if test "$source_path_used" = "yes" ; then  if test "$source_path_used" = "yes" ; then
     DIRS="tests"      DIRS="tests tests/cris slirp audio block pc-bios/optionrom"
     FILES="Makefile tests/Makefile"      FILES="Makefile tests/Makefile"
       FILES="$FILES tests/cris/Makefile tests/cris/.gdbinit"
       FILES="$FILES tests/test-mmap.c"
       FILES="$FILES pc-bios/optionrom/Makefile"
     for dir in $DIRS ; do      for dir in $DIRS ; do
             mkdir -p $dir              mkdir -p $dir
     done      done
Line 989  if test "$source_path_used" = "yes" ; th Line 2100  if test "$source_path_used" = "yes" ; th
     done      done
 fi  fi
   
 rm -f $TMPO $TMPC $TMPE $TMPS  for hwlib in 32 64; do
     d=libhw$hwlib
     mkdir -p $d
     rm -f $d/Makefile
     ln -s $source_path/Makefile.hw $d/Makefile
     echo "HWLIB=libqemuhw$hwlib.a" > $d/config.mak
     echo "CPPFLAGS=-DTARGET_PHYS_ADDR_BITS=$hwlib" >> $d/config.mak
   done

Removed from v.1.1.1.5  
changed lines
  Added in v.1.1.1.10


unix.superglobalmegacorp.com