gcc/configure.ac

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