gcc/configure.ac

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