gcc/configure.ac

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