gcc/acinclude.m4

   1 dnl See whether we need a declaration for a function.
   2 dnl The result is highly dependent on the INCLUDES passed in, so make sure
   3 dnl to use a different cache variable name in this macro if it is invoked
   4 dnl in a different context somewhere else.
   5 dnl gcc_AC_CHECK_DECL(SYMBOL,
   6 dnl     [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND [, INCLUDES]]])
   7 AC_DEFUN([gcc_AC_CHECK_DECL],
   8 [AC_MSG_CHECKING([whether $1 is declared])
   9 AC_CACHE_VAL(gcc_cv_have_decl_$1,
  10 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([$4],
  11 [#ifndef $1
  12 char *(*pfn) = (char *(*)) $1 ;
  13 #endif])], eval "gcc_cv_have_decl_$1=yes", eval "gcc_cv_have_decl_$1=no")])
  14 if eval "test \"`echo '$gcc_cv_have_decl_'$1`\" = yes"; then
  15   AC_MSG_RESULT(yes) ; ifelse([$2], , :, [$2])
  16 else
  17   AC_MSG_RESULT(no) ; ifelse([$3], , :, [$3])
  18 fi
  19 ])dnl
  20
  21 dnl Check multiple functions to see whether each needs a declaration.
  22 dnl Arrange to define HAVE_DECL_<FUNCTION> to 0 or 1 as appropriate.
  23 dnl gcc_AC_CHECK_DECLS(SYMBOLS,
  24 dnl     [ACTION-IF-NEEDED [, ACTION-IF-NOT-NEEDED [, INCLUDES]]])
  25 AC_DEFUN([gcc_AC_CHECK_DECLS],
  26 [AC_FOREACH([gcc_AC_Func], [$1],
  27   [AH_TEMPLATE(AS_TR_CPP(HAVE_DECL_[]gcc_AC_Func),
  28   [Define to 1 if we found a declaration for ']gcc_AC_Func[', otherwise
  29    define to 0.])])dnl
  30 for ac_func in $1
  31 do
  32   ac_tr_decl=AS_TR_CPP([HAVE_DECL_$ac_func])
  33 gcc_AC_CHECK_DECL($ac_func,
  34   [AC_DEFINE_UNQUOTED($ac_tr_decl, 1) $2],
  35   [AC_DEFINE_UNQUOTED($ac_tr_decl, 0) $3],
  36 dnl It is possible that the include files passed in here are local headers
  37 dnl which supply a backup declaration for the relevant prototype based on
  38 dnl the definition of (or lack of) the HAVE_DECL_ macro.  If so, this test
  39 dnl will always return success.  E.g. see libiberty.h's handling of
  40 dnl `basename'.  To avoid this, we define the relevant HAVE_DECL_ macro to
  41 dnl 1 so that any local headers used do not provide their own prototype
  42 dnl during this test.
  43 #undef $ac_tr_decl
  44 #define $ac_tr_decl 1
  45   $4
  46 )
  47 done
  48 ])
  49
  50 dnl 'make compare' can be significantly faster, if cmp itself can
  51 dnl skip bytes instead of using tail.  The test being performed is
  52 dnl "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2"
  53 dnl but we need to sink errors and handle broken shells.  We also test
  54 dnl for the parameter format "cmp file1 file2 skip1 skip2" which is
  55 dnl accepted by cmp on some systems.
  56 AC_DEFUN([gcc_AC_PROG_CMP_IGNORE_INITIAL],
  57 [AC_CACHE_CHECK([for cmp's capabilities], gcc_cv_prog_cmp_skip,
  58 [ echo abfoo >t1
  59   echo cdfoo >t2
  60   gcc_cv_prog_cmp_skip=slowcompare
  61   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
  62     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
  63       :
  64     else
  65       gcc_cv_prog_cmp_skip=gnucompare
  66     fi
  67   fi
  68   if test $gcc_cv_prog_cmp_skip = slowcompare ; then
  69     if cmp t1 t2 2 2 > /dev/null 2>&1; then
  70       if cmp t1 t2 1 1 > /dev/null 2>&1; then
  71         :
  72       else
  73         gcc_cv_prog_cmp_skip=fastcompare
  74       fi
  75     fi
  76   fi
  77   rm t1 t2
  78 ])
  79 make_compare_target=$gcc_cv_prog_cmp_skip
  80 AC_SUBST(make_compare_target)
  81 ])
  82
  83 dnl See if symbolic links work and if not, try to substitute either hard links or simple copy.
  84 AC_DEFUN([gcc_AC_PROG_LN_S],
  85 [AC_MSG_CHECKING(whether ln -s works)
  86 AC_CACHE_VAL(gcc_cv_prog_LN_S,
  87 [rm -f conftestdata_t
  88 echo >conftestdata_f
  89 if ln -s conftestdata_f conftestdata_t 2>/dev/null
  90 then
  91   gcc_cv_prog_LN_S="ln -s"
  92 else
  93   if ln conftestdata_f conftestdata_t 2>/dev/null
  94   then
  95     gcc_cv_prog_LN_S=ln
  96   else
  97     if cp -p conftestdata_f conftestdata_t 2>/dev/null
  98     then
  99       gcc_cv_prog_LN_S="cp -p"
 100     else
 101       gcc_cv_prog_LN_S=cp
 102     fi
 103   fi
 104 fi
 105 rm -f conftestdata_f conftestdata_t
 106 ])dnl
 107 LN_S="$gcc_cv_prog_LN_S"
 108 if test "$gcc_cv_prog_LN_S" = "ln -s"; then
 109   AC_MSG_RESULT(yes)
 110 else
 111   if test "$gcc_cv_prog_LN_S" = "ln"; then
 112     AC_MSG_RESULT([no, using ln])
 113   else
 114     AC_MSG_RESULT([no, and neither does ln, so using $gcc_cv_prog_LN_S])
 115   fi
 116 fi
 117 AC_SUBST(LN_S)dnl
 118 ])
 119
 120 dnl Define MKDIR_TAKES_ONE_ARG if mkdir accepts only one argument instead
 121 dnl of the usual 2.
 122 AC_DEFUN([gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG],
 123 [AC_CACHE_CHECK([if mkdir takes one argument], gcc_cv_mkdir_takes_one_arg,
 124 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
 125 #include <sys/types.h>
 126 #ifdef HAVE_SYS_STAT_H
 127 # include <sys/stat.h>
 128 #endif
 129 #ifdef HAVE_UNISTD_H
 130 # include <unistd.h>
 131 #endif
 132 #ifdef HAVE_DIRECT_H
 133 # include <direct.h>
 134 #endif], [mkdir ("foo", 0);])],
 135         gcc_cv_mkdir_takes_one_arg=no, gcc_cv_mkdir_takes_one_arg=yes)])
 136 if test $gcc_cv_mkdir_takes_one_arg = yes ; then
 137   AC_DEFINE(MKDIR_TAKES_ONE_ARG, 1, [Define if host mkdir takes a single argument.])
 138 fi
 139 ])
 140
 141 AC_DEFUN([gcc_AC_PROG_INSTALL],
 142 [AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
 143 # Find a good install program.  We prefer a C program (faster),
 144 # so one script is as good as another.  But avoid the broken or
 145 # incompatible versions:
 146 # SysV /etc/install, /usr/sbin/install
 147 # SunOS /usr/etc/install
 148 # IRIX /sbin/install
 149 # AIX /bin/install
 150 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
 151 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 152 # ./install, which can be erroneously created by make from ./install.sh.
 153 AC_MSG_CHECKING(for a BSD compatible install)
 154 if test -z "$INSTALL"; then
 155 AC_CACHE_VAL(ac_cv_path_install,
 156 [  IFS="${IFS=  }"; ac_save_IFS="$IFS"; IFS="${IFS}:"
 157   for ac_dir in $PATH; do
 158     # Account for people who put trailing slashes in PATH elements.
 159     case "$ac_dir/" in
 160     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
 161     *)
 162       # OSF1 and SCO ODT 3.0 have their own names for install.
 163       for ac_prog in ginstall scoinst install; do
 164         if test -f $ac_dir/$ac_prog; then
 165           if test $ac_prog = install &&
 166             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
 167             # AIX install.  It has an incompatible calling convention.
 168             # OSF/1 installbsd also uses dspmsg, but is usable.
 169             :
 170           else
 171             ac_cv_path_install="$ac_dir/$ac_prog -c"
 172             break 2
 173           fi
 174         fi
 175       done
 176       ;;
 177     esac
 178   done
 179   IFS="$ac_save_IFS"
 180 ])dnl
 181   if test "${ac_cv_path_install+set}" = set; then
 182     INSTALL="$ac_cv_path_install"
 183   else
 184     # As a last resort, use the slow shell script.  We don't cache a
 185     # path for INSTALL within a source directory, because that will
 186     # break other packages using the cache if that directory is
 187     # removed, or if the path is relative.
 188     INSTALL="$ac_install_sh"
 189   fi
 190 fi
 191 dnl We do special magic for INSTALL instead of AC_SUBST, to get
 192 dnl relative paths right.
 193 AC_MSG_RESULT($INSTALL)
 194 AC_SUBST(INSTALL)dnl
 195
 196 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
 197 # It thinks the first close brace ends the variable substitution.
 198 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
 199 AC_SUBST(INSTALL_PROGRAM)dnl
 200
 201 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 202 AC_SUBST(INSTALL_DATA)dnl
 203 ])
 204
 205 # mmap(2) blacklisting.  Some platforms provide the mmap library routine
 206 # but don't support all of the features we need from it.
 207 AC_DEFUN([gcc_AC_FUNC_MMAP_BLACKLIST],
 208 [
 209 AC_CHECK_HEADER([sys/mman.h],
 210                 [gcc_header_sys_mman_h=yes], [gcc_header_sys_mman_h=no])
 211 AC_CHECK_FUNC([mmap], [gcc_func_mmap=yes], [gcc_func_mmap=no])
 212 if test "$gcc_header_sys_mman_h" != yes \
 213  || test "$gcc_func_mmap" != yes; then
 214    gcc_cv_func_mmap_file=no
 215    gcc_cv_func_mmap_dev_zero=no
 216    gcc_cv_func_mmap_anon=no
 217 else
 218    AC_CACHE_CHECK([whether read-only mmap of a plain file works],
 219   gcc_cv_func_mmap_file,
 220   [# Add a system to this blacklist if
 221    # mmap(0, stat_size, PROT_READ, MAP_PRIVATE, fd, 0) doesn't return a
 222    # memory area containing the same data that you'd get if you applied
 223    # read() to the same fd.  The only system known to have a problem here
 224    # is VMS, where text files have record structure.
 225    case "$host_os" in
 226      vms* | ultrix*)
 227         gcc_cv_func_mmap_file=no ;;
 228      *)
 229         gcc_cv_func_mmap_file=yes;;
 230    esac])
 231    AC_CACHE_CHECK([whether mmap from /dev/zero works],
 232   gcc_cv_func_mmap_dev_zero,
 233   [# Add a system to this blacklist if it has mmap() but /dev/zero
 234    # does not exist, or if mmapping /dev/zero does not give anonymous
 235    # zeroed pages with both the following properties:
 236    # 1. If you map N consecutive pages in with one call, and then
 237    #    unmap any subset of those pages, the pages that were not
 238    #    explicitly unmapped remain accessible.
 239    # 2. If you map two adjacent blocks of memory and then unmap them
 240    #    both at once, they must both go away.
 241    # Systems known to be in this category are Windows (all variants),
 242    # VMS, and Darwin.
 243    case "$host_os" in
 244      vms* | cygwin* | pe | mingw* | darwin* | ultrix* | hpux10* | hpux11.00)
 245         gcc_cv_func_mmap_dev_zero=no ;;
 246      *)
 247         gcc_cv_func_mmap_dev_zero=yes;;
 248    esac])
 249
 250    # Unlike /dev/zero, the MAP_ANON(YMOUS) defines can be probed for.
 251    AC_CACHE_CHECK([for MAP_ANON(YMOUS)], gcc_cv_decl_map_anon,
 252     [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
 253 [#include <sys/types.h>
 254 #include <sys/mman.h>
 255 #include <unistd.h>
 256
 257 #ifndef MAP_ANONYMOUS
 258 #define MAP_ANONYMOUS MAP_ANON
 259 #endif
 260 ],
 261 [int n = MAP_ANONYMOUS;])],
 262     gcc_cv_decl_map_anon=yes,
 263     gcc_cv_decl_map_anon=no)])
 264
 265    if test $gcc_cv_decl_map_anon = no; then
 266      gcc_cv_func_mmap_anon=no
 267    else
 268      AC_CACHE_CHECK([whether mmap with MAP_ANON(YMOUS) works],
 269      gcc_cv_func_mmap_anon,
 270   [# Add a system to this blacklist if it has mmap() and MAP_ANON or
 271    # MAP_ANONYMOUS, but using mmap(..., MAP_PRIVATE|MAP_ANONYMOUS, -1, 0)
 272    # doesn't give anonymous zeroed pages with the same properties listed
 273    # above for use of /dev/zero.
 274    # Systems known to be in this category are Windows, VMS, and SCO Unix.
 275    case "$host_os" in
 276      vms* | cygwin* | pe | mingw* | sco* | udk* )
 277         gcc_cv_func_mmap_anon=no ;;
 278      *)
 279         gcc_cv_func_mmap_anon=yes;;
 280    esac])
 281    fi
 282 fi
 283
 284 if test $gcc_cv_func_mmap_file = yes; then
 285   AC_DEFINE(HAVE_MMAP_FILE, 1,
 286             [Define if read-only mmap of a plain file works.])
 287 fi
 288 if test $gcc_cv_func_mmap_dev_zero = yes; then
 289   AC_DEFINE(HAVE_MMAP_DEV_ZERO, 1,
 290             [Define if mmap of /dev/zero works.])
 291 fi
 292 if test $gcc_cv_func_mmap_anon = yes; then
 293   AC_DEFINE(HAVE_MMAP_ANON, 1,
 294             [Define if mmap with MAP_ANON(YMOUS) works.])
 295 fi
 296 ])
 297
 298 dnl Determine if enumerated bitfields are unsigned.   ISO C says they can
 299 dnl be either signed or unsigned.
 300 dnl
 301 AC_DEFUN([gcc_AC_C_ENUM_BF_UNSIGNED],
 302 [AC_CACHE_CHECK(for unsigned enumerated bitfields, gcc_cv_enum_bf_unsigned,
 303 [AC_RUN_IFELSE([AC_LANG_SOURCE([#include <stdlib.h>
 304 enum t { BLAH = 128 } ;
 305 struct s_t { enum t member : 8; } s ;
 306 int main(void)
 307 {
 308         s.member = BLAH;
 309         if (s.member < 0) exit(1);
 310         exit(0);
 311
 312 }])], gcc_cv_enum_bf_unsigned=yes, gcc_cv_enum_bf_unsigned=no, gcc_cv_enum_bf_unsigned=yes)])
 313 if test $gcc_cv_enum_bf_unsigned = yes; then
 314   AC_DEFINE(ENUM_BITFIELDS_ARE_UNSIGNED, 1,
 315     [Define if enumerated bitfields are treated as unsigned values.])
 316 fi])
 317
 318 dnl Probe number of bits in a byte.
 319 dnl Note C89 requires CHAR_BIT >= 8.
 320 dnl
 321 AC_DEFUN([gcc_AC_C_CHAR_BIT],
 322 [AC_CACHE_CHECK(for CHAR_BIT, gcc_cv_decl_char_bit,
 323 [AC_EGREP_CPP(found,
 324 [#ifdef HAVE_LIMITS_H
 325 #include <limits.h>
 326 #endif
 327 #ifdef CHAR_BIT
 328 found
 329 #endif], gcc_cv_decl_char_bit=yes, gcc_cv_decl_char_bit=no)
 330 ])
 331 if test $gcc_cv_decl_char_bit = no; then
 332   AC_CACHE_CHECK(number of bits in a byte, gcc_cv_c_nbby,
 333 [i=8
 334  gcc_cv_c_nbby=
 335  while test $i -lt 65; do
 336    AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,
 337      [switch(0) {
 338   case (unsigned char)((unsigned long)1 << $i) == ((unsigned long)1 << $i):
 339   case (unsigned char)((unsigned long)1<<($i-1)) == ((unsigned long)1<<($i-1)):
 340   ; }])],
 341      [gcc_cv_c_nbby=$i; break])
 342    i=`expr $i + 1`
 343  done
 344  test -z "$gcc_cv_c_nbby" && gcc_cv_c_nbby=failed
 345 ])
 346 if test $gcc_cv_c_nbby = failed; then
 347   AC_MSG_ERROR(cannot determine number of bits in a byte)
 348 else
 349   AC_DEFINE_UNQUOTED(CHAR_BIT, $gcc_cv_c_nbby,
 350   [Define as the number of bits in a byte, if `limits.h' doesn't.])
 351 fi
 352 fi])
 353
 354 AC_DEFUN([gcc_AC_INITFINI_ARRAY],
 355 [AC_ARG_ENABLE(initfini-array,
 356         [  --enable-initfini-array      use .init_array/.fini_array sections],
 357         [], [
 358 AC_CACHE_CHECK(for .preinit_array/.init_array/.fini_array support,
 359                  gcc_cv_initfini_array, [dnl
 360   AC_RUN_IFELSE([AC_LANG_SOURCE([
 361 static int x = -1;
 362 int main (void) { return x; }
 363 int foo (void) { x = 0; }
 364 int (*fp) (void) __attribute__ ((section (".init_array"))) = foo;])],
 365              [gcc_cv_initfini_array=yes], [gcc_cv_initfini_array=no],
 366              [gcc_cv_initfini_array=no])])
 367   enable_initfini_array=$gcc_cv_initfini_array
 368 ])
 369 if test $enable_initfini_array = yes; then
 370   AC_DEFINE(HAVE_INITFINI_ARRAY, 1,
 371     [Define .init_array/.fini_array sections are available and working.])
 372 fi])
 373
 374 dnl # _gcc_COMPUTE_GAS_VERSION
 375 dnl # Used by gcc_GAS_VERSION_GTE_IFELSE
 376 dnl #
 377 dnl # WARNING:
 378 dnl # gcc_cv_as_gas_srcdir must be defined before this.
 379 dnl # This gross requirement will go away eventually.
 380 AC_DEFUN([_gcc_COMPUTE_GAS_VERSION],
 381 [gcc_cv_as_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
 382 for f in $gcc_cv_as_bfd_srcdir/configure \
 383          $gcc_cv_as_gas_srcdir/configure \
 384          $gcc_cv_as_gas_srcdir/configure.in \
 385          $gcc_cv_as_gas_srcdir/Makefile.in ; do
 386   gcc_cv_gas_version=`sed -n -e 's/^[[  ]]*\(VERSION=[[0-9]]*\.[[0-9]]*.*\)/\1/p' < $f`
 387   if test x$gcc_cv_gas_version != x; then
 388     break
 389   fi
 390 done
 391 gcc_cv_gas_major_version=`expr "$gcc_cv_gas_version" : "VERSION=\([[0-9]]*\)"`
 392 gcc_cv_gas_minor_version=`expr "$gcc_cv_gas_version" : "VERSION=[[0-9]]*\.\([[0-9]]*\)"`
 393 gcc_cv_gas_patch_version=`expr "$gcc_cv_gas_version" : "VERSION=[[0-9]]*\.[[0-9]]*\.\([[0-9]]*\)"`
 394 case $gcc_cv_gas_patch_version in
 395   "") gcc_cv_gas_patch_version="0" ;;
 396 esac
 397 gcc_cv_gas_vers=`expr \( \( $gcc_cv_gas_major_version \* 1000 \) \
 398                             + $gcc_cv_gas_minor_version \) \* 1000 \
 399                             + $gcc_cv_gas_patch_version`
 400 ]) []dnl # _gcc_COMPUTE_GAS_VERSION
 401
 402 dnl # gcc_GAS_VERSION_GTE_IFELSE([elf,] major, minor, patchlevel,
 403 dnl #                     [command_if_true = :], [command_if_false = :])
 404 dnl # Check to see if the version of GAS is greater than or
 405 dnl # equal to the specified version.
 406 dnl #
 407 dnl # The first ifelse() shortens the shell code if the patchlevel
 408 dnl # is unimportant (the usual case).  The others handle missing
 409 dnl # commands.  Note that the tests are structured so that the most
 410 dnl # common version number cases are tested first.
 411 AC_DEFUN([_gcc_GAS_VERSION_GTE_IFELSE],
 412 [ifelse([$1], elf,
 413  [if test $in_tree_gas_is_elf = yes \
 414   &&],
 415  [if]) test $gcc_cv_gas_vers -ge `expr \( \( $2 \* 1000 \) + $3 \) \* 1000 + $4`
 416   then dnl
 417 ifelse([$5],,:,[$5])[]dnl
 418 ifelse([$6],,,[
 419   else $6])
 420 fi])
 421
 422 AC_DEFUN([gcc_GAS_VERSION_GTE_IFELSE],
 423 [AC_REQUIRE([_gcc_COMPUTE_GAS_VERSION])dnl
 424 ifelse([$1], elf, [_gcc_GAS_VERSION_GTE_IFELSE($@)],
 425                   [_gcc_GAS_VERSION_GTE_IFELSE(,$@)])])
 426
 427 dnl gcc_GAS_CHECK_FEATURE(description, cv, [[elf,]major,minor,patchlevel],
 428 dnl [extra switches to as], [assembler input],
 429 dnl [extra testing logic], [command if feature available])
 430 dnl
 431 dnl Checks for an assembler feature.  If we are building an in-tree
 432 dnl gas, the feature is available if the associated assembler version
 433 dnl is greater than or equal to major.minor.patchlevel.  If not, then
 434 dnl ASSEMBLER INPUT is fed to the assembler and the feature is available
 435 dnl if assembly succeeds.  If EXTRA TESTING LOGIC is not the empty string,
 436 dnl then it is run instead of simply setting CV to "yes" - it is responsible
 437 dnl for doing so, if appropriate.
 438 AC_DEFUN([gcc_GAS_CHECK_FEATURE],
 439 [AC_CACHE_CHECK([assembler for $1], [$2],
 440  [[$2]=no
 441   ifelse([$3],,,[dnl
 442   if test $in_tree_gas = yes; then
 443     gcc_GAS_VERSION_GTE_IFELSE($3, [[$2]=yes])
 444   el])if test x$gcc_cv_as != x; then
 445     echo ifelse(m4_substr([$5],0,1),[$], "[$5]", '[$5]') > conftest.s
 446     if AC_TRY_COMMAND([$gcc_cv_as $4 -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD])
 447     then
 448         ifelse([$6],, [$2]=yes, [$6])
 449     else
 450       echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
 451       cat conftest.s >&AS_MESSAGE_LOG_FD
 452     fi
 453     rm -f conftest.o conftest.s
 454   fi])
 455 ifelse([$7],,,[dnl
 456 if test $[$2] = yes; then
 457   $7
 458 fi])])
 459
 460 dnl GCC_TARGET_TEMPLATE(KEY)
 461 dnl ------------------------
 462 dnl Define KEY as a valid configure key on the target machine.
 463
 464 m4_define([GCC_TARGET_TEMPLATE],
 465 [m4_define([GCC_TARGET_TEMPLATE($1)],[])])
 466
 467 dnl AH_TEMPLATE(KEY, DESCRIPTION)
 468 dnl -----------------------------
 469 dnl Issue an autoheader template for KEY, i.e., a comment composed of
 470 dnl DESCRIPTION (properly wrapped), and then #undef KEY.  Redefinition
 471 dnl of the macro in autoheader.m4, to support definition of only a few
 472 dnl keys while compiling target libraries.
 473
 474 m4_define([AH_TEMPLATE],
 475 [AH_VERBATIM([$1],m4_text_wrap([$2 */], [   ], [/* ])
 476 m4_ifdef([GCC_TARGET_TEMPLATE($1)],[],[#ifndef USED_FOR_TARGET
 477 ])[#undef $1]m4_ifdef([GCC_TARGET_TEMPLATE($1)],[],[
 478 #endif
 479 ]))])
 480
 481 dnl Make sure that build_exeext is looked for
 482 AC_DEFUN([gcc_AC_BUILD_EXEEXT], [
 483 ac_executable_extensions="$build_exeext"])
 484