arch/common/boot/grub2/aclocal.m4

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