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