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