gcc/configure.in

   1 # configure.in for GNU CC
   2 # Process this file with autoconf to generate a configuration script.
   3
   4 # Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
   5
   6 #This file is part of GNU CC.
   7
   8 #GNU CC is free software; you can redistribute it and/or modify
   9 #it under the terms of the GNU General Public License as published by
  10 #the Free Software Foundation; either version 2, or (at your option)
  11 #any later version.
  12
  13 #GNU CC is distributed in the hope that it will be useful,
  14 #but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 #MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 #GNU General Public License for more details.
  17
  18 #You should have received a copy of the GNU General Public License
  19 #along with GNU CC; see the file COPYING.  If not, write to
  20 #the Free Software Foundation, 59 Temple Place - Suite 330,
  21 #Boston, MA 02111-1307, USA.
  22
  23 # Initialization and defaults
  24 AC_PREREQ(2.13)
  25 AC_INIT(tree.c)
  26 AC_CONFIG_HEADER(auto-host.h:config.in)
  27
  28 remove=rm
  29 hard_link=ln
  30 symbolic_link='ln -s'
  31 copy=cp
  32
  33 # Check for bogus environment variables.
  34 # Test if LIBRARY_PATH contains the notation for the current directory
  35 # since this would lead to problems installing/building glibc.
  36 # LIBRARY_PATH contains the current directory if one of the following
  37 # is true:
  38 # - one of the terminals (":" and ";") is the first or last sign
  39 # - two terminals occur directly after each other
  40 # - the path contains an element with a dot in it
  41 AC_MSG_CHECKING(LIBRARY_PATH variable)
  42 changequote(,)dnl
  43 case ${LIBRARY_PATH} in
  44   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
  45     library_path_setting="contains current directory"
  46     ;;
  47   *)
  48     library_path_setting="ok"
  49     ;;
  50 esac
  51 changequote([,])dnl
  52 AC_MSG_RESULT($library_path_setting)
  53 if test "$library_path_setting" != "ok"; then
  54 AC_MSG_ERROR([
  55 *** LIBRARY_PATH shouldn't contain the current directory when
  56 *** building gcc. Please change the environment variable
  57 *** and run configure again.])
  58 fi
  59
  60 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
  61 # since this would lead to problems installing/building glibc.
  62 # GCC_EXEC_PREFIX contains the current directory if one of the following
  63 # is true:
  64 # - one of the terminals (":" and ";") is the first or last sign
  65 # - two terminals occur directly after each other
  66 # - the path contains an element with a dot in it
  67 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
  68 changequote(,)dnl
  69 case ${GCC_EXEC_PREFIX} in
  70   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
  71     gcc_exec_prefix_setting="contains current directory"
  72     ;;
  73   *)
  74     gcc_exec_prefix_setting="ok"
  75     ;;
  76 esac
  77 changequote([,])dnl
  78 AC_MSG_RESULT($gcc_exec_prefix_setting)
  79 if test "$gcc_exec_prefix_setting" != "ok"; then
  80 AC_MSG_ERROR([
  81 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
  82 *** building gcc. Please change the environment variable
  83 *** and run configure again.])
  84 fi
  85
  86 # Check for additional parameters
  87
  88 # With GNU ld
  89 AC_ARG_WITH(gnu-ld,
  90 [  --with-gnu-ld           arrange to work with GNU ld.],
  91 gnu_ld_flag="$with_gnu_ld",
  92 gnu_ld_flag=no)
  93
  94 # With pre-defined ld
  95 AC_ARG_WITH(ld,
  96 [  --with-ld               arrange to use the specified ld (full pathname).],
  97 DEFAULT_LINKER="$with_ld")
  98 if test x"${DEFAULT_LINKER+set}" = x"set"; then
  99   if test ! -x "$DEFAULT_LINKER"; then
 100     AC_MSG_WARN([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
 101   elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
 102     gnu_ld_flag=yes
 103   fi
 104   AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
 105         [Define to enable the use of a default linker.])
 106 fi
 107
 108 # With GNU as
 109 AC_ARG_WITH(gnu-as,
 110 [  --with-gnu-as           arrange to work with GNU as.],
 111 gas_flag="$with_gnu_as",
 112 gas_flag=no)
 113
 114 AC_ARG_WITH(as,
 115 [  --with-as               arrange to use the specified as (full pathname).],
 116 DEFAULT_ASSEMBLER="$with_as")
 117 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
 118   if test ! -x "$DEFAULT_ASSEMBLER"; then
 119     AC_MSG_WARN([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
 120   elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
 121     gas_flag=yes
 122   fi
 123   AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
 124         [Define to enable the use of a default assembler.])
 125 fi
 126
 127 # With stabs
 128 AC_ARG_WITH(stabs,
 129 [  --with-stabs            arrange to use stabs instead of host debug format.],
 130 stabs="$with_stabs",
 131 stabs=no)
 132
 133 # With ELF
 134 AC_ARG_WITH(elf,
 135 [  --with-elf              arrange to use ELF instead of host debug format.],
 136 elf="$with_elf",
 137 elf=no)
 138
 139 # Specify the local prefix
 140 local_prefix=
 141 AC_ARG_WITH(local-prefix,
 142 [  --with-local-prefix=DIR specifies directory to put local include.],
 143 [case "${withval}" in
 144 yes)    AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
 145 no)     ;;
 146 *)      local_prefix=$with_local_prefix ;;
 147 esac])
 148
 149 # Default local prefix if it is empty
 150 if test x$local_prefix = x; then
 151         local_prefix=/usr/local
 152 fi
 153
 154 # Build a new-libstdc++ system (ie libstdc++-v3)
 155 AC_MSG_CHECKING([for libstdc++ to install])
 156 AC_ARG_ENABLE(libstdcxx-v3,
 157 [  --enable-libstdcxx-v3
 158                           enable libstdc++-v3 for building and installation],
 159   [enable_libstdcxx_v3="$enableval"], [enable_libstdcxx_v3=yes])
 160
 161 if test x$enable_libstdcxx_v3 = xyes; then
 162   AC_MSG_RESULT(v3)
 163   HAVE_LIBSTDCXX_V3=1
 164   ac_esn=1
 165 else
 166   AC_MSG_RESULT(v2)
 167   HAVE_LIBSTDCXX_V3=0
 168   ac_esn=0
 169 fi
 170
 171 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
 172 # passed in by the toplevel make and thus we'd get different behavior
 173 # depending on where we built the sources.
 174 gcc_gxx_include_dir=
 175 # Specify the g++ header file directory
 176 AC_ARG_WITH(gxx-include-dir,
 177 [  --with-gxx-include-dir=DIR
 178                           specifies directory to put g++ header files.],
 179 [case "${withval}" in
 180 yes)    AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
 181 no)     ;;
 182 *)      gcc_gxx_include_dir=$with_gxx_include_dir ;;
 183 esac])
 184
 185 if test x${gcc_gxx_include_dir} = x; then
 186   if test x${enable_version_specific_runtime_libs} = xyes; then
 187     gcc_gxx_include_dir='${libsubdir}/include/g++'
 188   else
 189     topsrcdir=${srcdir}/.. . ${srcdir}/../config.if
 190 changequote(<<, >>)dnl
 191     gcc_gxx_include_dir="\$(libsubdir)/\$(unlibsubdir)/..\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/[^/]*|/..|g'\`/include/g++"-${libstdcxx_interface}
 192 changequote([, ])dnl
 193   fi
 194 fi
 195
 196 # Enable expensive internal checks
 197 AC_ARG_ENABLE(checking,
 198 [  --enable-checking[=LIST]
 199                           enable expensive run-time checks.  With LIST,
 200                           enable only specific categories of checks.
 201                           Categories are: misc,tree,rtl,gc,gcac; default
 202                           is misc,tree,gc],
 203 [ac_checking=
 204 ac_tree_checking=
 205 ac_rtl_checking=
 206 ac_gc_checking=
 207 ac_gc_always_collect=
 208 case "${enableval}" in
 209 yes)    ac_checking=1 ; ac_tree_checking=1 ; ac_gc_checking=1 ;;
 210 no)     ;;
 211 *)      IFS="${IFS=     }"; ac_save_IFS="$IFS"; IFS="$IFS,"
 212         set fnord $enableval; shift
 213         IFS="$ac_save_IFS"
 214         for check
 215         do
 216                 case $check in
 217                 misc)   ac_checking=1 ;;
 218                 tree)   ac_tree_checking=1 ;;
 219                 rtl)    ac_rtl_checking=1 ;;
 220                 gc)     ac_gc_checking=1 ;;
 221                 gcac)   ac_gc_always_collect=1 ;;
 222                 *)      AC_MSG_ERROR(unknown check category $check) ;;
 223                 esac
 224         done
 225         ;;
 226 esac
 227 ],
 228 # Enable some checks by default for development versions of GCC
 229 [ac_checking=1; ac_tree_checking=1; ac_gc_checking=1;])
 230 if test x$ac_checking != x ; then
 231   AC_DEFINE(ENABLE_CHECKING, 1,
 232 [Define if you want more run-time sanity checks.  This one gets a grab
 233    bag of miscellaneous but relatively cheap checks.])
 234 fi
 235 if test x$ac_tree_checking != x ; then
 236   AC_DEFINE(ENABLE_TREE_CHECKING, 1,
 237 [Define if you want all operations on trees (the basic data
 238    structure of the front ends) to be checked for dynamic type safety
 239    at runtime.  This is moderately expensive.])
 240 fi
 241 if test x$ac_rtl_checking != x ; then
 242   AC_DEFINE(ENABLE_RTL_CHECKING, 1,
 243 [Define if you want all operations on RTL (the basic data structure
 244    of the optimizer and back end) to be checked for dynamic type safety
 245    at runtime.  This is quite expensive.])
 246 fi
 247 if test x$ac_gc_checking != x ; then
 248   AC_DEFINE(ENABLE_GC_CHECKING, 1,
 249 [Define if you want the garbage collector to do object poisoning and
 250    other memory allocation checks.  This is quite expensive.])
 251 fi
 252 if test x$ac_gc_always_collect != x ; then
 253   AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
 254 [Define if you want the garbage collector to operate in maximally
 255    paranoid mode, validating the entire heap and collecting garbage at
 256    every opportunity.  This is extremely expensive.])
 257 fi
 258
 259
 260 AC_ARG_ENABLE(cpp,
 261 [  --disable-cpp           don't provide a user-visible C preprocessor.],
 262 [], [enable_cpp=yes])
 263
 264 AC_ARG_WITH(cpp_install_dir,
 265 [  --with-cpp-install-dir=DIR
 266                           install the user visible C preprocessor in DIR
 267                           (relative to PREFIX) as well as PREFIX/bin.],
 268 [if test x$withval = xyes; then
 269   AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
 270 elif test x$withval != xno; then
 271   cpp_install_dir=$withval
 272 fi])
 273
 274 # Enable Multibyte Characters for C/C++
 275 AC_ARG_ENABLE(c-mbchar,
 276 [  --enable-c-mbchar       Enable multibyte characters for C and C++.],
 277 if test x$enable_c_mbchar != xno; then
 278   AC_DEFINE(MULTIBYTE_CHARS, 1,
 279   [Define if you want the C and C++ compilers to support multibyte
 280    character sets for source code.])
 281 fi)
 282
 283 # Enable threads
 284 # Pass with no value to take the default
 285 # Pass with a value to specify a thread package
 286 AC_ARG_ENABLE(threads,
 287 [  --enable-threads        enable thread usage for target GCC.
 288   --enable-threads=LIB    use LIB thread package for target GCC.],,
 289 enable_threads='')
 290
 291 enable_threads_flag=$enable_threads
 292 # Check if a valid thread package
 293 case x${enable_threads_flag} in
 294         x | xno)
 295                 # No threads
 296                 target_thread_file='single'
 297                 ;;
 298         xyes)
 299                 # default
 300                 target_thread_file=''
 301                 ;;
 302         xdecosf1 | xirix | xmach | xos2 | xposix | xpthreads | xsingle | \
 303         xsolaris | xwin32 | xdce | xvxworks | xaix)
 304                 target_thread_file=$enable_threads_flag
 305                 ;;
 306         *)
 307                 echo "$enable_threads is an unknown thread package" 1>&2
 308                 exit 1
 309                 ;;
 310 esac
 311
 312 AC_ARG_ENABLE(objc-gc,
 313 [  --enable-objc-gc       enable the use of Boehm's garbage collector with
 314                           the GNU Objective-C runtime.],
 315 if test x$enable_objc_gc = xno; then
 316         objc_boehm_gc=''
 317 else
 318         objc_boehm_gc=1
 319 fi,
 320 objc_boehm_gc='')
 321
 322 AC_ARG_WITH(dwarf2,
 323 [  --with-dwarf2          force the default debug format to be DWARF2.],
 324 dwarf2="$with_dwarf2",
 325 dwarf2=no)
 326
 327 AC_ARG_ENABLE(shared,
 328 [  --disable-shared       don't provide a shared libgcc.],
 329 [], [enable_shared=yes])
 330 AC_SUBST(enable_shared)
 331
 332 # Determine the host, build, and target systems
 333 AC_CANONICAL_SYSTEM
 334
 335 # Find the native compiler
 336 AC_PROG_CC
 337 AC_PROG_CC_C_O
 338 # autoconf is lame and doesn't give us any substitution variable for this.
 339 if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = no"; then
 340   NO_MINUS_C_MINUS_O=yes
 341 else
 342   OUTPUT_OPTION='-o $@'
 343 fi
 344 AC_SUBST(NO_MINUS_C_MINUS_O)
 345 AC_SUBST(OUTPUT_OPTION)
 346
 347 gcc_AC_C_LONG_DOUBLE
 348
 349 AC_CACHE_CHECK(whether ${CC-cc} accepts -Wno-long-long,
 350 ac_cv_prog_cc_no_long_long,
 351 [save_CFLAGS="$CFLAGS"
 352 CFLAGS="-Wno-long-long"
 353 AC_TRY_COMPILE(,,ac_cv_prog_cc_no_long_long=yes,
 354                ac_cv_prog_cc_no_long_long=no)
 355 CFLAGS="$save_CFLAGS"])
 356 strict1_warn=
 357 if test $ac_cv_prog_cc_no_long_long = yes; then
 358   strict1_warn="-pedantic -Wno-long-long"
 359 fi
 360 AC_SUBST(strict1_warn)
 361
 362 # If the native compiler is GCC, we can enable warnings even in stage1.
 363 # That's useful for people building cross-compilers, or just running a
 364 # quick `make'.
 365 warn_cflags=
 366 if test "x$GCC" = "xyes"; then
 367   warn_cflags='$(GCC_WARN_CFLAGS)'
 368 fi
 369 AC_SUBST(warn_cflags)
 370
 371 # Stage specific cflags for build.
 372 stage1_cflags=
 373 case $build in
 374 vax-*-*)
 375   if test x$GCC = xyes
 376   then
 377     stage1_cflags="-Wa,-J"
 378   else
 379     stage1_cflags="-J"
 380   fi
 381   ;;
 382 esac
 383 AC_SUBST(stage1_cflags)
 384
 385 AC_PROG_MAKE_SET
 386
 387 AC_MSG_CHECKING([whether a default assembler was specified])
 388 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
 389     if test x"$gas_flag" = x"no"; then
 390         AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
 391     else
 392         AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
 393     fi
 394 else
 395     AC_MSG_RESULT(no)
 396 fi
 397
 398 AC_MSG_CHECKING([whether a default linker was specified])
 399 if test x"${DEFAULT_LINKER+set}" = x"set"; then
 400     if test x"$gnu_ld_flag" = x"no"; then
 401         AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
 402     else
 403         AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
 404     fi
 405 else
 406     AC_MSG_RESULT(no)
 407 fi
 408
 409 AC_MSG_CHECKING(for GNU C library)
 410 AC_CACHE_VAL(gcc_cv_glibc,
 411 [AC_TRY_COMPILE(
 412   [#include <features.h>],[
 413 #if ! (defined __GLIBC__ || defined __GNU_LIBRARY__)
 414 #error Not a GNU C library system
 415 #endif],
 416   [gcc_cv_glibc=yes],
 417   gcc_cv_glibc=no)])
 418 AC_MSG_RESULT($gcc_cv_glibc)
 419 if test $gcc_cv_glibc = yes; then
 420   AC_DEFINE(_GNU_SOURCE, 1, [Always define this when using the GNU C Library])
 421 fi
 422
 423 AC_C_INLINE
 424
 425 # Find some useful tools
 426 AC_PROG_AWK
 427 gcc_AC_PROG_LN
 428 gcc_AC_PROG_LN_S
 429 gcc_AC_C_VOLATILE
 430 AC_PROG_RANLIB
 431 gcc_AC_PROG_INSTALL
 432
 433 AC_HEADER_STDC
 434 AC_HEADER_TIME
 435 gcc_AC_HEADER_STRING
 436 AC_HEADER_SYS_WAIT
 437 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h \
 438                  fcntl.h unistd.h stab.h sys/file.h sys/time.h \
 439                  sys/resource.h sys/param.h sys/times.h sys/stat.h \
 440                  direct.h malloc.h langinfo.h iconv.h)
 441
 442 # Check for thread headers.
 443 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
 444 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
 445
 446 # See if GNAT has been installed
 447 AC_CHECK_PROG(gnat, gnatbind, yes, no)
 448
 449 # Do we have a single-tree copy of texinfo?
 450 if test -f $srcdir/../texinfo/Makefile.in; then
 451   MAKEINFO='$(objdir)/../texinfo/makeinfo/makeinfo'
 452   gcc_cv_prog_makeinfo_modern=yes
 453   AC_MSG_RESULT([Using makeinfo from the unified source tree.])
 454 else
 455   # See if makeinfo has been installed and is modern enough
 456   # that we can use it.
 457   gcc_AC_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
 458   [GNU texinfo.* \([0-9][0-9.]*\)],
 459   [3.1[2-9] | 3.[2-9][0-9] | 4.* | 1.6[89] | 1.7[0-9]])
 460 fi
 461
 462 if test $gcc_cv_prog_makeinfo_modern = no; then
 463   AC_MSG_WARN([
 464 *** Makeinfo is missing or too old.
 465 *** Info documentation will not be built.])
 466   BUILD_INFO=
 467 else
 468   BUILD_INFO=info               AC_SUBST(BUILD_INFO)
 469 fi
 470
 471 # How about lex?
 472 dnl Don't use AC_PROG_LEX; we insist on flex.
 473 dnl LEXLIB is not useful in gcc.
 474 if test -f $srcdir/../flex/skel.c; then
 475   FLEX='$(objdir)/../flex/flex'
 476 else
 477   AC_CHECK_PROG(FLEX, flex, flex, false)
 478 fi
 479
 480 # Bison?
 481 # The -L switch is so bison can find its skeleton file.
 482 if test -f $srcdir/../bison/bison.simple; then
 483   BISON='$(objdir)/../bison/bison -L $(srcdir)/../bison/'
 484 else
 485   AC_CHECK_PROG(BISON, bison, bison, false)
 486 fi
 487
 488 # See if the stage1 system preprocessor understands the ANSI C
 489 # preprocessor stringification operator.
 490 AC_C_STRINGIZE
 491
 492 # Use <inttypes.h> only if it exists,
 493 # doesn't clash with <sys/types.h>, and declares intmax_t.
 494 AC_MSG_CHECKING(for inttypes.h)
 495 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
 496 [AC_TRY_COMPILE(
 497   [#include <sys/types.h>
 498 #include <inttypes.h>],
 499   [intmax_t i = -1;],
 500   [gcc_cv_header_inttypes_h=yes],
 501   gcc_cv_header_inttypes_h=no)])
 502 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
 503 if test $gcc_cv_header_inttypes_h = yes; then
 504   AC_DEFINE(HAVE_INTTYPES_H, 1,
 505         [Define if you have a working <inttypes.h> header file.])
 506 fi
 507
 508 #
 509 # Determine if enumerated bitfields are unsigned.   ISO C says they can
 510 # be either signed or unsigned.
 511 #
 512 AC_CACHE_CHECK(for unsigned enumerated bitfields, gcc_cv_enum_bf_unsigned,
 513 [AC_TRY_RUN(#include <stdlib.h>
 514 enum t { BLAH = 128 } ;
 515 struct s_t { enum t member : 8; } s ;
 516 int main(void)
 517 {
 518         s.member = BLAH;
 519         if (s.member < 0) exit(1);
 520         exit(0);
 521
 522 }, gcc_cv_enum_bf_unsigned=yes, gcc_cv_enum_bf_unsigned=no, gcc_cv_enum_bf_unsigned=yes)])
 523 if test $gcc_cv_enum_bf_unsigned = yes; then
 524   AC_DEFINE(ENUM_BITFIELDS_ARE_UNSIGNED, 1,
 525     [Define if enumerated bitfields are treated as unsigned values.])
 526 fi
 527
 528 AC_CHECK_FUNCS(strtoul bsearch putenv popen bcopy \
 529         strchr strrchr kill getrlimit setrlimit atoll atoq \
 530         sysconf isascii gettimeofday strsignal putc_unlocked fputc_unlocked \
 531         fputs_unlocked getrusage valloc iconv nl_langinfo)
 532
 533 AC_CHECK_TYPE(ssize_t, int)
 534
 535 # Try to determine the array type of the second argument of getgroups
 536 # for the target system (int or gid_t).
 537 AC_TYPE_GETGROUPS
 538 if test "${target}" = "${build}"; then
 539   TARGET_GETGROUPS_T=$ac_cv_type_getgroups
 540 else
 541   case "${target}" in
 542         # This condition may need some tweaking.  It should include all
 543         # targets where the array type of the second argument of getgroups
 544         # is int and the type of gid_t is not equivalent to int.
 545         *-*-sunos* | *-*-ultrix*)
 546                 TARGET_GETGROUPS_T=int
 547                 ;;
 548         *)
 549                 TARGET_GETGROUPS_T=gid_t
 550                 ;;
 551   esac
 552 fi
 553 AC_SUBST(TARGET_GETGROUPS_T)
 554
 555 gcc_AC_FUNC_VFPRINTF_DOPRNT
 556 gcc_AC_FUNC_PRINTF_PTR
 557
 558 case "${host}" in
 559 *-*-uwin*)
 560   # Under some versions of uwin, vfork is notoriously buggy and the test
 561   # can hang configure; on other versions, vfork exists just as a stub.
 562   # FIXME: This should be removed once vfork in uwin's runtime is fixed.
 563   ac_cv_func_vfork_works=no
 564   ;;
 565 esac
 566 AC_FUNC_VFORK
 567 AC_FUNC_MMAP_ANYWHERE
 568 AC_FUNC_MMAP_FILE
 569
 570 # We will need to find libiberty.h and ansidecl.h
 571 saved_CFLAGS="$CFLAGS"
 572 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include"
 573 gcc_AC_CHECK_DECLS(bcopy \
 574         getenv atol sbrk abort atof getcwd getwd \
 575         strsignal putc_unlocked fputs_unlocked strstr environ \
 576         malloc realloc calloc free basename getopt, , ,[
 577 #include "gansidecl.h"
 578 #include "system.h"])
 579
 580 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
 581 #include "gansidecl.h"
 582 #include "system.h"
 583 #ifdef HAVE_SYS_RESOURCE_H
 584 #include <sys/resource.h>
 585 #endif
 586 ])
 587
 588 # Restore CFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
 589 CFLAGS="$saved_CFLAGS"
 590
 591 # mkdir takes a single argument on some systems.
 592 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
 593
 594 # File extensions
 595 manext='.1'
 596 objext='.o'
 597 AC_SUBST(manext)
 598 AC_SUBST(objext)
 599
 600 build_xm_file=
 601 build_xm_defines=
 602 build_install_headers_dir=install-headers-tar
 603 build_exeext=
 604 host_xm_file=
 605 host_xm_defines=
 606 host_xmake_file=
 607 host_truncate_target=
 608 host_exeext=
 609
 610 # Decode the host machine, then the target machine.
 611 # For the host machine, we save the xm_file variable as host_xm_file;
 612 # then we decode the target machine and forget everything else
 613 # that came from the host machine.
 614 for machine in $build $host $target; do
 615         . ${srcdir}/config.gcc
 616 done
 617
 618 extra_objs="${host_extra_objs} ${extra_objs}"
 619
 620 # Default the target-machine variables that were not explicitly set.
 621 if test x"$tm_file" = x
 622 then tm_file=$cpu_type/$cpu_type.h; fi
 623
 624 if test x"$extra_headers" = x
 625 then extra_headers=; fi
 626
 627 if test x"$xm_file" = x
 628 then xm_file=$cpu_type/xm-$cpu_type.h; fi
 629
 630 if test x$md_file = x
 631 then md_file=$cpu_type/$cpu_type.md; fi
 632
 633 if test x$out_file = x
 634 then out_file=$cpu_type/$cpu_type.c; fi
 635
 636 if test x"$tmake_file" = x
 637 then tmake_file=$cpu_type/t-$cpu_type
 638 fi
 639
 640 if test x"$dwarf2" = xyes
 641 then tm_file="$tm_file tm-dwarf2.h"
 642 fi
 643
 644 if test x$float_format = x
 645 then float_format=i64
 646 fi
 647
 648 if test $float_format = none
 649 then float_h_file=Makefile.in
 650 else float_h_file=float-$float_format.h
 651 fi
 652
 653 # Handle cpp installation.
 654 if test x$enable_cpp != xno
 655 then
 656   tmake_file="$tmake_file t-install-cpp"
 657 fi
 658
 659 # Say what files are being used for the output code and MD file.
 660 echo "Using \`$srcdir/config/$out_file' to output insns."
 661 echo "Using \`$srcdir/config/$md_file' as machine description file."
 662
 663 count=a
 664 for f in $tm_file; do
 665         count=${count}x
 666 done
 667 if test $count = ax; then
 668         echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
 669 else
 670         echo "Using the following target machine macro files:"
 671         for f in $tm_file; do
 672                 echo "  $srcdir/config/$f"
 673         done
 674 fi
 675
 676 count=a
 677 for f in $host_xm_file; do
 678         count=${count}x
 679 done
 680 if test $count = ax; then
 681         echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
 682 else
 683         echo "Using the following host machine macro files:"
 684         for f in $host_xm_file; do
 685                 echo "  $srcdir/config/$f"
 686         done
 687 fi
 688
 689 if test "$host_xm_file" != "$build_xm_file"; then
 690         count=a
 691         for f in $build_xm_file; do
 692                 count=${count}x
 693         done
 694         if test $count = ax; then
 695                 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
 696         else
 697                 echo "Using the following build machine macro files:"
 698                 for f in $build_xm_file; do
 699                         echo "  $srcdir/config/$f"
 700                 done
 701         fi
 702 fi
 703
 704 if test x$thread_file = x; then
 705         if test x$target_thread_file != x; then
 706                 thread_file=$target_thread_file
 707         else
 708                 thread_file='single'
 709         fi
 710 fi
 711
 712 # Set up the header files.
 713 # $links is the list of header files to create.
 714 # $vars is the list of shell variables with file names to include.
 715 # auto-host.h is the file containing items generated by autoconf and is
 716 # the first file included by config.h.
 717 null_defines=
 718 host_xm_file="auto-host.h gansidecl.h ${host_xm_file} hwint.h"
 719
 720 # If host=build, it is correct to have hconfig include auto-host.h
 721 # as well.  If host!=build, we are in error and need to do more
 722 # work to find out the build config parameters.
 723 if test x$host = x$build
 724 then
 725         build_xm_file="auto-host.h gansidecl.h ${build_xm_file} hwint.h"
 726 else
 727         # We create a subdir, then run autoconf in the subdir.
 728         # To prevent recursion we set host and build for the new
 729         # invocation of configure to the build for this invocation
 730         # of configure.
 731         tempdir=build.$$
 732         rm -rf $tempdir
 733         mkdir $tempdir
 734         cd $tempdir
 735         case ${srcdir} in
 736         /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
 737         *) realsrcdir=../${srcdir};;
 738         esac
 739         CC=${CC_FOR_BUILD} ${realsrcdir}/configure \
 740                 --target=$target --host=$build --build=$build
 741
 742         # We just finished tests for the build machine, so rename
 743         # the file auto-build.h in the gcc directory.
 744         mv auto-host.h ../auto-build.h
 745         cd ..
 746         rm -rf $tempdir
 747         build_xm_file="auto-build.h gansidecl.h ${build_xm_file} hwint.h"
 748 fi
 749
 750 xm_file="gansidecl.h ${xm_file}"
 751 tm_file="gansidecl.h ${tm_file}"
 752
 753 vars="host_xm_file tm_file tm_p_file xm_file build_xm_file"
 754 links="config.h tm.h tm_p.h tconfig.h hconfig.h"
 755 defines="host_xm_defines null_defines null_defines xm_defines build_xm_defines"
 756
 757 rm -f config.bak
 758 if test -f config.status; then mv -f config.status config.bak; fi
 759
 760 # Make the links.
 761 while test -n "$vars"
 762 do
 763         set $vars; var=$1; shift; vars=$*
 764         set $links; link=$1; shift; links=$*
 765         set $defines; define=$1; shift; defines=$*
 766
 767         rm -f $link
 768         # Make sure the file is created, even if it is empty.
 769         echo >$link
 770
 771         # Define TARGET_CPU_DEFAULT if the system wants one.
 772         # This substitutes for lots of *.h files.
 773         if test "$target_cpu_default" != "" -a $link = tm.h
 774         then
 775                 echo "#define TARGET_CPU_DEFAULT ($target_cpu_default)" >>$link
 776         fi
 777         if test $link = tm.h
 778         then
 779                 echo "#ifndef GENERATOR_FILE" >>$link
 780                 echo "#include \"insn-codes.h\"" >>$link
 781                 echo "#endif" >>$link
 782         fi
 783
 784         for file in `eval echo '$'$var`; do
 785                 case $file in
 786                 auto-host.h | auto-build.h )
 787                         ;;
 788                 *)
 789                         echo '#ifdef IN_GCC' >>$link
 790                         ;;
 791                 esac
 792                 echo "#include \"$file\"" >>$link
 793                 case $file in
 794                 auto-host.h | auto-build.h )
 795                         ;;
 796                 *)
 797                         echo '#endif' >>$link
 798                         ;;
 799                 esac
 800         done
 801
 802         for def in `eval echo '$'$define`; do
 803                 echo "#ifndef $def" >>$link
 804                 echo "#define $def" >>$link
 805                 echo "#endif" >>$link
 806         done
 807 done
 808
 809 # Truncate the target if necessary
 810 if test x$host_truncate_target != x; then
 811         target=`echo $target | sed -e 's/\(..............\).*/\1/'`
 812 fi
 813
 814 # Get the version trigger filename from the toplevel
 815 if test "${with_gcc_version_trigger+set}" = set; then
 816         gcc_version_trigger=$with_gcc_version_trigger
 817 else
 818         gcc_version_trigger=${srcdir}/version.c
 819 fi
 820 changequote(,)dnl
 821 gcc_version_full=`grep version_string ${gcc_version_trigger} | sed -e 's/.*\"\([^\"]*\)\".*/\1/'`
 822 gcc_version=`echo ${gcc_version_full} | sed -e 's/\([^ ]*\) .*/\1/'`
 823
 824 # Compile in configure arguments.
 825 if test -f configargs.h ; then
 826         # Being re-configured.
 827         gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*\"\([^\"]*\)\".*/\1/'`
 828         gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
 829 else
 830         gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
 831 fi
 832 cat > configargs.h <<EOF
 833 /* Generated automatically. */
 834 static const char configuration_arguments[] = "$gcc_config_arguments";
 835 EOF
 836 changequote([,])dnl
 837
 838 # Internationalization
 839 PACKAGE=gcc
 840 VERSION="$gcc_version"
 841 AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE",
 842         [Define to the name of the distribution.])
 843 AC_DEFINE_UNQUOTED(VERSION, "$VERSION",
 844         [Define to the version of the distribution.])
 845 AC_SUBST(PACKAGE)
 846 AC_SUBST(VERSION)
 847
 848 ALL_LINGUAS="sv"
 849
 850 # Enable NLS support by default
 851 AC_ARG_ENABLE(nls,
 852   [  --enable-nls            use Native Language Support (default)],
 853   , enable_nls=yes)
 854
 855 # if cross compiling, disable NLS support.
 856 # It's not worth the trouble, at least for now.
 857
 858 if test "${build}" != "${host}" && test "x$enable_nls" = "xyes"; then
 859   AC_MSG_WARN(Disabling NLS support for canadian cross compiler.)
 860   enable_nls=no
 861 fi
 862
 863 # if NLS is enabled, also enable check in po subdir
 864 if test $enable_nls = yes; then
 865   CHECK_PO=check-po
 866 else
 867   CHECK_PO=""
 868 fi
 869
 870 AC_SUBST(CHECK_PO)
 871
 872 AM_GNU_GETTEXT
 873 XGETTEXT="AWK='$AWK' \$(SHELL) \$(top_srcdir)/exgettext $XGETTEXT"
 874
 875 # Windows32 Registry support for specifying GCC installation paths.
 876 AC_ARG_ENABLE(win32-registry,
 877 [  --disable-win32-registry
 878                           Disable lookup of installation paths in the
 879                          Registry on Windows hosts.
 880   --enable-win32-registry Enable registry lookup (default).
 881   --enable-win32-registry=KEY
 882                           Use KEY instead of GCC version as the last portion
 883                          of the registry key.],,)
 884
 885 AC_MSG_CHECKING(whether windows registry support is requested)
 886 if test x$enable_win32_registry != xno; then
 887   AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
 888 [Define to 1 if installation paths should be looked up in Windows32
 889    Registry. Ignored on non windows32 hosts.])
 890   AC_MSG_RESULT(yes)
 891 else
 892   AC_MSG_RESULT(no)
 893 fi
 894
 895 # Check if user specified a different registry key.
 896 case x${enable_win32_registry} in
 897 x | xyes)
 898   # default.
 899   gcc_cv_win32_registry_key="$VERSION"
 900   ;;
 901 xno)
 902   # no registry lookup.
 903   gcc_cv_win32_registry_key=''
 904   ;;
 905 *)
 906   # user-specified key.
 907   gcc_cv_win32_registry_key="$enable_win32_registry"
 908   ;;
 909 esac
 910
 911 if test x$enable_win32_registry != xno; then
 912   AC_MSG_CHECKING(registry key on windows hosts)
 913   AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$gcc_cv_win32_registry_key",
 914         [Define to be the last portion of registry key on windows hosts.])
 915   AC_MSG_RESULT($gcc_cv_win32_registry_key)
 916 fi
 917
 918 # Get an absolute path to the GCC top-level source directory
 919 holddir=`pwd`
 920 cd $srcdir
 921 topdir=`pwd`
 922 cd $holddir
 923
 924 # Conditionalize the makefile for this host machine.
 925 # Make-host contains the concatenation of all host makefile fragments
 926 # [there can be more than one].  This file is built by configure.frag.
 927 host_overrides=Make-host
 928 dep_host_xmake_file=
 929 for f in .. ${host_xmake_file}
 930 do
 931         if test -f ${srcdir}/config/$f
 932         then
 933                 dep_host_xmake_file="${dep_host_xmake_file} ${srcdir}/config/$f"
 934         fi
 935 done
 936
 937 # Conditionalize the makefile for this target machine.
 938 # Make-target contains the concatenation of all host makefile fragments
 939 # [there can be more than one].  This file is built by configure.frag.
 940 target_overrides=Make-target
 941 dep_tmake_file=
 942 for f in .. ${tmake_file}
 943 do
 944         if test -f ${srcdir}/config/$f
 945         then
 946                 dep_tmake_file="${dep_tmake_file} ${srcdir}/config/$f"
 947         fi
 948 done
 949
 950 # If the host doesn't support symlinks, modify CC in
 951 # FLAGS_TO_PASS so CC="stage1/xgcc -Bstage1/" works.
 952 # Otherwise, we can use "CC=$(CC)".
 953 rm -f symtest.tem
 954 if $symbolic_link $srcdir/gcc.c symtest.tem 2>/dev/null
 955 then
 956         cc_set_by_configure="\$(CC)"
 957         quoted_cc_set_by_configure="\$(CC)"
 958         stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
 959 else
 960         rm -f symtest.tem
 961         if cp -p $srcdir/gcc.c symtest.tem 2>/dev/null
 962         then
 963                 symbolic_link="cp -p"
 964         else
 965                 symbolic_link="cp"
 966         fi
 967         cc_set_by_configure="\`case '\$(CC)' in stage*) echo '\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\$(CC)';; esac\`"
 968         quoted_cc_set_by_configure="\\\`case '\\\$(CC)' in stage*) echo '\\\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(CC)';; esac\\\`"
 969         stage_prefix_set_by_configure="\`case '\$(STAGE_PREFIX)' in stage*) echo '\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\$(STAGE_PREFIX)';; esac\`"
 970 fi
 971 rm -f symtest.tem
 972
 973 out_object_file=`basename $out_file .c`.o
 974
 975 tm_file_list=
 976 for f in $tm_file; do
 977   case $f in
 978     gansidecl.h )
 979        tm_file_list="${tm_file_list} $f" ;;
 980     *) tm_file_list="${tm_file_list} \$(srcdir)/config/$f" ;;
 981   esac
 982 done
 983
 984 host_xm_file_list=
 985 for f in $host_xm_file; do
 986   case $f in
 987     auto-host.h | gansidecl.h | hwint.h )
 988        host_xm_file_list="${host_xm_file_list} $f" ;;
 989     *) host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f" ;;
 990   esac
 991 done
 992
 993 build_xm_file_list=
 994 for f in $build_xm_file; do
 995   case $f in
 996     auto-build.h | auto-host.h | gansidecl.h | hwint.h )
 997        build_xm_file_list="${build_xm_file_list} $f" ;;
 998     *) build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f" ;;
 999   esac
1000 done
1001
1002 # Define macro CROSS_COMPILE in compilation
1003 # if this is a cross-compiler.
1004 # Also use all.cross instead of all.internal
1005 # and add cross-make to Makefile.
1006 cross_overrides="/dev/null"
1007 if test x$host != x$target
1008 then
1009         cross_defines="CROSS=-DCROSS_COMPILE"
1010         cross_overrides="${topdir}/cross-make"
1011 fi
1012
1013 # If this is a cross-compiler that does not
1014 # have its own set of headers then define
1015 # inhibit_libc
1016
1017 # If this is using newlib, then define inhibit_libc in
1018 # LIBGCC2_CFLAGS.  This will cause __eprintf to be left out of
1019 # libgcc.a, but that's OK because newlib should have its own version of
1020 # assert.h.
1021 inhibit_libc=
1022 if [test x$host != x$target] && [test x$with_headers = x]; then
1023        inhibit_libc=-Dinhibit_libc
1024 else
1025        if [test x$with_newlib = xyes]; then
1026                inhibit_libc=-Dinhibit_libc
1027        fi
1028 fi
1029 AC_SUBST(inhibit_libc)
1030
1031 # When building gcc with a cross-compiler, we need to fix a few things.
1032 # This must come after cross-make as we want all.build to override
1033 # all.cross.
1034 build_overrides="/dev/null"
1035 if test x$build != x$host
1036 then
1037         build_overrides="${topdir}/build-make"
1038 fi
1039
1040 # Expand extra_headers to include complete path.
1041 # This substitutes for lots of t-* files.
1042 extra_headers_list=
1043 if test "x$extra_headers" = x
1044 then true
1045 else
1046         # Prepend ${srcdir}/ginclude/ to every entry in extra_headers.
1047         for file in $extra_headers;
1048         do
1049                 extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/${file}"
1050         done
1051 fi
1052
1053 if test x$use_collect2 = xno; then
1054         use_collect2=
1055 fi
1056
1057 # Add a definition of USE_COLLECT2 if system wants one.
1058 # Also tell toplev.c what to do.
1059 # This substitutes for lots of t-* files.
1060 if test x$use_collect2 = x
1061 then
1062         will_use_collect2=
1063         maybe_use_collect2=
1064 else
1065         will_use_collect2="collect2"
1066         maybe_use_collect2="-DUSE_COLLECT2"
1067 fi
1068
1069 # If we have gas in the build tree, make a link to it.
1070 if test -f ../gas/Makefile; then
1071         rm -f as; $symbolic_link ../gas/as-new$host_exeext as$host_exeext 2>/dev/null
1072 fi
1073
1074 # If we have nm in the build tree, make a link to it.
1075 if test -f ../binutils/Makefile; then
1076         rm -f nm; $symbolic_link ../binutils/nm-new$host_exeext nm$host_exeext 2>/dev/null
1077 fi
1078
1079 # If we have ld in the build tree, make a link to it.
1080 if test -f ../ld/Makefile; then
1081 #       if test x$use_collect2 = x; then
1082 #               rm -f ld; $symbolic_link ../ld/ld-new$host_exeext ld$host_exeext 2>/dev/null
1083 #       else
1084                 rm -f collect-ld; $symbolic_link ../ld/ld-new$host_exeext collect-ld$host_exeext 2>/dev/null
1085 #       fi
1086 fi
1087
1088 # Figure out what assembler we will be using.
1089 AC_MSG_CHECKING(what assembler to use)
1090 gcc_cv_as=
1091 gcc_cv_gas_major_version=
1092 gcc_cv_gas_minor_version=
1093 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1094 if test -x "$DEFAULT_ASSEMBLER"; then
1095         gcc_cv_as="$DEFAULT_ASSEMBLER"
1096 elif test -x "$AS"; then
1097         gcc_cv_as="$AS"
1098 elif test -x as$host_exeext; then
1099         # Build using assembler in the current directory.
1100         gcc_cv_as=./as$host_exeext
1101 elif test -f $gcc_cv_as_gas_srcdir/configure.in -a -f ../gas/Makefile; then
1102         # Single tree build which includes gas.
1103         for f in $gcc_cv_as_gas_srcdir/configure $gcc_cv_as_gas_srcdir/configure.in $gcc_cv_as_gas_srcdir/Makefile.in
1104         do
1105 changequote(,)dnl
1106                 gcc_cv_gas_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
1107 changequote([,])dnl
1108                 if test x$gcc_cv_gas_version != x; then
1109                         break
1110                 fi
1111         done
1112 changequote(,)dnl
1113         gcc_cv_gas_major_version=`expr "$gcc_cv_gas_version" : "VERSION=\([0-9]*\)"`
1114         gcc_cv_gas_minor_version=`expr "$gcc_cv_gas_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1115 changequote([,])dnl
1116 fi
1117
1118 if test "x$gcc_cv_as" = x -a x$host = x$target; then
1119         # Native build.
1120         # Search the same directories that the installed compiler will
1121         # search.  Else we may find the wrong assembler and lose.  If we
1122         # do not find a suitable assembler binary, then try the user's
1123         # path.
1124         #
1125         # Also note we have to check MD_EXEC_PREFIX before checking the
1126         # user's path.  Unfortunately, there is no good way to get at the
1127         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1128         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1129         # to be fixed as part of the make/configure rewrite too.
1130
1131         if test "x$exec_prefix" = xNONE; then
1132                 if test "x$prefix" = xNONE; then
1133                         test_prefix=/usr/local
1134                 else
1135                         test_prefix=$prefix
1136                 fi
1137         else
1138                 test_prefix=$exec_prefix
1139         fi
1140
1141         # If the loop below does not find an assembler, then use whatever
1142         # one we can find in the users's path.
1143         # user's path.
1144         as=as$host_exeext
1145
1146         test_dirs="$test_prefix/lib/gcc-lib/$target/$gcc_version \
1147                    $test_prefix/lib/gcc-lib/$target \
1148                    /usr/lib/gcc/$target/$gcc_version \
1149                    /usr/lib/gcc/$target \
1150                    $test_prefix/$target/bin/$target/$gcc_version \
1151                    $test_prefix/$target/bin \
1152                    /usr/libexec \
1153                    /usr/ccs/gcc \
1154                    /usr/ccs/bin \
1155                    /udk/usr/ccs/bin \
1156                    /bsd43/usr/lib/cmplrs/cc \
1157                    /usr/cross64/usr/bin \
1158                    /usr/lib/cmplrs/cc \
1159                    /sysv/usr/lib/cmplrs/cc \
1160                    /svr4/usr/lib/cmplrs/cc \
1161                    /usr/bin"
1162
1163         for dir in $test_dirs; do
1164                 if test -f $dir/as$host_exeext; then
1165                         gcc_cv_as=$dir/as$host_exeext
1166                         break;
1167                 fi
1168         done
1169 fi
1170 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1171   AC_MSG_RESULT("newly built gas")
1172 else
1173   AC_MSG_RESULT($gcc_cv_as)
1174 fi
1175
1176 # Figure out what nm we will be using.
1177 AC_MSG_CHECKING(what nm to use)
1178 if test -x nm$host_exeext; then
1179         gcc_cv_nm=./nm$host_exeext
1180 elif test x$host = x$target; then
1181         # Native build.
1182         gcc_cv_nm=nm$host_exeext
1183 fi
1184 AC_MSG_RESULT($gcc_cv_nm)
1185
1186 # Figure out what assembler alignment features are present.
1187 AC_MSG_CHECKING(assembler alignment features)
1188 gcc_cv_as_alignment_features=none
1189 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1190         # Gas version 2.6 and later support for .balign and .p2align.
1191         # bytes to skip when using .p2align.
1192         if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 6 -o "$gcc_cv_gas_major_version" -gt 2; then
1193                 gcc_cv_as_alignment_features=".balign and .p2align"
1194                 AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN)
1195         fi
1196         # Gas version 2.8 and later support specifying the maximum
1197         # bytes to skip when using .p2align.
1198         if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 8 -o "$gcc_cv_gas_major_version" -gt 2; then
1199                 gcc_cv_as_alignment_features=".p2align including maximum skip"
1200                 AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN)
1201         fi
1202 elif test x$gcc_cv_as != x; then
1203         # Check if we have .balign and .p2align
1204         echo ".balign  4" > conftest.s
1205         echo ".p2align  2" >> conftest.s
1206         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1207                 gcc_cv_as_alignment_features=".balign and .p2align"
1208                 AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN)
1209         fi
1210         rm -f conftest.s conftest.o
1211         # Check if specifying the maximum bytes to skip when
1212         # using .p2align is supported.
1213         echo ".p2align 4,,7" > conftest.s
1214         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1215                 gcc_cv_as_alignment_features=".p2align including maximum skip"
1216                 AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN)
1217         fi
1218         rm -f conftest.s conftest.o
1219 fi
1220 AC_MSG_RESULT($gcc_cv_as_alignment_features)
1221
1222 AC_MSG_CHECKING(assembler subsection support)
1223 gcc_cv_as_subsections=no
1224 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1225   if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 9 -o "$gcc_cv_gas_major_version" -gt 2 && grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
1226     gcc_cv_as_subsections="working .subsection -1"
1227   fi
1228 elif test x$gcc_cv_as != x; then
1229         # Check if we have .subsection
1230         echo ".subsection 1" > conftest.s
1231         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1232                 gcc_cv_as_subsections=".subsection"
1233                 if test x$gcc_cv_nm != x; then
1234                         cat > conftest.s <<EOF
1235 conftest_label1: .word 0
1236 .subsection -1
1237 conftest_label2: .word 0
1238 .previous
1239 EOF
1240                         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1241                                 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
1242                                 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
1243                                 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1; then
1244                                         :
1245                                 else
1246                                         gcc_cv_as_subsections="working .subsection -1"
1247                                 fi
1248                         fi
1249                 fi
1250         fi
1251         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1252 fi
1253 if test x"$gcc_cv_as_subsections" = x"working .subsection -1"; then
1254         AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
1255 [Define if your assembler supports .subsection and .subsection -1 starts
1256    emitting at the beginning of your section.])
1257 fi
1258 AC_MSG_RESULT($gcc_cv_as_subsections)
1259
1260 AC_MSG_CHECKING(assembler weak support)
1261 gcc_cv_as_weak=no
1262 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1263   if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 2 -o "$gcc_cv_gas_major_version" -gt 2; then
1264     gcc_cv_as_weak="yes"
1265   fi
1266 elif test x$gcc_cv_as != x; then
1267         # Check if we have .weak
1268         echo "  .weak foobar" > conftest.s
1269         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1270                 gcc_cv_as_weak="yes"
1271         fi
1272         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1273 fi
1274 if test x"$gcc_cv_as_weak" = xyes; then
1275         AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])
1276 fi
1277 AC_MSG_RESULT($gcc_cv_as_weak)
1278
1279 AC_MSG_CHECKING(assembler hidden support)
1280 gcc_cv_as_hidden=no
1281 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1282   if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 10 -o "$gcc_cv_gas_major_version" -gt 2 && grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
1283     gcc_cv_as_hidden="yes"
1284   fi
1285 elif test x$gcc_cv_as != x; then
1286         # Check if we have .hidden
1287         echo "  .hidden foobar" > conftest.s
1288         echo "foobar:" >> conftest.s
1289         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1290                 gcc_cv_as_hidden="yes"
1291         fi
1292         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1293 fi
1294 if test x"$gcc_cv_as_hidden" = xyes; then
1295         AC_DEFINE(HAVE_GAS_HIDDEN, 1,
1296                 [Define if your assembler supports .hidden.])
1297 fi
1298 AC_MSG_RESULT($gcc_cv_as_hidden)
1299
1300 case "$target" in
1301   sparc*-*-*)
1302     AC_CACHE_CHECK([assembler .register pseudo-op support],
1303         gcc_cv_as_register_pseudo_op, [
1304         gcc_cv_as_register_pseudo_op=unknown
1305         if test x$gcc_cv_as != x; then
1306             # Check if we have .register
1307             echo ".register %g2, #scratch" > conftest.s
1308             if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1309                 gcc_cv_as_register_pseudo_op=yes
1310             else
1311                 gcc_cv_as_register_pseudo_op=no
1312             fi
1313             rm -f conftest.s conftest.o
1314         fi
1315     ])
1316     if test "x$gcc_cv_as_register_pseudo_op" = xyes; then
1317         AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
1318                 [Define if your assembler supports .register.])
1319     fi
1320
1321     AC_CACHE_CHECK([assembler supports -relax],
1322         gcc_cv_as_relax_opt, [
1323         gcc_cv_as_relax_opt=unknown
1324         if test x$gcc_cv_as != x; then
1325             # Check if gas supports -relax
1326             echo ".text" > conftest.s
1327             if $gcc_cv_as -relax -o conftest.o conftest.s > /dev/null 2>&1; then
1328                 gcc_cv_as_relax_opt=yes
1329             else
1330                 gcc_cv_as_relax_opt=no
1331             fi
1332             rm -f conftest.s conftest.o
1333         fi
1334     ])
1335     if test "x$gcc_cv_as_relax_opt" = xyes; then
1336         AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
1337                 [Define if your assembler supports -relax option.])
1338     fi
1339
1340     case "$tm_file" in
1341     *64*)
1342         AC_CACHE_CHECK([for 64 bit support in assembler ($gcc_cv_as)],
1343             gcc_cv_as_flags64, [
1344                 if test -n "$gcc_cv_as"; then
1345                     echo ".xword foo" > conftest.s
1346                     gcc_cv_as_flags64=no
1347                     for flag in "-xarch=v9" "-64 -Av9"; do
1348                         if $gcc_cv_as $flag -o conftest.o conftest.s \
1349                             > /dev/null 2>&1; then
1350                             gcc_cv_as_flags64=$flag
1351                             break
1352                         fi
1353                     done
1354                     rm -f conftest.s conftest.o
1355                 else
1356                     if test "$gas" = yes; then
1357                         gcc_cv_as_flags64="-64 -Av9"
1358                     else
1359                         gcc_cv_as_flags64="-xarch=v9"
1360                     fi
1361                 fi
1362         ])
1363         if test "x$gcc_cv_as_flags64" = xno; then
1364 changequote(, )
1365             tmake_file=`echo " $tmake_file " | sed -e 's, sparc/t-sol2-64 , ,' -e 's,^ ,,' -e 's, $,,'`
1366             dep_tmake_file=`echo " $dep_tmake_file " | sed -e 's, [^ ]*/config/sparc/t-sol2-64 , ,' -e 's,^ ,,' -e 's, $,,'`
1367 changequote([, ])
1368         else
1369             AC_DEFINE_UNQUOTED(AS_SPARC64_FLAG, "$gcc_cv_as_flags64",
1370                         [Define if the assembler supports 64bit sparc.])
1371         fi
1372         ;;
1373     *) gcc_cv_as_flags64=${gcc_cv_as_flags64-no}
1374         ;;
1375     esac
1376
1377     if test "x$gcc_cv_as_flags64" != xno; then
1378         AC_CACHE_CHECK([for assembler offsetable %lo() support],
1379             gcc_cv_as_offsetable_lo10, [
1380             gcc_cv_as_offsetable_lo10=unknown
1381             if test "x$gcc_cv_as" != x; then
1382                 # Check if assembler has offsetable %lo()
1383                 echo "or %g1, %lo(ab) + 12, %g1" > conftest.s
1384                 echo "or %g1, %lo(ab + 12), %g1" > conftest1.s
1385                 if $gcc_cv_as $gcc_cv_as_flags64 -o conftest.o conftest.s \
1386                         > /dev/null 2>&1 &&
1387                    $gcc_cv_as $gcc_cv_as_flags64 -o conftest1.o conftest1.s \
1388                         > /dev/null 2>&1; then
1389                     if cmp conftest.o conftest1.o > /dev/null 2>&1; then
1390                         gcc_cv_as_offsetable_lo10=no
1391                     else
1392                         gcc_cv_as_offsetable_lo10=yes
1393                     fi
1394                 else
1395                     gcc_cv_as_offsetable_lo10=no
1396                 fi
1397                 rm -f conftest.s conftest.o conftest1.s conftest1.o
1398             fi
1399         ])
1400         if test "x$gcc_cv_as_offsetable_lo10" = xyes; then
1401             AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
1402                 [Define if your assembler supports offsetable %lo().])
1403         fi
1404     fi
1405     ;;
1406
1407 changequote(,)dnl
1408   i[34567]86-*-*)
1409 changequote([,])dnl
1410     AC_MSG_CHECKING(assembler instructions)
1411     gcc_cv_as_instructions=
1412     if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1413       if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 9 -o "$gcc_cv_gas_major_version" -gt 2; then
1414         gcc_cv_as_instructions="filds fists"
1415       fi
1416     elif test x$gcc_cv_as != x; then
1417         set "filds fists" "filds mem; fists mem"
1418         while test $# -gt 0
1419         do
1420                 echo "$2" > conftest.s
1421                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1422                         gcc_cv_as_instructions=${gcc_cv_as_instructions}$1" "
1423                 fi
1424                 shift 2
1425         done
1426         rm -f conftest.s conftest.o
1427     fi
1428     if test x"$gcc_cv_as_instructions" != x; then
1429         AC_DEFINE_UNQUOTED(HAVE_GAS_`echo "$gcc_cv_as_instructions" | sed -e 's/ $//' | tr '[a-z ]' '[A-Z_]'`)
1430     fi
1431     AC_MSG_RESULT($gcc_cv_as_instructions)
1432     ;;
1433 esac
1434
1435 AC_MSG_CHECKING(assembler dwarf2 debug_line support)
1436 gcc_cv_as_dwarf2_debug_line=no
1437 # ??? Not all targets support dwarf2 debug_line, even within a version
1438 # of gas.  Moreover, we need to emit a valid instruction to trigger any
1439 # info to the output file.  So, as supported targets are added to gas 2.11,
1440 # add some instruction here to (also) show we expect this might work.
1441 # ??? Once 2.11 is released, probably need to add first known working
1442 # version to the per-target configury.
1443 case "$target" in
1444   i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-*)
1445     insn="nop"
1446     ;;
1447   ia64*-*-*)
1448     insn="nop 0"
1449     ;;
1450   esac
1451 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x;
1452 then
1453   if test "$gcc_cv_gas_major_version" -eq 2 \
1454         -a "$gcc_cv_gas_minor_version" -ge 11 \
1455         -o "$gcc_cv_gas_major_version" -gt 2 \
1456      && grep 'obj_format = elf' ../gas/Makefile > /dev/null \
1457      && test x"$insn" != x ; then
1458     gcc_cv_as_dwarf2_debug_line="yes"
1459   fi
1460 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
1461         echo '  .file 0 "conftest.s"' > conftest.s
1462         echo '  .loc 0 3 0' >> conftest.s
1463         echo "  $insn" >> conftest.s
1464         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
1465            && grep debug_line conftest.o > /dev/null 2>&1 ; then
1466                 gcc_cv_as_dwarf2_debug_line="yes"
1467         fi
1468         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1469 fi
1470 if test x"$gcc_cv_as_dwarf2_debug_line" = xyes; then
1471         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
1472           [Define if your assembler supports dwarf2 .file/.loc directives.])
1473 fi
1474 AC_MSG_RESULT($gcc_cv_as_dwarf2_debug_line)
1475
1476 # Figure out what language subdirectories are present.
1477 # Look if the user specified --enable-languages="..."; if not, use
1478 # the environment variable $LANGUAGES if defined. $LANGUAGES might
1479 # go away some day.
1480 if test x"${enable_languages+set}" != xset; then
1481         if test x"${LANGUAGES+set}" = xset; then
1482                 enable_languages="`echo ${LANGUAGES} | tr ' ' ','`"
1483         else
1484                 enable_languages=all
1485         fi
1486 else
1487         if test x"${enable_languages}" = x; then
1488                 AC_MSG_ERROR([--enable-languages needs at least one argument])
1489         fi
1490 fi
1491 subdirs=
1492 for lang in ${srcdir}/*/config-lang.in ..
1493 do
1494         case $lang in
1495         ..) ;;
1496         # The odd quoting in the next line works around
1497         # an apparent bug in bash 1.12 on linux.
1498 changequote(,)dnl
1499         ${srcdir}/[*]/config-lang.in) ;;
1500         *)
1501           lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
1502           if test "x$lang_alias" = x
1503           then
1504                 echo "$lang doesn't set \$language." 1>&2
1505                 exit 1
1506           fi
1507           if test x"${enable_languages}" = xall && test x"${lang_alias}" != xCHILL; then
1508                 add_this_lang=yes
1509           else
1510                 case "${enable_languages}" in
1511                     ${lang_alias} | "${lang_alias},"* | *",${lang_alias},"* | *",${lang_alias}" )
1512                         add_this_lang=yes
1513                         ;;
1514                     * )
1515                         add_this_lang=no
1516                         ;;
1517                 esac
1518           fi
1519           if test x"${add_this_lang}" = xyes; then
1520                 case $lang in
1521                     ${srcdir}/ada/config-lang.in)
1522                         if test x$gnat = xyes ; then
1523                                 subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
1524                         fi
1525                         ;;
1526                     *)
1527                         subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
1528                         ;;
1529                 esac
1530           fi
1531           ;;
1532 changequote([,])dnl
1533         esac
1534 done
1535
1536 # Make gthr-default.h if we have a thread file.
1537 gthread_flags=
1538 if test $thread_file != single; then
1539     rm -f gthr-default.h
1540     echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h
1541     gthread_flags=-DHAVE_GTHR_DEFAULT
1542 fi
1543 AC_SUBST(gthread_flags)
1544
1545 # Find out what GC implementation we want, or may, use.
1546 AC_ARG_WITH(gc,
1547 [  --with-gc={simple,page} Choose the garbage collection mechanism to use
1548                            with the compiler.],
1549 [case "$withval" in
1550   simple | page)
1551     GGC=ggc-$withval
1552     ;;
1553   *)
1554     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
1555     ;;
1556 esac],
1557 [if test $ac_cv_func_mmap_anywhere = yes \
1558     || test $ac_cv_func_valloc = yes; then
1559   GGC=ggc-page
1560 else
1561   GGC=ggc-simple
1562 fi])
1563 AC_SUBST(GGC)
1564 echo "Using $GGC for garbage collection."
1565
1566 # Use the system's zlib library.
1567 zlibdir=-L../zlib
1568 zlibinc="-I\$(srcdir)/../zlib"
1569 AC_ARG_WITH(system-zlib,
1570 [  --with-system-zlib      use installed libz],
1571 zlibdir=
1572 zlibinc=
1573 )
1574 AC_SUBST(zlibdir)
1575 AC_SUBST(zlibinc)
1576
1577 # Build a new-abi (c++) system
1578 AC_ARG_ENABLE(new-gxx-abi,
1579 [  --enable-new-gxx-abi
1580                           select the new abi for g++. You must select an ABI
1581                           at configuration time, so that the correct runtime
1582                           support is built. You cannot mix ABIs.],
1583    ,
1584   enable_new_gxx_abi=yes)
1585
1586 if test x$enable_new_gxx_abi = xyes; then
1587   AC_DEFINE(ENABLE_NEW_GXX_ABI, 1,
1588             [Define if you want to always select the new-abi for g++.])
1589   GXX_ABI_FLAG='-fnew-abi'
1590 else
1591   GXX_ABI_FLAG=
1592 fi
1593 AC_SUBST(GXX_ABI_FLAG)
1594
1595 AC_DEFINE_UNQUOTED(ENABLE_STD_NAMESPACE, $ac_esn,
1596   [Define to 1 if you want to enable namespaces (-fhonor-std) by default.])
1597 AC_SUBST(HAVE_LIBSTDCXX_V3)
1598
1599 dnl Very limited version of automake's enable-maintainer-mode
1600
1601 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
1602   dnl maintainer-mode is disabled by default
1603   AC_ARG_ENABLE(maintainer-mode,
1604 [  --enable-maintainer-mode enable make rules and dependencies not useful
1605                           (and sometimes confusing) to the casual installer],
1606       maintainer_mode=$enableval,
1607       maintainer_mode=no)
1608
1609 AC_MSG_RESULT($maintainer_mode)
1610
1611 if test "$maintainer_mode" = "yes"; then
1612   MAINT=''
1613 else
1614   MAINT='#'
1615 fi
1616 AC_SUBST(MAINT)dnl
1617
1618 # Make empty files to contain the specs and options for each language.
1619 # Then add #include lines to for a compiler that has specs and/or options.
1620
1621 lang_specs_files=
1622 lang_options_files=
1623 lang_tree_files=
1624 rm -f specs.h options.h gencheck.h
1625 touch specs.h options.h gencheck.h
1626 for subdir in . $subdirs
1627 do
1628         if test -f $srcdir/$subdir/lang-specs.h; then
1629                 echo "#include \"$subdir/lang-specs.h\"" >>specs.h
1630                 lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
1631         fi
1632         if test -f $srcdir/$subdir/lang-options.h; then
1633                 echo "#include \"$subdir/lang-options.h\"" >>options.h
1634                 lang_options_files="$lang_options_files $srcdir/$subdir/lang-options.h"
1635         fi
1636         if test -f $srcdir/$subdir/$subdir-tree.def; then
1637                 echo "#include \"$subdir/$subdir-tree.def\"" >>gencheck.h
1638                 lang_tree_files="$lang_tree_files $srcdir/$subdir/$subdir-tree.def"
1639         fi
1640 done
1641
1642 # These (without "all_") are set in each config-lang.in.
1643 # `language' must be a single word so is spelled singularly.
1644 all_languages=
1645 all_boot_languages=
1646 all_compilers=
1647 all_stagestuff=
1648 all_diff_excludes=
1649 all_outputs='Makefile intl/Makefile po/Makefile.in fixinc/Makefile gccbug mklibgcc'
1650 # List of language makefile fragments.
1651 all_lang_makefiles=
1652 all_headers=
1653 all_lib2funcs=
1654
1655 # Add the language fragments.
1656 # Languages are added via two mechanisms.  Some information must be
1657 # recorded in makefile variables, these are defined in config-lang.in.
1658 # We accumulate them and plug them into the main Makefile.
1659 # The other mechanism is a set of hooks for each of the main targets
1660 # like `clean', `install', etc.
1661
1662 language_fragments="Make-lang"
1663 language_hooks="Make-hooks"
1664
1665 for s in .. $subdirs
1666 do
1667         if test $s != ".."
1668         then
1669                 language=
1670                 boot_language=
1671                 compilers=
1672                 stagestuff=
1673                 diff_excludes=
1674                 headers=
1675                 outputs=
1676                 lib2funcs=
1677                 . ${srcdir}/$s/config-lang.in
1678                 if test "x$language" = x
1679                 then
1680                         echo "${srcdir}/$s/config-lang.in doesn't set \$language." 1>&2
1681                         exit 1
1682                 fi
1683                 all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Make-lang.in"
1684                 if test -f ${srcdir}/$s/Makefile.in
1685                 then all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Makefile.in"
1686                 fi
1687                 all_languages="$all_languages $language"
1688                 if test "x$boot_language" = xyes
1689                 then
1690                         all_boot_languages="$all_boot_languages $language"
1691                 fi
1692                 all_compilers="$all_compilers $compilers"
1693                 all_stagestuff="$all_stagestuff $stagestuff"
1694                 all_diff_excludes="$all_diff_excludes $diff_excludes"
1695                 all_headers="$all_headers $headers"
1696                 all_outputs="$all_outputs $outputs"
1697                 all_lib2funcs="$all_lib2funcs $lib2funcs"
1698         fi
1699 done
1700
1701 # Since we can't use `::' targets, we link each language in
1702 # with a set of hooks, reached indirectly via lang.${target}.
1703
1704 rm -f Make-hooks
1705 touch Make-hooks
1706 target_list="all.build all.cross start.encap rest.encap \
1707         info dvi \
1708         install-normal install-common install-info install-man \
1709         uninstall \
1710         mostlyclean clean distclean extraclean maintainer-clean \
1711         stage1 stage2 stage3 stage4"
1712 for t in $target_list
1713 do
1714         x=
1715         for lang in .. $all_languages
1716         do
1717                 if test $lang != ".."; then
1718                         x="$x $lang.$t"
1719                 fi
1720         done
1721         echo "lang.$t: $x" >> Make-hooks
1722 done
1723
1724 # If we're not building in srcdir, create .gdbinit.
1725
1726 if test ! -f Makefile.in; then
1727         echo "dir ." > .gdbinit
1728         echo "dir ${srcdir}" >> .gdbinit
1729         if test x$gdb_needs_out_file_path = xyes
1730         then
1731                 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
1732         fi
1733         if test "x$subdirs" != x; then
1734                 for s in $subdirs
1735                 do
1736                         echo "dir ${srcdir}/$s" >> .gdbinit
1737                 done
1738         fi
1739         echo "source ${srcdir}/.gdbinit" >> .gdbinit
1740 fi
1741
1742 # Define variables host_canonical and build_canonical
1743 # because some Cygnus local changes in the Makefile depend on them.
1744 build_canonical=${build}
1745 host_canonical=${host}
1746 target_subdir=
1747 if test "${host}" != "${target}" ; then
1748     target_subdir=${target}/
1749 fi
1750 AC_SUBST(build_canonical)
1751 AC_SUBST(host_canonical)
1752 AC_SUBST(target_subdir)
1753
1754 # If $(exec_prefix) exists and is not the same as $(prefix), then compute an
1755 # absolute path for gcc_tooldir based on inserting the number of up-directory
1756 # movements required to get from $(exec_prefix) to $(prefix) into the basic
1757 # $(libsubdir)/@(unlibsubdir) based path.
1758 # Don't set gcc_tooldir to tooldir since that's only passed in by the toplevel
1759 # make and thus we'd get different behavior depending on where we built the
1760 # sources.
1761 if test x$exec_prefix = xNONE -o x$exec_prefix = x$prefix; then
1762     gcc_tooldir='$(libsubdir)/$(unlibsubdir)/../$(target_alias)'
1763 else
1764 changequote(<<, >>)dnl
1765 # An explanation of the sed strings:
1766 #  -e 's|^\$(prefix)||'   matches and eliminates 'prefix' from 'exec_prefix'
1767 #  -e 's|/$||'            match a trailing forward slash and eliminates it
1768 #  -e 's|^[^/]|/|'        forces the string to start with a forward slash (*)
1769 #  -e 's|/[^/]*|../|g'    replaces each occurance of /<directory> with ../
1770 #
1771 # (*) Note this pattern overwrites the first character of the string
1772 # with a forward slash if one is not already present.  This is not a
1773 # problem because the exact names of the sub-directories concerned is
1774 # unimportant, just the number of them matters.
1775 #
1776 # The practical upshot of these patterns is like this:
1777 #
1778 #  prefix     exec_prefix        result
1779 #  ------     -----------        ------
1780 #   /foo        /foo/bar          ../
1781 #   /foo/       /foo/bar          ../
1782 #   /foo        /foo/bar/         ../
1783 #   /foo/       /foo/bar/         ../
1784 #   /foo        /foo/bar/ugg      ../../
1785 #
1786     dollar='$$'
1787     gcc_tooldir="\$(libsubdir)/\$(unlibsubdir)/\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/\$(dollar)||' -e 's|^[^/]|/|' -e 's|/[^/]*|../|g'\`\$(target_alias)"
1788 changequote([, ])dnl
1789 fi
1790 AC_SUBST(gcc_tooldir)
1791 AC_SUBST(dollar)
1792
1793 # Nothing to do for FLOAT_H, float_format already handled.
1794 objdir=`pwd`
1795 AC_SUBST(objdir)
1796
1797 # Process the language and host/target makefile fragments.
1798 ${CONFIG_SHELL-/bin/sh} $srcdir/configure.frag $srcdir "$subdirs" "$dep_host_xmake_file" "$dep_tmake_file"
1799
1800 # Substitute configuration variables
1801 AC_SUBST(subdirs)
1802 AC_SUBST(all_boot_languages)
1803 AC_SUBST(all_compilers)
1804 AC_SUBST(all_diff_excludes)
1805 AC_SUBST(all_headers)
1806 AC_SUBST(all_lang_makefiles)
1807 AC_SUBST(all_languages)
1808 AC_SUBST(all_lib2funcs)
1809 AC_SUBST(all_stagestuff)
1810 AC_SUBST(build_exeext)
1811 AC_SUBST(build_install_headers_dir)
1812 AC_SUBST(build_xm_file_list)
1813 AC_SUBST(cc_set_by_configure)
1814 AC_SUBST(quoted_cc_set_by_configure)
1815 AC_SUBST(cpp_install_dir)
1816 AC_SUBST(dep_host_xmake_file)
1817 AC_SUBST(dep_tmake_file)
1818 AC_SUBST(extra_c_flags)
1819 AC_SUBST(extra_headers_list)
1820 AC_SUBST(extra_objs)
1821 AC_SUBST(extra_parts)
1822 AC_SUBST(extra_passes)
1823 AC_SUBST(extra_programs)
1824 AC_SUBST(float_h_file)
1825 AC_SUBST(gcc_config_arguments)
1826 AC_SUBST(gcc_gxx_include_dir)
1827 AC_SUBST(gcc_version)
1828 AC_SUBST(gcc_version_full)
1829 AC_SUBST(gcc_version_trigger)
1830 AC_SUBST(host_exeext)
1831 AC_SUBST(host_extra_gcc_objs)
1832 AC_SUBST(host_xm_file_list)
1833 AC_SUBST(install)
1834 AC_SUBST(lang_options_files)
1835 AC_SUBST(lang_specs_files)
1836 AC_SUBST(lang_tree_files)
1837 AC_SUBST(local_prefix)
1838 AC_SUBST(maybe_use_collect2)
1839 AC_SUBST(md_file)
1840 AC_SUBST(objc_boehm_gc)
1841 AC_SUBST(out_file)
1842 AC_SUBST(out_object_file)
1843 AC_SUBST(stage_prefix_set_by_configure)
1844 AC_SUBST(symbolic_link)
1845 AC_SUBST(thread_file)
1846 AC_SUBST(tm_file_list)
1847 AC_SUBST(will_use_collect2)
1848 AC_SUBST(c_target_objs)
1849 AC_SUBST(cxx_target_objs)
1850
1851
1852 AC_SUBST_FILE(target_overrides)
1853 AC_SUBST_FILE(host_overrides)
1854 AC_SUBST(cross_defines)
1855 AC_SUBST_FILE(cross_overrides)
1856 AC_SUBST_FILE(build_overrides)
1857 AC_SUBST_FILE(language_fragments)
1858 AC_SUBST_FILE(language_hooks)
1859
1860 # Echo that links are built
1861 if test x$host = x$target
1862 then
1863         str1="native "
1864 else
1865         str1="cross-"
1866         str2=" from $host"
1867 fi
1868
1869 if test x$host != x$build
1870 then
1871         str3=" on a $build system"
1872 fi
1873
1874 if test "x$str2" != x || test "x$str3" != x
1875 then
1876         str4=
1877 fi
1878
1879 echo "Links are now set up to build a ${str1}compiler for ${target}$str4" 1>&2
1880
1881 if test "x$str2" != x || test "x$str3" != x
1882 then
1883         echo " ${str2}${str3}." 1>&2
1884 fi
1885
1886 # Truncate the target if necessary
1887 if test x$host_truncate_target != x; then
1888         target=`echo $target | sed -e 's/\(..............\).*/\1/'`
1889 fi
1890
1891 # Configure the subdirectories
1892 # AC_CONFIG_SUBDIRS($subdirs)
1893
1894 # Create the Makefile
1895 # and configure language subdirectories
1896 AC_OUTPUT($all_outputs,
1897 [
1898 case x$CONFIG_HEADERS in
1899 xauto-host.h:config.in)
1900 echo > cstamp-h ;;
1901 esac
1902 # If the host supports symlinks, point stage[1234] at ../stage[1234] so
1903 # bootstrapping and the installation procedure can still use
1904 # CC="stage1/xgcc -Bstage1/".  If the host doesn't support symlinks,
1905 # FLAGS_TO_PASS has been modified to solve the problem there.
1906 # This is virtually a duplicate of what happens in configure.lang; we do
1907 # an extra check to make sure this only happens if ln -s can be used.
1908 if test "$symbolic_link" = "ln -s"; then
1909  for d in .. ${subdirs} ; do
1910    if test $d != ..; then
1911         STARTDIR=`pwd`
1912         cd $d
1913         for t in stage1 stage2 stage3 stage4 include
1914         do
1915                 rm -f $t
1916                 $symbolic_link ../$t $t 2>/dev/null
1917         done
1918         cd $STARTDIR
1919    fi
1920  done
1921 else true ; fi
1922 # Avoid having to add intl to our include paths.
1923 if test -f intl/libintl.h; then
1924   echo creating libintl.h
1925   echo '#include "intl/libintl.h"' >libintl.h
1926 fi
1927 ],
1928 [
1929 host='${host}'
1930 build='${build}'
1931 target='${target}'
1932 target_alias='${target_alias}'
1933 srcdir='${srcdir}'
1934 subdirs='${subdirs}'
1935 symbolic_link='${symbolic_link}'
1936 program_transform_set='${program_transform_set}'
1937 program_transform_name='${program_transform_name}'
1938 dep_host_xmake_file='${dep_host_xmake_file}'
1939 host_xmake_file='${host_xmake_file}'
1940 dep_tmake_file='${dep_tmake_file}'
1941 tmake_file='${tmake_file}'
1942 thread_file='${thread_file}'
1943 gcc_config_arguments='${gcc_config_arguments}'
1944 gcc_version='${gcc_version}'
1945 gcc_version_full='${gcc_version_full}'
1946 gcc_version_trigger='${gcc_version_trigger}'
1947 local_prefix='${local_prefix}'
1948 build_install_headers_dir='${build_install_headers_dir}'
1949 build_exeext='${build_exeext}'
1950 host_exeext='${host_exeext}'
1951 out_file='${out_file}'
1952 gdb_needs_out_file_path='${gdb_needs_out_file_path}'
1953 SET_MAKE='${SET_MAKE}'
1954 target_list='${target_list}'
1955 target_overrides='${target_overrides}'
1956 host_overrides='${host_overrides}'
1957 cross_defines='${cross_defines}'
1958 cross_overrides='${cross_overrides}'
1959 build_overrides='${build_overrides}'
1960 cpp_install_dir='${cpp_install_dir}'
1961 ])