~ubuntu-branches/ubuntu/trusty/grub2/trusty-updates

# -*- autoconf -*-

# Process this file with autoconf to produce a configure script.

# Copyright (C) 2002,2003,2004,2005,2006,2007,2008,2009,2010  Free Software Foundation, Inc.

#

# This configure.ac is free software; the author

# gives unlimited permission to copy and/or distribute it,

# with or without modifications, as long as this notice is preserved.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY, to the extent permitted by law; without

# even the implied warranty of MERCHANTABILITY or FITNESS FOR A

# PARTICULAR PURPOSE.

dnl This configure script is complicated, because GRUB needs to deal

dnl with three potentially different types:

dnl

dnl   build  -- the environment for building GRUB

dnl   host   -- the environment for running utilities

dnl   target -- the environment for running GRUB

dnl

dnl In addition, GRUB needs to deal with a platform specification

dnl which specifies the system running GRUB, such as firmware.

dnl This is necessary because the target type in autoconf does not

dnl describe such a system very well.

dnl

dnl The current strategy is to use variables with no prefix (such as

dnl CC, CFLAGS, etc.) for the host type as well as the build type,

dnl because GRUB does not need to use those variables for the build

dnl type, so there is no conflict. Variables with the prefix "TARGET_"

dnl (such as TARGET_CC, TARGET_CFLAGS, etc.) are used for the target

dnl type.

AC_INIT([GRUB],[2.02~beta2],[bug-grub@gnu.org])

AC_CONFIG_AUX_DIR([build-aux])

# We don't want -g -O2 by default in CFLAGS

: ${CFLAGS=""}

# Checks for host and target systems.

AC_CANONICAL_HOST

save_program_prefix="${program_prefix}"

AC_CANONICAL_TARGET

program_prefix="${save_program_prefix}"

AM_INIT_AUTOMAKE([1.10.1])

AC_PREREQ(2.60)

AC_CONFIG_SRCDIR([include/grub/dl.h])

AC_CONFIG_HEADER([config-util.h])

# Program name transformations

AC_ARG_PROGRAM

grub_TRANSFORM([grub-bios-setup])

grub_TRANSFORM([grub-editenv])

grub_TRANSFORM([grub-install])

grub_TRANSFORM([grub-mkconfig])

grub_TRANSFORM([grub-mkfont])

grub_TRANSFORM([grub-mkimage])

grub_TRANSFORM([grub-glue-efi])

grub_TRANSFORM([grub-mklayout])

grub_TRANSFORM([grub-mkpasswd-pbkdf2])

grub_TRANSFORM([grub-mkrelpath])

grub_TRANSFORM([grub-mkrescue])

grub_TRANSFORM([grub-probe])

grub_TRANSFORM([grub-reboot])

grub_TRANSFORM([grub-script-check])

grub_TRANSFORM([grub-set-default])

grub_TRANSFORM([grub-sparc64-setup])

grub_TRANSFORM([grub-render-label])

grub_TRANSFORM([grub-file])

# Optimization flag.  Allow user to override.

if test "x$TARGET_CFLAGS" = x; then

  TARGET_CFLAGS="$TARGET_CFLAGS -Os"

fi

# Default HOST_CPPFLAGS

HOST_CPPFLAGS="$HOST_CPPFLAGS -Wall -W"

HOST_CPPFLAGS="$HOST_CPPFLAGS -I\$(top_builddir)/include"

HOST_CPPFLAGS="$HOST_CPPFLAGS -DGRUB_UTIL=1"

TARGET_CPPFLAGS="$TARGET_CPPFLAGS -Wall -W"

TARGET_CPPFLAGS="$TARGET_CPPFLAGS -I\$(top_srcdir)/include"

TARGET_CPPFLAGS="$TARGET_CPPFLAGS -I\$(top_builddir)/include"

case "$target_cpu" in

  i[[3456]]86)	target_cpu=i386 ;;

  amd64)	target_cpu=x86_64 ;;

  sparc)	target_cpu=sparc64 ;;

  mipsel|mips64el)

                target_cpu=mipsel;

		machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_CPU_MIPSEL=1";

		;;

  mips|mips64)

                target_cpu=mips;

		machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_CPU_MIPS=1";

		;;

  arm*)

		target_cpu=arm;

		;;

  aarch64*)

		target_cpu=arm64;

		;;

esac

# Specify the platform (such as firmware).

AC_ARG_WITH([platform],

            AS_HELP_STRING([--with-platform=PLATFORM],

                           [select the host platform [[guessed]]]))

# Guess the platform if not specified.

if test "x$with_platform" = x; then

  case "$target_cpu"-"$target_vendor" in

    i386-apple) platform=efi ;;

    i386-*) platform=pc ;;

    x86_64-apple) platform=efi ;;

    x86_64-*) platform=pc ;;

    powerpc-*) platform=ieee1275 ;;

    powerpc64-*) platform=ieee1275 ;;

    sparc64-*) platform=ieee1275 ;;

    mipsel-*) platform=loongson ;;

    mips-*) platform=arc ;;

    ia64-*) platform=efi ;;

    arm-*) platform=uboot ;;

    arm64-*) platform=efi ;;

    *) AC_MSG_ERROR([unsupported CPU: "$target_cpu"]) ;;

  esac

else

  platform="$with_platform"

fi

case "$target_cpu"-"$platform" in

  x86_64-efi) ;;

  x86_64-emu) ;;

  x86_64-xen) ;;

  x86_64-*) target_cpu=i386 ;;

  powerpc64-ieee1275) target_cpu=powerpc ;;

esac

# Check if the platform is supported, make final adjustments.

case "$target_cpu"-"$platform" in

  i386-efi) ;;

  x86_64-efi) ;;

  i386-xen) ;;

  x86_64-xen) ;;

  i386-pc) ;;

  i386-multiboot) ;;

  i386-coreboot) ;;

  i386-linuxbios) platform=coreboot ;;

  i386-ieee1275) ;;

  i386-qemu) ;;

  powerpc-ieee1275) ;;

  sparc64-ieee1275) ;;

  ia64-efi) ;;

  mips-qemu_mips) ;;

  mips-qemu-mips) platform=qemu_mips;;

  mips-arc) ;;

  mipsel-arc) ;;

  mipsel-qemu_mips) ;;

  mipsel-qemu-mips) platform=qemu_mips;;

  mipsel-yeeloong) platform=loongson ;;

  mipsel-fuloong) platform=loongson ;;

  mipsel-loongson) ;;

  arm-uboot) ;;

  arm-efi) ;;

  arm64-efi) ;;

  *-emu) ;;

  *) AC_MSG_ERROR([platform "$platform" is not supported for target CPU "$target_cpu"]) ;;

esac

if test x$platform != xemu ; then

   case "$target_cpu" in

	i386 | powerpc) target_m32=1 ;;

	x86_64 | sparc64) target_m64=1 ;;

   esac

fi

if test x"$target_cpu-$platform" = xsparc64-emu ; then

   target_m64=1 ;

fi

case "$target_os" in

  windows* | mingw32*) target_os=cygwin ;;

esac

# This normalizes the names, and creates a new variable ("host_kernel")

# while at it, since the mapping is not always 1:1 (e.g. different OSes

# using the same kernel type).

case "$host_os" in

  gnu*)				host_kernel=hurd ;;

  linux*)			host_kernel=linux ;;

  freebsd* | kfreebsd*-gnu)	host_kernel=kfreebsd ;;

  netbsd*)			host_kernel=netbsd ;;

  solaris*)			host_kernel=illumos ;;

  darwin*)			host_kernel=xnu ;;

  cygwin | windows* | mingw32*)	host_kernel=windows ;;

esac

case "$host_os" in

  cygwin | windows* | mingw32*)	have_exec=n ;;

  aros*) have_exec=n ;;

  *) have_exec=y;;

esac

case "$platform" in

  coreboot)	machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_COREBOOT=1" ;;

  multiboot)	machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_MULTIBOOT=1" ;;

  efi)		machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_EFI=1" ;;

  xen)		machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_XEN=1" ;;

  ieee1275)	machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_IEEE1275=1" ;;

  uboot)	machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_UBOOT=1" ;;

  qemu)		machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_QEMU=1" ;;

  pc)		machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_PCBIOS=1" ;;

  emu)		machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_EMU=1" ;;

  loongson)	machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_MIPS_LOONGSON=1" ;;

  qemu_mips)	machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_MIPS_QEMU_MIPS=1" ;;

  arc)	machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE_ARC=1" ;;

esac

if test x${target_cpu} = xmipsel ; then

   machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE=`echo mips_$platform | sed y,abcdefghijklmnopqrstuvwxyz,ABCDEFGHIJKLMNOPQRSTUVWXYZ,`"

else

   machine_CPPFLAGS="$machine_CPPFLAGS -DGRUB_MACHINE=`echo ${target_cpu}_$platform | sed y,abcdefghijklmnopqrstuvwxyz,ABCDEFGHIJKLMNOPQRSTUVWXYZ,`"

fi

case "${target_cpu}-$platform" in

     mips-arc)

        TARGET_LINK_ADDR=0x88200000

        TARGET_DECOMPRESSOR_LINK_ADDR=0x88100000

	;;

     mipsel-arc)

        TARGET_LINK_ADDR=0x80700000

	TARGET_DECOMPRESSOR_LINK_ADDR=0x80600000

	;;

     mips*-qemu_mips | mips*-loongson)

        TARGET_DECOMPRESSOR_LINK_ADDR=0x80100000

	;;

esac

AC_SUBST(TARGET_LINK_ADDR)

AC_SUBST(TARGET_DECOMPRESSOR_LINK_ADDR)

TARGET_CPPFLAGS="$TARGET_CPPFLAGS $machine_CPPFLAGS"

AC_SUBST(host_cpu)

AC_SUBST(host_os)

AC_SUBST(host_kernel)

AC_SUBST(target_cpu)

AC_SUBST(platform)

# Define default variables

have_with_bootdir=n

AC_ARG_WITH([bootdir],

            AS_HELP_STRING([--with-bootdir=DIR],

                           [set the name of /boot directory [[guessed]]]),

			   [have_with_bootdir=y],

			   [have_with_bootdir=n])

if test x$have_with_bootdir = xy; then

   bootdirname="$with_bootdir"

else

   case "$host_os" in

     netbsd* | openbsd*)

        # Because /boot is used for the boot block in NetBSD and OpenBSD,

           bootdirname=''      ;;

     *)    bootdirname='boot'  ;;

   esac

fi

AC_SUBST(bootdirname)

AC_DEFINE_UNQUOTED(GRUB_BOOT_DIR_NAME, "$bootdirname",

    [Default boot directory name]")

AC_ARG_WITH([grubdir],

            AS_HELP_STRING([--with-grubdir=DIR],

                           [set the name of grub directory [[guessed]]]),

			   [grubdirname="$with_grubdir"],

			   [grubdirname="$PACKAGE"])

AC_SUBST(grubdirname)

AC_DEFINE_UNQUOTED(GRUB_DIR_NAME, "$grubdirname",

    [Default grub directory name])

#

# Checks for build programs.

#

# Although cmp is listed in the GNU Coding Standards as a command which

# can used directly, OpenBSD lacks cmp in the default installation.

AC_CHECK_PROGS([CMP], [cmp])

if test "x$CMP" = x; then

  AC_MSG_ERROR([cmp is not found])

fi

AC_CHECK_PROGS([YACC], [bison])

if test "x$YACC" = x; then

  AC_MSG_ERROR([bison is not found])

fi

AC_PROG_RANLIB

AC_PROG_INSTALL

AC_PROG_AWK

AC_PROG_LEX

AC_PROG_YACC

AC_PROG_MAKE_SET

AC_PROG_MKDIR_P

AC_PROG_LN_S

if test "x$LEX" = "x:"; then

  AC_MSG_ERROR([flex is not found])

else

  version=`$LEX --version | $AWK '{ split($NF,x,"."); print x[[1]]*10000+x[[2]]*100+x[[3]]; }'`

  if test -n "$version" -a "$version" -ge 20535; then

    :

  else

    AC_MSG_ERROR([flex is too old. GRUB requires 2.5.35 or above])

  fi

fi

# These are not a "must".

AC_PATH_PROGS(MAKEINFO, makeinfo true)

#

# Checks for host programs.

#

AC_PROG_CC

gl_EARLY

AC_PROG_CXX

AM_PROG_CC_C_O

AM_PROG_AS

# Must be GCC.

test "x$GCC" = xyes || AC_MSG_ERROR([GCC is required])

AC_CHECK_PROG(HAVE_CXX, $CXX, yes, no)

AC_GNU_SOURCE

AM_GNU_GETTEXT([external])

AC_SYS_LARGEFILE

# Identify characteristics of the host architecture.

unset ac_cv_c_bigendian

if test x"$target_cpu-$platform" = xsparc64-emu ; then

  CFLAGS="$CFLAGS -m64"

  HOST_CFLAGS="$HOST_CFLAGS -m64"

fi

AC_C_BIGENDIAN

AC_CHECK_SIZEOF(void *)

AC_CHECK_SIZEOF(long)

case "$host_os" in

  cygwin | windows* | mingw32*)

     HOST_CPPFLAGS="$HOST_CPPFLAGS -DUNICODE=1 -D_WIN32_WINNT=0x0500"

     CPPFLAGS="$CPPFLAGS -DUNICODE=1 -D_WIN32_WINNT=0x0500"

     AC_CHECK_SIZEOF(TCHAR,,[#include <windows.h>])

   ;;

esac

if test x$USE_NLS = xno; then

  HOST_CFLAGS="$HOST_CFLAGS -fno-builtin-gettext"

fi

if test "x$cross_compiling" = xyes; then

  AC_MSG_WARN([cannot generate manual pages while cross compiling])

else

  AC_PATH_PROG(HELP2MAN, help2man)

fi

# Check for functions and headers.

AC_CHECK_FUNCS(posix_memalign memalign getextmntent)

AC_CHECK_HEADERS(sys/param.h sys/mount.h sys/mnttab.h sys/mkdev.h limits.h)

AC_CHECK_MEMBERS([struct statfs.f_fstypename],,,[$ac_includes_default

#include <sys/param.h>

#include <sys/mount.h>])

AC_CHECK_MEMBERS([struct statfs.f_mntfromname],,,[$ac_includes_default

#include <sys/param.h>

#include <sys/mount.h>])

# For opendisk() and getrawpartition() on NetBSD.

# Used in util/deviceiter.c and in util/hostdisk.c.

AC_CHECK_HEADER([util.h], [

  AC_CHECK_LIB([util], [opendisk], [

    LIBUTIL="-lutil"

    AC_DEFINE(HAVE_OPENDISK, 1, [Define if opendisk() in -lutil can be used])

  ])

  AC_CHECK_LIB([util], [getrawpartition], [

    LIBUTIL="-lutil"

    AC_DEFINE(HAVE_GETRAWPARTITION, 1, [Define if getrawpartition() in -lutil can be used])

  ])

])

AC_SUBST([LIBUTIL])

AC_CACHE_CHECK([whether -Wtrampolines work], [grub_cv_host_cc_wtrampolines], [

  SAVED_CFLAGS="$CFLAGS"

  CFLAGS="$HOST_CFLAGS -Wtrampolines -Werror"

  AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <stdarg.h>

int va_arg_func (int fixed, va_list args);]], [[]])],

      [grub_cv_host_cc_wtrampolines=yes],

      [grub_cv_host_cc_wtrampolines=no])

  CFLAGS="$SAVED_CFLAGS"

])

if test x"$grub_host_cv_cc_wtrampolines" = xyes ; then

  HOST_CFLAGS="$HOST_CFLAGS -Wtrampolines"

fi

#

# Check for host and build compilers.

#

HOST_CC=$CC

AC_CHECK_PROGS(BUILD_CC, [gcc egcs cc])

test -z "$BUILD_CC" && AC_MSG_ERROR([none of gcc, egcs and cc is found. set BUILD_CC manually.])

BUILD_CPP="$BUILD_CC -E"

case "$build_os" in

  haiku*)				BUILD_LIBM= ;;

  *) 					BUILD_LIBM=-lm ;;

esac

# For gnulib.

gl_INIT

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"

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"

HOST_CFLAGS="$HOST_CFLAGS $WARN_FLAGS -Wcast-align"

AC_CACHE_CHECK([which extra warnings work], [grub_cv_cc_w_extra_flags], [

  SAVED_CFLAGS="$CFLAGS"

  grub_cv_cc_w_extra_flags=

  for x in $EXTRA_WARN_FLAGS; do

      CFLAGS="$HOST_CFLAGS $x -Werror"

      AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[]])], [flag=1], [flag=0])

      if test x$flag = x1 ; then

         grub_cv_cc_w_extra_flags="$grub_cv_cc_w_extra_flags $x"

      fi

  done

  CFLAGS="$SAVED_CFLAGS"

])

HOST_CFLAGS="$HOST_CFLAGS $grub_cv_cc_w_extra_flags"

#

# Check for target programs.

#

# Find tools for the target.

if test "x$target_alias" != x && test "x$host_alias" != "x$target_alias"; then

  tmp_ac_tool_prefix="$ac_tool_prefix"

  ac_tool_prefix=$target_alias-

  AC_CHECK_TOOLS(TARGET_CC, [gcc egcs cc],

                 [AC_MSG_ERROR([none of gcc, egcs and cc is found. set TARGET_CC manually.])])

  AC_CHECK_TOOL(TARGET_OBJCOPY, objcopy)

  AC_CHECK_TOOL(TARGET_STRIP, strip)

  AC_CHECK_TOOL(TARGET_NM, nm)

  AC_CHECK_TOOL(TARGET_RANLIB, ranlib)

  ac_tool_prefix="$tmp_ac_tool_prefix"

else

  if test "x$TARGET_CC" = x; then

    TARGET_CC=$CC

  fi

  AC_CHECK_TOOL(TARGET_OBJCOPY, objcopy)

  AC_CHECK_TOOL(TARGET_STRIP, strip)

  AC_CHECK_TOOL(TARGET_NM, nm)

  AC_CHECK_TOOL(TARGET_RANLIB, ranlib)

fi

AC_SUBST(HOST_CC)

AC_SUBST(BUILD_CC)

AC_SUBST(BUILD_CFLAGS)

AC_SUBST(BUILD_CPPFLAGS)

AC_SUBST(TARGET_CC)

AC_SUBST(TARGET_NM)

AC_SUBST(TARGET_RANLIB)

AC_SUBST(TARGET_STRIP)

AC_SUBST(TARGET_OBJCOPY)

# Test the C compiler for the target environment.

tmp_CC="$CC"

tmp_CFLAGS="$CFLAGS"

tmp_LDFLAGS="$LDFLAGS"

tmp_CPPFLAGS="$CPPFLAGS"

tmp_LIBS="$LIBS"

CC="$TARGET_CC"

CFLAGS="$TARGET_CFLAGS"

CPPFLAGS="$TARGET_CPPFLAGS"

LDFLAGS="$TARGET_LDFLAGS"

LIBS=""

# debug flags.

TARGET_CFLAGS="$TARGET_CFLAGS $WARN_FLAGS -g -Wredundant-decls -Wmissing-prototypes -Wmissing-declarations"

TARGET_CCASFLAGS="$TARGET_CCASFLAGS -g"

if test "x$target_cpu" != xi386 && test "x$target_cpu" != xx86_64; then

TARGET_CFLAGS="$TARGET_CFLAGS -Wcast-align"

fi

TARGET_CC_VERSION="$(LC_ALL=C $TARGET_CC --version | head -n1)"

AC_CACHE_CHECK([which extra warnings work], [grub_cv_target_cc_w_extra_flags], [

  LDFLAGS="$TARGET_LDFLAGS -nostdlib -static"

  grub_cv_target_cc_w_extra_flags=

  for x in $EXTRA_WARN_FLAGS; do

      CFLAGS="$TARGET_CFLAGS $x -Werror"

      AC_LINK_IFELSE([AC_LANG_PROGRAM([[

asm (".globl start; start:");

void __main (void);

void __main (void) {}

int main (void);

]], [[]])], [flag=1], [flag=0])

      if test x$flag = x1 ; then

         grub_cv_target_cc_w_extra_flags="$grub_cv_target_cc_w_extra_flags $x"

      fi

  done

])

TARGET_CFLAGS="$TARGET_CFLAGS $grub_cv_target_cc_w_extra_flags"

AC_CACHE_CHECK([if compiling with clang], [grub_cv_cc_target_clang]

[

CFLAGS="$TARGET_CFLAGS"

AC_COMPILE_IFELSE(

[AC_LANG_PROGRAM([], [[

#ifdef __clang__

#error "is clang"

#endif

]])],

[grub_cv_cc_target_clang=no], [grub_cv_cc_target_clang=yes])])

# on x86 clang doesn't support .code16

# on arm clang doesn't support .arch directive

# on mips clang doesn't support privilegied instructions, doubleword store/load

# and crashes with hand-written assembly

if test "x$grub_cv_cc_target_clang" = xyes && ( test "x$target_cpu" = xi386 \

   || test "x$target_cpu" = xx86_64 || test "x$target_cpu" = xarm \

   || test "x$target_cpu" = xmips || test "x$target_cpu" = xmipsel ); then

   TARGET_CCASFLAGS="$TARGET_CCASFLAGS -no-integrated-as"

fi

if test "x$grub_cv_cc_target_clang" = xyes && test "x$target_cpu" = xpowerpc; then

AC_CACHE_CHECK([if clang can handle ame instruction], [grub_cv_cc_target_clang_ame]

[

CFLAGS="$TARGET_CFLAGS"

AC_COMPILE_IFELSE(

[AC_LANG_PROGRAM([], [[

   unsigned int a = 0, b = 0;

   asm volatile ("{ame|addme} %0,%1" : "=r" (a) : "r" (b));

   if (a)

     return 1;

]])],

[grub_cv_cc_target_clang_ame=yes], [grub_cv_cc_target_clang_ame=no])])

   # clang <= 3.3 doesn't handle most of ppc assembly, not even inline assembly

   # used by gcrypt

   if test x$grub_cv_cc_target_clang_ame = xno ; then

     TARGET_CCASFLAGS="$TARGET_CCASFLAGS -no-integrated-as"

     TARGET_CFLAGS="$TARGET_CFLAGS -no-integrated-as"

   fi

fi

if test "x$target_cpu" = xi386 && test "x$platform" != xemu; then

  TARGET_CFLAGS="$TARGET_CFLAGS -march=i386"

fi

if test "x$target_m32" = x1; then

  # Force 32-bit mode.

  TARGET_CFLAGS="$TARGET_CFLAGS -m32"

  TARGET_CCASFLAGS="$TARGET_CCASFLAGS -m32"

  TARGET_CPPFLAGS="$TARGET_CPPFLAGS -m32"

  TARGET_LDFLAGS="$TARGET_LDFLAGS -m32"

  TARGET_MODULE_FORMAT="elf32"

fi

if test "x$target_m64" = x1; then

  # Force 64-bit mode.

  TARGET_CFLAGS="$TARGET_CFLAGS -m64"

  TARGET_CCASFLAGS="$TARGET_CCASFLAGS -m64"

  TARGET_CPPFLAGS="$TARGET_CPPFLAGS -m64"

  TARGET_LDFLAGS="$TARGET_LDFLAGS -m64"

  TARGET_MODULE_FORMAT="elf64"

fi

if test "x$grub_cv_cc_target_clang" = xno && test "x$target_cpu" = xi386 && test "x$platform" != xemu && test "x$platform" != xefi; then

   TARGET_CFLAGS="$TARGET_CFLAGS -mrtd -mregparm=3"

fi

# on mips redirect cache flushing function to non-existant one.

if test "x$target_cpu" = xmips || test "x$target_cpu" = xmipsel ; then

  AC_CACHE_CHECK([whether -mflush-func=grub_red_herring works], [grub_cv_cc_mflush_func], [

    CFLAGS="$TARGET_CFLAGS -mflush-func=grub_red_herring -Werror"

    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],

        [grub_cv_cc_mflush_func=yes],

	[grub_cv_cc_mflush_func=no])

  ])

  if test "x$grub_cv_cc_mflush_func" = xyes; then

    TARGET_CFLAGS="$TARGET_CFLAGS -mflush-func=grub_red_herring"

  fi

fi

# Force no alignment to save space on i386.

if test "x$target_cpu" = xi386; then

  AC_CACHE_CHECK([whether -falign-loops works], [grub_cv_cc_falign_loop], [

    CFLAGS="$TARGET_CFLAGS -falign-loops=1 -Werror"

    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],

        [grub_cv_cc_falign_loop=yes],

	[grub_cv_cc_falign_loop=no])

  ])

  AC_CACHE_CHECK([whether -malign-loops works], [grub_cv_cc_malign_loop], [

    CFLAGS="$TARGET_CFLAGS -malign-loops=1 -Werror"

    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],

        [grub_cv_cc_malign_loop=yes],

	[grub_cv_cc_malign_loop=no])

  ])

  if test "x$grub_cv_cc_falign_loop" = xyes; then

    TARGET_CFLAGS="$TARGET_CFLAGS -falign-jumps=1 -falign-loops=1 -falign-functions=1"

  elif test "x$grub_cv_cc_malign_loop" = xyes; then

    TARGET_CFLAGS="$TARGET_CFLAGS -malign-jumps=1 -malign-loops=1 -malign-functions=1"

  fi

fi

AC_CACHE_CHECK([whether -freg-struct-return works], [grub_cv_cc_freg_struct_return], [

    CFLAGS="$TARGET_CFLAGS -freg-struct-return -Werror"

    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],

        [grub_cv_cc_freg_struct_return=yes],

	[grub_cv_cc_freg_struct_return=no])

])

if test "x$grub_cv_cc_freg_struct_return" = xyes; then

    TARGET_CFLAGS="$TARGET_CFLAGS -freg-struct-return"

fi

if ( test "x$target_cpu" = xi386 || test "x$target_cpu" = xx86_64 ) && test "x$platform" != xemu; then

  # Some toolchains enable these features by default, but they need

  # registers that aren't set up properly in GRUB.

  TARGET_CFLAGS="$TARGET_CFLAGS -mno-mmx -mno-sse -mno-sse2 -mno-3dnow"

fi

# By default, GCC 4.4 generates .eh_frame sections containing unwind

# information in some cases where it previously did not. GRUB doesn't need

# these and they just use up vital space. Restore the old compiler

# behaviour.

AC_CACHE_CHECK([whether -fno-dwarf2-cfi-asm works], [grub_cv_cc_fno_dwarf2_cfi_asm], [

  CFLAGS="$TARGET_CFLAGS -fno-dwarf2-cfi-asm"

  AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],

      [grub_cv_cc_fno_dwarf2_cfi_asm=yes],

      [grub_cv_cc_fno_dwarf2_cfi_asm=no])

])

if test "x$grub_cv_cc_fno_dwarf2_cfi_asm" = xyes; then

  TARGET_CFLAGS="$TARGET_CFLAGS -fno-dwarf2-cfi-asm"

fi

if test x"$target_os" = xcygwin; then

  AC_CACHE_CHECK([whether option -fno-reorder-functions works], grub_cv_cc_no_reorder_functions, [

    CFLAGS="$TARGET_CFLAGS -fno-reorder-functions"

    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],

		      [grub_cv_cc_no_reorder_functions=yes],

		      [grub_cv_cc_no_reorder_functions=no])

  ])

fi

if test x"$target_os" = xcygwin && test "x$grub_cv_cc_no_reorder_functions" = xyes; then

  TARGET_CFLAGS="$TARGET_CFLAGS -fno-reorder-functions"

fi

# By default, GCC 4.6 generates .eh_frame sections containing unwind

# information in some cases where it previously did not. GRUB doesn't need

# these and they just use up vital space. Restore the old compiler

# behaviour.

AC_CACHE_CHECK([whether -fno-asynchronous-unwind-tables works], [grub_cv_cc_fno_asynchronous_unwind_tables], [

  CFLAGS="$TARGET_CFLAGS -fno-dwarf2-cfi-asm"

  AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],

      [grub_cv_cc_fno_asynchronous_unwind_tables=yes],

      [grub_cv_cc_fno_asynchronous_unwind_tables=no])

])

if test "x$grub_cv_cc_fno_asynchronous_unwind_tables" = xyes; then

  TARGET_CFLAGS="$TARGET_CFLAGS -fno-asynchronous-unwind-tables"

fi

AC_ARG_ENABLE([efiemu],

	      [AS_HELP_STRING([--enable-efiemu],

                             [build and install the efiemu runtimes (default=guessed)])])

if test x"$enable_efiemu" = xno ; then

  efiemu_excuse="explicitly disabled"

fi

if test x"$grub_cv_target_cc_link_format" = x-mi386pe || test x"$grub_cv_target_cc_link_format" = x-mi386pep ; then

  efiemu_excuse="not available on cygwin"

fi

if test x"$target_cpu" != xi386 ; then

  efiemu_excuse="only available on i386"

fi

if test x"$platform" = xefi ; then

  efiemu_excuse="not available on efi"

fi

if test x"$efiemu_excuse" = x ; then

  AC_CACHE_CHECK([whether options required for efiemu work], grub_cv_cc_efiemu, [

    CFLAGS="-m64 -nostdlib -O2 -mcmodel=large -mno-red-zone"

    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],

		      [grub_cv_cc_efiemu=yes],

		      [grub_cv_cc_efiemu=no])

  ])

  if test x$grub_cv_cc_efiemu = xno; then

     efiemu_excuse="cannot compile with -m64 -mcmodel=large -mno-red-zone -nostdlib"

  fi

fi

if test x"$efiemu_excuse" = x ; then

  AC_CACHE_CHECK([for efiemu64 linking format], [grub_cv_target_cc_efiemu64_link_format], [

    grub_cv_target_cc_efiemu64_link_format=unknown

    for format in -melf_x86_64 -melf_x86_64_fbsd -melf_x86_64_obsd -melf_x86_64_haiku -arch,x86_64; do

      CFLAGS="-m64 -nostdlib -O2 -mcmodel=large -mno-red-zone"

      LDFLAGS="-m64 -Wl,$format -nostdlib -static"

      AC_LINK_IFELSE([AC_LANG_PROGRAM([[

      asm (".globl start; start:");

      asm (".globl _start; _start:");

      asm (".globl __start; __start:");

      void __main (void);

      void __main (void) {}

      ]], [[]])], [flag=1], [flag=0])

      if test x"$flag" = x1; then

        grub_cv_target_cc_efiemu64_link_format="$format"

	break;

      fi

    done])

  if test x"$grub_cv_target_cc_efiemu64_link_format" = xunknown; then

    efiemu_excuse="no suitable link format for efiemu64 found"

  else

    EFIEMU64_LINK_FORMAT="-Wl,$grub_cv_target_cc_efiemu64_link_format"

  fi

fi

if test x"$enable_efiemu" = xyes && test x"$efiemu_excuse" != x ; then

  AC_MSG_ERROR([efiemu runtime was explicitly requested but can't be compiled ($efiemu_excuse)])

fi

if test x"$efiemu_excuse" = x ; then

enable_efiemu=yes

else

enable_efiemu=no

fi

AC_SUBST([enable_efiemu])

AC_SUBST([EFIEMU64_LINK_FORMAT])

CFLAGS="$TARGET_CFLAGS"

if test x"$platform" = xemu ; then

  TARGET_OBJ2ELF=

  grub_cv_target_cc_link_format=

  case "$host_os" in

    *darwin* | *mac*)

       grub_cv_target_cc_link_format="-arch,${target_cpu}"

       TARGET_LDFLAGS="$TARGET_LDFLAGS -Wl,$grub_cv_target_cc_link_format"

        ;;

    *windows* | *cygwin* | *mingw*)

      if test x${target_cpu} = xi386 ; then

        grub_cv_target_cc_link_format=-mi386pe;

	TARGET_OBJ2ELF='./build-grub-pe2elf';

      fi

      if test x${target_cpu} = xx86_64 ; then

        grub_cv_target_cc_link_format=-mi386pep;

	TARGET_OBJ2ELF='./build-grub-pep2elf';

      fi

      TARGET_LDFLAGS="$TARGET_LDFLAGS -Wl,$grub_cv_target_cc_link_format"

      ;;

  esac

elif test x"$target_cpu" = xi386 || test x"$target_cpu" = xx86_64; then

  AC_CACHE_CHECK([for target linking format], [grub_cv_target_cc_link_format], [

    grub_cv_target_cc_link_format=unknown

    for format in -melf_${target_cpu} -melf_${target_cpu}_fbsd -melf_${target_cpu}_obsd -melf_${target_cpu}_haiku -mi386pe -mi386pep -arch,${target_cpu}; do

      if test x${target_cpu} != xi386 && test x$format = x-mi386pe; then

        continue

      fi

      if test x${target_cpu} != xx86_64 && test x$format = x-mi386pep; then

        continue

      fi

      CFLAGS="$TARGET_CFLAGS"

      LDFLAGS="$TARGET_LDFLAGS -Wl,$format -nostdlib -static"

      AC_LINK_IFELSE([AC_LANG_PROGRAM([[

      asm (".globl start; start:");

      asm (".globl _start; _start:");

      asm (".globl __start; __start:");

      void __main (void);

      void __main (void) {}

      ]], [[]])], [flag=1], [flag=0])

      if test x"$flag" = x1; then

        grub_cv_target_cc_link_format="$format"

	break;

      fi

    done])

  if test x"$grub_cv_target_cc_link_format" = xunknown; then

    AC_MSG_ERROR([no suitable link format found])

  fi

  TARGET_LDFLAGS="$TARGET_LDFLAGS -Wl,$grub_cv_target_cc_link_format"

  if test x"$grub_cv_target_cc_link_format" = x-mi386pe ; then

    TARGET_OBJ2ELF='./build-grub-pe2elf';

  fi

  if test x"$grub_cv_target_cc_link_format" = x-mi386pep ; then

    TARGET_OBJ2ELF='./build-grub-pep2elf';

  fi

fi

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

   TARGET_APPLE_LINKER=1

   AC_CHECK_PROG([TARGET_OBJCONV], [objconv], [objconv], [])

   if test "x$TARGET_OBJCONV" = x ; then

      AC_CHECK_PROG([TARGET_OBJCONV], [objconv], [./objconv], [], [.])

   fi

   if test "x$TARGET_OBJCONV" = x ; then

      AC_MSG_ERROR([objconv not found which is required when building with apple compiler])

   fi

   TARGET_IMG_LDSCRIPT=

   TARGET_IMG_CFLAGS="-static"

   TARGET_IMG_LDFLAGS='-nostdlib -static -Wl,-preload -Wl,-segalign,20'

   TARGET_IMG_LDFLAGS_AC='-nostdlib -static -Wl,-preload -Wl,-segalign,20'

   TARGET_IMG_BASE_LDOPT="-Wl,-image_base"

   TARGET_LDFLAGS_OLDMAGIC=""

elif test x$grub_cv_target_cc_link_format = x-mi386pe || test x$grub_cv_target_cc_link_format = x-mi386pep ; then

  TARGET_APPLE_LINKER=0

  TARGET_LDFLAGS_OLDMAGIC="-Wl,-N"

  TARGET_IMG_LDSCRIPT='$(top_srcdir)'"/${grub_coredir}/conf/i386-cygwin-img-ld.sc"

  TARGET_IMG_LDFLAGS="-Wl,-T${TARGET_IMG_LDSCRIPT}"

  TARGET_IMG_LDFLAGS_AC="-Wl,-T${srcdir}/${grub_coredir}/conf/i386-cygwin-img-ld.sc"

  TARGET_IMG_BASE_LDOPT="-Wl,-Ttext"

  TARGET_IMG_CFLAGS=

else

  TARGET_APPLE_LINKER=0

  TARGET_LDFLAGS_OLDMAGIC="-Wl,-N"

  TARGET_IMG_LDSCRIPT=

  TARGET_IMG_LDFLAGS='-Wl,-N'

  TARGET_IMG_LDFLAGS_AC='-Wl,-N'

  TARGET_IMG_BASE_LDOPT="-Wl,-Ttext"

  TARGET_IMG_CFLAGS=

fi

AC_SUBST(TARGET_LDFLAGS_OLDMAGIC)

LDFLAGS="$TARGET_LDFLAGS"

if test "$target_cpu" = x86_64 || test "$target_cpu-$platform" = sparc64-emu ; then

  # Use large model to support 4G memory

  AC_CACHE_CHECK([whether option -mcmodel=large works], grub_cv_cc_mcmodel, [

    CFLAGS="$TARGET_CFLAGS -m64 -mcmodel=large"

    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],

		      [grub_cv_cc_mcmodel=yes],

		      [grub_cv_cc_mcmodel=no])

  ])

  if test "x$grub_cv_cc_mcmodel" = xyes; then

    TARGET_CFLAGS="$TARGET_CFLAGS -mcmodel=large"

  elif test "$target_cpu-$platform" = sparc64-emu; then

    TARGET_CFLAGS="$TARGET_CFLAGS -mcmodel=medany"

  fi

fi

if test "$target_cpu"-"$platform" = x86_64-efi; then

  # EFI writes to stack below %rsp, we must not use the red zone

  AC_CACHE_CHECK([whether option -mno-red-zone works], grub_cv_cc_no_red_zone, [

    CFLAGS="$TARGET_CFLAGS -m64 -mno-red-zone"

    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],

		      [grub_cv_cc_no_red_zone=yes],

		      [grub_cv_cc_no_red_zone=no])

  ])