configure.ac

   1 # -*- autoconf -*-
   2
   3 # Process this file with autoconf to produce a configure script.
   4
   5 # Copyright (C) 2002,2003,2004,2005,2006,2007,2008,2009,2010  Free Software Foundation, Inc.
   6 #
   7 # This configure.ac is free software; the author
   8 # gives unlimited permission to copy and/or distribute it,
   9 # with or without modifications, as long as this notice is preserved.
  10 #
  11 # This program is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY, to the extent permitted by law; without
  13 # even the implied warranty of MERCHANTABILITY or FITNESS FOR A
  14 # PARTICULAR PURPOSE.
  15
  16 dnl This configure script is complicated, because GRUB needs to deal
  17 dnl with three potentially different types:
  18 dnl
  19 dnl   build  -- the environment for building GRUB
  20 dnl   host   -- the environment for running utilities
  21 dnl   target -- the environment for running GRUB
  22 dnl
  23 dnl In addition, GRUB needs to deal with a platform specification
  24 dnl which specifies the system running GRUB, such as firmware.
  25 dnl This is necessary because the target type in autoconf does not
  26 dnl describe such a system very well.
  27 dnl
  28 dnl The current strategy is to use variables with no prefix (such as
  29 dnl CC, CFLAGS, etc.) for the host type, variables with prefix "BUILD_"
  30 dnl (such as BUILD_CC, BUILD_CFLAGS, etc.) for the build type and variables
  31 dnl with the prefix "TARGET_" (such as TARGET_CC, TARGET_CFLAGS, etc.) are
  32 dnl used for the target type. See INSTALL for full list of variables.
  33
  34 AC_INIT([GRUB],[2.02~beta3],[bug-grub@gnu.org])
  35
  36 AC_CONFIG_AUX_DIR([build-aux])
  37
  38 # We don't want -g -O2 by default in CFLAGS
  39 : ${CFLAGS=""}
  40
  41 # Checks for build, host and target systems.
  42 AC_CANONICAL_BUILD
  43 AC_CANONICAL_HOST
  44 save_program_prefix="${program_prefix}"
  45 AC_CANONICAL_TARGET
  46 program_prefix="${save_program_prefix}"
  47
  48 AM_INIT_AUTOMAKE([1.10.1])
  49 AC_PREREQ(2.60)
  50 AC_CONFIG_SRCDIR([include/grub/dl.h])
  51 AC_CONFIG_HEADER([config-util.h])
  52
  53 # Program name transformations
  54 AC_ARG_PROGRAM
  55 grub_TRANSFORM([grub-bios-setup])
  56 grub_TRANSFORM([grub-editenv])
  57 grub_TRANSFORM([grub-install])
  58 grub_TRANSFORM([grub-mkconfig])
  59 grub_TRANSFORM([grub-mkfont])
  60 grub_TRANSFORM([grub-mkimage])
  61 grub_TRANSFORM([grub-glue-efi])
  62 grub_TRANSFORM([grub-mklayout])
  63 grub_TRANSFORM([grub-mkpasswd-pbkdf2])
  64 grub_TRANSFORM([grub-mkrelpath])
  65 grub_TRANSFORM([grub-mkrescue])
  66 grub_TRANSFORM([grub-probe])
  67 grub_TRANSFORM([grub-reboot])
  68 grub_TRANSFORM([grub-script-check])
  69 grub_TRANSFORM([grub-set-default])
  70 grub_TRANSFORM([grub-sparc64-setup])
  71 grub_TRANSFORM([grub-render-label])
  72 grub_TRANSFORM([grub-file])
  73
  74 # Optimization flag.  Allow user to override.
  75 if test "x$TARGET_CFLAGS" = x; then
  76   TARGET_CFLAGS="$TARGET_CFLAGS -Os"
  77 fi
  78
  79 # Default HOST_CPPFLAGS
  80 HOST_CPPFLAGS="$HOST_CPPFLAGS -Wall -W"
  81 HOST_CPPFLAGS="$HOST_CPPFLAGS -DGRUB_UTIL=1"
  82
  83 TARGET_CPPFLAGS="$TARGET_CPPFLAGS -Wall -W"
  84
  85 case "$target_cpu" in
  86   i[[3456]]86)  target_cpu=i386 ;;
  87   amd64)        target_cpu=x86_64 ;;
  88   sparc)        target_cpu=sparc64 ;;
  89   mipsel|mips64el)
  90                 target_cpu=mipsel
  91                 machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_CPU_MIPSEL=1"
  92                 ;;
  93   mips|mips64)
  94                 target_cpu=mips
  95                 machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_CPU_MIPS=1"
  96                 ;;
  97   arm*)
  98                 target_cpu=arm
  99                 ;;
 100   aarch64*)
 101                 target_cpu=arm64
 102                 ;;
 103 esac
 104
 105 # Specify the platform (such as firmware).
 106 AC_ARG_WITH([platform],
 107             AS_HELP_STRING([--with-platform=PLATFORM],
 108                            [select the host platform [[guessed]]]))
 109
 110 # Guess the platform if not specified.
 111 if test "x$with_platform" = x; then
 112   case "$target_cpu"-"$target_vendor" in
 113     i386-apple) platform=efi ;;
 114     i386-*) platform=pc ;;
 115     x86_64-apple) platform=efi ;;
 116     x86_64-*) platform=pc ;;
 117     powerpc-*) platform=ieee1275 ;;
 118     powerpc64-*) platform=ieee1275 ;;
 119     powerpc64le-*) platform=ieee1275 ;;
 120     sparc64-*) platform=ieee1275 ;;
 121     mipsel-*) platform=loongson ;;
 122     mips-*) platform=arc ;;
 123     ia64-*) platform=efi ;;
 124     arm-*) platform=uboot ;;
 125     arm64-*) platform=efi ;;
 126     *)
 127       AC_MSG_WARN([unsupported CPU: "$target_cpu" - only building utilities])
 128       platform=none
 129       ;;
 130   esac
 131 else
 132   platform="$with_platform"
 133 fi
 134
 135 case "$target_cpu"-"$platform" in
 136   x86_64-efi) ;;
 137   x86_64-emu) ;;
 138   x86_64-xen) ;;
 139   x86_64-none) ;;
 140   x86_64-*) target_cpu=i386 ;;
 141   powerpc64-ieee1275) target_cpu=powerpc ;;
 142   powerpc64le-ieee1275) target_cpu=powerpc ;;
 143 esac
 144
 145 # Check if the platform is supported, make final adjustments.
 146 case "$target_cpu"-"$platform" in
 147   i386-efi) ;;
 148   x86_64-efi) ;;
 149   i386-xen) ;;
 150   x86_64-xen) ;;
 151   i386-pc) ;;
 152   i386-multiboot) ;;
 153   i386-coreboot) ;;
 154   i386-linuxbios) platform=coreboot ;;
 155   i386-ieee1275) ;;
 156   i386-qemu) ;;
 157   powerpc-ieee1275) ;;
 158   sparc64-ieee1275) ;;
 159   ia64-efi) ;;
 160   mips-qemu_mips) ;;
 161   mips-qemu-mips) platform=qemu_mips;;
 162   mips-arc) ;;
 163   mipsel-arc) ;;
 164   mipsel-qemu_mips) ;;
 165   mipsel-qemu-mips) platform=qemu_mips;;
 166   mipsel-yeeloong) platform=loongson ;;
 167   mipsel-fuloong) platform=loongson ;;
 168   mipsel-loongson) ;;
 169   arm-uboot) ;;
 170   arm-efi) ;;
 171   arm64-efi) ;;
 172   *-emu) ;;
 173   *-none) ;;
 174   *) AC_MSG_ERROR([platform "$platform" is not supported for target CPU "$target_cpu"]) ;;
 175 esac
 176
 177 if test x$platform != xemu ; then
 178    case "$target_cpu" in
 179         i386 | powerpc) target_m32=1 ;;
 180         x86_64 | sparc64) target_m64=1 ;;
 181    esac
 182 fi
 183
 184 if test x"$target_cpu-$platform" = xsparc64-emu ; then
 185    target_m64=1
 186 fi
 187
 188 case "$target_os" in
 189   windows* | mingw32*) target_os=cygwin ;;
 190 esac
 191
 192 # This normalizes the names, and creates a new variable ("host_kernel")
 193 # while at it, since the mapping is not always 1:1 (e.g. different OSes
 194 # using the same kernel type).
 195 case "$host_os" in
 196   gnu*)                         host_kernel=hurd ;;
 197   linux*)                       host_kernel=linux ;;
 198   freebsd* | kfreebsd*-gnu)     host_kernel=kfreebsd ;;
 199   netbsd*)                      host_kernel=netbsd ;;
 200   solaris*)                     host_kernel=illumos ;;
 201   darwin*)                      host_kernel=xnu ;;
 202   cygwin | windows* | mingw32*) host_kernel=windows ;;
 203 esac
 204
 205 case "$host_os" in
 206   cygwin | windows* | mingw32*) have_exec=n ;;
 207   aros*) have_exec=n ;;
 208   *) have_exec=y;;
 209 esac
 210
 211 case "$platform" in
 212   coreboot)     machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_COREBOOT=1" ;;
 213   multiboot)    machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_MULTIBOOT=1" ;;
 214   efi)          machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_EFI=1" ;;
 215   xen)          machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_XEN=1" ;;
 216   ieee1275)     machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_IEEE1275=1" ;;
 217   uboot)        machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_UBOOT=1" ;;
 218   qemu)         machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_QEMU=1" ;;
 219   pc)           machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_PCBIOS=1" ;;
 220   emu)          machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_EMU=1" ;;
 221   loongson)     machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_MIPS_LOONGSON=1" ;;
 222   qemu_mips)    machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_MIPS_QEMU_MIPS=1" ;;
 223   arc)  machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_ARC=1" ;;
 224 esac
 225 if test x${target_cpu} = xmipsel ; then
 226    machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE=`echo mips_$platform | sed y,abcdefghijklmnopqrstuvwxyz,ABCDEFGHIJKLMNOPQRSTUVWXYZ,`"
 227 else
 228    machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE=`echo ${target_cpu}_$platform | sed y,abcdefghijklmnopqrstuvwxyz,ABCDEFGHIJKLMNOPQRSTUVWXYZ,`"
 229 fi
 230
 231 case "${target_cpu}-$platform" in
 232      mips-arc)
 233         TARGET_LINK_ADDR=0x88200000
 234         TARGET_DECOMPRESSOR_LINK_ADDR=0x88100000
 235         ;;
 236      mipsel-arc)
 237         TARGET_LINK_ADDR=0x80700000
 238         TARGET_DECOMPRESSOR_LINK_ADDR=0x80600000
 239         ;;
 240      mips*-qemu_mips | mips*-loongson)
 241         TARGET_DECOMPRESSOR_LINK_ADDR=0x80100000
 242         ;;
 243 esac
 244
 245 AC_SUBST(TARGET_LINK_ADDR)
 246 AC_SUBST(TARGET_DECOMPRESSOR_LINK_ADDR)
 247
 248 TARGET_CPPFLAGS="$TARGET_CPPFLAGS $machine_CPPFLAGS"
 249
 250 AC_SUBST(host_cpu)
 251 AC_SUBST(host_os)
 252 AC_SUBST(host_kernel)
 253
 254 AC_SUBST(target_cpu)
 255 AC_SUBST(platform)
 256
 257 # Define default variables
 258
 259 have_with_bootdir=n
 260 AC_ARG_WITH([bootdir],
 261             AS_HELP_STRING([--with-bootdir=DIR],
 262                            [set the name of /boot directory [[guessed]]]),
 263                            [have_with_bootdir=y],
 264                            [have_with_bootdir=n])
 265 if test x$have_with_bootdir = xy; then
 266    bootdirname="$with_bootdir"
 267 else
 268    case "$host_os" in
 269      netbsd* | openbsd*)
 270         # Because /boot is used for the boot block in NetBSD and OpenBSD,
 271            bootdirname=''      ;;
 272      *)    bootdirname='boot'  ;;
 273    esac
 274 fi
 275
 276 AC_SUBST(bootdirname)
 277 AC_DEFINE_UNQUOTED(GRUB_BOOT_DIR_NAME, "$bootdirname",
 278     [Default boot directory name]")
 279
 280 AC_ARG_WITH([grubdir],
 281             AS_HELP_STRING([--with-grubdir=DIR],
 282                            [set the name of grub directory [[guessed]]]),
 283                            [grubdirname="$with_grubdir"],
 284                            [grubdirname="$PACKAGE"])
 285
 286 AC_SUBST(grubdirname)
 287 AC_DEFINE_UNQUOTED(GRUB_DIR_NAME, "$grubdirname",
 288     [Default grub directory name])
 289
 290 #
 291 # Checks for build programs.
 292 #
 293
 294 # Although cmp is listed in the GNU Coding Standards as a command which
 295 # can used directly, OpenBSD lacks cmp in the default installation.
 296 AC_CHECK_PROGS([CMP], [cmp])
 297 if test "x$CMP" = x; then
 298   AC_MSG_ERROR([cmp is not found])
 299 fi
 300
 301 AC_CHECK_PROGS([YACC], [bison])
 302 if test "x$YACC" = x; then
 303   AC_MSG_ERROR([bison is not found])
 304 fi
 305
 306 AC_PROG_RANLIB
 307 AC_PROG_INSTALL
 308 AC_PROG_AWK
 309 AC_PROG_LEX
 310 AC_PROG_YACC
 311 AC_PROG_MAKE_SET
 312 AC_PROG_MKDIR_P
 313 AC_PROG_LN_S
 314
 315 if test "x$LEX" = "x:"; then
 316   AC_MSG_ERROR([flex is not found])
 317 else
 318   version=`$LEX --version | $AWK '{ split($2,x,"."); print x[[1]]*10000+x[[2]]*100+x[[3]]; }'`
 319   if test -n "$version" -a "$version" -ge 20535; then
 320     :
 321   else
 322     AC_MSG_ERROR([flex is too old. GRUB requires 2.5.35 or above])
 323   fi
 324 fi
 325
 326 # These are not a "must".
 327 AC_PATH_PROGS(MAKEINFO, makeinfo true)
 328
 329 #
 330 # Checks for host programs.
 331 #
 332
 333 AC_PROG_CC
 334 gl_EARLY
 335 AC_PROG_CXX
 336 AM_PROG_CC_C_O
 337 AM_PROG_AS
 338
 339 # Must be GCC.
 340 test "x$GCC" = xyes || AC_MSG_ERROR([GCC is required])
 341
 342 AC_CHECK_PROG(HAVE_CXX, $CXX, yes, no)
 343
 344 AC_GNU_SOURCE
 345 AM_GNU_GETTEXT([external])
 346 AC_SYS_LARGEFILE
 347
 348 # Identify characteristics of the host architecture.
 349 unset ac_cv_c_bigendian
 350
 351 if test x"$target_cpu-$platform" = xsparc64-emu ; then
 352   CFLAGS="$CFLAGS -m64"
 353   HOST_CFLAGS="$HOST_CFLAGS -m64"
 354 fi
 355
 356 CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=64"
 357 HOST_CPPFLAGS="$HOST_CPPFLAGS -D_FILE_OFFSET_BITS=64"
 358
 359 AC_C_BIGENDIAN
 360 AC_CHECK_SIZEOF(void *)
 361 AC_CHECK_SIZEOF(long)
 362
 363 case "$host_os" in
 364   cygwin | windows* | mingw32*)
 365      HOST_CPPFLAGS="$HOST_CPPFLAGS -DUNICODE=1 -D_WIN32_WINNT=0x0500"
 366      CPPFLAGS="$CPPFLAGS -DUNICODE=1 -D_WIN32_WINNT=0x0500"
 367      AC_CHECK_SIZEOF(TCHAR,,[#include <windows.h>])
 368    ;;
 369 esac
 370
 371 case "$host_os" in
 372   cygwin | windows* | mingw32* | aros*)
 373      ;;
 374   *)
 375      AC_CHECK_SIZEOF(off_t)
 376      test x"$ac_cv_sizeof_off_t" = x8 || AC_MSG_ERROR([Large file support is required]);;
 377 esac
 378
 379 if test x$USE_NLS = xno; then
 380   HOST_CFLAGS="$HOST_CFLAGS -fno-builtin-gettext"
 381 fi
 382
 383 if test "x$cross_compiling" = xyes; then
 384   AC_MSG_WARN([cannot generate manual pages while cross compiling])
 385 else
 386   AC_PATH_PROG(HELP2MAN, help2man)
 387 fi
 388
 389 # Check for functions and headers.
 390 AC_CHECK_FUNCS(posix_memalign memalign getextmntent)
 391 AC_CHECK_HEADERS(sys/param.h sys/mount.h sys/mnttab.h sys/mkdev.h limits.h)
 392
 393 AC_CHECK_MEMBERS([struct statfs.f_fstypename],,,[$ac_includes_default
 394 #include <sys/param.h>
 395 #include <sys/mount.h>])
 396
 397 AC_CHECK_MEMBERS([struct statfs.f_mntfromname],,,[$ac_includes_default
 398 #include <sys/param.h>
 399 #include <sys/mount.h>])
 400
 401 # For opendisk() and getrawpartition() on NetBSD.
 402 # Used in util/deviceiter.c and in util/hostdisk.c.
 403 AC_CHECK_HEADER([util.h], [
 404   AC_CHECK_LIB([util], [opendisk], [
 405     LIBUTIL="-lutil"
 406     AC_DEFINE(HAVE_OPENDISK, 1, [Define if opendisk() in -lutil can be used])
 407   ])
 408   AC_CHECK_LIB([util], [getrawpartition], [
 409     LIBUTIL="-lutil"
 410     AC_DEFINE(HAVE_GETRAWPARTITION, 1, [Define if getrawpartition() in -lutil can be used])
 411   ])
 412 ])
 413 AC_SUBST([LIBUTIL])
 414
 415 AC_CACHE_CHECK([whether -Wtrampolines work], [grub_cv_host_cc_wtrampolines], [
 416   SAVED_CFLAGS="$CFLAGS"
 417   CFLAGS="$HOST_CFLAGS -Wtrampolines -Werror"
 418   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <stdarg.h>
 419 int va_arg_func (int fixed, va_list args);]], [[]])],
 420       [grub_cv_host_cc_wtrampolines=yes],
 421       [grub_cv_host_cc_wtrampolines=no])
 422   CFLAGS="$SAVED_CFLAGS"
 423 ])
 424
 425 if test x"$grub_host_cv_cc_wtrampolines" = xyes ; then
 426   HOST_CFLAGS="$HOST_CFLAGS -Wtrampolines"
 427 fi
 428
 429 #
 430 # Check for host and build compilers.
 431 #
 432 HOST_CC=$CC
 433 AC_CHECK_PROGS(BUILD_CC, [gcc egcs cc])
 434 test -z "$BUILD_CC" && AC_MSG_ERROR([none of gcc, egcs and cc is found. set BUILD_CC manually.])
 435 BUILD_CPP="$BUILD_CC -E"
 436
 437 case "$build_os" in
 438   haiku*)                               BUILD_LIBM= ;;
 439   *)                                    BUILD_LIBM=-lm ;;
 440 esac
 441
 442 dnl FIXME proper test seems to require too deep dive into Autoconf internals.
 443 dnl For now just list known platforms that we support.
 444
 445 case "$build_os" in
 446   cygwin*|mingw32*|mingw64*)            BUILD_EXEEXT=.exe ;;
 447   *)                                    BUILD_EXEEXT= ;;
 448 esac
 449 AC_SUBST(BUILD_EXEEXT)
 450
 451 # For gnulib.
 452 gl_INIT
 453
 454 WARN_FLAGS="-Wall -W -Wshadow -Wpointer-arith -Wundef -Wchar-subscripts -Wcomment -Wdeprecated-declarations -Wdisabled-optimization -Wdiv-by-zero -Wfloat-equal -Wformat-extra-args -Wformat-security -Wformat-y2k -Wimplicit -Wimplicit-function-declaration -Wimplicit-int -Wmain -Wmissing-braces -Wmissing-format-attribute -Wmultichar -Wparentheses -Wreturn-type -Wsequence-point -Wshadow -Wsign-compare -Wswitch -Wtrigraphs -Wunknown-pragmas -Wunused -Wunused-function -Wunused-label -Wunused-parameter -Wunused-value  -Wunused-variable -Wwrite-strings -Wnested-externs -Wstrict-prototypes"
 455 EXTRA_WARN_FLAGS="-Wextra -Wattributes -Wendif-labels -Winit-self -Wint-to-pointer-cast -Winvalid-pch -Wmissing-field-initializers -Wnonnull -Woverflow -Wvla -Wpointer-to-int-cast -Wstrict-aliasing -Wvariadic-macros -Wvolatile-register-var -Wpointer-sign -Wmissing-include-dirs -Wmissing-prototypes -Wmissing-declarations -Wformat=2"
 456
 457 HOST_CFLAGS="$HOST_CFLAGS $WARN_FLAGS -Wcast-align"
 458
 459 AC_CACHE_CHECK([which extra warnings work], [grub_cv_cc_w_extra_flags], [
 460   SAVED_CFLAGS="$CFLAGS"
 461   grub_cv_cc_w_extra_flags=
 462   for x in $EXTRA_WARN_FLAGS; do
 463       CFLAGS="$HOST_CFLAGS $x -Werror"
 464       AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[]])], [flag=1], [flag=0])
 465       if test x$flag = x1 ; then
 466          grub_cv_cc_w_extra_flags="$grub_cv_cc_w_extra_flags $x"
 467       fi
 468   done
 469   CFLAGS="$SAVED_CFLAGS"
 470 ])
 471
 472 HOST_CFLAGS="$HOST_CFLAGS $grub_cv_cc_w_extra_flags"
 473
 474 #
 475 # Check for target programs.
 476 #
 477
 478 # Find tools for the target.
 479 if test "x$target_alias" != x && test "x$host_alias" != "x$target_alias"; then
 480   tmp_ac_tool_prefix="$ac_tool_prefix"
 481   ac_tool_prefix=$target_alias-
 482
 483   AC_CHECK_TOOLS(TARGET_CC, [gcc egcs cc],
 484                  [AC_MSG_ERROR([none of gcc, egcs and cc is found. set TARGET_CC manually.])])
 485   AC_CHECK_TOOL(TARGET_OBJCOPY, objcopy)
 486   AC_CHECK_TOOL(TARGET_STRIP, strip)
 487   AC_CHECK_TOOL(TARGET_NM, nm)
 488   AC_CHECK_TOOL(TARGET_RANLIB, ranlib)
 489
 490   ac_tool_prefix="$tmp_ac_tool_prefix"
 491 else
 492   if test "x$TARGET_CC" = x; then
 493     TARGET_CC=$CC
 494   fi
 495   AC_CHECK_TOOL(TARGET_OBJCOPY, objcopy)
 496   AC_CHECK_TOOL(TARGET_STRIP, strip)
 497   AC_CHECK_TOOL(TARGET_NM, nm)
 498   AC_CHECK_TOOL(TARGET_RANLIB, ranlib)
 499 fi
 500
 501 AC_SUBST(HOST_CC)
 502 AC_SUBST(BUILD_CC)
 503 AC_SUBST(BUILD_CFLAGS)
 504 AC_SUBST(BUILD_CPPFLAGS)
 505 AC_SUBST(BUILD_LDFLAGS)
 506 AC_SUBST(TARGET_CC)
 507 AC_SUBST(TARGET_NM)
 508 AC_SUBST(TARGET_RANLIB)
 509 AC_SUBST(TARGET_STRIP)
 510 AC_SUBST(TARGET_OBJCOPY)
 511
 512 # Test the C compiler for the target environment.
 513 tmp_CC="$CC"
 514 tmp_CFLAGS="$CFLAGS"
 515 tmp_LDFLAGS="$LDFLAGS"
 516 tmp_CPPFLAGS="$CPPFLAGS"
 517 tmp_LIBS="$LIBS"
 518 CC="$TARGET_CC"
 519 CFLAGS="$TARGET_CFLAGS"
 520 CPPFLAGS="$TARGET_CPPFLAGS"
 521 LDFLAGS="$TARGET_LDFLAGS"
 522 LIBS=""
 523
 524 # debug flags.
 525 TARGET_CFLAGS="$TARGET_CFLAGS $WARN_FLAGS -g -Wredundant-decls -Wmissing-prototypes -Wmissing-declarations"
 526 TARGET_CCASFLAGS="$TARGET_CCASFLAGS -g"
 527
 528 if test "x$target_cpu" != xi386 && test "x$target_cpu" != xx86_64; then
 529 TARGET_CFLAGS="$TARGET_CFLAGS -Wcast-align"
 530 fi
 531
 532 TARGET_CC_VERSION="$(LC_ALL=C $TARGET_CC --version | head -n1)"
 533
 534 AC_CACHE_CHECK([which extra warnings work], [grub_cv_target_cc_w_extra_flags], [
 535   LDFLAGS="$TARGET_LDFLAGS -nostdlib -static"
 536
 537   grub_cv_target_cc_w_extra_flags=
 538   for x in $EXTRA_WARN_FLAGS; do
 539       CFLAGS="$TARGET_CFLAGS $x -Werror"
 540       AC_LINK_IFELSE([AC_LANG_PROGRAM([[
 541 asm (".globl start; start:");
 542 void __main (void);
 543 void __main (void) {}
 544 int main (void);
 545 ]], [[]])], [flag=1], [flag=0])
 546       if test x$flag = x1 ; then
 547          grub_cv_target_cc_w_extra_flags="$grub_cv_target_cc_w_extra_flags $x"
 548       fi
 549   done
 550 ])
 551
 552 TARGET_CFLAGS="$TARGET_CFLAGS $grub_cv_target_cc_w_extra_flags"
 553
 554 AC_CACHE_CHECK([if compiling with clang], [grub_cv_cc_target_clang],
 555 [
 556 CFLAGS="$TARGET_CFLAGS"
 557 AC_COMPILE_IFELSE(
 558 [AC_LANG_PROGRAM([], [[
 559 #ifdef __clang__
 560 #error "is clang"
 561 #endif
 562 ]])],
 563 [grub_cv_cc_target_clang=no], [grub_cv_cc_target_clang=yes])])
 564
 565 if test x$target_cpu = xpowerpc -o x$target_cpu = xmips; then
 566   AC_CACHE_CHECK([for options to get big-endian compilation], grub_cv_target_cc_big_endian, [
 567     grub_cv_target_cc_big_endian=no
 568     for cand in "-target $target_cpu -Wl,-EB" "-target $target_cpu" \
 569                 "-target $target_cpu-linux-gnu -Wl,-EB" "-target $target_cpu-linux-gnu" \
 570                 "-EB" "-mbig-endian"; do
 571       if test x"$grub_cv_target_cc_big_endian" != xno ; then
 572         break
 573       fi
 574       CFLAGS="$TARGET_CFLAGS $cand -Werror"
 575       AC_LINK_IFELSE([AC_LANG_PROGRAM([[
 576 #if defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && (__ORDER_BIG_ENDIAN__ != __BYTE_ORDER__)
 577 #error still little endian
 578 #endif
 579 asm (".globl start; start:");
 580 asm (".globl _start; _start:");
 581 asm (".globl __start; __start:");
 582 void __main (void);
 583 void __main (void) {}
 584 int main (void);
 585 ]], [[]])],
 586                         [grub_cv_target_cc_big_endian="$cand"], [])
 587     done
 588   ])
 589
 590   if test x"$grub_cv_target_cc_big_endian" = xno ; then
 591     AC_MSG_ERROR([could not force big-endian])
 592   fi
 593
 594   skip_linkflags="$(echo "$grub_cv_target_cc_big_endian"|sed 's@-Wl,-EB@@')"
 595
 596   TARGET_CFLAGS="$TARGET_CFLAGS $skip_linkflags"
 597   TARGET_CPPFLAGS="$TARGET_CPPFLAGS $skip_linkflags"
 598   TARGET_CCASFLAGS="$TARGET_CCASFLAGS $skip_linkflags"
 599   TARGET_LDFLAGS="$TARGET_LDFLAGS $grub_cv_target_cc_big_endian"
 600 elif test x$target_cpu = xmipsel; then
 601   AC_CACHE_CHECK([for options to get little-endian compilation], grub_cv_target_cc_little_endian, [
 602     grub_cv_target_cc_little_endian=no
 603     for cand in "-target $target_cpu -Wl,-EL" "-target $target_cpu" \
 604                 "-target $target_cpu-linux-gnu -Wl,-EL" "-target $target_cpu-linux-gnu" \
 605                 "-EL"; do
 606       if test x"$grub_cv_target_cc_little_endian" != xno ; then
 607         break
 608       fi
 609       CFLAGS="$TARGET_CFLAGS $cand -Werror"
 610       AC_LINK_IFELSE([AC_LANG_PROGRAM([[
 611 #if defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && (__ORDER_BIG_ENDIAN__ == __BYTE_ORDER__)
 612 #error still big endian
 613 #endif
 614 asm (".globl start; start:");
 615 asm (".globl _start; _start:");
 616 asm (".globl __start; __start:");
 617 void __main (void);
 618 void __main (void) {}
 619 int main (void);
 620 ]], [[]])],
 621                         [grub_cv_target_cc_little_endian="$cand"], [])
 622     done
 623   ])
 624
 625   if test x"$grub_cv_target_cc_little_endian" = xno ; then
 626     AC_MSG_ERROR([could not force little-endian])
 627   fi
 628
 629   skip_linkflags="$(echo "$grub_cv_target_cc_little_endian"|sed 's@-Wl,-EL@@')"
 630
 631   TARGET_CFLAGS="$TARGET_CFLAGS $skip_linkflags"
 632   TARGET_CPPFLAGS="$TARGET_CPPFLAGS $skip_linkflags"
 633   TARGET_CCASFLAGS="$TARGET_CCASFLAGS $skip_linkflags"
 634   TARGET_LDFLAGS="$TARGET_LDFLAGS $grub_cv_target_cc_little_endian"
 635 fi
 636
 637 # GRUB code is N32-compliant but it's experimental and we would prefer to
 638 # avoid having too much variety when it doesn't result in any real improvement.
 639 # Moreover N64 isn't supported.
 640 if test "x$target_cpu" = xmips || test "x$target_cpu" = xmipsel ; then
 641   AC_CACHE_CHECK([for options to force MIPS o32 ABI], grub_cv_target_cc_mips_o32_abi, [
 642     grub_cv_target_cc_mips_o32_abi=no
 643     for arg in "" "-mabi=32" "-target $target_cpu -mabi=32" ; do
 644       if test x"$grub_cv_target_cc_mips_o32_abi" != xno ; then
 645         break
 646       fi
 647       CFLAGS="$TARGET_CFLAGS $arg -Werror"
 648       AC_LINK_IFELSE([AC_LANG_PROGRAM([[
 649 #if !defined(_ABIO32) || !defined(_MIPS_SIM) || (_MIPS_SIM != _ABIO32)
 650 #error not o32 ABI
 651 #endif
 652 asm (".globl start; start:");
 653 asm (".globl _start; _start:");
 654 asm (".globl __start; __start:");
 655 void __main (void);
 656 void __main (void) {}
 657 int main (void);
 658 ]], [[]])],
 659                         [grub_cv_target_cc_mips_o32_abi="$arg"], [])
 660     done
 661   ])
 662
 663   if test x"$grub_cv_target_cc_mips_o32_abi" = xno ; then
 664     AC_MSG_ERROR([could not force MIPS o32 ABI])
 665   fi
 666
 667   TARGET_CFLAGS="$TARGET_CFLAGS $grub_cv_target_cc_mips_o32_abi"
 668   TARGET_CCASFLAGS="$TARGET_CCASFLAGS $grub_cv_target_cc_mips_o32_abi"
 669 fi
 670
 671 AC_CACHE_CHECK([for options to compile assembly], [grub_cv_cc_target_asm_compile], [
 672 test_program=
 673 case "x$target_cpu-$platform" in
 674      xmips-* | xmipsel-*)
 675         test_program=mips
 676         ;;
 677      xi386-pc)
 678        test_program=i386-pc
 679         ;;
 680      xi386-* | xx86_64-*)
 681        test_program=i386
 682         ;;
 683      xpowerpc-* | xsparc64-* | xarm-*)
 684         test_program=$target_cpu
 685         ;;
 686 esac
 687 if test x"$test_program" = x ; then
 688   grub_cv_cc_target_asm_compile=
 689 else
 690   found=no
 691   for arg in "" "-no-integrated-as"; do
 692     cmdline="$TARGET_CC -c -o /dev/null $TARGET_CCASFLAGS $arg $TARGET_CPPFLAGS $srcdir/asm-tests/$test_program.S"
 693     echo "Running $cmdline" >&AS_MESSAGE_LOG_FD
 694     if $cmdline >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD; then
 695       grub_cv_cc_target_asm_compile="$arg"
 696       found=yes
 697       break
 698     fi
 699   done
 700   if test x"$found" = xno ; then
 701     AC_MSG_ERROR([could not compile assembly])
 702   fi
 703 fi
 704 ])
 705
 706 TARGET_CCASFLAGS="$TARGET_CCASFLAGS $grub_cv_cc_target_asm_compile"
 707
 708 if test "x$target_cpu" = xi386 && test "x$platform" != xemu; then
 709   TARGET_CFLAGS="$TARGET_CFLAGS -march=i386"
 710 fi
 711
 712 if test "x$target_m32" = x1; then
 713   # Force 32-bit mode.
 714   TARGET_CFLAGS="$TARGET_CFLAGS -m32"
 715   TARGET_CCASFLAGS="$TARGET_CCASFLAGS -m32"
 716   TARGET_CPPFLAGS="$TARGET_CPPFLAGS -m32"
 717   TARGET_LDFLAGS="$TARGET_LDFLAGS -m32"
 718   TARGET_MODULE_FORMAT="elf32"
 719 fi
 720
 721 if test "x$target_m64" = x1; then
 722   # Force 64-bit mode.
 723   TARGET_CFLAGS="$TARGET_CFLAGS -m64"
 724   TARGET_CCASFLAGS="$TARGET_CCASFLAGS -m64"
 725   TARGET_CPPFLAGS="$TARGET_CPPFLAGS -m64"
 726   TARGET_LDFLAGS="$TARGET_LDFLAGS -m64"
 727   TARGET_MODULE_FORMAT="elf64"
 728 fi
 729
 730 if test "x$grub_cv_cc_target_clang" = xno && test "x$target_cpu" = xi386 && test "x$platform" != xemu && test "x$platform" != xefi; then
 731    TARGET_CFLAGS="$TARGET_CFLAGS -mrtd -mregparm=3"
 732 fi
 733
 734 # on mips redirect cache flushing function to non-existant one.
 735 if test "x$target_cpu" = xmips || test "x$target_cpu" = xmipsel ; then
 736   AC_CACHE_CHECK([whether -mflush-func=grub_red_herring works], [grub_cv_cc_mflush_func], [
 737     CFLAGS="$TARGET_CFLAGS -mflush-func=grub_red_herring -Werror"
 738     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 739         [grub_cv_cc_mflush_func=yes],
 740         [grub_cv_cc_mflush_func=no])
 741   ])
 742
 743   if test "x$grub_cv_cc_mflush_func" = xyes; then
 744     TARGET_CFLAGS="$TARGET_CFLAGS -mflush-func=grub_red_herring"
 745   fi
 746 fi
 747
 748
 749 # Force no alignment to save space on i386.
 750 if test "x$target_cpu" = xi386; then
 751   AC_CACHE_CHECK([whether -falign-loops works], [grub_cv_cc_falign_loop], [
 752     CFLAGS="$TARGET_CFLAGS -falign-loops=1 -Werror"
 753     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 754         [grub_cv_cc_falign_loop=yes],
 755         [grub_cv_cc_falign_loop=no])
 756   ])
 757
 758   AC_CACHE_CHECK([whether -malign-loops works], [grub_cv_cc_malign_loop], [
 759     CFLAGS="$TARGET_CFLAGS -malign-loops=1 -Werror"
 760     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 761         [grub_cv_cc_malign_loop=yes],
 762         [grub_cv_cc_malign_loop=no])
 763   ])
 764
 765   if test "x$grub_cv_cc_falign_loop" = xyes; then
 766     TARGET_CFLAGS="$TARGET_CFLAGS -falign-jumps=1 -falign-loops=1 -falign-functions=1"
 767   elif test "x$grub_cv_cc_malign_loop" = xyes; then
 768     TARGET_CFLAGS="$TARGET_CFLAGS -malign-jumps=1 -malign-loops=1 -malign-functions=1"
 769   fi
 770 fi
 771
 772 AC_CACHE_CHECK([whether -freg-struct-return works], [grub_cv_cc_freg_struct_return], [
 773     CFLAGS="$TARGET_CFLAGS -freg-struct-return -Werror"
 774     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 775         [grub_cv_cc_freg_struct_return=yes],
 776         [grub_cv_cc_freg_struct_return=no])
 777 ])
 778
 779 if test "x$grub_cv_cc_freg_struct_return" = xyes; then
 780     TARGET_CFLAGS="$TARGET_CFLAGS -freg-struct-return"
 781 fi
 782
 783 if ( test "x$target_cpu" = xi386 || test "x$target_cpu" = xx86_64 ) && test "x$platform" != xemu; then
 784   # Some toolchains enable these features by default, but they need
 785   # registers that aren't set up properly in GRUB.
 786   TARGET_CFLAGS="$TARGET_CFLAGS -mno-mmx -mno-sse -mno-sse2 -mno-sse3 -mno-3dnow"
 787 fi
 788
 789 # GRUB doesn't use float or doubles at all. Yet some toolchains may decide
 790 # that floats are a good fit to run instead of what's written in the code.
 791 # Given that floating point unit is disabled (if present to begin with)
 792 # when GRUB is running which may result in various hard crashes.
 793 if test x"$platform" != xemu ; then
 794   AC_CACHE_CHECK([for options to get soft-float], grub_cv_target_cc_soft_float, [
 795     grub_cv_target_cc_soft_float=no
 796     if test "x$target_cpu" = xarm64; then
 797        CFLAGS="$TARGET_CFLAGS -mgeneral-regs-only -Werror"
 798        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 799                          [grub_cv_target_cc_soft_float="-mgeneral-regs-only"], [])
 800     fi
 801     if test "x$target_cpu" = xia64; then
 802        CFLAGS="$TARGET_CFLAGS -mno-inline-float-divide -mno-inline-sqrt -Werror"
 803        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 804                          [grub_cv_target_cc_soft_float="-mno-inline-float-divide -mno-inline-sqrt"], [])
 805     fi
 806     for cand in "-msoft-float -Xclang -msoft-float -Xclang -no-implicit-float" \
 807                 "-Xclang -msoft-float -Xclang -no-implicit-float" \
 808                 "-Xclang -msoft-float" "-msoft-float"; do
 809       if test x"$grub_cv_target_cc_soft_float" != xno ; then
 810         break
 811       fi
 812       CFLAGS="$TARGET_CFLAGS $cand -Werror"
 813       AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 814                         [grub_cv_target_cc_soft_float="$cand"], [])
 815     done
 816   ])
 817
 818   if test x"$grub_cv_target_cc_soft_float" = xno ; then
 819     AC_MSG_ERROR([could not force soft-float])
 820   fi
 821
 822   case x"$grub_cv_target_cc_soft_float" in
 823     x*"-Xclang"*)
 824       # A trick so that clang doesn't see it on link stаge
 825       TARGET_CPPFLAGS="$TARGET_CPPFLAGS $grub_cv_target_cc_soft_float"
 826       ;;
 827     *)
 828       TARGET_CFLAGS="$TARGET_CFLAGS $grub_cv_target_cc_soft_float"
 829       ;;
 830   esac
 831   TARGET_CCASFLAGS="$TARGET_CCASFLAGS $grub_cv_target_cc_soft_float"
 832
 833 fi
 834
 835 if test x"$target_cpu" = xsparc64 ; then
 836   AC_CACHE_CHECK([for options to reserve application registers], grub_cv_target_cc_mno_app_regs, [
 837     grub_cv_target_cc_mno_app_regs=no
 838     for cand in "-mllvm -sparc-reserve-app-registers" \
 839                 "-mno-app-regs"; do
 840       if test x"$grub_cv_target_cc_mno_app_regs" != xno ; then
 841         break
 842       fi
 843       CFLAGS="$TARGET_CFLAGS $cand -Werror"
 844       CPPFLAGS="$TARGET_CPPFLAGS"
 845       AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 846                         [grub_cv_target_cc_mno_app_regs="$cand"], [])
 847     done
 848   ])
 849
 850   if test x"$grub_cv_target_cc_mno_app_regs" = xno ; then
 851     AC_MSG_ERROR([could not reserve application registers])
 852   fi
 853   if test x"$grub_cv_target_cc_mno_app_regs" = x"-mllvm -sparc-reserve-app-registers" ; then
 854     # A trick so that clang doesn't see it on link stаge
 855     TARGET_CPPFLAGS="$TARGET_CPPFLAGS $grub_cv_target_cc_mno_app_regs"
 856   else
 857     TARGET_CFLAGS="$TARGET_CFLAGS $grub_cv_target_cc_mno_app_regs"
 858   fi
 859
 860   AC_CACHE_CHECK([for no-relax options], grub_cv_target_cc_mno_relax, [
 861     grub_cv_target_cc_mno_relax=no
 862     for cand in "-mno-relax" "-Wl,--no-relax"; do
 863       if test x"$grub_cv_target_cc_mno_relax" != xno ; then
 864         break
 865       fi
 866       LDFLAGS="$TARGET_LDFLAGS $cand -nostdlib -static"
 867       CFLAGS="$TARGET_CFLAGS -Werror"
 868       AC_LINK_IFELSE([AC_LANG_PROGRAM([[
 869             asm (".globl start; start:");
 870             void __main (void);
 871             void __main (void) {}
 872             int main (void);
 873             ]], [[]])], [grub_cv_target_cc_mno_relax="$cand"], [])
 874     done
 875   ])
 876   LDFLAGS="$TARGET_LDFLAGS"
 877   CFLAGS="$TARGET_CFLAGS"
 878
 879   if test x"$grub_cv_target_cc_mno_relax" = xno ; then
 880     AC_MSG_ERROR([could not find no-relax options])
 881   fi
 882   TARGET_LDFLAGS="$TARGET_LDFLAGS $grub_cv_target_cc_mno_relax"
 883 fi
 884
 885 # By default, GCC 4.4 generates .eh_frame sections containing unwind
 886 # information in some cases where it previously did not. GRUB doesn't need
 887 # these and they just use up vital space. Restore the old compiler
 888 # behaviour.
 889 AC_CACHE_CHECK([whether -fno-dwarf2-cfi-asm works], [grub_cv_cc_fno_dwarf2_cfi_asm], [
 890   CFLAGS="$TARGET_CFLAGS -fno-dwarf2-cfi-asm"
 891   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 892       [grub_cv_cc_fno_dwarf2_cfi_asm=yes],
 893       [grub_cv_cc_fno_dwarf2_cfi_asm=no])
 894 ])
 895
 896 if test "x$grub_cv_cc_fno_dwarf2_cfi_asm" = xyes; then
 897   TARGET_CFLAGS="$TARGET_CFLAGS -fno-dwarf2-cfi-asm"
 898 fi
 899
 900 if test x"$target_os" = xcygwin; then
 901   AC_CACHE_CHECK([whether option -fno-reorder-functions works], grub_cv_cc_no_reorder_functions, [
 902     CFLAGS="$TARGET_CFLAGS -fno-reorder-functions"
 903     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 904                       [grub_cv_cc_no_reorder_functions=yes],
 905                       [grub_cv_cc_no_reorder_functions=no])
 906   ])
 907 fi
 908
 909 if test x"$target_os" = xcygwin && test "x$grub_cv_cc_no_reorder_functions" = xyes; then
 910   TARGET_CFLAGS="$TARGET_CFLAGS -fno-reorder-functions"
 911 fi
 912
 913 AC_CACHE_CHECK([whether -mno-stack-arg-probe works], [grub_cv_cc_mno_stack_arg_probe], [
 914   CFLAGS="$TARGET_CFLAGS -mno-stack-arg-probe"
 915   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 916       [grub_cv_cc_mno_stack_arg_probe=yes],
 917       [grub_cv_cc_mno_stack_arg_probe=no])
 918 ])
 919
 920 if test "x$grub_cv_cc_mno_stack_arg_probe" = xyes; then
 921   TARGET_CFLAGS="$TARGET_CFLAGS -mno-stack-arg-probe"
 922 fi
 923
 924
 925 # By default, GCC 4.6 generates .eh_frame sections containing unwind
 926 # information in some cases where it previously did not. GRUB doesn't need
 927 # these and they just use up vital space. Restore the old compiler
 928 # behaviour.
 929 AC_CACHE_CHECK([whether -fno-asynchronous-unwind-tables works], [grub_cv_cc_fno_asynchronous_unwind_tables], [
 930   CFLAGS="$TARGET_CFLAGS -fno-asynchronous-unwind-tables"
 931   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 932       [grub_cv_cc_fno_asynchronous_unwind_tables=yes],
 933       [grub_cv_cc_fno_asynchronous_unwind_tables=no])
 934 ])
 935
 936 if test "x$grub_cv_cc_fno_asynchronous_unwind_tables" = xyes; then
 937   TARGET_CFLAGS="$TARGET_CFLAGS -fno-asynchronous-unwind-tables"
 938 fi
 939
 940 AC_CACHE_CHECK([whether -fno-unwind-tables works], [grub_cv_cc_fno_unwind_tables], [
 941   CFLAGS="$TARGET_CFLAGS -fno-unwind-tables"
 942   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 943       [grub_cv_cc_fno_unwind_tables=yes],
 944       [grub_cv_cc_fno_unwind_tables=no])
 945 ])
 946
 947 if test "x$grub_cv_cc_fno_unwind_tables" = xyes; then
 948   TARGET_CFLAGS="$TARGET_CFLAGS -fno-unwind-tables"
 949 fi
 950
 951
 952 CFLAGS="$TARGET_CFLAGS"
 953
 954
 955 if test x"$platform" = xemu ; then
 956   TARGET_OBJ2ELF=
 957   grub_cv_target_cc_link_format=
 958   case "$host_os" in
 959     *darwin* | *mac*)
 960        grub_cv_target_cc_link_format="-arch,${target_cpu}"
 961        TARGET_LDFLAGS="$TARGET_LDFLAGS -Wl,$grub_cv_target_cc_link_format"
 962         ;;
 963     *windows* | *cygwin* | *mingw*)
 964       if test x${target_cpu} = xi386 ; then
 965         grub_cv_target_cc_link_format=-mi386pe
 966         TARGET_OBJ2ELF='./build-grub-pe2elf$(BUILD_EXEEXT)'
 967       fi
 968       if test x${target_cpu} = xx86_64 ; then
 969         grub_cv_target_cc_link_format=-mi386pep
 970         TARGET_OBJ2ELF='./build-grub-pep2elf$(BUILD_EXEEXT)'
 971       fi
 972       TARGET_LDFLAGS="$TARGET_LDFLAGS -Wl,$grub_cv_target_cc_link_format"
 973       ;;
 974   esac
 975 elif test x"$target_cpu" = xi386 || test x"$target_cpu" = xx86_64; then
 976   AC_CACHE_CHECK([for target linking format], [grub_cv_target_cc_link_format], [
 977     grub_cv_target_cc_link_format=unknown
 978     for format in -melf_${target_cpu} -melf_${target_cpu}_fbsd -melf_${target_cpu}_obsd -melf_${target_cpu}_haiku -mi386pe -mi386pep -arch,${target_cpu}; do
 979       if test x${target_cpu} != xi386 && test x$format = x-mi386pe; then
 980         continue
 981       fi
 982       if test x${target_cpu} != xx86_64 && test x$format = x-mi386pep; then
 983         continue
 984       fi
 985       CFLAGS="$TARGET_CFLAGS"
 986       LDFLAGS="$TARGET_LDFLAGS -Wl,$format -nostdlib -static"
 987       AC_LINK_IFELSE([AC_LANG_PROGRAM([[
 988       asm (".globl start; start:");
 989       asm (".globl _start; _start:");
 990       asm (".globl __start; __start:");
 991       void __main (void);
 992       void __main (void) {}
 993       ]], [[]])], [flag=1], [flag=0])
 994       if test x"$flag" = x1; then
 995         grub_cv_target_cc_link_format="$format"
 996         break
 997       fi
 998     done])
 999   if test x"$grub_cv_target_cc_link_format" = xunknown; then
1000     AC_MSG_ERROR([no suitable link format found])
1001   fi
1002   TARGET_LDFLAGS="$TARGET_LDFLAGS -Wl,$grub_cv_target_cc_link_format"
1003   if test x"$grub_cv_target_cc_link_format" = x-mi386pe ; then
1004     TARGET_OBJ2ELF='./build-grub-pe2elf$(BUILD_EXEEXT)'
1005   fi
1006   if test x"$grub_cv_target_cc_link_format" = x-mi386pep ; then
1007     TARGET_OBJ2ELF='./build-grub-pep2elf$(BUILD_EXEEXT)'
1008   fi
1009 fi
1010
1011 if test x$grub_cv_target_cc_link_format = x-arch,i386 || test x$grub_cv_target_cc_link_format = x-arch,x86_64; then
1012    TARGET_APPLE_LINKER=1
1013    AC_CHECK_PROG([TARGET_OBJCONV], [objconv], [objconv], [])
1014    if test "x$TARGET_OBJCONV" = x ; then
1015       AC_CHECK_PROG([TARGET_OBJCONV], [objconv], [./objconv], [], [.])
1016    fi
1017    if test "x$TARGET_OBJCONV" = x ; then
1018       AC_MSG_ERROR([objconv not found which is required when building with apple compiler])
1019    fi
1020    TARGET_IMG_LDSCRIPT=
1021    TARGET_IMG_CFLAGS="-static"
1022    TARGET_IMG_LDFLAGS='-nostdlib -static -Wl,-preload -Wl,-segalign,20'
1023    TARGET_IMG_LDFLAGS_AC='-nostdlib -static -Wl,-preload -Wl,-segalign,20'
1024    TARGET_IMG_BASE_LDOPT="-Wl,-image_base"
1025    TARGET_LDFLAGS_OLDMAGIC=""
1026 elif test x$grub_cv_target_cc_link_format = x-mi386pe || test x$grub_cv_target_cc_link_format = x-mi386pep ; then
1027   TARGET_APPLE_LINKER=0
1028   TARGET_LDFLAGS_OLDMAGIC="-Wl,-N"
1029   TARGET_IMG_LDSCRIPT='$(top_srcdir)'"/${grub_coredir}/conf/i386-cygwin-img-ld.sc"
1030   TARGET_IMG_LDFLAGS="-Wl,-T${TARGET_IMG_LDSCRIPT}"
1031   TARGET_IMG_LDFLAGS_AC="-Wl,-T${srcdir}/${grub_coredir}/conf/i386-cygwin-img-ld.sc"
1032   TARGET_IMG_BASE_LDOPT="-Wl,-Ttext"
1033   TARGET_IMG_CFLAGS=
1034 else
1035   TARGET_APPLE_LINKER=0
1036   TARGET_LDFLAGS_OLDMAGIC="-Wl,-N"
1037   TARGET_IMG_LDSCRIPT=
1038   TARGET_IMG_LDFLAGS='-Wl,-N'
1039   TARGET_IMG_LDFLAGS_AC='-Wl,-N'
1040   TARGET_IMG_BASE_LDOPT="-Wl,-Ttext"
1041   TARGET_IMG_CFLAGS=
1042 fi
1043
1044 CFLAGS="$TARGET_CFLAGS"
1045
1046 AC_ARG_ENABLE([efiemu],
1047               [AS_HELP_STRING([--enable-efiemu],
1048                              [build and install the efiemu runtimes (default=guessed)])])
1049 if test x"$enable_efiemu" = xno ; then
1050   efiemu_excuse="explicitly disabled"
1051 fi
1052
1053 if test x"$grub_cv_target_cc_link_format" = x-mi386pe || test x"$grub_cv_target_cc_link_format" = x-mi386pep ; then
1054   efiemu_excuse="not available on cygwin"
1055 fi
1056 if test x"$target_cpu" != xi386 ; then
1057   efiemu_excuse="only available on i386"
1058 fi
1059 if test x"$platform" = xefi ; then
1060   efiemu_excuse="not available on efi"
1061 fi
1062
1063 if test x"$efiemu_excuse" = x ; then
1064   AC_CACHE_CHECK([whether options required for efiemu work], grub_cv_cc_efiemu, [
1065     CFLAGS="-m64 -nostdlib -O2 -mcmodel=large -mno-red-zone"
1066     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
1067                       [grub_cv_cc_efiemu=yes],
1068                       [grub_cv_cc_efiemu=no])
1069   ])
1070   if test x$grub_cv_cc_efiemu = xno; then
1071      efiemu_excuse="cannot compile with -m64 -mcmodel=large -mno-red-zone -nostdlib"
1072   fi
1073 fi
1074 if test x"$efiemu_excuse" = x ; then
1075   AC_CACHE_CHECK([for efiemu64 linking format], [grub_cv_target_cc_efiemu64_link_format], [
1076     grub_cv_target_cc_efiemu64_link_format=unknown
1077     for format in -melf_x86_64 -melf_x86_64_fbsd -melf_x86_64_obsd -melf_x86_64_haiku -arch,x86_64; do
1078       CFLAGS="-m64 -nostdlib -O2 -mcmodel=large -mno-red-zone"
1079       LDFLAGS="-m64 -Wl,$format -nostdlib -static"
1080       AC_LINK_IFELSE([AC_LANG_PROGRAM([[
1081       asm (".globl start; start:");
1082       asm (".globl _start; _start:");
1083       asm (".globl __start; __start:");
1084       void __main (void);
1085       void __main (void) {}
1086       ]], [[]])], [flag=1], [flag=0])
1087       if test x"$flag" = x1; then
1088         grub_cv_target_cc_efiemu64_link_format="$format"
1089         break
1090       fi
1091     done])
1092   if test x"$grub_cv_target_cc_efiemu64_link_format" = xunknown; then
1093     efiemu_excuse="no suitable link format for efiemu64 found"
1094   else
1095     EFIEMU64_LINK_FORMAT="-Wl,$grub_cv_target_cc_efiemu64_link_format"
1096   fi
1097 fi
1098 if test x"$enable_efiemu" = xyes && test x"$efiemu_excuse" != x ; then
1099   AC_MSG_ERROR([efiemu runtime was explicitly requested but can't be compiled ($efiemu_excuse)])
1100 fi
1101 if test x"$efiemu_excuse" = x ; then
1102 enable_efiemu=yes
1103 else
1104 enable_efiemu=no
1105 fi
1106 AC_SUBST([enable_efiemu])
1107 AC_SUBST([EFIEMU64_LINK_FORMAT])
1108
1109 CFLAGS="$TARGET_CFLAGS"
1110
1111 AC_SUBST(TARGET_LDFLAGS_OLDMAGIC)
1112
1113
1114 LDFLAGS="$TARGET_LDFLAGS"
1115
1116 if test "$target_cpu" = x86_64 || test "$target_cpu" = sparc64 ; then
1117   # Use large model to support 4G memory
1118   AC_CACHE_CHECK([whether option -mcmodel=large works], grub_cv_cc_mcmodel, [
1119     CFLAGS="$TARGET_CFLAGS -mcmodel=large"
1120     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
1121                       [grub_cv_cc_mcmodel=yes],
1122                       [grub_cv_cc_mcmodel=no])
1123   ])
1124   if test "x$grub_cv_cc_mcmodel" = xyes; then
1125     TARGET_CFLAGS="$TARGET_CFLAGS -mcmodel=large"
1126   elif test "$target_cpu" = sparc64; then
1127     TARGET_CFLAGS="$TARGET_CFLAGS -mcmodel=medany"
1128   fi
1129 fi
1130
1131 if test "$target_cpu"-"$platform" = x86_64-efi; then
1132   # EFI writes to stack below %rsp, we must not use the red zone
1133   AC_CACHE_CHECK([whether option -mno-red-zone works], grub_cv_cc_no_red_zone, [
1134     CFLAGS="$TARGET_CFLAGS -mno-red-zone"
1135     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
1136                       [grub_cv_cc_no_red_zone=yes],
1137                       [grub_cv_cc_no_red_zone=no])
1138   ])
1139   if test "x$grub_cv_cc_no_red_zone" = xno; then
1140     AC_MSG_ERROR([-mno-red-zone not supported, upgrade your gcc])
1141   fi
1142
1143   TARGET_CFLAGS="$TARGET_CFLAGS -mno-red-zone"
1144 fi
1145
1146 if test "x$target_cpu" = xarm; then
1147   AC_CACHE_CHECK([whether option -mlong-calls works], grub_cv_cc_mlong_calls, [
1148     CFLAGS="$TARGET_CFLAGS -mlong-calls -Werror"
1149     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
1150                       [grub_cv_cc_mlong_calls=yes],
1151                       [grub_cv_cc_mlong_calls=no])
1152   ])
1153   if test "x$grub_cv_cc_mlong_calls" = xyes; then
1154     TARGET_CFLAGS="$TARGET_CFLAGS -mlong-calls"
1155   fi
1156   AC_CACHE_CHECK([whether option -mthumb-interwork works], grub_cv_cc_mthumb_interwork, [
1157     CFLAGS="$TARGET_CFLAGS -mthumb-interwork -Werror"
1158     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
1159                       [grub_cv_cc_mthumb_interwork=yes],
1160                       [grub_cv_cc_mthumb_interwork=no])
1161   ])
1162   if test "x$grub_cv_cc_mthumb_interwork" = xyes; then
1163     TARGET_CFLAGS="$TARGET_CFLAGS -mthumb-interwork"
1164   # Clang defaults to thumb interworking
1165   elif test "x$grub_cv_cc_target_clang" = xno ; then
1166     AC_MSG_ERROR([your compiler doesn't support -mthumb-interwork])
1167   fi
1168 fi
1169
1170 AC_CACHE_CHECK([whether option -Qn works], grub_cv_target_cc_qn, [
1171   CFLAGS="$TARGET_CFLAGS -Qn -Werror"
1172   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
1173                     [grub_cv_target_cc_qn=yes],
1174                     [grub_cv_target_cc_qn=no])])
1175 if test "x$grub_cv_target_cc_qn" = xyes; then
1176   TARGET_CFLAGS="$TARGET_CFLAGS -Qn"
1177 fi
1178
1179 #
1180 # Compiler features.
1181 #
1182
1183 CFLAGS="$TARGET_CFLAGS"
1184
1185 # Position independent executable.
1186 grub_CHECK_PIE
1187 [# Need that, because some distributions ship compilers that include
1188 # `-fPIE' in the default specs.
1189 if [ x"$pie_possible" = xyes ]; then
1190   TARGET_CFLAGS="$TARGET_CFLAGS -fno-PIE"
1191 fi]
1192
1193 CFLAGS="$TARGET_CFLAGS"
1194
1195 # Position independent executable.
1196 grub_CHECK_PIC
1197 [# On most platforms we don't want PIC as it only makes relocations harder
1198 # and code less efficient. On mips we want to have one got table per module
1199 # and reload $gp in every function.
1200 # GCC implements it using symbol __gnu_local_gp in non-PIC as well.
1201 # However with clang we need PIC for this reloading to happen.
1202 # Since default varies across dictributions use either -fPIC or -fno-PIC
1203 # explicitly.
1204 if ( test x$target_cpu = xmips || test x$target_cpu = xmipsel ) && test "x$grub_cv_cc_target_clang" = xyes ; then
1205    TARGET_CFLAGS="$TARGET_CFLAGS -fPIC"
1206 elif [ x"$pic_possible" = xyes ]; then
1207    TARGET_CFLAGS="$TARGET_CFLAGS -fno-PIC"
1208 fi]
1209
1210 CFLAGS="$TARGET_CFLAGS"
1211
1212 # Smashing stack protector.
1213 grub_CHECK_STACK_PROTECTOR
1214 # Need that, because some distributions ship compilers that include
1215 # `-fstack-protector' in the default specs.
1216 if test "x$ssp_possible" = xyes; then
1217   TARGET_CFLAGS="$TARGET_CFLAGS -fno-stack-protector"
1218 fi
1219
1220 CFLAGS="$TARGET_CFLAGS"
1221
1222 grub_CHECK_STACK_ARG_PROBE
1223 # Cygwin's GCC uses alloca() to probe the stackframe on static
1224 # stack allocations above some threshold.
1225 if test x"$sap_possible" = xyes; then
1226   TARGET_CFLAGS="$TARGET_CFLAGS -mno-stack-arg-probe"
1227 fi
1228
1229 CFLAGS="$TARGET_CFLAGS"
1230
1231 # -mno-unaligned-access -mstrict-align
1232 if test "$target_cpu" = arm; then
1233   AC_CACHE_CHECK([for compile options to get strict alignment], [grub_cv_target_cc_strict_align], [
1234     grub_cv_target_cc_strict_align=
1235     for arg in -mno-unaligned-access "-Xclang -mstrict-align" -mstrict-align; do
1236       CFLAGS="$TARGET_CFLAGS $arg -Werror"
1237       LDFLAGS="$TARGET_LDFLAGS"
1238       AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])], [flag=1], [flag=0])
1239       if test x"$flag" = x1; then
1240         grub_cv_target_cc_strict_align="$arg"
1241         break
1242       fi
1243     done])
1244
1245   TARGET_CFLAGS="$TARGET_CFLAGS $grub_cv_target_cc_strict_align"
1246   if test x"$grub_cv_target_cc_strict_align" = x"-Xclang -mstrict-align"; then
1247     TARGET_LDFLAGS="$TARGET_LDFLAGS -Qunused-arguments"
1248   fi
1249   AC_CACHE_CHECK([if compiler generates unaligned accesses], [grub_cv_cc_target_emits_unaligned],
1250   [CFLAGS="$TARGET_CFLAGS"
1251    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[
1252 #ifdef __ARM_FEATURE_UNALIGNED
1253 #error "unaligned"
1254 #endif
1255      ]])],
1256      [grub_cv_cc_target_emits_unaligned=no], [grub_cv_cc_target_emits_unaligned=yes])])
1257   if test x$grub_cv_cc_target_emits_unaligned = xyes; then
1258     AC_MSG_ERROR([compiler generates unaligned accesses])
1259   fi
1260 fi
1261
1262 # Set them to their new values for the tests below.
1263 CC="$TARGET_CC"
1264 if test x"$platform" = xemu ; then
1265 CFLAGS="$TARGET_CFLAGS -Wno-error"
1266 elif test "x$TARGET_APPLE_LINKER" = x1 ; then
1267 CFLAGS="$TARGET_CFLAGS -nostdlib -static -Wno-error"
1268 else
1269 CFLAGS="$TARGET_CFLAGS -nostdlib -Wno-error"
1270 fi
1271 CPPFLAGS="$TARGET_CPPFLAGS"
1272
1273 grub_ASM_USCORE
1274 if test "x$TARGET_APPLE_LINKER" = x0 && test x"$platform" != xemu; then
1275 if test x$grub_cv_asm_uscore = xyes; then
1276 DEFSYM="-Wl,--defsym,_abort=_main -Wl,--defsym,__main=_main"
1277 else
1278 DEFSYM="-Wl,--defsym,abort=main -Wl,--defsym,_main=main -Wl,--defsym,__main=main"
1279 fi
1280 CFLAGS="$TARGET_CFLAGS -nostdlib $DEFSYM"
1281 fi
1282
1283 # Check for libgcc symbols
1284 if test x"$platform" = xemu; then
1285 AC_CHECK_FUNCS(__udivsi3 __umodsi3 __divsi3 __modsi3 __divdi3 __moddi3 __udivdi3 __umoddi3 __ctzdi2 __ctzsi2 __aeabi_uidiv __aeabi_uidivmod __aeabi_idiv __aeabi_idivmod __aeabi_ulcmp __muldi3 __aeabi_lmul __aeabi_memcpy __aeabi_memcpy4 __aeabi_memcpy8 __aeabi_memclr __aeabi_memclr4 __aeabi_memclr8 __aeabi_memset __aeabi_lasr __aeabi_llsl __aeabi_llsr _restgpr_14_x __ucmpdi2 __ashldi3 __ashrdi3 __lshrdi3 __bswapsi2 __bswapdi2 __bzero __register_frame_info __deregister_frame_info ___chkstk_ms __chkstk_ms)
1286 fi
1287
1288 if test "x$TARGET_APPLE_LINKER" = x1 ; then
1289 CFLAGS="$TARGET_CFLAGS -nostdlib -static"
1290 else
1291 CFLAGS="$TARGET_CFLAGS -nostdlib"
1292 fi
1293 LIBS=""
1294
1295 # Defined in aclocal.m4.
1296 grub_PROG_TARGET_CC
1297 if test "x$TARGET_APPLE_LINKER" != x1 ; then
1298 grub_PROG_OBJCOPY_ABSOLUTE
1299 fi
1300 grub_PROG_LD_BUILD_ID_NONE
1301 if test "x$target_cpu" = xi386; then
1302   if test "$platform" != emu && test "x$TARGET_APPLE_LINKER" != x1 ; then
1303     if test ! -z "$TARGET_IMG_LDSCRIPT"; then
1304       # Check symbols provided by linker script.
1305       CFLAGS="$TARGET_CFLAGS -nostdlib ${TARGET_IMG_LDFLAGS_AC} ${TARGET_IMG_BASE_LDOPT},0x8000"
1306     fi
1307     grub_CHECK_BSS_START_SYMBOL
1308     grub_CHECK_END_SYMBOL
1309   fi
1310   CFLAGS="$TARGET_CFLAGS"
1311 fi
1312
1313 grub_PROG_NM_WORKS
1314 grub_PROG_NM_MINUS_P
1315 grub_PROG_NM_DEFINED_ONLY
1316 AC_SUBST(TARGET_NMFLAGS_MINUS_P)
1317 AC_SUBST(TARGET_NMFLAGS_DEFINED_ONLY)
1318
1319 if test "$platform" != emu; then
1320 AC_CACHE_CHECK([whether -nostdinc -isystem works], [grub_cv_cc_isystem], [
1321   SAVED_CPPFLAGS="$CPPFLAGS"
1322   CPPFLAGS="$TARGET_CPPFLAGS -nostdinc -isystem `$TARGET_CC -print-file-name=include`"
1323   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <stdarg.h>
1324 #include <stddef.h>
1325 int va_arg_func (int fixed, va_list args);]], [[]])],
1326       [grub_cv_cc_isystem=yes],
1327       [grub_cv_cc_isystem=no])
1328   CPPFLAGS="$SAVED_CPPFLAGS"
1329 ])
1330
1331 if test x"$grub_cv_cc_isystem" = xyes ; then
1332   TARGET_CPPFLAGS="$TARGET_CPPFLAGS -nostdinc -isystem `$TARGET_CC -print-file-name=include`"
1333 fi
1334 fi
1335
1336 AC_CACHE_CHECK([whether -Wtrampolines work], [grub_cv_cc_wtrampolines], [
1337   CFLAGS="$TARGET_CFLAGS -Wtrampolines -Werror"
1338   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <stdarg.h>
1339 int va_arg_func (int fixed, va_list args);]], [[]])],
1340       [grub_cv_cc_wtrampolines=yes],
1341       [grub_cv_cc_wtrampolines=no])
1342 ])
1343
1344 if test x"$grub_cv_cc_wtrampolines" = xyes ; then
1345   TARGET_CFLAGS="$TARGET_CFLAGS -Wtrampolines"
1346 fi
1347
1348 # Restore the flags.
1349 CC="$tmp_CC"
1350 CFLAGS="$tmp_CFLAGS"
1351 CPPFLAGS="$tmp_CPPFLAGS"
1352 LDFLAGS="$tmp_LDFLAGS"
1353 LIBS="$tmp_LIBS"
1354
1355 #
1356 # Check for options.
1357 #
1358
1359 # Memory manager debugging.
1360 AC_ARG_ENABLE([mm-debug],
1361               AS_HELP_STRING([--enable-mm-debug],
1362                              [include memory manager debugging]),
1363               [AC_DEFINE([MM_DEBUG], [1],
1364                          [Define to 1 if you enable memory manager debugging.])])
1365
1366 AC_ARG_ENABLE([cache-stats],
1367               AS_HELP_STRING([--enable-cache-stats],
1368                              [enable disk cache statistics collection]))
1369
1370 if test x$enable_cache_stats = xyes; then
1371   DISK_CACHE_STATS=1
1372 else
1373   DISK_CACHE_STATS=0
1374 fi
1375 AC_SUBST([DISK_CACHE_STATS])
1376
1377 AC_ARG_ENABLE([boot-time],
1378               AS_HELP_STRING([--enable-boot-time],
1379                              [enable boot time statistics collection]))
1380
1381 if test x$enable_boot_time = xyes; then
1382   BOOT_TIME_STATS=1
1383 else
1384   BOOT_TIME_STATS=0
1385 fi
1386 AC_SUBST([BOOT_TIME_STATS])
1387
1388 AC_ARG_ENABLE([grub-emu-sdl],
1389               [AS_HELP_STRING([--enable-grub-emu-sdl],
1390                              [build and install the `grub-emu' debugging utility with SDL support (default=guessed)])])
1391
1392 AC_ARG_ENABLE([grub-emu-pci],
1393               [AS_HELP_STRING([--enable-grub-emu-pci],
1394                              [build and install the `grub-emu' debugging utility with PCI support (potentially dangerous) (default=no)])])
1395
1396 if test "$platform" = emu; then
1397
1398 if test x"$enable_grub_emu_sdl" = xno ; then
1399   grub_emu_sdl_excuse="explicitly disabled"
1400 fi
1401 [if [ x"$grub_emu_sdl_excuse" = x ]; then
1402     # Check for libSDL libraries.]
1403 AC_CHECK_LIB([SDL], [SDL_Init], [LIBSDL="-lSDL"],
1404     [grub_emu_sdl_excuse=["libSDL libraries are required to build \`grub-emu' with SDL support"]])
1405     AC_SUBST([LIBSDL])
1406 [fi]
1407
1408 [if [ x"$grub_emu_sdl_excuse" = x ]; then
1409     # Check for headers.]
1410     AC_CHECK_HEADERS([SDL/SDL.h], [],
1411       [grub_emu_sdl_excuse=["libSDL header file is required to build \`grub-emu' with SDL support"]])
1412 [fi]
1413
1414 if test x"enable_grub_emu_sdl" = xyes && test x"$grub_emu_sdl_excuse" != x ; then
1415   AC_MSG_ERROR([SDL support for grub-emu was explicitly requested but can't be compiled ($grub_emu_sdl_excuse)])
1416 fi
1417 if test x"$grub_emu_sdl_excuse" = x ; then
1418 enable_grub_emu_sdl=yes
1419 else
1420 enable_grub_emu_sdl=no
1421 fi
1422
1423 if test x"$enable_grub_emu_pci" != xyes ; then
1424    grub_emu_pci_excuse="not enabled"
1425 fi
1426
1427 [if [ x"$grub_emu_pci_excuse" = x ]; then
1428       # Check for libpci libraries.]
1429    AC_CHECK_LIB([pciaccess], [pci_system_init], [LIBPCIACCESS="-lpciaccess"],
1430       [grub_emu_pci_excuse=["need libpciaccess library"]])
1431     AC_SUBST([LIBPCIACCESS])
1432 [fi]
1433 [if [ x"$grub_emu_pci_excuse" = x ]; then
1434     # Check for headers.]
1435     AC_CHECK_HEADERS([pciaccess.h], [],
1436       [grub_emu_pci_excuse=["need libpciaccess headers"]])
1437 [fi]
1438
1439 if test x"$grub_emu_pci_excuse" = x ; then
1440 enable_grub_emu_pci=yes
1441 else
1442
1443 enable_grub_emu_pci=no
1444 fi
1445
1446 AC_SUBST([enable_grub_emu_sdl])
1447 AC_SUBST([enable_grub_emu_pci])
1448
1449 else
1450
1451 # Ignore --enable-emu-* if platform is not emu
1452 enable_grub_emu_sdl=no
1453 enable_grub_emu_pci=no
1454 fi
1455
1456 AC_ARG_ENABLE([grub-mkfont],
1457               [AS_HELP_STRING([--enable-grub-mkfont],
1458                              [build and install the `grub-mkfont' utility (default=guessed)])])
1459 if test x"$enable_grub_mkfont" = xno ; then
1460   grub_mkfont_excuse="explicitly disabled"
1461 fi
1462
1463 if test x"$grub_mkfont_excuse" = x ; then
1464   # Check for freetype libraries.
1465   AC_CHECK_TOOLS([FREETYPE], [freetype-config])
1466   if test "x$FREETYPE" = x ; then
1467     grub_mkfont_excuse=["need freetype2 library"]
1468   fi
1469 fi
1470
1471 unset ac_cv_header_ft2build_h
1472
1473 if test x"$grub_mkfont_excuse" = x ; then
1474   # Check for freetype libraries.
1475   freetype_cflags=`$FREETYPE --cflags`
1476   freetype_libs=`$FREETYPE --libs`
1477   SAVED_CPPFLAGS="$CPPFLAGS"
1478   SAVED_LIBS="$LIBS"
1479   CPPFLAGS="$CPPFLAGS $freetype_cflags"
1480   LIBS="$LIBS $freetype_libs"
1481   AC_CHECK_HEADERS([ft2build.h], [],
1482         [grub_mkfont_excuse=["need freetype2 headers"]])
1483   AC_LINK_IFELSE([AC_LANG_CALL([], [FT_Load_Glyph])], [], [grub_mkfont_excuse=["freetype2 library unusable"]])
1484   CPPFLAGS="$SAVED_CPPFLAGS"
1485   LIBS="$SAVED_LIBS"
1486 fi
1487
1488 if test x"$enable_grub_mkfont" = xyes && test x"$grub_mkfont_excuse" != x ; then
1489   AC_MSG_ERROR([grub-mkfont was explicitly requested but can't be compiled ($grub_mkfont_excuse)])
1490 fi
1491 if test x"$grub_mkfont_excuse" = x ; then
1492 enable_grub_mkfont=yes
1493 else
1494 enable_grub_mkfont=no
1495 fi
1496 AC_SUBST([enable_grub_mkfont])
1497 AC_SUBST([freetype_cflags])
1498 AC_SUBST([freetype_libs])
1499
1500 SAVED_CC="$CC"
1501 SAVED_CPP="$CPP"
1502 SAVED_CFLAGS="$CFLAGS"
1503 SAVED_CPPFLAGS="$CPPFLAGS"
1504 SAVED_LDFLAGS="$LDFLAGS"
1505 CC="$BUILD_CC"
1506 CPP="$BUILD_CPP"
1507 CFLAGS="$BUILD_CFLAGS"
1508 CPPFLAGS="$BUILD_CPPFLAGS"
1509 LDFLAGS="$BUILD_LDFAGS"
1510
1511 unset ac_cv_c_bigendian
1512 unset ac_cv_header_ft2build_h
1513
1514 AC_COMPUTE_INT([BUILD_SIZEOF_VOID_P], [sizeof (void *)])
1515 AC_COMPUTE_INT([BUILD_SIZEOF_LONG], [sizeof (long)])
1516 AC_C_BIGENDIAN([BUILD_WORDS_BIGENDIAN=1], [BUILD_WORDS_BIGENDIAN=0], [BUILD_WORDS_BIGENDIAN=err], [BUILD_WORDS_BIGENDIAN=err])
1517
1518 if test x$BUILD_WORDS_BIGENDIAN = xerr ; then
1519    AC_MSG_ERROR([couldnt determine build endianness])
1520 fi
1521
1522 AC_SUBST([BUILD_SIZEOF_LONG])
1523 AC_SUBST([BUILD_SIZEOF_VOID_P])
1524 AC_SUBST([BUILD_WORDS_BIGENDIAN])
1525
1526 if test x"$grub_build_mkfont_excuse" = x ; then
1527   # Check for freetype libraries.
1528   AC_CHECK_PROGS([BUILD_FREETYPE], [freetype-config])
1529   if test "x$BUILD_FREETYPE" = x ; then
1530     grub_build_mkfont_excuse=["need freetype2 library"]
1531   fi
1532 fi
1533
1534 if test x"$grub_build_mkfont_excuse" = x ; then
1535   # Check for freetype libraries.
1536   build_freetype_cflags=`$BUILD_FREETYPE --cflags`
1537   build_freetype_libs=`$BUILD_FREETYPE --libs`
1538   SAVED_CPPFLAGS_2="$CPPFLAGS"
1539   SAVED_LIBS="$LIBS"
1540   CPPFLAGS="$CPPFLAGS $build_freetype_cflags"
1541   LIBS="$LIBS $build_freetype_libs"
1542   AC_CHECK_HEADERS([ft2build.h], [],
1543         [grub_build_mkfont_excuse=["need freetype2 headers"]])
1544   AC_LINK_IFELSE([AC_LANG_CALL([], [FT_Load_Glyph])], [], [grub_build_mkfont_excuse=["freetype2 library unusable"]])
1545   LIBS="$SAVED_LIBS"
1546   CPPFLAGS="$SAVED_CPPFLAGS_2"
1547 fi
1548
1549 if test x"$enable_build_grub_mkfont" = xyes && test x"$grub_build_mkfont_excuse" != x ; then
1550   AC_MSG_ERROR([build-grub-mkfont was explicitly requested but can't be compiled ($grub_build_mkfont_excuse)])
1551 fi
1552 if test x"$grub_build_mkfont_excuse" = x ; then
1553   enable_build_grub_mkfont=yes
1554 else
1555   enable_build_grub_mkfont=no
1556 fi
1557 if test x"$enable_build_grub_mkfont" = xno && ( test "x$platform" = xqemu || test "x$platform" = xloongson || test "x$platform" = xqemu_mips || test "x$target_cpu"-"$platform" = xpowerpc-ieee1275 || test "x$platform" = xcoreboot ); then
1558   if test x"$grub_build_mkfont_excuse" = x ; then
1559     AC_MSG_ERROR([qemu, powerpc-ieee1275, coreboot and loongson ports needs build-time grub-mkfont])
1560   else
1561     AC_MSG_ERROR([qemu, powerpc-ieee1275, coreboot and loongson ports needs build-time grub-mkfont ($grub_build_mkfont_excuse)])
1562   fi
1563 fi
1564
1565 AC_SUBST([build_freetype_cflags])
1566 AC_SUBST([build_freetype_libs])
1567
1568 CC="$SAVED_CC"
1569 CPP="$SAVED_CPP"
1570 CFLAGS="$SAVED_CFLAGS"
1571 CPPFLAGS="$SAVED_CPPFLAGS"
1572 LDFLAGS="$SAVED_LDFLAGS"
1573
1574
1575 DJVU_FONT_SOURCE=
1576
1577 starfield_excuse=
1578
1579 AC_ARG_ENABLE([grub-themes],
1580               [AS_HELP_STRING([--enable-grub-themes],
1581                              [build and install GRUB themes (default=guessed)])])
1582 if test x"$enable_grub_themes" = xno ; then
1583   starfield_excuse="explicitly disabled"
1584 fi
1585
1586 if test x"$starfield_excuse" = x && test x"$enable_build_grub_mkfont" = xno ; then
1587   starfield_excuse="No build-time grub-mkfont"
1588 fi
1589
1590 if test x"$starfield_excuse" = x; then
1591    for ext in pcf pcf.gz bdf bdf.gz ttf ttf.gz; do
1592      for dir in . /usr/src /usr/share/fonts/X11/misc /usr/share/fonts/truetype/ttf-dejavu /usr/share/fonts/dejavu /usr/share/fonts/truetype; do
1593         if test -f "$dir/DejaVuSans.$ext"; then
1594           DJVU_FONT_SOURCE="$dir/DejaVuSans.$ext"
1595           break 2
1596         fi
1597      done
1598    done
1599
1600    if test "x$DJVU_FONT_SOURCE" = x; then
1601      starfield_excuse="No DejaVu found"
1602    fi
1603 fi
1604
1605 if test x"$enable_grub_themes" = xyes &&  test x"$starfield_excuse" != x; then
1606    AC_MSG_ERROR([themes were explicitly requested but requirements are not satisfied ($starfield_excuse)])
1607 fi
1608
1609 AC_SUBST([DJVU_FONT_SOURCE])
1610
1611 FONT_SOURCE=
1612
1613 for ext in pcf pcf.gz bdf bdf.gz ttf ttf.gz; do
1614   for dir in . /usr/src /usr/share/fonts/X11/misc /usr/share/fonts/unifont /usr/share/fonts/uni /usr/share/fonts/truetype/unifont /usr/share/fonts/misc; do
1615     if test -f "$dir/unifont.$ext"; then
1616       md5="$(md5sum "$dir/unifont.$ext"|awk '{ print $1; }')"
1617       # PCF and BDF from version 6.3 isn't hanled properly by libfreetype.
1618       if test "$md5" = 0a54834d2788c83886a3e1785a6a1e61 || test "$md5" = 28f2565c7a41d8d407e2551159385edb || test "$md5" = dae5e588461b3b92b87b6ffee734f936 || test "$md5" = 4a3d687aa5bb329ed05f4263a1016791 ; then
1619         continue
1620       fi
1621       FONT_SOURCE="$dir/unifont.$ext"
1622       break 2
1623     fi
1624   done
1625 done
1626
1627 if test x"$enable_build_grub_mkfont" = xno ; then
1628   FONT_SOURCE=
1629 fi
1630
1631 if test "x$FONT_SOURCE" = x && ( test "x$platform" = xqemu || test "x$platform" = xloongson || test "x$platform" = xqemu_mips || test "x$target_cpu"-"$platform" = xpowerpc-ieee1275 || test "x$platform" = xcoreboot ); then
1632   if test x"$grub_build_mkfont_excuse" = x ; then
1633     AC_MSG_ERROR([qemu, powerpc-ieee1275, coreboot and loongson ports need unifont])
1634   else
1635     AC_MSG_ERROR([qemu, powerpc-ieee1275, coreboot and loongson ports need unifont ($grub_build_mkfont_excuse)])
1636   fi
1637 fi
1638
1639 AC_SUBST([FONT_SOURCE])
1640
1641 if test x"$FONT_SOURCE" = x &&  test x"$DJVU_FONT_SOURCE" = x && test x"$grub_build_mkfont_excuse" = x; then
1642   grub_build_mkfont_excuse="no fonts"
1643 fi
1644
1645
1646 AC_ARG_ENABLE([grub-mount],
1647               [AS_HELP_STRING([--enable-grub-mount],
1648                              [build and install the `grub-mount' utility (default=guessed)])])
1649 if test x"$enable_grub_mount" = xno ; then
1650   grub_mount_excuse="explicitly disabled"
1651 fi
1652
1653 if test x"$grub_mount_excuse" = x ; then
1654   AC_CHECK_LIB([fuse], [fuse_main_real], [],
1655                [grub_mount_excuse="need FUSE library"])
1656 fi
1657
1658 if test x"$grub_mount_excuse" = x ; then
1659   # Check for fuse headers.
1660   SAVED_CPPFLAGS="$CPPFLAGS"
1661   CPPFLAGS="$CPPFLAGS -DFUSE_USE_VERSION=26"
1662   AC_CHECK_HEADERS([fuse/fuse.h], [],
1663         [grub_mount_excuse=["need FUSE headers"]])
1664   CPPFLAGS="$SAVED_CPPFLAGS"
1665 fi
1666
1667 if test x"$enable_grub_mount" = xyes && test x"$grub_mount_excuse" != x ; then
1668   AC_MSG_ERROR([grub-mount was explicitly requested but can't be compiled ($grub_mount_excuse)])
1669 fi
1670 if test x"$grub_mount_excuse" = x ; then
1671 enable_grub_mount=yes
1672 else
1673 enable_grub_mount=no
1674 fi
1675 AC_SUBST([enable_grub_mount])
1676
1677 AC_ARG_ENABLE([device-mapper],
1678               [AS_HELP_STRING([--enable-device-mapper],
1679                               [enable Linux device-mapper support (default=guessed)])])
1680 if test x"$enable_device_mapper" = xno ; then
1681   device_mapper_excuse="explicitly disabled"
1682 fi
1683
1684 if test x"$device_mapper_excuse" = x ; then
1685   # Check for device-mapper header.
1686   AC_CHECK_HEADER([libdevmapper.h], [],
1687                [device_mapper_excuse="need libdevmapper header"])
1688 fi
1689
1690 if test x"$device_mapper_excuse" = x ; then
1691   # Check for device-mapper library.
1692   AC_CHECK_LIB([devmapper], [dm_task_create], [],
1693                [device_mapper_excuse="need devmapper library"])
1694 fi
1695
1696 if test x"$device_mapper_excuse" = x ; then
1697   # Check for device-mapper library.
1698   AC_CHECK_LIB([devmapper], [dm_log_with_errno_init],
1699                [],
1700                [device_mapper_excuse="need devmapper library"])
1701 fi
1702
1703 if test x"$device_mapper_excuse" = x ; then
1704    LIBDEVMAPPER="-ldevmapper"
1705    AC_DEFINE([HAVE_DEVICE_MAPPER], [1],
1706              [Define to 1 if you have the devmapper library.])
1707 fi
1708
1709 AC_SUBST([LIBDEVMAPPER])
1710
1711 LIBGEOM=
1712 if test x$host_kernel = xkfreebsd; then
1713   AC_CHECK_LIB([geom], [geom_gettree], [],
1714                [AC_MSG_ERROR([Your platform requires libgeom])])
1715   LIBGEOM="-lgeom"
1716 fi
1717
1718 AC_SUBST([LIBGEOM])
1719
1720 AC_ARG_ENABLE([liblzma],
1721               [AS_HELP_STRING([--enable-liblzma],
1722                               [enable liblzma integration (default=guessed)])])
1723 if test x"$enable_liblzma" = xno ; then
1724   liblzma_excuse="explicitly disabled"
1725 fi
1726
1727 if test x"$liblzma_excuse" = x ; then
1728 AC_CHECK_LIB([lzma], [lzma_code],
1729              [],[liblzma_excuse="need lzma library"])
1730 fi
1731 if test x"$liblzma_excuse" = x ; then
1732 AC_CHECK_HEADER([lzma.h], [], [liblzma_excuse="need lzma header"])
1733 fi
1734
1735 if test x"$enable_liblzma" = xyes && test x"$liblzma_excuse" != x ; then
1736   AC_MSG_ERROR([liblzma support was explicitly requested but requirements are not satisfied ($liblzma_excuse)])
1737 fi
1738
1739
1740 if test x"$liblzma_excuse" = x ; then
1741    LIBLZMA="-llzma"
1742    AC_DEFINE([USE_LIBLZMA], [1],
1743              [Define to 1 if you have the LZMA library.])
1744 fi
1745
1746 AC_SUBST([LIBLZMA])
1747
1748 AC_ARG_ENABLE([libzfs],
1749               [AS_HELP_STRING([--enable-libzfs],
1750                               [enable libzfs integration (default=guessed)])])
1751 if test x"$enable_libzfs" = xno ; then
1752   libzfs_excuse="explicitly disabled"
1753 fi
1754
1755 if test x"$libzfs_excuse" = x ; then
1756   # Only check for system headers if libzfs support has not been disabled.
1757   AC_CHECK_HEADERS(libzfs.h libnvpair.h)
1758 fi
1759
1760 if test x"$libzfs_excuse" = x ; then
1761   AC_CHECK_LIB([zfs], [libzfs_init],
1762                [],
1763                [libzfs_excuse="need zfs library"])
1764 fi
1765
1766 if test x"$libzfs_excuse" = x ; then
1767   AC_CHECK_LIB([nvpair], [nvlist_lookup_string],
1768                [],
1769                [libzfs_excuse="need nvpair library"])
1770 fi
1771
1772 if test x"$enable_libzfs" = xyes && test x"$libzfs_excuse" != x ; then
1773   AC_MSG_ERROR([libzfs support was explicitly requested but requirements are not satisfied ($libzfs_excuse)])
1774 fi
1775
1776 if test x"$libzfs_excuse" = x ; then
1777   # We need both libzfs and libnvpair for a successful build.
1778   LIBZFS="-lzfs"
1779   AC_DEFINE([HAVE_LIBZFS], [1],
1780             [Define to 1 if you have the ZFS library.])
1781   LIBNVPAIR="-lnvpair"
1782   AC_DEFINE([HAVE_LIBNVPAIR], [1],
1783             [Define to 1 if you have the NVPAIR library.])
1784 fi
1785
1786 AC_SUBST([LIBZFS])
1787 AC_SUBST([LIBNVPAIR])
1788
1789 LIBS=""
1790
1791 AC_SUBST([FONT_SOURCE])
1792 AS_IF([test x$target_cpu = xi386 -a x$platform = xqemu],
1793             [AC_SUBST([GRUB_BOOT_MACHINE_LINK_ADDR], 0xffe00)])
1794
1795 AC_SUBST(HAVE_ASM_USCORE)
1796 AC_SUBST(BSS_START_SYMBOL)
1797 AC_SUBST(END_SYMBOL)
1798 AC_SUBST(PACKAGE)
1799 AC_SUBST(VERSION)
1800
1801 AC_ARG_ENABLE([werror],
1802               [AS_HELP_STRING([--disable-werror],
1803                              [do not use -Werror when building GRUB])])
1804 if test x"$enable_werror" != xno ; then
1805   TARGET_CFLAGS="$TARGET_CFLAGS -Werror"
1806   HOST_CFLAGS="$HOST_CFLAGS -Werror"
1807 fi
1808
1809 TARGET_CPP="$TARGET_CC -E"
1810 TARGET_CCAS=$TARGET_CC
1811
1812 # Includes which include make-time substitutions. They must come last
1813 # as to avoid executing top_builddir in shell.
1814 HOST_CPPFLAGS="$HOST_CPPFLAGS -I\$(top_builddir)/include"
1815 TARGET_CPPFLAGS="$TARGET_CPPFLAGS -I\$(top_srcdir)/include"
1816 TARGET_CPPFLAGS="$TARGET_CPPFLAGS -I\$(top_builddir)/include"
1817
1818 GRUB_TARGET_CPU="${target_cpu}"
1819 GRUB_PLATFORM="${platform}"
1820
1821 AC_SUBST(GRUB_TARGET_CPU)
1822 AC_SUBST(GRUB_PLATFORM)
1823
1824 AC_SUBST(TARGET_OBJCONV)
1825 AC_SUBST(TARGET_CPP)
1826 AC_SUBST(TARGET_CCAS)
1827 AC_SUBST(TARGET_OBJ2ELF)
1828 AC_SUBST(TARGET_MODULE_FORMAT)
1829 AC_SUBST(TARGET_CC_VERSION)
1830
1831 AC_SUBST(TARGET_CFLAGS)
1832 AC_SUBST(TARGET_LDFLAGS)
1833 AC_SUBST(TARGET_CPPFLAGS)
1834 AC_SUBST(TARGET_CCASFLAGS)
1835
1836 AC_SUBST(TARGET_IMG_LDFLAGS)
1837 AC_SUBST(TARGET_IMG_CFLAGS)
1838 AC_SUBST(TARGET_IMG_BASE_LDOPT)
1839 AC_SUBST(TARGET_APPLE_LINKER)
1840
1841 AC_SUBST(HOST_CFLAGS)
1842 AC_SUBST(HOST_LDFLAGS)
1843 AC_SUBST(HOST_CPPFLAGS)
1844 AC_SUBST(HOST_CCASFLAGS)
1845
1846 AC_SUBST(BUILD_LIBM)
1847
1848 #
1849 # Automake conditionals
1850 #
1851
1852 AM_CONDITIONAL([COND_real_platform], [test x$platform != xnone])
1853 AM_CONDITIONAL([COND_emu], [test x$platform = xemu])
1854 AM_CONDITIONAL([COND_i386_pc], [test x$target_cpu = xi386 -a x$platform = xpc])
1855 AM_CONDITIONAL([COND_i386_efi], [test x$target_cpu = xi386 -a x$platform = xefi])
1856 AM_CONDITIONAL([COND_ia64_efi], [test x$target_cpu = xia64 -a x$platform = xefi])
1857 AM_CONDITIONAL([COND_i386_qemu], [test x$target_cpu = xi386 -a x$platform = xqemu])
1858 AM_CONDITIONAL([COND_i386_ieee1275], [test x$target_cpu = xi386 -a x$platform = xieee1275])
1859 AM_CONDITIONAL([COND_i386_coreboot], [test x$target_cpu = xi386 -a x$platform = xcoreboot])
1860 AM_CONDITIONAL([COND_i386_multiboot], [test x$target_cpu = xi386 -a x$platform = xmultiboot])
1861 AM_CONDITIONAL([COND_x86_64_efi], [test x$target_cpu = xx86_64 -a x$platform = xefi])
1862 AM_CONDITIONAL([COND_i386_xen], [test x$target_cpu = xi386 -a x$platform = xxen])
1863 AM_CONDITIONAL([COND_x86_64_xen], [test x$target_cpu = xx86_64 -a x$platform = xxen])
1864 AM_CONDITIONAL([COND_mips_loongson], [test x$target_cpu = xmipsel -a x$platform = xloongson])
1865 AM_CONDITIONAL([COND_mips_qemu_mips], [test "(" x$target_cpu = xmips -o x$target_cpu = xmipsel ")"  -a x$platform = xqemu_mips])
1866 AM_CONDITIONAL([COND_mips_arc], [test "(" x$target_cpu = xmips -o x$target_cpu = xmipsel ")"  -a x$platform = xarc])
1867 AM_CONDITIONAL([COND_sparc64_ieee1275], [test x$target_cpu = xsparc64 -a x$platform = xieee1275])
1868 AM_CONDITIONAL([COND_sparc64_emu], [test x$target_cpu = xsparc64 -a x$platform = xemu])
1869 AM_CONDITIONAL([COND_powerpc_ieee1275], [test x$target_cpu = xpowerpc -a x$platform = xieee1275])
1870 AM_CONDITIONAL([COND_mips], [test x$target_cpu = xmips -o x$target_cpu = xmipsel])
1871 AM_CONDITIONAL([COND_mipsel], [test x$target_cpu = xmipsel])
1872 AM_CONDITIONAL([COND_mipseb], [test x$target_cpu = xmips])
1873 AM_CONDITIONAL([COND_arm], [test x$target_cpu = xarm ])
1874 AM_CONDITIONAL([COND_arm_uboot], [test x$target_cpu = xarm -a x$platform = xuboot])
1875 AM_CONDITIONAL([COND_arm_efi], [test x$target_cpu = xarm -a x$platform = xefi])
1876 AM_CONDITIONAL([COND_arm64], [test x$target_cpu = xarm64 ])
1877 AM_CONDITIONAL([COND_arm64_efi], [test x$target_cpu = xarm64 -a x$platform = xefi])
1878
1879 AM_CONDITIONAL([COND_HOST_HURD], [test x$host_kernel = xhurd])
1880 AM_CONDITIONAL([COND_HOST_LINUX], [test x$host_kernel = xlinux])
1881 AM_CONDITIONAL([COND_HOST_NETBSD], [test x$host_kernel = xnetbsd])
1882 AM_CONDITIONAL([COND_HOST_WINDOWS], [test x$host_kernel = xwindows])
1883 AM_CONDITIONAL([COND_HOST_KFREEBSD], [test x$host_kernel = xkfreebsd])
1884 AM_CONDITIONAL([COND_HOST_XNU], [test x$host_kernel = xxnu])
1885 AM_CONDITIONAL([COND_HOST_ILLUMOS], [test x$host_kernel = xillumos])
1886
1887 AM_CONDITIONAL([COND_MAN_PAGES], [test x$cross_compiling = xno -a x$HELP2MAN != x])
1888 AM_CONDITIONAL([COND_GRUB_EMU_SDL], [test x$enable_grub_emu_sdl = xyes])
1889 AM_CONDITIONAL([COND_GRUB_EMU_PCI], [test x$enable_grub_emu_pci = xyes])
1890 AM_CONDITIONAL([COND_GRUB_MKFONT], [test x$enable_grub_mkfont = xyes])
1891 AM_CONDITIONAL([COND_GRUB_MOUNT], [test x$enable_grub_mount = xyes])
1892 AM_CONDITIONAL([COND_HAVE_FONT_SOURCE], [test x$FONT_SOURCE != x])
1893 if test x$FONT_SOURCE != x ; then
1894    HAVE_FONT_SOURCE=1
1895 else
1896    HAVE_FONT_SOURCE=0
1897 fi
1898 AC_SUBST(HAVE_FONT_SOURCE)
1899 AM_CONDITIONAL([COND_APPLE_LINKER], [test x$TARGET_APPLE_LINKER = x1])
1900 AM_CONDITIONAL([COND_ENABLE_EFIEMU], [test x$enable_efiemu = xyes])
1901 AM_CONDITIONAL([COND_ENABLE_CACHE_STATS], [test x$DISK_CACHE_STATS = x1])
1902 AM_CONDITIONAL([COND_ENABLE_BOOT_TIME_STATS], [test x$BOOT_TIME_STATS = x1])
1903
1904 AM_CONDITIONAL([COND_HAVE_CXX], [test x$HAVE_CXX = xyes])
1905
1906 AM_CONDITIONAL([COND_HAVE_ASM_USCORE], [test x$HAVE_ASM_USCORE = x1])
1907 AM_CONDITIONAL([COND_STARFIELD], [test "x$starfield_excuse" = x])
1908 AM_CONDITIONAL([COND_HAVE_EXEC], [test "x$have_exec" = xy])
1909
1910 test "x$prefix" = xNONE && prefix="$ac_default_prefix"
1911 test "x$exec_prefix" = xNONE && exec_prefix="${prefix}"
1912 datarootdir="$(eval echo "$datarootdir")"
1913 grub_libdir="$(eval echo "$libdir")"
1914 grub_localedir="$(eval echo "$localedir")"
1915 grub_datadir="$(eval echo "$datadir")"
1916 grub_sysconfdir="$(eval echo "$sysconfdir")"
1917 AC_DEFINE_UNQUOTED(LOCALEDIR, "$grub_localedir", [Locale dir])
1918 AC_DEFINE_UNQUOTED(GRUB_LIBDIR, "$grub_libdir", [Library dir])
1919 AC_DEFINE_UNQUOTED(GRUB_DATADIR, "$grub_datadir", [Data dir])
1920 AC_DEFINE_UNQUOTED(GRUB_SYSCONFDIR, "$grub_sysconfdir", [Configuration dir])
1921
1922
1923 # Output files.
1924 if test "$platform" != none; then
1925   cpudir="${target_cpu}"
1926   if test x${cpudir} = xmipsel; then
1927     cpudir=mips;
1928   fi
1929   grub_CHECK_LINK_DIR
1930   if test x"$link_dir" = xyes ; then
1931     AC_CONFIG_LINKS([include/grub/cpu:include/grub/$cpudir])
1932     if test "$platform" != emu ; then
1933       AC_CONFIG_LINKS([include/grub/machine:include/grub/$cpudir/$platform])
1934     fi
1935   else
1936     mkdir -p include/grub 2>/dev/null
1937     rm -rf include/grub/cpu
1938     cp -rp $srcdir/include/grub/$cpudir include/grub/cpu 2>/dev/null
1939     if test "$platform" != emu ; then
1940       rm -rf include/grub/machine
1941       cp -rp $srcdir/include/grub/$cpudir/$platform include/grub/machine 2>/dev/null
1942     fi
1943   fi
1944 else
1945   # Just enough to stop the compiler failing with -I$(srcdir)/include.
1946   mkdir -p include 2>/dev/null
1947   rm -rf include/grub/cpu include/grub/machine
1948 fi
1949
1950 AC_CONFIG_FILES([Makefile])
1951 AC_CONFIG_FILES([grub-core/Makefile])
1952 AC_CONFIG_FILES([grub-core/gnulib/Makefile])
1953 AC_CONFIG_FILES([po/Makefile.in])
1954 AC_CONFIG_FILES([docs/Makefile])
1955 AC_CONFIG_FILES([util/bash-completion.d/Makefile])
1956 AC_CONFIG_FILES([stamp-h], [echo timestamp > stamp-h])
1957 AC_CONFIG_FILES([config.h])
1958
1959 AC_OUTPUT
1960 [
1961 echo "*******************************************************"
1962 echo GRUB2 will be compiled with following components:
1963 echo Platform: "$target_cpu"-"$platform"
1964 if [ x"$platform" = xemu ]; then
1965 if [ x"$grub_emu_sdl_excuse" = x ]; then
1966 echo SDL support for grub-emu: Yes
1967 else
1968 echo SDL support for grub-emu: No "($grub_emu_sdl_excuse)"
1969 fi
1970 if [ x"$grub_emu_pci_excuse" = x ]; then
1971 echo PCI support for grub-emu: Yes
1972 else
1973 echo PCI support for grub-emu: No "($grub_emu_pci_excuse)"
1974 fi
1975 fi
1976 if test x"$device_mapper_excuse" = x ; then
1977 echo With devmapper support: Yes
1978 else
1979 echo With devmapper support: No "($device_mapper_excuse)"
1980 fi
1981 if [ x"$enable_mm_debug" = xyes ]; then
1982 echo With memory debugging: Yes
1983 else
1984 echo With memory debugging: No
1985 fi
1986 if [ x"$enable_cache_stats" = xyes ]; then
1987 echo With disk cache statistics: Yes
1988 else
1989 echo With disk cache statistics: No
1990 fi
1991
1992 if [ x"$enable_boot_time" = xyes ]; then
1993 echo With boot time statistics: Yes
1994 else
1995 echo With boot time statistics: No
1996 fi
1997
1998 if [ x"$efiemu_excuse" = x ]; then
1999 echo efiemu runtime: Yes
2000 else
2001 echo efiemu runtime: No "($efiemu_excuse)"
2002 fi
2003 if [ x"$grub_mkfont_excuse" = x ]; then
2004 echo grub-mkfont: Yes
2005 else
2006 echo grub-mkfont: No "($grub_mkfont_excuse)"
2007 fi
2008 if [ x"$grub_mount_excuse" = x ]; then
2009 echo grub-mount: Yes
2010 else
2011 echo grub-mount: No "($grub_mount_excuse)"
2012 fi
2013 if [ x"$starfield_excuse" = x ]; then
2014 echo starfield theme: Yes
2015 echo With DejaVuSans font from $DJVU_FONT_SOURCE
2016 else
2017 echo starfield theme: No "($starfield_excuse)"
2018 fi
2019 if [ x"$libzfs_excuse" = x ]; then
2020 echo With libzfs support: Yes
2021 else
2022 echo With libzfs support: No "($libzfs_excuse)"
2023 fi
2024 if [ x"$grub_build_mkfont_excuse" = x ]; then
2025   echo Build-time grub-mkfont: Yes
2026   if test "x$FONT_SOURCE" = x ; then
2027     echo "Without unifont"
2028   else
2029     echo "With unifont from $FONT_SOURCE"
2030   fi
2031 else
2032   echo Build-time grub-mkfont: No "($grub_build_mkfont_excuse)"
2033   echo "Without unifont (no build-time grub-mkfont)"
2034 fi
2035 if test x"$liblzma_excuse" != x ; then
2036 echo "Without liblzma (no support for XZ-compressed mips images) ($liblzma_excuse)"
2037 else
2038 echo "With liblzma from $LIBLZMA (support for XZ-compressed mips images)"
2039 fi
2040 echo "*******************************************************"
2041 ]