gcc/acinclude.m4

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