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