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