gcc/aclocal.m4

   1 m4_include(../config/accross.m4)
   2 m4_include(../config/acx.m4)
   3 m4_include(../config/gettext-sister.m4)
   4 m4_include(../config/iconv.m4)
   5 m4_include(../config/lcmessage.m4)
   6 m4_include(../config/lib-ld.m4)
   7 m4_include(../config/lib-link.m4)
   8 m4_include(../config/lib-prefix.m4)
   9 m4_include(../config/progtest.m4)
  10
  11 dnl See whether we need a declaration for a function.
  12 dnl The result is highly dependent on the INCLUDES passed in, so make sure
  13 dnl to use a different cache variable name in this macro if it is invoked
  14 dnl in a different context somewhere else.
  15 dnl gcc_AC_CHECK_DECL(SYMBOL,
  16 dnl     [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND [, INCLUDES]]])
  17 AC_DEFUN([gcc_AC_CHECK_DECL],
  18 [AC_MSG_CHECKING([whether $1 is declared])
  19 AC_CACHE_VAL(gcc_cv_have_decl_$1,
  20 [AC_TRY_COMPILE([$4],
  21 [#ifndef $1
  22 char *(*pfn) = (char *(*)) $1 ;
  23 #endif], eval "gcc_cv_have_decl_$1=yes", eval "gcc_cv_have_decl_$1=no")])
  24 if eval "test \"`echo '$gcc_cv_have_decl_'$1`\" = yes"; then
  25   AC_MSG_RESULT(yes) ; ifelse([$2], , :, [$2])
  26 else
  27   AC_MSG_RESULT(no) ; ifelse([$3], , :, [$3])
  28 fi
  29 ])dnl
  30
  31 dnl Check multiple functions to see whether each needs a declaration.
  32 dnl Arrange to define HAVE_DECL_<FUNCTION> to 0 or 1 as appropriate.
  33 dnl gcc_AC_CHECK_DECLS(SYMBOLS,
  34 dnl     [ACTION-IF-NEEDED [, ACTION-IF-NOT-NEEDED [, INCLUDES]]])
  35 AC_DEFUN([gcc_AC_CHECK_DECLS],
  36 [AC_FOREACH([gcc_AC_Func], [$1],
  37   [AH_TEMPLATE(AS_TR_CPP(HAVE_DECL_[]gcc_AC_Func),
  38   [Define to 1 if we found a declaration for ']gcc_AC_Func[', otherwise
  39    define to 0.])])dnl
  40 for ac_func in $1
  41 do
  42   ac_tr_decl=AS_TR_CPP([HAVE_DECL_$ac_func])
  43 gcc_AC_CHECK_DECL($ac_func,
  44   [AC_DEFINE_UNQUOTED($ac_tr_decl, 1) $2],
  45   [AC_DEFINE_UNQUOTED($ac_tr_decl, 0) $3],
  46 dnl It is possible that the include files passed in here are local headers
  47 dnl which supply a backup declaration for the relevant prototype based on
  48 dnl the definition of (or lack of) the HAVE_DECL_ macro.  If so, this test
  49 dnl will always return success.  E.g. see libiberty.h's handling of
  50 dnl `basename'.  To avoid this, we define the relevant HAVE_DECL_ macro to
  51 dnl 1 so that any local headers used do not provide their own prototype
  52 dnl during this test.
  53 #undef $ac_tr_decl
  54 #define $ac_tr_decl 1
  55   $4
  56 )
  57 done
  58 ])
  59
  60 dnl 'make compare' can be significantly faster, if cmp itself can
  61 dnl skip bytes instead of using tail.  The test being performed is
  62 dnl "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2"
  63 dnl but we need to sink errors and handle broken shells.  We also test
  64 dnl for the parameter format "cmp file1 file2 skip1 skip2" which is
  65 dnl accepted by cmp on some systems.
  66 AC_DEFUN([gcc_AC_PROG_CMP_IGNORE_INITIAL],
  67 [AC_CACHE_CHECK([for cmp's capabilities], gcc_cv_prog_cmp_skip,
  68 [ echo abfoo >t1
  69   echo cdfoo >t2
  70   gcc_cv_prog_cmp_skip=slowcompare
  71   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
  72     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
  73       :
  74     else
  75       gcc_cv_prog_cmp_skip=gnucompare
  76     fi
  77   fi
  78   if test $gcc_cv_prog_cmp_skip = slowcompare ; then
  79     if cmp t1 t2 2 2 > /dev/null 2>&1; then
  80       if cmp t1 t2 1 1 > /dev/null 2>&1; then
  81         :
  82       else
  83         gcc_cv_prog_cmp_skip=fastcompare
  84       fi
  85     fi
  86   fi
  87   rm t1 t2
  88 ])
  89 make_compare_target=$gcc_cv_prog_cmp_skip
  90 AC_SUBST(make_compare_target)
  91 ])
  92
  93 dnl See if the printf functions in libc support %p in format strings.
  94 AC_DEFUN([gcc_AC_FUNC_PRINTF_PTR],
  95 [AC_CACHE_CHECK(whether the printf functions support %p,
  96   gcc_cv_func_printf_ptr,
  97 [AC_TRY_RUN([#include <stdio.h>
  98
  99 int main()
 100 {
 101   char buf[64];
 102   char *p = buf, *q = NULL;
 103   sprintf(buf, "%p", p);
 104   sscanf(buf, "%p", &q);
 105   return (p != q);
 106 }], gcc_cv_func_printf_ptr=yes, gcc_cv_func_printf_ptr=no,
 107         gcc_cv_func_printf_ptr=no)
 108 rm -f core core.* *.core])
 109 if test $gcc_cv_func_printf_ptr = yes ; then
 110   AC_DEFINE(HAVE_PRINTF_PTR, 1, [Define if printf supports "%p".])
 111 fi
 112 ])
 113
 114 dnl See if symbolic links work and if not, try to substitute either hard links or simple copy.
 115 AC_DEFUN([gcc_AC_PROG_LN_S],
 116 [AC_MSG_CHECKING(whether ln -s works)
 117 AC_CACHE_VAL(gcc_cv_prog_LN_S,
 118 [rm -f conftestdata_t
 119 echo >conftestdata_f
 120 if ln -s conftestdata_f conftestdata_t 2>/dev/null
 121 then
 122   gcc_cv_prog_LN_S="ln -s"
 123 else
 124   if ln conftestdata_f conftestdata_t 2>/dev/null
 125   then
 126     gcc_cv_prog_LN_S=ln
 127   else
 128     gcc_cv_prog_LN_S=cp
 129   fi
 130 fi
 131 rm -f conftestdata_f conftestdata_t
 132 ])dnl
 133 LN_S="$gcc_cv_prog_LN_S"
 134 if test "$gcc_cv_prog_LN_S" = "ln -s"; then
 135   AC_MSG_RESULT(yes)
 136 else
 137   if test "$gcc_cv_prog_LN_S" = "ln"; then
 138     AC_MSG_RESULT([no, using ln])
 139   else
 140     AC_MSG_RESULT([no, and neither does ln, so using cp])
 141   fi
 142 fi
 143 AC_SUBST(LN_S)dnl
 144 ])
 145
 146 dnl Define MKDIR_TAKES_ONE_ARG if mkdir accepts only one argument instead
 147 dnl of the usual 2.
 148 AC_DEFUN([gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG],
 149 [AC_CACHE_CHECK([if mkdir takes one argument], gcc_cv_mkdir_takes_one_arg,
 150 [AC_TRY_COMPILE([
 151 #include <sys/types.h>
 152 #ifdef HAVE_SYS_STAT_H
 153 # include <sys/stat.h>
 154 #endif
 155 #ifdef HAVE_UNISTD_H
 156 # include <unistd.h>
 157 #endif
 158 #ifdef HAVE_DIRECT_H
 159 # include <direct.h>
 160 #endif], [mkdir ("foo", 0);],
 161         gcc_cv_mkdir_takes_one_arg=no, gcc_cv_mkdir_takes_one_arg=yes)])
 162 if test $gcc_cv_mkdir_takes_one_arg = yes ; then
 163   AC_DEFINE(MKDIR_TAKES_ONE_ARG, 1, [Define if host mkdir takes a single argument.])
 164 fi
 165 ])
 166
 167 AC_DEFUN([gcc_AC_PROG_INSTALL],
 168 [AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
 169 # Find a good install program.  We prefer a C program (faster),
 170 # so one script is as good as another.  But avoid the broken or
 171 # incompatible versions:
 172 # SysV /etc/install, /usr/sbin/install
 173 # SunOS /usr/etc/install
 174 # IRIX /sbin/install
 175 # AIX /bin/install
 176 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
 177 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 178 # ./install, which can be erroneously created by make from ./install.sh.
 179 AC_MSG_CHECKING(for a BSD compatible install)
 180 if test -z "$INSTALL"; then
 181 AC_CACHE_VAL(ac_cv_path_install,
 182 [  IFS="${IFS=  }"; ac_save_IFS="$IFS"; IFS="${IFS}:"
 183   for ac_dir in $PATH; do
 184     # Account for people who put trailing slashes in PATH elements.
 185     case "$ac_dir/" in
 186     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
 187     *)
 188       # OSF1 and SCO ODT 3.0 have their own names for install.
 189       for ac_prog in ginstall scoinst install; do
 190         if test -f $ac_dir/$ac_prog; then
 191           if test $ac_prog = install &&
 192             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
 193             # AIX install.  It has an incompatible calling convention.
 194             # OSF/1 installbsd also uses dspmsg, but is usable.
 195             :
 196           else
 197             ac_cv_path_install="$ac_dir/$ac_prog -c"
 198             break 2
 199           fi
 200         fi
 201       done
 202       ;;
 203     esac
 204   done
 205   IFS="$ac_save_IFS"
 206 ])dnl
 207   if test "${ac_cv_path_install+set}" = set; then
 208     INSTALL="$ac_cv_path_install"
 209   else
 210     # As a last resort, use the slow shell script.  We don't cache a
 211     # path for INSTALL within a source directory, because that will
 212     # break other packages using the cache if that directory is
 213     # removed, or if the path is relative.
 214     INSTALL="$ac_install_sh"
 215   fi
 216 fi
 217 dnl We do special magic for INSTALL instead of AC_SUBST, to get
 218 dnl relative paths right.
 219 AC_MSG_RESULT($INSTALL)
 220 AC_SUBST(INSTALL)dnl
 221
 222 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
 223 # It thinks the first close brace ends the variable substitution.
 224 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
 225 AC_SUBST(INSTALL_PROGRAM)dnl
 226
 227 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 228 AC_SUBST(INSTALL_DATA)dnl
 229 ])
 230
 231 # mmap(2) blacklisting.  Some platforms provide the mmap library routine
 232 # but don't support all of the features we need from it.
 233 AC_DEFUN([gcc_AC_FUNC_MMAP_BLACKLIST],
 234 [
 235 AC_CHECK_HEADER([sys/mman.h],
 236                 [gcc_header_sys_mman_h=yes], [gcc_header_sys_mman_h=no])
 237 AC_CHECK_FUNC([mmap], [gcc_func_mmap=yes], [gcc_func_mmap=no])
 238 if test "$gcc_header_sys_mman_h" != yes \
 239  || test "$gcc_func_mmap" != yes; then
 240    gcc_cv_func_mmap_file=no
 241    gcc_cv_func_mmap_dev_zero=no
 242    gcc_cv_func_mmap_anon=no
 243 else
 244    AC_CACHE_CHECK([whether read-only mmap of a plain file works],
 245   gcc_cv_func_mmap_file,
 246   [# Add a system to this blacklist if
 247    # mmap(0, stat_size, PROT_READ, MAP_PRIVATE, fd, 0) doesn't return a
 248    # memory area containing the same data that you'd get if you applied
 249    # read() to the same fd.  The only system known to have a problem here
 250    # is VMS, where text files have record structure.
 251    case "$host_os" in
 252      vms* | ultrix*)
 253         gcc_cv_func_mmap_file=no ;;
 254      *)
 255         gcc_cv_func_mmap_file=yes;;
 256    esac])
 257    AC_CACHE_CHECK([whether mmap from /dev/zero works],
 258   gcc_cv_func_mmap_dev_zero,
 259   [# Add a system to this blacklist if it has mmap() but /dev/zero
 260    # does not exist, or if mmapping /dev/zero does not give anonymous
 261    # zeroed pages with both the following properties:
 262    # 1. If you map N consecutive pages in with one call, and then
 263    #    unmap any subset of those pages, the pages that were not
 264    #    explicitly unmapped remain accessible.
 265    # 2. If you map two adjacent blocks of memory and then unmap them
 266    #    both at once, they must both go away.
 267    # Systems known to be in this category are Windows (all variants),
 268    # VMS, and Darwin.
 269    case "$host_os" in
 270      vms* | cygwin* | pe | mingw* | darwin* | ultrix* | hpux10* | hpux11.00)
 271         gcc_cv_func_mmap_dev_zero=no ;;
 272      *)
 273         gcc_cv_func_mmap_dev_zero=yes;;
 274    esac])
 275
 276    # Unlike /dev/zero, the MAP_ANON(YMOUS) defines can be probed for.
 277    AC_CACHE_CHECK([for MAP_ANON(YMOUS)], gcc_cv_decl_map_anon,
 278     [AC_TRY_COMPILE(
 279 [#include <sys/types.h>
 280 #include <sys/mman.h>
 281 #include <unistd.h>
 282
 283 #ifndef MAP_ANONYMOUS
 284 #define MAP_ANONYMOUS MAP_ANON
 285 #endif
 286 ],
 287 [int n = MAP_ANONYMOUS;],
 288     gcc_cv_decl_map_anon=yes,
 289     gcc_cv_decl_map_anon=no)])
 290
 291    if test $gcc_cv_decl_map_anon = no; then
 292      gcc_cv_func_mmap_anon=no
 293    else
 294      AC_CACHE_CHECK([whether mmap with MAP_ANON(YMOUS) works],
 295      gcc_cv_func_mmap_anon,
 296   [# Add a system to this blacklist if it has mmap() and MAP_ANON or
 297    # MAP_ANONYMOUS, but using mmap(..., MAP_PRIVATE|MAP_ANONYMOUS, -1, 0)
 298    # doesn't give anonymous zeroed pages with the same properties listed
 299    # above for use of /dev/zero.
 300    # Systems known to be in this category are Windows, VMS, and SCO Unix.
 301    case "$host_os" in
 302      vms* | cygwin* | pe | mingw* | sco* | udk* )
 303         gcc_cv_func_mmap_anon=no ;;
 304      *)
 305         gcc_cv_func_mmap_anon=yes;;
 306    esac])
 307    fi
 308 fi
 309
 310 if test $gcc_cv_func_mmap_file = yes; then
 311   AC_DEFINE(HAVE_MMAP_FILE, 1,
 312             [Define if read-only mmap of a plain file works.])
 313 fi
 314 if test $gcc_cv_func_mmap_dev_zero = yes; then
 315   AC_DEFINE(HAVE_MMAP_DEV_ZERO, 1,
 316             [Define if mmap of /dev/zero works.])
 317 fi
 318 if test $gcc_cv_func_mmap_anon = yes; then
 319   AC_DEFINE(HAVE_MMAP_ANON, 1,
 320             [Define if mmap with MAP_ANON(YMOUS) works.])
 321 fi
 322 ])
 323
 324 dnl Locate a program and check that its version is acceptable.
 325 dnl AC_PROG_CHECK_VER(var, name, version-switch,
 326 dnl                  version-extract-regexp, version-glob)
 327 AC_DEFUN([gcc_AC_CHECK_PROG_VER],
 328 [AC_CHECK_PROG([$1], [$2], [$2])
 329 if test -n "[$]$1"; then
 330   # Found it, now check the version.
 331   AC_CACHE_CHECK(for modern $2, gcc_cv_prog_$2_modern,
 332 [changequote(<<,>>)dnl
 333   ac_prog_version=`<<$>>$1 $3 2>&1 |
 334                    sed -n 's/^.*patsubst(<<$4>>,/,\/).*$/\1/p'`
 335 changequote([,])dnl
 336   echo "configure:__oline__: version of $2 is $ac_prog_version" >&AC_FD_CC
 337 changequote(<<,>>)dnl
 338   case $ac_prog_version in
 339     '')     gcc_cv_prog_$2_modern=no;;
 340     <<$5>>)
 341             gcc_cv_prog_$2_modern=yes;;
 342     *)      gcc_cv_prog_$2_modern=no;;
 343   esac
 344 changequote([,])dnl
 345 ])
 346 else
 347   gcc_cv_prog_$2_modern=no
 348 fi
 349 ])
 350
 351 dnl Determine if enumerated bitfields are unsigned.   ISO C says they can
 352 dnl be either signed or unsigned.
 353 dnl
 354 AC_DEFUN([gcc_AC_C_ENUM_BF_UNSIGNED],
 355 [AC_CACHE_CHECK(for unsigned enumerated bitfields, gcc_cv_enum_bf_unsigned,
 356 [AC_TRY_RUN(#include <stdlib.h>
 357 enum t { BLAH = 128 } ;
 358 struct s_t { enum t member : 8; } s ;
 359 int main(void)
 360 {
 361         s.member = BLAH;
 362         if (s.member < 0) exit(1);
 363         exit(0);
 364
 365 }, gcc_cv_enum_bf_unsigned=yes, gcc_cv_enum_bf_unsigned=no, gcc_cv_enum_bf_unsigned=yes)])
 366 if test $gcc_cv_enum_bf_unsigned = yes; then
 367   AC_DEFINE(ENUM_BITFIELDS_ARE_UNSIGNED, 1,
 368     [Define if enumerated bitfields are treated as unsigned values.])
 369 fi])
 370
 371 dnl Probe number of bits in a byte.
 372 dnl Note C89 requires CHAR_BIT >= 8.
 373 dnl
 374 AC_DEFUN([gcc_AC_C_CHAR_BIT],
 375 [AC_CACHE_CHECK(for CHAR_BIT, gcc_cv_decl_char_bit,
 376 [AC_EGREP_CPP(found,
 377 [#ifdef HAVE_LIMITS_H
 378 #include <limits.h>
 379 #endif
 380 #ifdef CHAR_BIT
 381 found
 382 #endif], gcc_cv_decl_char_bit=yes, gcc_cv_decl_char_bit=no)
 383 ])
 384 if test $gcc_cv_decl_char_bit = no; then
 385   AC_CACHE_CHECK(number of bits in a byte, gcc_cv_c_nbby,
 386 [i=8
 387  gcc_cv_c_nbby=
 388  while test $i -lt 65; do
 389    AC_TRY_COMPILE(,
 390      [switch(0) {
 391   case (unsigned char)((unsigned long)1 << $i) == ((unsigned long)1 << $i):
 392   case (unsigned char)((unsigned long)1<<($i-1)) == ((unsigned long)1<<($i-1)):
 393   ; }],
 394      [gcc_cv_c_nbby=$i; break])
 395    i=`expr $i + 1`
 396  done
 397  test -z "$gcc_cv_c_nbby" && gcc_cv_c_nbby=failed
 398 ])
 399 if test $gcc_cv_c_nbby = failed; then
 400   AC_MSG_ERROR(cannot determine number of bits in a byte)
 401 else
 402   AC_DEFINE_UNQUOTED(CHAR_BIT, $gcc_cv_c_nbby,
 403   [Define as the number of bits in a byte, if \`limits.h' doesn't.])
 404 fi
 405 fi])
 406
 407 dnl Checking for long long.
 408 dnl By Caolan McNamara <caolan@skynet.ie>
 409 dnl Added check for __int64, Zack Weinberg <zackw@stanford.edu>
 410 dnl
 411 AC_DEFUN([gcc_AC_C_LONG_LONG],
 412 [AC_CACHE_CHECK(for long long int, ac_cv_c_long_long,
 413   [AC_TRY_COMPILE(,[long long int i;],
 414          ac_cv_c_long_long=yes,
 415          ac_cv_c_long_long=no)])
 416   if test $ac_cv_c_long_long = yes; then
 417     AC_DEFINE(HAVE_LONG_LONG, 1,
 418       [Define if your compiler supports the \`long long' type.])
 419   fi
 420 AC_CACHE_CHECK(for __int64, ac_cv_c___int64,
 421   [AC_TRY_COMPILE(,[__int64 i;],
 422         ac_cv_c___int64=yes,
 423         ac_cv_c___int64=no)])
 424   if test $ac_cv_c___int64 = yes; then
 425     AC_DEFINE(HAVE___INT64, 1,
 426       [Define if your compiler supports the \`__int64' type.])
 427   fi
 428 ])
 429
 430 AC_DEFUN([gcc_AC_INITFINI_ARRAY],
 431 [AC_ARG_ENABLE(initfini-array,
 432         [  --enable-initfini-array      use .init_array/.fini_array sections],
 433         [], [
 434 AC_CACHE_CHECK(for .preinit_array/.init_array/.fini_array support,
 435                  gcc_cv_initfini_array, [dnl
 436   AC_TRY_RUN([
 437 static int x = -1;
 438 int main (void) { return x; }
 439 int foo (void) { x = 0; }
 440 int (*fp) (void) __attribute__ ((section (".init_array"))) = foo;],
 441              [gcc_cv_initfini_array=yes], [gcc_cv_initfini_array=no],
 442              [gcc_cv_initfini_array=no])])
 443   enable_initfini_array=$gcc_cv_initfini_array
 444 ])
 445 if test $enable_initfini_array = yes; then
 446   AC_DEFINE(HAVE_INITFINI_ARRAY, 1,
 447     [Define .init_array/.fini_array sections are available and working.])
 448 fi])
 449
 450 dnl # _gcc_COMPUTE_GAS_VERSION
 451 dnl # Used by gcc_GAS_VERSION_GTE_IFELSE
 452 dnl #
 453 dnl # WARNING:
 454 dnl # gcc_cv_as_gas_srcdir must be defined before this.
 455 dnl # This gross requirement will go away eventually.
 456 AC_DEFUN([_gcc_COMPUTE_GAS_VERSION],
 457 [gcc_cv_as_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
 458 for f in $gcc_cv_as_bfd_srcdir/configure \
 459          $gcc_cv_as_gas_srcdir/configure \
 460          $gcc_cv_as_gas_srcdir/configure.in \
 461          $gcc_cv_as_gas_srcdir/Makefile.in ; do
 462   gcc_cv_gas_version=`sed -n -e 's/^[[  ]]*\(VERSION=[[0-9]]*\.[[0-9]]*.*\)/\1/p' < $f`
 463   if test x$gcc_cv_gas_version != x; then
 464     break
 465   fi
 466 done
 467 gcc_cv_gas_major_version=`expr "$gcc_cv_gas_version" : "VERSION=\([[0-9]]*\)"`
 468 gcc_cv_gas_minor_version=`expr "$gcc_cv_gas_version" : "VERSION=[[0-9]]*\.\([[0-9]]*\)"`
 469 gcc_cv_gas_patch_version=`expr "$gcc_cv_gas_version" : "VERSION=[[0-9]]*\.[[0-9]]*\.\([[0-9]]*\)"`
 470 case $gcc_cv_gas_patch_version in
 471   "") gcc_cv_gas_patch_version="0" ;;
 472 esac
 473 gcc_cv_gas_vers=`expr \( \( $gcc_cv_gas_major_version \* 1000 \) \
 474                             + $gcc_cv_gas_minor_version \) \* 1000 \
 475                             + $gcc_cv_gas_patch_version`
 476 ]) []dnl # _gcc_COMPUTE_GAS_VERSION
 477
 478 dnl # gcc_GAS_VERSION_GTE_IFELSE([elf,] major, minor, patchlevel,
 479 dnl #                     [command_if_true = :], [command_if_false = :])
 480 dnl # Check to see if the version of GAS is greater than or
 481 dnl # equal to the specified version.
 482 dnl #
 483 dnl # The first ifelse() shortens the shell code if the patchlevel
 484 dnl # is unimportant (the usual case).  The others handle missing
 485 dnl # commands.  Note that the tests are structured so that the most
 486 dnl # common version number cases are tested first.
 487 AC_DEFUN([_gcc_GAS_VERSION_GTE_IFELSE],
 488 [ifelse([$1], elf,
 489  [if test $in_tree_gas_is_elf = yes \
 490   &&],
 491  [if]) test $gcc_cv_gas_vers -ge `expr \( \( $2 \* 1000 \) + $3 \) \* 1000 + $4`
 492   then dnl
 493 ifelse([$5],,:,[$5])[]dnl
 494 ifelse([$6],,,[
 495   else $6])
 496 fi])
 497
 498 AC_DEFUN([gcc_GAS_VERSION_GTE_IFELSE],
 499 [AC_REQUIRE([_gcc_COMPUTE_GAS_VERSION])dnl
 500 ifelse([$1], elf, [_gcc_GAS_VERSION_GTE_IFELSE($@)],
 501                   [_gcc_GAS_VERSION_GTE_IFELSE(,$@)])])
 502
 503 dnl gcc_GAS_CHECK_FEATURE(description, cv, [[elf,]major,minor,patchlevel],
 504 dnl [extra switches to as], [assembler input],
 505 dnl [extra testing logic], [command if feature available])
 506 dnl
 507 dnl Checks for an assembler feature.  If we are building an in-tree
 508 dnl gas, the feature is available if the associated assembler version
 509 dnl is greater than or equal to major.minor.patchlevel.  If not, then
 510 dnl ASSEMBLER INPUT is fed to the assembler and the feature is available
 511 dnl if assembly succeeds.  If EXTRA TESTING LOGIC is not the empty string,
 512 dnl then it is run instead of simply setting CV to "yes" - it is responsible
 513 dnl for doing so, if appropriate.
 514 AC_DEFUN([gcc_GAS_CHECK_FEATURE],
 515 [AC_CACHE_CHECK([assembler for $1], [$2],
 516  [[$2]=no
 517   ifelse([$3],,,[dnl
 518   if test $in_tree_gas = yes; then
 519     gcc_GAS_VERSION_GTE_IFELSE($3, [[$2]=yes])
 520   el])if test x$gcc_cv_as != x; then
 521     echo ifelse(m4_substr([$5],0,1),[$], "[$5]", '[$5]') > conftest.s
 522     if AC_TRY_COMMAND([$gcc_cv_as $4 -o conftest.o conftest.s >&AC_FD_CC])
 523     then
 524         ifelse([$6],, [$2]=yes, [$6])
 525     else
 526       echo "configure: failed program was" >&AC_FD_CC
 527       cat conftest.s >&AC_FD_CC
 528     fi
 529     rm -f conftest.o conftest.s
 530   fi])
 531 ifelse([$7],,,[dnl
 532 if test $[$2] = yes; then
 533   $7
 534 fi])])
 535
 536 # AM_PROG_CC_C_O
 537 # --------------
 538 # Like AC_PROG_CC_C_O, but changed for automake.
 539
 540 # Copyright (C) 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
 541
 542 # This program is free software; you can redistribute it and/or modify
 543 # it under the terms of the GNU General Public License as published by
 544 # the Free Software Foundation; either version 2, or (at your option)
 545 # any later version.
 546
 547 # This program is distributed in the hope that it will be useful,
 548 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 549 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 550 # GNU General Public License for more details.
 551
 552 # You should have received a copy of the GNU General Public License
 553 # along with this program; if not, write to the Free Software
 554 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 555 # 02111-1307, USA.
 556
 557 AC_DEFUN([AM_PROG_CC_C_O],
 558 [AC_REQUIRE([AC_PROG_CC_C_O])dnl
 559 AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
 560 # FIXME: we rely on the cache variable name because
 561 # there is no other way.
 562 set dummy $CC
 563 ac_cc=`echo $[2] | sed ['s/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/']`
 564 if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" != yes"; then
 565    # Losing compiler, so override with the script.
 566    # FIXME: It is wrong to rewrite CC.
 567    # But if we don't then we get into trouble of one sort or another.
 568    # A longer-term fix would be to have automake use am__CC in this case,
 569    # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
 570    CC="$am_aux_dir/compile $CC"
 571 fi
 572 ])
 573
 574 # AM_AUX_DIR_EXPAND
 575
 576 # Copyright (C) 2001, 2003 Free Software Foundation, Inc.
 577
 578 # This program is free software; you can redistribute it and/or modify
 579 # it under the terms of the GNU General Public License as published by
 580 # the Free Software Foundation; either version 2, or (at your option)
 581 # any later version.
 582
 583 # This program is distributed in the hope that it will be useful,
 584 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 585 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 586 # GNU General Public License for more details.
 587
 588 # You should have received a copy of the GNU General Public License
 589 # along with this program; if not, write to the Free Software
 590 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 591 # 02111-1307, USA.
 592
 593 # For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets
 594 # $ac_aux_dir to `$srcdir/foo'.  In other projects, it is set to
 595 # `$srcdir', `$srcdir/..', or `$srcdir/../..'.
 596 #
 597 # Of course, Automake must honor this variable whenever it calls a
 598 # tool from the auxiliary directory.  The problem is that $srcdir (and
 599 # therefore $ac_aux_dir as well) can be either absolute or relative,
 600 # depending on how configure is run.  This is pretty annoying, since
 601 # it makes $ac_aux_dir quite unusable in subdirectories: in the top
 602 # source directory, any form will work fine, but in subdirectories a
 603 # relative path needs to be adjusted first.
 604 #
 605 # $ac_aux_dir/missing
 606 #    fails when called from a subdirectory if $ac_aux_dir is relative
 607 # $top_srcdir/$ac_aux_dir/missing
 608 #    fails if $ac_aux_dir is absolute,
 609 #    fails when called from a subdirectory in a VPATH build with
 610 #          a relative $ac_aux_dir
 611 #
 612 # The reason of the latter failure is that $top_srcdir and $ac_aux_dir
 613 # are both prefixed by $srcdir.  In an in-source build this is usually
 614 # harmless because $srcdir is `.', but things will broke when you
 615 # start a VPATH build or use an absolute $srcdir.
 616 #
 617 # So we could use something similar to $top_srcdir/$ac_aux_dir/missing,
 618 # iff we strip the leading $srcdir from $ac_aux_dir.  That would be:
 619 #   am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"`
 620 # and then we would define $MISSING as
 621 #   MISSING="\${SHELL} $am_aux_dir/missing"
 622 # This will work as long as MISSING is not called from configure, because
 623 # unfortunately $(top_srcdir) has no meaning in configure.
 624 # However there are other variables, like CC, which are often used in
 625 # configure, and could therefore not use this "fixed" $ac_aux_dir.
 626 #
 627 # Another solution, used here, is to always expand $ac_aux_dir to an
 628 # absolute PATH.  The drawback is that using absolute paths prevent a
 629 # configured tree to be moved without reconfiguration.
 630
 631 AC_DEFUN([AM_AUX_DIR_EXPAND],
 632 [dnl Rely on autoconf to set up CDPATH properly.
 633 AC_PREREQ([2.50])dnl
 634 # expand $ac_aux_dir to an absolute path
 635 am_aux_dir=`cd $ac_aux_dir && pwd`
 636 ])