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 grub_CHECK_NO_PIE
1189 [# Need that, because some distributions ship compilers that include
1190 # `-fPIE' or '-fpie' and '-pie' in the default specs.
1191 if [ x"$pie_possible" = xyes ]; then
1192   TARGET_CFLAGS="$TARGET_CFLAGS -fno-PIE -fno-pie"
1193 fi
1194 if [ x"$nopie_possible" = xyes ] &&  [ x"$pie_possible" = xyes ]; then
1195   TARGET_LDFLAGS="$TARGET_LDFLAGS -no-pie"
1196 fi]
1197
1198 CFLAGS="$TARGET_CFLAGS"
1199 LDFLAGS="$TARGET_LDFLAGS"
1200
1201 # Position independent executable.
1202 grub_CHECK_PIC
1203 [# On most platforms we don't want PIC as it only makes relocations harder
1204 # and code less efficient. On mips we want to have one got table per module
1205 # and reload $gp in every function.
1206 # GCC implements it using symbol __gnu_local_gp in non-PIC as well.
1207 # However with clang we need PIC for this reloading to happen.
1208 # Since default varies across dictributions use either -fPIC or -fno-PIC
1209 # explicitly.
1210 if ( test x$target_cpu = xmips || test x$target_cpu = xmipsel ) && test "x$grub_cv_cc_target_clang" = xyes ; then
1211    TARGET_CFLAGS="$TARGET_CFLAGS -fPIC"
1212 elif [ x"$pic_possible" = xyes ]; then
1213    TARGET_CFLAGS="$TARGET_CFLAGS -fno-PIC"
1214 fi]
1215
1216 CFLAGS="$TARGET_CFLAGS"
1217
1218 # Smashing stack protector.
1219 grub_CHECK_STACK_PROTECTOR
1220 # Need that, because some distributions ship compilers that include
1221 # `-fstack-protector' in the default specs.
1222 if test "x$ssp_possible" = xyes; then
1223   TARGET_CFLAGS="$TARGET_CFLAGS -fno-stack-protector"
1224 fi
1225
1226 CFLAGS="$TARGET_CFLAGS"
1227
1228 grub_CHECK_STACK_ARG_PROBE
1229 # Cygwin's GCC uses alloca() to probe the stackframe on static
1230 # stack allocations above some threshold.
1231 if test x"$sap_possible" = xyes; then
1232   TARGET_CFLAGS="$TARGET_CFLAGS -mno-stack-arg-probe"
1233 fi
1234
1235 CFLAGS="$TARGET_CFLAGS"
1236
1237 # -mno-unaligned-access -mstrict-align
1238 if test "$target_cpu" = arm; then
1239   AC_CACHE_CHECK([for compile options to get strict alignment], [grub_cv_target_cc_strict_align], [
1240     grub_cv_target_cc_strict_align=
1241     for arg in -mno-unaligned-access "-Xclang -mstrict-align" -mstrict-align; do
1242       CFLAGS="$TARGET_CFLAGS $arg -Werror"
1243       LDFLAGS="$TARGET_LDFLAGS"
1244       AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])], [flag=1], [flag=0])
1245       if test x"$flag" = x1; then
1246         grub_cv_target_cc_strict_align="$arg"
1247         break
1248       fi
1249     done])
1250
1251   TARGET_CFLAGS="$TARGET_CFLAGS $grub_cv_target_cc_strict_align"
1252   if test x"$grub_cv_target_cc_strict_align" = x"-Xclang -mstrict-align"; then
1253     TARGET_LDFLAGS="$TARGET_LDFLAGS -Qunused-arguments"
1254   fi
1255   AC_CACHE_CHECK([if compiler generates unaligned accesses], [grub_cv_cc_target_emits_unaligned],
1256   [CFLAGS="$TARGET_CFLAGS"
1257    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[
1258 #ifdef __ARM_FEATURE_UNALIGNED
1259 #error "unaligned"
1260 #endif
1261      ]])],
1262      [grub_cv_cc_target_emits_unaligned=no], [grub_cv_cc_target_emits_unaligned=yes])])
1263   if test x$grub_cv_cc_target_emits_unaligned = xyes; then
1264     AC_MSG_ERROR([compiler generates unaligned accesses])
1265   fi
1266 fi
1267
1268 # Set them to their new values for the tests below.
1269 CC="$TARGET_CC"
1270 if test x"$platform" = xemu ; then
1271 CFLAGS="$TARGET_CFLAGS -Wno-error"
1272 elif test "x$TARGET_APPLE_LINKER" = x1 ; then
1273 CFLAGS="$TARGET_CFLAGS -nostdlib -static -Wno-error"
1274 else
1275 CFLAGS="$TARGET_CFLAGS -nostdlib -Wno-error"
1276 fi
1277 CPPFLAGS="$TARGET_CPPFLAGS"
1278
1279 grub_ASM_USCORE
1280 if test "x$TARGET_APPLE_LINKER" = x0 && test x"$platform" != xemu; then
1281 if test x$grub_cv_asm_uscore = xyes; then
1282 DEFSYM="-Wl,--defsym,_abort=_main -Wl,--defsym,__main=_main"
1283 else
1284 DEFSYM="-Wl,--defsym,abort=main -Wl,--defsym,_main=main -Wl,--defsym,__main=main"
1285 fi
1286 CFLAGS="$TARGET_CFLAGS -nostdlib $DEFSYM"
1287 fi
1288
1289 # Check for libgcc symbols
1290 if test x"$platform" = xemu; then
1291 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)
1292 fi
1293
1294 if test "x$TARGET_APPLE_LINKER" = x1 ; then
1295 CFLAGS="$TARGET_CFLAGS -nostdlib -static"
1296 else
1297 CFLAGS="$TARGET_CFLAGS -nostdlib"
1298 fi
1299 LIBS=""
1300
1301 # Defined in aclocal.m4.
1302 grub_PROG_TARGET_CC
1303 if test "x$TARGET_APPLE_LINKER" != x1 ; then
1304 grub_PROG_OBJCOPY_ABSOLUTE
1305 fi
1306 grub_PROG_LD_BUILD_ID_NONE
1307 if test "x$target_cpu" = xi386; then
1308   if test "$platform" != emu && test "x$TARGET_APPLE_LINKER" != x1 ; then
1309     if test ! -z "$TARGET_IMG_LDSCRIPT"; then
1310       # Check symbols provided by linker script.
1311       CFLAGS="$TARGET_CFLAGS -nostdlib ${TARGET_IMG_LDFLAGS_AC} ${TARGET_IMG_BASE_LDOPT},0x8000"
1312     fi
1313     grub_CHECK_BSS_START_SYMBOL
1314     grub_CHECK_END_SYMBOL
1315   fi
1316   CFLAGS="$TARGET_CFLAGS"
1317 fi
1318
1319 grub_PROG_NM_WORKS
1320 grub_PROG_NM_MINUS_P
1321 grub_PROG_NM_DEFINED_ONLY
1322 AC_SUBST(TARGET_NMFLAGS_MINUS_P)
1323 AC_SUBST(TARGET_NMFLAGS_DEFINED_ONLY)
1324
1325 if test "$platform" != emu; then
1326 AC_CACHE_CHECK([whether -nostdinc -isystem works], [grub_cv_cc_isystem], [
1327   SAVED_CPPFLAGS="$CPPFLAGS"
1328   CPPFLAGS="$TARGET_CPPFLAGS -nostdinc -isystem `$TARGET_CC -print-file-name=include`"
1329   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <stdarg.h>
1330 #include <stddef.h>
1331 int va_arg_func (int fixed, va_list args);]], [[]])],
1332       [grub_cv_cc_isystem=yes],
1333       [grub_cv_cc_isystem=no])
1334   CPPFLAGS="$SAVED_CPPFLAGS"
1335 ])
1336
1337 if test x"$grub_cv_cc_isystem" = xyes ; then
1338   TARGET_CPPFLAGS="$TARGET_CPPFLAGS -nostdinc -isystem `$TARGET_CC -print-file-name=include`"
1339 fi
1340 fi
1341
1342 AC_CACHE_CHECK([whether -Wtrampolines work], [grub_cv_cc_wtrampolines], [
1343   CFLAGS="$TARGET_CFLAGS -Wtrampolines -Werror"
1344   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <stdarg.h>
1345 int va_arg_func (int fixed, va_list args);]], [[]])],
1346       [grub_cv_cc_wtrampolines=yes],
1347       [grub_cv_cc_wtrampolines=no])
1348 ])
1349
1350 if test x"$grub_cv_cc_wtrampolines" = xyes ; then
1351   TARGET_CFLAGS="$TARGET_CFLAGS -Wtrampolines"
1352 fi
1353
1354 # Restore the flags.
1355 CC="$tmp_CC"
1356 CFLAGS="$tmp_CFLAGS"
1357 CPPFLAGS="$tmp_CPPFLAGS"
1358 LDFLAGS="$tmp_LDFLAGS"
1359 LIBS="$tmp_LIBS"
1360
1361 #
1362 # Check for options.
1363 #
1364
1365 # Memory manager debugging.
1366 AC_ARG_ENABLE([mm-debug],
1367               AS_HELP_STRING([--enable-mm-debug],
1368                              [include memory manager debugging]),
1369               [AC_DEFINE([MM_DEBUG], [1],
1370                          [Define to 1 if you enable memory manager debugging.])])
1371
1372 AC_ARG_ENABLE([cache-stats],
1373               AS_HELP_STRING([--enable-cache-stats],
1374                              [enable disk cache statistics collection]))
1375
1376 if test x$enable_cache_stats = xyes; then
1377   DISK_CACHE_STATS=1
1378 else
1379   DISK_CACHE_STATS=0
1380 fi
1381 AC_SUBST([DISK_CACHE_STATS])
1382
1383 AC_ARG_ENABLE([boot-time],
1384               AS_HELP_STRING([--enable-boot-time],
1385                              [enable boot time statistics collection]))
1386
1387 if test x$enable_boot_time = xyes; then
1388   BOOT_TIME_STATS=1
1389 else
1390   BOOT_TIME_STATS=0
1391 fi
1392 AC_SUBST([BOOT_TIME_STATS])
1393
1394 AC_ARG_ENABLE([grub-emu-sdl],
1395               [AS_HELP_STRING([--enable-grub-emu-sdl],
1396                              [build and install the `grub-emu' debugging utility with SDL support (default=guessed)])])
1397
1398 AC_ARG_ENABLE([grub-emu-pci],
1399               [AS_HELP_STRING([--enable-grub-emu-pci],
1400                              [build and install the `grub-emu' debugging utility with PCI support (potentially dangerous) (default=no)])])
1401
1402 if test "$platform" = emu; then
1403
1404 if test x"$enable_grub_emu_sdl" = xno ; then
1405   grub_emu_sdl_excuse="explicitly disabled"
1406 fi
1407 [if [ x"$grub_emu_sdl_excuse" = x ]; then
1408     # Check for libSDL libraries.]
1409 AC_CHECK_LIB([SDL], [SDL_Init], [LIBSDL="-lSDL"],
1410     [grub_emu_sdl_excuse=["libSDL libraries are required to build \`grub-emu' with SDL support"]])
1411     AC_SUBST([LIBSDL])
1412 [fi]
1413
1414 [if [ x"$grub_emu_sdl_excuse" = x ]; then
1415     # Check for headers.]
1416     AC_CHECK_HEADERS([SDL/SDL.h], [],
1417       [grub_emu_sdl_excuse=["libSDL header file is required to build \`grub-emu' with SDL support"]])
1418 [fi]
1419
1420 if test x"enable_grub_emu_sdl" = xyes && test x"$grub_emu_sdl_excuse" != x ; then
1421   AC_MSG_ERROR([SDL support for grub-emu was explicitly requested but can't be compiled ($grub_emu_sdl_excuse)])
1422 fi
1423 if test x"$grub_emu_sdl_excuse" = x ; then
1424 enable_grub_emu_sdl=yes
1425 else
1426 enable_grub_emu_sdl=no
1427 fi
1428
1429 if test x"$enable_grub_emu_pci" != xyes ; then
1430    grub_emu_pci_excuse="not enabled"
1431 fi
1432
1433 [if [ x"$grub_emu_pci_excuse" = x ]; then
1434       # Check for libpci libraries.]
1435    AC_CHECK_LIB([pciaccess], [pci_system_init], [LIBPCIACCESS="-lpciaccess"],
1436       [grub_emu_pci_excuse=["need libpciaccess library"]])
1437     AC_SUBST([LIBPCIACCESS])
1438 [fi]
1439 [if [ x"$grub_emu_pci_excuse" = x ]; then
1440     # Check for headers.]
1441     AC_CHECK_HEADERS([pciaccess.h], [],
1442       [grub_emu_pci_excuse=["need libpciaccess headers"]])
1443 [fi]
1444
1445 if test x"$grub_emu_pci_excuse" = x ; then
1446 enable_grub_emu_pci=yes
1447 else
1448
1449 enable_grub_emu_pci=no
1450 fi
1451
1452 AC_SUBST([enable_grub_emu_sdl])
1453 AC_SUBST([enable_grub_emu_pci])
1454
1455 else
1456
1457 # Ignore --enable-emu-* if platform is not emu
1458 enable_grub_emu_sdl=no
1459 enable_grub_emu_pci=no
1460 fi
1461
1462 AC_ARG_ENABLE([grub-mkfont],
1463               [AS_HELP_STRING([--enable-grub-mkfont],
1464                              [build and install the `grub-mkfont' utility (default=guessed)])])
1465 if test x"$enable_grub_mkfont" = xno ; then
1466   grub_mkfont_excuse="explicitly disabled"
1467 fi
1468
1469 if test x"$grub_mkfont_excuse" = x ; then
1470   # Check for freetype libraries.
1471   AC_CHECK_TOOLS([FREETYPE], [freetype-config])
1472   if test "x$FREETYPE" = x ; then
1473     grub_mkfont_excuse=["need freetype2 library"]
1474   fi
1475 fi
1476
1477 unset ac_cv_header_ft2build_h
1478
1479 if test x"$grub_mkfont_excuse" = x ; then
1480   # Check for freetype libraries.
1481   freetype_cflags=`$FREETYPE --cflags`
1482   freetype_libs=`$FREETYPE --libs`
1483   SAVED_CPPFLAGS="$CPPFLAGS"
1484   SAVED_LIBS="$LIBS"
1485   CPPFLAGS="$CPPFLAGS $freetype_cflags"
1486   LIBS="$LIBS $freetype_libs"
1487   AC_CHECK_HEADERS([ft2build.h], [],
1488         [grub_mkfont_excuse=["need freetype2 headers"]])
1489   AC_LINK_IFELSE([AC_LANG_CALL([], [FT_Load_Glyph])], [], [grub_mkfont_excuse=["freetype2 library unusable"]])
1490   CPPFLAGS="$SAVED_CPPFLAGS"
1491   LIBS="$SAVED_LIBS"
1492 fi
1493
1494 if test x"$enable_grub_mkfont" = xyes && test x"$grub_mkfont_excuse" != x ; then
1495   AC_MSG_ERROR([grub-mkfont was explicitly requested but can't be compiled ($grub_mkfont_excuse)])
1496 fi
1497 if test x"$grub_mkfont_excuse" = x ; then
1498 enable_grub_mkfont=yes
1499 else
1500 enable_grub_mkfont=no
1501 fi
1502 AC_SUBST([enable_grub_mkfont])
1503 AC_SUBST([freetype_cflags])
1504 AC_SUBST([freetype_libs])
1505
1506 SAVED_CC="$CC"
1507 SAVED_CPP="$CPP"
1508 SAVED_CFLAGS="$CFLAGS"
1509 SAVED_CPPFLAGS="$CPPFLAGS"
1510 SAVED_LDFLAGS="$LDFLAGS"
1511 CC="$BUILD_CC"
1512 CPP="$BUILD_CPP"
1513 CFLAGS="$BUILD_CFLAGS"
1514 CPPFLAGS="$BUILD_CPPFLAGS"
1515 LDFLAGS="$BUILD_LDFAGS"
1516
1517 unset ac_cv_c_bigendian
1518 unset ac_cv_header_ft2build_h
1519
1520 AC_COMPUTE_INT([BUILD_SIZEOF_VOID_P], [sizeof (void *)])
1521 AC_COMPUTE_INT([BUILD_SIZEOF_LONG], [sizeof (long)])
1522 AC_C_BIGENDIAN([BUILD_WORDS_BIGENDIAN=1], [BUILD_WORDS_BIGENDIAN=0], [BUILD_WORDS_BIGENDIAN=err], [BUILD_WORDS_BIGENDIAN=err])
1523
1524 if test x$BUILD_WORDS_BIGENDIAN = xerr ; then
1525    AC_MSG_ERROR([couldnt determine build endianness])
1526 fi
1527
1528 AC_SUBST([BUILD_SIZEOF_LONG])
1529 AC_SUBST([BUILD_SIZEOF_VOID_P])
1530 AC_SUBST([BUILD_WORDS_BIGENDIAN])
1531
1532 if test x"$grub_build_mkfont_excuse" = x ; then
1533   # Check for freetype libraries.
1534   AC_CHECK_PROGS([BUILD_FREETYPE], [freetype-config])
1535   if test "x$BUILD_FREETYPE" = x ; then
1536     grub_build_mkfont_excuse=["need freetype2 library"]
1537   fi
1538 fi
1539
1540 if test x"$grub_build_mkfont_excuse" = x ; then
1541   # Check for freetype libraries.
1542   build_freetype_cflags=`$BUILD_FREETYPE --cflags`
1543   build_freetype_libs=`$BUILD_FREETYPE --libs`
1544   SAVED_CPPFLAGS_2="$CPPFLAGS"
1545   SAVED_LIBS="$LIBS"
1546   CPPFLAGS="$CPPFLAGS $build_freetype_cflags"
1547   LIBS="$LIBS $build_freetype_libs"
1548   AC_CHECK_HEADERS([ft2build.h], [],
1549         [grub_build_mkfont_excuse=["need freetype2 headers"]])
1550   AC_LINK_IFELSE([AC_LANG_CALL([], [FT_Load_Glyph])], [], [grub_build_mkfont_excuse=["freetype2 library unusable"]])
1551   LIBS="$SAVED_LIBS"
1552   CPPFLAGS="$SAVED_CPPFLAGS_2"
1553 fi
1554
1555 if test x"$enable_build_grub_mkfont" = xyes && test x"$grub_build_mkfont_excuse" != x ; then
1556   AC_MSG_ERROR([build-grub-mkfont was explicitly requested but can't be compiled ($grub_build_mkfont_excuse)])
1557 fi
1558 if test x"$grub_build_mkfont_excuse" = x ; then
1559   enable_build_grub_mkfont=yes
1560 else
1561   enable_build_grub_mkfont=no
1562 fi
1563 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
1564   if test x"$grub_build_mkfont_excuse" = x ; then
1565     AC_MSG_ERROR([qemu, coreboot and loongson ports need build-time grub-mkfont])
1566   else
1567     AC_MSG_ERROR([qemu, coreboot and loongson ports need build-time grub-mkfont ($grub_build_mkfont_excuse)])
1568   fi
1569 fi
1570
1571 AC_SUBST([build_freetype_cflags])
1572 AC_SUBST([build_freetype_libs])
1573
1574 CC="$SAVED_CC"
1575 CPP="$SAVED_CPP"
1576 CFLAGS="$SAVED_CFLAGS"
1577 CPPFLAGS="$SAVED_CPPFLAGS"
1578 LDFLAGS="$SAVED_LDFLAGS"
1579
1580
1581 DJVU_FONT_SOURCE=
1582
1583 starfield_excuse=
1584
1585 AC_ARG_ENABLE([grub-themes],
1586               [AS_HELP_STRING([--enable-grub-themes],
1587                              [build and install GRUB themes (default=guessed)])])
1588 if test x"$enable_grub_themes" = xno ; then
1589   starfield_excuse="explicitly disabled"
1590 fi
1591
1592 if test x"$starfield_excuse" = x && test x"$enable_build_grub_mkfont" = xno ; then
1593   starfield_excuse="No build-time grub-mkfont"
1594 fi
1595
1596 if test x"$starfield_excuse" = x; then
1597    for ext in pcf pcf.gz bdf bdf.gz ttf ttf.gz; do
1598      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
1599         if test -f "$dir/DejaVuSans.$ext"; then
1600           DJVU_FONT_SOURCE="$dir/DejaVuSans.$ext"
1601           break 2
1602         fi
1603      done
1604    done
1605
1606    if test "x$DJVU_FONT_SOURCE" = x; then
1607      starfield_excuse="No DejaVu found"
1608    fi
1609 fi
1610
1611 if test x"$enable_grub_themes" = xyes &&  test x"$starfield_excuse" != x; then
1612    AC_MSG_ERROR([themes were explicitly requested but requirements are not satisfied ($starfield_excuse)])
1613 fi
1614
1615 AC_SUBST([DJVU_FONT_SOURCE])
1616
1617 FONT_SOURCE=
1618
1619 for ext in pcf pcf.gz bdf bdf.gz ttf ttf.gz; do
1620   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
1621     if test -f "$dir/unifont.$ext"; then
1622       md5="$(md5sum "$dir/unifont.$ext"|awk '{ print $1; }')"
1623       # PCF and BDF from version 6.3 isn't hanled properly by libfreetype.
1624       if test "$md5" = 0a54834d2788c83886a3e1785a6a1e61 || test "$md5" = 28f2565c7a41d8d407e2551159385edb || test "$md5" = dae5e588461b3b92b87b6ffee734f936 || test "$md5" = 4a3d687aa5bb329ed05f4263a1016791 ; then
1625         continue
1626       fi
1627       FONT_SOURCE="$dir/unifont.$ext"
1628       break 2
1629     fi
1630   done
1631 done
1632
1633 if test x"$enable_build_grub_mkfont" = xno ; then
1634   FONT_SOURCE=
1635 fi
1636
1637 if test "x$FONT_SOURCE" = x && ( test "x$platform" = xqemu || test "x$platform" = xloongson || test "x$platform" = xqemu_mips || test "x$platform" = xcoreboot ); then
1638   if test x"$grub_build_mkfont_excuse" = x ; then
1639     AC_MSG_ERROR([qemu, coreboot and loongson ports need unifont])
1640   else
1641     AC_MSG_ERROR([qemu, coreboot and loongson ports need unifont ($grub_build_mkfont_excuse)])
1642   fi
1643 fi
1644
1645 AC_SUBST([FONT_SOURCE])
1646
1647 if test x"$FONT_SOURCE" = x &&  test x"$DJVU_FONT_SOURCE" = x && test x"$grub_build_mkfont_excuse" = x; then
1648   grub_build_mkfont_excuse="no fonts"
1649 fi
1650
1651
1652 AC_ARG_ENABLE([grub-mount],
1653               [AS_HELP_STRING([--enable-grub-mount],
1654                              [build and install the `grub-mount' utility (default=guessed)])])
1655 if test x"$enable_grub_mount" = xno ; then
1656   grub_mount_excuse="explicitly disabled"
1657 fi
1658
1659 if test x"$grub_mount_excuse" = x ; then
1660   AC_CHECK_LIB([fuse], [fuse_main_real], [],
1661                [grub_mount_excuse="need FUSE library"])
1662 fi
1663
1664 if test x"$grub_mount_excuse" = x ; then
1665   # Check for fuse headers.
1666   SAVED_CPPFLAGS="$CPPFLAGS"
1667   CPPFLAGS="$CPPFLAGS -DFUSE_USE_VERSION=26"
1668   AC_CHECK_HEADERS([fuse/fuse.h], [],
1669         [grub_mount_excuse=["need FUSE headers"]])
1670   CPPFLAGS="$SAVED_CPPFLAGS"
1671 fi
1672
1673 if test x"$enable_grub_mount" = xyes && test x"$grub_mount_excuse" != x ; then
1674   AC_MSG_ERROR([grub-mount was explicitly requested but can't be compiled ($grub_mount_excuse)])
1675 fi
1676 if test x"$grub_mount_excuse" = x ; then
1677 enable_grub_mount=yes
1678 else
1679 enable_grub_mount=no
1680 fi
1681 AC_SUBST([enable_grub_mount])
1682
1683 AC_ARG_ENABLE([device-mapper],
1684               [AS_HELP_STRING([--enable-device-mapper],
1685                               [enable Linux device-mapper support (default=guessed)])])
1686 if test x"$enable_device_mapper" = xno ; then
1687   device_mapper_excuse="explicitly disabled"
1688 fi
1689
1690 if test x"$device_mapper_excuse" = x ; then
1691   # Check for device-mapper header.
1692   AC_CHECK_HEADER([libdevmapper.h], [],
1693                [device_mapper_excuse="need libdevmapper header"])
1694 fi
1695
1696 if test x"$device_mapper_excuse" = x ; then
1697   # Check for device-mapper library.
1698   AC_CHECK_LIB([devmapper], [dm_task_create], [],
1699                [device_mapper_excuse="need devmapper library"])
1700 fi
1701
1702 if test x"$device_mapper_excuse" = x ; then
1703   # Check for device-mapper library.
1704   AC_CHECK_LIB([devmapper], [dm_log_with_errno_init],
1705                [],
1706                [device_mapper_excuse="need devmapper library"])
1707 fi
1708
1709 if test x"$device_mapper_excuse" = x ; then
1710    LIBDEVMAPPER="-ldevmapper"
1711    AC_DEFINE([HAVE_DEVICE_MAPPER], [1],
1712              [Define to 1 if you have the devmapper library.])
1713 fi
1714
1715 AC_SUBST([LIBDEVMAPPER])
1716
1717 LIBGEOM=
1718 if test x$host_kernel = xkfreebsd; then
1719   AC_CHECK_LIB([geom], [geom_gettree], [],
1720                [AC_MSG_ERROR([Your platform requires libgeom])])
1721   LIBGEOM="-lgeom"
1722 fi
1723
1724 AC_SUBST([LIBGEOM])
1725
1726 AC_ARG_ENABLE([liblzma],
1727               [AS_HELP_STRING([--enable-liblzma],
1728                               [enable liblzma integration (default=guessed)])])
1729 if test x"$enable_liblzma" = xno ; then
1730   liblzma_excuse="explicitly disabled"
1731 fi
1732
1733 if test x"$liblzma_excuse" = x ; then
1734 AC_CHECK_LIB([lzma], [lzma_code],
1735              [],[liblzma_excuse="need lzma library"])
1736 fi
1737 if test x"$liblzma_excuse" = x ; then
1738 AC_CHECK_HEADER([lzma.h], [], [liblzma_excuse="need lzma header"])
1739 fi
1740
1741 if test x"$enable_liblzma" = xyes && test x"$liblzma_excuse" != x ; then
1742   AC_MSG_ERROR([liblzma support was explicitly requested but requirements are not satisfied ($liblzma_excuse)])
1743 fi
1744
1745
1746 if test x"$liblzma_excuse" = x ; then
1747    LIBLZMA="-llzma"
1748    AC_DEFINE([USE_LIBLZMA], [1],
1749              [Define to 1 if you have the LZMA library.])
1750 fi
1751
1752 AC_SUBST([LIBLZMA])
1753
1754 AC_ARG_ENABLE([libzfs],
1755               [AS_HELP_STRING([--enable-libzfs],
1756                               [enable libzfs integration (default=guessed)])])
1757 if test x"$enable_libzfs" = xno ; then
1758   libzfs_excuse="explicitly disabled"
1759 fi
1760
1761 if test x"$libzfs_excuse" = x ; then
1762   # Only check for system headers if libzfs support has not been disabled.
1763   AC_CHECK_HEADERS(libzfs.h libnvpair.h)
1764 fi
1765
1766 if test x"$libzfs_excuse" = x ; then
1767   AC_CHECK_LIB([zfs], [libzfs_init],
1768                [],
1769                [libzfs_excuse="need zfs library"])
1770 fi
1771
1772 if test x"$libzfs_excuse" = x ; then
1773   AC_CHECK_LIB([nvpair], [nvlist_lookup_string],
1774                [],
1775                [libzfs_excuse="need nvpair library"])
1776 fi
1777
1778 if test x"$enable_libzfs" = xyes && test x"$libzfs_excuse" != x ; then
1779   AC_MSG_ERROR([libzfs support was explicitly requested but requirements are not satisfied ($libzfs_excuse)])
1780 fi
1781
1782 if test x"$libzfs_excuse" = x ; then
1783   # We need both libzfs and libnvpair for a successful build.
1784   LIBZFS="-lzfs"
1785   AC_DEFINE([HAVE_LIBZFS], [1],
1786             [Define to 1 if you have the ZFS library.])
1787   LIBNVPAIR="-lnvpair"
1788   AC_DEFINE([HAVE_LIBNVPAIR], [1],
1789             [Define to 1 if you have the NVPAIR library.])
1790 fi
1791
1792 AC_SUBST([LIBZFS])
1793 AC_SUBST([LIBNVPAIR])
1794
1795 LIBS=""
1796
1797 AC_SUBST([FONT_SOURCE])
1798 AS_IF([test x$target_cpu = xi386 -a x$platform = xqemu],
1799             [AC_SUBST([GRUB_BOOT_MACHINE_LINK_ADDR], 0xffe00)])
1800
1801 AC_SUBST(HAVE_ASM_USCORE)
1802 AC_SUBST(BSS_START_SYMBOL)
1803 AC_SUBST(END_SYMBOL)
1804 AC_SUBST(PACKAGE)
1805 AC_SUBST(VERSION)
1806
1807 AC_ARG_ENABLE([werror],
1808               [AS_HELP_STRING([--disable-werror],
1809                              [do not use -Werror when building GRUB])])
1810 if test x"$enable_werror" != xno ; then
1811   TARGET_CFLAGS="$TARGET_CFLAGS -Werror"
1812   HOST_CFLAGS="$HOST_CFLAGS -Werror"
1813 fi
1814
1815 TARGET_CPP="$TARGET_CC -E"
1816 TARGET_CCAS=$TARGET_CC
1817
1818 # Includes which include make-time substitutions. They must come last
1819 # as to avoid executing top_builddir in shell.
1820 HOST_CPPFLAGS="$HOST_CPPFLAGS -I\$(top_builddir)/include"
1821 TARGET_CPPFLAGS="$TARGET_CPPFLAGS -I\$(top_srcdir)/include"
1822 TARGET_CPPFLAGS="$TARGET_CPPFLAGS -I\$(top_builddir)/include"
1823
1824 GRUB_TARGET_CPU="${target_cpu}"
1825 GRUB_PLATFORM="${platform}"
1826
1827 AC_SUBST(GRUB_TARGET_CPU)
1828 AC_SUBST(GRUB_PLATFORM)
1829
1830 AC_SUBST(TARGET_OBJCONV)
1831 AC_SUBST(TARGET_CPP)
1832 AC_SUBST(TARGET_CCAS)
1833 AC_SUBST(TARGET_OBJ2ELF)
1834 AC_SUBST(TARGET_MODULE_FORMAT)
1835 AC_SUBST(TARGET_CC_VERSION)
1836
1837 AC_SUBST(TARGET_CFLAGS)
1838 AC_SUBST(TARGET_LDFLAGS)
1839 AC_SUBST(TARGET_CPPFLAGS)
1840 AC_SUBST(TARGET_CCASFLAGS)
1841
1842 AC_SUBST(TARGET_IMG_LDFLAGS)
1843 AC_SUBST(TARGET_IMG_CFLAGS)
1844 AC_SUBST(TARGET_IMG_BASE_LDOPT)
1845 AC_SUBST(TARGET_APPLE_LINKER)
1846
1847 AC_SUBST(HOST_CFLAGS)
1848 AC_SUBST(HOST_LDFLAGS)
1849 AC_SUBST(HOST_CPPFLAGS)
1850 AC_SUBST(HOST_CCASFLAGS)
1851
1852 AC_SUBST(BUILD_LIBM)
1853
1854 #
1855 # Automake conditionals
1856 #
1857
1858 AM_CONDITIONAL([COND_real_platform], [test x$platform != xnone])
1859 AM_CONDITIONAL([COND_emu], [test x$platform = xemu])
1860 AM_CONDITIONAL([COND_i386_pc], [test x$target_cpu = xi386 -a x$platform = xpc])
1861 AM_CONDITIONAL([COND_i386_efi], [test x$target_cpu = xi386 -a x$platform = xefi])
1862 AM_CONDITIONAL([COND_ia64_efi], [test x$target_cpu = xia64 -a x$platform = xefi])
1863 AM_CONDITIONAL([COND_i386_qemu], [test x$target_cpu = xi386 -a x$platform = xqemu])
1864 AM_CONDITIONAL([COND_i386_ieee1275], [test x$target_cpu = xi386 -a x$platform = xieee1275])
1865 AM_CONDITIONAL([COND_i386_coreboot], [test x$target_cpu = xi386 -a x$platform = xcoreboot])
1866 AM_CONDITIONAL([COND_i386_multiboot], [test x$target_cpu = xi386 -a x$platform = xmultiboot])
1867 AM_CONDITIONAL([COND_x86_64_efi], [test x$target_cpu = xx86_64 -a x$platform = xefi])
1868 AM_CONDITIONAL([COND_i386_xen], [test x$target_cpu = xi386 -a x$platform = xxen])
1869 AM_CONDITIONAL([COND_x86_64_xen], [test x$target_cpu = xx86_64 -a x$platform = xxen])
1870 AM_CONDITIONAL([COND_mips_loongson], [test x$target_cpu = xmipsel -a x$platform = xloongson])
1871 AM_CONDITIONAL([COND_mips_qemu_mips], [test "(" x$target_cpu = xmips -o x$target_cpu = xmipsel ")"  -a x$platform = xqemu_mips])
1872 AM_CONDITIONAL([COND_mips_arc], [test "(" x$target_cpu = xmips -o x$target_cpu = xmipsel ")"  -a x$platform = xarc])
1873 AM_CONDITIONAL([COND_sparc64_ieee1275], [test x$target_cpu = xsparc64 -a x$platform = xieee1275])
1874 AM_CONDITIONAL([COND_sparc64_emu], [test x$target_cpu = xsparc64 -a x$platform = xemu])
1875 AM_CONDITIONAL([COND_powerpc_ieee1275], [test x$target_cpu = xpowerpc -a x$platform = xieee1275])
1876 AM_CONDITIONAL([COND_mips], [test x$target_cpu = xmips -o x$target_cpu = xmipsel])
1877 AM_CONDITIONAL([COND_mipsel], [test x$target_cpu = xmipsel])
1878 AM_CONDITIONAL([COND_mipseb], [test x$target_cpu = xmips])
1879 AM_CONDITIONAL([COND_arm], [test x$target_cpu = xarm ])
1880 AM_CONDITIONAL([COND_arm_uboot], [test x$target_cpu = xarm -a x$platform = xuboot])
1881 AM_CONDITIONAL([COND_arm_efi], [test x$target_cpu = xarm -a x$platform = xefi])
1882 AM_CONDITIONAL([COND_arm64], [test x$target_cpu = xarm64 ])
1883 AM_CONDITIONAL([COND_arm64_efi], [test x$target_cpu = xarm64 -a x$platform = xefi])
1884
1885 AM_CONDITIONAL([COND_HOST_HURD], [test x$host_kernel = xhurd])
1886 AM_CONDITIONAL([COND_HOST_LINUX], [test x$host_kernel = xlinux])
1887 AM_CONDITIONAL([COND_HOST_NETBSD], [test x$host_kernel = xnetbsd])
1888 AM_CONDITIONAL([COND_HOST_WINDOWS], [test x$host_kernel = xwindows])
1889 AM_CONDITIONAL([COND_HOST_KFREEBSD], [test x$host_kernel = xkfreebsd])
1890 AM_CONDITIONAL([COND_HOST_XNU], [test x$host_kernel = xxnu])
1891 AM_CONDITIONAL([COND_HOST_ILLUMOS], [test x$host_kernel = xillumos])
1892
1893 AM_CONDITIONAL([COND_MAN_PAGES], [test x$cross_compiling = xno -a x$HELP2MAN != x])
1894 AM_CONDITIONAL([COND_GRUB_EMU_SDL], [test x$enable_grub_emu_sdl = xyes])
1895 AM_CONDITIONAL([COND_GRUB_EMU_PCI], [test x$enable_grub_emu_pci = xyes])
1896 AM_CONDITIONAL([COND_GRUB_MKFONT], [test x$enable_grub_mkfont = xyes])
1897 AM_CONDITIONAL([COND_GRUB_MOUNT], [test x$enable_grub_mount = xyes])
1898 AM_CONDITIONAL([COND_HAVE_FONT_SOURCE], [test x$FONT_SOURCE != x])
1899 if test x$FONT_SOURCE != x ; then
1900    HAVE_FONT_SOURCE=1
1901 else
1902    HAVE_FONT_SOURCE=0
1903 fi
1904 AC_SUBST(HAVE_FONT_SOURCE)
1905 AM_CONDITIONAL([COND_APPLE_LINKER], [test x$TARGET_APPLE_LINKER = x1])
1906 AM_CONDITIONAL([COND_ENABLE_EFIEMU], [test x$enable_efiemu = xyes])
1907 AM_CONDITIONAL([COND_ENABLE_CACHE_STATS], [test x$DISK_CACHE_STATS = x1])
1908 AM_CONDITIONAL([COND_ENABLE_BOOT_TIME_STATS], [test x$BOOT_TIME_STATS = x1])
1909
1910 AM_CONDITIONAL([COND_HAVE_CXX], [test x$HAVE_CXX = xyes])
1911
1912 AM_CONDITIONAL([COND_HAVE_ASM_USCORE], [test x$HAVE_ASM_USCORE = x1])
1913 AM_CONDITIONAL([COND_STARFIELD], [test "x$starfield_excuse" = x])
1914 AM_CONDITIONAL([COND_HAVE_EXEC], [test "x$have_exec" = xy])
1915
1916 test "x$prefix" = xNONE && prefix="$ac_default_prefix"
1917 test "x$exec_prefix" = xNONE && exec_prefix="${prefix}"
1918 datarootdir="$(eval echo "$datarootdir")"
1919 grub_libdir="$(eval echo "$libdir")"
1920 grub_localedir="$(eval echo "$localedir")"
1921 grub_datadir="$(eval echo "$datadir")"
1922 grub_sysconfdir="$(eval echo "$sysconfdir")"
1923 AC_DEFINE_UNQUOTED(LOCALEDIR, "$grub_localedir", [Locale dir])
1924 AC_DEFINE_UNQUOTED(GRUB_LIBDIR, "$grub_libdir", [Library dir])
1925 AC_DEFINE_UNQUOTED(GRUB_DATADIR, "$grub_datadir", [Data dir])
1926 AC_DEFINE_UNQUOTED(GRUB_SYSCONFDIR, "$grub_sysconfdir", [Configuration dir])
1927
1928
1929 # Output files.
1930 if test "$platform" != none; then
1931   cpudir="${target_cpu}"
1932   if test x${cpudir} = xmipsel; then
1933     cpudir=mips;
1934   fi
1935   grub_CHECK_LINK_DIR
1936   if test x"$link_dir" = xyes ; then
1937     AC_CONFIG_LINKS([include/grub/cpu:include/grub/$cpudir])
1938     if test "$platform" != emu ; then
1939       AC_CONFIG_LINKS([include/grub/machine:include/grub/$cpudir/$platform])
1940     fi
1941   else
1942     mkdir -p include/grub 2>/dev/null
1943     rm -rf include/grub/cpu
1944     cp -rp $srcdir/include/grub/$cpudir include/grub/cpu 2>/dev/null
1945     if test "$platform" != emu ; then
1946       rm -rf include/grub/machine
1947       cp -rp $srcdir/include/grub/$cpudir/$platform include/grub/machine 2>/dev/null
1948     fi
1949   fi
1950 else
1951   # Just enough to stop the compiler failing with -I$(srcdir)/include.
1952   mkdir -p include 2>/dev/null
1953   rm -rf include/grub/cpu include/grub/machine
1954 fi
1955
1956 AC_CONFIG_FILES([Makefile])
1957 AC_CONFIG_FILES([grub-core/Makefile])
1958 AC_CONFIG_FILES([grub-core/gnulib/Makefile])
1959 AC_CONFIG_FILES([po/Makefile.in])
1960 AC_CONFIG_FILES([docs/Makefile])
1961 AC_CONFIG_FILES([util/bash-completion.d/Makefile])
1962 AC_CONFIG_FILES([stamp-h], [echo timestamp > stamp-h])
1963 AC_CONFIG_FILES([config.h])
1964
1965 AC_OUTPUT
1966 [
1967 echo "*******************************************************"
1968 echo GRUB2 will be compiled with following components:
1969 echo Platform: "$target_cpu"-"$platform"
1970 if [ x"$platform" = xemu ]; then
1971 if [ x"$grub_emu_sdl_excuse" = x ]; then
1972 echo SDL support for grub-emu: Yes
1973 else
1974 echo SDL support for grub-emu: No "($grub_emu_sdl_excuse)"
1975 fi
1976 if [ x"$grub_emu_pci_excuse" = x ]; then
1977 echo PCI support for grub-emu: Yes
1978 else
1979 echo PCI support for grub-emu: No "($grub_emu_pci_excuse)"
1980 fi
1981 fi
1982 if test x"$device_mapper_excuse" = x ; then
1983 echo With devmapper support: Yes
1984 else
1985 echo With devmapper support: No "($device_mapper_excuse)"
1986 fi
1987 if [ x"$enable_mm_debug" = xyes ]; then
1988 echo With memory debugging: Yes
1989 else
1990 echo With memory debugging: No
1991 fi
1992 if [ x"$enable_cache_stats" = xyes ]; then
1993 echo With disk cache statistics: Yes
1994 else
1995 echo With disk cache statistics: No
1996 fi
1997
1998 if [ x"$enable_boot_time" = xyes ]; then
1999 echo With boot time statistics: Yes
2000 else
2001 echo With boot time statistics: No
2002 fi
2003
2004 if [ x"$efiemu_excuse" = x ]; then
2005 echo efiemu runtime: Yes
2006 else
2007 echo efiemu runtime: No "($efiemu_excuse)"
2008 fi
2009 if [ x"$grub_mkfont_excuse" = x ]; then
2010 echo grub-mkfont: Yes
2011 else
2012 echo grub-mkfont: No "($grub_mkfont_excuse)"
2013 fi
2014 if [ x"$grub_mount_excuse" = x ]; then
2015 echo grub-mount: Yes
2016 else
2017 echo grub-mount: No "($grub_mount_excuse)"
2018 fi
2019 if [ x"$starfield_excuse" = x ]; then
2020 echo starfield theme: Yes
2021 echo With DejaVuSans font from $DJVU_FONT_SOURCE
2022 else
2023 echo starfield theme: No "($starfield_excuse)"
2024 fi
2025 if [ x"$libzfs_excuse" = x ]; then
2026 echo With libzfs support: Yes
2027 else
2028 echo With libzfs support: No "($libzfs_excuse)"
2029 fi
2030 if [ x"$grub_build_mkfont_excuse" = x ]; then
2031   echo Build-time grub-mkfont: Yes
2032   if test "x$FONT_SOURCE" = x ; then
2033     echo "Without unifont"
2034   else
2035     echo "With unifont from $FONT_SOURCE"
2036   fi
2037 else
2038   echo Build-time grub-mkfont: No "($grub_build_mkfont_excuse)"
2039   echo "Without unifont (no build-time grub-mkfont)"
2040 fi
2041 if test x"$liblzma_excuse" != x ; then
2042 echo "Without liblzma (no support for XZ-compressed mips images) ($liblzma_excuse)"
2043 else
2044 echo "With liblzma from $LIBLZMA (support for XZ-compressed mips images)"
2045 fi
2046 echo "*******************************************************"
2047 ]