gcc/configure.in

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