gcc/configure.ac

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