gcc/configure.ac

   1 # configure.ac for GCC
   2 # Process this file with autoconf to generate a configuration script.
   3
   4 # Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
   5 # Free Software Foundation, Inc.
   6
   7 #This file is part of GCC.
   8
   9 #GCC is free software; you can redistribute it and/or modify it under
  10 #the terms of the GNU General Public License as published by the Free
  11 #Software Foundation; either version 2, or (at your option) any later
  12 #version.
  13
  14 #GCC is distributed in the hope that it will be useful, but WITHOUT
  15 #ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 #FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 #for more details.
  18
  19 #You should have received a copy of the GNU General Public License
  20 #along with GCC; see the file COPYING.  If not, write to the Free
  21 #Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  22 #02111-1307, USA.
  23
  24 # --------------------------------
  25 # Initialization and sanity checks
  26 # --------------------------------
  27
  28 AC_PREREQ(2.57)
  29 AC_INIT
  30 AC_CONFIG_SRCDIR(tree.c)
  31 AC_CONFIG_HEADER(auto-host.h:config.in)
  32
  33 # Determine the host, build, and target systems
  34 AC_CANONICAL_BUILD
  35 AC_CANONICAL_HOST
  36 AC_CANONICAL_TARGET
  37
  38 # Determine the noncanonical target name, for directory use.
  39 _GCC_TOPLEV_NONCANONICAL_TARGET
  40
  41 # Determine the target- and build-specific subdirectories
  42 GCC_TOPLEV_SUBDIRS
  43
  44 # Set program_transform_name
  45 AC_ARG_PROGRAM
  46
  47 # Check for bogus environment variables.
  48 # Test if LIBRARY_PATH contains the notation for the current directory
  49 # since this would lead to problems installing/building glibc.
  50 # LIBRARY_PATH contains the current directory if one of the following
  51 # is true:
  52 # - one of the terminals (":" and ";") is the first or last sign
  53 # - two terminals occur directly after each other
  54 # - the path contains an element with a dot in it
  55 AC_MSG_CHECKING(LIBRARY_PATH variable)
  56 changequote(,)dnl
  57 case ${LIBRARY_PATH} in
  58   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
  59     library_path_setting="contains current directory"
  60     ;;
  61   *)
  62     library_path_setting="ok"
  63     ;;
  64 esac
  65 changequote([,])dnl
  66 AC_MSG_RESULT($library_path_setting)
  67 if test "$library_path_setting" != "ok"; then
  68 AC_MSG_ERROR([
  69 *** LIBRARY_PATH shouldn't contain the current directory when
  70 *** building gcc. Please change the environment variable
  71 *** and run configure again.])
  72 fi
  73
  74 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
  75 # since this would lead to problems installing/building glibc.
  76 # GCC_EXEC_PREFIX contains the current directory if one of the following
  77 # is true:
  78 # - one of the terminals (":" and ";") is the first or last sign
  79 # - two terminals occur directly after each other
  80 # - the path contains an element with a dot in it
  81 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
  82 changequote(,)dnl
  83 case ${GCC_EXEC_PREFIX} in
  84   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
  85     gcc_exec_prefix_setting="contains current directory"
  86     ;;
  87   *)
  88     gcc_exec_prefix_setting="ok"
  89     ;;
  90 esac
  91 changequote([,])dnl
  92 AC_MSG_RESULT($gcc_exec_prefix_setting)
  93 if test "$gcc_exec_prefix_setting" != "ok"; then
  94 AC_MSG_ERROR([
  95 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
  96 *** building gcc. Please change the environment variable
  97 *** and run configure again.])
  98 fi
  99
 100 # -----------
 101 # Directories
 102 # -----------
 103
 104 # Specify the local prefix
 105 local_prefix=
 106 AC_ARG_WITH(local-prefix,
 107 [  --with-local-prefix=DIR specifies directory to put local include],
 108 [case "${withval}" in
 109 yes)    AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
 110 no)     ;;
 111 *)      local_prefix=$with_local_prefix ;;
 112 esac])
 113
 114 # Default local prefix if it is empty
 115 if test x$local_prefix = x; then
 116         local_prefix=/usr/local
 117 fi
 118
 119 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
 120 # passed in by the toplevel make and thus we'd get different behavior
 121 # depending on where we built the sources.
 122 gcc_gxx_include_dir=
 123 # Specify the g++ header file directory
 124 AC_ARG_WITH(gxx-include-dir,
 125 [  --with-gxx-include-dir=DIR
 126                           specifies directory to put g++ header files],
 127 [case "${withval}" in
 128 yes)    AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
 129 no)     ;;
 130 *)      gcc_gxx_include_dir=$with_gxx_include_dir ;;
 131 esac])
 132
 133 if test x${gcc_gxx_include_dir} = x; then
 134   if test x${enable_version_specific_runtime_libs} = xyes; then
 135     gcc_gxx_include_dir='${libsubdir}/include/c++'
 136   else
 137     topsrcdir=${srcdir}/.. . ${srcdir}/../config.if
 138 changequote(<<, >>)dnl
 139     gcc_gxx_include_dir="\$(libsubdir)/\$(unlibsubdir)/..\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/[^/]*|/..|g'\`/include/"${libstdcxx_incdir}
 140 changequote([, ])dnl
 141   fi
 142 fi
 143
 144 AC_ARG_WITH(cpp_install_dir,
 145 [  --with-cpp-install-dir=DIR
 146                           install the user visible C preprocessor in DIR
 147                           (relative to PREFIX) as well as PREFIX/bin],
 148 [if test x$withval = xyes; then
 149   AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
 150 elif test x$withval != xno; then
 151   cpp_install_dir=$withval
 152 fi])
 153
 154 # We would like to our source tree to be readonly.  However when releases or
 155 # pre-releases are generated, the flex/bison generated files as well as the
 156 # various formats of manuals need to be included along with the rest of the
 157 # sources.  Therefore we have --enable-generated-files-in-srcdir to do
 158 # just that.
 159
 160 AC_MSG_CHECKING([whether to place generated files in the source directory])
 161   dnl generated-files-in-srcdir is disabled by default
 162   AC_ARG_ENABLE(generated-files-in-srcdir,
 163 [  --enable-generated-files-in-srcdir
 164                           put copies of generated files in source dir
 165                           intended for creating source tarballs for users
 166                           without texinfo bison or flex.],
 167       generated_files_in_srcdir=$enableval,
 168       generated_files_in_srcdir=no)
 169
 170 AC_MSG_RESULT($generated_files_in_srcdir)
 171
 172 if test "$generated_files_in_srcdir" = "yes"; then
 173   GENINSRC=''
 174   docobjdir='$(srcdir)/doc'
 175 else
 176   GENINSRC='#'
 177   docobjdir='$(objdir)/doc'
 178 fi
 179 AC_SUBST(GENINSRC)
 180
 181 # -------------------
 182 # Find default linker
 183 # -------------------
 184
 185 # With GNU ld
 186 AC_ARG_WITH(gnu-ld,
 187 [  --with-gnu-ld           arrange to work with GNU ld.],
 188 gnu_ld_flag="$with_gnu_ld",
 189 gnu_ld_flag=no)
 190
 191 # With pre-defined ld
 192 AC_ARG_WITH(ld,
 193 [  --with-ld               arrange to use the specified ld (full pathname)],
 194 DEFAULT_LINKER="$with_ld")
 195 if test x"${DEFAULT_LINKER+set}" = x"set"; then
 196   if test ! -x "$DEFAULT_LINKER"; then
 197     AC_MSG_WARN([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
 198   elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
 199     gnu_ld_flag=yes
 200   fi
 201   AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
 202         [Define to enable the use of a default linker.])
 203 fi
 204
 205 AC_MSG_CHECKING([whether a default linker was specified])
 206 if test x"${DEFAULT_LINKER+set}" = x"set"; then
 207   if test x"$gnu_ld_flag" = x"no"; then
 208     AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
 209   else
 210     AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
 211   fi
 212 else
 213   AC_MSG_RESULT(no)
 214 fi
 215
 216 # ----------------------
 217 # Find default assembler
 218 # ----------------------
 219
 220 # With GNU as
 221 AC_ARG_WITH(gnu-as,
 222 [  --with-gnu-as           arrange to work with GNU as],
 223 gas_flag="$with_gnu_as",
 224 gas_flag=no)
 225
 226 AC_ARG_WITH(as,
 227 [  --with-as               arrange to use the specified as (full pathname)],
 228 DEFAULT_ASSEMBLER="$with_as")
 229 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
 230   if test ! -x "$DEFAULT_ASSEMBLER"; then
 231     AC_MSG_WARN([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
 232   elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
 233     gas_flag=yes
 234   fi
 235   AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
 236         [Define to enable the use of a default assembler.])
 237 fi
 238
 239 AC_MSG_CHECKING([whether a default assembler was specified])
 240 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
 241   if test x"$gas_flag" = x"no"; then
 242     AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
 243   else
 244     AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
 245   fi
 246 else
 247   AC_MSG_RESULT(no)
 248 fi
 249
 250 # ---------------
 251 # Find C compiler
 252 # ---------------
 253
 254 # Find the native compiler
 255 AC_PROG_CC
 256 AC_PROG_CC_C_O
 257 # autoconf is lame and doesn't give us any substitution variable for this.
 258 if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = no"; then
 259   NO_MINUS_C_MINUS_O=yes
 260 else
 261   OUTPUT_OPTION='-o $@'
 262 fi
 263 AC_SUBST(NO_MINUS_C_MINUS_O)
 264 AC_SUBST(OUTPUT_OPTION)
 265
 266 # -------------------------
 267 # Check C compiler features
 268 # -------------------------
 269
 270 AC_CACHE_CHECK(whether ${CC-cc} accepts -Wno-long-long,
 271 ac_cv_prog_cc_no_long_long,
 272 [save_CFLAGS="$CFLAGS"
 273 CFLAGS="-Wno-long-long"
 274 AC_TRY_COMPILE(,,ac_cv_prog_cc_no_long_long=yes,
 275                ac_cv_prog_cc_no_long_long=no)
 276 CFLAGS="$save_CFLAGS"])
 277
 278 AC_PROG_CPP
 279 AC_C_INLINE
 280
 281 gcc_AC_C_LONG_LONG
 282 gcc_AC_C__BOOL
 283
 284 # sizeof(char) is 1 by definition.
 285 AC_COMPILE_CHECK_SIZEOF(void *)
 286 AC_COMPILE_CHECK_SIZEOF(short)
 287 AC_COMPILE_CHECK_SIZEOF(int)
 288 AC_COMPILE_CHECK_SIZEOF(long)
 289 if test $ac_cv_c_long_long = yes; then
 290   AC_COMPILE_CHECK_SIZEOF(long long)
 291 fi
 292 if test $ac_cv_c___int64 = yes; then
 293   AC_COMPILE_CHECK_SIZEOF(__int64)
 294 fi
 295
 296 # -----------------
 297 # Find Ada compiler
 298 # -----------------
 299
 300 # See if GNAT has been installed
 301 gcc_AC_PROG_GNAT
 302
 303 # ---------------------
 304 # Warnings and checking
 305 # ---------------------
 306
 307 strict1_warn=
 308 if test $ac_cv_prog_cc_no_long_long = yes ; then
 309   strict1_warn="-pedantic -Wno-long-long"
 310 fi
 311 AC_SUBST(strict1_warn)
 312
 313 # If the native compiler is GCC, we can enable warnings even in stage1.
 314 # That's useful for people building cross-compilers, or just running a
 315 # quick `make'.
 316 warn_cflags=
 317 if test "x$GCC" = "xyes"; then
 318   warn_cflags='$(GCC_WARN_CFLAGS)'
 319 fi
 320 AC_SUBST(warn_cflags)
 321
 322 # Enable -Werror in bootstrap stage2 and later.
 323 # Change the default to "no" on release branches.
 324 AC_ARG_ENABLE(werror,
 325 [  --enable-werror         enable -Werror in bootstrap stage2 and later], [],
 326 [enable_werror=yes])
 327 if test x$enable_werror = xyes ; then
 328   WERROR=-Werror
 329 fi
 330 AC_SUBST(WERROR)
 331
 332 # Enable expensive internal checks
 333 AC_ARG_ENABLE(checking,
 334 [  --enable-checking[=LIST]
 335                           enable expensive run-time checks.  With LIST,
 336                           enable only specific categories of checks.
 337                           Categories are: misc,tree,rtl,rtlflag,gc,gcac,fold;
 338                           default is misc,tree,gc,rtlflag],
 339 [ac_checking=
 340 ac_tree_checking=
 341 ac_rtl_checking=
 342 ac_rtlflag_checking=
 343 ac_gc_checking=
 344 ac_gc_always_collect=
 345 ac_fold_checking=
 346 case "${enableval}" in
 347 yes)    ac_checking=1 ; ac_tree_checking=1 ; ac_gc_checking=1 ;
 348         ac_rtlflag_checking=1 ;;
 349 no)     ;;
 350 *)      IFS="${IFS=     }"; ac_save_IFS="$IFS"; IFS="$IFS,"
 351         set fnord $enableval; shift
 352         IFS="$ac_save_IFS"
 353         for check
 354         do
 355                 case $check in
 356                 misc)   ac_checking=1 ;;
 357                 tree)   ac_tree_checking=1 ;;
 358                 rtlflag)        ac_rtlflag_checking=1 ;;
 359                 rtl)    ac_rtl_checking=1 ;;
 360                 gc)     ac_gc_checking=1 ;;
 361                 gcac)   ac_gc_always_collect=1 ;;
 362                 fold)   ac_fold_checking=1 ;;
 363                 valgrind)       ac_checking_valgrind=1 ;;
 364                 *)      AC_MSG_ERROR(unknown check category $check) ;;
 365                 esac
 366         done
 367         ;;
 368 esac
 369 ],
 370 # Enable some checks by default for development versions of GCC
 371 [ac_checking=1; ac_tree_checking=1; ac_gc_checking=1; ac_rtlflag_checking=1;])
 372 nocommon_flag=""
 373 if test x$ac_checking != x ; then
 374   AC_DEFINE(ENABLE_CHECKING, 1,
 375 [Define if you want more run-time sanity checks.  This one gets a grab
 376    bag of miscellaneous but relatively cheap checks.])
 377   nocommon_flag=-fno-common
 378 fi
 379 AC_SUBST(nocommon_flag)
 380 if test x$ac_tree_checking != x ; then
 381   AC_DEFINE(ENABLE_TREE_CHECKING, 1,
 382 [Define if you want all operations on trees (the basic data
 383    structure of the front ends) to be checked for dynamic type safety
 384    at runtime.  This is moderately expensive.])
 385 fi
 386 if test x$ac_rtl_checking != x ; then
 387   AC_DEFINE(ENABLE_RTL_CHECKING, 1,
 388 [Define if you want all operations on RTL (the basic data structure
 389    of the optimizer and back end) to be checked for dynamic type safety
 390    at runtime.  This is quite expensive.])
 391 fi
 392 if test x$ac_rtlflag_checking != x ; then
 393   AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
 394 [Define if you want RTL flag accesses to be checked against the RTL
 395    codes that are supported for each access macro.  This is relatively
 396    cheap.])
 397 fi
 398 if test x$ac_gc_checking != x ; then
 399   AC_DEFINE(ENABLE_GC_CHECKING, 1,
 400 [Define if you want the garbage collector to do object poisoning and
 401    other memory allocation checks.  This is quite expensive.])
 402 fi
 403 if test x$ac_gc_always_collect != x ; then
 404   AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
 405 [Define if you want the garbage collector to operate in maximally
 406    paranoid mode, validating the entire heap and collecting garbage at
 407    every opportunity.  This is extremely expensive.])
 408 fi
 409 if test x$ac_fold_checking != x ; then
 410   AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
 411 [Define if you want fold checked that it never destructs its argument.
 412    This is quite expensive.])
 413 fi
 414 valgrind_path_defines=
 415 valgrind_command=
 416
 417 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
 418 dnl # an if statement.  This was the source of very frustrating bugs
 419 dnl # in converting to autoconf 2.5x!
 420 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
 421
 422 if test x$ac_checking_valgrind != x ; then
 423   # It is certainly possible that there's valgrind but no valgrind.h.
 424   # GCC relies on making annotations so we must have both.
 425   AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
 426   AC_TRY_CPP(
 427     [#include <valgrind/memcheck.h>
 428 #ifndef VALGRIND_DISCARD
 429 #error VALGRIND_DISCARD not defined
 430 #endif],
 431   [gcc_cv_header_valgrind_memcheck_h=yes],
 432   [gcc_cv_header_valgrind_memcheck_h=no])
 433   AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
 434   AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
 435   AC_TRY_CPP(
 436     [#include <memcheck.h>
 437 #ifndef VALGRIND_DISCARD
 438 #error VALGRIND_DISCARD not defined
 439 #endif],
 440   [gcc_cv_header_memcheck_h=yes],
 441   gcc_cv_header_memcheck_h=no)
 442   AC_MSG_RESULT($gcc_cv_header_memcheck_h)
 443   AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
 444         [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
 445   if test "x$valgrind_path" = "x" \
 446     || (test $have_valgrind_h = no \
 447         && test $gcc_cv_header_memcheck_h = no \
 448         && test $gcc_cv_header_valgrind_memcheck_h = no); then
 449         AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
 450   fi
 451   valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
 452   valgrind_command="$valgrind_path -q"
 453   AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
 454 [Define if you want to run subprograms and generated programs
 455    through valgrind (a memory checker).  This is extremely expensive.])
 456   if test $gcc_cv_header_valgrind_memcheck_h = yes; then
 457     AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
 458         [Define if valgrind's valgrind/memcheck.h header is installed.])
 459   fi
 460   if test $gcc_cv_header_memcheck_h = yes; then
 461     AC_DEFINE(HAVE_MEMCHECK_H, 1,
 462         [Define if valgrind's memcheck.h header is installed.])
 463   fi
 464 fi
 465 AC_SUBST(valgrind_path_defines)
 466 AC_SUBST(valgrind_command)
 467
 468 # Enable code coverage collection
 469 AC_ARG_ENABLE(coverage,
 470 [  --enable-coverage[=LEVEL]
 471                           enable compiler\'s code coverage collection.
 472                           Use to measure compiler performance and locate
 473                           unused parts of the compiler. With LEVEL, specify
 474                           optimization. Values are opt, noopt,
 475                           default is noopt],
 476 [case "${enableval}" in
 477 yes|noopt)
 478         coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
 479         ;;
 480 opt)
 481         coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
 482         ;;
 483 *)
 484         AC_MSG_ERROR(unknown coverage setting $enableval)
 485         ;;
 486 esac],
 487 [coverage_flags=""])
 488 AC_SUBST(coverage_flags)
 489
 490 AC_ARG_ENABLE(gather-detailed-mem-stats,
 491 [  --enable-gather-detailed-mem-stats         enable detailed memory allocation stats gathering], [],
 492 [enable_gather_detailed_mem_stats=no])
 493 if test x$enable_gather_detailed_mem_stats = xyes ; then
 494   AC_DEFINE(GATHER_STATISTICS, 1,
 495         [Define to enable detailed memory allocation stats gathering.])
 496 fi
 497
 498 # -------------------------------
 499 # Miscenalleous configure options
 500 # -------------------------------
 501
 502 # With stabs
 503 AC_ARG_WITH(stabs,
 504 [  --with-stabs            arrange to use stabs instead of host debug format],
 505 stabs="$with_stabs",
 506 stabs=no)
 507
 508 # Determine whether or not multilibs are enabled.
 509 AC_ARG_ENABLE(multilib,
 510 [  --enable-multilib       enable library support for multiple ABIs],
 511 [], [enable_multilib=yes])
 512 AC_SUBST(enable_multilib)
 513
 514 # Enable __cxa_atexit for C++.
 515 AC_ARG_ENABLE(__cxa_atexit,
 516 [  --enable-__cxa_atexit   enable __cxa_atexit for C++],
 517 [], [])
 518
 519 # Enable threads
 520 # Pass with no value to take the default
 521 # Pass with a value to specify a thread package
 522 AC_ARG_ENABLE(threads,
 523 [  --enable-threads        enable thread usage for target GCC
 524   --enable-threads=LIB    use LIB thread package for target GCC],,
 525 enable_threads='')
 526 # Save in case it gets overwritten in config.gcc
 527 enable_threads_flag=$enable_threads
 528
 529 AC_ARG_ENABLE(objc-gc,
 530 [  --enable-objc-gc       enable the use of Boehm's garbage collector with
 531                           the GNU Objective-C runtime],
 532 if test x$enable_objc_gc = xno; then
 533         objc_boehm_gc=''
 534 else
 535         objc_boehm_gc=1
 536 fi,
 537 objc_boehm_gc='')
 538
 539 AC_ARG_WITH(dwarf2,
 540 [  --with-dwarf2           force the default debug format to be DWARF 2],
 541 dwarf2="$with_dwarf2",
 542 dwarf2=no)
 543
 544 AC_ARG_ENABLE(shared,
 545 [  --disable-shared        don't provide a shared libgcc],
 546 [
 547   case $enable_shared in
 548   yes | no) ;;
 549   *)
 550     enable_shared=no
 551     IFS="${IFS=         }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
 552     for pkg in $enableval; do
 553       if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
 554         enable_shared=yes
 555       fi
 556     done
 557     IFS="$ac_save_ifs"
 558     ;;
 559   esac
 560 ], [enable_shared=yes])
 561 AC_SUBST(enable_shared)
 562
 563 AC_ARG_WITH(sysroot,
 564 [  --with-sysroot[=DIR] Search for usr/lib, usr/include, et al, within DIR.],
 565 [
 566  case ${with_sysroot} in
 567  yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
 568  *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
 569  esac
 570
 571  TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
 572  CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR)'
 573
 574  if test "x$exec_prefix" = xNONE; then
 575   if test "x$prefix" = xNONE; then
 576    test_prefix=/usr/local
 577   else
 578    test_prefix=$prefix
 579   fi
 580  else
 581   test_prefix=$exec_prefix
 582  fi
 583  case ${TARGET_SYSTEM_ROOT} in
 584  "${test_prefix}"|"${test_prefix}/"*|\
 585  '${exec_prefix}'|'${exec_prefix}/'*)
 586    t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
 587    TARGET_SYSTEM_ROOT_DEFINE="$t"
 588    ;;
 589  esac
 590 ], [
 591  TARGET_SYSTEM_ROOT=
 592  TARGET_SYSTEM_ROOT_DEFINE=
 593  CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
 594 ])
 595 AC_SUBST(TARGET_SYSTEM_ROOT)
 596 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
 597 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
 598
 599 # Build with intermodule optimisations
 600 AC_ARG_ENABLE(intermodule,
 601 [  --enable-intermodule    build the compiler in one step],
 602 [case ${enable_intermodule} in
 603   yes) onestep="-onestep";;
 604   *) onestep="";;
 605 esac],
 606 [onestep=""])
 607 AC_SUBST(onestep)
 608
 609 # -------------------------
 610 # Checks for other programs
 611 # -------------------------
 612
 613 AC_PROG_MAKE_SET
 614
 615 # Find some useful tools
 616 AC_PROG_AWK
 617 # We need awk to run opts.sh (to create options.c and options.h).
 618 # Bail out if it's missing.
 619 case ${AWK} in
 620   "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
 621 esac
 622
 623 gcc_AC_PROG_LN
 624 gcc_AC_PROG_LN_S
 625 AC_PROG_RANLIB
 626 gcc_AC_PROG_INSTALL
 627
 628 # See if cmp has --ignore-initial.
 629 gcc_AC_PROG_CMP_IGNORE_INITIAL
 630
 631 # See if we have the mktemp command.
 632 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
 633
 634 # Do we have a single-tree copy of texinfo?
 635 if test -f $srcdir/../texinfo/Makefile.in; then
 636   MAKEINFO='$(objdir)/../texinfo/makeinfo/makeinfo'
 637   gcc_cv_prog_makeinfo_modern=yes
 638   AC_MSG_RESULT([Using makeinfo from the unified source tree.])
 639 else
 640   # See if makeinfo has been installed and is modern enough
 641   # that we can use it.
 642   gcc_AC_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
 643   [GNU texinfo.* \([0-9][0-9.]*\)],
 644   [4.[2-9]*])
 645 fi
 646
 647 if test $gcc_cv_prog_makeinfo_modern = no; then
 648   AC_MSG_WARN([
 649 *** Makeinfo is missing or too old.
 650 *** Info documentation will not be built.])
 651   BUILD_INFO=
 652 else
 653   BUILD_INFO=info               AC_SUBST(BUILD_INFO)
 654 fi
 655
 656 # Is pod2man recent enough to regenerate manpages?
 657 AC_MSG_CHECKING([for recent Pod::Man])
 658 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
 659   AC_MSG_RESULT(yes)
 660   GENERATED_MANPAGES=generated-manpages         AC_SUBST(GENERATED_MANPAGES)
 661 else
 662   AC_MSG_RESULT(no)
 663   GENERATED_MANPAGES=
 664 fi
 665
 666 # How about lex?
 667 dnl Don't use AC_PROG_LEX; we insist on flex.
 668 dnl LEXLIB is not useful in gcc.
 669 if test -f $srcdir/../flex/skel.c; then
 670   FLEX='$(objdir)/../flex/flex'
 671 else
 672   AC_CHECK_PROG(FLEX, flex, flex, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing flex)
 673 fi
 674
 675 # Bison?
 676 # The -L switch is so bison can find its skeleton file.
 677 if test -f $srcdir/../bison/bison.simple; then
 678   BISON='$(objdir)/../bison/bison -L $(srcdir)/../bison/'
 679 else
 680   AC_CHECK_PROG(BISON, bison, bison, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing bison)
 681 fi
 682
 683 # --------------------
 684 # Checks for C headers
 685 # --------------------
 686
 687 AC_MSG_CHECKING(for GNU C library)
 688 AC_CACHE_VAL(gcc_cv_glibc,
 689 [AC_TRY_COMPILE(
 690   [#include <features.h>],[
 691 #if ! (defined __GLIBC__ || defined __GNU_LIBRARY__)
 692 #error Not a GNU C library system
 693 #endif],
 694   [gcc_cv_glibc=yes],
 695   gcc_cv_glibc=no)])
 696 AC_MSG_RESULT($gcc_cv_glibc)
 697 if test $gcc_cv_glibc = yes; then
 698   AC_DEFINE(_GNU_SOURCE, 1, [Always define this when using the GNU C Library])
 699 fi
 700
 701 # Need to reject headers which give warnings, so that the -Werror bootstrap
 702 # works later. *sigh*  This needs to come before all header checks.
 703 AC_PROG_CPP_WERROR
 704
 705 AC_HEADER_STDC
 706 AC_HEADER_TIME
 707 gcc_AC_HEADER_STDBOOL
 708 gcc_AC_HEADER_STRING
 709 AC_HEADER_SYS_WAIT
 710 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h \
 711                  fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
 712                  sys/resource.h sys/param.h sys/times.h sys/stat.h \
 713                  direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
 714
 715 # Check for thread headers.
 716 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
 717 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
 718
 719 # These tests can't be done till we know if we have limits.h.
 720 gcc_AC_C_CHAR_BIT
 721 AC_C_BIGENDIAN_CROSS
 722
 723 # --------
 724 # UNSORTED
 725 # --------
 726
 727 # Stage specific cflags for build.
 728 stage1_cflags=
 729 case $build in
 730 vax-*-*)
 731   if test x$GCC = xyes
 732   then
 733     stage1_cflags="-Wa,-J"
 734   else
 735     stage1_cflags="-J"
 736   fi
 737   ;;
 738 powerpc-*-darwin*)
 739   # The spiffy cpp-precomp chokes on some legitimate constructs in GCC
 740   # sources; use -no-cpp-precomp to get to GNU cpp.
 741   # Apple's GCC has bugs in designated initializer handling, so disable
 742   # that too.
 743   stage1_cflags="-no-cpp-precomp -DHAVE_DESIGNATED_INITIALIZERS=0"
 744   ;;
 745 esac
 746 AC_SUBST(stage1_cflags)
 747
 748 # These libraries may be used by collect2.
 749 # We may need a special search path to get them linked.
 750 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
 751 [save_LIBS="$LIBS"
 752 for libs in '' -lld -lmld \
 753                 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
 754                 '-L/usr/lib/cmplrs/cc3.11 -lmld'
 755 do
 756         LIBS="$libs"
 757         AC_TRY_LINK_FUNC(ldopen,
 758                 [gcc_cv_collect2_libs="$libs"; break])
 759 done
 760 LIBS="$save_LIBS"
 761 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
 762 case $gcc_cv_collect2_libs in
 763         "none required")        ;;
 764         *)      COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
 765 esac
 766 AC_SUBST(COLLECT2_LIBS)
 767
 768 # When building Ada code on Alpha, we need exc_resume which is usually in
 769 # -lexc.  So test for it.
 770 save_LIBS="$LIBS"
 771 LIBS=
 772 AC_SEARCH_LIBS(exc_resume, exc)
 773 GNAT_LIBEXC="$LIBS"
 774 LIBS="$save_LIBS"
 775 AC_SUBST(GNAT_LIBEXC)
 776
 777 # Some systems put ldexp and frexp in libm instead of libc; assume
 778 # they're both in the same place.  jcf-dump needs them.
 779 save_LIBS="$LIBS"
 780 LIBS=
 781 AC_SEARCH_LIBS(ldexp, m)
 782 LDEXP_LIB="$LIBS"
 783 LIBS="$save_LIBS"
 784 AC_SUBST(LDEXP_LIB)
 785
 786 # Use <inttypes.h> only if it exists,
 787 # doesn't clash with <sys/types.h>, and declares intmax_t.
 788 AC_MSG_CHECKING(for inttypes.h)
 789 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
 790 [AC_TRY_COMPILE(
 791   [#include <sys/types.h>
 792 #include <inttypes.h>],
 793   [intmax_t i = -1;],
 794   [gcc_cv_header_inttypes_h=yes],
 795   gcc_cv_header_inttypes_h=no)])
 796 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
 797 if test $gcc_cv_header_inttypes_h = yes; then
 798   AC_DEFINE(HAVE_INTTYPES_H, 1,
 799         [Define if you have a working <inttypes.h> header file.])
 800 fi
 801
 802 dnl Disabled until we have a complete test for buggy enum bitfields.
 803 dnl gcc_AC_C_ENUM_BF_UNSIGNED
 804
 805 AC_CHECK_FUNCS(times clock dup2 kill getrlimit setrlimit atoll atoq \
 806         sysconf strsignal putc_unlocked fputc_unlocked fputs_unlocked \
 807         fwrite_unlocked fprintf_unlocked getrusage nl_langinfo \
 808         scandir alphasort gettimeofday mbstowcs wcswidth mmap mincore \
 809         setlocale)
 810
 811 if test x$ac_cv_func_mbstowcs = xyes; then
 812   AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
 813 [    AC_TRY_RUN([#include <stdlib.h>
 814 int main()
 815 {
 816   mbstowcs(0, "", 0);
 817   return 0;
 818 }],
 819     gcc_cv_func_mbstowcs_works=yes,
 820     gcc_cv_func_mbstowcs_works=no,
 821     gcc_cv_func_mbstowcs_works=yes)])
 822   if test x$gcc_cv_func_mbstowcs_works = xyes; then
 823     AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
 824   [Define this macro if mbstowcs does not crash when its
 825    first argument is NULL.])
 826   fi
 827 fi
 828
 829 AC_CHECK_TYPE(ssize_t, int)
 830
 831 # Try to determine the array type of the second argument of getgroups
 832 # for the target system (int or gid_t).
 833 AC_TYPE_GETGROUPS
 834 if test "${target}" = "${build}"; then
 835   TARGET_GETGROUPS_T=$ac_cv_type_getgroups
 836 else
 837   case "${target}" in
 838         # This condition may need some tweaking.  It should include all
 839         # targets where the array type of the second argument of getgroups
 840         # is int and the type of gid_t is not equivalent to int.
 841         *-*-sunos* | *-*-ultrix*)
 842                 TARGET_GETGROUPS_T=int
 843                 ;;
 844         *)
 845                 TARGET_GETGROUPS_T=gid_t
 846                 ;;
 847   esac
 848 fi
 849 AC_SUBST(TARGET_GETGROUPS_T)
 850
 851 gcc_AC_FUNC_PRINTF_PTR
 852 gcc_AC_FUNC_MMAP_BLACKLIST
 853
 854 case "${host}" in
 855 *-*-*vms*)
 856   # Under VMS, vfork works very differently than on Unix. The standard test
 857   # won't work, and it isn't easily adaptable. It makes more sense to
 858   # just force it.
 859   ac_cv_func_vfork_works=yes
 860   ;;
 861 esac
 862 AC_FUNC_VFORK
 863
 864 AM_ICONV
 865 # Until we have in-tree GNU iconv:
 866 LIBICONV_DEP=
 867 AC_SUBST(LIBICONV_DEP)
 868
 869 AM_LC_MESSAGES
 870
 871 # We will need to find libiberty.h and ansidecl.h
 872 saved_CFLAGS="$CFLAGS"
 873 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include"
 874 gcc_AC_CHECK_DECLS(getenv atol sbrk abort atof getcwd getwd \
 875         strsignal putc_unlocked fputs_unlocked fwrite_unlocked \
 876         fprintf_unlocked strstr errno snprintf vasprintf \
 877         malloc realloc calloc free basename getopt clock, , ,[
 878 #include "ansidecl.h"
 879 #include "system.h"])
 880
 881 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
 882 #include "ansidecl.h"
 883 #include "system.h"
 884 #ifdef HAVE_SYS_RESOURCE_H
 885 #include <sys/resource.h>
 886 #endif
 887 ])
 888
 889 AC_TRY_COMPILE([
 890 #include "ansidecl.h"
 891 #include "system.h"
 892 #ifdef HAVE_SYS_RESOURCE_H
 893 #include <sys/resource.h>
 894 #endif
 895 ],[rlim_t l = 0;],,[AC_DEFINE([rlim_t],[long],
 896 [Define to \`long' if <sys/resource.h> doesn't define.])])
 897
 898 gcc_AC_CHECK_DECLS(ldgetname, , ,[
 899 #include "ansidecl.h"
 900 #include "system.h"
 901 #ifdef HAVE_LDFCN_H
 902 #include <ldfcn.h>
 903 #endif
 904 ])
 905
 906 gcc_AC_CHECK_DECLS(times, , ,[
 907 #include "ansidecl.h"
 908 #include "system.h"
 909 #ifdef HAVE_SYS_TIMES_H
 910 #include <sys/times.h>
 911 #endif
 912 ])
 913
 914 # More time-related stuff.
 915 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
 916 AC_TRY_COMPILE([
 917 #include "ansidecl.h"
 918 #include "system.h"
 919 #ifdef HAVE_SYS_TIMES_H
 920 #include <sys/times.h>
 921 #endif
 922 ], [struct tms tms;], ac_cv_struct_tms=yes, ac_cv_struct_tms=no)])
 923 if test $ac_cv_struct_tms = yes; then
 924   AC_DEFINE(HAVE_STRUCT_TMS, 1,
 925   [Define if <sys/times.h> defines struct tms.])
 926 fi
 927
 928 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
 929 # revisit after autoconf 2.50.
 930 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
 931 AC_TRY_COMPILE([
 932 #include "ansidecl.h"
 933 #include "system.h"
 934 ], [clock_t x;], gcc_cv_type_clock_t=yes, gcc_cv_type_clock_t=no)])
 935 if test $gcc_cv_type_clock_t = yes; then
 936   AC_DEFINE(HAVE_CLOCK_T, 1,
 937   [Define if <time.h> defines clock_t.])
 938 fi
 939
 940 AC_CACHE_CHECK(for uchar, gcc_cv_type_uchar,
 941 [AC_TRY_COMPILE([
 942 #include "ansidecl.h"
 943 #include "system.h"
 944 ],
 945 [if ((uchar *)0) return 0;
 946  if (sizeof(uchar)) return 0;],
 947 ac_cv_type_uchar=yes, ac_cv_type_uchar=no)])
 948 if test $ac_cv_type_uchar = yes; then
 949   AC_DEFINE(HAVE_UCHAR, 1,
 950   [Define if <sys/types.h> defines \`uchar'.])
 951 fi
 952
 953 # Restore CFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
 954 CFLAGS="$saved_CFLAGS"
 955
 956 gcc_AC_INITFINI_ARRAY
 957
 958 # mkdir takes a single argument on some systems.
 959 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
 960
 961 # File extensions
 962 manext='.1'
 963 objext='.o'
 964 AC_SUBST(manext)
 965 AC_SUBST(objext)
 966
 967 # With Setjmp/Longjmp based exception handling.
 968 AC_ARG_ENABLE(sjlj-exceptions,
 969 [  --enable-sjlj-exceptions
 970                           arrange to use setjmp/longjmp exception handling],
 971 [sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
 972 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
 973   [Define 0/1 to force the choice for exception handling model.])])
 974
 975 if test x$host = x$target; then
 976    AC_CHECK_LIB(unwind, main, use_libunwind_default=yes, use_libunwind_default=no)
 977 else
 978    use_libunwind_default=no
 979 fi
 980 # Use libunwind based exception handling.
 981 AC_ARG_ENABLE(libunwind-exceptions,
 982 [  --enable-libunwind-exceptions  force use libunwind for exceptions],
 983 use_libunwind_exceptions=$enableval,
 984 use_libunwind_exceptions=$use_libunwind_default)
 985 if test x"$use_libunwind_exceptions" = xyes; then
 986    AC_DEFINE(USE_LIBUNWIND_EXCEPTIONS, 1,
 987         [Define if gcc should use -lunwind.])
 988 fi
 989
 990 # --------------------------------------------------------
 991 # Build, host, and target specific configuration fragments
 992 # --------------------------------------------------------
 993
 994 # Collect build-machine-specific information.
 995 . ${srcdir}/config.build
 996
 997 # Collect host-machine-specific information.
 998 . ${srcdir}/config.host
 999
1000 target_gtfiles=
1001
1002 # Collect target-machine-specific information.
1003 . ${srcdir}/config.gcc
1004
1005 extra_objs="${host_extra_objs} ${extra_objs}"
1006
1007 # Default the target-machine variables that were not explicitly set.
1008 if test x"$tm_file" = x
1009 then tm_file=$cpu_type/$cpu_type.h; fi
1010
1011 if test x"$extra_headers" = x
1012 then extra_headers=; fi
1013
1014 if test x$md_file = x
1015 then md_file=$cpu_type/$cpu_type.md; fi
1016
1017 if test x$out_file = x
1018 then out_file=$cpu_type/$cpu_type.c; fi
1019
1020 if test x"$tmake_file" = x
1021 then tmake_file=$cpu_type/t-$cpu_type
1022 fi
1023
1024 if test x"$dwarf2" = xyes
1025 then tm_file="$tm_file tm-dwarf2.h"
1026 fi
1027
1028 # Say what files are being used for the output code and MD file.
1029 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1030 echo "Using \`$srcdir/config/$md_file' as machine description file."
1031
1032 # If any of the xm_file variables contain nonexistent files, warn
1033 # about them and drop them.
1034
1035 bx=
1036 for x in $build_xm_file; do
1037   if    test -f $srcdir/config/$x
1038   then      bx="$bx $x"
1039   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1040   fi
1041 done
1042 build_xm_file="$bx"
1043
1044 hx=
1045 for x in $host_xm_file; do
1046   if    test -f $srcdir/config/$x
1047   then      hx="$hx $x"
1048   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1049   fi
1050 done
1051 host_xm_file="$hx"
1052
1053 tx=
1054 for x in $xm_file; do
1055   if    test -f $srcdir/config/$x
1056   then      tx="$tx $x"
1057   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1058   fi
1059 done
1060 xm_file="$tx"
1061
1062 count=a
1063 for f in $tm_file; do
1064         count=${count}x
1065 done
1066 if test $count = ax; then
1067         echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1068 else
1069         echo "Using the following target machine macro files:"
1070         for f in $tm_file; do
1071                 echo "  $srcdir/config/$f"
1072         done
1073 fi
1074
1075 if test x$need_64bit_hwint = xyes; then
1076         AC_DEFINE(NEED_64BIT_HOST_WIDE_INT, 1,
1077 [Define to 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h).])
1078 fi
1079
1080 count=a
1081 for f in $host_xm_file; do
1082         count=${count}x
1083 done
1084 if test $count = a; then
1085         :
1086 elif test $count = ax; then
1087         echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1088 else
1089         echo "Using the following host machine macro files:"
1090         for f in $host_xm_file; do
1091                 echo "  $srcdir/config/$f"
1092         done
1093 fi
1094 echo "Using ${out_host_hook_obj} for host machine hooks."
1095
1096 if test "$host_xm_file" != "$build_xm_file"; then
1097         count=a
1098         for f in $build_xm_file; do
1099                 count=${count}x
1100         done
1101         if test $count = a; then
1102                 :
1103         elif test $count = ax; then
1104                 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1105         else
1106                 echo "Using the following build machine macro files:"
1107                 for f in $build_xm_file; do
1108                         echo "  $srcdir/config/$f"
1109                 done
1110         fi
1111 fi
1112
1113 # Check if a valid thread package
1114 case ${enable_threads_flag} in
1115   "" | no)
1116     # No threads
1117     target_thread_file='single'
1118     ;;
1119   yes)
1120     # default
1121     target_thread_file='single'
1122     ;;
1123   aix | dce | gnat | irix | posix | rtems | \
1124   single | solaris | vxworks | win32 )
1125     target_thread_file=${enable_threads_flag}
1126     ;;
1127   *)
1128     echo "${enable_threads_flag} is an unknown thread package" 1>&2
1129     exit 1
1130     ;;
1131 esac
1132
1133 if test x${thread_file} = x; then
1134   # No thread file set by target-specific clauses in config.gcc,
1135   # so use file chosen by default logic above
1136   thread_file=${target_thread_file}
1137 fi
1138
1139 if test x$enable___cxa_atexit = xyes || \
1140    test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1141   AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 1,
1142   [Define if you want to use __cxa_atexit, rather than atexit, to
1143    register C++ destructors for local statics and global objects.
1144    This is essential for fully standards-compliant handling of
1145    destructors, but requires __cxa_atexit in libc.])
1146 fi
1147
1148 # Look for a file containing extra machine modes.
1149 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1150   extra_modes_file='$(srcdir)'/config/${extra_modes}
1151   AC_SUBST(extra_modes_file)
1152   AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1153   [Define to the name of a file containing a list of extra machine modes
1154    for this architecture.])
1155 fi
1156
1157 # auto-host.h is the file containing items generated by autoconf and is
1158 # the first file included by config.h.
1159 # If host=build, it is correct to have bconfig include auto-host.h
1160 # as well.  If host!=build, we are in error and need to do more
1161 # work to find out the build config parameters.
1162 if test x$host = x$build
1163 then
1164         build_auto=auto-host.h
1165         FORBUILD=..
1166 else
1167         # We create a subdir, then run autoconf in the subdir.
1168         # To prevent recursion we set host and build for the new
1169         # invocation of configure to the build for this invocation
1170         # of configure.
1171         tempdir=build.$$
1172         rm -rf $tempdir
1173         mkdir $tempdir
1174         cd $tempdir
1175         case ${srcdir} in
1176         /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1177         *) realsrcdir=../${srcdir};;
1178         esac
1179         saved_CFLAGS="${CFLAGS}"
1180         CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1181         ${realsrcdir}/configure \
1182                 --target=$target_alias --host=$build_alias --build=$build_alias
1183         CFLAGS="${saved_CFLAGS}"
1184
1185         # We just finished tests for the build machine, so rename
1186         # the file auto-build.h in the gcc directory.
1187         mv auto-host.h ../auto-build.h
1188         cd ..
1189         rm -rf $tempdir
1190         build_auto=auto-build.h
1191         FORBUILD=../${build_subdir}
1192 fi
1193 AC_SUBST(FORBUILD)
1194
1195 tm_file="${tm_file} defaults.h"
1196 tm_p_file="${tm_p_file} tm-preds.h"
1197 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1198 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1199 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1200 # put this back in temporarily.
1201 xm_file="ansidecl.h ${xm_file}"
1202
1203 # --------
1204 # UNSORTED
1205 # --------
1206
1207 # Get the version trigger filename from the toplevel
1208 if test "${with_gcc_version_trigger+set}" = set; then
1209         gcc_version_trigger=$with_gcc_version_trigger
1210 else
1211         gcc_version_trigger=${srcdir}/version.c
1212 fi
1213 changequote(,)dnl
1214 gcc_version_full=`grep version_string ${gcc_version_trigger} | sed -e 's/.*"\([^"]*\)".*/\1/'`
1215 gcc_version=`echo ${gcc_version_full} | sed -e 's/\([^ ]*\) .*/\1/'`
1216
1217 # Compile in configure arguments.
1218 if test -f configargs.h ; then
1219         # Being re-configured.
1220         gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1221         gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1222 else
1223         gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1224 fi
1225
1226 # Double all backslashes and backslash all quotes to turn
1227 # gcc_config_arguments into a C string.
1228 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1229 $gcc_config_arguments
1230 EOF
1231 gcc_config_arguments_str=`cat conftest.out`
1232 rm -f conftest.out
1233
1234 cat > configargs.h <<EOF
1235 /* Generated automatically. */
1236 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1237 static const char thread_model[] = "$thread_file";
1238
1239 static const struct {
1240   const char *name, *value;
1241 } configure_default_options[] = $configure_default_options;
1242 EOF
1243 changequote([,])dnl
1244
1245 # Internationalization
1246 PACKAGE=gcc
1247 VERSION="$gcc_version"
1248 AC_SUBST(PACKAGE)
1249 AC_SUBST(VERSION)
1250
1251 ZW_GNU_GETTEXT_SISTER_DIR
1252
1253 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1254 # -liconv on the link line twice.
1255 case "$LIBINTL" in *$LIBICONV*)
1256         LIBICONV= ;;
1257 esac
1258
1259 # Windows32 Registry support for specifying GCC installation paths.
1260 AC_ARG_ENABLE(win32-registry,
1261 [  --disable-win32-registry
1262                           disable lookup of installation paths in the
1263                           Registry on Windows hosts
1264   --enable-win32-registry enable registry lookup (default)
1265   --enable-win32-registry=KEY
1266                           use KEY instead of GCC version as the last portion
1267                           of the registry key],,)
1268 case $host_os in
1269         win32 | pe | cygwin* | mingw32* | uwin*)
1270 AC_MSG_CHECKING(whether windows registry support is requested)
1271 if test "x$enable_win32_registry" != xno; then
1272   AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1273 [Define to 1 if installation paths should be looked up in Windows32
1274    Registry. Ignored on non windows32 hosts.])
1275   AC_MSG_RESULT(yes)
1276   AC_SEARCH_LIBS(RegOpenKeyExA, advapi32)
1277 else
1278   AC_MSG_RESULT(no)
1279 fi
1280
1281 # Check if user specified a different registry key.
1282 case "x${enable_win32_registry}" in
1283 x | xyes)
1284   # default.
1285   gcc_cv_win32_registry_key="$VERSION"
1286   ;;
1287 xno)
1288   # no registry lookup.
1289   gcc_cv_win32_registry_key=''
1290   ;;
1291 *)
1292   # user-specified key.
1293   gcc_cv_win32_registry_key="$enable_win32_registry"
1294   ;;
1295 esac
1296
1297 if test "x$enable_win32_registry" != xno; then
1298   AC_MSG_CHECKING(registry key on windows hosts)
1299   AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$gcc_cv_win32_registry_key",
1300         [Define to be the last portion of registry key on windows hosts.])
1301   AC_MSG_RESULT($gcc_cv_win32_registry_key)
1302 fi
1303 ;;
1304 esac
1305
1306 # Get an absolute path to the GCC top-level source directory
1307 holddir=`${PWDCMD-pwd}`
1308 cd $srcdir
1309 topdir=`${PWDCMD-pwd}`
1310 cd $holddir
1311
1312 # Conditionalize the makefile for this host machine.
1313 xmake_file=
1314 for f in ${host_xmake_file}
1315 do
1316         if test -f ${srcdir}/config/$f
1317         then
1318                 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1319         fi
1320 done
1321
1322 # Conditionalize the makefile for this target machine.
1323 tmake_file_=
1324 for f in ${tmake_file}
1325 do
1326         if test -f ${srcdir}/config/$f
1327         then
1328                 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1329         fi
1330 done
1331 tmake_file="${tmake_file_}"
1332
1333 symbolic_link='ln -s'
1334
1335 # If the host doesn't support symlinks, modify CC in
1336 # FLAGS_TO_PASS so CC="stage1/xgcc -Bstage1/" works.
1337 # Otherwise, we can use "CC=$(CC)".
1338 rm -f symtest.tem
1339 if $symbolic_link $srcdir/gcc.c symtest.tem 2>/dev/null
1340 then
1341         cc_set_by_configure="\$(CC)"
1342         quoted_cc_set_by_configure="\$(CC)"
1343         stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1344         quoted_stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1345 else
1346         rm -f symtest.tem
1347         if cp -p $srcdir/gcc.c symtest.tem 2>/dev/null
1348         then
1349                 symbolic_link="cp -p"
1350         else
1351                 symbolic_link="cp"
1352         fi
1353         cc_set_by_configure="\`case '\$(CC)' in stage*) echo '\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\$(CC)';; esac\`"
1354         quoted_cc_set_by_configure="\\\`case '\\\$(CC)' in stage*) echo '\\\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(CC)';; esac\\\`"
1355         stage_prefix_set_by_configure="\`case '\$(STAGE_PREFIX)' in stage*) echo '\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\$(STAGE_PREFIX)';; esac\`"
1356         quoted_stage_prefix_set_by_configure="\\\`case '\\\$(STAGE_PREFIX)' in stage*) echo '\\\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(STAGE_PREFIX)';; esac\\\`"
1357 fi
1358 rm -f symtest.tem
1359
1360 out_object_file=`basename $out_file .c`.o
1361
1362 tm_file_list=
1363 tm_include_list=
1364 for f in $tm_file; do
1365   case $f in
1366     defaults.h )
1367        tm_file_list="${tm_file_list} \$(srcdir)/$f"
1368        tm_include_list="${tm_include_list} $f"
1369        ;;
1370     * )
1371        tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1372        tm_include_list="${tm_include_list} config/$f"
1373        ;;
1374   esac
1375 done
1376
1377 tm_p_file_list=
1378 tm_p_include_list=
1379 for f in $tm_p_file; do
1380   case $f in
1381     tm-preds.h )
1382        tm_p_file_list="${tm_p_file_list} $f"
1383        tm_p_include_list="${tm_p_include_list} $f"
1384        ;;
1385     * )
1386        tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1387        tm_p_include_list="${tm_p_include_list} config/$f"
1388   esac
1389 done
1390
1391 xm_file_list=
1392 xm_include_list=
1393 for f in $xm_file; do
1394   case $f in
1395     ansidecl.h )
1396        xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1397        xm_include_list="${xm_include_list} $f"
1398        ;;
1399     auto-host.h )
1400        xm_file_list="${xm_file_list} $f"
1401        xm_include_list="${xm_include_list} $f"
1402        ;;
1403     * )
1404        xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1405        xm_include_list="${xm_include_list} config/$f"
1406        ;;
1407   esac
1408 done
1409
1410 host_xm_file_list=
1411 host_xm_include_list=
1412 for f in $host_xm_file; do
1413   case $f in
1414     ansidecl.h )
1415        host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1416        host_xm_include_list="${host_xm_include_list} $f"
1417        ;;
1418     auto-host.h )
1419        host_xm_file_list="${host_xm_file_list} $f"
1420        host_xm_include_list="${host_xm_include_list} $f"
1421        ;;
1422     * )
1423        host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1424        host_xm_include_list="${host_xm_include_list} config/$f"
1425        ;;
1426   esac
1427 done
1428
1429 build_xm_file_list=
1430 for f in $build_xm_file; do
1431   case $f in
1432     ansidecl.h )
1433        build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1434        build_xm_include_list="${build_xm_include_list} $f"
1435        ;;
1436     auto-build.h | auto-host.h )
1437        build_xm_file_list="${build_xm_file_list} $f"
1438        build_xm_include_list="${build_xm_include_list} $f"
1439        ;;
1440     * )
1441        build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1442        build_xm_include_list="${build_xm_include_list} config/$f"
1443        ;;
1444   esac
1445 done
1446
1447 # Define macro CROSS_COMPILE in compilation if this is a cross-compiler.
1448 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1449 CROSS=                                          AC_SUBST(CROSS)
1450 ALL=all.internal                                AC_SUBST(ALL)
1451 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1452 if test x$host != x$target
1453 then
1454         CROSS="-DCROSS_COMPILE"
1455         ALL=all.cross
1456         SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1457         case "$host","$target" in
1458         # Darwin crosses can use the host system's libraries and headers,
1459         # because of the fat library support.  Of course, it must be the
1460         # same version of Darwin on both sides.  Allow the user to
1461         # just say --target=foo-darwin without a version number to mean
1462         # "the version on this system".
1463             *-*-darwin*,*-*-darwin*)
1464                 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1465                 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1466                 if test $hostos = $targetos -o $targetos = darwin ; then
1467                     CROSS=
1468                     SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1469                     with_headers=yes
1470                 fi
1471                 ;;
1472
1473             i?86-*-*,x86_64-*-* \
1474             | powerpc*-*-*,powerpc64*-*-*)
1475                 CROSS="$CROSS -DNATIVE_CROSS" ;;
1476         esac
1477 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1478         # This is just $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR)
1479         SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1480 fi
1481
1482 # If this is a cross-compiler that does not
1483 # have its own set of headers then define
1484 # inhibit_libc
1485
1486 # If this is using newlib, without having the headers available now,
1487 # then define inhibit_libc in LIBGCC2_CFLAGS.
1488 # This prevents libgcc2 from containing any code which requires libc
1489 # support.
1490 inhibit_libc=
1491 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1492        test x$with_newlib = xyes ; } &&
1493      { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1494        inhibit_libc=-Dinhibit_libc
1495 fi
1496 AC_SUBST(inhibit_libc)
1497
1498 # When building gcc with a cross-compiler, we need to adjust things so
1499 # that the generator programs are still built with the native compiler.
1500 # Also, we cannot run fixincludes or fix-header.
1501
1502 # These are the normal (build=host) settings:
1503 BUILD_PREFIX=                   AC_SUBST(BUILD_PREFIX)
1504 BUILD_PREFIX_1=ignore-          AC_SUBST(BUILD_PREFIX_1)
1505 CC_FOR_BUILD='$(CC)'            AC_SUBST(CC_FOR_BUILD)
1506 BUILD_CFLAGS='$(ALL_CFLAGS)'    AC_SUBST(BUILD_CFLAGS)
1507
1508 STMP_FIXINC=stmp-fixinc         AC_SUBST(STMP_FIXINC)
1509
1510 # Possibly disable fixproto, on a per-target basis.
1511 case ${use_fixproto} in
1512   no)
1513     STMP_FIXPROTO=
1514     ;;
1515   yes)
1516     STMP_FIXPROTO=stmp-fixproto
1517     ;;
1518 esac
1519 AC_SUBST(STMP_FIXPROTO)
1520
1521 # And these apply if build != host, or we are generating coverage data
1522 if test x$build != x$host || test "x$coverage_flags" != x
1523 then
1524     BUILD_PREFIX=build-
1525     BUILD_PREFIX_1=build-
1526     BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1527
1528     if test "x$TARGET_SYSTEM_ROOT" = x; then
1529         STMP_FIXINC=
1530         STMP_FIXPROTO=
1531     fi
1532 fi
1533
1534 # Expand extra_headers to include complete path.
1535 # This substitutes for lots of t-* files.
1536 extra_headers_list=
1537 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1538 for file in ${extra_headers} ; do
1539   extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1540 done
1541
1542 # Add a definition of USE_COLLECT2 if system wants one.
1543 case $use_collect2 in
1544   no) use_collect2= ;;
1545   "") ;;
1546   *)
1547     host_xm_defines="${host_xm_defines} USE_COLLECT2"
1548     xm_defines="${xm_defines} USE_COLLECT2"
1549     ;;
1550 esac
1551
1552 # Identify the assembler which will work hand-in-glove with the newly
1553 # built GCC, so that we can examine its features.  This is the assembler
1554 # which will be driven by the driver program.
1555 #
1556 # If build != host, and we aren't building gas in-tree, we identify a
1557 # build->target assembler and hope that it will have the same features
1558 # as the host->target assembler we'll be using.
1559 AC_MSG_CHECKING(what assembler to use)
1560 in_tree_gas=no
1561 gcc_cv_as=
1562 gcc_cv_gas_major_version=
1563 gcc_cv_gas_minor_version=
1564 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1565 if test -x "$DEFAULT_ASSEMBLER"; then
1566         gcc_cv_as="$DEFAULT_ASSEMBLER"
1567 elif test -x "$AS"; then
1568         gcc_cv_as="$AS"
1569 elif test -x as$host_exeext; then
1570         # Build using assembler in the current directory.
1571         gcc_cv_as=./as$host_exeext
1572 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
1573      && test -f ../gas/Makefile; then
1574   # Single tree build which includes gas.
1575   in_tree_gas=yes
1576   _gcc_COMPUTE_GAS_VERSION
1577   rm -f as$host_exeext
1578   $symbolic_link ../gas/as-new$host_exeext as$host_exeext 2>/dev/null
1579   in_tree_gas_is_elf=no
1580   if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
1581      || (grep 'obj_format = multi' ../gas/Makefile \
1582          && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
1583   then
1584     in_tree_gas_is_elf=yes
1585   fi
1586 fi
1587
1588 if test "x$gcc_cv_as" = x; then
1589         # Search the same directories that the installed compiler will
1590         # search.  Else we may find the wrong assembler and lose.  If we
1591         # do not find a suitable assembler binary, then try the user's
1592         # path.
1593         #
1594         # Also note we have to check MD_EXEC_PREFIX before checking the
1595         # user's path.  Unfortunately, there is no good way to get at the
1596         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1597         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1598         # to be fixed as part of the make/configure rewrite too.
1599
1600         if test "x$exec_prefix" = xNONE; then
1601                 if test "x$prefix" = xNONE; then
1602                         test_prefix=/usr/local
1603                 else
1604                         test_prefix=$prefix
1605                 fi
1606         else
1607                 test_prefix=$exec_prefix
1608         fi
1609
1610         # If the loop below does not find an assembler, then use whatever
1611         # one we can find in the users's path.
1612         # user's path.
1613         if test "x$program_prefix" != xNONE; then
1614                 gcc_cv_as=${program_prefix}as$host_exeext
1615         else
1616                 gcc_cv_as=`echo as | sed ${program_transform_name}`$host_exeext
1617         fi
1618
1619         test_dirs="$test_prefix/lib/gcc-lib/$target_noncanonical/$gcc_version \
1620                    $test_prefix/lib/gcc-lib/$target_noncanonical \
1621                    /usr/lib/gcc/$target_noncanonical/$gcc_version \
1622                    /usr/lib/gcc/$target_noncanonical \
1623                    $test_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version \
1624                    $test_prefix/$target_noncanonical/bin"
1625
1626         if test x$host = x$target; then
1627             test_dirs="$test_dirs \
1628                    /usr/libexec \
1629                    /usr/ccs/gcc \
1630                    /usr/ccs/bin \
1631                    /udk/usr/ccs/bin \
1632                    /bsd43/usr/lib/cmplrs/cc \
1633                    /usr/cross64/usr/bin \
1634                    /usr/lib/cmplrs/cc \
1635                    /sysv/usr/lib/cmplrs/cc \
1636                    /svr4/usr/lib/cmplrs/cc \
1637                    /usr/bin"
1638         fi
1639
1640         for dir in $test_dirs; do
1641                 if test -x $dir/as$host_exeext; then
1642                         gcc_cv_as=$dir/as$host_exeext
1643                         break;
1644                 fi
1645         done
1646 fi
1647 case $in_tree_gas in
1648   yes)
1649     AC_MSG_RESULT("newly built gas")
1650     ;;
1651   no)
1652     AC_MSG_RESULT($gcc_cv_as)
1653     ;;
1654 esac
1655
1656 # Identify the linker which will work hand-in-glove with the newly
1657 # built GCC, so that we can examine its features.  This is the linker
1658 # which will be driven by the driver program.
1659 #
1660 # If build != host, and we aren't building gas in-tree, we identify a
1661 # build->target linker and hope that it will have the same features
1662 # as the host->target linker we'll be using.
1663 AC_MSG_CHECKING(what linker to use)
1664 in_tree_ld=no
1665 gcc_cv_ld=
1666 gcc_cv_gld_major_version=
1667 gcc_cv_gld_minor_version=
1668 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1669 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1670 if test -x "$DEFAULT_LINKER"; then
1671         gcc_cv_ld="$DEFAULT_LINKER"
1672 elif test -x "$LD"; then
1673         gcc_cv_ld="$LD"
1674 elif test -x collect-ld$host_exeext; then
1675         # Build using linker in the current directory.
1676         gcc_cv_ld=./collect-ld$host_exeext
1677 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
1678      && test -f ../ld/Makefile; then
1679         # Single tree build which includes ld.
1680         in_tree_ld=yes
1681         in_tree_ld_is_elf=no
1682         if (grep 'EMUL = .*elf' ../ld/Makefile \
1683             || grep 'EMUL = .*linux' ../ld/Makefile) > /dev/null; then
1684           in_tree_ld_is_elf=yes
1685         fi
1686         for f in $gcc_cv_ld_bfd_srcdir/configure $gcc_cv_ld_gld_srcdir/configure $gcc_cv_ld_gld_srcdir/configure.in $gcc_cv_ld_gld_srcdir/Makefile.in
1687         do
1688 changequote(,)dnl
1689                 gcc_cv_gld_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
1690 changequote([,])dnl
1691                 if test x$gcc_cv_gld_version != x; then
1692                         break
1693                 fi
1694         done
1695 changequote(,)dnl
1696         gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
1697         gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1698 changequote([,])dnl
1699         rm -f collect-ld$host_exeext
1700         $symbolic_link ../ld/ld-new$host_exeext collect-ld$host_exeext \
1701                 2>/dev/null
1702 fi
1703
1704 if test "x$gcc_cv_ld" = x; then
1705         # Search the same directories that the installed compiler will
1706         # search.  Else we may find the wrong linker and lose.  If we
1707         # do not find a suitable linker binary, then try the user's
1708         # path.
1709         #
1710         # Also note we have to check MD_EXEC_PREFIX before checking the
1711         # user's path.  Unfortunately, there is no good way to get at the
1712         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1713         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1714         # to be fixed as part of the make/configure rewrite too.
1715
1716         if test "x$exec_prefix" = xNONE; then
1717                 if test "x$prefix" = xNONE; then
1718                         test_prefix=/usr/local
1719                 else
1720                         test_prefix=$prefix
1721                 fi
1722         else
1723                 test_prefix=$exec_prefix
1724         fi
1725
1726         # If the loop below does not find an linker, then use whatever
1727         # one we can find in the users's path.
1728         # user's path.
1729         if test "x$program_prefix" != xNONE; then
1730                 gcc_cv_ld=${program_prefix}ld$host_exeext
1731         else
1732                 gcc_cv_ld=`echo ld | sed ${program_transform_name}`$host_exeext
1733         fi
1734
1735         test_dirs="$test_prefix/lib/gcc-lib/$target_noncanonical/$gcc_version \
1736                    $test_prefix/lib/gcc-lib/$target_noncanonical \
1737                    /usr/lib/gcc/$target_noncanonical/$gcc_version \
1738                    /usr/lib/gcc/$target_noncanonical \
1739                    $test_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version \
1740                    $test_prefix/$target_noncanonical/bin"
1741
1742         if test x$host = x$target; then
1743             test_dirs="$test_dirs \
1744                    /usr/libexec \
1745                    /usr/ccs/gcc \
1746                    /usr/ccs/bin \
1747                    /udk/usr/ccs/bin \
1748                    /bsd43/usr/lib/cmplrs/cc \
1749                    /usr/cross64/usr/bin \
1750                    /usr/lib/cmplrs/cc \
1751                    /sysv/usr/lib/cmplrs/cc \
1752                    /svr4/usr/lib/cmplrs/cc \
1753                    /usr/bin"
1754         fi
1755
1756         for dir in $test_dirs; do
1757                 if test -x $dir/ld$host_exeext; then
1758                         gcc_cv_ld=$dir/ld$host_exeext
1759                         break;
1760                 fi
1761         done
1762 fi
1763 case $in_tree_ld in
1764   yes)
1765     AC_MSG_RESULT("newly built ld")
1766     ;;
1767   no)
1768     AC_MSG_RESULT($gcc_cv_ld)
1769     ;;
1770 esac
1771
1772 # Figure out what nm we will be using.
1773 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
1774 AC_MSG_CHECKING(what nm to use)
1775 in_tree_nm=no
1776 if test -x nm$host_exeext; then
1777         gcc_cv_nm=./nm$host_exeext
1778 elif test -f $gcc_cv_binutils_srcdir/configure.in \
1779      && test -f ../binutils/Makefile; then
1780         # Single tree build which includes binutils.
1781         in_tree_nm=yes
1782         gcc_cv_nm=./nm$host_exeext
1783         rm -f nm$host_exeext
1784         $symbolic_link ../binutils/nm-new$host_exeext nm$host_exeext 2>/dev/null
1785 elif test "x$program_prefix" != xNONE; then
1786         gcc_cv_nm=${program_prefix}nm$host_exeext
1787 else
1788         gcc_cv_nm=`echo nm | sed ${program_transform_name}`$host_exeext
1789 fi
1790 case $in_tree_nm in
1791   yes) AC_MSG_RESULT("newly built nm") ;;
1792   no)  AC_MSG_RESULT($gcc_cv_nm) ;;
1793 esac
1794
1795 # Figure out what objdump we will be using.
1796 AC_MSG_CHECKING(what objdump to use)
1797 in_tree_objdump=no
1798 if test -x objdump$host_exeext; then
1799         gcc_cv_objdump=./objdump$host_exeext
1800 elif test -f $gcc_cv_binutils_srcdir/configure.in \
1801      && test -f ../binutils/Makefile; then
1802         # Single tree build which includes binutils.
1803         in_tree_objdump=yes
1804         gcc_cv_objdump=./objdump$host_exeext
1805         rm -f objdump$host_exeext
1806         $symbolic_link ../binutils/objdump$host_exeext \
1807                 objdump$host_exeext 2>/dev/null
1808 elif test "x$program_prefix" != xNONE; then
1809         gcc_cv_objdump=${program_prefix}objdump$host_exeext
1810 else
1811         gcc_cv_objdump=`echo objdump | \
1812                 sed ${program_transform_name}`$host_exeext
1813 fi
1814 case $in_tree_objdump in
1815   yes) AC_MSG_RESULT("newly built objdump") ;;
1816   no)  AC_MSG_RESULT($gcc_cv_objdump) ;;
1817 esac
1818
1819 # Figure out what assembler alignment features are present.
1820 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
1821  [2,6,0],,
1822 [.balign 4
1823 .p2align 2],,
1824 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
1825   [Define if your assembler supports .balign and .p2align.])])
1826
1827 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
1828  [2,8,0],,
1829  [.p2align 4,,7],,
1830 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
1831   [Define if your assembler supports specifying the maximum number
1832    of bytes to skip when using the GAS .p2align command.])])
1833
1834 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
1835  [elf,2,9,0],,
1836  [conftest_label1: .word 0
1837 .subsection -1
1838 conftest_label2: .word 0
1839 .previous],
1840  [if test x$gcc_cv_nm != x; then
1841     $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
1842     $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
1843     if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
1844     then :
1845     else gcc_cv_as_subsection_m1=yes
1846     fi
1847     rm -f conftest.nm1 conftest.nm2
1848   fi],
1849  [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
1850   [Define if your assembler supports .subsection and .subsection -1 starts
1851    emitting at the beginning of your section.])])
1852
1853 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
1854  [2,2,0],,
1855  [      .weak foobar],,
1856 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
1857
1858 # .hidden needs to be supported in both the assembler and the linker,
1859 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
1860 # This is irritatingly difficult to feature test for; we have to check the
1861 # date string after the version number.  If we've got an in-tree
1862 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
1863 # to be safe.
1864 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
1865 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
1866  [elf,2,13,0],,
1867 [       .hidden foobar
1868 foobar:])
1869
1870 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
1871 [if test $in_tree_ld = yes ; then
1872   gcc_cv_ld_hidden=no
1873   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 13 -o "$gcc_cv_gld_major_version" -gt 2 \
1874      && test $in_tree_ld_is_elf = yes; then
1875      gcc_cv_ld_hidden=yes
1876   fi
1877 else
1878   gcc_cv_ld_hidden=yes
1879   ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
1880   if echo "$ld_ver" | grep GNU > /dev/null; then
1881 changequote(,)dnl
1882     ld_vers=`echo $ld_ver | sed -n \
1883         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
1884         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
1885         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
1886         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*\)[  ].*$,\1,p' \
1887         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)[     ].*$,\1,p' \
1888         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)[        ].*$,\1,p'`
1889     ld_date=`echo $ld_ver | sed -n 's,^.*\([2-9][0-9][0-9][0-9]\)[-]*\([01][0-9]\)[-]*\([0-3][0-9]\).*$,\1\2\3,p'`
1890     if test 0"$ld_date" -lt 20020404; then
1891       if test -n "$ld_date"; then
1892         # If there was date string, but was earlier than 2002-04-04, fail
1893         gcc_cv_ld_hidden=no
1894       elif test -z "$ld_vers"; then
1895         # If there was no date string nor ld version number, something is wrong
1896         gcc_cv_ld_hidden=no
1897       else
1898         ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
1899         ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
1900         ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
1901         test -z "$ld_vers_patch" && ld_vers_patch=0
1902         if test "$ld_vers_major" -lt 2; then
1903           gcc_cv_ld_hidden=no
1904         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
1905           gcc_cv_ld_hidden="no"
1906         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
1907           gcc_cv_ld_hidden=no
1908         fi
1909       fi
1910 changequote([,])dnl
1911     fi
1912   else
1913     case "${target}" in
1914       hppa64*-*-hpux* | ia64*-*-hpux*)
1915         gcc_cv_ld_hidden=yes
1916         ;;
1917       *)
1918         gcc_cv_ld_hidden=no
1919         ;;
1920     esac
1921   fi
1922 fi])
1923 libgcc_visibility=no
1924 AC_SUBST(libgcc_visibility)
1925 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
1926   libgcc_visibility=yes
1927   AC_DEFINE(HAVE_GAS_HIDDEN, 1,
1928   [Define if your assembler and linker support .hidden.])
1929 fi
1930
1931 # Check if we have .[us]leb128, and support symbol arithmetic with it.
1932 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
1933   [elf,2,11,0],,
1934 [       .data
1935         .uleb128 L2 - L1
1936 L1:
1937         .uleb128 1280
1938         .sleb128 -1010
1939 L2:],
1940  [# GAS versions before 2.11 do not support uleb128,
1941   # despite appearing to.
1942   # ??? There exists an elf-specific test that will crash
1943   # the assembler.  Perhaps it's better to figure out whether
1944   # arbitrary sections are supported and try the test.
1945   as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
1946   if echo "$as_ver" | grep GNU > /dev/null; then
1947 changequote(,)dnl
1948     as_ver=`echo $as_ver | sed -e 's/GNU assembler \([0-9.][0-9.]*\).*/\1/'`
1949     as_major=`echo $as_ver | sed 's/\..*//'`
1950     as_minor=`echo $as_ver | sed 's/[^.]*\.\([0-9]*\).*/\1/'`
1951 changequote([,])dnl
1952     if test $as_major -eq 2 && test $as_minor -lt 11
1953     then :
1954     else gcc_cv_as_leb128=yes
1955     fi
1956   fi],
1957   [AC_DEFINE(HAVE_AS_LEB128, 1,
1958     [Define if your assembler supports .sleb128 and .uleb128.])])
1959
1960 # GAS versions up to and including 2.11.0 may mis-optimize
1961 # .eh_frame data.
1962 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
1963   [elf,2,12,0],,
1964 [       .text
1965 .LFB1:
1966         .4byte  0
1967 .L1:
1968         .4byte  0
1969 .LFE1:
1970         .section        .eh_frame,"aw",@progbits
1971 __FRAME_BEGIN__:
1972         .4byte  .LECIE1-.LSCIE1
1973 .LSCIE1:
1974         .4byte  0x0
1975         .byte   0x1
1976         .ascii "z\0"
1977         .byte   0x1
1978         .byte   0x78
1979         .byte   0x1a
1980         .byte   0x0
1981         .byte   0x4
1982         .4byte  1
1983         .p2align 1
1984 .LECIE1:
1985 .LSFDE1:
1986         .4byte  .LEFDE1-.LASFDE1
1987 .LASFDE1:
1988         .4byte  .LASFDE1-__FRAME_BEGIN__
1989         .4byte  .LFB1
1990         .4byte  .LFE1-.LFB1
1991         .byte   0x4
1992         .4byte  .LFE1-.LFB1
1993         .byte   0x4
1994         .4byte  .L1-.LFB1
1995 .LEFDE1:],
1996 [  dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
1997 cat > conftest.lit <<EOF
1998  0000 10000000 00000000 017a0001 781a0004  .........z..x...
1999  0010 01000000 12000000 18000000 00000000  ................
2000  0020 08000000 04080000 0044               .........D      @&t@
2001 EOF
2002 cat > conftest.big <<EOF
2003  0000 00000010 00000000 017a0001 781a0004  .........z..x...
2004  0010 00000001 00000012 00000018 00000000  ................
2005  0020 00000008 04000000 0844               .........D      @&t@
2006 EOF
2007   # If the assembler didn't choke, and we can objdump,
2008   # and we got the correct data, then succeed.
2009   if test x$gcc_cv_objdump != x \
2010   && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2011      | tail -3 > conftest.got \
2012   && { cmp conftest.lit conftest.got > /dev/null 2>&1 \
2013     || cmp conftest.big conftest.got > /dev/null 2>&1; }
2014   then
2015     gcc_cv_as_eh_frame=yes
2016   elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2017     gcc_cv_as_eh_frame=buggy
2018   else
2019     # Uh oh, what do we do now?
2020     gcc_cv_as_eh_frame=no
2021   fi])
2022
2023 if test $gcc_cv_as_eh_frame = buggy; then
2024   AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2025   [Define if your assembler mis-optimizes .eh_frame data.])
2026 fi
2027
2028 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2029  [elf,2,12,0], [--fatal-warnings],
2030  [.section .rodata.str, "aMS", @progbits, 1])
2031 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2032   [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2033 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2034
2035 # Thread-local storage - the check is heavily parametrized.
2036 conftest_s=
2037 tls_first_major=
2038 tls_first_minor=
2039 tls_as_opt=
2040 case "$target" in
2041 changequote(,)dnl
2042   alpha*-*-*)
2043     conftest_s='
2044         .section ".tdata","awT",@progbits
2045 foo:    .long   25
2046         .text
2047         ldq     $27,__tls_get_addr($29)         !literal!1
2048         lda     $16,foo($29)                    !tlsgd!1
2049         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
2050         ldq     $27,__tls_get_addr($29)         !literal!2
2051         lda     $16,foo($29)                    !tlsldm!2
2052         jsr     $26,($27),__tls_get_addr        !lituse_tlsldm!2
2053         ldq     $1,foo($29)                     !gotdtprel
2054         ldah    $2,foo($29)                     !dtprelhi
2055         lda     $3,foo($2)                      !dtprello
2056         lda     $4,foo($29)                     !dtprel
2057         ldq     $1,foo($29)                     !gottprel
2058         ldah    $2,foo($29)                     !tprelhi
2059         lda     $3,foo($2)                      !tprello
2060         lda     $4,foo($29)                     !tprel'
2061         tls_first_major=2
2062         tls_first_minor=13
2063         tls_as_opt=--fatal-warnings
2064         ;;
2065   i[34567]86-*-*)
2066     conftest_s='
2067         .section ".tdata","awT",@progbits
2068 foo:    .long   25
2069         .text
2070         movl    %gs:0, %eax
2071         leal    foo@TLSGD(,%ebx,1), %eax
2072         leal    foo@TLSLDM(%ebx), %eax
2073         leal    foo@DTPOFF(%eax), %edx
2074         movl    foo@GOTTPOFF(%ebx), %eax
2075         subl    foo@GOTTPOFF(%ebx), %eax
2076         addl    foo@GOTNTPOFF(%ebx), %eax
2077         movl    foo@INDNTPOFF, %eax
2078         movl    $foo@TPOFF, %eax
2079         subl    $foo@TPOFF, %eax
2080         leal    foo@NTPOFF(%ecx), %eax'
2081         tls_first_major=2
2082         tls_first_minor=14
2083         tls_as_opt=--fatal-warnings
2084         ;;
2085   x86_64-*-*)
2086     conftest_s='
2087         .section ".tdata","awT",@progbits
2088 foo:    .long   25
2089         .text
2090         movq    %fs:0, %rax
2091         leaq    foo@TLSGD(%rip), %rdi
2092         leaq    foo@TLSLD(%rip), %rdi
2093         leaq    foo@DTPOFF(%rax), %rdx
2094         movq    foo@GOTTPOFF(%rip), %rax
2095         movq    $foo@TPOFF, %rax'
2096         tls_first_major=2
2097         tls_first_minor=14
2098         tls_as_opt=--fatal-warnings
2099         ;;
2100   ia64-*-*)
2101     conftest_s='
2102         .section ".tdata","awT",@progbits
2103 foo:    data8   25
2104         .text
2105         addl    r16 = @ltoff(@dtpmod(foo#)), gp
2106         addl    r17 = @ltoff(@dtprel(foo#)), gp
2107         addl    r18 = @ltoff(@tprel(foo#)), gp
2108         addl    r19 = @dtprel(foo#), gp
2109         adds    r21 = @dtprel(foo#), r13
2110         movl    r23 = @dtprel(foo#)
2111         addl    r20 = @tprel(foo#), gp
2112         adds    r22 = @tprel(foo#), r13
2113         movl    r24 = @tprel(foo#)'
2114         tls_first_major=2
2115         tls_first_minor=13
2116         tls_as_opt=--fatal-warnings
2117         ;;
2118   powerpc-*-*)
2119     conftest_s='
2120         .section ".tdata","awT",@progbits
2121         .align 2
2122 ld0:    .space 4
2123 ld1:    .space 4
2124 x1:     .space 4
2125 x2:     .space 4
2126 x3:     .space 4
2127         .text
2128         addi 3,31,ld0@got@tlsgd
2129         bl __tls_get_addr
2130         addi 3,31,x1@got@tlsld
2131         bl __tls_get_addr
2132         addi 9,3,x1@dtprel
2133         addis 9,3,x2@dtprel@ha
2134         addi 9,9,x2@dtprel@l
2135         lwz 9,x3@got@tprel(31)
2136         add 9,9,x@tls
2137         addi 9,2,x1@tprel
2138         addis 9,2,x2@tprel@ha
2139         addi 9,9,x2@tprel@l'
2140         tls_first_major=2
2141         tls_first_minor=14
2142         tls_as_opt="-a32 --fatal-warnings"
2143         ;;
2144   powerpc64-*-*)
2145     conftest_s='
2146         .section ".tdata","awT",@progbits
2147         .align 3
2148 ld0:    .space 8
2149 ld1:    .space 8
2150 x1:     .space 8
2151 x2:     .space 8
2152 x3:     .space 8
2153         .text
2154         addi 3,2,ld0@got@tlsgd
2155         bl .__tls_get_addr
2156         nop
2157         addi 3,2,ld1@toc
2158         bl .__tls_get_addr
2159         nop
2160         addi 3,2,x1@got@tlsld
2161         bl .__tls_get_addr
2162         nop
2163         addi 9,3,x1@dtprel
2164         bl .__tls_get_addr
2165         nop
2166         addis 9,3,x2@dtprel@ha
2167         addi 9,9,x2@dtprel@l
2168         bl .__tls_get_addr
2169         nop
2170         ld 9,x3@got@dtprel(2)
2171         add 9,9,3
2172         bl .__tls_get_addr
2173         nop'
2174         tls_first_major=2
2175         tls_first_minor=14
2176         tls_as_opt="-a64 --fatal-warnings"
2177         ;;
2178   s390-*-*)
2179     conftest_s='
2180         .section ".tdata","awT",@progbits
2181 foo:    .long   25
2182         .text
2183         .long   foo@TLSGD
2184         .long   foo@TLSLDM
2185         .long   foo@DTPOFF
2186         .long   foo@NTPOFF
2187         .long   foo@GOTNTPOFF
2188         .long   foo@INDNTPOFF
2189         l       %r1,foo@GOTNTPOFF(%r12)
2190         l       %r1,0(%r1):tls_load:foo
2191         bas     %r14,0(%r1,%r13):tls_gdcall:foo
2192         bas     %r14,0(%r1,%r13):tls_ldcall:foo'
2193         tls_first_major=2
2194         tls_first_minor=14
2195         tls_as_opt="-m31 --fatal-warnings"
2196         ;;
2197   s390x-*-*)
2198     conftest_s='
2199         .section ".tdata","awT",@progbits
2200 foo:    .long   25
2201         .text
2202         .quad   foo@TLSGD
2203         .quad   foo@TLSLDM
2204         .quad   foo@DTPOFF
2205         .quad   foo@NTPOFF
2206         .quad   foo@GOTNTPOFF
2207         lg      %r1,foo@GOTNTPOFF(%r12)
2208         larl    %r1,foo@INDNTPOFF
2209         brasl   %r14,__tls_get_offset@PLT:tls_gdcall:foo
2210         brasl   %r14,__tls_get_offset@PLT:tls_ldcall:foo'
2211         tls_first_major=2
2212         tls_first_minor=14
2213         tls_as_opt="-m64 -Aesame --fatal-warnings"
2214         ;;
2215   sh-*-* | sh[34]-*-*)
2216     conftest_s='
2217         .section ".tdata","awT",@progbits
2218 foo:    .long   25
2219         .text
2220         .long   foo@TLSGD
2221         .long   foo@TLSLDM
2222         .long   foo@DTPOFF
2223         .long   foo@GOTTPOFF
2224         .long   foo@TPOFF'
2225         tls_first_major=2
2226         tls_first_minor=13
2227         tls_as_opt=--fatal-warnings
2228         ;;
2229   sparc*-*-*)
2230     case "$target" in
2231       sparc*-sun-solaris2.*)
2232         on_solaris=yes
2233         ;;
2234       *)
2235         on_solaris=no
2236         ;;
2237     esac
2238     if test x$on_solaris = xyes && test x$gas_flag = xno; then
2239       conftest_s='
2240         .section ".tdata",#alloc,#write,#tls
2241 foo:    .long   25
2242         .text
2243         sethi   %tgd_hi22(foo), %o0
2244         add     %o0, %tgd_lo10(foo), %o1
2245         add     %l7, %o1, %o0, %tgd_add(foo)
2246         call    __tls_get_addr, %tgd_call(foo)
2247         sethi   %tldm_hi22(foo), %l1
2248         add     %l1, %tldm_lo10(foo), %l2
2249         add     %l7, %l2, %o0, %tldm_add(foo)
2250         call    __tls_get_addr, %tldm_call(foo)
2251         sethi   %tldo_hix22(foo), %l3
2252         xor     %l3, %tldo_lox10(foo), %l4
2253         add     %o0, %l4, %l5, %tldo_add(foo)
2254         sethi   %tie_hi22(foo), %o3
2255         add     %o3, %tie_lo10(foo), %o3
2256         ld      [%l7 + %o3], %o2, %tie_ld(foo)
2257         add     %g7, %o2, %o4, %tie_add(foo)
2258         sethi   %tle_hix22(foo), %l1
2259         xor     %l1, %tle_lox10(foo), %o5
2260         ld      [%g7 + %o5], %o1'
2261         tls_first_major=0
2262         tls_first_minor=0
2263     else
2264       conftest_s='
2265         .section ".tdata","awT",@progbits
2266 foo:    .long   25
2267         .text
2268         sethi   %tgd_hi22(foo), %o0
2269         add     %o0, %tgd_lo10(foo), %o1
2270         add     %l7, %o1, %o0, %tgd_add(foo)
2271         call    __tls_get_addr, %tgd_call(foo)
2272         sethi   %tldm_hi22(foo), %l1
2273         add     %l1, %tldm_lo10(foo), %l2
2274         add     %l7, %l2, %o0, %tldm_add(foo)
2275         call    __tls_get_addr, %tldm_call(foo)
2276         sethi   %tldo_hix22(foo), %l3
2277         xor     %l3, %tldo_lox10(foo), %l4
2278         add     %o0, %l4, %l5, %tldo_add(foo)
2279         sethi   %tie_hi22(foo), %o3
2280         add     %o3, %tie_lo10(foo), %o3
2281         ld      [%l7 + %o3], %o2, %tie_ld(foo)
2282         add     %g7, %o2, %o4, %tie_add(foo)
2283         sethi   %tle_hix22(foo), %l1
2284         xor     %l1, %tle_lox10(foo), %o5
2285         ld      [%g7 + %o5], %o1'
2286         tls_first_major=2
2287         tls_first_minor=14
2288         tls_as_opt="-32 --fatal-warnings"
2289       fi
2290         ;;
2291 changequote([,])dnl
2292 esac
2293 if test -z "$tls_first_major"; then
2294   : # If we don't have a check, assume no support.
2295 else
2296   gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
2297   [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
2298   [AC_DEFINE(HAVE_AS_TLS, 1,
2299             [Define if your assembler supports thread-local storage.])])
2300 fi
2301
2302 # Target-specific assembler checks.
2303
2304 case "$target" in
2305   # All TARGET_ABI_OSF targets.
2306   alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
2307     gcc_GAS_CHECK_FEATURE([explicit relocation support],
2308         gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
2309 [       .set nomacro
2310         .text
2311         extbl   $3, $2, $3      !lituse_bytoff!1
2312         ldq     $2, a($29)      !literal!1
2313         ldq     $4, b($29)      !literal!2
2314         ldq_u   $3, 0($2)       !lituse_base!1
2315         ldq     $27, f($29)     !literal!5
2316         jsr     $26, ($27), f   !lituse_jsr!5
2317         ldah    $29, 0($26)     !gpdisp!3
2318         lda     $0, c($29)      !gprel
2319         ldah    $1, d($29)      !gprelhigh
2320         lda     $1, d($1)       !gprellow
2321         lda     $29, 0($29)     !gpdisp!3],,
2322     [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
2323   [Define if your assembler supports explicit relocations.])])
2324     ;;
2325
2326   sparc*-*-*)
2327     gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
2328       [.register %g2, #scratch],,
2329       [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
2330                 [Define if your assembler supports .register.])])
2331
2332     gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
2333       [-relax], [.text],,
2334       [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
2335                 [Define if your assembler supports -relax option.])])
2336
2337     gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
2338       gcc_cv_as_sparc_ua_pcrel,,
2339       [-K PIC],
2340 [.text
2341 foo:
2342         nop
2343 .data
2344 .align 4
2345 .byte 0
2346 .uaword %r_disp32(foo)],
2347       [if test x$gcc_cv_ld != x \
2348        && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
2349          gcc_cv_as_sparc_ua_pcrel=yes
2350        fi
2351        rm -f conftest],
2352       [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
2353                 [Define if your assembler and linker support unaligned PC relative relocs.])
2354
2355       gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
2356         gcc_cv_as_sparc_ua_pcrel_hidden,,
2357         [-K PIC],
2358 [.data
2359 .align 4
2360 .byte 0x31
2361 .uaword %r_disp32(foo)
2362 .byte 0x32, 0x33, 0x34
2363 .global foo
2364 .hidden foo
2365 foo:
2366 .skip 4],
2367         [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
2368          && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
2369          && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
2370             | grep ' 31000000 07323334' > /dev/null 2>&1; then
2371             if $gcc_cv_objdump -R conftest 2> /dev/null \
2372                | grep 'DISP32' > /dev/null 2>&1; then
2373                 :
2374             else
2375                 gcc_cv_as_sparc_ua_pcrel_hidden=yes
2376             fi
2377          fi
2378          rm -f conftest],
2379          [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
2380                    [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
2381     ]) # unaligned pcrel relocs
2382
2383     gcc_GAS_CHECK_FEATURE([offsetable %lo()],
2384       gcc_cv_as_sparc_offsetable_lo10,,
2385       [-xarch=v9],
2386 [.text
2387         or %g1, %lo(ab) + 12, %g1
2388         or %g1, %lo(ab + 12), %g1],
2389       [if test x$gcc_cv_objdump != x \
2390        && %gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
2391           | grep ' 82106000 82106000' > /dev/null 2>&1; then
2392          gcc_cv_as_offsetable_lo10=yes
2393        fi],
2394        [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
2395                  [Define if your assembler supports offsetable %lo().])])
2396     ;;
2397
2398 changequote(,)dnl
2399   i[34567]86-*-* | x86_64-*-*)
2400 changequote([,])dnl
2401     gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
2402        gcc_cv_as_ix86_filds_fists,
2403       [2,9,0],, [filds mem; fists mem],,
2404       [AC_DEFINE(HAVE_GAS_FILDS_FISTS, 1,
2405         [Define if your assembler uses the new HImode fild and fist notation.])])
2406
2407     gcc_GAS_CHECK_FEATURE([cmov syntax],
2408       gcc_cv_as_ix86_cmov_sun_syntax,,,
2409       [cmovl.l %edx, %eax],,
2410       [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
2411         [Define if your assembler supports the Sun syntax for cmov.])])
2412
2413     # This one is used unconditionally by i386.[ch]; it is to be defined
2414     # to 1 if the feature is present, 0 otherwise.
2415     gcc_GAS_CHECK_FEATURE([GOTOFF in data],
2416         gcc_cv_as_ix86_gotoff_in_data, [2,11,0],,
2417 [       .text
2418 .L0:
2419         nop
2420         .data
2421         .long .L0@GOTOFF])
2422     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
2423       [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
2424       [Define true if the assembler supports '.long foo@GOTOFF'.])
2425     ;;
2426
2427   ia64*-*-*)
2428     gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
2429         gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
2430 [       .text
2431         addl r15 = @ltoffx(x#), gp
2432         ;;
2433         ld8.mov r16 = [[r15]], x#],,
2434     [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
2435           [Define if your assembler supports ltoffx and ldxmov relocations.])])
2436
2437     ;;
2438
2439   powerpc*-*-*)
2440     case $target in
2441       *-*-aix) conftest_s='     .csect .text[PR]';;
2442       *)       conftest_s='     .text';;
2443     esac
2444     conftest_s="$conftest_s
2445         mfcr 3,128"
2446
2447     gcc_GAS_CHECK_FEATURE([mfcr field support],
2448       gcc_cv_as_powerpc_mfcrf, [2,14,0],,
2449       [$conftest_s],,
2450       [AC_DEFINE(HAVE_AS_MFCRF, 1,
2451           [Define if your assembler supports mfcr field.])])
2452     ;;
2453
2454   mips*-*-*)
2455     gcc_GAS_CHECK_FEATURE([explicit relocation support],
2456       gcc_cv_as_mips_explicit_relocs, [2,14,0],,
2457 [       lw $4,%gp_rel(foo)($4)],,
2458       [if test x$target_cpu_default = x
2459        then target_cpu_default=MASK_EXPLICIT_RELOCS
2460        else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
2461        fi])
2462
2463     ;;
2464 esac
2465 # ??? Not all targets support dwarf2 debug_line, even within a version
2466 # of gas.  Moreover, we need to emit a valid instruction to trigger any
2467 # info to the output file.  So, as supported targets are added to gas 2.11,
2468 # add some instruction here to (also) show we expect this might work.
2469 # ??? Once 2.11 is released, probably need to add first known working
2470 # version to the per-target configury.
2471 case "$target" in
2472   i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* \
2473   | x86_64*-*-* | hppa*-*-* | arm*-*-* | strongarm*-*-* | xscale*-*-* \
2474   | xstormy16*-*-* | cris-*-* | xtensa-*-*)
2475     insn="nop"
2476     ;;
2477   ia64*-*-*)
2478     insn="nop 0"
2479     ;;
2480   mmix-*-*)
2481     insn="swym 0"
2482     ;;
2483 esac
2484 if test x"$insn" != x; then
2485  conftest_s="\
2486         .file 1 \"conftest.s\"
2487         .loc 1 3 0
2488         $insn"
2489  gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
2490   gcc_cv_as_dwarf2_debug_line,
2491   [elf,2,11,0],, [$conftest_s],
2492   [# ??? This fails with non-gnu grep.  Maybe use objdump?
2493    if grep debug_line conftest.o > /dev/null 2>&1; then
2494      gcc_cv_as_dwarf2_debug_line=yes
2495    fi])
2496
2497 # The .debug_line file table must be in the exact order that
2498 # we specified the files, since these indices are also used
2499 # by DW_AT_decl_file.  Approximate this test by testing if
2500 # the assembler bitches if the same index is assigned twice.
2501  gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
2502   gcc_cv_as_dwarf2_file_buggy,,,
2503 [       .file 1 "foo.s"
2504         .file 1 "bar.s"])
2505
2506  if test $gcc_cv_as_dwarf2_debug_line = yes \
2507  && test $gcc_cv_as_dwarf2_file_buggy = no; then
2508         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
2509   [Define if your assembler supports dwarf2 .file/.loc directives,
2510    and preserves file table indices exactly as given.])
2511  fi
2512
2513  gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
2514   gcc_cv_as_gdwarf2_flag,
2515   [elf,2,11,0], [--gdwarf2], [$insn],,
2516   [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
2517 [Define if your assembler supports the --gdwarf2 option.])])
2518
2519  gcc_GAS_CHECK_FEATURE([--gstabs option],
2520   gcc_cv_as_gstabs_flag,
2521   [elf,2,11,0], [--gstabs], [$insn],
2522   [# The native Solaris 9/Intel assembler doesn't understand --gstabs
2523    # and warns about it, but still exits successfully.  So check for
2524    # this.
2525    if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
2526    then :
2527    else gcc_cv_as_gstabs_flag=yes
2528    fi],
2529   [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
2530 [Define if your assembler supports the --gstabs option.])])
2531 fi
2532
2533 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2534 gcc_cv_ld_ro_rw_mix=unknown
2535 if test $in_tree_ld = yes ; then
2536   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 10 -o "$gcc_cv_gld_major_version" -gt 2 \
2537      && test $in_tree_ld_is_elf = yes; then
2538     gcc_cv_ld_ro_rw_mix=read-write
2539   fi
2540 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2541   echo '.section myfoosect, "a"' > conftest1.s
2542   echo '.section myfoosect, "aw"' > conftest2.s
2543   echo '.byte 1' >> conftest2.s
2544   echo '.section myfoosect, "a"' > conftest3.s
2545   echo '.byte 0' >> conftest3.s
2546   if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2547      && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2548      && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2549      && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2550         conftest2.o conftest3.o > /dev/null 2>&1; then
2551     gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2552                          | sed -e '/myfoosect/!d' -e N`
2553     if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2554       if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2555         gcc_cv_ld_ro_rw_mix=read-only
2556       else
2557         gcc_cv_ld_ro_rw_mix=read-write
2558       fi
2559     fi
2560   fi
2561 changequote(,)dnl
2562   rm -f conftest.* conftest[123].*
2563 changequote([,])dnl
2564 fi
2565 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2566         AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2567   [Define if your linker links a mix of read-only
2568    and read-write sections into a read-write section.])
2569 fi
2570 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2571
2572 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
2573 gcc_cv_ld_eh_frame_hdr=no
2574 if test $in_tree_ld = yes ; then
2575   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 12 -o "$gcc_cv_gld_major_version" -gt 2 \
2576      && test $in_tree_ld_is_elf = yes; then
2577     gcc_cv_ld_eh_frame_hdr=yes
2578   fi
2579 elif test x$gcc_cv_ld != x; then
2580         # Check if linker supports --eh-frame-hdr option
2581         if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
2582                 gcc_cv_ld_eh_frame_hdr=yes
2583         fi
2584 fi
2585 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
2586         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
2587 [Define if your linker supports --eh-frame-hdr option.])
2588 fi
2589 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
2590
2591 AC_MSG_CHECKING(linker position independent executable support)
2592 gcc_cv_ld_pie=no
2593 if test $in_tree_ld = yes ; then
2594   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 15 -o "$gcc_cv_gld_major_version" -gt 2 \
2595      && test $in_tree_ld_is_elf = yes; then
2596     gcc_cv_ld_pie=yes
2597   fi
2598 elif test x$gcc_cv_ld != x; then
2599         # Check if linker supports -pie option
2600         if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
2601                 gcc_cv_ld_pie=yes
2602         fi
2603 fi
2604 if test x"$gcc_cv_ld_pie" = xyes; then
2605         AC_DEFINE(HAVE_LD_PIE, 1,
2606 [Define if your linker supports -pie option.])
2607 fi
2608 AC_MSG_RESULT($gcc_cv_ld_pie)
2609
2610 if test x$with_sysroot = x && test x$host = x$target \
2611    && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" ; then
2612   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
2613 [Define to PREFIX/include if cpp should also search that directory.])
2614 fi
2615
2616 # Figure out what language subdirectories are present.
2617 # Look if the user specified --enable-languages="..."; if not, use
2618 # the environment variable $LANGUAGES if defined. $LANGUAGES might
2619 # go away some day.
2620 # NB:  embedded tabs in this IF block -- do not untabify
2621 if test x"${enable_languages+set}" != xset; then
2622         if test x"${LANGUAGES+set}" = xset; then
2623                 enable_languages="${LANGUAGES}"
2624                 AC_MSG_WARN([setting LANGUAGES is deprecated, use --enable-languages instead])
2625
2626         else
2627                 enable_languages=all
2628         fi
2629 else
2630         if test x"${enable_languages}" = x \
2631         || test x"${enable_languages}" = xyes;
2632         then
2633                 AC_MSG_ERROR([--enable-languages needs at least one language argument])
2634         fi
2635 fi
2636 enable_languages=`echo "${enable_languages}" | sed -e 's/[[     ,]][[   ,]]*/,/g' -e 's/,$//'`
2637
2638 # First scan to see if an enabled language requires some other language.
2639 # We assume that a given config-lang.in will list all the language
2640 # front ends it requires, even if some are required indirectly.
2641 for lang in ${srcdir}/*/config-lang.in
2642 do
2643    case $lang in
2644     # The odd quoting in the next line works around
2645     # an apparent bug in bash 1.12 on linux.
2646 changequote(,)dnl
2647     ${srcdir}/[*]/config-lang.in)
2648        ;;
2649     *)
2650        lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^      ]*\).*$,\1,p' $lang`
2651        this_lang_requires=`sed -n -e 's,^lang_requires=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^lang_requires=\([^    ]*\).*$,\1,p' $lang`
2652        for other in $this_lang_requires
2653        do
2654           case ,${enable_languages}, in
2655            *,$other,*)
2656               ;;
2657            *,all,*)
2658               ;;
2659            *,$lang_alias,*)
2660               enable_languages="$enable_languages,$other"
2661               ;;
2662           esac
2663        done
2664        ;;
2665 changequote([,])dnl
2666    esac
2667 done
2668
2669 expected_languages=`echo ,${enable_languages}, | sed -e 's:,: :g' -e 's:  *: :g' -e 's:  *: :g' -e 's:^ ::' -e 's: $::'`
2670 found_languages=
2671 subdirs=
2672 for lang in ${srcdir}/*/config-lang.in
2673 do
2674         case $lang in
2675         # The odd quoting in the next line works around
2676         # an apparent bug in bash 1.12 on linux.
2677 changequote(,)dnl
2678         ${srcdir}/[*]/config-lang.in) ;;
2679         *)
2680           lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
2681           this_lang_libs=`sed -n -e 's,^target_libs=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^target_libs=\([^         ]*\).*$,\1,p' $lang`
2682           build_by_default=`sed -n -e 's,^build_by_default=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^build_by_default=\([^     ]*\).*$,\1,p' $lang`
2683           if test "x$lang_alias" = x
2684           then
2685                 echo "$lang doesn't set \$language." 1>&2
2686                 exit 1
2687           fi
2688           case ${build_by_default},${enable_languages}, in
2689           *,$lang_alias,*) add_this_lang=yes ;;
2690           no,*) add_this_lang=no ;;
2691           *,all,*) add_this_lang=yes ;;
2692           *) add_this_lang=no ;;
2693           esac
2694           found_languages="${found_languages} ${lang_alias}"
2695           if test x"${add_this_lang}" = xyes; then
2696                 case $lang in
2697                     ${srcdir}/ada/config-lang.in)
2698                         if test x$have_gnat = xyes ; then
2699                                 subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2700                         fi
2701                         ;;
2702                     *)
2703                         subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2704                         ;;
2705                 esac
2706           fi
2707           ;;
2708 changequote([,])dnl
2709         esac
2710 done
2711
2712 missing_languages=
2713 for expected_language in ${expected_languages} ..
2714 do
2715     if test "${expected_language}" != ..; then
2716         missing_language="${expected_language}"
2717         if test "${expected_language}" = "c" \
2718            || test "${expected_language}" = "all"; then
2719                 missing_language=
2720         fi
2721         for found_language in ${found_languages} ..
2722         do
2723             if test "${found_language}" != ..; then
2724                 if test "${expected_language}" = "${found_language}"; then
2725                     missing_language=
2726                 fi
2727             fi
2728         done
2729         if test "x${missing_language}" != x; then
2730            missing_languages="${missing_languages} ${missing_language}"
2731         fi
2732     fi
2733 done
2734
2735 if test "x$missing_languages" != x; then
2736   AC_MSG_ERROR([
2737 The following requested languages were not found:${missing_languages}
2738 The following languages were available: c${found_languages}])
2739 fi
2740
2741 # Make gthr-default.h if we have a thread file.
2742 gthread_flags=
2743 if test $thread_file != single; then
2744     rm -f gthr-default.h
2745     echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h
2746     gthread_flags=-DHAVE_GTHR_DEFAULT
2747 fi
2748 AC_SUBST(gthread_flags)
2749
2750 # Find out what GC implementation we want, or may, use.
2751 AC_ARG_WITH(gc,
2752 [  --with-gc={page,zone}   choose the garbage collection mechanism to use
2753                           with the compiler],
2754 [case "$withval" in
2755   page | zone)
2756     GGC=ggc-$withval
2757     ;;
2758   *)
2759     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
2760     ;;
2761 esac],
2762 [GGC=ggc-page])
2763 AC_SUBST(GGC)
2764 echo "Using $GGC for garbage collection."
2765
2766 # Use the system's zlib library.
2767 zlibdir=-L../zlib
2768 zlibinc="-I\$(srcdir)/../zlib"
2769 AC_ARG_WITH(system-zlib,
2770 [  --with-system-zlib      use installed libz],
2771 zlibdir=
2772 zlibinc=
2773 )
2774 AC_SUBST(zlibdir)
2775 AC_SUBST(zlibinc)
2776
2777 dnl Very limited version of automake's enable-maintainer-mode
2778
2779 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
2780   dnl maintainer-mode is disabled by default
2781   AC_ARG_ENABLE(maintainer-mode,
2782 [  --enable-maintainer-mode
2783                           enable make rules and dependencies not useful
2784                           (and sometimes confusing) to the casual installer],
2785       maintainer_mode=$enableval,
2786       maintainer_mode=no)
2787
2788 AC_MSG_RESULT($maintainer_mode)
2789
2790 if test "$maintainer_mode" = "yes"; then
2791   MAINT=''
2792 else
2793   MAINT='#'
2794 fi
2795 AC_SUBST(MAINT)dnl
2796
2797 # Make empty files to contain the specs and options for each language.
2798 # Then add #include lines to for a compiler that has specs and/or options.
2799
2800 lang_opt_files=
2801 lang_specs_files=
2802 lang_tree_files=
2803 for subdir in . $subdirs
2804 do
2805         if test -f $srcdir/$subdir/lang.opt; then
2806             lang_opt_files="$lang_opt_files $srcdir/$subdir/lang.opt"
2807         fi
2808         if test -f $srcdir/$subdir/lang-specs.h; then
2809             lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
2810         fi
2811         if test -f $srcdir/$subdir/$subdir-tree.def; then
2812             lang_tree_files="$lang_tree_files $srcdir/$subdir/$subdir-tree.def"
2813         fi
2814 done
2815
2816 # These (without "all_") are set in each config-lang.in.
2817 # `language' must be a single word so is spelled singularly.
2818 all_languages=
2819 all_boot_languages=
2820 all_compilers=
2821 all_stagestuff=
2822 all_outputs='Makefile fixinc/Makefile gccbug mklibgcc mkheaders'
2823 # List of language makefile fragments.
2824 all_lang_makefrags=
2825 # List of language subdirectory makefiles.  Deprecated.
2826 all_lang_makefiles=
2827 # Files for gengtype
2828 all_gtfiles="$target_gtfiles"
2829 # Files for gengtype with language
2830 all_gtfiles_files_langs=
2831 all_gtfiles_files_files=
2832
2833 # Add the language fragments.
2834 # Languages are added via two mechanisms.  Some information must be
2835 # recorded in makefile variables, these are defined in config-lang.in.
2836 # We accumulate them and plug them into the main Makefile.
2837 # The other mechanism is a set of hooks for each of the main targets
2838 # like `clean', `install', etc.
2839
2840 language_hooks="Make-hooks"
2841
2842 for s in $subdirs
2843 do
2844                 language=
2845                 boot_language=
2846                 compilers=
2847                 stagestuff=
2848                 outputs=
2849                 gtfiles=
2850                 . ${srcdir}/$s/config-lang.in
2851                 if test "x$language" = x
2852                 then
2853                         echo "${srcdir}/$s/config-lang.in doesn't set \$language." 1>&2
2854                         exit 1
2855                 fi
2856                 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$s/Make-lang.in"
2857                 if test -f ${srcdir}/$s/Makefile.in
2858                 then all_lang_makefiles="$s/Makefile"
2859                 fi
2860                 all_languages="$all_languages $language"
2861                 if test "x$boot_language" = xyes
2862                 then
2863                         all_boot_languages="$all_boot_languages $language"
2864                 fi
2865                 all_compilers="$all_compilers $compilers"
2866                 all_stagestuff="$all_stagestuff $stagestuff"
2867                 all_outputs="$all_outputs $outputs"
2868                 all_gtfiles="$all_gtfiles $gtfiles"
2869                 for f in $gtfiles
2870                 do
2871                          all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2872                          all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2873                 done
2874 done
2875
2876 # Pick up gtfiles for c
2877 gtfiles=
2878 s="c"
2879 . ${srcdir}/c-config-lang.in
2880 all_gtfiles="$all_gtfiles $gtfiles"
2881 for f in $gtfiles
2882 do
2883         all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2884         all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2885 done
2886
2887 check_languages=
2888 for language in $all_languages
2889 do
2890                 check_languages="$check_languages check-$language"
2891 done
2892
2893 # We link each language in with a set of hooks, reached indirectly via
2894 # lang.${target}.
2895
2896 rm -f Make-hooks
2897 touch Make-hooks
2898 target_list="all.build all.cross start.encap rest.encap tags \
2899         install-normal install-common install-man \
2900         uninstall srcextra \
2901         mostlyclean clean distclean maintainer-clean \
2902         stage1 stage2 stage3 stage4 stageprofile stagefeedback"
2903 for t in $target_list
2904 do
2905         x=
2906         for lang in $all_languages
2907         do
2908                         x="$x $lang.$t"
2909         done
2910         echo "lang.$t: $x" >> Make-hooks
2911 done
2912
2913 # Create .gdbinit.
2914
2915 echo "dir ." > .gdbinit
2916 echo "dir ${srcdir}" >> .gdbinit
2917 if test x$gdb_needs_out_file_path = xyes
2918 then
2919         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
2920 fi
2921 if test "x$subdirs" != x; then
2922         for s in $subdirs
2923         do
2924                 echo "dir ${srcdir}/$s" >> .gdbinit
2925         done
2926 fi
2927 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
2928
2929 # If $(exec_prefix) exists and is not the same as $(prefix), then compute an
2930 # absolute path for gcc_tooldir based on inserting the number of up-directory
2931 # movements required to get from $(exec_prefix) to $(prefix) into the basic
2932 # $(libsubdir)/@(unlibsubdir) based path.
2933 # Don't set gcc_tooldir to tooldir since that's only passed in by the toplevel
2934 # make and thus we'd get different behavior depending on where we built the
2935 # sources.
2936 if test x$exec_prefix = xNONE -o x$exec_prefix = x$prefix; then
2937     gcc_tooldir='$(libsubdir)/$(unlibsubdir)/../$(target_noncanonical)'
2938 else
2939 changequote(<<, >>)dnl
2940 # An explanation of the sed strings:
2941 #  -e 's|^\$(prefix)||'   matches and eliminates 'prefix' from 'exec_prefix'
2942 #  -e 's|/$||'            match a trailing forward slash and eliminates it
2943 #  -e 's|^[^/]|/|'        forces the string to start with a forward slash (*)
2944 #  -e 's|/[^/]*|../|g'    replaces each occurrence of /<directory> with ../
2945 #
2946 # (*) Note this pattern overwrites the first character of the string
2947 # with a forward slash if one is not already present.  This is not a
2948 # problem because the exact names of the sub-directories concerned is
2949 # unimportant, just the number of them matters.
2950 #
2951 # The practical upshot of these patterns is like this:
2952 #
2953 #  prefix     exec_prefix        result
2954 #  ------     -----------        ------
2955 #   /foo        /foo/bar          ../
2956 #   /foo/       /foo/bar          ../
2957 #   /foo        /foo/bar/         ../
2958 #   /foo/       /foo/bar/         ../
2959 #   /foo        /foo/bar/ugg      ../../
2960 #
2961     dollar='$$'
2962     gcc_tooldir="\$(libsubdir)/\$(unlibsubdir)/\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/\$(dollar)||' -e 's|^[^/]|/|' -e 's|/[^/]*|../|g'\`\$(target_noncanonical)"
2963 changequote([, ])dnl
2964 fi
2965 AC_SUBST(gcc_tooldir)
2966 AC_SUBST(dollar)
2967
2968 # Find a directory in which to install a shared libgcc.
2969
2970 AC_ARG_ENABLE(version-specific-runtime-libs,
2971 [  --enable-version-specific-runtime-libs
2972                           specify that runtime libraries should be
2973                           installed in a compiler-specific directory])
2974
2975 AC_ARG_WITH(slibdir,
2976 [  --with-slibdir=DIR      shared libraries in DIR [LIBDIR]],
2977 slibdir="$with_slibdir",
2978 if test "${enable_version_specific_runtime_libs+set}" = set; then
2979   slibdir='$(libsubdir)'
2980 elif test "$host" != "$target"; then
2981   slibdir='$(build_tooldir)/lib'
2982 else
2983   slibdir='$(libdir)'
2984 fi)
2985 AC_SUBST(slibdir)
2986
2987 objdir=`${PWDCMD-pwd}`
2988 AC_SUBST(objdir)
2989
2990 # Substitute configuration variables
2991 AC_SUBST(subdirs)
2992 AC_SUBST(srcdir)
2993 AC_SUBST(docobjdir)
2994 AC_SUBST(all_boot_languages)
2995 AC_SUBST(all_compilers)
2996 AC_SUBST(all_gtfiles)
2997 AC_SUBST(all_gtfiles_files_langs)
2998 AC_SUBST(all_gtfiles_files_files)
2999 AC_SUBST(all_lang_makefrags)
3000 AC_SUBST(all_lang_makefiles)
3001 AC_SUBST(all_languages)
3002 AC_SUBST(all_stagestuff)
3003 AC_SUBST(build_exeext)
3004 AC_SUBST(build_install_headers_dir)
3005 AC_SUBST(build_xm_file_list)
3006 AC_SUBST(build_xm_include_list)
3007 AC_SUBST(build_xm_defines)
3008 AC_SUBST(check_languages)
3009 AC_SUBST(cc_set_by_configure)
3010 AC_SUBST(quoted_cc_set_by_configure)
3011 AC_SUBST(cpp_install_dir)
3012 AC_SUBST(xmake_file)
3013 AC_SUBST(tmake_file)
3014 AC_SUBST(extra_headers_list)
3015 AC_SUBST(extra_objs)
3016 AC_SUBST(extra_parts)
3017 AC_SUBST(extra_passes)
3018 AC_SUBST(extra_programs)
3019 AC_SUBST(float_h_file)
3020 AC_SUBST(gcc_config_arguments)
3021 AC_SUBST(gcc_gxx_include_dir)
3022 AC_SUBST(libstdcxx_incdir)
3023 AC_SUBST(gcc_version)
3024 AC_SUBST(gcc_version_full)
3025 AC_SUBST(gcc_version_trigger)
3026 AC_SUBST(host_exeext)
3027 AC_SUBST(host_extra_gcc_objs)
3028 AC_SUBST(host_xm_file_list)
3029 AC_SUBST(host_xm_include_list)
3030 AC_SUBST(host_xm_defines)
3031 AC_SUBST(out_host_hook_obj)
3032 AC_SUBST(install)
3033 AC_SUBST(lang_opt_files)
3034 AC_SUBST(lang_specs_files)
3035 AC_SUBST(lang_tree_files)
3036 AC_SUBST(local_prefix)
3037 AC_SUBST(md_file)
3038 AC_SUBST(objc_boehm_gc)
3039 AC_SUBST(out_file)
3040 AC_SUBST(out_object_file)
3041 AC_SUBST(stage_prefix_set_by_configure)
3042 AC_SUBST(quoted_stage_prefix_set_by_configure)
3043 AC_SUBST(symbolic_link)
3044 AC_SUBST(thread_file)
3045 AC_SUBST(tm_file_list)
3046 AC_SUBST(tm_include_list)
3047 AC_SUBST(tm_defines)
3048 AC_SUBST(tm_p_file_list)
3049 AC_SUBST(tm_p_include_list)
3050 AC_SUBST(xm_file_list)
3051 AC_SUBST(xm_include_list)
3052 AC_SUBST(xm_defines)
3053 AC_SUBST(target_noncanonical)
3054 AC_SUBST(c_target_objs)
3055 AC_SUBST(cxx_target_objs)
3056 AC_SUBST(target_cpu_default)
3057
3058 AC_SUBST_FILE(language_hooks)
3059
3060 # Echo link setup.
3061 if test x${build} = x${host} ; then
3062   if test x${host} = x${target} ; then
3063     echo "Links are now set up to build a native compiler for ${target}." 1>&2
3064   else
3065     echo "Links are now set up to build a cross-compiler" 1>&2
3066     echo " from ${host} to ${target}." 1>&2
3067   fi
3068 else
3069   if test x${host} = x${target} ; then
3070     echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
3071     echo " for ${target}." 1>&2
3072   else
3073     echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
3074     echo " from ${host} to ${target}." 1>&2
3075   fi
3076 fi
3077
3078 # Configure the subdirectories
3079 # AC_CONFIG_SUBDIRS($subdirs)
3080
3081 # Create the Makefile
3082 # and configure language subdirectories
3083 AC_CONFIG_FILES($all_outputs)
3084
3085 AC_CONFIG_COMMANDS([default],
3086 [
3087 case ${CONFIG_HEADERS} in
3088   *auto-host.h:config.in*)
3089   echo > cstamp-h ;;
3090 esac
3091 # Make sure all the subdirs exist.
3092 for d in $subdirs
3093 do
3094     test -d $d || mkdir $d
3095 done
3096 # If the host supports symlinks, point stage[1234] at ../stage[1234] so
3097 # bootstrapping and the installation procedure can still use
3098 # CC="stage1/xgcc -Bstage1/".  If the host doesn't support symlinks,
3099 # FLAGS_TO_PASS has been modified to solve the problem there.
3100 # This is virtually a duplicate of what happens in configure.lang; we do
3101 # an extra check to make sure this only happens if ln -s can be used.
3102 if test "$symbolic_link" = "ln -s"; then
3103  for d in ${subdirs} fixinc ; do
3104         STARTDIR=`${PWDCMD-pwd}`
3105         cd $d
3106         for t in stage1 stage2 stage3 stage4 stageprofile stagefeedback include
3107         do
3108                 rm -f $t
3109                 $symbolic_link ../$t $t 2>/dev/null
3110         done
3111         cd $STARTDIR
3112  done
3113 else true ; fi
3114 ],
3115 [subdirs='$subdirs'
3116 symbolic_link='$symbolic_link'
3117 ])
3118 AC_OUTPUT