Diff for /qemu/configure between versions 1.1.1.2 and 1.1.1.11

version 1.1.1.2, 2018/04/24 16:38:31 version 1.1.1.11, 2018/04/24 17:34:29
Line 13  fi Line 13  fi
   
 TMPC="${TMPDIR1}/qemu-conf-${RANDOM}-$$-${RANDOM}.c"  TMPC="${TMPDIR1}/qemu-conf-${RANDOM}-$$-${RANDOM}.c"
 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}.exe"
 TMPS="${TMPDIR1}/qemu-conf-${RANDOM}-$$-${RANDOM}.S"  
   trap "rm -f $TMPC $TMPO $TMPE ; exit" 0 2 3 15
   
   compile_object() {
     $cc $QEMU_CFLAGS -c -o $TMPO $TMPC > /dev/null 2> /dev/null
   }
   
   compile_prog() {
     local_cflags="$1"
     local_ldflags="$2"
     $cc $QEMU_CFLAGS $local_cflags -o $TMPE $TMPC $LDFLAGS $local_ldflags > /dev/null 2> /dev/null
   }
   
 # default parameters  # default parameters
   cpu=""
 prefix=""  prefix=""
 interp_prefix="/usr/gnemul/qemu-%M"  interp_prefix="/usr/gnemul/qemu-%M"
 static="no"  static="no"
   sparc_cpu=""
 cross_prefix=""  cross_prefix=""
 cc="gcc"  cc="gcc"
   audio_drv_list=""
   audio_card_list="ac97 es1370 sb16"
   audio_possible_cards="ac97 es1370 sb16 cs4231a adlib gus"
   block_drv_whitelist=""
 host_cc="gcc"  host_cc="gcc"
 ar="ar"  ar="ar"
 make="make"  make="make"
 strip="strip"  install="install"
 cpu=`uname -m`  objcopy="objcopy"
   ld="ld"
   helper_cflags=""
   libs_softmmu=""
   libs_tools=""
   audio_pt_int=""
   audio_win_int=""
   
   # parse CC options first
   for opt do
     optarg=`expr "x$opt" : 'x[^=]*=\(.*\)'`
     case "$opt" in
     --cross-prefix=*) cross_prefix="$optarg"
     ;;
     --cc=*) cc="$optarg"
     ;;
     --cpu=*) cpu="$optarg"
     ;;
     --extra-cflags=*) QEMU_CFLAGS="$optarg $QEMU_CFLAGS"
     ;;
     --extra-ldflags=*) LDFLAGS="$optarg $LDFLAGS"
     ;;
     --sparc_cpu=*)
       sparc_cpu="$optarg"
       case $sparc_cpu in
       v7|v8|v8plus|v8plusa)
         cpu="sparc"
       ;;
       v9)
         cpu="sparc64"
       ;;
       *)
         echo "undefined SPARC architecture. Exiting";
         exit 1
       ;;
       esac
     ;;
     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}"
   objcopy="${cross_prefix}${objcopy}"
   ld="${cross_prefix}${ld}"
   
   # default flags for all hosts
   QEMU_CFLAGS="-fno-strict-aliasing $QEMU_CFLAGS"
   CFLAGS="-g $CFLAGS"
   QEMU_CFLAGS="-Wall -Wundef -Wendif-labels -Wwrite-strings -Wmissing-prototypes $QEMU_CFLAGS"
   QEMU_CFLAGS="-Wstrict-prototypes -Wredundant-decls $QEMU_CFLAGS"
   QEMU_CFLAGS="-D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE $QEMU_CFLAGS"
   QEMU_CFLAGS="-U_FORTIFY_SOURCE $QEMU_CFLAGS"
   QEMU_CFLAGS="-I. -I\$(SRC_PATH) $QEMU_CFLAGS"
   LDFLAGS="-g $LDFLAGS"
   
   gcc_flags="-Wold-style-declaration -Wold-style-definition"
   cat > $TMPC << EOF
   int main(void) { }
   EOF
   for flag in $gcc_flags; do
       if compile_prog "$QEMU_CFLAGS" "$flag" ; then
           QEMU_CFLAGS="$flag $QEMU_CFLAGS"
       fi
   done
   
   # check that the C compiler works.
   cat > $TMPC <<EOF
   int main(void) {}
   EOF
   
   if compile_object ; 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
     compile_object
   }
   
   if test ! -z "$cpu" ; then
     # command line argument
     :
   elif 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
   elif check_define __mips__ ; then
     cpu="mips"
   else
     cpu=`uname -m`
   fi
   
 target_list=""  target_list=""
 case "$cpu" in  case "$cpu" in
     alpha|cris|ia64|m68k|microblaze|ppc|ppc64|sparc64)
       cpu="$cpu"
     ;;
   i386|i486|i586|i686|i86pc|BePC)    i386|i486|i586|i686|i86pc|BePC)
     cpu="i386"      cpu="i386"
   ;;    ;;
     x86_64|amd64)
       cpu="x86_64"
     ;;
   armv*b)    armv*b)
     cpu="armv4b"      cpu="armv4b"
   ;;    ;;
   armv*l)    armv*l)
     cpu="armv4l"      cpu="armv4l"
   ;;    ;;
   alpha)    parisc|parisc64)
     cpu="alpha"      cpu="hppa"
   ;;  
   "Power Macintosh"|ppc|ppc64)  
     cpu="powerpc"  
   ;;    ;;
   mips)    mips*)
     cpu="mips"      cpu="mips"
   ;;    ;;
   s390)    s390)
     cpu="s390"      cpu="s390"
   ;;    ;;
   sparc)    s390x)
     cpu="sparc"      cpu="s390x"
   ;;  
   sparc64)  
     cpu="sparc64"  
   ;;  
   ia64)  
     cpu="ia64"  
   ;;  
   m68k)  
     cpu="m68k"  
   ;;    ;;
   x86_64|amd64)    sparc|sun4[cdmuv])
     cpu="x86_64"      cpu="sparc"
   ;;    ;;
   *)    *)
     cpu="unknown"      cpu="unknown"
   ;;    ;;
 esac  esac
   
   # Default value for a variable defining feature "foo".
   #  * foo="no"  feature will only be used if --enable-foo arg is given
   #  * foo=""    feature will be searched for, and if found, will be used
   #              unless --disable-foo is given
   #  * foo="yes" this value will only be set by --enable-foo flag.
   #              feature will searched for,
   #              if not found, configure exits with error
   #
   # Always add --enable-foo and --disable-foo command line args.
   # Distributions want to ensure that several features are compiled in, and it
   # is impossible without a --enable-foo that exits if a feature is not found.
   
   bluez=""
   brlapi=""
   curl=""
   curses=""
   docs=""
   fdt=""
   kvm=""
   nptl=""
   sdl=""
   sparse="no"
   uuid=""
   vde=""
   vnc_tls=""
   vnc_sasl=""
   xen=""
   linux_aio=""
   
 gprof="no"  gprof="no"
   debug_tcg="no"
   debug="no"
   strip_opt="yes"
 bigendian="no"  bigendian="no"
 mingw32="no"  mingw32="no"
 EXESUF=""  EXESUF=""
 gdbstub="yes"  
 slirp="yes"  slirp="yes"
 adlib="no"  
 oss="no"  
 dsound="no"  
 coreaudio="no"  
 alsa="no"  
 fmod="no"  
 fmod_lib=""  fmod_lib=""
 fmod_inc=""  fmod_inc=""
   oss_lib=""
   bsd="no"
 linux="no"  linux="no"
 kqemu="no"  solaris="no"
 kernel_path=""  profiler="no"
 cocoa="no"  cocoa="no"
 check_gfx="yes"  softmmu="yes"
 check_gcc="yes"  linux_user="no"
   darwin_user="no"
   bsd_user="no"
   guest_base=""
   uname_release=""
   io_thread="no"
   mixemu="no"
   kerneldir=""
   aix="no"
   blobs="yes"
   pkgversion=""
   check_utests="no"
   user_pie="no"
   zero_malloc=""
   
 # 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"
 CFLAGS="-O2 -mno-cygwin"    QEMU_CFLAGS="-mno-cygwin $QEMU_CFLAGS"
     audio_possible_drivers="winwave sdl"
     audio_drv_list="winwave"
 ;;  ;;
 MINGW32*)  MINGW32*)
 mingw32="yes"    mingw32="yes"
     audio_possible_drivers="winwave dsound sdl fmod"
     audio_drv_list="winwave"
   ;;
   GNU/kFreeBSD)
     bsd="yes"
     audio_drv_list="oss"
     audio_possible_drivers="oss sdl esd pa"
 ;;  ;;
 FreeBSD)  FreeBSD)
 bsd="yes"    bsd="yes"
 oss="yes"    make="gmake"
 if [ "$cpu" = "i386" -o "$cpu" = "x86_64" ] ; then    audio_drv_list="oss"
     kqemu="yes"    audio_possible_drivers="oss sdl esd pa"
 fi  ;;
   DragonFly)
     bsd="yes"
     make="gmake"
     audio_drv_list="oss"
     audio_possible_drivers="oss sdl esd pa"
 ;;  ;;
 NetBSD)  NetBSD)
 bsd="yes"    bsd="yes"
 oss="yes"    make="gmake"
     audio_drv_list="oss"
     audio_possible_drivers="oss sdl esd"
     oss_lib="-lossaudio"
 ;;  ;;
 OpenBSD)  OpenBSD)
 bsd="yes"    bsd="yes"
 oss="yes"    make="gmake"
     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
       QEMU_CFLAGS="-arch x86_64 $QEMU_CFLAGS"
       LDFLAGS="-arch x86_64 $LDFLAGS"
     else
       QEMU_CFLAGS="-mdynamic-no-pic $QEMU_CFLAGS"
     fi
     darwin_user="yes"
     cocoa="yes"
     audio_drv_list="coreaudio"
     audio_possible_drivers="coreaudio sdl fmod"
     LDFLAGS="-framework CoreFoundation -framework IOKit $LDFLAGS"
     libs_softmmu="-F/System/Library/Frameworks -framework Cocoa -framework IOKit $libs_softmmu"
   ;;
   SunOS)
     solaris="yes"
     make="gmake"
     install="ginstall"
     ld="gld"
     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"
           QEMU_CFLAGS="-I/opt/SUNWspro/prod/include/cc $QEMU_CFLAGS"
           LDFLAGS="-L/opt/SUNWspro/prod/lib -R/opt/SUNWspro/prod/lib $LDFLAGS"
           LIBS="-lsunmath $LIBS"
         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
     fi
     if test -f /usr/include/sys/soundcard.h ; then
       audio_drv_list="oss"
     fi
     audio_possible_drivers="oss sdl"
   # needed for CMSG_ macros in sys/socket.h
     QEMU_CFLAGS="-D_XOPEN_SOURCE=600 $QEMU_CFLAGS"
   # needed for TIOCWIN* defines in termios.h
     QEMU_CFLAGS="-D__EXTENSIONS__ $QEMU_CFLAGS"
     QEMU_CFLAGS="-std=gnu99 $QEMU_CFLAGS"
     LIBS="-lsocket -lnsl -lresolv $LIBS"
   ;;
   AIX)
     aix="yes"
     make="gmake"
 ;;  ;;
 *)  *)
 oss="yes"    audio_drv_list="oss"
 linux="yes"    audio_possible_drivers="oss alsa sdl esd pa"
 if [ "$cpu" = "i386" -o "$cpu" = "x86_64" ] ; then    linux="yes"
     kqemu="yes"    linux_user="yes"
 fi    usb="linux"
     if [ "$cpu" = "i386" -o "$cpu" = "x86_64" ] ; then
       audio_possible_drivers="$audio_possible_drivers fmod"
     fi
 ;;  ;;
 esac  esac
   
 if [ "$bsd" = "yes" ] ; then  if [ "$bsd" = "yes" ] ; then
   if [ ! "$darwin" = "yes" ] ; then    if [ "$darwin" != "yes" ] ; then
     make="gmake"      usb="bsd"
   fi    fi
     bsd_user="yes"
   fi
   
   if test "$mingw32" = "yes" ; then
     EXESUF=".exe"
     QEMU_CFLAGS="-DWIN32_LEAN_AND_MEAN -DWINVER=0x501 $QEMU_CFLAGS"
     LIBS="-lwinmm -lws2_32 -liphlpapi $LIBS"
 fi  fi
   
 # find source path  # find source path
 # XXX: we assume an absolute path is given when launching configure,  source_path=`dirname "$0"`
 # except in './configure' case.  source_path_used="no"
 source_path=${0%configure}  workdir=`pwd`
 source_path=${source_path%/}  if [ -z "$source_path" ]; then
 source_path_used="yes"      source_path=$workdir
 if test -z "$source_path" -o "$source_path" = "." ; then  else
     source_path=`pwd`      source_path=`cd "$source_path"; pwd`
     source_path_used="no"  
 fi  fi
   [ -f "$workdir/vl.c" ] || source_path_used="yes"
   
   werror=""
   
 for opt do  for opt do
     optarg=`expr "x$opt" : 'x[^=]*=\(.*\)'`
   case "$opt" in    case "$opt" in
   --help|-h) show_help=yes    --help|-h) show_help=yes
   ;;    ;;
   --prefix=*) prefix=`echo $opt | cut -d '=' -f 2`    --prefix=*) prefix="$optarg"
     ;;
     --interp-prefix=*) interp_prefix="$optarg"
   ;;    ;;
   --interp-prefix=*) interp_prefix=`echo $opt | cut -d '=' -f 2`    --source-path=*) source_path="$optarg"
     source_path_used="yes"
   ;;    ;;
   --source-path=*) source_path=`echo $opt | cut -d '=' -f 2`    --cross-prefix=*)
   ;;    ;;
   --cross-prefix=*) cross_prefix=`echo $opt | cut -d '=' -f 2`    --cc=*)
   ;;    ;;
   --cc=*) cc=`echo $opt | cut -d '=' -f 2`    --host-cc=*) host_cc="$optarg"
   ;;    ;;
   --host-cc=*) host_cc=`echo $opt | cut -d '=' -f 2`    --make=*) make="$optarg"
   ;;    ;;
   --make=*) make=`echo $opt | cut -d '=' -f 2`    --install=*) install="$optarg"
   ;;    ;;
   --extra-cflags=*) CFLAGS="${opt#--extra-cflags=}"    --extra-cflags=*)
   ;;    ;;
   --extra-ldflags=*) LDFLAGS="${opt#--extra-ldflags=}"    --extra-ldflags=*)
   ;;    ;;
   --cpu=*) cpu=`echo $opt | cut -d '=' -f 2`    --cpu=*)
   ;;    ;;
   --target-list=*) target_list=${opt#--target-list=}    --target-list=*) target_list="$optarg"
   ;;    ;;
   --enable-gprof) gprof="yes"    --enable-gprof) gprof="yes"
   ;;    ;;
Line 177  for opt do Line 454  for opt do
   ;;    ;;
   --disable-sdl) sdl="no"    --disable-sdl) sdl="no"
   ;;    ;;
   --enable-coreaudio) coreaudio="yes"    --enable-sdl) sdl="yes"
     ;;
     --fmod-lib=*) fmod_lib="$optarg"
     ;;
     --fmod-inc=*) fmod_inc="$optarg"
     ;;
     --oss-lib=*) oss_lib="$optarg"
     ;;
     --audio-card-list=*) audio_card_list=`echo "$optarg" | sed -e 's/,/ /g'`
     ;;
     --audio-drv-list=*) audio_drv_list="$optarg"
     ;;
     --block-drv-whitelist=*) block_drv_whitelist=`echo "$optarg" | sed -e 's/,/ /g'`
     ;;
     --enable-debug-tcg) debug_tcg="yes"
     ;;
     --disable-debug-tcg) debug_tcg="no"
   ;;    ;;
   --enable-alsa) alsa="yes"    --enable-debug)
         # Enable debugging options that aren't excessively noisy
         debug_tcg="yes"
         debug="yes"
         strip_opt="no"
   ;;    ;;
   --enable-dsound) dsound="yes"    --enable-sparse) sparse="yes"
   ;;    ;;
   --enable-fmod) fmod="yes"    --disable-sparse) sparse="no"
   ;;    ;;
   --fmod-lib=*) fmod_lib=${opt#--fmod-lib=}    --disable-strip) strip_opt="no"
   ;;    ;;
   --fmod-inc=*) fmod_inc=${opt#--fmod-inc=}    --disable-vnc-tls) vnc_tls="no"
   ;;    ;;
   --enable-mingw32) mingw32="yes" ; cross_prefix="i386-mingw32-"    --enable-vnc-tls) vnc_tls="yes"
     ;;
     --disable-vnc-sasl) vnc_sasl="no"
     ;;
     --enable-vnc-sasl) vnc_sasl="yes"
   ;;    ;;
   --disable-slirp) slirp="no"    --disable-slirp) slirp="no"
   ;;    ;;
   --enable-adlib) adlib="yes"    --disable-uuid) uuid="no"
     ;;
     --enable-uuid) uuid="yes"
     ;;
     --disable-vde) vde="no"
     ;;
     --enable-vde) vde="yes"
     ;;
     --disable-xen) xen="no"
     ;;
     --enable-xen) xen="yes"
     ;;
     --disable-brlapi) brlapi="no"
     ;;
     --enable-brlapi) brlapi="yes"
     ;;
     --disable-bluez) bluez="no"
     ;;
     --enable-bluez) bluez="yes"
     ;;
     --disable-kvm) kvm="no"
     ;;
     --enable-kvm) kvm="yes"
     ;;
     --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"
     ;;
     --enable-system) softmmu="yes"
     ;;
     --disable-user)
         linux_user="no" ;
         bsd_user="no" ;
         darwin_user="no"
     ;;
     --enable-user) ;;
     --disable-linux-user) linux_user="no"
     ;;
     --enable-linux-user) linux_user="yes"
     ;;
     --disable-darwin-user) darwin_user="no"
     ;;
     --enable-darwin-user) darwin_user="yes"
     ;;
     --disable-bsd-user) bsd_user="no"
     ;;
     --enable-bsd-user) bsd_user="yes"
     ;;
     --enable-guest-base) guest_base="yes"
     ;;
     --disable-guest-base) guest_base="no"
     ;;
     --enable-user-pie) user_pie="yes"
     ;;
     --disable-user-pie) user_pie="no"
     ;;
     --enable-uname-release=*) uname_release="$optarg"
     ;;
     --sparc_cpu=*)
     ;;
     --enable-werror) werror="yes"
     ;;
     --disable-werror) werror="no"
   ;;    ;;
   --disable-kqemu) kqemu="no"    --disable-curses) curses="no"
   ;;    ;;
   --kernel-path=*) kernel_path=${opt#--kernel-path=}    --enable-curses) curses="yes"
   ;;    ;;
   --enable-cocoa) cocoa="yes" ; coreaudio="yes" ; sdl="no"    --disable-curl) curl="no"
   ;;    ;;
   --disable-gfx-check) check_gfx="no"    --enable-curl) curl="yes"
   ;;    ;;
   --disable-gcc-check) check_gcc="no"    --disable-fdt) fdt="no"
     ;;
     --enable-fdt) fdt="yes"
     ;;
     --disable-check-utests) check_utests="no"
     ;;
     --enable-check-utests) check_utests="yes"
     ;;
     --disable-nptl) nptl="no"
     ;;
     --enable-nptl) nptl="yes"
     ;;
     --enable-mixemu) mixemu="yes"
     ;;
     --disable-linux-aio) linux_aio="no"
     ;;
     --enable-linux-aio) linux_aio="yes"
     ;;
     --enable-io-thread) io_thread="yes"
     ;;
     --disable-blobs) blobs="no"
     ;;
     --kerneldir=*) kerneldir="$optarg"
     ;;
     --with-pkgversion=*) pkgversion=" ($optarg)"
     ;;
     --disable-docs) docs="no"
     ;;
     --enable-docs) docs="yes"
     ;;
     *) echo "ERROR: unknown option $opt"; show_help="yes"
   ;;    ;;
   esac    esac
 done  done
   
 # Checking for CFLAGS  #
 if test -z "$CFLAGS"; then  # If cpu ~= sparc and  sparc_cpu hasn't been defined, plug in the right
     CFLAGS="-O2"  # QEMU_CFLAGS/LDFLAGS (assume sparc_v8plus for 32-bit and sparc_v9 for 64-bit)
 fi  #
   host_guest_base="no"
   case "$cpu" in
       sparc) case $sparc_cpu in
              v7|v8)
                QEMU_CFLAGS="-mcpu=${sparc_cpu} -D__sparc_${sparc_cpu}__ $QEMU_CFLAGS"
              ;;
              v8plus|v8plusa)
                QEMU_CFLAGS="-mcpu=ultrasparc -D__sparc_${sparc_cpu}__ $QEMU_CFLAGS"
              ;;
              *) # sparc_cpu not defined in the command line
                QEMU_CFLAGS="-mcpu=ultrasparc -D__sparc_v8plus__ $QEMU_CFLAGS"
              esac
              LDFLAGS="-m32 $LDFLAGS"
              QEMU_CFLAGS="-m32 -ffixed-g2 -ffixed-g3 $QEMU_CFLAGS"
              if test "$solaris" = "no" ; then
                QEMU_CFLAGS="-ffixed-g1 -ffixed-g6 $QEMU_CFLAGS"
                helper_cflags="-ffixed-i0"
              fi
              ;;
       sparc64)
              QEMU_CFLAGS="-m64 -mcpu=ultrasparc -D__sparc_v9__ $QEMU_CFLAGS"
              LDFLAGS="-m64 $LDFLAGS"
              QEMU_CFLAGS="-ffixed-g5 -ffixed-g6 -ffixed-g7 $QEMU_CFLAGS"
              if test "$solaris" != "no" ; then
                QEMU_CFLAGS="-ffixed-g1 $QEMU_CFLAGS"
              fi
              ;;
       s390)
              QEMU_CFLAGS="-march=z900 $QEMU_CFLAGS"
              ;;
       i386)
              QEMU_CFLAGS="-m32 $QEMU_CFLAGS"
              LDFLAGS="-m32 $LDFLAGS"
              helper_cflags="-fomit-frame-pointer"
              host_guest_base="yes"
              ;;
       x86_64)
              QEMU_CFLAGS="-m64 $QEMU_CFLAGS"
              LDFLAGS="-m64 $LDFLAGS"
              host_guest_base="yes"
              ;;
       arm*)
              host_guest_base="yes"
              ;;
       ppc*)
              host_guest_base="yes"
              ;;
   esac
   
 cc="${cross_prefix}${cc}"  [ -z "$guest_base" ] && guest_base="$host_guest_base"
 ar="${cross_prefix}${ar}"  
 strip="${cross_prefix}${strip}"  
   
 if test "$mingw32" = "yes" ; then  if test x"$show_help" = x"yes" ; then
     linux="no"  cat << EOF
     EXESUF=".exe"  
     gdbstub="no"  Usage: configure [options]
     oss="no"  Options: [defaults in brackets after descriptions]
     if [ "$cpu" = "i386" ] ; then  
         kqemu="yes"  EOF
   echo "Standard options:"
   echo "  --help                   print this message"
   echo "  --prefix=PREFIX          install in PREFIX [$prefix]"
   echo "  --interp-prefix=PREFIX   where to find shared libraries, etc."
   echo "                           use %M for cpu name [$interp_prefix]"
   echo "  --target-list=LIST       set target list [$target_list]"
   echo ""
   echo "Advanced options (experts only):"
   echo "  --source-path=PATH       path of source code [$source_path]"
   echo "  --cross-prefix=PREFIX    use PREFIX for compile tools [$cross_prefix]"
   echo "  --cc=CC                  use C compiler CC [$cc]"
   echo "  --host-cc=CC             use C compiler CC [$host_cc] for dyngen etc."
   echo "  --extra-cflags=CFLAGS    append extra C compiler flags QEMU_CFLAGS"
   echo "  --extra-ldflags=LDFLAGS  append extra linker flags LDFLAGS"
   echo "  --make=MAKE              use specified make [$make]"
   echo "  --install=INSTALL        use specified install [$install]"
   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-sdl             enable SDL"
   echo "  --enable-cocoa           enable COCOA (Mac OS X only)"
   echo "  --audio-drv-list=LIST    set audio drivers list:"
   echo "                           Available drivers: $audio_possible_drivers"
   echo "  --audio-card-list=LIST   set list of emulated audio cards [$audio_card_list]"
   echo "                           Available cards: $audio_possible_cards"
   echo "  --block-drv-whitelist=L  set block driver whitelist"
   echo "                           (affects only QEMU, not qemu-img)"
   echo "  --enable-mixemu          enable mixer emulation"
   echo "  --disable-xen            disable xen backend driver support"
   echo "  --enable-xen             enable xen backend driver support"
   echo "  --disable-brlapi         disable BrlAPI"
   echo "  --enable-brlapi          enable BrlAPI"
   echo "  --disable-vnc-tls        disable TLS encryption for VNC server"
   echo "  --enable-vnc-tls         enable TLS encryption for VNC server"
   echo "  --disable-vnc-sasl       disable SASL encryption for VNC server"
   echo "  --enable-vnc-sasl        enable SASL encryption for VNC server"
   echo "  --disable-curses         disable curses output"
   echo "  --enable-curses          enable curses output"
   echo "  --disable-curl           disable curl connectivity"
   echo "  --enable-curl            enable curl connectivity"
   echo "  --disable-fdt            disable fdt device tree"
   echo "  --enable-fdt             enable fdt device tree"
   echo "  --disable-check-utests   disable check unit-tests"
   echo "  --enable-check-utests    enable check unit-tests"
   echo "  --disable-bluez          disable bluez stack connectivity"
   echo "  --enable-bluez           enable bluez stack connectivity"
   echo "  --disable-kvm            disable KVM acceleration support"
   echo "  --enable-kvm             enable KVM acceleration support"
   echo "  --disable-nptl           disable usermode NPTL support"
   echo "  --enable-nptl            enable usermode NPTL support"
   echo "  --enable-system          enable all system emulation targets"
   echo "  --disable-system         disable all system emulation targets"
   echo "  --enable-user            enable supported user emulation targets"
   echo "  --disable-user           disable all user emulation targets"
   echo "  --enable-linux-user      enable 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 "  --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 "  --enable-guest-base      enable GUEST_BASE support for usermode"
   echo "                           emulation targets"
   echo "  --disable-guest-base     disable GUEST_BASE support"
   echo "  --enable-user-pie        build usermode emulation targets as PIE"
   echo "  --disable-user-pie       do not build usermode emulation targets as PIE"
   echo "  --fmod-lib               path to FMOD library"
   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 "  --sparc_cpu=V            Build qemu for Sparc architecture v7, v8, v8plus, v8plusa, v9"
   echo "  --disable-uuid           disable uuid support"
   echo "  --enable-uuid            enable uuid support"
   echo "  --disable-vde            disable support for vde network"
   echo "  --enable-vde             enable support for vde network"
   echo "  --disable-linux-aio      disable Linux AIO support"
   echo "  --enable-linux-aio       enable Linux 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 "NOTE: The object files are built at the place where configure is launched"
   exit 1
   fi
   
   #
   # Solaris specific configure tool chain decisions
   #
   if test "$solaris" = "yes" ; then
     solinst=`which $install 2> /dev/null | /usr/bin/grep -v "no $install in"`
     if test -z "$solinst" ; then
       echo "Solaris install program not found. Use --install=/usr/ucb/install or"
       echo "install fileutils from www.blastwave.org using pkg-get -i fileutils"
       echo "to get ginstall which is used by default (which lives in /opt/csw/bin)"
       exit 1
     fi
     if test "$solinst" = "/usr/sbin/install" ; then
       echo "Error: Solaris /usr/sbin/install is not an appropriate install program."
       echo "try ginstall from the GNU fileutils available from www.blastwave.org"
       echo "using pkg-get -i fileutils, or use --install=/usr/ucb/install"
       exit 1
     fi
     sol_ar=`which ar 2> /dev/null | /usr/bin/grep -v "no ar in"`
     if test -z "$sol_ar" ; then
       echo "Error: No path includes ar"
       if test -f /usr/ccs/bin/ar ; then
         echo "Add /usr/ccs/bin to your path and rerun configure"
     fi      fi
       exit 1
     fi
 fi  fi
   
   
 if test -z "$target_list" ; then  if test -z "$target_list" ; then
 # these targets are portable  # these targets are portable
     target_list="i386-softmmu ppc-softmmu sparc-softmmu x86_64-softmmu mips-softmmu arm-softmmu"      if [ "$softmmu" = "yes" ] ; then
           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
 # the following are Linux specific  # the following are Linux specific
     if [ "$linux" = "yes" ] ; then      if [ "$linux_user" = "yes" ] ; then
         target_list="i386-user arm-user armeb-user sparc-user ppc-user mips-user mipsel-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
   # the following are Darwin specific
       if [ "$darwin_user" = "yes" ] ; then
           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'`
   fi
   if test -z "$target_list" ; then
       echo "No targets enabled"
       exit 1
 fi  fi
   
   feature_not_found() {
     feature=$1
   
     echo "ERROR"
     echo "ERROR: User requested feature $feature"
     echo "ERROR: configure was not able to find it"
     echo "ERROR"
     exit 1;
   }
   
 if test -z "$cross_prefix" ; then  if test -z "$cross_prefix" ; then
   
 # ---  # ---
Line 250  int main(int argc, char ** argv){ Line 875  int main(int argc, char ** argv){
 }  }
 EOF  EOF
   
 if $cc -o $TMPE $TMPC 2>/dev/null ; then  if compile_prog "" "" ; then
 $TMPE && bigendian="yes"  $TMPE && bigendian="yes"
 else  else
 echo big/little test failed  echo big/little test failed
Line 259  fi Line 884  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  case "$cpu" in
     bigendian="yes"    armv4b|hppa|m68k|mips|mips64|ppc|ppc64|s390|s390x|sparc|sparc64)
 fi      bigendian=yes
     ;;
   esac
   
 fi  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  case "$cpu" in
     hostlongbits="64"    x86_64|alpha|ia64|sparc64|ppc64|s390x)
 fi      hostlongbits=64
     ;;
   esac
   
 # check gcc options support  
 cat > $TMPC <<EOF  ##########################################
 int main(void) {  # NPTL probe
   
   if test "$nptl" != "no" ; then
     cat > $TMPC <<EOF
   #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 compile_object ; then
 if $cc -fno-reorder-blocks -fno-optimize-sibling-calls -o $TMPO $TMPC 2> /dev/null ; then      nptl=yes
    have_gcc3_options="yes"    else
       if test "$nptl" = "yes" ; then
         feature_not_found "nptl"
       fi
       nptl=no
     fi
 fi  fi
   
 # Check for gcc4  ##########################################
 if test "$check_gcc" = "yes" ; then  # zlib check
     cat > $TMPC <<EOF  
 #if __GNUC__ >= 4  cat > $TMPC << EOF
 #error gcc4  #include <zlib.h>
 #endif  int main(void) { zlibVersion(); return 0; }
 int main(){return 0;}  
 EOF  EOF
     if ! $cc -o $TMPO $TMPC 2>/dev/null ; then  if compile_prog "" "-lz" ; then
         echo "ERROR: \"$cc\" looks like gcc 4.x"      :
         echo "QEMU is known to have problems when compiled with gcc 4.x"  else
         echo "It is recommended that you use gcc 3.x to build QEMU"      echo
         echo "To use this compiler anyway, configure with --disable-gcc-check"      echo "Error: zlib check failed"
         exit 1;      echo "Make sure to have the zlib libs and headers installed."
       echo
       exit 1
   fi
   
   ##########################################
   # xen probe
   
   if test "$xen" != "no" ; then
     xen_libs="-lxenstore -lxenctrl -lxenguest"
     cat > $TMPC <<EOF
   #include <xenctrl.h>
   #include <xs.h>
   int main(void) { xs_daemon_open(); xc_interface_open(); return 0; }
   EOF
     if compile_prog "" "$xen_libs" ; then
       xen=yes
       libs_softmmu="$xen_libs $libs_softmmu"
     else
       if test "$xen" = "yes" ; then
         feature_not_found "xen"
       fi
       xen=no
     fi
   fi
   
   ##########################################
   # Sparse probe
   if test "$sparse" != "no" ; then
     if test -x "$(which cgcc 2>/dev/null)"; then
       sparse=yes
     else
       if test "$sparse" = "yes" ; then
         feature_not_found "sparse"
     fi      fi
       sparse=no
     fi
 fi  fi
   
 ##########################################  ##########################################
Line 304  fi Line 982  fi
   
 sdl_too_old=no  sdl_too_old=no
   
 if test -z "$sdl" ; then  if test "$sdl" != "no" ; then
     cat > $TMPC << EOF
 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  
 #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
     sdl_cflags=`sdl-config --cflags 2> /dev/null`
     sdl_libs=`sdl-config --libs 2> /dev/null`
     if compile_prog "$sdl_cflags" "$sdl_libs" ; 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" -a "$static" = "yes" ; then
 if test "$_sdlversion" -lt 121 ; then        sdl_libs=`sdl-config --static-libs 2>/dev/null`
 sdl_too_old=yes        if test `sdl-config --static-libs 2>/dev/null | grep \\\-laa > /dev/null` ; then
 else           sdl_libs="$sdl_libs `aalib-config --static-libs >2 /dev/null`"
 sdl=yes           sdl_cflags="$sd_cflags `aalib-config --cflags >2 /dev/null`"
         fi
         if compile_prog "$sdl_cflags" "$sdl_libs" ; then
           :
         else
           sdl=no
         fi
       fi # static link
     else # sdl not found
       if test "$sdl" = "yes" ; then
         feature_not_found "sdl"
       fi
       sdl=no
     fi # sdl compile test
 fi  fi
   
 # 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 compile_prog "$sdl_cflags" "$sdl_libs" ; then
       sdl_libs="$sdl_libs -lX11"
     fi
     if test "$mingw32" = "yes" ; then
       sdl_libs="`echo $sdl_libs | sed s/-mwindows//g` -mconsole"
     fi
     libs_softmmu="$sdl_libs $libs_softmmu"
 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" != "no" ; 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 compile_prog "$vnc_tls_cflags" "$vnc_tls_libs" ; then
       vnc_tls=yes
       libs_softmmu="$vnc_tls_libs $libs_softmmu"
     else
       if test "$vnc_tls" = "yes" ; then
         feature_not_found "vnc-tls"
       fi
       vnc_tls=no
     fi
 fi  fi
   
 fi # static link  ##########################################
   # VNC SASL detection
 fi # sdl compile test  if test "$vnc_sasl" != "no" ; then
     cat > $TMPC <<EOF
 fi # cross compilation  #include <sasl/sasl.h>
 fi # -z $sdl  #include <stdio.h>
   int main(void) { sasl_server_init(NULL, "qemu"); return 0; }
 if test x"$show_help" = x"yes" ; then  EOF
 cat << EOF    # Assuming Cyrus-SASL installed in /usr prefix
     vnc_sasl_cflags=""
     vnc_sasl_libs="-lsasl2"
     if compile_prog "$vnc_sasl_cflags" "$vnc_sasl_libs" ; then
       vnc_sasl=yes
       libs_softmmu="$vnc_sasl_libs $libs_softmmu"
     else
       if test "$vnc_sasl" = "yes" ; then
         feature_not_found "vnc-sasl"
       fi
       vnc_sasl=no
     fi
   fi
   
 Usage: configure [options]  ##########################################
 Options: [defaults in brackets after descriptions]  # 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 compile_prog "" "" ; then
      fnmatch="yes"
   fi
   
   ##########################################
   # uuid_generate() probe, used for vdi block driver
   if test "$uuid" != "no" ; then
     uuid_libs="-luuid"
     cat > $TMPC << EOF
   #include <uuid/uuid.h>
   int main(void)
   {
       uuid_t my_uuid;
       uuid_generate(my_uuid);
       return 0;
   }
 EOF  EOF
 echo "Standard options:"    if compile_prog "" "$uuid_libs" ; then
 echo "  --help                   print this message"      uuid="yes"
 echo "  --prefix=PREFIX          install in PREFIX [$prefix]"      libs_softmmu="$uuid_libs $libs_softmmu"
 echo "  --interp-prefix=PREFIX   where to find shared libraries, etc."      libs_tools="$uuid_libs $libs_tools"
 echo "                           use %M for cpu name [$interp_prefix]"    else
 echo "  --target-list=LIST       set target list [$target_list]"      if test "$uuid" = "yes" ; then
 echo ""        feature_not_found "uuid"
 echo "kqemu kernel acceleration support:"      fi
 echo "  --disable-kqemu          disable kqemu build"      uuid=no
 echo "  --kernel-path=PATH       set the kernel path (configure probes it)"    fi
 echo ""  
 echo "Advanced options (experts only):"  
 echo "  --source-path=PATH       path of source code [$source_path]"  
 echo "  --cross-prefix=PREFIX    use PREFIX for compile tools [$cross_prefix]"  
 echo "  --cc=CC                  use C compiler CC [$cc]"  
 echo "  --host-cc=CC             use C compiler CC [$host_cc] for dyngen etc."  
 echo "  --make=MAKE              use specified make [$make]"  
 echo "  --static                 enable static build [$static]"  
 echo "  --enable-mingw32         enable Win32 cross compilation with mingw32"  
 echo "  --enable-adlib           enable Adlib emulation"  
 echo "  --enable-coreaudio       enable Coreaudio audio driver"  
 echo "  --enable-alsa            enable ALSA audio driver"  
 echo "  --enable-fmod            enable FMOD audio driver"  
 echo "  --enabled-dsound         enable DirectSound audio driver"  
 echo "  --fmod-lib               path to FMOD library"  
 echo "  --fmod-inc               path to FMOD includes"  
 echo ""  
 echo "NOTE: The object files are build at the place where configure is launched"  
 exit 1  
 fi  fi
   
 if test "$mingw32" = "yes" ; then  ##########################################
 if test -z "$prefix" ; then  # vde libraries probe
     prefix="/c/Program Files/Qemu"  if test "$vde" != "no" ; then
     vde_libs="-lvdeplug"
     cat > $TMPC << EOF
   #include <libvdeplug.h>
   int main(void)
   {
       struct vde_open_args a = {0, 0, 0};
       vde_open("", "", &a);
       return 0;
   }
   EOF
     if compile_prog "" "$vde_libs" ; then
       vde=yes
       libs_softmmu="$vde_libs $libs_softmmu"
       libs_tools="$vde_libs $libs_tools"
     else
       if test "$vde" = "yes" ; then
         feature_not_found "vde"
       fi
       vde=no
     fi
 fi  fi
 mandir="$prefix"  
 datadir="$prefix"  ##########################################
 docdir="$prefix"  # Sound support libraries probe
 bindir="$prefix"  
 else  audio_drv_probe()
 if test -z "$prefix" ; then  {
     prefix="/usr/local"      drv=$1
       hdr=$2
       lib=$3
       exp=$4
       cfl=$5
           cat > $TMPC << EOF
   #include <$hdr>
   int main(void) { $exp }
   EOF
       if compile_prog "$cfl" "$lib" ; 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);"
       libs_softmmu="-lasound $libs_softmmu"
       ;;
   
       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"
       libs_softmmu="$fmod_lib $libs_softmmu"
       ;;
   
       esd)
       audio_drv_probe $drv esd.h -lesd 'return esd_play_stream(0, 0, "", 0);'
       libs_softmmu="-lesd $libs_softmmu"
       audio_pt_int="yes"
       ;;
   
       pa)
       audio_drv_probe $drv pulse/simple.h "-lpulse-simple -lpulse" \
           "pa_simple *s = NULL; pa_simple_free(s); return 0;"
       libs_softmmu="-lpulse -lpulse-simple $libs_softmmu"
       audio_pt_int="yes"
       ;;
   
       coreaudio)
         libs_softmmu="-framework CoreAudio $libs_softmmu"
       ;;
   
       dsound)
         libs_softmmu="-lole32 -ldxguid $libs_softmmu"
         audio_win_int="yes"
       ;;
   
       oss)
         libs_softmmu="$oss_lib $libs_softmmu"
       ;;
   
       sdl|wav)
       # XXX: Probes for CoreAudio, DirectSound, SDL(?)
       ;;
   
       winwave)
         libs_softmmu="-lwinmm $libs_softmmu"
         audio_win_int="yes"
       ;;
   
       *)
       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 "$brlapi" != "no" ; then
     brlapi_libs="-lbrlapi"
     cat > $TMPC << EOF
   #include <brlapi.h>
   int main( void ) { return brlapi__openConnection (NULL, NULL, NULL); }
   EOF
     if compile_prog "" "$brlapi_libs" ; then
       brlapi=yes
       libs_softmmu="$brlapi_libs $libs_softmmu"
     else
       if test "$brlapi" = "yes" ; then
         feature_not_found "brlapi"
       fi
       brlapi=no
     fi
   fi
   
   ##########################################
   # curses probe
   curses_list="-lncurses -lcurses"
   
   if test "$curses" != "no" ; then
     curses_found=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
     for curses_lib in $curses_list; do
       if compile_prog "" "$curses_lib" ; then
         curses_found=yes
         libs_softmmu="$curses_lib $libs_softmmu"
         break
       fi
     done
     if test "$curses_found" = "yes" ; then
       curses=yes
     else
       if test "$curses" = "yes" ; then
         feature_not_found "curses"
       fi
       curses=no
     fi
   fi
   
   ##########################################
   # curl probe
   
   if test "$curl" != "no" ; then
     cat > $TMPC << EOF
   #include <curl/curl.h>
   int main(void) { return curl_easy_init(); }
   EOF
     curl_cflags=`curl-config --cflags 2>/dev/null`
     curl_libs=`curl-config --libs 2>/dev/null`
     if compile_prog "$curl_cflags" "$curl_libs" ; then
       curl=yes
       libs_tools="$curl_libs $libs_tools"
       libs_softmmu="$curl_libs $libs_softmmu"
     else
       if test "$curl" = "yes" ; then
         feature_not_found "curl"
       fi
       curl=no
     fi
   fi # test "$curl"
   
   ##########################################
   # check framework probe
   
   if test "$check_utests" != "no" ; then
     cat > $TMPC << EOF
   #include <check.h>
   int main(void) { suite_create("qemu test"); return 0; }
   EOF
     check_libs=`pkg-config --libs check`
     if compile_prog "" $check_libs ; then
       check_utests=yes
       libs_tools="$check_libs $libs_tools"
     else
       if test "$check_utests" = "yes" ; then
         feature_not_found "check"
       fi
       check_utests=no
     fi
   fi # test "$check_utests"
   
   ##########################################
   # bluez support probe
   if test "$bluez" != "no" ; then
     cat > $TMPC << EOF
   #include <bluetooth/bluetooth.h>
   int main(void) { return bt_error(0); }
   EOF
     bluez_cflags=`pkg-config --cflags bluez 2> /dev/null`
     bluez_libs=`pkg-config --libs bluez 2> /dev/null`
     if compile_prog "$bluez_cflags" "$bluez_libs" ; then
       bluez=yes
       libs_softmmu="$bluez_libs $libs_softmmu"
     else
       if test "$bluez" = "yes" ; then
         feature_not_found "bluez"
       fi
       bluez="no"
     fi
   fi
   
   ##########################################
   # kvm probe
   if test "$kvm" != "no" ; 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 "$cpu" = "s390x" -a -d "$kerneldir/arch/s390/include" ; then
               kvm_cflags="$kvm_cflags -I$kerneldir/arch/s390/include"
           elif test -d "$kerneldir/arch/$cpu/include" ; then
               kvm_cflags="$kvm_cflags -I$kerneldir/arch/$cpu/include"
         fi
     else
         kvm_cflags=""
     fi
     if compile_prog "$kvm_cflags" "" ; then
       kvm=yes
     else
       if test "$kvm" = "yes" ; then
         if [ -x "`which awk 2>/dev/null`" ] && \
            [ -x "`which grep 2>/dev/null`" ]; then
           kvmerr=`LANG=C $cc $QEMU_CFLAGS -o $TMPE $kvm_cflags $TMPC 2>&1 \
           | grep "error: " \
           | awk -F "error: " '{if (NR>1) printf(", "); printf("%s",$2);}'`
           if test "$kvmerr" != "" ; then
             echo -e "${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
         feature_not_found "kvm"
       fi
       kvm=no
     fi
   fi
   
   ##########################################
   # pthread probe
   PTHREADLIBS_LIST="-lpthread -lpthreadGC2"
   
   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 compile_prog "" "$pthread_lib" ; then
       pthread=yes
       LIBS="$pthread_lib $LIBS"
       break
     fi
   done
   
   if test "$mingw32" != yes -a "$pthread" = no; then
     echo
     echo "Error: pthread check failed"
     echo "Make sure to have the pthread libs and headers installed."
     echo
     exit 1
   fi
   
   ##########################################
   # linux-aio probe
   
   if test "$linux_aio" != "no" ; then
     cat > $TMPC <<EOF
   #include <libaio.h>
   #include <sys/eventfd.h>
   int main(void) { io_setup(0, NULL); io_set_eventfd(NULL, 0); eventfd(0, 0); return 0; }
   EOF
     if compile_prog "" "-laio" ; then
       linux_aio=yes
       LIBS="$LIBS -laio"
     else
       if test "$linux_aio" = "yes" ; then
         feature_not_found "linux AIO"
       fi
       linux_aio=no
     fi
 fi  fi
 mandir="$prefix/share/man"  
 datadir="$prefix/share/qemu"  ##########################################
 docdir="$prefix/share/doc/qemu"  # iovec probe
 bindir="$prefix/bin"  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 compile_prog "" "" ; then
     iovec=yes
 fi  fi
   
 # kqemu support  ##########################################
 if test $kqemu = "yes" ; then  # preadv probe
     # test if the source code is installed  cat > $TMPC <<EOF
     if test '!' -f "kqemu/Makefile" ; then  #include <sys/types.h>
         kqemu="no"  #include <sys/uio.h>
   #include <unistd.h>
   int main(void) { preadv; }
   EOF
   preadv=no
   if compile_prog "" "" ; then
     preadv=yes
   fi
   
   ##########################################
   # fdt probe
   if test "$fdt" != "no" ; then
     fdt_libs="-lfdt"
     cat > $TMPC << EOF
   int main(void) { return 0; }
   EOF
     if compile_prog "" "$fdt_libs" ; then
       fdt=yes
       libs_softmmu="$fdt_libs $libs_softmmu"
     else
       if test "$fdt" = "yes" ; then
         feature_not_found "fdt"
     fi      fi
       fdt=no
     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 compile_prog "" "" ; 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 compile_prog "" "" ; 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 compile_prog "" "" ; 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 compile_prog "" "" ; then
     pipe2=yes
   fi
   
   # check if accept4 is there
   accept4=no
   cat > $TMPC << EOF
   #define _GNU_SOURCE
   #include <sys/socket.h>
   #include <stddef.h>
   
   int main(void)
   {
       accept4(0, NULL, NULL, SOCK_CLOEXEC);
       return 0;
   }
   EOF
   if compile_prog "" "" ; then
     accept4=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 compile_prog "" "" ; then
     splice=yes
 fi  fi
   
 # Linux specific kqemu configuration  # check if eventfd is supported
 if test $kqemu = "yes" -a $linux = "yes" ; then  eventfd=no
 # find the kernel path  cat > $TMPC << EOF
 if test -z "$kernel_path" ; then  #include <sys/eventfd.h>
 kernel_version=`uname -r`  
 kernel_path="/lib/modules/$kernel_version/build"  int main(void)
 if test '!' -d "$kernel_path/include" ; then  {
     kernel_path="/usr/src/linux"      int efd = eventfd(0, 0);
     if test '!' -d "$kernel_path/include" ; then      return 0;
         echo "Could not find kernel includes in /lib/modules or /usr/src/linux - cannot build the kqemu module"  }
         kqemu="no"  EOF
   if compile_prog "" "" ; then
     eventfd=yes
   fi
   
   # check for fallocate
   fallocate=no
   cat > $TMPC << EOF
   #include <fcntl.h>
   
   int main(void)
   {
       fallocate(0, 0, 0, 0);
       return 0;
   }
   EOF
   if compile_prog "$ARCH_CFLAGS" "" ; then
     fallocate=yes
   fi
   
   # check for dup3
   dup3=no
   cat > $TMPC << EOF
   #include <unistd.h>
   
   int main(void)
   {
       dup3(0, 0, 0);
       return 0;
   }
   EOF
   if compile_prog "" "" ; then
     dup3=yes
   fi
   
   # Check if tools are available to build documentation.
   if test "$docs" != "no" ; then
     if test -x "`which texi2html 2>/dev/null`" -a \
             -x "`which pod2man 2>/dev/null`" ; then
       docs=yes
     else
       if test "$docs" = "yes" ; then
         feature_not_found "docs"
       fi
       docs=no
     fi
   fi
   
   # Search for bswap_32 function
   byteswap_h=no
   cat > $TMPC << EOF
   #include <byteswap.h>
   int main(void) { return bswap_32(0); }
   EOF
   if compile_prog "" "" ; then
     byteswap_h=yes
   fi
   
   # Search for bswap_32 function
   bswap_h=no
   cat > $TMPC << EOF
   #include <sys/endian.h>
   #include <sys/types.h>
   #include <machine/bswap.h>
   int main(void) { return bswap32(0); }
   EOF
   if compile_prog "" "" ; then
     bswap_h=yes
   fi
   
   ##########################################
   # Do we need librt
   cat > $TMPC <<EOF
   #include <signal.h>
   #include <time.h>
   int main(void) { clockid_t id; return clock_gettime(id, NULL); }
   EOF
   
   if compile_prog "" "" ; then
     :
   elif compile_prog "" "-lrt" ; then
     LIBS="-lrt $LIBS"
   fi
   
   # Determine what linker flags to use to force archive inclusion
   check_linker_flags()
   {
       w2=
       if test "$2" ; then
           w2=-Wl,$2
     fi      fi
       compile_prog "" "-Wl,$1 ${w2}"
   }
   
   cat > $TMPC << EOF
   int main(void) { }
   EOF
   if check_linker_flags --whole-archive --no-whole-archive ; then
       # GNU ld
       arlibs_begin="-Wl,--whole-archive"
       arlibs_end="-Wl,--no-whole-archive"
   elif check_linker_flags -z,allextract -z,defaultextract ; then
       # Solaris ld
       arlibs_begin="-Wl,-z,allextract"
       arlibs_end="-Wl,-z,defaultextract"
   elif check_linker_flags -all_load ; then
       # Mac OS X
       arlibs_begin="-all_load"
       arlibs_end=""
   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 "$darwin" != "yes" -a "$mingw32" != "yes" -a "$solaris" != yes -a \
           "$aix" != "yes" ; then
       libs_softmmu="-lutil $libs_softmmu"
   fi
   
   ##########################################
   # check if the compiler defines offsetof
   
   need_offsetof=yes
   cat > $TMPC << EOF
   #include <stddef.h>
   int main(void) { struct s { int f; }; return offsetof(struct s, f); }
   EOF
   if compile_prog "" "" ; then
       need_offsetof=no
   fi
   
   ##########################################
   # check if the compiler understands attribute warn_unused_result
   #
   # This could be smarter, but gcc -Werror does not error out even when warning
   # about attribute warn_unused_result
   
   gcc_attribute_warn_unused_result=no
   cat > $TMPC << EOF
   #if defined(__GNUC__) && (__GNUC__ < 4) && defined(__GNUC_MINOR__) && (__GNUC__ < 4)
   #error gcc 3.3 or older
   #endif
   int main(void) { return 0;}
   EOF
   if compile_prog "" ""; then
       gcc_attribute_warn_unused_result=yes
 fi  fi
   
   ##########################################
   # check if we have fdatasync
   
   fdatasync=no
   cat > $TMPC << EOF
   #include <unistd.h>
   int main(void) { return fdatasync(0); }
   EOF
   if compile_prog "" "" ; then
       fdatasync=yes
 fi  fi
   
 if test $kqemu = "yes" ; then  # End of CC checks
   # After here, no more $cc or $ld runs
   
 # test that the kernel config is present  if test "$debug" = "no" ; then
 if test '!' -f "$kernel_path/Makefile" ; then    CFLAGS="-O2 $CFLAGS"
     echo "No Makefile file present in $kernel_path - kqemu cannot be built"  
     kqemu="no"  
 fi  fi
   
 # find build system (2.6 or legacy)  # Consult white-list to determine whether to enable werror
 kbuild26="yes"  # by default.  Only enable by default for git builds
 if grep -q "PATCHLEVEL = 4" $kernel_path/Makefile ; then  z_version=`cut -f3 -d. $source_path/VERSION`
 kbuild26="no"  
   if test -z "$werror" ; then
       if test "$z_version" = "50" -a \
           "$linux" = "yes" ; then
           werror="yes"
       else
           werror="no"
       fi
 fi  fi
   
 fi # kqemu  # Disable zero malloc errors for official releases unless explicitly told to
   # enable/disable
   if test -z "$zero_malloc" ; then
       if test "$z_version" = "50" ; then
           zero_malloc="no"
       else
           zero_malloc="yes"
       fi
   fi
   
 fi # kqemu and linux  if test "$werror" = "yes" ; then
       QEMU_CFLAGS="-Werror $QEMU_CFLAGS"
   fi
   
   if test "$solaris" = "no" ; then
       if $ld --version 2>/dev/null | grep "GNU ld" >/dev/null 2>/dev/null ; then
           LDFLAGS="-Wl,--warn-common $LDFLAGS"
       fi
   fi
   
   if test "$mingw32" = "yes" ; then
     if test -z "$prefix" ; then
         prefix="c:/Program Files/Qemu"
     fi
     mansuffix=""
     datasuffix=""
     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
   
 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 "CFLAGS            $CFLAGS"
   echo "QEMU_CFLAGS       $QEMU_CFLAGS"
   echo "LDFLAGS           $LDFLAGS"
 echo "make              $make"  echo "make              $make"
   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 "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
 echo "SDL support       $sdl"  echo "SDL support       $sdl"
 if test "$sdl" != "no" ; then  echo "curses support    $curses"
     echo "SDL static link   $sdl_static"  echo "curl support      $curl"
 fi  echo "check support     $check_utests"
 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 "Block whitelist   $block_drv_whitelist"
 echo "DSound support    $dsound"  echo "Mixer emulation   $mixemu"
 echo -n "FMOD support      $fmod"  echo "VNC TLS support   $vnc_tls"
 if test "$fmod" = "yes"; then  echo "VNC SASL support  $vnc_sasl"
     if test -z $fmod_lib || test -z $fmod_inc; then  if test -n "$sparc_cpu"; then
         echo      echo "Target Sparc Arch $sparc_cpu"
         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 "xen support       $xen"
         echo  echo "brlapi support    $brlapi"
         exit 1  echo "bluez  support    $bluez"
     fi  echo "Documentation     $docs"
     echo -n " (lib='$fmod_lib' include='$fmod_inc')"  [ ! -z "$uname_release" ] && \
 fi  echo "uname -r          $uname_release"
 echo ""  echo "NPTL support      $nptl"
 echo "kqemu support     $kqemu"  echo "GUEST_BASE        $guest_base"
 if test $kqemu = "yes" -a $linux = "yes" ; then  echo "PIE user targets  $user_pie"
 echo ""  echo "vde support       $vde"
 echo "KQEMU Linux module configuration:"  echo "IO thread         $io_thread"
 echo "kernel sources    $kernel_path"  echo "Linux AIO support $linux_aio"
 echo -n "kbuild type       "  echo "Install blobs     $blobs"
 if test $kbuild26 = "yes"; then  echo "KVM support       $kvm"
 echo "2.6"  echo "fdt support       $fdt"
 else  echo "preadv support    $preadv"
 echo "2.4"  echo "fdatasync         $fdatasync"
 fi  echo "uuid support      $uuid"
 fi  
   
 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"
 fi  fi
 #if test "$sdl_static" = "no"; then  
 #  echo "WARNING: cannot compile statically with SDL - qemu-fast won't have a graphical output"  config_host_mak="config-host.mak"
 #fi  config_host_ld="config-host.ld"
   
 config_mak="config-host.mak"  echo "# Automatically generated by configure - do not modify" > $config_host_mak
 config_h="config-host.h"  printf "# Configured with:" >> $config_host_mak
   printf " '%s'" "$0" "$@" >> $config_host_mak
 #echo "Creating $config_mak and $config_h"  echo >> $config_host_mak
   
 echo "# Automatically generated by configure - do not modify" > $config_mak  echo "CONFIG_QEMU_SHAREDIR=\"$prefix$datasuffix\"" >> $config_host_mak
 echo "/* Automatically generated by configure - do not modify */" > $config_h  
   case "$cpu" in
 echo "prefix=$prefix" >> $config_mak    i386|x86_64|alpha|cris|hppa|ia64|m68k|microblaze|mips|mips64|ppc|ppc64|s390|s390x|sparc|sparc64)
 echo "bindir=$bindir" >> $config_mak      ARCH=$cpu
 echo "mandir=$mandir" >> $config_mak    ;;
 echo "datadir=$datadir" >> $config_mak    armv4b|armv4l)
 echo "docdir=$docdir" >> $config_mak      ARCH=arm
 echo "#define CONFIG_QEMU_SHAREDIR \"$datadir\"" >> $config_h    ;;
 echo "MAKE=$make" >> $config_mak    *)
 echo "CC=$cc" >> $config_mak      echo "Unsupported CPU = $cpu"
 if test "$have_gcc3_options" = "yes" ; then      exit 1
   echo "HAVE_GCC3_OPTIONS=yes" >> $config_mak    ;;
 fi  esac
 echo "HOST_CC=$host_cc" >> $config_mak  echo "ARCH=$ARCH" >> $config_host_mak
 echo "AR=$ar" >> $config_mak  if test "$debug_tcg" = "yes" ; then
 echo "STRIP=$strip -s -R .comment -R .note" >> $config_mak    echo "CONFIG_DEBUG_TCG=y" >> $config_host_mak
 echo "CFLAGS=$CFLAGS" >> $config_mak  fi
 echo "LDFLAGS=$LDFLAGS" >> $config_mak  if test "$debug" = "yes" ; then
 echo "EXESUF=$EXESUF" >> $config_mak    echo "CONFIG_DEBUG_EXEC=y" >> $config_host_mak
 if test "$cpu" = "i386" ; then  fi
   echo "ARCH=i386" >> $config_mak  if test "$strip_opt" = "yes" ; then
   echo "#define HOST_I386 1" >> $config_h    echo "STRIP_OPT=-s" >> $config_host_mak
 elif test "$cpu" = "x86_64" ; then  
   echo "ARCH=x86_64" >> $config_mak  
   echo "#define HOST_X86_64 1" >> $config_h  
 elif test "$cpu" = "armv4b" ; then  
   echo "ARCH=arm" >> $config_mak  
   echo "#define HOST_ARM 1" >> $config_h  
 elif test "$cpu" = "armv4l" ; then  
   echo "ARCH=arm" >> $config_mak  
   echo "#define HOST_ARM 1" >> $config_h  
 elif test "$cpu" = "powerpc" ; then  
   echo "ARCH=ppc" >> $config_mak  
   echo "#define HOST_PPC 1" >> $config_h  
 elif test "$cpu" = "mips" ; then  
   echo "ARCH=mips" >> $config_mak  
   echo "#define HOST_MIPS 1" >> $config_h  
 elif test "$cpu" = "s390" ; then  
   echo "ARCH=s390" >> $config_mak  
   echo "#define HOST_S390 1" >> $config_h  
 elif test "$cpu" = "alpha" ; then  
   echo "ARCH=alpha" >> $config_mak  
   echo "#define HOST_ALPHA 1" >> $config_h  
 elif test "$cpu" = "sparc" ; then  
   echo "ARCH=sparc" >> $config_mak  
   echo "#define HOST_SPARC 1" >> $config_h  
 elif test "$cpu" = "sparc64" ; then  
   echo "ARCH=sparc64" >> $config_mak  
   echo "#define HOST_SPARC64 1" >> $config_h  
 elif test "$cpu" = "ia64" ; then  
   echo "ARCH=ia64" >> $config_mak  
   echo "#define HOST_IA64 1" >> $config_h  
 elif test "$cpu" = "m68k" ; then  
   echo "ARCH=m68k" >> $config_mak  
   echo "#define HOST_M68K 1" >> $config_h  
 else  
   echo "Unsupported CPU"  
   exit 1  
 fi  fi
 if test "$bigendian" = "yes" ; then  if test "$bigendian" = "yes" ; then
   echo "WORDS_BIGENDIAN=yes" >> $config_mak    echo "HOST_WORDS_BIGENDIAN=y" >> $config_host_mak
   echo "#define WORDS_BIGENDIAN 1" >> $config_h  
 fi  fi
 echo "#define HOST_LONG_BITS $hostlongbits" >> $config_h  echo "HOST_LONG_BITS=$hostlongbits" >> $config_host_mak
 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  else
 elif test -f "/usr/include/byteswap.h" ; then    echo "CONFIG_POSIX=y" >> $config_host_mak
   echo "#define HAVE_BYTESWAP_H 1" >> $config_h  fi
   
   if test "$linux" = "yes" ; then
     echo "CONFIG_LINUX=y" >> $config_host_mak
 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  
 fi  fi
 if test "$gdbstub" = "yes" ; then  
   echo "CONFIG_GDBSTUB=yes" >> $config_mak  if test "$aix" = "yes" ; then
   echo "#define CONFIG_GDBSTUB 1" >> $config_h    echo "CONFIG_AIX=y" >> $config_host_mak
 fi  fi
 if test "$gprof" = "yes" ; then  
   echo "TARGET_GPROF=yes" >> $config_mak  if test "$solaris" = "yes" ; then
   echo "#define HAVE_GPROF 1" >> $config_h    echo "CONFIG_SOLARIS=y" >> $config_host_mak
     echo "CONFIG_SOLARIS_VERSION=$solarisrev" >> $config_host_mak
     if test "$needs_libsunmath" = "yes" ; then
       echo "CONFIG_NEEDS_LIBSUNMATH=y" >> $config_host_mak
     fi
 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    LDFLAGS="-static $LDFLAGS"
   fi
   if test $profiler = "yes" ; then
     echo "CONFIG_PROFILER=y" >> $config_host_mak
 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    QEMU_CFLAGS="-I\$(SRC_PATH)/slirp $QEMU_CFLAGS"
   fi
   if test "$vde" = "yes" ; then
     echo "CONFIG_VDE=y" >> $config_host_mak
 fi  fi
 if test "$adlib" = "yes" ; then  for card in $audio_card_list; do
   echo "CONFIG_ADLIB=yes" >> $config_mak      def=CONFIG_`echo $card | tr '[:lower:]' '[:upper:]'`
   echo "#define CONFIG_ADLIB 1" >> $config_h      echo "$def=y" >> $config_host_mak
 fi  done
 if test "$oss" = "yes" ; then  echo "CONFIG_AUDIO_DRIVERS=$audio_drv_list" >> $config_host_mak
   echo "CONFIG_OSS=yes" >> $config_mak  for drv in $audio_drv_list; do
   echo "#define CONFIG_OSS 1" >> $config_h      def=CONFIG_`echo $drv | tr '[:lower:]' '[:upper:]'`
 fi      echo "$def=y" >> $config_host_mak
 if test "$coreaudio" = "yes" ; then      if test "$drv" = "fmod"; then
   echo "CONFIG_COREAUDIO=yes" >> $config_mak          echo "FMOD_CFLAGS=-I$fmod_inc" >> $config_host_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  
 echo -n "VERSION=" >>$config_mak  
 head $source_path/VERSION >>$config_mak  
 echo "" >>$config_mak  
 echo -n "#define QEMU_VERSION \"" >> $config_h  
 head $source_path/VERSION >> $config_h  
 echo "\"" >> $config_h  
   
 if test $kqemu = "yes" ; then  
   echo "CONFIG_KQEMU=yes" >> $config_mak  
   if test $linux = "yes" ; then  
     echo "KERNEL_PATH=$kernel_path" >> $config_mak  
     if test $kbuild26 = "yes" ; then  
       echo "CONFIG_KBUILD26=yes" >> $config_mak  
     fi      fi
   fi  done
   if test "$audio_pt_int" = "yes" ; then
     echo "CONFIG_AUDIO_PT_INT=y" >> $config_host_mak
   fi
   if test "$audio_win_int" = "yes" ; then
     echo "CONFIG_AUDIO_WIN_INT=y" >> $config_host_mak
   fi
   echo "CONFIG_BDRV_WHITELIST=$block_drv_whitelist" >> $config_host_mak
   if test "$mixemu" = "yes" ; then
     echo "CONFIG_MIXEMU=y" >> $config_host_mak
   fi
   if test "$vnc_tls" = "yes" ; then
     echo "CONFIG_VNC_TLS=y" >> $config_host_mak
     echo "VNC_TLS_CFLAGS=$vnc_tls_cflags" >> $config_host_mak
   fi
   if test "$vnc_sasl" = "yes" ; then
     echo "CONFIG_VNC_SASL=y" >> $config_host_mak
     echo "VNC_SASL_CFLAGS=$vnc_sasl_cflags" >> $config_host_mak
   fi
   if test "$fnmatch" = "yes" ; then
     echo "CONFIG_FNMATCH=y" >> $config_host_mak
   fi
   if test "$uuid" = "yes" ; then
     echo "CONFIG_UUID=y" >> $config_host_mak
   fi
   qemu_version=`head $source_path/VERSION`
   echo "VERSION=$qemu_version" >>$config_host_mak
   echo "PKGVERSION=$pkgversion" >>$config_host_mak
   echo "SRC_PATH=$source_path" >> $config_host_mak
   if [ "$source_path_used" = "yes" ]; then
     echo "VPATH=$source_path" >> $config_host_mak
   fi
   echo "TARGET_DIRS=$target_list" >> $config_host_mak
   if [ "$docs" = "yes" ] ; then
     echo "BUILD_DOCS=yes" >> $config_host_mak
   fi
   if test "$sdl" = "yes" ; then
     echo "CONFIG_SDL=y" >> $config_host_mak
     echo "SDL_CFLAGS=$sdl_cflags" >> $config_host_mak
   fi
   if test "$cocoa" = "yes" ; then
     echo "CONFIG_COCOA=y" >> $config_host_mak
   fi
   if test "$curses" = "yes" ; then
     echo "CONFIG_CURSES=y" >> $config_host_mak
   fi
   if test "$atfile" = "yes" ; then
     echo "CONFIG_ATFILE=y" >> $config_host_mak
   fi
   if test "$utimens" = "yes" ; then
     echo "CONFIG_UTIMENSAT=y" >> $config_host_mak
   fi
   if test "$pipe2" = "yes" ; then
     echo "CONFIG_PIPE2=y" >> $config_host_mak
   fi
   if test "$accept4" = "yes" ; then
     echo "CONFIG_ACCEPT4=y" >> $config_host_mak
   fi
   if test "$splice" = "yes" ; then
     echo "CONFIG_SPLICE=y" >> $config_host_mak
   fi
   if test "$eventfd" = "yes" ; then
     echo "CONFIG_EVENTFD=y" >> $config_host_mak
   fi
   if test "$fallocate" = "yes" ; then
     echo "CONFIG_FALLOCATE=y" >> $config_host_mak
   fi
   if test "$dup3" = "yes" ; then
     echo "CONFIG_DUP3=y" >> $config_host_mak
   fi
   if test "$inotify" = "yes" ; then
     echo "CONFIG_INOTIFY=y" >> $config_host_mak
   fi
   if test "$byteswap_h" = "yes" ; then
     echo "CONFIG_BYTESWAP_H=y" >> $config_host_mak
   fi
   if test "$bswap_h" = "yes" ; then
     echo "CONFIG_MACHINE_BSWAP_H=y" >> $config_host_mak
   fi
   if test "$curl" = "yes" ; then
     echo "CONFIG_CURL=y" >> $config_host_mak
     echo "CURL_CFLAGS=$curl_cflags" >> $config_host_mak
   fi
   if test "$brlapi" = "yes" ; then
     echo "CONFIG_BRLAPI=y" >> $config_host_mak
   fi
   if test "$bluez" = "yes" ; then
     echo "CONFIG_BLUEZ=y" >> $config_host_mak
     echo "BLUEZ_CFLAGS=$bluez_cflags" >> $config_host_mak
   fi
   if test "$xen" = "yes" ; then
     echo "CONFIG_XEN=y" >> $config_host_mak
   fi
   if test "$io_thread" = "yes" ; then
     echo "CONFIG_IOTHREAD=y" >> $config_host_mak
   fi
   if test "$linux_aio" = "yes" ; then
     echo "CONFIG_LINUX_AIO=y" >> $config_host_mak
   fi
   if test "$blobs" = "yes" ; then
     echo "INSTALL_BLOBS=yes" >> $config_host_mak
   fi
   if test "$iovec" = "yes" ; then
     echo "CONFIG_IOVEC=y" >> $config_host_mak
   fi
   if test "$preadv" = "yes" ; then
     echo "CONFIG_PREADV=y" >> $config_host_mak
   fi
   if test "$fdt" = "yes" ; then
     echo "CONFIG_FDT=y" >> $config_host_mak
   fi
   if test "$need_offsetof" = "yes" ; then
     echo "CONFIG_NEED_OFFSETOF=y" >> $config_host_mak
   fi
   if test "$gcc_attribute_warn_unused_result" = "yes" ; then
     echo "CONFIG_GCC_ATTRIBUTE_WARN_UNUSED_RESULT=y" >> $config_host_mak
   fi
   if test "$fdatasync" = "yes" ; then
     echo "CONFIG_FDATASYNC=y" >> $config_host_mak
 fi  fi
 echo "SRC_PATH=$source_path" >> $config_mak  
 echo "TARGET_DIRS=$target_list" >> $config_mak  
   
 # XXX: suppress that  # XXX: suppress that
 if [ "$bsd" = "yes" ] ; then  if [ "$bsd" = "yes" ] ; then
   echo "#define O_LARGEFILE 0" >> $config_h    echo "CONFIG_BSD=y" >> $config_host_mak
   echo "#define MAP_ANONYMOUS MAP_ANON" >> $config_h  
   echo "#define _BSD 1" >> $config_h  
 fi  fi
   
 for target in $target_list; do  echo "CONFIG_UNAME_RELEASE=\"$uname_release\"" >> $config_host_mak
   
 target_dir="$target"  if test "$zero_malloc" = "yes" ; then
 config_mak=$target_dir/config.mak    echo "CONFIG_ZERO_MALLOC=y" >> $config_host_mak
 config_h=$target_dir/config.h  
 target_cpu=`echo $target | cut -d '-' -f 1`  
 target_bigendian="no"  
 [ "$target_cpu" = "armeb" ] && target_bigendian=yes  
 [ "$target_cpu" = "sparc" ] && target_bigendian=yes  
 [ "$target_cpu" = "sparc64" ] && target_bigendian=yes  
 [ "$target_cpu" = "ppc" ] && target_bigendian=yes  
 [ "$target_cpu" = "ppc64" ] && target_bigendian=yes  
 [ "$target_cpu" = "mips" ] && target_bigendian=yes  
 target_softmmu="no"  
 if expr $target : '.*-softmmu' > /dev/null ; then  
   target_softmmu="yes"  
 fi  fi
 target_user_only="no"  
 if expr $target : '.*-user' > /dev/null ; then  # USB host support
   target_user_only="yes"  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
   
   tools=
   if test `expr "$target_list" : ".*softmmu.*"` != 0 ; then
     tools="qemu-img\$(EXESUF) qemu-io\$(EXESUF) $tools"
     if [ "$linux" = "yes" ] ; then
         tools="qemu-nbd\$(EXESUF) $tools"
       if [ "$check_utests" = "yes" ]; then
         tools="check-qint check-qstring check-qdict check-qlist $tools"
         tools="check-qfloat check-qjson $tools"
       fi
     fi
 fi  fi
   echo "TOOLS=$tools" >> $config_host_mak
   
 if test "$target_user_only" = "no" -a "$check_gfx" = "yes" \  # Mac OS X ships with a broken assembler
         -a "$sdl" = "no" -a "$cocoa" = "no" ; then  roms=
     echo "ERROR: QEMU requires SDL or Cocoa for graphical output"  if test \( "$cpu" = "i386" -o "$cpu" = "x86_64" \) -a \
     echo "To build QEMU with graphical output configure with --disable-gfx-check"          "$targetos" != "Darwin" -a "$targetos" != "SunOS" -a \
     echo "Note that this will disable all output from the virtual graphics card."          `expr "$target_list" : ".*softmmu.*"` != 0 ; then
     exit 1;    roms="optionrom"
   fi
   echo "ROMS=$roms" >> $config_host_mak
   
   echo "prefix=$prefix" >> $config_host_mak
   echo "bindir=\${prefix}$binsuffix" >> $config_host_mak
   echo "mandir=\${prefix}$mansuffix" >> $config_host_mak
   echo "datadir=\${prefix}$datasuffix" >> $config_host_mak
   echo "docdir=\${prefix}$docsuffix" >> $config_host_mak
   echo "MAKE=$make" >> $config_host_mak
   echo "INSTALL=$install" >> $config_host_mak
   echo "INSTALL_DIR=$install -d -m0755 -p" >> $config_host_mak
   echo "INSTALL_DATA=$install -m0644 -p" >> $config_host_mak
   echo "INSTALL_PROG=$install -m0755 -p" >> $config_host_mak
   echo "CC=$cc" >> $config_host_mak
   echo "HOST_CC=$host_cc" >> $config_host_mak
   if test "$sparse" = "yes" ; then
     echo "CC      := REAL_CC=\"\$(CC)\" cgcc"       >> $config_host_mak
     echo "HOST_CC := REAL_CC=\"\$(HOST_CC)\" cgcc"  >> $config_host_mak
     echo "QEMU_CFLAGS  += -Wbitwise -Wno-transparent-union -Wno-old-initializer -Wno-non-pointer-null" >> $config_host_mak
   fi
   echo "AR=$ar" >> $config_host_mak
   echo "OBJCOPY=$objcopy" >> $config_host_mak
   echo "LD=$ld" >> $config_host_mak
   echo "CFLAGS=$CFLAGS" >> $config_host_mak
   echo "QEMU_CFLAGS=$QEMU_CFLAGS" >> $config_host_mak
   echo "HELPER_CFLAGS=$helper_cflags" >> $config_host_mak
   echo "LDFLAGS=$LDFLAGS" >> $config_host_mak
   echo "ARLIBS_BEGIN=$arlibs_begin" >> $config_host_mak
   echo "ARLIBS_END=$arlibs_end" >> $config_host_mak
   echo "LIBS+=$LIBS" >> $config_host_mak
   echo "LIBS_TOOLS+=$libs_tools" >> $config_host_mak
   echo "EXESUF=$EXESUF" >> $config_host_mak
   
   # generate list of library paths for linker script
   
   $ld --verbose -v 2> /dev/null | grep SEARCH_DIR > ${config_host_ld}
   
   if test -f ${config_host_ld}~ ; then
     if cmp -s $config_host_ld ${config_host_ld}~ ; then
       mv ${config_host_ld}~ $config_host_ld
     else
       rm ${config_host_ld}~
     fi
 fi  fi
   
 #echo "Creating $config_mak, $config_h and $target_dir/Makefile"  for target in $target_list; do
   target_dir="$target"
   config_target_mak=$target_dir/config-target.mak
   target_arch2=`echo $target | cut -d '-' -f 1`
   target_bigendian="no"
   
   case "$target_arch2" in
     armeb|m68k|microblaze|mips|mipsn32|mips64|ppc|ppcemb|ppc64|ppc64abi32|s390x|sh4eb|sparc|sparc64|sparc32plus)
     target_bigendian=yes
     ;;
   esac
   target_softmmu="no"
   target_user_only="no"
   target_linux_user="no"
   target_darwin_user="no"
   target_bsd_user="no"
   case "$target" in
     ${target_arch2}-softmmu)
       target_softmmu="yes"
       ;;
     ${target_arch2}-linux-user)
       if test "$linux" != "yes" ; then
         echo "ERROR: Target '$target' is only available on a Linux host"
         exit 1
       fi
       target_user_only="yes"
       target_linux_user="yes"
       ;;
     ${target_arch2}-darwin-user)
       if test "$darwin" != "yes" ; then
         echo "ERROR: Target '$target' is only available on a Darwin host"
         exit 1
       fi
       target_user_only="yes"
       target_darwin_user="yes"
       ;;
     ${target_arch2}-bsd-user)
       if test "$bsd" != "yes" ; then
         echo "ERROR: Target '$target' is only available on a BSD host"
         exit 1
       fi
       target_user_only="yes"
       target_bsd_user="yes"
       ;;
     *)
       echo "ERROR: Target '$target' not recognised"
       exit 1
       ;;
   esac
   
 mkdir -p $target_dir  mkdir -p $target_dir
 mkdir -p $target_dir/fpu  mkdir -p $target_dir/fpu
 if test "$target" = "arm-user" -o "$target" = "armeb-user" ; then  mkdir -p $target_dir/tcg
   mkdir -p $target_dir/ide
   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  #
   # don't use ln -sf as not all "ln -sf" over write the file/link
   #
   rm -f $target_dir/Makefile
   ln -s $source_path/Makefile.target $target_dir/Makefile
   
   
   echo "# Automatically generated by configure - do not modify" > $config_target_mak
   
   bflt="no"
   elfload32="no"
   target_nptl="no"
   interp_prefix1=`echo "$interp_prefix" | sed "s/%M/$target_arch2/g"`
   echo "CONFIG_QEMU_PREFIX=\"$interp_prefix1\"" >> $config_target_mak
   gdb_xml_files=""
   
   TARGET_ARCH="$target_arch2"
   TARGET_BASE_ARCH=""
   TARGET_ABI_DIR=""
   
   case "$target_arch2" in
     i386)
       target_phys_bits=32
     ;;
     x86_64)
       TARGET_BASE_ARCH=i386
       target_phys_bits=64
     ;;
     alpha)
       target_phys_bits=64
     ;;
     arm|armeb)
       TARGET_ARCH=arm
       bflt="yes"
       target_nptl="yes"
       gdb_xml_files="arm-core.xml arm-vfp.xml arm-vfp3.xml arm-neon.xml"
       target_phys_bits=32
     ;;
     cris)
       target_nptl="yes"
       target_phys_bits=32
     ;;
     m68k)
       bflt="yes"
       gdb_xml_files="cf-core.xml cf-fp.xml"
       target_phys_bits=32
     ;;
     microblaze)
       bflt="yes"
       target_nptl="yes"
       target_phys_bits=32
     ;;
     mips|mipsel)
       TARGET_ARCH=mips
       echo "TARGET_ABI_MIPSO32=y" >> $config_target_mak
       target_nptl="yes"
       target_phys_bits=64
     ;;
     mipsn32|mipsn32el)
       TARGET_ARCH=mipsn32
       TARGET_BASE_ARCH=mips
       echo "TARGET_ABI_MIPSN32=y" >> $config_target_mak
       target_phys_bits=64
     ;;
     mips64|mips64el)
       TARGET_ARCH=mips64
       TARGET_BASE_ARCH=mips
       echo "TARGET_ABI_MIPSN64=y" >> $config_target_mak
       target_phys_bits=64
     ;;
     ppc)
       gdb_xml_files="power-core.xml power-fpu.xml power-altivec.xml power-spe.xml"
       target_phys_bits=32
       target_nptl="yes"
     ;;
     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
       target_nptl="yes"
     ;;
     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_target_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_target_mak
       target_phys_bits=64
     ;;
     s390x)
       target_phys_bits=64
     ;;
     *)
       echo "Unsupported target CPU"
       exit 1
     ;;
   esac
   echo "TARGET_ARCH=$TARGET_ARCH" >> $config_target_mak
   target_arch_name="`echo $TARGET_ARCH | tr '[:lower:]' '[:upper:]'`"
   echo "TARGET_$target_arch_name=y" >> $config_target_mak
   echo "TARGET_ARCH2=$target_arch2" >> $config_target_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_target_mak
   if [ "$TARGET_ABI_DIR" = "" ]; then
     TARGET_ABI_DIR=$TARGET_ARCH
   fi
   echo "TARGET_ABI_DIR=$TARGET_ABI_DIR" >> $config_target_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_target_mak
       fi
   esac
   case "$target_arch2" in
     i386|x86_64|ppcemb|ppc|ppc64|s390x)
       # 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" = "ppc64"  -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_target_mak
         echo "KVM_CFLAGS=$kvm_cflags" >> $config_target_mak
       fi
   esac
   echo "TARGET_PHYS_ADDR_BITS=$target_phys_bits" >> $config_target_mak
   if test "$target_bigendian" = "yes" ; then
     echo "TARGET_WORDS_BIGENDIAN=y" >> $config_target_mak
 fi  fi
   if test "$target_softmmu" = "yes" ; then
     echo "CONFIG_SOFTMMU=y" >> $config_target_mak
     echo "LIBS+=$libs_softmmu" >> $config_target_mak
     echo "HWLIB=../libhw$target_phys_bits/libqemuhw$target_phys_bits.a" >> $config_target_mak
     echo "subdir-$target: subdir-libhw$target_phys_bits" >> $config_host_mak
   fi
   if test "$target_user_only" = "yes" ; then
     echo "CONFIG_USER_ONLY=y" >> $config_target_mak
   fi
   if test "$target_linux_user" = "yes" ; then
     echo "CONFIG_LINUX_USER=y" >> $config_target_mak
   fi
   if test "$target_darwin_user" = "yes" ; then
     echo "CONFIG_DARWIN_USER=y" >> $config_target_mak
   fi
   list=""
   if test ! -z "$gdb_xml_files" ; then
     for x in $gdb_xml_files; do
       list="$list $source_path/gdb-xml/$x"
     done
     echo "TARGET_XML_FILES=$list" >> $config_target_mak
   fi
   
   case "$target_arch2" in
     arm|armeb|m68k|microblaze|mips|mipsel|mipsn32|mipsn32el|mips64|mips64el|ppc|ppc64|ppc64abi32|ppcemb|s390x|sparc|sparc64|sparc32plus)
       echo "CONFIG_SOFTFLOAT=y" >> $config_target_mak
       ;;
     *)
       echo "CONFIG_NOSOFTFLOAT=y" >> $config_target_mak
       ;;
   esac
   
 ln -sf $source_path/Makefile.target $target_dir/Makefile  if test "$target_user_only" = "yes" -a "$bflt" = "yes"; then
     echo "TARGET_HAS_BFLT=y" >> $config_target_mak
   fi
   if test "$target_user_only" = "yes" \
           -a "$nptl" = "yes" -a "$target_nptl" = "yes"; then
     echo "CONFIG_USE_NPTL=y" >> $config_target_mak
   fi
   # 32 bit ELF loader in addition to native 64 bit loader?
   if test "$target_user_only" = "yes" -a "$elfload32" = "yes"; then
     echo "TARGET_HAS_ELFLOAD32=y" >> $config_target_mak
   fi
   if test "$target_user_only" = "yes" -a "$guest_base" = "yes"; then
     echo "CONFIG_USE_GUEST_BASE=y" >> $config_target_mak
   fi
   if test "$target_bsd_user" = "yes" ; then
     echo "CONFIG_BSD_USER=y" >> $config_target_mak
   fi
   
 echo "# Automatically generated by configure - do not modify" > $config_mak  # generate QEMU_CFLAGS/LDFLAGS for targets
 echo "/* Automatically generated by configure - do not modify */" > $config_h  
   
   cflags=""
   ldflags=""
   
 echo "include ../config-host.mak" >> $config_mak  if test "$ARCH" = "sparc64" ; then
 echo "#include \"../config-host.h\"" >> $config_h    cflags="-I\$(SRC_PATH)/tcg/sparc $cflags"
   elif test "$ARCH" = "s390x" ; then
 interp_prefix1=`echo "$interp_prefix" | sed "s/%M/$target_cpu/g"`    cflags="-I\$(SRC_PATH)/tcg/s390 $cflags"
 echo "#define CONFIG_QEMU_PREFIX \"$interp_prefix1\"" >> $config_h  
   
 if test "$target_cpu" = "i386" ; then  
   echo "TARGET_ARCH=i386" >> $config_mak  
   echo "#define TARGET_ARCH \"i386\"" >> $config_h  
   echo "#define TARGET_I386 1" >> $config_h  
   if test $kqemu = "yes" -a "$target_softmmu" = "yes" -a $cpu = "i386" ; then  
     echo "#define USE_KQEMU 1" >> $config_h  
   fi  
 elif test "$target_cpu" = "arm" -o "$target_cpu" = "armeb" ; then  
   echo "TARGET_ARCH=arm" >> $config_mak  
   echo "#define TARGET_ARCH \"arm\"" >> $config_h  
   echo "#define TARGET_ARM 1" >> $config_h  
 elif test "$target_cpu" = "sparc" ; then  
   echo "TARGET_ARCH=sparc" >> $config_mak  
   echo "#define TARGET_ARCH \"sparc\"" >> $config_h  
   echo "#define TARGET_SPARC 1" >> $config_h  
 elif test "$target_cpu" = "sparc64" ; then  
   echo "TARGET_ARCH=sparc64" >> $config_mak  
   echo "#define TARGET_ARCH \"sparc64\"" >> $config_h  
   echo "#define TARGET_SPARC 1" >> $config_h  
   echo "#define TARGET_SPARC64 1" >> $config_h  
 elif test "$target_cpu" = "ppc" ; then  
   echo "TARGET_ARCH=ppc" >> $config_mak  
   echo "#define TARGET_ARCH \"ppc\"" >> $config_h  
   echo "#define TARGET_PPC 1" >> $config_h  
 elif test "$target_cpu" = "ppc64" ; then  
   echo "TARGET_ARCH=ppc64" >> $config_mak  
   echo "#define TARGET_ARCH \"ppc64\"" >> $config_h  
   echo "#define TARGET_PPC 1" >> $config_h  
   echo "#define TARGET_PPC64 1" >> $config_h  
 elif test "$target_cpu" = "x86_64" ; then  
   echo "TARGET_ARCH=x86_64" >> $config_mak  
   echo "#define TARGET_ARCH \"x86_64\"" >> $config_h  
   echo "#define TARGET_I386 1" >> $config_h  
   echo "#define TARGET_X86_64 1" >> $config_h  
   if test $kqemu = "yes" -a "$target_softmmu" = "yes" -a $cpu = "x86_64"  ; then  
     echo "#define USE_KQEMU 1" >> $config_h  
   fi  
 elif test "$target_cpu" = "mips" -o "$target_cpu" = "mipsel" ; then  
   echo "TARGET_ARCH=mips" >> $config_mak  
   echo "#define TARGET_ARCH \"mips\"" >> $config_h  
   echo "#define TARGET_MIPS 1" >> $config_h  
 else  else
   echo "Unsupported target CPU"    cflags="-I\$(SRC_PATH)/tcg/\$(ARCH) $cflags"
   exit 1  
 fi  
 if test "$target_bigendian" = "yes" ; then  
   echo "TARGET_WORDS_BIGENDIAN=yes" >> $config_mak  
   echo "#define TARGET_WORDS_BIGENDIAN 1" >> $config_h  
 fi  fi
   cflags="-I\$(SRC_PATH)/tcg $cflags"
   cflags="-I\$(SRC_PATH)/fpu $cflags"
   
   for i in $ARCH $TARGET_BASE_ARCH ; do
     case "$i" in
     alpha)
       echo "CONFIG_ALPHA_DIS=y"  >> $config_target_mak
     ;;
     arm)
       echo "CONFIG_ARM_DIS=y"  >> $config_target_mak
     ;;
     cris)
       echo "CONFIG_CRIS_DIS=y"  >> $config_target_mak
     ;;
     hppa)
       echo "CONFIG_HPPA_DIS=y"  >> $config_target_mak
     ;;
     i386|x86_64)
       echo "CONFIG_I386_DIS=y"  >> $config_target_mak
     ;;
     m68k)
       echo "CONFIG_M68K_DIS=y"  >> $config_target_mak
     ;;
     microblaze)
       echo "CONFIG_MICROBLAZE_DIS=y"  >> $config_target_mak
     ;;
     mips*)
       echo "CONFIG_MIPS_DIS=y"  >> $config_target_mak
     ;;
     ppc*)
       echo "CONFIG_PPC_DIS=y"  >> $config_target_mak
     ;;
     s390*)
       echo "CONFIG_S390_DIS=y"  >> $config_target_mak
     ;;
     sh4)
       echo "CONFIG_SH4_DIS=y"  >> $config_target_mak
     ;;
     sparc*)
       echo "CONFIG_SPARC_DIS=y"  >> $config_target_mak
     ;;
     esac
   done
   
   case "$ARCH" in
   alpha)
     # Ensure there's only a single GP
     cflags="-msmall-data $cflags"
   ;;
   ia64)
     cflags="-mno-sdata $cflags"
   ;;
   esac
   
 if test "$target_softmmu" = "yes" ; then  if test "$target_softmmu" = "yes" ; then
   echo "CONFIG_SOFTMMU=yes" >> $config_mak    case "$TARGET_BASE_ARCH" in
   echo "#define CONFIG_SOFTMMU 1" >> $config_h    arm)
       cflags="-DHAS_AUDIO $cflags"
     ;;
     i386|mips|ppc)
       cflags="-DHAS_AUDIO -DHAS_AUDIO_CHOICE $cflags"
     ;;
     esac
 fi  fi
 if test "$target_user_only" = "yes" ; then  
   echo "CONFIG_USER_ONLY=yes" >> $config_mak  if test "$target_user_only" = "yes" -a "$static" = "no" -a \
   echo "#define CONFIG_USER_ONLY 1" >> $config_h          "$user_pie" = "yes" ; then
     cflags="-fpie $cflags"
     ldflags="-pie $ldflags"
 fi  fi
   
 if test "$target_cpu" = "arm" -o "$target_cpu" = "armeb" ; then  if test "$target_softmmu" = "yes" -a \( \
   echo "CONFIG_SOFTFLOAT=yes" >> $config_mak          "$TARGET_ARCH" = "microblaze" -o \
   echo "#define CONFIG_SOFTFLOAT 1" >> $config_h          "$TARGET_ARCH" = "cris" \) ; then
     echo "CONFIG_NEED_MMU=y" >> $config_target_mak
 fi  fi
 # sdl defines  
   
 if test "$target_user_only" = "no"; then  if test "$gprof" = "yes" ; then
     if test "$target_softmmu" = "no" -o "$static" = "yes"; then    echo "TARGET_GPROF=yes" >> $config_target_mak
         sdl1=$sdl_static    if test "$target_linux_user" = "yes" ; then
     else      cflags="-p $cflags"
         sdl1=$sdl      ldflags="-p $ldflags"
     fi    fi
     if test "$sdl1" = "yes" ; then    if test "$target_softmmu" = "yes" ; then
         echo "#define CONFIG_SDL 1" >> $config_h      ldflags="-p $ldflags"
         echo "CONFIG_SDL=yes" >> $config_mak      echo "GPROF_CFLAGS=-p" >> $config_target_mak
         if test "$target_softmmu" = "no" -o "$static" = "yes"; then    fi
             echo "SDL_LIBS=$sdl_static_libs" >> $config_mak  
         else  
             echo "SDL_LIBS=`$sdl_config --libs`" >> $config_mak  
         fi  
         echo -n "SDL_CFLAGS=`$sdl_config --cflags`" >> $config_mak  
         if [ "${aa}" = "yes" ] ; then  
             echo -n " `aalib-config --cflags`" >> $config_mak ;  
         fi  
         echo "" >> $config_mak  
     fi  
 fi  fi
   
 if test "$cocoa" = "yes" ; then  linker_script="-Wl,-T../config-host.ld -Wl,-T,\$(SRC_PATH)/\$(ARCH).ld"
     echo "#define CONFIG_COCOA 1" >> $config_h  if test "$target_linux_user" = "yes" -o "$target_bsd_user" = "yes" ; then
     echo "CONFIG_COCOA=yes" >> $config_mak    case "$ARCH" in
     sparc)
       # -static is used to avoid g1/g3 usage by the dynamic linker
       ldflags="$linker_script -static $ldflags"
       ;;
     ia64)
       ldflags="-Wl,-G0 $linker_script -static $ldflags"
       ;;
     i386|x86_64|ppc|ppc64|s390|sparc64|alpha|arm|m68k|mips|mips64)
       ldflags="$linker_script $ldflags"
       ;;
     esac
   fi
   if test "$target_softmmu" = "yes" ; then
     case "$ARCH" in
     ia64)
       ldflags="-Wl,-G0 $linker_script -static $ldflags"
       ;;
     esac
 fi  fi
   
   echo "LDFLAGS+=$ldflags" >> $config_target_mak
   echo "QEMU_CFLAGS+=$cflags" >> $config_target_mak
   
 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 net pc-bios/optionrom"
       DIRS="$DIRS roms/seabios roms/vgabios"
     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 pc-bios/keymaps pc-bios/video.x"
       FILES="$FILES roms/seabios/Makefile roms/vgabios/Makefile"
       for bios_file in $source_path/pc-bios/*.bin $source_path/pc-bios/*.dtb $source_path/pc-bios/openbios-*; do
           FILES="$FILES pc-bios/`basename $bios_file`"
       done
     for dir in $DIRS ; do      for dir in $DIRS ; do
             mkdir -p $dir              mkdir -p $dir
     done      done
       # remove the link and recreate it, as not all "ln -sf" overwrite the link
     for f in $FILES ; do      for f in $FILES ; do
         ln -sf $source_path/$f $f          rm -f $f
           ln -s $source_path/$f $f
     done      done
 fi  fi
   
 rm -f $TMPO $TMPC $TMPE $TMPS  # temporary config to build submodules
   for rom in seabios vgabios ; do
       config_mak=roms/$rom/config.mak
       echo "# Automatically generated by configure - do not modify" >> $config_mak
       echo "SRC_PATH=$source_path/roms/$rom" >> $config_mak
       echo "CC=$cc" >> $config_mak
       echo "BCC=bcc" >> $config_mak
       echo "CPP=${cross_prefix}cpp" >> $config_mak
       echo "OBJCOPY=objcopy" >> $config_mak
       echo "IASL=iasl" >> $config_mak
       echo "HOST_CC=$host_cc" >> $config_mak
       echo "LD=$ld" >> $config_mak
   done
   
   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 "QEMU_CFLAGS+=-DTARGET_PHYS_ADDR_BITS=$hwlib" >> $d/config.mak
   done
   
   d=libuser
   mkdir -p $d
   rm -f $d/Makefile
   ln -s $source_path/Makefile.user $d/Makefile

Removed from v.1.1.1.2  
changed lines
  Added in v.1.1.1.11


unix.superglobalmegacorp.com