gcc/acinclude.m4

   1 dnl Copyright (C) 2005-2021 Free Software Foundation, Inc.
   2 dnl
   3 dnl This file is part of GCC.
   4 dnl
   5 dnl GCC is free software; you can redistribute it and/or modify
   6 dnl it under the terms of the GNU General Public License as published by
   7 dnl the Free Software Foundation; either version 3, or (at your option)
   8 dnl any later version.
   9 dnl
  10 dnl GCC is distributed in the hope that it will be useful,
  11 dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 dnl GNU General Public License for more details.
  14 dnl
  15 dnl You should have received a copy of the GNU General Public License
  16 dnl along with GCC; see the file COPYING3.  If not see
  17 dnl <http://www.gnu.org/licenses/>.
  18
  19 dnl See whether we need a declaration for a function.
  20 dnl The result is highly dependent on the INCLUDES passed in, so make sure
  21 dnl to use a different cache variable name in this macro if it is invoked
  22 dnl in a different context somewhere else.
  23 dnl gcc_AC_CHECK_DECL(SYMBOL,
  24 dnl     [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND [, INCLUDES]]])
  25 AC_DEFUN([gcc_AC_CHECK_DECL],
  26 [AC_MSG_CHECKING([whether $1 is declared])
  27 AC_CACHE_VAL(gcc_cv_have_decl_$1,
  28 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([$4],
  29 [#ifndef $1
  30 char *(*pfn) = (char *(*)) $1 ;
  31 #endif])], eval "gcc_cv_have_decl_$1=yes", eval "gcc_cv_have_decl_$1=no")])
  32 if eval "test \"`echo '$gcc_cv_have_decl_'$1`\" = yes"; then
  33   AC_MSG_RESULT(yes) ; ifelse([$2], , :, [$2])
  34 else
  35   AC_MSG_RESULT(no) ; ifelse([$3], , :, [$3])
  36 fi
  37 ])dnl
  38
  39 dnl Check multiple functions to see whether each needs a declaration.
  40 dnl Arrange to define HAVE_DECL_<FUNCTION> to 0 or 1 as appropriate.
  41 dnl gcc_AC_CHECK_DECLS(SYMBOLS,
  42 dnl     [ACTION-IF-NEEDED [, ACTION-IF-NOT-NEEDED [, INCLUDES]]])
  43 AC_DEFUN([gcc_AC_CHECK_DECLS],
  44 [AC_FOREACH([gcc_AC_Func], [$1],
  45   [AH_TEMPLATE(AS_TR_CPP(HAVE_DECL_[]gcc_AC_Func),
  46   [Define to 1 if we found a declaration for ']gcc_AC_Func[', otherwise
  47    define to 0.])])dnl
  48 for ac_func in $1
  49 do
  50   ac_tr_decl=AS_TR_CPP([HAVE_DECL_$ac_func])
  51 gcc_AC_CHECK_DECL($ac_func,
  52   [AC_DEFINE_UNQUOTED($ac_tr_decl, 1) $2],
  53   [AC_DEFINE_UNQUOTED($ac_tr_decl, 0) $3],
  54 dnl It is possible that the include files passed in here are local headers
  55 dnl which supply a backup declaration for the relevant prototype based on
  56 dnl the definition of (or lack of) the HAVE_DECL_ macro.  If so, this test
  57 dnl will always return success.  E.g. see libiberty.h's handling of
  58 dnl `basename'.  To avoid this, we define the relevant HAVE_DECL_ macro to
  59 dnl 1 so that any local headers used do not provide their own prototype
  60 dnl during this test.
  61 #undef $ac_tr_decl
  62 #define $ac_tr_decl 1
  63   $4
  64 )
  65 done
  66 ])
  67
  68 dnl 'make compare' can be significantly faster, if cmp itself can
  69 dnl skip bytes instead of using tail.  The test being performed is
  70 dnl "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2"
  71 dnl but we need to sink errors and handle broken shells.  We also test
  72 dnl for the parameter format "cmp file1 file2 skip1 skip2" which is
  73 dnl accepted by cmp on some systems.
  74 AC_DEFUN([gcc_AC_PROG_CMP_IGNORE_INITIAL],
  75 [AC_CACHE_CHECK([for cmp's capabilities], gcc_cv_prog_cmp_skip,
  76 [ echo abfoo >t1
  77   echo cdfoo >t2
  78   gcc_cv_prog_cmp_skip=slowcompare
  79   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
  80     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
  81       :
  82     else
  83       gcc_cv_prog_cmp_skip=gnucompare
  84     fi
  85   fi
  86   if test $gcc_cv_prog_cmp_skip = slowcompare ; then
  87     if cmp t1 t2 2 2 > /dev/null 2>&1; then
  88       if cmp t1 t2 1 1 > /dev/null 2>&1; then
  89         :
  90       else
  91         gcc_cv_prog_cmp_skip=fastcompare
  92       fi
  93     fi
  94   fi
  95   rm t1 t2
  96 ])
  97 make_compare_target=$gcc_cv_prog_cmp_skip
  98 AC_SUBST(make_compare_target)
  99 ])
 100
 101 dnl See if symbolic links work and if not, try to substitute either hard links or simple copy.
 102 AC_DEFUN([gcc_AC_PROG_LN_S],
 103 [AC_MSG_CHECKING(whether ln -s works)
 104 AC_CACHE_VAL(gcc_cv_prog_LN_S,
 105 [rm -f conftestdata_t
 106 echo >conftestdata_f
 107 if ln -s conftestdata_f conftestdata_t 2>/dev/null
 108 then
 109   gcc_cv_prog_LN_S="ln -s"
 110 else
 111   if ln conftestdata_f conftestdata_t 2>/dev/null
 112   then
 113     gcc_cv_prog_LN_S=ln
 114   else
 115     if cp -p conftestdata_f conftestdata_t 2>/dev/null
 116     then
 117       gcc_cv_prog_LN_S="cp -p"
 118     else
 119       gcc_cv_prog_LN_S=cp
 120     fi
 121   fi
 122 fi
 123 rm -f conftestdata_f conftestdata_t
 124 ])dnl
 125 LN_S="$gcc_cv_prog_LN_S"
 126 if test "$gcc_cv_prog_LN_S" = "ln -s"; then
 127   AC_MSG_RESULT(yes)
 128 else
 129   if test "$gcc_cv_prog_LN_S" = "ln"; then
 130     AC_MSG_RESULT([no, using ln])
 131   else
 132     AC_MSG_RESULT([no, and neither does ln, so using $gcc_cv_prog_LN_S])
 133   fi
 134 fi
 135 AC_SUBST(LN_S)dnl
 136 ])
 137
 138 dnl Define MKDIR_TAKES_ONE_ARG if mkdir accepts only one argument instead
 139 dnl of the usual 2.
 140 AC_DEFUN([gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG],
 141 [AC_CACHE_CHECK([if mkdir takes one argument], gcc_cv_mkdir_takes_one_arg,
 142 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
 143 #include <sys/types.h>
 144 #ifdef HAVE_SYS_STAT_H
 145 # include <sys/stat.h>
 146 #endif
 147 #ifdef HAVE_UNISTD_H
 148 # include <unistd.h>
 149 #endif
 150 #ifdef HAVE_DIRECT_H
 151 # include <direct.h>
 152 #endif], [mkdir ("foo", 0);])],
 153         gcc_cv_mkdir_takes_one_arg=no, gcc_cv_mkdir_takes_one_arg=yes)])
 154 if test $gcc_cv_mkdir_takes_one_arg = yes ; then
 155   AC_DEFINE(MKDIR_TAKES_ONE_ARG, 1, [Define if host mkdir takes a single argument.])
 156 fi
 157 ])
 158
 159 AC_DEFUN([gcc_AC_PROG_INSTALL],
 160 [AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
 161 # Find a good install program.  We prefer a C program (faster),
 162 # so one script is as good as another.  But avoid the broken or
 163 # incompatible versions:
 164 # SysV /etc/install, /usr/sbin/install
 165 # SunOS /usr/etc/install
 166 # IRIX /sbin/install
 167 # AIX /bin/install
 168 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
 169 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 170 # ./install, which can be erroneously created by make from ./install.sh.
 171 AC_MSG_CHECKING(for a BSD compatible install)
 172 if test -z "$INSTALL"; then
 173 AC_CACHE_VAL(ac_cv_path_install,
 174 [  IFS="${IFS=  }"; ac_save_IFS="$IFS"; IFS="${IFS}:"
 175   for ac_dir in $PATH; do
 176     # Account for people who put trailing slashes in PATH elements.
 177     case "$ac_dir/" in
 178     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
 179     *)
 180       # OSF1 and SCO ODT 3.0 have their own names for install.
 181       for ac_prog in ginstall scoinst install; do
 182         if test -f $ac_dir/$ac_prog; then
 183           if test $ac_prog = install &&
 184             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
 185             # AIX install.  It has an incompatible calling convention.
 186             # OSF/1 installbsd also uses dspmsg, but is usable.
 187             :
 188           else
 189             ac_cv_path_install="$ac_dir/$ac_prog -c"
 190             break 2
 191           fi
 192         fi
 193       done
 194       ;;
 195     esac
 196   done
 197   IFS="$ac_save_IFS"
 198 ])dnl
 199   if test "${ac_cv_path_install+set}" = set; then
 200     INSTALL="$ac_cv_path_install"
 201   else
 202     # As a last resort, use the slow shell script.  We don't cache a
 203     # path for INSTALL within a source directory, because that will
 204     # break other packages using the cache if that directory is
 205     # removed, or if the path is relative.
 206     INSTALL="$ac_install_sh"
 207   fi
 208 fi
 209 dnl We do special magic for INSTALL instead of AC_SUBST, to get
 210 dnl relative paths right.
 211 AC_MSG_RESULT($INSTALL)
 212 AC_SUBST(INSTALL)dnl
 213
 214 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
 215 # It thinks the first close brace ends the variable substitution.
 216 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
 217 AC_SUBST(INSTALL_PROGRAM)dnl
 218
 219 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 220 AC_SUBST(INSTALL_DATA)dnl
 221 ])
 222
 223 dnl Determine if enumerated bitfields are unsigned.   ISO C says they can
 224 dnl be either signed or unsigned.
 225 dnl
 226 AC_DEFUN([gcc_AC_C_ENUM_BF_UNSIGNED],
 227 [AC_CACHE_CHECK(for unsigned enumerated bitfields, gcc_cv_enum_bf_unsigned,
 228 [AC_RUN_IFELSE([AC_LANG_SOURCE([#include <stdlib.h>
 229 enum t { BLAH = 128 } ;
 230 struct s_t { enum t member : 8; } s ;
 231 int main(void)
 232 {
 233         s.member = BLAH;
 234         if (s.member < 0) exit(1);
 235         exit(0);
 236
 237 }])], gcc_cv_enum_bf_unsigned=yes, gcc_cv_enum_bf_unsigned=no, gcc_cv_enum_bf_unsigned=yes)])
 238 if test $gcc_cv_enum_bf_unsigned = yes; then
 239   AC_DEFINE(ENUM_BITFIELDS_ARE_UNSIGNED, 1,
 240     [Define if enumerated bitfields are treated as unsigned values.])
 241 fi])
 242
 243 dnl Probe number of bits in a byte.
 244 dnl Note C89 requires CHAR_BIT >= 8.
 245 dnl
 246 AC_DEFUN([gcc_AC_C_CHAR_BIT],
 247 [AC_CACHE_CHECK(for CHAR_BIT, gcc_cv_decl_char_bit,
 248 [AC_EGREP_CPP(found,
 249 [#ifdef HAVE_LIMITS_H
 250 #include <limits.h>
 251 #endif
 252 #ifdef CHAR_BIT
 253 found
 254 #endif], gcc_cv_decl_char_bit=yes, gcc_cv_decl_char_bit=no)
 255 ])
 256 if test $gcc_cv_decl_char_bit = no; then
 257   AC_CACHE_CHECK(number of bits in a byte, gcc_cv_c_nbby,
 258 [i=8
 259  gcc_cv_c_nbby=
 260  while test $i -lt 65; do
 261    AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,
 262      [switch(0) {
 263   case (unsigned char)((unsigned long)1 << $i) == ((unsigned long)1 << $i):
 264   case (unsigned char)((unsigned long)1<<($i-1)) == ((unsigned long)1<<($i-1)):
 265   ; }])],
 266      [gcc_cv_c_nbby=$i; break])
 267    i=`expr $i + 1`
 268  done
 269  test -z "$gcc_cv_c_nbby" && gcc_cv_c_nbby=failed
 270 ])
 271 if test $gcc_cv_c_nbby = failed; then
 272   AC_MSG_ERROR(cannot determine number of bits in a byte)
 273 else
 274   AC_DEFINE_UNQUOTED(CHAR_BIT, $gcc_cv_c_nbby,
 275   [Define as the number of bits in a byte, if `limits.h' doesn't.])
 276 fi
 277 fi])
 278
 279 AC_DEFUN([gcc_AC_INITFINI_ARRAY],
 280 [AC_ARG_ENABLE(initfini-array,
 281         [  --enable-initfini-array      use .init_array/.fini_array sections],
 282         [], [
 283 AC_CACHE_CHECK(for .preinit_array/.init_array/.fini_array support,
 284                  gcc_cv_initfini_array, [dnl
 285   if test "x${build}" = "x${target}" && test "x${build}" = "x${host}"; then
 286     case "${target}" in
 287       ia64-*)
 288         AC_RUN_IFELSE([AC_LANG_SOURCE([
 289 #ifndef __ELF__
 290 #error Not an ELF OS
 291 #endif
 292 /* We turn on .preinit_array/.init_array/.fini_array support for ia64
 293    if it can be used.  */
 294 static int x = -1;
 295 int main (void) { return x; }
 296 int foo (void) { x = 0; }
 297 int (*fp) (void) __attribute__ ((section (".init_array"))) = foo;
 298 ])],
 299              [gcc_cv_initfini_array=yes], [gcc_cv_initfini_array=no],
 300              [gcc_cv_initfini_array=no]);;
 301       *)
 302         gcc_cv_initfini_array=no
 303         if test $in_tree_ld = yes ; then
 304           if test "$gcc_cv_gld_major_version" -eq 2 \
 305              -a "$gcc_cv_gld_minor_version" -ge 22 \
 306              -o "$gcc_cv_gld_major_version" -gt 2 \
 307              && test $in_tree_ld_is_elf = yes; then
 308             gcc_cv_initfini_array=yes
 309           fi
 310         elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
 311           case $target:$gas in
 312             *:yes)
 313               sh_flags='"a"'
 314               sh_type='%progbits'
 315               ;;
 316             i?86-*-solaris2*:no | x86_64-*-solaris2*:no)
 317               sh_flags='"a"'
 318               sh_type='@progbits'
 319               ;;
 320             sparc*-*-solaris2*:no)
 321               sh_flags='#alloc'
 322               sh_type='#progbits'
 323               sh_quote='"'
 324               ;;
 325           esac
 326           case "$target:$gnu_ld" in
 327             *:yes)
 328               cat > conftest.s <<EOF
 329 .section .dtors,$sh_flags,$sh_type
 330 .balign 4
 331 .byte 'A', 'A', 'A', 'A'
 332 .section .ctors,$sh_flags,$sh_type
 333 .balign 4
 334 .byte 'B', 'B', 'B', 'B'
 335 .section .fini_array.65530,$sh_flags,$sh_type
 336 .balign 4
 337 .byte 'C', 'C', 'C', 'C'
 338 .section .init_array.65530,$sh_flags,$sh_type
 339 .balign 4
 340 .byte 'D', 'D', 'D', 'D'
 341 .section .dtors.64528,$sh_flags,$sh_type
 342 .balign 4
 343 .byte 'E', 'E', 'E', 'E'
 344 .section .ctors.64528,$sh_flags,$sh_type
 345 .balign 4
 346 .byte 'F', 'F', 'F', 'F'
 347 .section .fini_array.01005,$sh_flags,$sh_type
 348 .balign 4
 349 .byte 'G', 'G', 'G', 'G'
 350 .section .init_array.01005,$sh_flags,$sh_type
 351 .balign 4
 352 .byte 'H', 'H', 'H', 'H'
 353 .text
 354 .globl _start
 355 _start:
 356 EOF
 357               if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
 358                  && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1 \
 359                  && $gcc_cv_objdump -s -j .init_array conftest \
 360                     | grep HHHHFFFFDDDDBBBB > /dev/null 2>&1 \
 361                  && $gcc_cv_objdump -s -j .fini_array conftest \
 362                     | grep GGGGEEEECCCCAAAA > /dev/null 2>&1; then
 363                 gcc_cv_initfini_array=yes
 364               fi
 365               ;;
 366             *-*-solaris2*:no)
 367               # When Solaris ld added constructor priority support, it was
 368               # decided to only handle .init_array.N/.fini_array.N since
 369               # there was no need for backwards compatibility with
 370               # .ctors.N/.dtors.N.  .ctors/.dtors remain as separate
 371               # sections with correct execution order resp. to
 372               # .init_array/.fini_array, while gld merges them into
 373               # .init_array/.fini_array.
 374               cat > conftest.s <<EOF
 375 .section $sh_quote.fini_array.65530$sh_quote,$sh_flags,$sh_type
 376 .align 4
 377 .byte 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C'
 378 .section $sh_quote.init_array.65530$sh_quote,$sh_flags,$sh_type
 379 .align 4
 380 .byte 'D', 'D', 'D', 'D', 'D', 'D', 'D', 'D'
 381 .section $sh_quote.fini_array.01005$sh_quote,$sh_flags,$sh_type
 382 .align 4
 383 .byte 'G', 'G', 'G', 'G', 'G', 'G', 'G', 'G'
 384 .section $sh_quote.init_array.01005$sh_quote,$sh_flags,$sh_type
 385 .align 4
 386 .byte 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H'
 387 .text
 388 .globl _start
 389 _start:
 390 EOF
 391               if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
 392                  && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1 \
 393                  && $gcc_cv_objdump -s -j .init_array conftest \
 394                     | grep HHHHHHHHDDDDDDDD > /dev/null 2>&1 \
 395                  && $gcc_cv_objdump -s -j .fini_array conftest \
 396                     | grep GGGGGGGGCCCCCCCC > /dev/null 2>&1; then
 397                 gcc_cv_initfini_array=yes
 398               fi
 399               ;;
 400             esac
 401 changequote(,)dnl
 402           rm -f conftest conftest.*
 403 changequote([,])dnl
 404         fi
 405         AC_PREPROC_IFELSE([AC_LANG_SOURCE([
 406 #ifndef __ELF__
 407 # error Not an ELF OS
 408 #endif
 409 #include <stdlib.h>
 410 #if defined __GLIBC_PREREQ
 411 # if __GLIBC_PREREQ (2, 4)
 412 # else
 413 #  error GLIBC 2.4 required
 414 # endif
 415 #else
 416 # if defined __sun__ && defined __svr4__
 417    /* Solaris ld.so.1 supports .init_array/.fini_array since Solaris 8.  */
 418 # else
 419 #  error The C library not known to support .init_array/.fini_array
 420 # endif
 421 #endif
 422 ])],, [gcc_cv_initfini_array=no]);;
 423     esac
 424   else
 425     case "${target}" in
 426       aarch64*-linux-gnu*)
 427         # AArch64 postdates glibc support for .init_array/.fini_array,
 428         # so we don't need the preprocessor test above.
 429         gcc_cv_initfini_array=yes
 430         ;;
 431
 432       *)
 433         AC_MSG_CHECKING(cross compile... guessing)
 434         gcc_cv_initfini_array=no
 435         ;;
 436     esac
 437   fi])
 438   enable_initfini_array=$gcc_cv_initfini_array
 439 ])
 440 AC_DEFINE_UNQUOTED(HAVE_INITFINI_ARRAY_SUPPORT,
 441   [`if test $enable_initfini_array = yes; then echo 1; else echo 0; fi`],
 442   [Define 0/1 if .init_array/.fini_array sections are available and working.])
 443 ])
 444
 445 dnl # _gcc_COMPUTE_GAS_VERSION
 446 dnl # Used by gcc_GAS_VERSION_GTE_IFELSE
 447 dnl #
 448 dnl # WARNING:
 449 dnl # gcc_cv_as_gas_srcdir must be defined before this.
 450 dnl # This gross requirement will go away eventually.
 451 AC_DEFUN([_gcc_COMPUTE_GAS_VERSION],
 452 [gcc_cv_as_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
 453 for f in $gcc_cv_as_bfd_srcdir/configure \
 454          $gcc_cv_as_gas_srcdir/configure \
 455          $gcc_cv_as_gas_srcdir/configure.ac \
 456          $gcc_cv_as_gas_srcdir/Makefile.in ; do
 457   gcc_cv_gas_version=`sed -n -e 's/^[[  ]]*VERSION=[[^0-9A-Za-z_]]*\([[0-9]]*\.[[0-9]]*.*\)/VERSION=\1/p' < $f`
 458   if test x$gcc_cv_gas_version != x; then
 459     break
 460   fi
 461 done
 462 case $gcc_cv_gas_version in
 463   VERSION=[[0-9]]*) ;;
 464   *) AC_MSG_ERROR([[cannot find version of in-tree assembler]]);;
 465 esac
 466 gcc_cv_gas_major_version=`expr "$gcc_cv_gas_version" : "VERSION=\([[0-9]]*\)"`
 467 gcc_cv_gas_minor_version=`expr "$gcc_cv_gas_version" : "VERSION=[[0-9]]*\.\([[0-9]]*\)"`
 468 gcc_cv_gas_patch_version=`expr "$gcc_cv_gas_version" : "VERSION=[[0-9]]*\.[[0-9]]*\.\([[0-9]]*\)"`
 469 case $gcc_cv_gas_patch_version in
 470   "") gcc_cv_gas_patch_version="0" ;;
 471 esac
 472 gcc_cv_gas_vers=`expr \( \( $gcc_cv_gas_major_version \* 1000 \) \
 473                             + $gcc_cv_gas_minor_version \) \* 1000 \
 474                             + $gcc_cv_gas_patch_version`
 475 ]) []dnl # _gcc_COMPUTE_GAS_VERSION
 476
 477 dnl # gcc_GAS_VERSION_GTE_IFELSE([elf,] major, minor, patchlevel,
 478 dnl #                     [command_if_true = :], [command_if_false = :])
 479 dnl # Check to see if the version of GAS is greater than or
 480 dnl # equal to the specified version.
 481 dnl #
 482 dnl # The first ifelse() shortens the shell code if the patchlevel
 483 dnl # is unimportant (the usual case).  The others handle missing
 484 dnl # commands.  Note that the tests are structured so that the most
 485 dnl # common version number cases are tested first.
 486 AC_DEFUN([_gcc_GAS_VERSION_GTE_IFELSE],
 487 [ifelse([$1], elf,
 488  [if test $in_tree_gas_is_elf = yes \
 489   &&],
 490  [if]) test $gcc_cv_gas_vers -ge `expr \( \( $2 \* 1000 \) + $3 \) \* 1000 + $4`
 491   then dnl
 492 ifelse([$5],,:,[$5])[]dnl
 493 ifelse([$6],,,[
 494   else $6])
 495 fi])
 496
 497 AC_DEFUN([gcc_GAS_VERSION_GTE_IFELSE],
 498 [AC_REQUIRE([_gcc_COMPUTE_GAS_VERSION])dnl
 499 ifelse([$1], elf, [_gcc_GAS_VERSION_GTE_IFELSE($@)],
 500                   [_gcc_GAS_VERSION_GTE_IFELSE(,$@)])])
 501
 502 dnl # gcc_GAS_FLAGS
 503 dnl # Used by gcc_GAS_CHECK_FEATURE
 504 dnl #
 505 AC_DEFUN([gcc_GAS_FLAGS],
 506 [AC_CACHE_CHECK([assembler flags], gcc_cv_as_flags,
 507 [ case "$target" in
 508   i[[34567]]86-*-linux*)
 509     dnl Override the default, which may be incompatible.
 510     gcc_cv_as_flags=--32
 511     ;;
 512   x86_64-*-linux-gnux32)
 513     dnl Override the default, which may be incompatible.
 514     gcc_cv_as_flags=--x32
 515     ;;
 516   x86_64-*-linux*)
 517     dnl Override the default, which may be incompatible.
 518     gcc_cv_as_flags=--64
 519     ;;
 520   powerpc*-*-darwin*)
 521     dnl Always pass -arch ppc to assembler.
 522     gcc_cv_as_flags="-arch ppc"
 523     ;;
 524   *)
 525     gcc_cv_as_flags=" "
 526     ;;
 527   esac])
 528 ])
 529
 530 dnl gcc_GAS_CHECK_FEATURE(description, cv, [[elf,]major,minor,patchlevel],
 531 dnl [extra switches to as], [assembler input],
 532 dnl [extra testing logic], [command if feature available])
 533 dnl
 534 dnl Checks for an assembler feature.  If we are building an in-tree
 535 dnl gas, the feature is available if the associated assembler version
 536 dnl is greater than or equal to major.minor.patchlevel.  If not, then
 537 dnl ASSEMBLER INPUT is fed to the assembler and the feature is available
 538 dnl if assembly succeeds.  If EXTRA TESTING LOGIC is not the empty string,
 539 dnl then it is run instead of simply setting CV to "yes" - it is responsible
 540 dnl for doing so, if appropriate.
 541 AC_DEFUN([gcc_GAS_CHECK_FEATURE],
 542 [AC_REQUIRE([gcc_GAS_FLAGS])dnl
 543 AC_CACHE_CHECK([assembler for $1], [$2],
 544  [[$2]=no
 545   ifelse([$3],,,[dnl
 546   if test $in_tree_gas = yes; then
 547     gcc_GAS_VERSION_GTE_IFELSE($3, [[$2]=yes])
 548   el])if test x$gcc_cv_as != x; then
 549     AS_ECHO([ifelse(m4_substr([$5],0,1),[$], "[$5]", '[$5]')]) > conftest.s
 550     if AC_TRY_COMMAND([$gcc_cv_as $gcc_cv_as_flags $4 -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD])
 551     then
 552         ifelse([$6],, [$2]=yes, [$6])
 553     else
 554       echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
 555       cat conftest.s >&AS_MESSAGE_LOG_FD
 556     fi
 557     rm -f conftest.o conftest.s
 558   fi])
 559 ifelse([$7],,,[dnl
 560 if test $[$2] = yes; then
 561   $7
 562 fi])
 563 ifelse([$8],,,[dnl
 564 if test $[$2] != yes; then
 565   $8
 566 fi])])
 567
 568 dnl GCC_TARGET_TEMPLATE(KEY)
 569 dnl ------------------------
 570 dnl Define KEY as a valid configure key on the target machine.
 571
 572 m4_define([GCC_TARGET_TEMPLATE],
 573 [m4_define([GCC_TARGET_TEMPLATE($1)],[])])
 574
 575 dnl AH_TEMPLATE(KEY, DESCRIPTION)
 576 dnl -----------------------------
 577 dnl Issue an autoheader template for KEY, i.e., a comment composed of
 578 dnl DESCRIPTION (properly wrapped), and then #undef KEY.  Redefinition
 579 dnl of the macro in autoheader.m4, to support definition of only a few
 580 dnl keys while compiling target libraries.
 581
 582 m4_define([AH_TEMPLATE],
 583 [AH_VERBATIM([$1],m4_text_wrap([$2 */], [   ], [/* ])
 584 m4_ifdef([GCC_TARGET_TEMPLATE($1)],[],[#ifndef USED_FOR_TARGET
 585 ])[#undef $1]m4_ifdef([GCC_TARGET_TEMPLATE($1)],[],[
 586 #endif
 587 ]))])
 588
 589 dnl Make sure that build_exeext is looked for
 590 AC_DEFUN([gcc_AC_BUILD_EXEEXT], [
 591 ac_executable_extensions="$build_exeext"])
 592
 593 dnl GCC_GLIBC_VERSION_GTE_IFELSE(MAJOR, MINOR, IF-TRUE, IF-FALSE)
 594 dnl -------------------------------------------------------------
 595 dnl If the target glibc version ($glibc_version_major.$glibc_version_minor)
 596 dnl is at least MAJOR.MINOR, call IF-TRUE, otherwise call IF-FALSE.
 597 AC_DEFUN([GCC_GLIBC_VERSION_GTE_IFELSE],
 598 [
 599 AS_IF([test $glibc_version_major -gt $1 \
 600   || ( test $glibc_version_major -eq $1 && test $glibc_version_minor -ge $2 )],
 601 [$3], [$4])])