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