[grub2.git] / configure.ac

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

# Copyright (C) 2002,2003,2004,2005,2006,2007,2008,2009  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],[1.96],[bug-grub@gnu.org])
AC_PREREQ(2.59)
AC_CONFIG_SRCDIR([include/grub/dl.h])
AC_CONFIG_HEADER([config.h])

# Checks for host and target systems.
AC_CANONICAL_HOST
AC_CANONICAL_TARGET

# Program name transformations
AC_ARG_PROGRAM

case "$host_cpu" in
  powerpc64) host_m32=1 ;;
esac

case "$target_cpu" in
  i[[3456]]86) target_cpu=i386 ;;
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 ;;
    *) AC_MSG_ERROR([unsupported CPU: "$target_cpu"]) ;;
  esac
else
  platform="$with_platform"
fi

# Adjust CPU unless target was explicitly specified.
if test -z "$target_alias"; then
  case "$target_cpu"-"$platform" in
    x86_64-efi) ;;
    x86_64-*) target_cpu=i386 ;;
    powerpc64-ieee1275) target_cpu=powerpc ;;
  esac
fi

# Check if the platform is supported, make final adjustments.
case "$target_cpu"-"$platform" in
  i386-efi) ;;
  x86_64-efi) ;;
  i386-pc) ;;
  i386-coreboot) ;;
  i386-linuxbios) platform=coreboot ;;
  i386-ieee1275) ;;
  powerpc-ieee1275) ;;
  sparc64-ieee1275) ;;
  *) AC_MSG_ERROR([platform "$platform" is not supported for target CPU "$target_cpu"]) ;;
esac

case "$target_cpu" in
  i386 | powerpc) target_m32=1 ;;
  x86_64 | sparc64) target_m64=1 ;;
esac

case "$host_os" in
  mingw32) host_os=cygwin ;;
esac

case "$target_os" in
  mingw32) target_os=cygwin ;;
esac

AC_SUBST(target_cpu)
AC_SUBST(target_os)
AC_SUBST(platform)

#
# 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

for file in /usr/src/unifont.bdf ; do
  if test -e $file ; then
    AC_SUBST([UNIFONT_BDF], [$file])
    break
  fi
done

AC_PROG_INSTALL
AC_PROG_AWK
AC_PROG_MAKE_SET

# These are not a "must".
AC_PATH_PROG(RUBY, ruby)
AC_PATH_PROG(HELP2MAN, help2man)

#
# Checks for host programs.
#

AC_PROG_CC
# Must be GCC.
test "x$GCC" = xyes || AC_MSG_ERROR([GCC is required])

AC_GNU_SOURCE
AC_SYS_LARGEFILE

# Identify characteristics of the host architecture.
AC_C_BIGENDIAN
AC_CHECK_SIZEOF(void *)
AC_CHECK_SIZEOF(long)

if test "x$host_m32" = x1; then
  # Force 32-bit mode.
  CFLAGS="$CFLAGS -m32"
  LDFLAGS="$LDFLAGS -m32"
fi

# Check LZO when compiling for the i386-pc.
if test "$target_cpu"-"$platform" = i386-pc; then
  AC_ARG_ENABLE([lzo],
	      [AS_HELP_STRING([--enable-lzo],
                             [use lzo to compress kernel (default is lzma)])])
  [if [ x"$enable_lzo" = xyes ]; then
    # There are three possibilities. LZO version 2 installed with the name
    # liblzo2, with the name liblzo, and LZO version 1.]
    AC_DEFINE([ENABLE_LZO], [1], [Use lzo compression])
    AC_CHECK_LIB([lzo2], [__lzo_init_v2], [LIBLZO="-llzo2"],
      [AC_CHECK_LIB([lzo], [__lzo_init_v2], [LIBLZO="-llzo"],
        [AC_CHECK_LIB([lzo], [__lzo_init2], [LIBLZO="-llzo"],
	       [AC_MSG_ERROR([LZO library version 1.02 or later is required])])])])
    AC_SUBST([LIBLZO])
    [LIBS="$LIBS $LIBLZO"]
    AC_CHECK_FUNC([lzo1x_999_compress], ,
	        [AC_MSG_ERROR([LZO1X-999 must be enabled])])

    [# LZO version 2 uses lzo/lzo1x.h, while LZO version 1 uses lzo1x.h.]
    AC_CHECK_HEADERS([lzo/lzo1x.h lzo1x.h])
  [else]
    AC_DEFINE([ENABLE_LZMA], [1], [Use lzma compression])
  [fi]
  AC_SUBST([enable_lzo])
fi

# Check for functions.
AC_CHECK_FUNCS(posix_memalign memalign asprintf)

#
# Check for target programs.
#


# Use linker script if present, otherwise use builtin -N script.
AC_MSG_CHECKING([for option to link raw image])
if test -f "${srcdir}/conf/${target_cpu}-${platform}-${target_os}-img-ld.sc"; then
  TARGET_IMG_LDSCRIPT='$(top_srcdir)'"/conf/${target_cpu}-${platform}-${target_os}-img-ld.sc"
  TARGET_IMG_LDFLAGS="-Wl,-T${TARGET_IMG_LDSCRIPT}"
  TARGET_IMG_LDFLAGS_AC="-Wl,-T${srcdir}/conf/${target_cpu}-${platform}-${target_os}-img-ld.sc"
else
  TARGET_IMG_LDSCRIPT=
  TARGET_IMG_LDFLAGS='-Wl,-N'
  TARGET_IMG_LDFLAGS_AC='-Wl,-N'
fi
AC_SUBST(TARGET_IMG_LDSCRIPT)
AC_SUBST(TARGET_IMG_LDFLAGS)
AC_MSG_RESULT([$TARGET_IMG_LDFLAGS_AC])

# For platforms where ELF is not the default link format.
AC_MSG_CHECKING([for command to convert module to ELF format])
case "${host_os}:${target_os}" in
  cygwin:cygwin) TARGET_OBJ2ELF='grub-pe2elf' ;;
  *) ;;
esac
AC_SUBST(TARGET_OBJ2ELF)
AC_MSG_RESULT([$TARGET_OBJ2ELF])

# For cross-compiling.
if test "x$build" != "x$host"; then
  # XXX this depends on the implementation of autoconf!
  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(OBJCOPY, objcopy)
  AC_CHECK_TOOL(STRIP, strip)
  AC_CHECK_TOOL(NM, nm)

  ac_tool_prefix="$tmp_ac_tool_prefix"
else
  if test "x$TARGET_CC" = x; then
    TARGET_CC=$CC
  fi
  AC_CHECK_TOOL(OBJCOPY, objcopy)
  AC_CHECK_TOOL(STRIP, strip)
  AC_CHECK_TOOL(NM, nm)
fi
AC_SUBST(TARGET_CC)


# 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=""

if test "x$TARGET_CFLAGS" = x; then
  # debug flags.
  TARGET_CFLAGS="-Wall -W -Wshadow -Wpointer-arith -Wmissing-prototypes \
                 -Wundef -Wstrict-prototypes -g"

  # optimization flags.
  AC_CACHE_CHECK([whether optimization for size works], grub_cv_cc_Os, [
    CFLAGS=-Os
    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
		      [grub_cv_cc_Os=yes],
		      [grub_cv_cc_Os=no])
  ])
  if test "x$grub_cv_cc_Os" = xyes; then
    TARGET_CFLAGS="$TARGET_CFLAGS -Os"
  else
    TARGET_CFLAGS="$TARGET_CFLAGS -O2 -fno-strength-reduce -fno-unroll-loops"
  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="-falign-loops=1"
      AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
		        [grub_cv_cc_falign_loop=yes],
			[grub_cv_cc_falign_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"
    else
      TARGET_CFLAGS="$TARGET_CFLAGS -malign-jumps=1 -malign-loops=1 -malign-functions=1"
    fi
  fi
fi

if test "x$target_m32" = x1; then
  # Force 32-bit mode.
  TARGET_CFLAGS="$TARGET_CFLAGS -m32"
  TARGET_LDFLAGS="$TARGET_LDFLAGS -m32"
fi

if test "x$target_m64" = x1; then
  # Force 64-bit mode.
  TARGET_CFLAGS="$TARGET_CFLAGS -m64"
  TARGET_LDFLAGS="$TARGET_LDFLAGS -m64"
fi

#
# Compiler features.
#

# Need __enable_execute_stack() for nested function trampolines?
grub_CHECK_ENABLE_EXECUTE_STACK

# Smashing stack protector.
grub_CHECK_STACK_PROTECTOR
# Need that, because some distributions ship compilers that include
# `-fstack-protector' in the default specs.
if test "x$ssp_possible" = xyes; then
  TARGET_CFLAGS="$TARGET_CFLAGS -fno-stack-protector"
fi
grub_CHECK_STACK_ARG_PROBE
# Cygwin's GCC uses alloca() to probe the stackframe on static
# stack allocations above some threshold.
if test x"$sap_possible" = xyes; then
  TARGET_CFLAGS="$TARGET_CFLAGS -mno-stack-arg-probe"
fi

AC_SUBST(TARGET_CFLAGS)
AC_SUBST(TARGET_CPPFLAGS)
AC_SUBST(TARGET_LDFLAGS)
AC_SUBST(MODULE_LDFLAGS)

# Set them to their new values for the tests below.
CC="$TARGET_CC"
CFLAGS="$TARGET_CFLAGS"
CPPFLAGS="$TARGET_CPPFLAGS"
LDFLAGS="$TARGET_LDFLAGS"

# Defined in aclocal.m4.
grub_PROG_TARGET_CC
grub_PROG_OBJCOPY_ABSOLUTE
grub_PROG_LD_BUILD_ID_NONE
grub_ASM_USCORE
if test "x$target_cpu" = xi386; then
  if test ! -z "$TARGET_IMG_LDSCRIPT"; then
    # Check symbols provided by linker script.
    CFLAGS="$TARGET_CFLAGS -nostdlib $TARGET_IMG_LDFLAGS_AC -Wl,-Ttext,8000,--defsym,___main=0x8100"
  fi
  if test "x$platform" = xpc; then
    grub_CHECK_START_SYMBOL
    grub_CHECK_BSS_START_SYMBOL
    grub_CHECK_END_SYMBOL
  fi
  CFLAGS="$TARGET_CFLAGS"
  grub_I386_ASM_PREFIX_REQUIREMENT
  grub_I386_ASM_ADDR32
  grub_I386_ASM_ABSOLUTE_WITHOUT_ASTERISK
  grub_I386_CHECK_REGPARM_BUG
else
  AC_DEFINE([NESTED_FUNC_ATTR], [], [Catch gcc bug])
fi

# Restore the flags.
CC="$tmp_CC"
CFLAGS="$tmp_CFLAGS"
CPPFLAGS="$tmp_CPPFLAGS"
LDFLAGS="$tmp_LDFLAGS"
LIBS="$tmp_LIBS"

#
# Check for options.
#

# Memory manager debugging.
AC_ARG_ENABLE([mm-debug], 
	      AS_HELP_STRING([--enable-mm-debug],
                             [include memory manager debugging]),
              [AC_DEFINE([MM_DEBUG], [1],
                         [Define to 1 if you enable memory manager debugging.])])

AC_ARG_ENABLE([grub-emu],
	      [AS_HELP_STRING([--enable-grub-emu],
                             [build and install the `grub-emu' debugging utility])])
[if [ x"$enable_grub_emu" = xyes ]; then
  # Check for curses libraries.]
  AC_CHECK_LIB([ncurses], [wgetch], [LIBCURSES="-lncurses"],
    [AC_CHECK_LIB([curses], [wgetch], [LIBCURSES="-lcurses"],
      [AC_MSG_ERROR([(n)curses libraries are required to build `grub-emu'])])])
  AC_SUBST([LIBCURSES])

  [# Check for headers.]
  AC_CHECK_HEADERS([ncurses/curses.h], [],
    [AC_CHECK_HEADERS([ncurses.h], [],
      [AC_CHECK_HEADERS([curses.h], [],
	[AC_MSG_ERROR([(n)curses header files are required to build `grub-emu'])])])])
[fi]
AC_SUBST([enable_grub_emu])

AC_ARG_ENABLE([grub-fstest],
	      [AS_HELP_STRING([--enable-grub-fstest],
                             [build and install the `grub-fstest' debugging utility])])
AC_SUBST([enable_grub_fstest])

AC_ARG_ENABLE([grub-pe2elf],
	      [AS_HELP_STRING([--enable-grub-pe2elf],
                             [build and install the `grub-pe2elf' conversion utility])])
AC_SUBST([enable_grub_pe2elf])

AC_ARG_ENABLE([grub-mkfont],
	      [AS_HELP_STRING([--enable-grub-mkfont],
                             [build and install the `grub-mkfont' utility])])
if test x"$enable_grub_mkfont" = xyes ; then
  # Check for freetype libraries.
  AC_CHECK_PROGS([FREETYPE], [freetype-config])
  if test "x$FREETYPE" = x ; then
    AC_MSG_ERROR([freetype2 libraries are required to build `grub-mkfont'])
  fi
  freetype_cflags=`freetype-config --cflags`
  freetype_libs=`freetype-config --libs`
fi
AC_SUBST([enable_grub_mkfont])
AC_SUBST([freetype_cflags])
AC_SUBST([freetype_libs])

# Output files.
AC_CONFIG_LINKS([include/grub/cpu:include/grub/$target_cpu
	include/grub/machine:include/grub/$target_cpu/$platform])
AC_CONFIG_FILES([Makefile gensymlist.sh genkernsyms.sh])
AC_CONFIG_FILES([stamp-h], [echo timestamp > stamp-h])
AC_OUTPUT
Commit	Line	Data
6a161fa9	1	# Process this file with autoconf to produce a configure script.
6a161fa9	2
1e901a75	3	# Copyright (C) 2002,2003,2004,2005,2006,2007,2008,2009 Free Software Foundation, Inc.
6a161fa9	4	#
	5	# This configure.ac is free software; the author
	6	# gives unlimited permission to copy and/or distribute it,
	7	# with or without modifications, as long as this notice is preserved.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
	11	# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
	12	# PARTICULAR PURPOSE.
	13
b977bf01	14	dnl This configure script is complicated, because GRUB needs to deal
	15	dnl with three potentially different types:
	16	dnl
	17	dnl build -- the environment for building GRUB
	18	dnl host -- the environment for running utilities
	19	dnl target -- the environment for running GRUB
	20	dnl
	21	dnl In addition, GRUB needs to deal with a platform specification
	22	dnl which specifies the system running GRUB, such as firmware.
	23	dnl This is necessary because the target type in autoconf does not
	24	dnl describe such a system very well.
	25	dnl
	26	dnl The current strategy is to use variables with no prefix (such as
	27	dnl CC, CFLAGS, etc.) for the host type as well as the build type,
	28	dnl because GRUB does not need to use those variables for the build
	29	dnl type, so there is no conflict. Variables with the prefix "TARGET_"
	30	dnl (such as TARGET_CC, TARGET_CFLAGS, etc.) are used for the target
	31	dnl type.
	32
	33
eb73121d	34	AC_INIT([GRUB],[1.96],[bug-grub@gnu.org])
46e04eb9	35	AC_PREREQ(2.59)
4b13b216	36	AC_CONFIG_SRCDIR([include/grub/dl.h])
6a161fa9	37	AC_CONFIG_HEADER([config.h])
6a161fa9	38
b977bf01	39	# Checks for host and target systems.
6a161fa9	40	AC_CANONICAL_HOST
b977bf01	41	AC_CANONICAL_TARGET
6a161fa9	42
1d543c3e	43	# Program name transformations
	44	AC_ARG_PROGRAM
	45
6a161fa9	46	case "$host_cpu" in
b977bf01	47	powerpc64) host_m32=1 ;;
	48	esac
	49
	50	case "$target_cpu" in
	51	i[[3456]]86) target_cpu=i386 ;;
6a161fa9	52	esac
6a161fa9	53
05568c2e	54	# Specify the platform (such as firmware).
	55	AC_ARG_WITH([platform],
	56	AS_HELP_STRING([--with-platform=PLATFORM],
83b984de	57	[select the host platform [[guessed]]]))
05568c2e	58
	59	# Guess the platform if not specified.
	60	if test "x$with_platform" = x; then
b977bf01	61	case "$target_cpu"-"$target_vendor" in
05568c2e	62	i386-apple) platform=efi ;;
05568c2e	63	i386-*) platform=pc ;;
58393a2d	64	x86_64-apple) platform=efi ;;
737feb35	65	x86_64-*) platform=pc ;;
05568c2e	66	powerpc-*) platform=ieee1275 ;;
58393a2d	67	powerpc64-*) platform=ieee1275 ;;
05568c2e	68	sparc64-*) platform=ieee1275 ;;
58393a2d	69	*) AC_MSG_ERROR([unsupported CPU: "$target_cpu"]) ;;
05568c2e	70	esac
	71	else
	72	platform="$with_platform"
	73	fi
	74
58393a2d	75	# Adjust CPU unless target was explicitly specified.
	76	if test -z "$target_alias"; then
	77	case "$target_cpu"-"$platform" in
	78	x86_64-efi) ;;
3f4ce737	79	x86_64-*) target_cpu=i386 ;;
3f4ce737	80	powerpc64-ieee1275) target_cpu=powerpc ;;
20011694	81	esac
	82	fi
	83
58393a2d	84	# Check if the platform is supported, make final adjustments.
b977bf01	85	case "$target_cpu"-"$platform" in
05568c2e	86	i386-efi) ;;
3f4ce737	87	x86_64-efi) ;;
05568c2e	88	i386-pc) ;;
546f966a	89	i386-coreboot) ;;
58393a2d	90	i386-linuxbios) platform=coreboot ;;
3d04eab8	91	i386-ieee1275) ;;
05568c2e	92	powerpc-ieee1275) ;;
05568c2e	93	sparc64-ieee1275) ;;
58393a2d	94	*) AC_MSG_ERROR([platform "$platform" is not supported for target CPU "$target_cpu"]) ;;
6a161fa9	95	esac
6a161fa9	96
3f4ce737	97	case "$target_cpu" in
	98	i386 \| powerpc) target_m32=1 ;;
	99	x86_64 \| sparc64) target_m64=1 ;;
	100	esac
	101
6e5a42fe	102	case "$host_os" in
	103	mingw32) host_os=cygwin ;;
	104	esac
	105
	106	case "$target_os" in
	107	mingw32) target_os=cygwin ;;
	108	esac
	109
b977bf01	110	AC_SUBST(target_cpu)
2d05bc6a	111	AC_SUBST(target_os)
05568c2e	112	AC_SUBST(platform)
6a161fa9	113
b977bf01	114	#
	115	# Checks for build programs.
	116	#
144f1f98	117
6c826348	118	# Although cmp is listed in the GNU Coding Standards as a command which
	119	# can used directly, OpenBSD lacks cmp in the default installation.
	120	AC_CHECK_PROGS([CMP], [cmp])
	121	if test "x$CMP" = x; then
	122	AC_MSG_ERROR([cmp is not found])
	123	fi
	124
144f1f98	125	AC_CHECK_PROGS([YACC], [bison])
1569ec51	126	if test "x$YACC" = x; then
6c826348	127	AC_MSG_ERROR([bison is not found])
1569ec51	128	fi
1569ec51	129
1e901a75	130	for file in /usr/src/unifont.bdf ; do
4931827f	131	if test -e $file ; then
1e901a75	132	AC_SUBST([UNIFONT_BDF], [$file])
4931827f	133	break
	134	fi
	135	done
	136
b977bf01	137	AC_PROG_INSTALL
	138	AC_PROG_AWK
	139	AC_PROG_MAKE_SET
	140
68807e5f	141	# These are not a "must".
b977bf01	142	AC_PATH_PROG(RUBY, ruby)
68807e5f	143	AC_PATH_PROG(HELP2MAN, help2man)
6a161fa9	144
b977bf01	145	#
	146	# Checks for host programs.
	147	#
	148
	149	AC_PROG_CC
6a161fa9	150	# Must be GCC.
	151	test "x$GCC" = xyes \|\| AC_MSG_ERROR([GCC is required])
	152
4889bdec	153	AC_GNU_SOURCE
b977bf01	154	AC_SYS_LARGEFILE
	155
	156	# Identify characteristics of the host architecture.
	157	AC_C_BIGENDIAN
	158	AC_CHECK_SIZEOF(void *)
	159	AC_CHECK_SIZEOF(long)
	160
	161	if test "x$host_m32" = x1; then
	162	# Force 32-bit mode.
	163	CFLAGS="$CFLAGS -m32"
	164	LDFLAGS="$LDFLAGS -m32"
	165	fi
	166
	167	# Check LZO when compiling for the i386-pc.
	168	if test "$target_cpu"-"$platform" = i386-pc; then
aa24b516	169	AC_ARG_ENABLE([lzo],
	170	[AS_HELP_STRING([--enable-lzo],
	171	[use lzo to compress kernel (default is lzma)])])
	172	[if [ x"$enable_lzo" = xyes ]; then
	173	# There are three possibilities. LZO version 2 installed with the name
	174	# liblzo2, with the name liblzo, and LZO version 1.]
	175	AC_DEFINE([ENABLE_LZO], [1], [Use lzo compression])
	176	AC_CHECK_LIB([lzo2], [__lzo_init_v2], [LIBLZO="-llzo2"],
	177	[AC_CHECK_LIB([lzo], [__lzo_init_v2], [LIBLZO="-llzo"],
	178	[AC_CHECK_LIB([lzo], [__lzo_init2], [LIBLZO="-llzo"],
	179	[AC_MSG_ERROR([LZO library version 1.02 or later is required])])])])
	180	AC_SUBST([LIBLZO])
	181	[LIBS="$LIBS $LIBLZO"]
	182	AC_CHECK_FUNC([lzo1x_999_compress], ,
b977bf01	183	[AC_MSG_ERROR([LZO1X-999 must be enabled])])
b977bf01	184
aa24b516	185	[# LZO version 2 uses lzo/lzo1x.h, while LZO version 1 uses lzo1x.h.]
	186	AC_CHECK_HEADERS([lzo/lzo1x.h lzo1x.h])
	187	[else]
	188	AC_DEFINE([ENABLE_LZMA], [1], [Use lzma compression])
	189	[fi]
	190	AC_SUBST([enable_lzo])
b977bf01	191	fi
b977bf01	192
4889bdec	193	# Check for functions.
6e5a42fe	194	AC_CHECK_FUNCS(posix_memalign memalign asprintf)
4889bdec	195
b977bf01	196	#
	197	# Check for target programs.
	198	#
	199
2a8a80e4	200
	201	# Use linker script if present, otherwise use builtin -N script.
	202	AC_MSG_CHECKING([for option to link raw image])
	203	if test -f "${srcdir}/conf/${target_cpu}-${platform}-${target_os}-img-ld.sc"; then
	204	TARGET_IMG_LDSCRIPT='$(top_srcdir)'"/conf/${target_cpu}-${platform}-${target_os}-img-ld.sc"
	205	TARGET_IMG_LDFLAGS="-Wl,-T${TARGET_IMG_LDSCRIPT}"
	206	TARGET_IMG_LDFLAGS_AC="-Wl,-T${srcdir}/conf/${target_cpu}-${platform}-${target_os}-img-ld.sc"
	207	else
	208	TARGET_IMG_LDSCRIPT=
	209	TARGET_IMG_LDFLAGS='-Wl,-N'
	210	TARGET_IMG_LDFLAGS_AC='-Wl,-N'
	211	fi
	212	AC_SUBST(TARGET_IMG_LDSCRIPT)
	213	AC_SUBST(TARGET_IMG_LDFLAGS)
	214	AC_MSG_RESULT([$TARGET_IMG_LDFLAGS_AC])
	215
	216	# For platforms where ELF is not the default link format.
	217	AC_MSG_CHECKING([for command to convert module to ELF format])
2d05bc6a	218	case "${host_os}:${target_os}" in
	219	cygwin:cygwin) TARGET_OBJ2ELF='grub-pe2elf' ;;
	220	*) ;;
	221	esac
2a8a80e4	222	AC_SUBST(TARGET_OBJ2ELF)
	223	AC_MSG_RESULT([$TARGET_OBJ2ELF])
	224
b977bf01	225	# For cross-compiling.
580b2a0f	226	if test "x$build" != "x$host"; then
b977bf01	227	# XXX this depends on the implementation of autoconf!
	228	tmp_ac_tool_prefix="$ac_tool_prefix"
	229	ac_tool_prefix=$target_alias-
	230
	231	AC_CHECK_TOOLS(TARGET_CC, [gcc egcs cc],
	232	[AC_MSG_ERROR([none of gcc, egcs and cc is found. set TARGET_CC manually.])])
	233	AC_CHECK_TOOL(OBJCOPY, objcopy)
	234	AC_CHECK_TOOL(STRIP, strip)
	235	AC_CHECK_TOOL(NM, nm)
	236
	237	ac_tool_prefix="$tmp_ac_tool_prefix"
	238	else
	239	if test "x$TARGET_CC" = x; then
	240	TARGET_CC=$CC
	241	fi
	242	AC_CHECK_TOOL(OBJCOPY, objcopy)
	243	AC_CHECK_TOOL(STRIP, strip)
	244	AC_CHECK_TOOL(NM, nm)
	245	fi
	246	AC_SUBST(TARGET_CC)
	247
	248
	249	# Test the C compiler for the target environment.
	250	tmp_CC="$CC"
	251	tmp_CFLAGS="$CFLAGS"
	252	tmp_LDFLAGS="$LDFLAGS"
	253	tmp_CPPFLAGS="$CPPFLAGS"
aa6d7826	254	tmp_LIBS="$LIBS"
b977bf01	255	CC="$TARGET_CC"
	256	CFLAGS="$TARGET_CFLAGS"
	257	CPPFLAGS="$TARGET_CPPFLAGS"
	258	LDFLAGS="$TARGET_LDFLAGS"
aa6d7826	259	LIBS=""
b977bf01	260
b977bf01	261	if test "x$TARGET_CFLAGS" = x; then
6a161fa9	262	# debug flags.
b977bf01	263	TARGET_CFLAGS="-Wall -W -Wshadow -Wpointer-arith -Wmissing-prototypes \
b977bf01	264	-Wundef -Wstrict-prototypes -g"
6a161fa9	265
6a161fa9	266	# optimization flags.
322562ea	267	AC_CACHE_CHECK([whether optimization for size works], grub_cv_cc_Os, [
6a161fa9	268	CFLAGS=-Os
eb73121d	269	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
	270	[grub_cv_cc_Os=yes],
	271	[grub_cv_cc_Os=no])
6a161fa9	272	])
322562ea	273	if test "x$grub_cv_cc_Os" = xyes; then
b977bf01	274	TARGET_CFLAGS="$TARGET_CFLAGS -Os"
6a161fa9	275	else
b977bf01	276	TARGET_CFLAGS="$TARGET_CFLAGS -O2 -fno-strength-reduce -fno-unroll-loops"
6a161fa9	277	fi
	278
	279	# Force no alignment to save space on i386.
b977bf01	280	if test "x$target_cpu" = xi386; then
322562ea	281	AC_CACHE_CHECK([whether -falign-loops works], [grub_cv_cc_falign_loop], [
6a161fa9	282	CFLAGS="-falign-loops=1"
eb73121d	283	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
	284	[grub_cv_cc_falign_loop=yes],
	285	[grub_cv_cc_falign_loop=no])
6a161fa9	286	])
6a161fa9	287
322562ea	288	if test "x$grub_cv_cc_falign_loop" = xyes; then
b977bf01	289	TARGET_CFLAGS="$TARGET_CFLAGS -falign-jumps=1 -falign-loops=1 -falign-functions=1"
6a161fa9	290	else
b977bf01	291	TARGET_CFLAGS="$TARGET_CFLAGS -malign-jumps=1 -malign-loops=1 -malign-functions=1"
6a161fa9	292	fi
6a161fa9	293	fi
b977bf01	294	fi
6a161fa9	295
b977bf01	296	if test "x$target_m32" = x1; then
	297	# Force 32-bit mode.
	298	TARGET_CFLAGS="$TARGET_CFLAGS -m32"
	299	TARGET_LDFLAGS="$TARGET_LDFLAGS -m32"
6a161fa9	300	fi
b977bf01	301
20011694	302	if test "x$target_m64" = x1; then
	303	# Force 64-bit mode.
	304	TARGET_CFLAGS="$TARGET_CFLAGS -m64"
	305	TARGET_LDFLAGS="$TARGET_LDFLAGS -m64"
	306	fi
	307
baa2a121	308	#
	309	# Compiler features.
	310	#
	311
9035dce4	312	# Need __enable_execute_stack() for nested function trampolines?
	313	grub_CHECK_ENABLE_EXECUTE_STACK
	314
baa2a121	315	# Smashing stack protector.
baa2a121	316	grub_CHECK_STACK_PROTECTOR
c3db8364	317	# Need that, because some distributions ship compilers that include
baa2a121	318	# `-fstack-protector' in the default specs.
c3db8364	319	if test "x$ssp_possible" = xyes; then
	320	TARGET_CFLAGS="$TARGET_CFLAGS -fno-stack-protector"
	321	fi
2a8a80e4	322	grub_CHECK_STACK_ARG_PROBE
	323	# Cygwin's GCC uses alloca() to probe the stackframe on static
	324	# stack allocations above some threshold.
	325	if test x"$sap_possible" = xyes; then
	326	TARGET_CFLAGS="$TARGET_CFLAGS -mno-stack-arg-probe"
	327	fi
baa2a121	328
b977bf01	329	AC_SUBST(TARGET_CFLAGS)
	330	AC_SUBST(TARGET_CPPFLAGS)
	331	AC_SUBST(TARGET_LDFLAGS)
cb71ba20	332	AC_SUBST(MODULE_LDFLAGS)
6a161fa9	333
aa6d7826	334	# Set them to their new values for the tests below.
	335	CC="$TARGET_CC"
	336	CFLAGS="$TARGET_CFLAGS"
	337	CPPFLAGS="$TARGET_CPPFLAGS"
	338	LDFLAGS="$TARGET_LDFLAGS"
	339
6a161fa9	340	# Defined in aclocal.m4.
f6130a12	341	grub_PROG_TARGET_CC
b977bf01	342	grub_PROG_OBJCOPY_ABSOLUTE
cb71ba20	343	grub_PROG_LD_BUILD_ID_NONE
4b13b216	344	grub_ASM_USCORE
b977bf01	345	if test "x$target_cpu" = xi386; then
2a8a80e4	346	if test ! -z "$TARGET_IMG_LDSCRIPT"; then
	347	# Check symbols provided by linker script.
	348	CFLAGS="$TARGET_CFLAGS -nostdlib $TARGET_IMG_LDFLAGS_AC -Wl,-Ttext,8000,--defsym,___main=0x8100"
	349	fi
7810e747	350	if test "x$platform" = xpc; then
2a8a80e4	351	grub_CHECK_START_SYMBOL
	352	grub_CHECK_BSS_START_SYMBOL
	353	grub_CHECK_END_SYMBOL
	354	fi
	355	CFLAGS="$TARGET_CFLAGS"
4b13b216	356	grub_I386_ASM_PREFIX_REQUIREMENT
	357	grub_I386_ASM_ADDR32
	358	grub_I386_ASM_ABSOLUTE_WITHOUT_ASTERISK
	359	grub_I386_CHECK_REGPARM_BUG
5aded270	360	else
f4917dfd	361	AC_DEFINE([NESTED_FUNC_ATTR], [], [Catch gcc bug])
6a161fa9	362	fi
6a161fa9	363
c9a86192	364	# Restore the flags.
9962ed99	365	CC="$tmp_CC"
	366	CFLAGS="$tmp_CFLAGS"
	367	CPPFLAGS="$tmp_CPPFLAGS"
c9a86192	368	LDFLAGS="$tmp_LDFLAGS"
aa6d7826	369	LIBS="$tmp_LIBS"
6a161fa9	370
4fe9862e	371	#
2965c7cc	372	# Check for options.
4fe9862e	373	#
	374
	375	# Memory manager debugging.
2965c7cc	376	AC_ARG_ENABLE([mm-debug],
2965c7cc	377	AS_HELP_STRING([--enable-mm-debug],
90ce5d56	378	[include memory manager debugging]),
2965c7cc	379	[AC_DEFINE([MM_DEBUG], [1],
	380	[Define to 1 if you enable memory manager debugging.])])
	381
4fe9862e	382	AC_ARG_ENABLE([grub-emu],
	383	[AS_HELP_STRING([--enable-grub-emu],
	384	[build and install the `grub-emu' debugging utility])])
	385	[if [ x"$enable_grub_emu" = xyes ]; then
	386	# Check for curses libraries.]
	387	AC_CHECK_LIB([ncurses], [wgetch], [LIBCURSES="-lncurses"],
	388	[AC_CHECK_LIB([curses], [wgetch], [LIBCURSES="-lcurses"],
	389	[AC_MSG_ERROR([(n)curses libraries are required to build `grub-emu'])])])
	390	AC_SUBST([LIBCURSES])
	391
	392	[# Check for headers.]
	393	AC_CHECK_HEADERS([ncurses/curses.h], [],
	394	[AC_CHECK_HEADERS([ncurses.h], [],
	395	[AC_CHECK_HEADERS([curses.h], [],
	396	[AC_MSG_ERROR([(n)curses header files are required to build `grub-emu'])])])])
	397	[fi]
	398	AC_SUBST([enable_grub_emu])
	399
99fadbaa	400	AC_ARG_ENABLE([grub-fstest],
	401	[AS_HELP_STRING([--enable-grub-fstest],
	402	[build and install the `grub-fstest' debugging utility])])
	403	AC_SUBST([enable_grub_fstest])
	404
2d05bc6a	405	AC_ARG_ENABLE([grub-pe2elf],
	406	[AS_HELP_STRING([--enable-grub-pe2elf],
	407	[build and install the `grub-pe2elf' conversion utility])])
	408	AC_SUBST([enable_grub_pe2elf])
	409
e52db1f7	410	AC_ARG_ENABLE([grub-mkfont],
	411	[AS_HELP_STRING([--enable-grub-mkfont],
	412	[build and install the `grub-mkfont' utility])])
	413	if test x"$enable_grub_mkfont" = xyes ; then
	414	# Check for freetype libraries.
	415	AC_CHECK_PROGS([FREETYPE], [freetype-config])
	416	if test "x$FREETYPE" = x ; then
	417	AC_MSG_ERROR([freetype2 libraries are required to build `grub-mkfont'])
	418	fi
	419	freetype_cflags=`freetype-config --cflags`
	420	freetype_libs=`freetype-config --libs`
	421	fi
	422	AC_SUBST([enable_grub_mkfont])
	423	AC_SUBST([freetype_cflags])
	424	AC_SUBST([freetype_libs])
	425
6a161fa9	426	# Output files.
b977bf01	427	AC_CONFIG_LINKS([include/grub/cpu:include/grub/$target_cpu
b977bf01	428	include/grub/machine:include/grub/$target_cpu/$platform])
7b455f4d	429	AC_CONFIG_FILES([Makefile gensymlist.sh genkernsyms.sh])
6a161fa9	430	AC_CONFIG_FILES([stamp-h], [echo timestamp > stamp-h])
6a161fa9	431	AC_OUTPUT