aclocal.m4

   1 dnl Redefine AC_LANG_PROGRAM with a "-Wstrict-prototypes -Werror"-friendly
   2 dnl version.  Patch submitted to bug-autoconf in 2009-09-16.
   3 m4_define([AC_LANG_PROGRAM(C)],
   4 [$1
   5 int
   6 main (void)
   7 {
   8 dnl Do *not* indent the following line: there may be CPP directives.
   9 dnl Don't move the `;' right after for the same reason.
  10 $2
  11   ;
  12   return 0;
  13 }])
  14
  15
  16 dnl Check whether target compiler is working
  17 AC_DEFUN(grub_PROG_TARGET_CC,
  18 [AC_MSG_CHECKING([whether target compiler is working])
  19 AC_CACHE_VAL(grub_cv_prog_target_cc,
  20 [AC_LINK_IFELSE([AC_LANG_PROGRAM([[
  21 asm (".globl start; start: nop");
  22 int main (void);
  23 ]], [[]])],
  24                 [grub_cv_prog_target_cc=yes],
  25                 [grub_cv_prog_target_cc=no])
  26 ])
  27 AC_MSG_RESULT([$grub_cv_prog_target_cc])
  28
  29 if test "x$grub_cv_prog_target_cc" = xno; then
  30   AC_MSG_ERROR([cannot compile for the target])
  31 fi
  32 ])
  33
  34
  35 dnl grub_ASM_USCORE checks if C symbols get an underscore after
  36 dnl compiling to assembler.
  37 dnl Written by Pavel Roskin. Based on grub_ASM_EXT_C written by
  38 dnl Erich Boleyn and modified by Yoshinori K. Okuji.
  39 AC_DEFUN(grub_ASM_USCORE,
  40 [AC_REQUIRE([AC_PROG_CC])
  41 AC_MSG_CHECKING([if C symbols get an underscore after compilation])
  42 AC_CACHE_VAL(grub_cv_asm_uscore,
  43 [cat > conftest.c <<\EOF
  44 int func (int *);
  45 int
  46 func (int *list)
  47 {
  48   *list = 0;
  49   return *list;
  50 }
  51 EOF
  52
  53 if AC_TRY_COMMAND([${CC-cc} ${CFLAGS} -S conftest.c]) && test -s conftest.s; then
  54   true
  55 else
  56   AC_MSG_ERROR([${CC-cc} failed to produce assembly code])
  57 fi
  58
  59 if grep _func conftest.s >/dev/null 2>&1; then
  60   grub_cv_asm_uscore=yes
  61 else
  62   grub_cv_asm_uscore=no
  63 fi
  64
  65 rm -f conftest*])
  66
  67 if test "x$grub_cv_asm_uscore" = xyes; then
  68   AC_DEFINE_UNQUOTED([HAVE_ASM_USCORE], $grub_cv_asm_uscore,
  69     [Define if C symbols get an underscore after compilation])
  70 fi
  71
  72 AC_MSG_RESULT([$grub_cv_asm_uscore])
  73 ])
  74
  75
  76 dnl Some versions of `objcopy -O binary' vary their output depending
  77 dnl on the link address.
  78 AC_DEFUN(grub_PROG_OBJCOPY_ABSOLUTE,
  79 [AC_MSG_CHECKING([whether ${OBJCOPY} works for absolute addresses])
  80 AC_CACHE_VAL(grub_cv_prog_objcopy_absolute,
  81 [cat > conftest.c <<\EOF
  82 void cmain (void);
  83 void
  84 cmain (void)
  85 {
  86    *((int *) 0x1000) = 2;
  87 }
  88 EOF
  89
  90 if AC_TRY_EVAL(ac_compile) && test -s conftest.o; then :
  91 else
  92   AC_MSG_ERROR([${CC-cc} cannot compile C source code])
  93 fi
  94 grub_cv_prog_objcopy_absolute=yes
  95 for link_addr in 2000 8000 7C00; do
  96   if AC_TRY_COMMAND([${CC-cc} ${CFLAGS} -nostdlib ${TARGET_IMG_LDFLAGS_AC} -Wl,-Ttext -Wl,$link_addr conftest.o -o conftest.exec]); then :
  97   else
  98     AC_MSG_ERROR([${CC-cc} cannot link at address $link_addr])
  99   fi
 100   if AC_TRY_COMMAND([${OBJCOPY-objcopy} --only-section=.text -O binary conftest.exec conftest]); then :
 101   else
 102     AC_MSG_ERROR([${OBJCOPY-objcopy} cannot create binary files])
 103   fi
 104   if test ! -f conftest.old || AC_TRY_COMMAND([cmp -s conftest.old conftest]); then
 105     mv -f conftest conftest.old
 106   else
 107     grub_cv_prog_objcopy_absolute=no
 108     break
 109   fi
 110 done
 111 rm -f conftest*])
 112 AC_MSG_RESULT([$grub_cv_prog_objcopy_absolute])
 113
 114 if test "x$grub_cv_prog_objcopy_absolute" = xno; then
 115   AC_MSG_ERROR([GRUB requires a working absolute objcopy; upgrade your binutils])
 116 fi
 117 ])
 118
 119
 120 dnl Supply --build-id=none to ld if building modules.
 121 dnl This suppresses warnings from ld on some systems
 122 AC_DEFUN(grub_PROG_LD_BUILD_ID_NONE,
 123 [AC_MSG_CHECKING([whether linker accepts --build-id=none])
 124 AC_CACHE_VAL(grub_cv_prog_ld_build_id_none,
 125 [save_LDFLAGS="$LDFLAGS"
 126 LDFLAGS="$LDFLAGS -Wl,--build-id=none"
 127 AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
 128                [grub_cv_prog_ld_build_id_none=yes],
 129                [grub_cv_prog_ld_build_id_none=no])
 130 LDFLAGS="$save_LDFLAGS"
 131 ])
 132 AC_MSG_RESULT([$grub_cv_prog_ld_build_id_none])
 133
 134 if test "x$grub_cv_prog_ld_build_id_none" = xyes; then
 135   TARGET_LDFLAGS="$TARGET_LDFLAGS -Wl,--build-id=none"
 136 fi
 137 ])
 138
 139
 140 dnl Mass confusion!
 141 dnl Older versions of GAS interpret `.code16' to mean ``generate 32-bit
 142 dnl instructions, but implicitly insert addr32 and data32 bytes so
 143 dnl that the code works in real mode''.
 144 dnl
 145 dnl Newer versions of GAS interpret `.code16' to mean ``generate 16-bit
 146 dnl instructions,'' which seems right.  This requires the programmer
 147 dnl to explicitly insert addr32 and data32 instructions when they want
 148 dnl them.
 149 dnl
 150 dnl We only support the newer versions, because the old versions cause
 151 dnl major pain, by requiring manual assembly to get 16-bit instructions into
 152 dnl asm files.
 153 AC_DEFUN(grub_I386_ASM_ADDR32,
 154 [AC_REQUIRE([AC_PROG_CC])
 155 AC_REQUIRE([grub_I386_ASM_PREFIX_REQUIREMENT])
 156 AC_MSG_CHECKING([for .code16 addr32 assembler support])
 157 AC_CACHE_VAL(grub_cv_i386_asm_addr32,
 158 [cat > conftest.s.in <<\EOF
 159         .code16
 160 l1:     @ADDR32@        movb    %al, l1
 161 EOF
 162
 163 if test "x$grub_cv_i386_asm_prefix_requirement" = xyes; then
 164   sed -e s/@ADDR32@/addr32/ < conftest.s.in > conftest.s
 165 else
 166   sed -e s/@ADDR32@/addr32\;/ < conftest.s.in > conftest.s
 167 fi
 168
 169 if AC_TRY_COMMAND([${CC-cc} ${CFLAGS} -c conftest.s]) && test -s conftest.o; then
 170   grub_cv_i386_asm_addr32=yes
 171 else
 172   grub_cv_i386_asm_addr32=no
 173 fi
 174
 175 rm -f conftest*])
 176
 177 AC_MSG_RESULT([$grub_cv_i386_asm_addr32])])
 178
 179 dnl check if our compiler is apple cc
 180 dnl because it requires numerous workarounds
 181 AC_DEFUN(grub_apple_cc,
 182 [AC_REQUIRE([AC_PROG_CC])
 183 AC_MSG_CHECKING([whether our compiler is apple cc])
 184 AC_CACHE_VAL(grub_cv_apple_cc,
 185 [if $CC -v 2>&1 | grep "Apple Inc." > /dev/null; then
 186   grub_cv_apple_cc=yes
 187 else
 188   grub_cv_apple_cc=no
 189 fi
 190 ])
 191
 192 AC_MSG_RESULT([$grub_cv_apple_cc])])
 193
 194 dnl check if our target compiler is apple cc
 195 dnl because it requires numerous workarounds
 196 AC_DEFUN(grub_apple_target_cc,
 197 [AC_REQUIRE([AC_PROG_CC])
 198 AC_MSG_CHECKING([whether our target compiler is apple cc])
 199 AC_CACHE_VAL(grub_cv_apple_target_cc,
 200 [if $CC -v 2>&1 | grep "Apple Inc." > /dev/null; then
 201   grub_cv_apple_target_cc=yes
 202 else
 203   grub_cv_apple_target_cc=no
 204 fi
 205 ])
 206
 207 AC_MSG_RESULT([$grub_cv_apple_target_cc])])
 208
 209
 210 dnl Later versions of GAS requires that addr32 and data32 prefixes
 211 dnl appear in the same lines as the instructions they modify, while
 212 dnl earlier versions requires that they appear in separate lines.
 213 AC_DEFUN(grub_I386_ASM_PREFIX_REQUIREMENT,
 214 [AC_REQUIRE([AC_PROG_CC])
 215 AC_MSG_CHECKING(dnl
 216 [whether addr32 must be in the same line as the instruction])
 217 AC_CACHE_VAL(grub_cv_i386_asm_prefix_requirement,
 218 [cat > conftest.s <<\EOF
 219         .code16
 220 l1:     addr32  movb    %al, l1
 221 EOF
 222
 223 if AC_TRY_COMMAND([${CC-cc} ${CFLAGS} -c conftest.s]) && test -s conftest.o; then
 224   grub_cv_i386_asm_prefix_requirement=yes
 225 else
 226   grub_cv_i386_asm_prefix_requirement=no
 227 fi
 228
 229 rm -f conftest*])
 230
 231 if test "x$grub_cv_i386_asm_prefix_requirement" = xyes; then
 232   grub_tmp_addr32="addr32"
 233   grub_tmp_data32="data32"
 234 else
 235   grub_tmp_addr32="addr32;"
 236   grub_tmp_data32="data32;"
 237 fi
 238
 239 AC_DEFINE_UNQUOTED([ADDR32], $grub_tmp_addr32,
 240   [Define it to \"addr32\" or \"addr32;\" to make GAS happy])
 241 AC_DEFINE_UNQUOTED([DATA32], $grub_tmp_data32,
 242   [Define it to \"data32\" or \"data32;\" to make GAS happy])
 243
 244 AC_MSG_RESULT([$grub_cv_i386_asm_prefix_requirement])])
 245
 246
 247 dnl Older versions of GAS require that absolute indirect calls/jumps are
 248 dnl not prefixed with `*', while later versions warn if not prefixed.
 249 AC_DEFUN(grub_I386_ASM_ABSOLUTE_WITHOUT_ASTERISK,
 250 [AC_REQUIRE([AC_PROG_CC])
 251 AC_MSG_CHECKING(dnl
 252 [whether an absolute indirect call/jump must not be prefixed with an asterisk])
 253 AC_CACHE_VAL(grub_cv_i386_asm_absolute_without_asterisk,
 254 [cat > conftest.s <<\EOF
 255         lcall   *(offset)
 256 offset:
 257         .long   0
 258         .word   0
 259 EOF
 260
 261 if AC_TRY_COMMAND([${CC-cc} ${CFLAGS} -c conftest.s]) && test -s conftest.o; then
 262   grub_cv_i386_asm_absolute_without_asterisk=no
 263 else
 264   grub_cv_i386_asm_absolute_without_asterisk=yes
 265 fi
 266
 267 rm -f conftest*])
 268
 269 if test "x$grub_cv_i386_asm_absolute_without_asterisk" = xyes; then
 270   AC_DEFINE([ABSOLUTE_WITHOUT_ASTERISK], 1,
 271             [Define it if GAS requires that absolute indirect calls/jumps are not prefixed with an asterisk])
 272 fi
 273
 274 AC_MSG_RESULT([$grub_cv_i386_asm_absolute_without_asterisk])])
 275
 276
 277 dnl Check what symbol is defined as a bss start symbol.
 278 dnl Written by Michael Hohmoth and Yoshinori K. Okuji.
 279 AC_DEFUN(grub_CHECK_BSS_START_SYMBOL,
 280 [AC_REQUIRE([AC_PROG_CC])
 281 AC_MSG_CHECKING([if __bss_start is defined by the compiler])
 282 AC_CACHE_VAL(grub_cv_check_uscore_uscore_bss_start_symbol,
 283 [AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],
 284                 [[asm ("incl __bss_start")]])],
 285                 [grub_cv_check_uscore_uscore_bss_start_symbol=yes],
 286                 [grub_cv_check_uscore_uscore_bss_start_symbol=no])])
 287
 288 AC_MSG_RESULT([$grub_cv_check_uscore_uscore_bss_start_symbol])
 289
 290 AC_MSG_CHECKING([if edata is defined by the compiler])
 291 AC_CACHE_VAL(grub_cv_check_edata_symbol,
 292 [AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],
 293                 [[asm ("incl edata")]])],
 294                 [grub_cv_check_edata_symbol=yes],
 295                 [grub_cv_check_edata_symbol=no])])
 296
 297 AC_MSG_RESULT([$grub_cv_check_edata_symbol])
 298
 299 AC_MSG_CHECKING([if _edata is defined by the compiler])
 300 AC_CACHE_VAL(grub_cv_check_uscore_edata_symbol,
 301 [AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],
 302                 [[asm ("incl _edata")]])],
 303                 [grub_cv_check_uscore_edata_symbol=yes],
 304                 [grub_cv_check_uscore_edata_symbol=no])])
 305
 306 AC_MSG_RESULT([$grub_cv_check_uscore_edata_symbol])
 307
 308 AH_TEMPLATE([BSS_START_SYMBOL], [Define it to one of __bss_start, edata and _edata])
 309
 310 if test "x$grub_cv_check_uscore_uscore_bss_start_symbol" = xyes; then
 311   AC_DEFINE([BSS_START_SYMBOL], [__bss_start])
 312 elif test "x$grub_cv_check_edata_symbol" = xyes; then
 313   AC_DEFINE([BSS_START_SYMBOL], [edata])
 314 elif test "x$grub_cv_check_uscore_edata_symbol" = xyes; then
 315   AC_DEFINE([BSS_START_SYMBOL], [_edata])
 316 else
 317   AC_MSG_ERROR([none of __bss_start, edata or _edata is defined])
 318 fi
 319 ])
 320
 321 dnl Check what symbol is defined as an end symbol.
 322 dnl Written by Yoshinori K. Okuji.
 323 AC_DEFUN(grub_CHECK_END_SYMBOL,
 324 [AC_REQUIRE([AC_PROG_CC])
 325 AC_MSG_CHECKING([if end is defined by the compiler])
 326 AC_CACHE_VAL(grub_cv_check_end_symbol,
 327 [AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],
 328                 [[asm ("incl end")]])],
 329                 [grub_cv_check_end_symbol=yes],
 330                 [grub_cv_check_end_symbol=no])])
 331
 332 AC_MSG_RESULT([$grub_cv_check_end_symbol])
 333
 334 AC_MSG_CHECKING([if _end is defined by the compiler])
 335 AC_CACHE_VAL(grub_cv_check_uscore_end_symbol,
 336 [AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],
 337                 [[asm ("incl _end")]])],
 338                 [grub_cv_check_uscore_end_symbol=yes],
 339                 [grub_cv_check_uscore_end_symbol=no])])
 340
 341 AC_MSG_RESULT([$grub_cv_check_uscore_end_symbol])
 342
 343 AH_TEMPLATE([END_SYMBOL], [Define it to either end or _end])
 344
 345 if test "x$grub_cv_check_end_symbol" = xyes; then
 346   AC_DEFINE([END_SYMBOL], [end])
 347 elif test "x$grub_cv_check_uscore_end_symbol" = xyes; then
 348   AC_DEFINE([END_SYMBOL], [_end])
 349 else
 350   AC_MSG_ERROR([neither end nor _end is defined])
 351 fi
 352 ])
 353
 354 dnl Check if the C compiler generates calls to `__enable_execute_stack()'.
 355 AC_DEFUN(grub_CHECK_ENABLE_EXECUTE_STACK,[
 356 AC_MSG_CHECKING([whether `$CC' generates calls to `__enable_execute_stack()'])
 357 AC_LANG_CONFTEST([[
 358 void f (int (*p) (void));
 359 void g (int i)
 360 {
 361   int nestedfunc (void) { return i; }
 362   f (nestedfunc);
 363 }
 364 ]])
 365 if AC_TRY_COMMAND([${CC-cc} ${CFLAGS} -S conftest.c]) && test -s conftest.s; then
 366   true
 367 else
 368   AC_MSG_ERROR([${CC-cc} failed to produce assembly code])
 369 fi
 370 if grep __enable_execute_stack conftest.s >/dev/null 2>&1; then
 371   AC_DEFINE([NEED_ENABLE_EXECUTE_STACK], 1,
 372             [Define to 1 if GCC generates calls to __enable_execute_stack()])
 373   AC_MSG_RESULT([yes])
 374 else
 375   AC_MSG_RESULT([no])
 376 fi
 377 rm -f conftest*
 378 ])
 379
 380 \f
 381 dnl Check if the C compiler supports `-fstack-protector'.
 382 AC_DEFUN(grub_CHECK_STACK_PROTECTOR,[
 383 [# Smashing stack protector.
 384 ssp_possible=yes]
 385 AC_MSG_CHECKING([whether `$CC' accepts `-fstack-protector'])
 386 # Is this a reliable test case?
 387 AC_LANG_CONFTEST([[void foo (void) { volatile char a[8]; a[3]; }]])
 388 [# `$CC -c -o ...' might not be portable.  But, oh, well...  Is calling
 389 # `ac_compile' like this correct, after all?
 390 if eval "$ac_compile -S -fstack-protector -o conftest.s" 2> /dev/null; then]
 391   AC_MSG_RESULT([yes])
 392   [# Should we clear up other files as well, having called `AC_LANG_CONFTEST'?
 393   rm -f conftest.s
 394 else
 395   ssp_possible=no]
 396   AC_MSG_RESULT([no])
 397 [fi]
 398 ])
 399
 400 dnl Check if the C compiler supports `-mstack-arg-probe' (Cygwin).
 401 AC_DEFUN(grub_CHECK_STACK_ARG_PROBE,[
 402 [# Smashing stack arg probe.
 403 sap_possible=yes]
 404 AC_MSG_CHECKING([whether `$CC' accepts `-mstack-arg-probe'])
 405 AC_LANG_CONFTEST([[void foo (void) { volatile char a[8]; a[3]; }]])
 406 [if eval "$ac_compile -S -mstack-arg-probe -o conftest.s" 2> /dev/null; then]
 407   AC_MSG_RESULT([yes])
 408   [# Should we clear up other files as well, having called `AC_LANG_CONFTEST'?
 409   rm -f conftest.s
 410 else
 411   sap_possible=no]
 412   AC_MSG_RESULT([no])
 413 [fi]
 414 ])
 415
 416 dnl Check if ln can handle directories properly (mingw).
 417 AC_DEFUN(grub_CHECK_LINK_DIR,[
 418 AC_MSG_CHECKING([whether ln can handle directories properly])
 419 [mkdir testdir 2>/dev/null
 420 case $srcdir in
 421 [\\/$]* | ?:[\\/]* ) reldir=$srcdir/include/grub/util ;;
 422     *) reldir=../$srcdir/include/grub/util ;;
 423 esac
 424 if ln -s $reldir testdir/util 2>/dev/null ; then]
 425   AC_MSG_RESULT([yes])
 426   [link_dir=yes
 427 else
 428   link_dir=no]
 429   AC_MSG_RESULT([no])
 430 [fi
 431 rm -rf testdir]
 432 ])
 433
 434 dnl Check if the C compiler supports `-fPIE'.
 435 AC_DEFUN(grub_CHECK_PIE,[
 436 [# Position independent executable.
 437 pie_possible=yes]
 438 AC_MSG_CHECKING([whether `$CC' has `-fPIE' as default])
 439 # Is this a reliable test case?
 440 AC_LANG_CONFTEST([[
 441 #ifdef __PIE__
 442 int main() {
 443         return 0;
 444 }
 445 #else
 446 #error NO __PIE__ DEFINED
 447 #endif
 448 ]])
 449
 450 [# `$CC -c -o ...' might not be portable.  But, oh, well...  Is calling
 451 # `ac_compile' like this correct, after all?
 452 if eval "$ac_compile -S -o conftest.s" 2> /dev/null; then]
 453   AC_MSG_RESULT([yes])
 454   [# Should we clear up other files as well, having called `AC_LANG_CONFTEST'?
 455   rm -f conftest.s
 456 else
 457   pie_possible=no]
 458   AC_MSG_RESULT([no])
 459 [fi]
 460 ])