2N/Adnl Redefine AC_LANG_PROGRAM with a "-Wstrict-prototypes -Werror"-friendly

2N/Adnl version. Patch submitted to bug-autoconf in 2009-09-16.

2N/Am4_define([AC_LANG_PROGRAM(C)],

2N/A[$1

2N/Aint

2N/Amain (void)

2N/A{

2N/Adnl Do *not* indent the following line: there may be CPP directives.

2N/Adnl Don't move the `;' right after for the same reason.

2N/A$2

2N/A ;

2N/A return 0;

2N/A}])

2N/A

2N/A

2N/Adnl Check whether target compiler is working

2N/AAC_DEFUN([grub_PROG_TARGET_CC],

2N/A[AC_MSG_CHECKING([whether target compiler is working])

2N/AAC_CACHE_VAL(grub_cv_prog_target_cc,

2N/A[AC_LINK_IFELSE([AC_LANG_PROGRAM([[

2N/Aasm (".globl start; start:");

2N/Aint main (void);

2N/A]], [[]])],

2N/A [grub_cv_prog_target_cc=yes],

2N/A [grub_cv_prog_target_cc=no])

2N/A])

2N/AAC_MSG_RESULT([$grub_cv_prog_target_cc])

2N/A

2N/Aif test "x$grub_cv_prog_target_cc" = xno; then

2N/A AC_MSG_ERROR([cannot compile for the target])

2N/Afi

2N/A])

2N/A

2N/Adnl Check whether target compiler uses gas as its assembler

2N/AAC_DEFUN([grub_PROG_TARGET_CC_USES_GAS],

2N/A[AC_MSG_CHECKING([whether target compiler uses gas as its assembler])

2N/AAC_CACHE_VAL(grub_cv_prog_target_cc_uses_gas,

2N/A[AC_LINK_IFELSE([AC_LANG_PROGRAM([[

2N/Aasm (".code16; .globl start; .type start, \"function\"; start:");

2N/Aint main (void);

2N/A]], [[]])],

2N/A [grub_cv_prog_target_cc_uses_gas=yes],

2N/A [grub_cv_prog_target_cc_uses_gas=no])

2N/A])

2N/AAC_MSG_RESULT([$grub_cv_prog_target_cc_uses_gas])

2N/A])

2N/A

2N/A

2N/Adnl grub_ASM_USCORE checks if C symbols get an underscore after

2N/Adnl compiling to assembler.

2N/Adnl Written by Pavel Roskin. Based on grub_ASM_EXT_C written by

2N/Adnl Erich Boleyn and modified by Yoshinori K. Okuji.

2N/AAC_DEFUN([grub_ASM_USCORE],

2N/A[AC_REQUIRE([AC_PROG_CC])

2N/AAC_REQUIRE([AC_PROG_EGREP])

2N/AAC_MSG_CHECKING([if C symbols get an underscore after compilation])

2N/AAC_CACHE_VAL(grub_cv_asm_uscore,

2N/A[cat > conftest.c <<\EOF

2N/Aint func (int *);

2N/Aint

2N/Afunc (int *list)

2N/A{

2N/A *list = 0;

2N/A return *list;

2N/A}

2N/AEOF

2N/A

2N/Aif AC_TRY_COMMAND([${CC-cc} ${CFLAGS} -S conftest.c]) && test -s conftest.s; then

2N/A true

2N/Aelse

2N/A AC_MSG_ERROR([${CC-cc} failed to produce assembly code])

2N/Afi

2N/A

2N/Aif $EGREP '(^|[^_[:alnum]])_func' conftest.s >/dev/null 2>&1; then

2N/A HAVE_ASM_USCORE=1

2N/A grub_cv_asm_uscore=yes

2N/Aelse

2N/A HAVE_ASM_USCORE=0

2N/A grub_cv_asm_uscore=no

2N/Afi

2N/A

2N/Arm -f conftest*])

2N/A

2N/AAC_MSG_RESULT([$grub_cv_asm_uscore])

2N/A])

2N/A

2N/A

2N/Adnl Some versions of `objcopy -O binary' vary their output depending

2N/Adnl on the link address.

2N/AAC_DEFUN([grub_PROG_OBJCOPY_ABSOLUTE],

2N/A[AC_MSG_CHECKING([whether ${OBJCOPY} works for absolute addresses])

2N/AAC_CACHE_VAL(grub_cv_prog_objcopy_absolute,

2N/A[cat > conftest.c <<\EOF

2N/Avoid cmain (void);

2N/Avoid

2N/Acmain (void)

2N/A{

2N/A *((int *) 0x1000) = 2;

2N/A}

2N/AEOF

2N/A

2N/Aif AC_TRY_EVAL(ac_compile) && test -s conftest.o; then :

2N/Aelse

2N/A AC_MSG_ERROR([${CC-cc} cannot compile C source code])

2N/Afi

2N/Agrub_cv_prog_objcopy_absolute=yes

2N/Afor link_addr in 0x2000 0x8000 0x7C00; do

2N/A

2N/A if test x$grub_cv_solaris_linker = xyes ; then

2N/A

2N/Acat > conftest.map <<EOF

2N/A text = P${link_addr} ;

2N/AEOF

2N/A if AC_TRY_COMMAND([${CC-cc} ${CFLAGS} -nostdlib -Wl,-Mconftest.map conftest.o -o conftest.exec]); then :

2N/A else

2N/A AC_MSG_ERROR([${CC-cc} cannot link at address $link_addr])

2N/A fi

2N/A if AC_TRY_COMMAND([${OBJCOPY-objcopy} --only-section=.text -O binary conftest.exec conftest]); then :

2N/A else

2N/A AC_MSG_ERROR([${OBJCOPY-objcopy} cannot create binary files])

2N/A fi

2N/A

2N/A else

2N/A

2N/A if AC_TRY_COMMAND([${CC-cc} ${CFLAGS} -nostdlib ${TARGET_IMG_LDFLAGS_AC} ${TARGET_IMG_BASE_LDOPT},$link_addr conftest.o -o conftest.exec]); then :

2N/A else

2N/A AC_MSG_ERROR([${CC-cc} cannot link at address $link_addr])

2N/A fi

2N/A if AC_TRY_COMMAND([${OBJCOPY-objcopy} --only-section=.text -O binary conftest.exec conftest]); then :

2N/A else

2N/A AC_MSG_ERROR([${OBJCOPY-objcopy} cannot create binary files])

2N/A fi

2N/A

2N/A fi

2N/A

2N/A if test ! -f conftest.old || AC_TRY_COMMAND([cmp -s conftest.old conftest]); then

2N/A mv -f conftest conftest.old

2N/A else

2N/A grub_cv_prog_objcopy_absolute=no

2N/A break

2N/A fi

2N/A

2N/Adone

2N/Arm -f conftest*])

2N/AAC_MSG_RESULT([$grub_cv_prog_objcopy_absolute])

2N/A

2N/Aif test "x$grub_cv_prog_objcopy_absolute" = xno; then

2N/A AC_MSG_ERROR([GRUB requires a working absolute objcopy; upgrade your binutils])

2N/Afi

2N/A])

2N/A

2N/A

2N/Adnl Supply --build-id=none to ld if building modules.

2N/Adnl This suppresses warnings from ld on some systems

2N/AAC_DEFUN([grub_PROG_LD_BUILD_ID_NONE],

2N/A[AC_MSG_CHECKING([whether linker accepts --build-id=none])

2N/AAC_CACHE_VAL(grub_cv_prog_ld_build_id_none,

2N/A[save_LDFLAGS="$LDFLAGS"

2N/ALDFLAGS="$LDFLAGS -Wl,--build-id=none"

2N/AAC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[]])],

2N/A [grub_cv_prog_ld_build_id_none=yes],

2N/A [grub_cv_prog_ld_build_id_none=no])

2N/ALDFLAGS="$save_LDFLAGS"

2N/A])

2N/AAC_MSG_RESULT([$grub_cv_prog_ld_build_id_none])

2N/A

2N/Aif test "x$grub_cv_prog_ld_build_id_none" = xyes; then

2N/A TARGET_LDFLAGS="$TARGET_LDFLAGS -Wl,--build-id=none"

2N/Afi

2N/A])

2N/A

2N/A

2N/Adnl Mass confusion!

2N/Adnl Older versions of GAS interpret `.code16' to mean ``generate 32-bit

2N/Adnl instructions, but implicitly insert addr32 and data32 bytes so

2N/Adnl that the code works in real mode''.

2N/Adnl

2N/Adnl Newer versions of GAS interpret `.code16' to mean ``generate 16-bit

2N/Adnl instructions,'' which seems right. This requires the programmer

2N/Adnl to explicitly insert addr32 and data32 instructions when they want

2N/Adnl them.

2N/Adnl

2N/Adnl We only support the newer versions, because the old versions cause

2N/Adnl major pain, by requiring manual assembly to get 16-bit instructions into

2N/Adnl asm files.

2N/AAC_DEFUN([grub_I386_ASM_ADDR32],

2N/A[AC_REQUIRE([AC_PROG_CC])

2N/AAC_REQUIRE([grub_I386_ASM_PREFIX_REQUIREMENT])

2N/AAC_MSG_CHECKING([for .code16 addr32 assembler support])

2N/AAC_CACHE_VAL(grub_cv_i386_asm_addr32,

2N/A[cat > conftest.s.in <<\EOF

2N/A .code16

2N/Al1: @ADDR32@ movb %al, l1

2N/AEOF

2N/A

2N/Aif test "x$grub_cv_i386_asm_prefix_requirement" = xyes; then

2N/A sed -e s/@ADDR32@/addr32/ < conftest.s.in > conftest.s

2N/Aelse

2N/A sed -e s/@ADDR32@/addr32\;/ < conftest.s.in > conftest.s

2N/Afi

2N/A

2N/Aif AC_TRY_COMMAND([${CC-cc} ${CFLAGS} -c conftest.s]) && test -s conftest.o; then

2N/A grub_cv_i386_asm_addr32=yes

2N/Aelse

2N/A grub_cv_i386_asm_addr32=no

2N/Afi

2N/A

2N/Arm -f conftest*])

2N/A

2N/AAC_MSG_RESULT([$grub_cv_i386_asm_addr32])])

2N/A

2N/Adnl check if our compiler is apple cc

2N/Adnl because it requires numerous workarounds

2N/AAC_DEFUN([grub_apple_cc],

2N/A[AC_REQUIRE([AC_PROG_CC])

2N/AAC_MSG_CHECKING([whether our compiler is apple cc])

2N/AAC_CACHE_VAL(grub_cv_apple_cc,

2N/A[if $CC -v 2>&1 | grep "Apple Inc." > /dev/null; then

2N/A grub_cv_apple_cc=yes

2N/Aelse

2N/A grub_cv_apple_cc=no

2N/Afi

2N/A])

2N/A

2N/AAC_MSG_RESULT([$grub_cv_apple_cc])])

2N/A

2N/Adnl check if our target compiler is apple cc

2N/Adnl because it requires numerous workarounds

2N/AAC_DEFUN([grub_apple_target_cc],

2N/A[AC_REQUIRE([AC_PROG_CC])

2N/AAC_MSG_CHECKING([whether our target compiler is apple cc])

2N/AAC_CACHE_VAL(grub_cv_apple_target_cc,

2N/A[if $CC -v 2>&1 | grep "Apple Inc." > /dev/null; then

2N/A grub_cv_apple_target_cc=yes

2N/Aelse

2N/A grub_cv_apple_target_cc=no

2N/Afi

2N/A])

2N/A

2N/AAC_MSG_RESULT([$grub_cv_apple_target_cc])])

2N/A

2N/Adnl check if our target linker is Solaris ld

2N/Adnl because it requires mapfiles instead of GNU ld command-line args

2N/AAC_DEFUN([grub_solaris_linker],

2N/A[AC_REQUIRE([AC_PROG_CC])

2N/AAC_MSG_CHECKING([whether our target linker is Solaris ld])

2N/AAC_CACHE_VAL(grub_cv_solaris_linker,

2N/A[cat > conftest.c <<\EOF

2N/Aint main(int argc, char **argv){return 0;}

2N/AEOF

2N/Aif $CC conftest.c -o /dev/null -Wl,-V 2>&1 | grep "Solaris Link Editors" > /dev/null; then

2N/A grub_cv_solaris_linker=yes

2N/Aelse

2N/A grub_cv_solaris_linker=no

2N/Afi

2N/A])

2N/A

2N/AAC_MSG_RESULT([$grub_cv_solaris_linker])])

2N/A

2N/A

2N/Adnl Later versions of GAS requires that addr32 and data32 prefixes

2N/Adnl appear in the same lines as the instructions they modify, while

2N/Adnl earlier versions requires that they appear in separate lines.

2N/AAC_DEFUN([grub_I386_ASM_PREFIX_REQUIREMENT],

2N/A[AC_REQUIRE([AC_PROG_CC])

2N/AAC_MSG_CHECKING(dnl

2N/A[whether addr32 must be in the same line as the instruction])

2N/AAC_CACHE_VAL(grub_cv_i386_asm_prefix_requirement,

2N/A[cat > conftest.s <<\EOF

2N/A .code16

2N/Al1: addr32 movb %al, l1

2N/AEOF

2N/A

2N/Aif AC_TRY_COMMAND([${CC-cc} ${CFLAGS} -c conftest.s]) && test -s conftest.o; then

2N/A grub_cv_i386_asm_prefix_requirement=yes

2N/Aelif test "x$grub_cv_solaris_linker" = xyes; then

2N/A # Force this to be true on Solaris since we always use the latest GAS

2N/A grub_cv_i386_asm_prefix_requirement=yes

2N/Aelse

2N/A grub_cv_i386_asm_prefix_requirement=no

2N/Afi

2N/A

2N/Arm -f conftest*])

2N/A

2N/Aif test "x$grub_cv_i386_asm_prefix_requirement" = xyes; then

2N/A grub_tmp_addr32="addr32"

2N/A grub_tmp_data32="data32"

2N/Aelse

2N/A grub_tmp_addr32="addr32;"

2N/A grub_tmp_data32="data32;"

2N/Afi

2N/A

2N/AADDR32=$grub_tmp_addr32

2N/ADATA32=$grub_tmp_data32

2N/A

2N/AAC_MSG_RESULT([$grub_cv_i386_asm_prefix_requirement])])

2N/A

2N/A

2N/Adnl Check what symbol is defined as a bss start symbol.

2N/Adnl Written by Michael Hohmoth and Yoshinori K. Okuji.

2N/AAC_DEFUN([grub_CHECK_BSS_START_SYMBOL],

2N/A[AC_REQUIRE([AC_PROG_CC])

2N/AAC_MSG_CHECKING([if __bss_start is defined by the compiler])

2N/AAC_CACHE_VAL(grub_cv_check_uscore_uscore_bss_start_symbol,

2N/A[AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],

2N/A [[asm ("incl __bss_start")]])],

2N/A [grub_cv_check_uscore_uscore_bss_start_symbol=yes],

2N/A [grub_cv_check_uscore_uscore_bss_start_symbol=no])])

2N/A

2N/AAC_MSG_RESULT([$grub_cv_check_uscore_uscore_bss_start_symbol])

2N/A

2N/AAC_MSG_CHECKING([if edata is defined by the compiler])

2N/AAC_CACHE_VAL(grub_cv_check_edata_symbol,

2N/A[AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],

2N/A [[asm ("incl edata")]])],

2N/A [grub_cv_check_edata_symbol=yes],

2N/A [grub_cv_check_edata_symbol=no])])

2N/A

2N/AAC_MSG_RESULT([$grub_cv_check_edata_symbol])

2N/A

2N/AAC_MSG_CHECKING([if _edata is defined by the compiler])

2N/AAC_CACHE_VAL(grub_cv_check_uscore_edata_symbol,

2N/A[AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],

2N/A [[asm ("incl _edata")]])],

2N/A [grub_cv_check_uscore_edata_symbol=yes],

2N/A [grub_cv_check_uscore_edata_symbol=no])])

2N/A

2N/AAC_MSG_RESULT([$grub_cv_check_uscore_edata_symbol])

2N/A

2N/Aif test "x$grub_cv_check_uscore_uscore_bss_start_symbol" = xyes; then

2N/A BSS_START_SYMBOL=__bss_start

2N/Aelif test "x$grub_cv_check_edata_symbol" = xyes; then

2N/A BSS_START_SYMBOL=edata

2N/Aelif test "x$grub_cv_check_uscore_edata_symbol" = xyes; then

2N/A BSS_START_SYMBOL=_edata

2N/Aelse

2N/A AC_MSG_ERROR([none of __bss_start, edata or _edata is defined])

2N/Afi

2N/A])

2N/A

2N/Adnl Check what symbol is defined as an end symbol.

2N/Adnl Written by Yoshinori K. Okuji.

2N/AAC_DEFUN([grub_CHECK_END_SYMBOL],

2N/A[AC_REQUIRE([AC_PROG_CC])

2N/AAC_MSG_CHECKING([if end is defined by the compiler])

2N/AAC_CACHE_VAL(grub_cv_check_end_symbol,

2N/A[AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],

2N/A [[asm ("incl end")]])],

2N/A [grub_cv_check_end_symbol=yes],

2N/A [grub_cv_check_end_symbol=no])])

2N/A

2N/AAC_MSG_RESULT([$grub_cv_check_end_symbol])

2N/A

2N/AAC_MSG_CHECKING([if _end is defined by the compiler])

2N/AAC_CACHE_VAL(grub_cv_check_uscore_end_symbol,

2N/A[AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],

2N/A [[asm ("incl _end")]])],

2N/A [grub_cv_check_uscore_end_symbol=yes],

2N/A [grub_cv_check_uscore_end_symbol=no])])

2N/A

2N/AAC_MSG_RESULT([$grub_cv_check_uscore_end_symbol])

2N/A

2N/Aif test "x$grub_cv_check_end_symbol" = xyes; then

2N/A END_SYMBOL=end

2N/Aelif test "x$grub_cv_check_uscore_end_symbol" = xyes; then

2N/A END_SYMBOL=_end

2N/Aelse

2N/A AC_MSG_ERROR([neither end nor _end is defined])

2N/Afi

2N/A])

2N/A

2N/Adnl Check if the C compiler generates calls to `__enable_execute_stack()'.

2N/AAC_DEFUN([grub_CHECK_ENABLE_EXECUTE_STACK],[

2N/AAC_MSG_CHECKING([whether `$CC' generates calls to `__enable_execute_stack()'])

2N/AAC_LANG_CONFTEST([AC_LANG_SOURCE([[

2N/Avoid f (int (*p) (void));

2N/Avoid g (int i)

2N/A{

2N/A int nestedfunc (void) { return i; }

2N/A f (nestedfunc);

2N/A}

2N/A]])])

2N/Aif AC_TRY_COMMAND([${CC-cc} ${CFLAGS} -S conftest.c]) && test -s conftest.s; then

2N/A true

2N/Aelse

2N/A AC_MSG_ERROR([${CC-cc} failed to produce assembly code])

2N/Afi

2N/Aif grep __enable_execute_stack conftest.s >/dev/null 2>&1; then

2N/A NEED_ENABLE_EXECUTE_STACK=1

2N/A AC_MSG_RESULT([yes])

2N/Aelse

2N/A NEED_ENABLE_EXECUTE_STACK=0

2N/A AC_MSG_RESULT([no])

2N/Afi

2N/Arm -f conftest*

2N/A])

2N/A

2N/A

2N/Adnl Check if the C compiler supports `-fstack-protector'.

2N/AAC_DEFUN([grub_CHECK_STACK_PROTECTOR],[

2N/A[# Smashing stack protector.

2N/Assp_possible=yes]

2N/AAC_MSG_CHECKING([whether `$CC' accepts `-fstack-protector'])

2N/A# Is this a reliable test case?

2N/AAC_LANG_CONFTEST([AC_LANG_SOURCE([[

2N/Avoid foo (void) { volatile char a[8]; a[3]; }

2N/A]])])

2N/A[# `$CC -c -o ...' might not be portable. But, oh, well... Is calling

2N/A# `ac_compile' like this correct, after all?

2N/Aif eval "$ac_compile -S -fstack-protector -o conftest.s" 2> /dev/null; then]

2N/A AC_MSG_RESULT([yes])

2N/A [# Should we clear up other files as well, having called `AC_LANG_CONFTEST'?

2N/A rm -f conftest.s

2N/Aelse

2N/A ssp_possible=no]

2N/A AC_MSG_RESULT([no])

2N/A[fi]

2N/A])

2N/A

2N/Adnl Check if the C compiler supports `-mstack-arg-probe' (Cygwin).

2N/AAC_DEFUN([grub_CHECK_STACK_ARG_PROBE],[

2N/A[# Smashing stack arg probe.

2N/Asap_possible=yes]

2N/AAC_MSG_CHECKING([whether `$CC' accepts `-mstack-arg-probe'])

2N/AAC_LANG_CONFTEST([AC_LANG_SOURCE([[

2N/Avoid foo (void) { volatile char a[8]; a[3]; }

2N/A]])])

2N/A[if eval "$ac_compile -S -mstack-arg-probe -o conftest.s" 2> /dev/null; then]

2N/A AC_MSG_RESULT([yes])

2N/A [# Should we clear up other files as well, having called `AC_LANG_CONFTEST'?

2N/A rm -f conftest.s

2N/Aelse

2N/A sap_possible=no]

2N/A AC_MSG_RESULT([no])

2N/A[fi]

2N/A])

2N/A

2N/Adnl Check if ln can handle directories properly (mingw).

2N/AAC_DEFUN([grub_CHECK_LINK_DIR],[

2N/AAC_MSG_CHECKING([whether ln can handle directories properly])

2N/A[mkdir testdir 2>/dev/null

2N/Acase $srcdir in

2N/A[\\/$]* | ?:[\\/]* ) reldir=$srcdir/include/grub/util ;;

2N/A *) reldir=../$srcdir/include/grub/util ;;

2N/Aesac

2N/Aif ln -s $reldir testdir/util 2>/dev/null ; then]

2N/A AC_MSG_RESULT([yes])

2N/A [link_dir=yes

2N/Aelse

2N/A link_dir=no]

2N/A AC_MSG_RESULT([no])

2N/A[fi

2N/Arm -rf testdir]

2N/A])

2N/A

2N/Adnl Check if the C compiler supports `-fPIE'.

2N/AAC_DEFUN([grub_CHECK_PIE],[

2N/A[# Position independent executable.

2N/Apie_possible=yes]

2N/AAC_MSG_CHECKING([whether `$CC' has `-fPIE' as default])

2N/A# Is this a reliable test case?

2N/AAC_LANG_CONFTEST([AC_LANG_SOURCE([[

2N/A#ifdef __PIE__

2N/Aint main() {

2N/A return 0;

2N/A}

2N/A#else

2N/A#error NO __PIE__ DEFINED

2N/A#endif

2N/A]])])

2N/A

2N/A[# `$CC -c -o ...' might not be portable. But, oh, well... Is calling

2N/A# `ac_compile' like this correct, after all?

2N/Aif eval "$ac_compile -S -o conftest.s" 2> /dev/null; then]

2N/A AC_MSG_RESULT([yes])

2N/A [# Should we clear up other files as well, having called `AC_LANG_CONFTEST'?

2N/A rm -f conftest.s

2N/Aelse

2N/A pie_possible=no]

2N/A AC_MSG_RESULT([no])

2N/A[fi]

2N/A])