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 limits.h)
 392
 393 # glibc 2.25 still includes sys/sysmacros.h in sys/types.h but emits deprecation
 394 # warning which causes compilation failure later with -Werror. So use -Werror here
 395 # as well to force proper sys/sysmacros.h detection.
 396 SAVED_CFLAGS="$CFLAGS"
 397 CFLAGS="$HOST_CFLAGS -Werror"
 398 AC_HEADER_MAJOR
 399 CFLAGS="$SAVED_CFLAGS"
 400
 401 AC_CHECK_MEMBERS([struct statfs.f_fstypename],,,[$ac_includes_default
 402 #include <sys/param.h>
 403 #include <sys/mount.h>])
 404
 405 AC_CHECK_MEMBERS([struct statfs.f_mntfromname],,,[$ac_includes_default
 406 #include <sys/param.h>
 407 #include <sys/mount.h>])
 408
 409 # For opendisk() and getrawpartition() on NetBSD.
 410 # Used in util/deviceiter.c and in util/hostdisk.c.
 411 AC_CHECK_HEADER([util.h], [
 412   AC_CHECK_LIB([util], [opendisk], [
 413     LIBUTIL="-lutil"
 414     AC_DEFINE(HAVE_OPENDISK, 1, [Define if opendisk() in -lutil can be used])
 415   ])
 416   AC_CHECK_LIB([util], [getrawpartition], [
 417     LIBUTIL="-lutil"
 418     AC_DEFINE(HAVE_GETRAWPARTITION, 1, [Define if getrawpartition() in -lutil can be used])
 419   ])
 420 ])
 421 AC_SUBST([LIBUTIL])
 422
 423 AC_CACHE_CHECK([whether -Wtrampolines work], [grub_cv_host_cc_wtrampolines], [
 424   SAVED_CFLAGS="$CFLAGS"
 425   CFLAGS="$HOST_CFLAGS -Wtrampolines -Werror"
 426   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <stdarg.h>
 427 int va_arg_func (int fixed, va_list args);]], [[]])],
 428       [grub_cv_host_cc_wtrampolines=yes],
 429       [grub_cv_host_cc_wtrampolines=no])
 430   CFLAGS="$SAVED_CFLAGS"
 431 ])
 432
 433 if test x"$grub_host_cv_cc_wtrampolines" = xyes ; then
 434   HOST_CFLAGS="$HOST_CFLAGS -Wtrampolines"
 435 fi
 436
 437 #
 438 # Check for host and build compilers.
 439 #
 440 HOST_CC=$CC
 441 AC_CHECK_PROGS(BUILD_CC, [gcc egcs cc])
 442 test -z "$BUILD_CC" && AC_MSG_ERROR([none of gcc, egcs and cc is found. set BUILD_CC manually.])
 443 BUILD_CPP="$BUILD_CC -E"
 444
 445 case "$build_os" in
 446   haiku*)                               BUILD_LIBM= ;;
 447   *)                                    BUILD_LIBM=-lm ;;
 448 esac
 449
 450 dnl FIXME proper test seems to require too deep dive into Autoconf internals.
 451 dnl For now just list known platforms that we support.
 452
 453 case "$build_os" in
 454   cygwin*|mingw32*|mingw64*)            BUILD_EXEEXT=.exe ;;
 455   *)                                    BUILD_EXEEXT= ;;
 456 esac
 457 AC_SUBST(BUILD_EXEEXT)
 458
 459 # For gnulib.
 460 gl_INIT
 461
 462 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"
 463 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"
 464
 465 HOST_CFLAGS="$HOST_CFLAGS $WARN_FLAGS -Wcast-align"
 466
 467 AC_CACHE_CHECK([which extra warnings work], [grub_cv_cc_w_extra_flags], [
 468   SAVED_CFLAGS="$CFLAGS"
 469   grub_cv_cc_w_extra_flags=
 470   for x in $EXTRA_WARN_FLAGS; do
 471       CFLAGS="$HOST_CFLAGS $x -Werror"
 472       AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[]])], [flag=1], [flag=0])
 473       if test x$flag = x1 ; then
 474          grub_cv_cc_w_extra_flags="$grub_cv_cc_w_extra_flags $x"
 475       fi
 476   done
 477   CFLAGS="$SAVED_CFLAGS"
 478 ])
 479
 480 HOST_CFLAGS="$HOST_CFLAGS $grub_cv_cc_w_extra_flags"
 481
 482 #
 483 # Check for target programs.
 484 #
 485
 486 # Find tools for the target.
 487 if test "x$target_alias" != x && test "x$host_alias" != "x$target_alias"; then
 488   tmp_ac_tool_prefix="$ac_tool_prefix"
 489   ac_tool_prefix=$target_alias-
 490
 491   AC_CHECK_TOOLS(TARGET_CC, [gcc egcs cc],
 492                  [AC_MSG_ERROR([none of gcc, egcs and cc is found. set TARGET_CC manually.])])
 493   AC_CHECK_TOOL(TARGET_OBJCOPY, objcopy)
 494   AC_CHECK_TOOL(TARGET_STRIP, strip)
 495   AC_CHECK_TOOL(TARGET_NM, nm)
 496   AC_CHECK_TOOL(TARGET_RANLIB, ranlib)
 497
 498   ac_tool_prefix="$tmp_ac_tool_prefix"
 499 else
 500   if test "x$TARGET_CC" = x; then
 501     TARGET_CC=$CC
 502   fi
 503   AC_CHECK_TOOL(TARGET_OBJCOPY, objcopy)
 504   AC_CHECK_TOOL(TARGET_STRIP, strip)
 505   AC_CHECK_TOOL(TARGET_NM, nm)
 506   AC_CHECK_TOOL(TARGET_RANLIB, ranlib)
 507 fi
 508
 509 AC_SUBST(HOST_CC)
 510 AC_SUBST(BUILD_CC)
 511 AC_SUBST(BUILD_CFLAGS)
 512 AC_SUBST(BUILD_CPPFLAGS)
 513 AC_SUBST(BUILD_LDFLAGS)
 514 AC_SUBST(TARGET_CC)
 515 AC_SUBST(TARGET_NM)
 516 AC_SUBST(TARGET_RANLIB)
 517 AC_SUBST(TARGET_STRIP)
 518 AC_SUBST(TARGET_OBJCOPY)
 519
 520 # Test the C compiler for the target environment.
 521 tmp_CC="$CC"
 522 tmp_CFLAGS="$CFLAGS"
 523 tmp_LDFLAGS="$LDFLAGS"
 524 tmp_CPPFLAGS="$CPPFLAGS"
 525 tmp_LIBS="$LIBS"
 526 CC="$TARGET_CC"
 527 CFLAGS="$TARGET_CFLAGS"
 528 CPPFLAGS="$TARGET_CPPFLAGS"
 529 LDFLAGS="$TARGET_LDFLAGS"
 530 LIBS=""
 531
 532 # debug flags.
 533 TARGET_CFLAGS="$TARGET_CFLAGS $WARN_FLAGS -g -Wredundant-decls -Wmissing-prototypes -Wmissing-declarations"
 534 TARGET_CCASFLAGS="$TARGET_CCASFLAGS -g"
 535
 536 if test "x$target_cpu" != xi386 && test "x$target_cpu" != xx86_64; then
 537 TARGET_CFLAGS="$TARGET_CFLAGS -Wcast-align"
 538 fi
 539
 540 TARGET_CC_VERSION="$(LC_ALL=C $TARGET_CC --version | head -n1)"
 541
 542 AC_CACHE_CHECK([which extra warnings work], [grub_cv_target_cc_w_extra_flags], [
 543   LDFLAGS="$TARGET_LDFLAGS -nostdlib -static"
 544
 545   grub_cv_target_cc_w_extra_flags=
 546   for x in $EXTRA_WARN_FLAGS; do
 547       CFLAGS="$TARGET_CFLAGS $x -Werror"
 548       AC_LINK_IFELSE([AC_LANG_PROGRAM([[
 549 asm (".globl start; start:");
 550 void __main (void);
 551 void __main (void) {}
 552 int main (void);
 553 ]], [[]])], [flag=1], [flag=0])
 554       if test x$flag = x1 ; then
 555          grub_cv_target_cc_w_extra_flags="$grub_cv_target_cc_w_extra_flags $x"
 556       fi
 557   done
 558 ])
 559
 560 TARGET_CFLAGS="$TARGET_CFLAGS $grub_cv_target_cc_w_extra_flags"
 561
 562 AC_CACHE_CHECK([if compiling with clang], [grub_cv_cc_target_clang],
 563 [
 564 CFLAGS="$TARGET_CFLAGS"
 565 AC_COMPILE_IFELSE(
 566 [AC_LANG_PROGRAM([], [[
 567 #ifdef __clang__
 568 #error "is clang"
 569 #endif
 570 ]])],
 571 [grub_cv_cc_target_clang=no], [grub_cv_cc_target_clang=yes])])
 572
 573 if test x$target_cpu = xpowerpc -o x$target_cpu = xmips; then
 574   AC_CACHE_CHECK([for options to get big-endian compilation], grub_cv_target_cc_big_endian, [
 575     grub_cv_target_cc_big_endian=no
 576     for cand in "-target $target_cpu -Wl,-EB" "-target $target_cpu" \
 577                 "-target $target_cpu-linux-gnu -Wl,-EB" "-target $target_cpu-linux-gnu" \
 578                 "-EB" "-mbig-endian"; do
 579       if test x"$grub_cv_target_cc_big_endian" != xno ; then
 580         break
 581       fi
 582       CFLAGS="$TARGET_CFLAGS $cand -Werror"
 583       AC_LINK_IFELSE([AC_LANG_PROGRAM([[
 584 #if defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && (__ORDER_BIG_ENDIAN__ != __BYTE_ORDER__)
 585 #error still little endian
 586 #endif
 587 asm (".globl start; start:");
 588 asm (".globl _start; _start:");
 589 asm (".globl __start; __start:");
 590 void __main (void);
 591 void __main (void) {}
 592 int main (void);
 593 ]], [[]])],
 594                         [grub_cv_target_cc_big_endian="$cand"], [])
 595     done
 596   ])
 597
 598   if test x"$grub_cv_target_cc_big_endian" = xno ; then
 599     AC_MSG_ERROR([could not force big-endian])
 600   fi
 601
 602   skip_linkflags="$(echo "$grub_cv_target_cc_big_endian"|sed 's@-Wl,-EB@@')"
 603
 604   TARGET_CFLAGS="$TARGET_CFLAGS $skip_linkflags"
 605   TARGET_CPPFLAGS="$TARGET_CPPFLAGS $skip_linkflags"
 606   TARGET_CCASFLAGS="$TARGET_CCASFLAGS $skip_linkflags"
 607   TARGET_LDFLAGS="$TARGET_LDFLAGS $grub_cv_target_cc_big_endian"
 608 elif test x$target_cpu = xmipsel; then
 609   AC_CACHE_CHECK([for options to get little-endian compilation], grub_cv_target_cc_little_endian, [
 610     grub_cv_target_cc_little_endian=no
 611     for cand in "-target $target_cpu -Wl,-EL" "-target $target_cpu" \
 612                 "-target $target_cpu-linux-gnu -Wl,-EL" "-target $target_cpu-linux-gnu" \
 613                 "-EL"; do
 614       if test x"$grub_cv_target_cc_little_endian" != xno ; then
 615         break
 616       fi
 617       CFLAGS="$TARGET_CFLAGS $cand -Werror"
 618       AC_LINK_IFELSE([AC_LANG_PROGRAM([[
 619 #if defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && (__ORDER_BIG_ENDIAN__ == __BYTE_ORDER__)
 620 #error still big endian
 621 #endif
 622 asm (".globl start; start:");
 623 asm (".globl _start; _start:");
 624 asm (".globl __start; __start:");
 625 void __main (void);
 626 void __main (void) {}
 627 int main (void);
 628 ]], [[]])],
 629                         [grub_cv_target_cc_little_endian="$cand"], [])
 630     done
 631   ])
 632
 633   if test x"$grub_cv_target_cc_little_endian" = xno ; then
 634     AC_MSG_ERROR([could not force little-endian])
 635   fi
 636
 637   skip_linkflags="$(echo "$grub_cv_target_cc_little_endian"|sed 's@-Wl,-EL@@')"
 638
 639   TARGET_CFLAGS="$TARGET_CFLAGS $skip_linkflags"
 640   TARGET_CPPFLAGS="$TARGET_CPPFLAGS $skip_linkflags"
 641   TARGET_CCASFLAGS="$TARGET_CCASFLAGS $skip_linkflags"
 642   TARGET_LDFLAGS="$TARGET_LDFLAGS $grub_cv_target_cc_little_endian"
 643 fi
 644
 645 # GRUB code is N32-compliant but it's experimental and we would prefer to
 646 # avoid having too much variety when it doesn't result in any real improvement.
 647 # Moreover N64 isn't supported.
 648 if test "x$target_cpu" = xmips || test "x$target_cpu" = xmipsel ; then
 649   AC_CACHE_CHECK([for options to force MIPS o32 ABI], grub_cv_target_cc_mips_o32_abi, [
 650     grub_cv_target_cc_mips_o32_abi=no
 651     for arg in "" "-mabi=32" "-target $target_cpu -mabi=32" ; do
 652       if test x"$grub_cv_target_cc_mips_o32_abi" != xno ; then
 653         break
 654       fi
 655       CFLAGS="$TARGET_CFLAGS $arg -Werror"
 656       AC_LINK_IFELSE([AC_LANG_PROGRAM([[
 657 #if !defined(_ABIO32) || !defined(_MIPS_SIM) || (_MIPS_SIM != _ABIO32)
 658 #error not o32 ABI
 659 #endif
 660 asm (".globl start; start:");
 661 asm (".globl _start; _start:");
 662 asm (".globl __start; __start:");
 663 void __main (void);
 664 void __main (void) {}
 665 int main (void);
 666 ]], [[]])],
 667                         [grub_cv_target_cc_mips_o32_abi="$arg"], [])
 668     done
 669   ])
 670
 671   if test x"$grub_cv_target_cc_mips_o32_abi" = xno ; then
 672     AC_MSG_ERROR([could not force MIPS o32 ABI])
 673   fi
 674
 675   TARGET_CFLAGS="$TARGET_CFLAGS $grub_cv_target_cc_mips_o32_abi"
 676   TARGET_CCASFLAGS="$TARGET_CCASFLAGS $grub_cv_target_cc_mips_o32_abi"
 677 fi
 678
 679 AC_CACHE_CHECK([for options to compile assembly], [grub_cv_cc_target_asm_compile], [
 680 test_program=
 681 case "x$target_cpu-$platform" in
 682      xmips-* | xmipsel-*)
 683         test_program=mips
 684         ;;
 685      xi386-pc)
 686        test_program=i386-pc
 687         ;;
 688      xi386-* | xx86_64-*)
 689        test_program=i386
 690         ;;
 691      xpowerpc-* | xsparc64-* | xarm-*)
 692         test_program=$target_cpu
 693         ;;
 694 esac
 695 if test x"$test_program" = x ; then
 696   grub_cv_cc_target_asm_compile=
 697 else
 698   found=no
 699   for arg in "" "-no-integrated-as"; do
 700     cmdline="$TARGET_CC -c -o /dev/null $TARGET_CCASFLAGS $arg $TARGET_CPPFLAGS $srcdir/asm-tests/$test_program.S"
 701     echo "Running $cmdline" >&AS_MESSAGE_LOG_FD
 702     if $cmdline >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD; then
 703       grub_cv_cc_target_asm_compile="$arg"
 704       found=yes
 705       break
 706     fi
 707   done
 708   if test x"$found" = xno ; then
 709     AC_MSG_ERROR([could not compile assembly])
 710   fi
 711 fi
 712 ])
 713
 714 TARGET_CCASFLAGS="$TARGET_CCASFLAGS $grub_cv_cc_target_asm_compile"
 715
 716 if test "x$target_cpu" = xi386 && test "x$platform" != xemu; then
 717   TARGET_CFLAGS="$TARGET_CFLAGS -march=i386"
 718 fi
 719
 720 if test "x$target_m32" = x1; then
 721   # Force 32-bit mode.
 722   TARGET_CFLAGS="$TARGET_CFLAGS -m32"
 723   TARGET_CCASFLAGS="$TARGET_CCASFLAGS -m32"
 724   TARGET_CPPFLAGS="$TARGET_CPPFLAGS -m32"
 725   TARGET_LDFLAGS="$TARGET_LDFLAGS -m32"
 726   TARGET_MODULE_FORMAT="elf32"
 727 fi
 728
 729 if test "x$target_m64" = x1; then
 730   # Force 64-bit mode.
 731   TARGET_CFLAGS="$TARGET_CFLAGS -m64"
 732   TARGET_CCASFLAGS="$TARGET_CCASFLAGS -m64"
 733   TARGET_CPPFLAGS="$TARGET_CPPFLAGS -m64"
 734   TARGET_LDFLAGS="$TARGET_LDFLAGS -m64"
 735   TARGET_MODULE_FORMAT="elf64"
 736 fi
 737
 738 if test "x$grub_cv_cc_target_clang" = xno && test "x$target_cpu" = xi386 && test "x$platform" != xemu && test "x$platform" != xefi; then
 739    TARGET_CFLAGS="$TARGET_CFLAGS -mrtd -mregparm=3"
 740 fi
 741
 742 # on mips redirect cache flushing function to non-existant one.
 743 if test "x$target_cpu" = xmips || test "x$target_cpu" = xmipsel ; then
 744   AC_CACHE_CHECK([whether -mflush-func=grub_red_herring works], [grub_cv_cc_mflush_func], [
 745     CFLAGS="$TARGET_CFLAGS -mflush-func=grub_red_herring -Werror"
 746     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 747         [grub_cv_cc_mflush_func=yes],
 748         [grub_cv_cc_mflush_func=no])
 749   ])
 750
 751   if test "x$grub_cv_cc_mflush_func" = xyes; then
 752     TARGET_CFLAGS="$TARGET_CFLAGS -mflush-func=grub_red_herring"
 753   fi
 754 fi
 755
 756
 757 # Force no alignment to save space on i386.
 758 if test "x$target_cpu" = xi386; then
 759   AC_CACHE_CHECK([whether -falign-loops works], [grub_cv_cc_falign_loop], [
 760     CFLAGS="$TARGET_CFLAGS -falign-loops=1 -Werror"
 761     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 762         [grub_cv_cc_falign_loop=yes],
 763         [grub_cv_cc_falign_loop=no])
 764   ])
 765
 766   AC_CACHE_CHECK([whether -malign-loops works], [grub_cv_cc_malign_loop], [
 767     CFLAGS="$TARGET_CFLAGS -malign-loops=1 -Werror"
 768     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 769         [grub_cv_cc_malign_loop=yes],
 770         [grub_cv_cc_malign_loop=no])
 771   ])
 772
 773   if test "x$grub_cv_cc_falign_loop" = xyes; then
 774     TARGET_CFLAGS="$TARGET_CFLAGS -falign-jumps=1 -falign-loops=1 -falign-functions=1"
 775   elif test "x$grub_cv_cc_malign_loop" = xyes; then
 776     TARGET_CFLAGS="$TARGET_CFLAGS -malign-jumps=1 -malign-loops=1 -malign-functions=1"
 777   fi
 778 fi
 779
 780 AC_CACHE_CHECK([whether -freg-struct-return works], [grub_cv_cc_freg_struct_return], [
 781     CFLAGS="$TARGET_CFLAGS -freg-struct-return -Werror"
 782     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 783         [grub_cv_cc_freg_struct_return=yes],
 784         [grub_cv_cc_freg_struct_return=no])
 785 ])
 786
 787 if test "x$grub_cv_cc_freg_struct_return" = xyes; then
 788     TARGET_CFLAGS="$TARGET_CFLAGS -freg-struct-return"
 789 fi
 790
 791 if ( test "x$target_cpu" = xi386 || test "x$target_cpu" = xx86_64 ) && test "x$platform" != xemu; then
 792   # Some toolchains enable these features by default, but they need
 793   # registers that aren't set up properly in GRUB.
 794   TARGET_CFLAGS="$TARGET_CFLAGS -mno-mmx -mno-sse -mno-sse2 -mno-sse3 -mno-3dnow"
 795 fi
 796
 797 # GRUB doesn't use float or doubles at all. Yet some toolchains may decide
 798 # that floats are a good fit to run instead of what's written in the code.
 799 # Given that floating point unit is disabled (if present to begin with)
 800 # when GRUB is running which may result in various hard crashes.
 801 if test x"$platform" != xemu ; then
 802   AC_CACHE_CHECK([for options to get soft-float], grub_cv_target_cc_soft_float, [
 803     grub_cv_target_cc_soft_float=no
 804     if test "x$target_cpu" = xarm64; then
 805        CFLAGS="$TARGET_CFLAGS -mgeneral-regs-only -Werror"
 806        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 807                          [grub_cv_target_cc_soft_float="-mgeneral-regs-only"], [])
 808     fi
 809     if test "x$target_cpu" = xia64; then
 810        CFLAGS="$TARGET_CFLAGS -mno-inline-float-divide -mno-inline-sqrt -Werror"
 811        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 812                          [grub_cv_target_cc_soft_float="-mno-inline-float-divide -mno-inline-sqrt"], [])
 813     fi
 814     for cand in "-msoft-float -Xclang -msoft-float -Xclang -no-implicit-float" \
 815                 "-Xclang -msoft-float -Xclang -no-implicit-float" \
 816                 "-Xclang -msoft-float" "-msoft-float"; do
 817       if test x"$grub_cv_target_cc_soft_float" != xno ; then
 818         break
 819       fi
 820       CFLAGS="$TARGET_CFLAGS $cand -Werror"
 821       AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 822                         [grub_cv_target_cc_soft_float="$cand"], [])
 823     done
 824   ])
 825
 826   if test x"$grub_cv_target_cc_soft_float" = xno ; then
 827     AC_MSG_ERROR([could not force soft-float])
 828   fi
 829
 830   case x"$grub_cv_target_cc_soft_float" in
 831     x*"-Xclang"*)
 832       # A trick so that clang doesn't see it on link stаge
 833       TARGET_CPPFLAGS="$TARGET_CPPFLAGS $grub_cv_target_cc_soft_float"
 834       ;;
 835     *)
 836       TARGET_CFLAGS="$TARGET_CFLAGS $grub_cv_target_cc_soft_float"
 837       ;;
 838   esac
 839   TARGET_CCASFLAGS="$TARGET_CCASFLAGS $grub_cv_target_cc_soft_float"
 840
 841 fi
 842
 843 if test x"$target_cpu" = xsparc64 ; then
 844   AC_CACHE_CHECK([for options to reserve application registers], grub_cv_target_cc_mno_app_regs, [
 845     grub_cv_target_cc_mno_app_regs=no
 846     for cand in "-mllvm -sparc-reserve-app-registers" \
 847                 "-mno-app-regs"; do
 848       if test x"$grub_cv_target_cc_mno_app_regs" != xno ; then
 849         break
 850       fi
 851       CFLAGS="$TARGET_CFLAGS $cand -Werror"
 852       CPPFLAGS="$TARGET_CPPFLAGS"
 853       AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 854                         [grub_cv_target_cc_mno_app_regs="$cand"], [])
 855     done
 856   ])
 857
 858   if test x"$grub_cv_target_cc_mno_app_regs" = xno ; then
 859     AC_MSG_ERROR([could not reserve application registers])
 860   fi
 861   if test x"$grub_cv_target_cc_mno_app_regs" = x"-mllvm -sparc-reserve-app-registers" ; then
 862     # A trick so that clang doesn't see it on link stаge
 863     TARGET_CPPFLAGS="$TARGET_CPPFLAGS $grub_cv_target_cc_mno_app_regs"
 864   else
 865     TARGET_CFLAGS="$TARGET_CFLAGS $grub_cv_target_cc_mno_app_regs"
 866   fi
 867
 868   AC_CACHE_CHECK([for no-relax options], grub_cv_target_cc_mno_relax, [
 869     grub_cv_target_cc_mno_relax=no
 870     for cand in "-mno-relax" "-Wl,--no-relax"; do
 871       if test x"$grub_cv_target_cc_mno_relax" != xno ; then
 872         break
 873       fi
 874       LDFLAGS="$TARGET_LDFLAGS $cand -nostdlib -static"
 875       CFLAGS="$TARGET_CFLAGS -Werror"
 876       AC_LINK_IFELSE([AC_LANG_PROGRAM([[
 877             asm (".globl start; start:");
 878             void __main (void);
 879             void __main (void) {}
 880             int main (void);
 881             ]], [[]])], [grub_cv_target_cc_mno_relax="$cand"], [])
 882     done
 883   ])
 884   LDFLAGS="$TARGET_LDFLAGS"
 885   CFLAGS="$TARGET_CFLAGS"
 886
 887   if test x"$grub_cv_target_cc_mno_relax" = xno ; then
 888     AC_MSG_ERROR([could not find no-relax options])
 889   fi
 890   TARGET_LDFLAGS="$TARGET_LDFLAGS $grub_cv_target_cc_mno_relax"
 891 fi
 892
 893 # By default, GCC 4.4 generates .eh_frame sections containing unwind
 894 # information in some cases where it previously did not. GRUB doesn't need
 895 # these and they just use up vital space. Restore the old compiler
 896 # behaviour.
 897 AC_CACHE_CHECK([whether -fno-dwarf2-cfi-asm works], [grub_cv_cc_fno_dwarf2_cfi_asm], [
 898   CFLAGS="$TARGET_CFLAGS -fno-dwarf2-cfi-asm"
 899   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 900       [grub_cv_cc_fno_dwarf2_cfi_asm=yes],
 901       [grub_cv_cc_fno_dwarf2_cfi_asm=no])
 902 ])
 903
 904 if test "x$grub_cv_cc_fno_dwarf2_cfi_asm" = xyes; then
 905   TARGET_CFLAGS="$TARGET_CFLAGS -fno-dwarf2-cfi-asm"
 906 fi
 907
 908 if test x"$target_os" = xcygwin; then
 909   AC_CACHE_CHECK([whether option -fno-reorder-functions works], grub_cv_cc_no_reorder_functions, [
 910     CFLAGS="$TARGET_CFLAGS -fno-reorder-functions"
 911     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 912                       [grub_cv_cc_no_reorder_functions=yes],
 913                       [grub_cv_cc_no_reorder_functions=no])
 914   ])
 915 fi
 916
 917 if test x"$target_os" = xcygwin && test "x$grub_cv_cc_no_reorder_functions" = xyes; then
 918   TARGET_CFLAGS="$TARGET_CFLAGS -fno-reorder-functions"
 919 fi
 920
 921 AC_CACHE_CHECK([whether -mno-stack-arg-probe works], [grub_cv_cc_mno_stack_arg_probe], [
 922   CFLAGS="$TARGET_CFLAGS -mno-stack-arg-probe"
 923   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 924       [grub_cv_cc_mno_stack_arg_probe=yes],
 925       [grub_cv_cc_mno_stack_arg_probe=no])
 926 ])
 927
 928 if test "x$grub_cv_cc_mno_stack_arg_probe" = xyes; then
 929   TARGET_CFLAGS="$TARGET_CFLAGS -mno-stack-arg-probe"
 930 fi
 931
 932
 933 # By default, GCC 4.6 generates .eh_frame sections containing unwind
 934 # information in some cases where it previously did not. GRUB doesn't need
 935 # these and they just use up vital space. Restore the old compiler
 936 # behaviour.
 937 AC_CACHE_CHECK([whether -fno-asynchronous-unwind-tables works], [grub_cv_cc_fno_asynchronous_unwind_tables], [
 938   CFLAGS="$TARGET_CFLAGS -fno-asynchronous-unwind-tables"
 939   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 940       [grub_cv_cc_fno_asynchronous_unwind_tables=yes],
 941       [grub_cv_cc_fno_asynchronous_unwind_tables=no])
 942 ])
 943
 944 if test "x$grub_cv_cc_fno_asynchronous_unwind_tables" = xyes; then
 945   TARGET_CFLAGS="$TARGET_CFLAGS -fno-asynchronous-unwind-tables"
 946 fi
 947
 948 AC_CACHE_CHECK([whether -fno-unwind-tables works], [grub_cv_cc_fno_unwind_tables], [
 949   CFLAGS="$TARGET_CFLAGS -fno-unwind-tables"
 950   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 951       [grub_cv_cc_fno_unwind_tables=yes],
 952       [grub_cv_cc_fno_unwind_tables=no])
 953 ])
 954
 955 if test "x$grub_cv_cc_fno_unwind_tables" = xyes; then
 956   TARGET_CFLAGS="$TARGET_CFLAGS -fno-unwind-tables"
 957 fi
 958
 959
 960 CFLAGS="$TARGET_CFLAGS"
 961
 962
 963 if test x"$platform" = xemu ; then
 964   TARGET_OBJ2ELF=
 965   grub_cv_target_cc_link_format=
 966   case "$host_os" in
 967     *darwin* | *mac*)
 968        grub_cv_target_cc_link_format="-arch,${target_cpu}"
 969        TARGET_LDFLAGS="$TARGET_LDFLAGS -Wl,$grub_cv_target_cc_link_format"
 970         ;;
 971     *windows* | *cygwin* | *mingw*)
 972       if test x${target_cpu} = xi386 ; then
 973         grub_cv_target_cc_link_format=-mi386pe
 974         TARGET_OBJ2ELF='./build-grub-pe2elf$(BUILD_EXEEXT)'
 975       fi
 976       if test x${target_cpu} = xx86_64 ; then
 977         grub_cv_target_cc_link_format=-mi386pep
 978         TARGET_OBJ2ELF='./build-grub-pep2elf$(BUILD_EXEEXT)'
 979       fi
 980       TARGET_LDFLAGS="$TARGET_LDFLAGS -Wl,$grub_cv_target_cc_link_format"
 981       ;;
 982   esac
 983 elif test x"$target_cpu" = xi386 || test x"$target_cpu" = xx86_64; then
 984   AC_CACHE_CHECK([for target linking format], [grub_cv_target_cc_link_format], [
 985     grub_cv_target_cc_link_format=unknown
 986     for format in -melf_${target_cpu} -melf_${target_cpu}_fbsd -melf_${target_cpu}_obsd -melf_${target_cpu}_haiku -mi386pe -mi386pep -arch,${target_cpu}; do
 987       if test x${target_cpu} != xi386 && test x$format = x-mi386pe; then
 988         continue
 989       fi
 990       if test x${target_cpu} != xx86_64 && test x$format = x-mi386pep; then
 991         continue
 992       fi
 993       CFLAGS="$TARGET_CFLAGS"
 994       LDFLAGS="$TARGET_LDFLAGS -Wl,$format -nostdlib -static"
 995       AC_LINK_IFELSE([AC_LANG_PROGRAM([[
 996       asm (".globl start; start:");
 997       asm (".globl _start; _start:");
 998       asm (".globl __start; __start:");
 999       void __main (void);
1000       void __main (void) {}
1001       ]], [[]])], [flag=1], [flag=0])
1002       if test x"$flag" = x1; then
1003         grub_cv_target_cc_link_format="$format"
1004         break
1005       fi
1006     done])
1007   if test x"$grub_cv_target_cc_link_format" = xunknown; then
1008     AC_MSG_ERROR([no suitable link format found])
1009   fi
1010   TARGET_LDFLAGS="$TARGET_LDFLAGS -Wl,$grub_cv_target_cc_link_format"
1011   if test x"$grub_cv_target_cc_link_format" = x-mi386pe ; then
1012     TARGET_OBJ2ELF='./build-grub-pe2elf$(BUILD_EXEEXT)'
1013   fi
1014   if test x"$grub_cv_target_cc_link_format" = x-mi386pep ; then
1015     TARGET_OBJ2ELF='./build-grub-pep2elf$(BUILD_EXEEXT)'
1016   fi
1017 fi
1018
1019 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
1020    TARGET_APPLE_LINKER=1
1021    AC_CHECK_PROG([TARGET_OBJCONV], [objconv], [objconv], [])
1022    if test "x$TARGET_OBJCONV" = x ; then
1023       AC_CHECK_PROG([TARGET_OBJCONV], [objconv], [./objconv], [], [.])
1024    fi
1025    if test "x$TARGET_OBJCONV" = x ; then
1026       AC_MSG_ERROR([objconv not found which is required when building with apple compiler])
1027    fi
1028    TARGET_IMG_LDSCRIPT=
1029    TARGET_IMG_CFLAGS="-static"
1030    TARGET_IMG_LDFLAGS='-nostdlib -static -Wl,-preload -Wl,-segalign,20'
1031    TARGET_IMG_LDFLAGS_AC='-nostdlib -static -Wl,-preload -Wl,-segalign,20'
1032    TARGET_IMG_BASE_LDOPT="-Wl,-image_base"
1033    TARGET_LDFLAGS_OLDMAGIC=""
1034 elif test x$grub_cv_target_cc_link_format = x-mi386pe || test x$grub_cv_target_cc_link_format = x-mi386pep ; then
1035   TARGET_APPLE_LINKER=0
1036   TARGET_LDFLAGS_OLDMAGIC="-Wl,-N"
1037   TARGET_IMG_LDSCRIPT='$(top_srcdir)'"/${grub_coredir}/conf/i386-cygwin-img-ld.sc"
1038   TARGET_IMG_LDFLAGS="-Wl,-T${TARGET_IMG_LDSCRIPT}"
1039   TARGET_IMG_LDFLAGS_AC="-Wl,-T${srcdir}/${grub_coredir}/conf/i386-cygwin-img-ld.sc"
1040   TARGET_IMG_BASE_LDOPT="-Wl,-Ttext"
1041   TARGET_IMG_CFLAGS=
1042 else
1043   TARGET_APPLE_LINKER=0
1044   TARGET_LDFLAGS_OLDMAGIC="-Wl,-N"
1045   TARGET_IMG_LDSCRIPT=
1046   TARGET_IMG_LDFLAGS='-Wl,-N'
1047   TARGET_IMG_LDFLAGS_AC='-Wl,-N'
1048   TARGET_IMG_BASE_LDOPT="-Wl,-Ttext"
1049   TARGET_IMG_CFLAGS=
1050 fi
1051
1052 CFLAGS="$TARGET_CFLAGS"
1053
1054 AC_ARG_ENABLE([efiemu],
1055               [AS_HELP_STRING([--enable-efiemu],
1056                              [build and install the efiemu runtimes (default=guessed)])])
1057 if test x"$enable_efiemu" = xno ; then
1058   efiemu_excuse="explicitly disabled"
1059 fi
1060
1061 if test x"$grub_cv_target_cc_link_format" = x-mi386pe || test x"$grub_cv_target_cc_link_format" = x-mi386pep ; then
1062   efiemu_excuse="not available on cygwin"
1063 fi
1064 if test x"$target_cpu" != xi386 ; then
1065   efiemu_excuse="only available on i386"
1066 fi
1067 if test x"$platform" = xefi ; then
1068   efiemu_excuse="not available on efi"
1069 fi
1070
1071 if test x"$efiemu_excuse" = x ; then
1072   AC_CACHE_CHECK([whether options required for efiemu work], grub_cv_cc_efiemu, [
1073     CFLAGS="-m64 -nostdlib -O2 -mcmodel=large -mno-red-zone"
1074     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
1075                       [grub_cv_cc_efiemu=yes],
1076                       [grub_cv_cc_efiemu=no])
1077   ])
1078   if test x$grub_cv_cc_efiemu = xno; then
1079      efiemu_excuse="cannot compile with -m64 -mcmodel=large -mno-red-zone -nostdlib"
1080   fi
1081 fi
1082 if test x"$efiemu_excuse" = x ; then
1083   AC_CACHE_CHECK([for efiemu64 linking format], [grub_cv_target_cc_efiemu64_link_format], [
1084     grub_cv_target_cc_efiemu64_link_format=unknown
1085     for format in -melf_x86_64 -melf_x86_64_fbsd -melf_x86_64_obsd -melf_x86_64_haiku -arch,x86_64; do
1086       CFLAGS="-m64 -nostdlib -O2 -mcmodel=large -mno-red-zone"
1087       LDFLAGS="-m64 -Wl,$format -nostdlib -static"
1088       AC_LINK_IFELSE([AC_LANG_PROGRAM([[
1089       asm (".globl start; start:");
1090       asm (".globl _start; _start:");
1091       asm (".globl __start; __start:");
1092       void __main (void);
1093       void __main (void) {}
1094       ]], [[]])], [flag=1], [flag=0])
1095       if test x"$flag" = x1; then
1096         grub_cv_target_cc_efiemu64_link_format="$format"
1097         break
1098       fi
1099     done])
1100   if test x"$grub_cv_target_cc_efiemu64_link_format" = xunknown; then
1101     efiemu_excuse="no suitable link format for efiemu64 found"
1102   else
1103     EFIEMU64_LINK_FORMAT="-Wl,$grub_cv_target_cc_efiemu64_link_format"
1104   fi
1105 fi
1106 if test x"$enable_efiemu" = xyes && test x"$efiemu_excuse" != x ; then
1107   AC_MSG_ERROR([efiemu runtime was explicitly requested but can't be compiled ($efiemu_excuse)])
1108 fi
1109 if test x"$efiemu_excuse" = x ; then
1110 enable_efiemu=yes
1111 else
1112 enable_efiemu=no
1113 fi
1114 AC_SUBST([enable_efiemu])
1115 AC_SUBST([EFIEMU64_LINK_FORMAT])
1116
1117 CFLAGS="$TARGET_CFLAGS"
1118
1119 AC_SUBST(TARGET_LDFLAGS_OLDMAGIC)
1120
1121
1122 LDFLAGS="$TARGET_LDFLAGS"
1123
1124 if test "$target_cpu" = x86_64 || test "$target_cpu" = sparc64 ; then
1125   # Use large model to support 4G memory
1126   AC_CACHE_CHECK([whether option -mcmodel=large works], grub_cv_cc_mcmodel, [
1127     CFLAGS="$TARGET_CFLAGS -mcmodel=large"
1128     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
1129                       [grub_cv_cc_mcmodel=yes],
1130                       [grub_cv_cc_mcmodel=no])
1131   ])
1132   if test "x$grub_cv_cc_mcmodel" = xyes; then
1133     TARGET_CFLAGS="$TARGET_CFLAGS -mcmodel=large"
1134   elif test "$target_cpu" = sparc64; then
1135     TARGET_CFLAGS="$TARGET_CFLAGS -mcmodel=medany"
1136   fi
1137 fi
1138
1139 if test "$target_cpu"-"$platform" = x86_64-efi; then
1140   # EFI writes to stack below %rsp, we must not use the red zone
1141   AC_CACHE_CHECK([whether option -mno-red-zone works], grub_cv_cc_no_red_zone, [
1142     CFLAGS="$TARGET_CFLAGS -mno-red-zone"
1143     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
1144                       [grub_cv_cc_no_red_zone=yes],
1145                       [grub_cv_cc_no_red_zone=no])
1146   ])
1147   if test "x$grub_cv_cc_no_red_zone" = xno; then
1148     AC_MSG_ERROR([-mno-red-zone not supported, upgrade your gcc])
1149   fi
1150
1151   TARGET_CFLAGS="$TARGET_CFLAGS -mno-red-zone"
1152 fi
1153
1154 if test "x$target_cpu" = xarm; then
1155   AC_CACHE_CHECK([whether option -mlong-calls works], grub_cv_cc_mlong_calls, [
1156     CFLAGS="$TARGET_CFLAGS -mlong-calls -Werror"
1157     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
1158                       [grub_cv_cc_mlong_calls=yes],
1159                       [grub_cv_cc_mlong_calls=no])
1160   ])
1161   if test "x$grub_cv_cc_mlong_calls" = xyes; then
1162     TARGET_CFLAGS="$TARGET_CFLAGS -mlong-calls"
1163   fi
1164   AC_CACHE_CHECK([whether option -mthumb-interwork works], grub_cv_cc_mthumb_interwork, [
1165     CFLAGS="$TARGET_CFLAGS -mthumb-interwork -Werror"
1166     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
1167                       [grub_cv_cc_mthumb_interwork=yes],
1168                       [grub_cv_cc_mthumb_interwork=no])
1169   ])
1170   if test "x$grub_cv_cc_mthumb_interwork" = xyes; then
1171     TARGET_CFLAGS="$TARGET_CFLAGS -mthumb-interwork"
1172   # Clang defaults to thumb interworking
1173   elif test "x$grub_cv_cc_target_clang" = xno ; then
1174     AC_MSG_ERROR([your compiler doesn't support -mthumb-interwork])
1175   fi
1176 fi
1177
1178 AC_CACHE_CHECK([whether option -Qn works], grub_cv_target_cc_qn, [
1179   CFLAGS="$TARGET_CFLAGS -Qn -Werror"
1180   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
1181                     [grub_cv_target_cc_qn=yes],
1182                     [grub_cv_target_cc_qn=no])])
1183 if test "x$grub_cv_target_cc_qn" = xyes; then
1184   TARGET_CFLAGS="$TARGET_CFLAGS -Qn"
1185 fi
1186
1187 #
1188 # Compiler features.
1189 #
1190
1191 CFLAGS="$TARGET_CFLAGS"
1192
1193 # Position independent executable.
1194 grub_CHECK_PIE
1195 grub_CHECK_NO_PIE
1196 [# Need that, because some distributions ship compilers that include
1197 # `-fPIE' or '-fpie' and '-pie' in the default specs.
1198 if [ x"$pie_possible" = xyes ]; then
1199   TARGET_CFLAGS="$TARGET_CFLAGS -fno-PIE -fno-pie"
1200 fi
1201 if [ x"$nopie_possible" = xyes ] &&  [ x"$pie_possible" = xyes ]; then
1202   TARGET_LDFLAGS="$TARGET_LDFLAGS -no-pie"
1203 fi]
1204
1205 CFLAGS="$TARGET_CFLAGS"
1206 LDFLAGS="$TARGET_LDFLAGS"
1207
1208 # Position independent executable.
1209 grub_CHECK_PIC
1210 [# On most platforms we don't want PIC as it only makes relocations harder
1211 # and code less efficient. On mips we want to have one got table per module
1212 # and reload $gp in every function.
1213 # GCC implements it using symbol __gnu_local_gp in non-PIC as well.
1214 # However with clang we need PIC for this reloading to happen.
1215 # Since default varies across dictributions use either -fPIC or -fno-PIC
1216 # explicitly.
1217 if ( test x$target_cpu = xmips || test x$target_cpu = xmipsel ) && test "x$grub_cv_cc_target_clang" = xyes ; then
1218    TARGET_CFLAGS="$TARGET_CFLAGS -fPIC"
1219 elif [ x"$pic_possible" = xyes ]; then
1220    TARGET_CFLAGS="$TARGET_CFLAGS -fno-PIC"
1221 fi]
1222
1223 CFLAGS="$TARGET_CFLAGS"
1224
1225 # Smashing stack protector.
1226 grub_CHECK_STACK_PROTECTOR
1227 # Need that, because some distributions ship compilers that include
1228 # `-fstack-protector' in the default specs.
1229 if test "x$ssp_possible" = xyes; then
1230   TARGET_CFLAGS="$TARGET_CFLAGS -fno-stack-protector"
1231 fi
1232
1233 CFLAGS="$TARGET_CFLAGS"
1234
1235 grub_CHECK_STACK_ARG_PROBE
1236 # Cygwin's GCC uses alloca() to probe the stackframe on static
1237 # stack allocations above some threshold.
1238 if test x"$sap_possible" = xyes; then
1239   TARGET_CFLAGS="$TARGET_CFLAGS -mno-stack-arg-probe"
1240 fi
1241
1242 CFLAGS="$TARGET_CFLAGS"
1243
1244 # -mno-unaligned-access -mstrict-align
1245 if test "$target_cpu" = arm; then
1246   AC_CACHE_CHECK([for compile options to get strict alignment], [grub_cv_target_cc_strict_align], [
1247     grub_cv_target_cc_strict_align=
1248     for arg in -mno-unaligned-access "-Xclang -mstrict-align" -mstrict-align; do
1249       CFLAGS="$TARGET_CFLAGS $arg -Werror"
1250       LDFLAGS="$TARGET_LDFLAGS"
1251       AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])], [flag=1], [flag=0])
1252       if test x"$flag" = x1; then
1253         grub_cv_target_cc_strict_align="$arg"
1254         break
1255       fi
1256     done])
1257
1258   TARGET_CFLAGS="$TARGET_CFLAGS $grub_cv_target_cc_strict_align"
1259   if test x"$grub_cv_target_cc_strict_align" = x"-Xclang -mstrict-align"; then
1260     TARGET_LDFLAGS="$TARGET_LDFLAGS -Qunused-arguments"
1261   fi
1262   AC_CACHE_CHECK([if compiler generates unaligned accesses], [grub_cv_cc_target_emits_unaligned],
1263   [CFLAGS="$TARGET_CFLAGS"
1264    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[
1265 #ifdef __ARM_FEATURE_UNALIGNED
1266 #error "unaligned"
1267 #endif
1268      ]])],
1269      [grub_cv_cc_target_emits_unaligned=no], [grub_cv_cc_target_emits_unaligned=yes])])
1270   if test x$grub_cv_cc_target_emits_unaligned = xyes; then
1271     AC_MSG_ERROR([compiler generates unaligned accesses])
1272   fi
1273 fi
1274
1275 # Set them to their new values for the tests below.
1276 CC="$TARGET_CC"
1277 if test x"$platform" = xemu ; then
1278 CFLAGS="$TARGET_CFLAGS -Wno-error"
1279 elif test "x$TARGET_APPLE_LINKER" = x1 ; then
1280 CFLAGS="$TARGET_CFLAGS -nostdlib -static -Wno-error"
1281 else
1282 CFLAGS="$TARGET_CFLAGS -nostdlib -Wno-error"
1283 fi
1284 CPPFLAGS="$TARGET_CPPFLAGS"
1285
1286 grub_ASM_USCORE
1287 if test "x$TARGET_APPLE_LINKER" = x0 && test x"$platform" != xemu; then
1288 if test x$grub_cv_asm_uscore = xyes; then
1289 DEFSYM="-Wl,--defsym,_abort=_main -Wl,--defsym,__main=_main"
1290 else
1291 DEFSYM="-Wl,--defsym,abort=main -Wl,--defsym,_main=main -Wl,--defsym,__main=main"
1292 fi
1293 CFLAGS="$TARGET_CFLAGS -nostdlib $DEFSYM"
1294 fi
1295
1296 # Check for libgcc symbols
1297 if test x"$platform" = xemu; then
1298 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)
1299 fi
1300
1301 if test "x$TARGET_APPLE_LINKER" = x1 ; then
1302 CFLAGS="$TARGET_CFLAGS -nostdlib -static"
1303 else
1304 CFLAGS="$TARGET_CFLAGS -nostdlib"
1305 fi
1306 LIBS=""
1307
1308 # Defined in aclocal.m4.
1309 grub_PROG_TARGET_CC
1310 if test "x$TARGET_APPLE_LINKER" != x1 ; then
1311 grub_PROG_OBJCOPY_ABSOLUTE
1312 fi
1313 grub_PROG_LD_BUILD_ID_NONE
1314 if test "x$target_cpu" = xi386; then
1315   if test "$platform" != emu && test "x$TARGET_APPLE_LINKER" != x1 ; then
1316     if test ! -z "$TARGET_IMG_LDSCRIPT"; then
1317       # Check symbols provided by linker script.
1318       CFLAGS="$TARGET_CFLAGS -nostdlib ${TARGET_IMG_LDFLAGS_AC} ${TARGET_IMG_BASE_LDOPT},0x8000"
1319     fi
1320     grub_CHECK_BSS_START_SYMBOL
1321     grub_CHECK_END_SYMBOL
1322   fi
1323   CFLAGS="$TARGET_CFLAGS"
1324 fi
1325
1326 grub_PROG_NM_WORKS
1327 grub_PROG_NM_MINUS_P
1328 grub_PROG_NM_DEFINED_ONLY
1329 AC_SUBST(TARGET_NMFLAGS_MINUS_P)
1330 AC_SUBST(TARGET_NMFLAGS_DEFINED_ONLY)
1331
1332 if test "$platform" != emu; then
1333 AC_CACHE_CHECK([whether -nostdinc -isystem works], [grub_cv_cc_isystem], [
1334   SAVED_CPPFLAGS="$CPPFLAGS"
1335   CPPFLAGS="$TARGET_CPPFLAGS -nostdinc -isystem `$TARGET_CC -print-file-name=include`"
1336   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <stdarg.h>
1337 #include <stddef.h>
1338 int va_arg_func (int fixed, va_list args);]], [[]])],
1339       [grub_cv_cc_isystem=yes],
1340       [grub_cv_cc_isystem=no])
1341   CPPFLAGS="$SAVED_CPPFLAGS"
1342 ])
1343
1344 if test x"$grub_cv_cc_isystem" = xyes ; then
1345   TARGET_CPPFLAGS="$TARGET_CPPFLAGS -nostdinc -isystem `$TARGET_CC -print-file-name=include`"
1346 fi
1347 fi
1348
1349 AC_CACHE_CHECK([whether -Wtrampolines work], [grub_cv_cc_wtrampolines], [
1350   CFLAGS="$TARGET_CFLAGS -Wtrampolines -Werror"
1351   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <stdarg.h>
1352 int va_arg_func (int fixed, va_list args);]], [[]])],
1353       [grub_cv_cc_wtrampolines=yes],
1354       [grub_cv_cc_wtrampolines=no])
1355 ])
1356
1357 if test x"$grub_cv_cc_wtrampolines" = xyes ; then
1358   TARGET_CFLAGS="$TARGET_CFLAGS -Wtrampolines"
1359 fi
1360
1361 # Restore the flags.
1362 CC="$tmp_CC"
1363 CFLAGS="$tmp_CFLAGS"
1364 CPPFLAGS="$tmp_CPPFLAGS"
1365 LDFLAGS="$tmp_LDFLAGS"
1366 LIBS="$tmp_LIBS"
1367
1368 #
1369 # Check for options.
1370 #
1371
1372 # Memory manager debugging.
1373 AC_ARG_ENABLE([mm-debug],
1374               AS_HELP_STRING([--enable-mm-debug],
1375                              [include memory manager debugging]),
1376               [AC_DEFINE([MM_DEBUG], [1],
1377                          [Define to 1 if you enable memory manager debugging.])])
1378
1379 AC_ARG_ENABLE([cache-stats],
1380               AS_HELP_STRING([--enable-cache-stats],
1381                              [enable disk cache statistics collection]))
1382
1383 if test x$enable_cache_stats = xyes; then
1384   DISK_CACHE_STATS=1
1385 else
1386   DISK_CACHE_STATS=0
1387 fi
1388 AC_SUBST([DISK_CACHE_STATS])
1389
1390 AC_ARG_ENABLE([boot-time],
1391               AS_HELP_STRING([--enable-boot-time],
1392                              [enable boot time statistics collection]))
1393
1394 if test x$enable_boot_time = xyes; then
1395   BOOT_TIME_STATS=1
1396 else
1397   BOOT_TIME_STATS=0
1398 fi
1399 AC_SUBST([BOOT_TIME_STATS])
1400
1401 AC_ARG_ENABLE([grub-emu-sdl],
1402               [AS_HELP_STRING([--enable-grub-emu-sdl],
1403                              [build and install the `grub-emu' debugging utility with SDL support (default=guessed)])])
1404
1405 AC_ARG_ENABLE([grub-emu-pci],
1406               [AS_HELP_STRING([--enable-grub-emu-pci],
1407                              [build and install the `grub-emu' debugging utility with PCI support (potentially dangerous) (default=no)])])
1408
1409 if test "$platform" = emu; then
1410
1411 if test x"$enable_grub_emu_sdl" = xno ; then
1412   grub_emu_sdl_excuse="explicitly disabled"
1413 fi
1414 [if [ x"$grub_emu_sdl_excuse" = x ]; then
1415     # Check for libSDL libraries.]
1416 AC_CHECK_LIB([SDL], [SDL_Init], [LIBSDL="-lSDL"],
1417     [grub_emu_sdl_excuse=["libSDL libraries are required to build \`grub-emu' with SDL support"]])
1418     AC_SUBST([LIBSDL])
1419 [fi]
1420
1421 [if [ x"$grub_emu_sdl_excuse" = x ]; then
1422     # Check for headers.]
1423     AC_CHECK_HEADERS([SDL/SDL.h], [],
1424       [grub_emu_sdl_excuse=["libSDL header file is required to build \`grub-emu' with SDL support"]])
1425 [fi]
1426
1427 if test x"enable_grub_emu_sdl" = xyes && test x"$grub_emu_sdl_excuse" != x ; then
1428   AC_MSG_ERROR([SDL support for grub-emu was explicitly requested but can't be compiled ($grub_emu_sdl_excuse)])
1429 fi
1430 if test x"$grub_emu_sdl_excuse" = x ; then
1431 enable_grub_emu_sdl=yes
1432 else
1433 enable_grub_emu_sdl=no
1434 fi
1435
1436 if test x"$enable_grub_emu_pci" != xyes ; then
1437    grub_emu_pci_excuse="not enabled"
1438 fi
1439
1440 [if [ x"$grub_emu_pci_excuse" = x ]; then
1441       # Check for libpci libraries.]
1442    AC_CHECK_LIB([pciaccess], [pci_system_init], [LIBPCIACCESS="-lpciaccess"],
1443       [grub_emu_pci_excuse=["need libpciaccess library"]])
1444     AC_SUBST([LIBPCIACCESS])
1445 [fi]
1446 [if [ x"$grub_emu_pci_excuse" = x ]; then
1447     # Check for headers.]
1448     AC_CHECK_HEADERS([pciaccess.h], [],
1449       [grub_emu_pci_excuse=["need libpciaccess headers"]])
1450 [fi]
1451
1452 if test x"$grub_emu_pci_excuse" = x ; then
1453 enable_grub_emu_pci=yes
1454 else
1455
1456 enable_grub_emu_pci=no
1457 fi
1458
1459 AC_SUBST([enable_grub_emu_sdl])
1460 AC_SUBST([enable_grub_emu_pci])
1461
1462 else
1463
1464 # Ignore --enable-emu-* if platform is not emu
1465 enable_grub_emu_sdl=no
1466 enable_grub_emu_pci=no
1467 fi
1468
1469 AC_ARG_ENABLE([grub-mkfont],
1470               [AS_HELP_STRING([--enable-grub-mkfont],
1471                              [build and install the `grub-mkfont' utility (default=guessed)])])
1472 if test x"$enable_grub_mkfont" = xno ; then
1473   grub_mkfont_excuse="explicitly disabled"
1474 fi
1475
1476 if test x"$grub_mkfont_excuse" = x ; then
1477   # Check for freetype libraries.
1478   AC_CHECK_TOOLS([FREETYPE], [freetype-config])
1479   if test "x$FREETYPE" = x ; then
1480     grub_mkfont_excuse=["need freetype2 library"]
1481   fi
1482 fi
1483
1484 unset ac_cv_header_ft2build_h
1485
1486 if test x"$grub_mkfont_excuse" = x ; then
1487   # Check for freetype libraries.
1488   freetype_cflags=`$FREETYPE --cflags`
1489   freetype_libs=`$FREETYPE --libs`
1490   SAVED_CPPFLAGS="$CPPFLAGS"
1491   SAVED_LIBS="$LIBS"
1492   CPPFLAGS="$CPPFLAGS $freetype_cflags"
1493   LIBS="$LIBS $freetype_libs"
1494   AC_CHECK_HEADERS([ft2build.h], [],
1495         [grub_mkfont_excuse=["need freetype2 headers"]])
1496   AC_LINK_IFELSE([AC_LANG_CALL([], [FT_Load_Glyph])], [], [grub_mkfont_excuse=["freetype2 library unusable"]])
1497   CPPFLAGS="$SAVED_CPPFLAGS"
1498   LIBS="$SAVED_LIBS"
1499 fi
1500
1501 if test x"$enable_grub_mkfont" = xyes && test x"$grub_mkfont_excuse" != x ; then
1502   AC_MSG_ERROR([grub-mkfont was explicitly requested but can't be compiled ($grub_mkfont_excuse)])
1503 fi
1504 if test x"$grub_mkfont_excuse" = x ; then
1505 enable_grub_mkfont=yes
1506 else
1507 enable_grub_mkfont=no
1508 fi
1509 AC_SUBST([enable_grub_mkfont])
1510 AC_SUBST([freetype_cflags])
1511 AC_SUBST([freetype_libs])
1512
1513 SAVED_CC="$CC"
1514 SAVED_CPP="$CPP"
1515 SAVED_CFLAGS="$CFLAGS"
1516 SAVED_CPPFLAGS="$CPPFLAGS"
1517 SAVED_LDFLAGS="$LDFLAGS"
1518 CC="$BUILD_CC"
1519 CPP="$BUILD_CPP"
1520 CFLAGS="$BUILD_CFLAGS"
1521 CPPFLAGS="$BUILD_CPPFLAGS"
1522 LDFLAGS="$BUILD_LDFAGS"
1523
1524 unset ac_cv_c_bigendian
1525 unset ac_cv_header_ft2build_h
1526
1527 AC_COMPUTE_INT([BUILD_SIZEOF_VOID_P], [sizeof (void *)])
1528 AC_COMPUTE_INT([BUILD_SIZEOF_LONG], [sizeof (long)])
1529 AC_C_BIGENDIAN([BUILD_WORDS_BIGENDIAN=1], [BUILD_WORDS_BIGENDIAN=0], [BUILD_WORDS_BIGENDIAN=err], [BUILD_WORDS_BIGENDIAN=err])
1530
1531 if test x$BUILD_WORDS_BIGENDIAN = xerr ; then
1532    AC_MSG_ERROR([couldnt determine build endianness])
1533 fi
1534
1535 AC_SUBST([BUILD_SIZEOF_LONG])
1536 AC_SUBST([BUILD_SIZEOF_VOID_P])
1537 AC_SUBST([BUILD_WORDS_BIGENDIAN])
1538
1539 if test x"$grub_build_mkfont_excuse" = x ; then
1540   # Check for freetype libraries.
1541   AC_CHECK_PROGS([BUILD_FREETYPE], [freetype-config])
1542   if test "x$BUILD_FREETYPE" = x ; then
1543     grub_build_mkfont_excuse=["need freetype2 library"]
1544   fi
1545 fi
1546
1547 if test x"$grub_build_mkfont_excuse" = x ; then
1548   # Check for freetype libraries.
1549   build_freetype_cflags=`$BUILD_FREETYPE --cflags`
1550   build_freetype_libs=`$BUILD_FREETYPE --libs`
1551   SAVED_CPPFLAGS_2="$CPPFLAGS"
1552   SAVED_LIBS="$LIBS"
1553   CPPFLAGS="$CPPFLAGS $build_freetype_cflags"
1554   LIBS="$LIBS $build_freetype_libs"
1555   AC_CHECK_HEADERS([ft2build.h], [],
1556         [grub_build_mkfont_excuse=["need freetype2 headers"]])
1557   AC_LINK_IFELSE([AC_LANG_CALL([], [FT_Load_Glyph])], [], [grub_build_mkfont_excuse=["freetype2 library unusable"]])
1558   LIBS="$SAVED_LIBS"
1559   CPPFLAGS="$SAVED_CPPFLAGS_2"
1560 fi
1561
1562 if test x"$enable_build_grub_mkfont" = xyes && test x"$grub_build_mkfont_excuse" != x ; then
1563   AC_MSG_ERROR([build-grub-mkfont was explicitly requested but can't be compiled ($grub_build_mkfont_excuse)])
1564 fi
1565 if test x"$grub_build_mkfont_excuse" = x ; then
1566   enable_build_grub_mkfont=yes
1567 else
1568   enable_build_grub_mkfont=no
1569 fi
1570 if test x"$enable_build_grub_mkfont" = xno && ( test "x$platform" = xqemu || test "x$platform" = xloongson || test "x$platform" = xqemu_mips || test "x$platform" = xcoreboot ); then
1571   if test x"$grub_build_mkfont_excuse" = x ; then
1572     AC_MSG_ERROR([qemu, coreboot and loongson ports need build-time grub-mkfont])
1573   else
1574     AC_MSG_ERROR([qemu, coreboot and loongson ports need build-time grub-mkfont ($grub_build_mkfont_excuse)])
1575   fi
1576 fi
1577
1578 AC_SUBST([build_freetype_cflags])
1579 AC_SUBST([build_freetype_libs])
1580
1581 CC="$SAVED_CC"
1582 CPP="$SAVED_CPP"
1583 CFLAGS="$SAVED_CFLAGS"
1584 CPPFLAGS="$SAVED_CPPFLAGS"
1585 LDFLAGS="$SAVED_LDFLAGS"
1586
1587
1588 DJVU_FONT_SOURCE=
1589
1590 starfield_excuse=
1591
1592 AC_ARG_ENABLE([grub-themes],
1593               [AS_HELP_STRING([--enable-grub-themes],
1594                              [build and install GRUB themes (default=guessed)])])
1595 if test x"$enable_grub_themes" = xno ; then
1596   starfield_excuse="explicitly disabled"
1597 fi
1598
1599 if test x"$starfield_excuse" = x && test x"$enable_build_grub_mkfont" = xno ; then
1600   starfield_excuse="No build-time grub-mkfont"
1601 fi
1602
1603 if test x"$starfield_excuse" = x; then
1604    for ext in pcf pcf.gz bdf bdf.gz ttf ttf.gz; do
1605      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
1606         if test -f "$dir/DejaVuSans.$ext"; then
1607           DJVU_FONT_SOURCE="$dir/DejaVuSans.$ext"
1608           break 2
1609         fi
1610      done
1611    done
1612
1613    if test "x$DJVU_FONT_SOURCE" = x; then
1614      starfield_excuse="No DejaVu found"
1615    fi
1616 fi
1617
1618 if test x"$enable_grub_themes" = xyes &&  test x"$starfield_excuse" != x; then
1619    AC_MSG_ERROR([themes were explicitly requested but requirements are not satisfied ($starfield_excuse)])
1620 fi
1621
1622 AC_SUBST([DJVU_FONT_SOURCE])
1623
1624 FONT_SOURCE=
1625
1626 for ext in pcf pcf.gz bdf bdf.gz ttf ttf.gz; do
1627   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
1628     if test -f "$dir/unifont.$ext"; then
1629       md5="$(md5sum "$dir/unifont.$ext"|awk '{ print $1; }')"
1630       # PCF and BDF from version 6.3 isn't hanled properly by libfreetype.
1631       if test "$md5" = 0a54834d2788c83886a3e1785a6a1e61 || test "$md5" = 28f2565c7a41d8d407e2551159385edb || test "$md5" = dae5e588461b3b92b87b6ffee734f936 || test "$md5" = 4a3d687aa5bb329ed05f4263a1016791 ; then
1632         continue
1633       fi
1634       FONT_SOURCE="$dir/unifont.$ext"
1635       break 2
1636     fi
1637   done
1638 done
1639
1640 if test x"$enable_build_grub_mkfont" = xno ; then
1641   FONT_SOURCE=
1642 fi
1643
1644 if test "x$FONT_SOURCE" = x && ( test "x$platform" = xqemu || test "x$platform" = xloongson || test "x$platform" = xqemu_mips || test "x$platform" = xcoreboot ); then
1645   if test x"$grub_build_mkfont_excuse" = x ; then
1646     AC_MSG_ERROR([qemu, coreboot and loongson ports need unifont])
1647   else
1648     AC_MSG_ERROR([qemu, coreboot and loongson ports need unifont ($grub_build_mkfont_excuse)])
1649   fi
1650 fi
1651
1652 AC_SUBST([FONT_SOURCE])
1653
1654 if test x"$FONT_SOURCE" = x &&  test x"$DJVU_FONT_SOURCE" = x && test x"$grub_build_mkfont_excuse" = x; then
1655   grub_build_mkfont_excuse="no fonts"
1656 fi
1657
1658
1659 AC_ARG_ENABLE([grub-mount],
1660               [AS_HELP_STRING([--enable-grub-mount],
1661                              [build and install the `grub-mount' utility (default=guessed)])])
1662 if test x"$enable_grub_mount" = xno ; then
1663   grub_mount_excuse="explicitly disabled"
1664 fi
1665
1666 if test x"$grub_mount_excuse" = x ; then
1667   AC_CHECK_LIB([fuse], [fuse_main_real], [],
1668                [grub_mount_excuse="need FUSE library"])
1669 fi
1670
1671 if test x"$grub_mount_excuse" = x ; then
1672   # Check for fuse headers.
1673   SAVED_CPPFLAGS="$CPPFLAGS"
1674   CPPFLAGS="$CPPFLAGS -DFUSE_USE_VERSION=26"
1675   AC_CHECK_HEADERS([fuse/fuse.h], [],
1676         [grub_mount_excuse=["need FUSE headers"]])
1677   CPPFLAGS="$SAVED_CPPFLAGS"
1678 fi
1679
1680 if test x"$enable_grub_mount" = xyes && test x"$grub_mount_excuse" != x ; then
1681   AC_MSG_ERROR([grub-mount was explicitly requested but can't be compiled ($grub_mount_excuse)])
1682 fi
1683 if test x"$grub_mount_excuse" = x ; then
1684 enable_grub_mount=yes
1685 else
1686 enable_grub_mount=no
1687 fi
1688 AC_SUBST([enable_grub_mount])
1689
1690 AC_ARG_ENABLE([device-mapper],
1691               [AS_HELP_STRING([--enable-device-mapper],
1692                               [enable Linux device-mapper support (default=guessed)])])
1693 if test x"$enable_device_mapper" = xno ; then
1694   device_mapper_excuse="explicitly disabled"
1695 fi
1696
1697 if test x"$device_mapper_excuse" = x ; then
1698   # Check for device-mapper header.
1699   AC_CHECK_HEADER([libdevmapper.h], [],
1700                [device_mapper_excuse="need libdevmapper header"])
1701 fi
1702
1703 if test x"$device_mapper_excuse" = x ; then
1704   # Check for device-mapper library.
1705   AC_CHECK_LIB([devmapper], [dm_task_create], [],
1706                [device_mapper_excuse="need devmapper library"])
1707 fi
1708
1709 if test x"$device_mapper_excuse" = x ; then
1710   # Check for device-mapper library.
1711   AC_CHECK_LIB([devmapper], [dm_log_with_errno_init],
1712                [],
1713                [device_mapper_excuse="need devmapper library"])
1714 fi
1715
1716 if test x"$device_mapper_excuse" = x ; then
1717    LIBDEVMAPPER="-ldevmapper"
1718    AC_DEFINE([HAVE_DEVICE_MAPPER], [1],
1719              [Define to 1 if you have the devmapper library.])
1720 fi
1721
1722 AC_SUBST([LIBDEVMAPPER])
1723
1724 LIBGEOM=
1725 if test x$host_kernel = xkfreebsd; then
1726   AC_CHECK_LIB([geom], [geom_gettree], [],
1727                [AC_MSG_ERROR([Your platform requires libgeom])])
1728   LIBGEOM="-lgeom"
1729 fi
1730
1731 AC_SUBST([LIBGEOM])
1732
1733 AC_ARG_ENABLE([liblzma],
1734               [AS_HELP_STRING([--enable-liblzma],
1735                               [enable liblzma integration (default=guessed)])])
1736 if test x"$enable_liblzma" = xno ; then
1737   liblzma_excuse="explicitly disabled"
1738 fi
1739
1740 if test x"$liblzma_excuse" = x ; then
1741 AC_CHECK_LIB([lzma], [lzma_code],
1742              [],[liblzma_excuse="need lzma library"])
1743 fi
1744 if test x"$liblzma_excuse" = x ; then
1745 AC_CHECK_HEADER([lzma.h], [], [liblzma_excuse="need lzma header"])
1746 fi
1747
1748 if test x"$enable_liblzma" = xyes && test x"$liblzma_excuse" != x ; then
1749   AC_MSG_ERROR([liblzma support was explicitly requested but requirements are not satisfied ($liblzma_excuse)])
1750 fi
1751
1752
1753 if test x"$liblzma_excuse" = x ; then
1754    LIBLZMA="-llzma"
1755    AC_DEFINE([USE_LIBLZMA], [1],
1756              [Define to 1 if you have the LZMA library.])
1757 fi
1758
1759 AC_SUBST([LIBLZMA])
1760
1761 AC_ARG_ENABLE([libzfs],
1762               [AS_HELP_STRING([--enable-libzfs],
1763                               [enable libzfs integration (default=guessed)])])
1764 if test x"$enable_libzfs" = xno ; then
1765   libzfs_excuse="explicitly disabled"
1766 fi
1767
1768 if test x"$libzfs_excuse" = x ; then
1769   # Only check for system headers if libzfs support has not been disabled.
1770   AC_CHECK_HEADERS(libzfs.h libnvpair.h)
1771 fi
1772
1773 if test x"$libzfs_excuse" = x ; then
1774   AC_CHECK_LIB([zfs], [libzfs_init],
1775                [],
1776                [libzfs_excuse="need zfs library"])
1777 fi
1778
1779 if test x"$libzfs_excuse" = x ; then
1780   AC_CHECK_LIB([nvpair], [nvlist_lookup_string],
1781                [],
1782                [libzfs_excuse="need nvpair library"])
1783 fi
1784
1785 if test x"$enable_libzfs" = xyes && test x"$libzfs_excuse" != x ; then
1786   AC_MSG_ERROR([libzfs support was explicitly requested but requirements are not satisfied ($libzfs_excuse)])
1787 fi
1788
1789 if test x"$libzfs_excuse" = x ; then
1790   # We need both libzfs and libnvpair for a successful build.
1791   LIBZFS="-lzfs"
1792   AC_DEFINE([HAVE_LIBZFS], [1],
1793             [Define to 1 if you have the ZFS library.])
1794   LIBNVPAIR="-lnvpair"
1795   AC_DEFINE([HAVE_LIBNVPAIR], [1],
1796             [Define to 1 if you have the NVPAIR library.])
1797 fi
1798
1799 AC_SUBST([LIBZFS])
1800 AC_SUBST([LIBNVPAIR])
1801
1802 LIBS=""
1803
1804 AC_SUBST([FONT_SOURCE])
1805 AS_IF([test x$target_cpu = xi386 -a x$platform = xqemu],
1806             [AC_SUBST([GRUB_BOOT_MACHINE_LINK_ADDR], 0xffe00)])
1807
1808 AC_SUBST(HAVE_ASM_USCORE)
1809 AC_SUBST(BSS_START_SYMBOL)
1810 AC_SUBST(END_SYMBOL)
1811 AC_SUBST(PACKAGE)
1812 AC_SUBST(VERSION)
1813
1814 AC_ARG_ENABLE([werror],
1815               [AS_HELP_STRING([--disable-werror],
1816                              [do not use -Werror when building GRUB])])
1817 if test x"$enable_werror" != xno ; then
1818   TARGET_CFLAGS="$TARGET_CFLAGS -Werror"
1819   HOST_CFLAGS="$HOST_CFLAGS -Werror"
1820 fi
1821
1822 TARGET_CPP="$TARGET_CC -E"
1823 TARGET_CCAS=$TARGET_CC
1824
1825 # Includes which include make-time substitutions. They must come last
1826 # as to avoid executing top_builddir in shell.
1827 HOST_CPPFLAGS="$HOST_CPPFLAGS -I\$(top_builddir)/include"
1828 TARGET_CPPFLAGS="$TARGET_CPPFLAGS -I\$(top_srcdir)/include"
1829 TARGET_CPPFLAGS="$TARGET_CPPFLAGS -I\$(top_builddir)/include"
1830
1831 GRUB_TARGET_CPU="${target_cpu}"
1832 GRUB_PLATFORM="${platform}"
1833
1834 AC_SUBST(GRUB_TARGET_CPU)
1835 AC_SUBST(GRUB_PLATFORM)
1836
1837 AC_SUBST(TARGET_OBJCONV)
1838 AC_SUBST(TARGET_CPP)
1839 AC_SUBST(TARGET_CCAS)
1840 AC_SUBST(TARGET_OBJ2ELF)
1841 AC_SUBST(TARGET_MODULE_FORMAT)
1842 AC_SUBST(TARGET_CC_VERSION)
1843
1844 AC_SUBST(TARGET_CFLAGS)
1845 AC_SUBST(TARGET_LDFLAGS)
1846 AC_SUBST(TARGET_CPPFLAGS)
1847 AC_SUBST(TARGET_CCASFLAGS)
1848
1849 AC_SUBST(TARGET_IMG_LDFLAGS)
1850 AC_SUBST(TARGET_IMG_CFLAGS)
1851 AC_SUBST(TARGET_IMG_BASE_LDOPT)
1852 AC_SUBST(TARGET_APPLE_LINKER)
1853
1854 AC_SUBST(HOST_CFLAGS)
1855 AC_SUBST(HOST_LDFLAGS)
1856 AC_SUBST(HOST_CPPFLAGS)
1857 AC_SUBST(HOST_CCASFLAGS)
1858
1859 AC_SUBST(BUILD_LIBM)
1860
1861 #
1862 # Automake conditionals
1863 #
1864
1865 AM_CONDITIONAL([COND_real_platform], [test x$platform != xnone])
1866 AM_CONDITIONAL([COND_emu], [test x$platform = xemu])
1867 AM_CONDITIONAL([COND_i386_pc], [test x$target_cpu = xi386 -a x$platform = xpc])
1868 AM_CONDITIONAL([COND_i386_efi], [test x$target_cpu = xi386 -a x$platform = xefi])
1869 AM_CONDITIONAL([COND_ia64_efi], [test x$target_cpu = xia64 -a x$platform = xefi])
1870 AM_CONDITIONAL([COND_i386_qemu], [test x$target_cpu = xi386 -a x$platform = xqemu])
1871 AM_CONDITIONAL([COND_i386_ieee1275], [test x$target_cpu = xi386 -a x$platform = xieee1275])
1872 AM_CONDITIONAL([COND_i386_coreboot], [test x$target_cpu = xi386 -a x$platform = xcoreboot])
1873 AM_CONDITIONAL([COND_i386_multiboot], [test x$target_cpu = xi386 -a x$platform = xmultiboot])
1874 AM_CONDITIONAL([COND_x86_64_efi], [test x$target_cpu = xx86_64 -a x$platform = xefi])
1875 AM_CONDITIONAL([COND_i386_xen], [test x$target_cpu = xi386 -a x$platform = xxen])
1876 AM_CONDITIONAL([COND_x86_64_xen], [test x$target_cpu = xx86_64 -a x$platform = xxen])
1877 AM_CONDITIONAL([COND_mips_loongson], [test x$target_cpu = xmipsel -a x$platform = xloongson])
1878 AM_CONDITIONAL([COND_mips_qemu_mips], [test "(" x$target_cpu = xmips -o x$target_cpu = xmipsel ")"  -a x$platform = xqemu_mips])
1879 AM_CONDITIONAL([COND_mips_arc], [test "(" x$target_cpu = xmips -o x$target_cpu = xmipsel ")"  -a x$platform = xarc])
1880 AM_CONDITIONAL([COND_sparc64_ieee1275], [test x$target_cpu = xsparc64 -a x$platform = xieee1275])
1881 AM_CONDITIONAL([COND_sparc64_emu], [test x$target_cpu = xsparc64 -a x$platform = xemu])
1882 AM_CONDITIONAL([COND_powerpc_ieee1275], [test x$target_cpu = xpowerpc -a x$platform = xieee1275])
1883 AM_CONDITIONAL([COND_mips], [test x$target_cpu = xmips -o x$target_cpu = xmipsel])
1884 AM_CONDITIONAL([COND_mipsel], [test x$target_cpu = xmipsel])
1885 AM_CONDITIONAL([COND_mipseb], [test x$target_cpu = xmips])
1886 AM_CONDITIONAL([COND_arm], [test x$target_cpu = xarm ])
1887 AM_CONDITIONAL([COND_arm_uboot], [test x$target_cpu = xarm -a x$platform = xuboot])
1888 AM_CONDITIONAL([COND_arm_efi], [test x$target_cpu = xarm -a x$platform = xefi])
1889 AM_CONDITIONAL([COND_arm64], [test x$target_cpu = xarm64 ])
1890 AM_CONDITIONAL([COND_arm64_efi], [test x$target_cpu = xarm64 -a x$platform = xefi])
1891
1892 AM_CONDITIONAL([COND_HOST_HURD], [test x$host_kernel = xhurd])
1893 AM_CONDITIONAL([COND_HOST_LINUX], [test x$host_kernel = xlinux])
1894 AM_CONDITIONAL([COND_HOST_NETBSD], [test x$host_kernel = xnetbsd])
1895 AM_CONDITIONAL([COND_HOST_WINDOWS], [test x$host_kernel = xwindows])
1896 AM_CONDITIONAL([COND_HOST_KFREEBSD], [test x$host_kernel = xkfreebsd])
1897 AM_CONDITIONAL([COND_HOST_XNU], [test x$host_kernel = xxnu])
1898 AM_CONDITIONAL([COND_HOST_ILLUMOS], [test x$host_kernel = xillumos])
1899
1900 AM_CONDITIONAL([COND_MAN_PAGES], [test x$cross_compiling = xno -a x$HELP2MAN != x])
1901 AM_CONDITIONAL([COND_GRUB_EMU_SDL], [test x$enable_grub_emu_sdl = xyes])
1902 AM_CONDITIONAL([COND_GRUB_EMU_PCI], [test x$enable_grub_emu_pci = xyes])
1903 AM_CONDITIONAL([COND_GRUB_MKFONT], [test x$enable_grub_mkfont = xyes])
1904 AM_CONDITIONAL([COND_GRUB_MOUNT], [test x$enable_grub_mount = xyes])
1905 AM_CONDITIONAL([COND_HAVE_FONT_SOURCE], [test x$FONT_SOURCE != x])
1906 if test x$FONT_SOURCE != x ; then
1907    HAVE_FONT_SOURCE=1
1908 else
1909    HAVE_FONT_SOURCE=0
1910 fi
1911 AC_SUBST(HAVE_FONT_SOURCE)
1912 AM_CONDITIONAL([COND_APPLE_LINKER], [test x$TARGET_APPLE_LINKER = x1])
1913 AM_CONDITIONAL([COND_ENABLE_EFIEMU], [test x$enable_efiemu = xyes])
1914 AM_CONDITIONAL([COND_ENABLE_CACHE_STATS], [test x$DISK_CACHE_STATS = x1])
1915 AM_CONDITIONAL([COND_ENABLE_BOOT_TIME_STATS], [test x$BOOT_TIME_STATS = x1])
1916
1917 AM_CONDITIONAL([COND_HAVE_CXX], [test x$HAVE_CXX = xyes])
1918
1919 AM_CONDITIONAL([COND_HAVE_ASM_USCORE], [test x$HAVE_ASM_USCORE = x1])
1920 AM_CONDITIONAL([COND_STARFIELD], [test "x$starfield_excuse" = x])
1921 AM_CONDITIONAL([COND_HAVE_EXEC], [test "x$have_exec" = xy])
1922
1923 test "x$prefix" = xNONE && prefix="$ac_default_prefix"
1924 test "x$exec_prefix" = xNONE && exec_prefix="${prefix}"
1925 datarootdir="$(eval echo "$datarootdir")"
1926 grub_libdir="$(eval echo "$libdir")"
1927 grub_localedir="$(eval echo "$localedir")"
1928 grub_datadir="$(eval echo "$datadir")"
1929 grub_sysconfdir="$(eval echo "$sysconfdir")"
1930 AC_DEFINE_UNQUOTED(LOCALEDIR, "$grub_localedir", [Locale dir])
1931 AC_DEFINE_UNQUOTED(GRUB_LIBDIR, "$grub_libdir", [Library dir])
1932 AC_DEFINE_UNQUOTED(GRUB_DATADIR, "$grub_datadir", [Data dir])
1933 AC_DEFINE_UNQUOTED(GRUB_SYSCONFDIR, "$grub_sysconfdir", [Configuration dir])
1934
1935
1936 # Output files.
1937 if test "$platform" != none; then
1938   cpudir="${target_cpu}"
1939   if test x${cpudir} = xmipsel; then
1940     cpudir=mips;
1941   fi
1942   grub_CHECK_LINK_DIR
1943   if test x"$link_dir" = xyes ; then
1944     AC_CONFIG_LINKS([include/grub/cpu:include/grub/$cpudir])
1945     if test "$platform" != emu ; then
1946       AC_CONFIG_LINKS([include/grub/machine:include/grub/$cpudir/$platform])
1947     fi
1948   else
1949     mkdir -p include/grub 2>/dev/null
1950     rm -rf include/grub/cpu
1951     cp -rp $srcdir/include/grub/$cpudir include/grub/cpu 2>/dev/null
1952     if test "$platform" != emu ; then
1953       rm -rf include/grub/machine
1954       cp -rp $srcdir/include/grub/$cpudir/$platform include/grub/machine 2>/dev/null
1955     fi
1956   fi
1957 else
1958   # Just enough to stop the compiler failing with -I$(srcdir)/include.
1959   mkdir -p include 2>/dev/null
1960   rm -rf include/grub/cpu include/grub/machine
1961 fi
1962
1963 AC_CONFIG_FILES([Makefile])
1964 AC_CONFIG_FILES([grub-core/Makefile])
1965 AC_CONFIG_FILES([grub-core/gnulib/Makefile])
1966 AC_CONFIG_FILES([po/Makefile.in])
1967 AC_CONFIG_FILES([docs/Makefile])
1968 AC_CONFIG_FILES([util/bash-completion.d/Makefile])
1969 AC_CONFIG_FILES([stamp-h], [echo timestamp > stamp-h])
1970 AC_CONFIG_FILES([config.h])
1971
1972 AC_OUTPUT
1973 [
1974 echo "*******************************************************"
1975 echo GRUB2 will be compiled with following components:
1976 echo Platform: "$target_cpu"-"$platform"
1977 if [ x"$platform" = xemu ]; then
1978 if [ x"$grub_emu_sdl_excuse" = x ]; then
1979 echo SDL support for grub-emu: Yes
1980 else
1981 echo SDL support for grub-emu: No "($grub_emu_sdl_excuse)"
1982 fi
1983 if [ x"$grub_emu_pci_excuse" = x ]; then
1984 echo PCI support for grub-emu: Yes
1985 else
1986 echo PCI support for grub-emu: No "($grub_emu_pci_excuse)"
1987 fi
1988 fi
1989 if test x"$device_mapper_excuse" = x ; then
1990 echo With devmapper support: Yes
1991 else
1992 echo With devmapper support: No "($device_mapper_excuse)"
1993 fi
1994 if [ x"$enable_mm_debug" = xyes ]; then
1995 echo With memory debugging: Yes
1996 else
1997 echo With memory debugging: No
1998 fi
1999 if [ x"$enable_cache_stats" = xyes ]; then
2000 echo With disk cache statistics: Yes
2001 else
2002 echo With disk cache statistics: No
2003 fi
2004
2005 if [ x"$enable_boot_time" = xyes ]; then
2006 echo With boot time statistics: Yes
2007 else
2008 echo With boot time statistics: No
2009 fi
2010
2011 if [ x"$efiemu_excuse" = x ]; then
2012 echo efiemu runtime: Yes
2013 else
2014 echo efiemu runtime: No "($efiemu_excuse)"
2015 fi
2016 if [ x"$grub_mkfont_excuse" = x ]; then
2017 echo grub-mkfont: Yes
2018 else
2019 echo grub-mkfont: No "($grub_mkfont_excuse)"
2020 fi
2021 if [ x"$grub_mount_excuse" = x ]; then
2022 echo grub-mount: Yes
2023 else
2024 echo grub-mount: No "($grub_mount_excuse)"
2025 fi
2026 if [ x"$starfield_excuse" = x ]; then
2027 echo starfield theme: Yes
2028 echo With DejaVuSans font from $DJVU_FONT_SOURCE
2029 else
2030 echo starfield theme: No "($starfield_excuse)"
2031 fi
2032 if [ x"$libzfs_excuse" = x ]; then
2033 echo With libzfs support: Yes
2034 else
2035 echo With libzfs support: No "($libzfs_excuse)"
2036 fi
2037 if [ x"$grub_build_mkfont_excuse" = x ]; then
2038   echo Build-time grub-mkfont: Yes
2039   if test "x$FONT_SOURCE" = x ; then
2040     echo "Without unifont"
2041   else
2042     echo "With unifont from $FONT_SOURCE"
2043   fi
2044 else
2045   echo Build-time grub-mkfont: No "($grub_build_mkfont_excuse)"
2046   echo "Without unifont (no build-time grub-mkfont)"
2047 fi
2048 if test x"$liblzma_excuse" != x ; then
2049 echo "Without liblzma (no support for XZ-compressed mips images) ($liblzma_excuse)"
2050 else
2051 echo "With liblzma from $LIBLZMA (support for XZ-compressed mips images)"
2052 fi
2053 echo "*******************************************************"
2054 ]