gcc/configure.in

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