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, 2005, 2006,
   5 # 2007, 2008, 2009, 2010, 2011 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 3, 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 COPYING3.  If not see
  21 #<http://www.gnu.org/licenses/>.
  22
  23 # --------------------------------
  24 # Initialization and sanity checks
  25 # --------------------------------
  26
  27 AC_PREREQ(2.64)
  28 AC_INIT
  29 AC_CONFIG_SRCDIR(tree.c)
  30 AC_CONFIG_HEADER(auto-host.h:config.in)
  31
  32 gcc_version=`cat $srcdir/BASE-VER`
  33
  34 # Determine the host, build, and target systems
  35 AC_CANONICAL_BUILD
  36 AC_CANONICAL_HOST
  37 AC_CANONICAL_TARGET
  38
  39 # Determine the noncanonical target name, for directory use.
  40 ACX_NONCANONICAL_TARGET
  41
  42 # Determine the target- and build-specific subdirectories
  43 GCC_TOPLEV_SUBDIRS
  44
  45 # Set program_transform_name
  46 AC_ARG_PROGRAM
  47
  48 # Check for bogus environment variables.
  49 # Test if LIBRARY_PATH contains the notation for the current directory
  50 # since this would lead to problems installing/building glibc.
  51 # LIBRARY_PATH contains the current directory if one of the following
  52 # is true:
  53 # - one of the terminals (":" and ";") is the first or last sign
  54 # - two terminals occur directly after each other
  55 # - the path contains an element with a dot in it
  56 AC_MSG_CHECKING(LIBRARY_PATH variable)
  57 changequote(,)dnl
  58 case ${LIBRARY_PATH} in
  59   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
  60     library_path_setting="contains current directory"
  61     ;;
  62   *)
  63     library_path_setting="ok"
  64     ;;
  65 esac
  66 changequote([,])dnl
  67 AC_MSG_RESULT($library_path_setting)
  68 if test "$library_path_setting" != "ok"; then
  69 AC_MSG_ERROR([
  70 *** LIBRARY_PATH shouldn't contain the current directory when
  71 *** building gcc. Please change the environment variable
  72 *** and run configure again.])
  73 fi
  74
  75 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
  76 # since this would lead to problems installing/building glibc.
  77 # GCC_EXEC_PREFIX contains the current directory if one of the following
  78 # is true:
  79 # - one of the terminals (":" and ";") is the first or last sign
  80 # - two terminals occur directly after each other
  81 # - the path contains an element with a dot in it
  82 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
  83 changequote(,)dnl
  84 case ${GCC_EXEC_PREFIX} in
  85   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
  86     gcc_exec_prefix_setting="contains current directory"
  87     ;;
  88   *)
  89     gcc_exec_prefix_setting="ok"
  90     ;;
  91 esac
  92 changequote([,])dnl
  93 AC_MSG_RESULT($gcc_exec_prefix_setting)
  94 if test "$gcc_exec_prefix_setting" != "ok"; then
  95 AC_MSG_ERROR([
  96 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
  97 *** building gcc. Please change the environment variable
  98 *** and run configure again.])
  99 fi
 100
 101 # -----------
 102 # Directories
 103 # -----------
 104
 105 # Specify the local prefix
 106 local_prefix=
 107 AC_ARG_WITH(local-prefix,
 108 [AS_HELP_STRING([--with-local-prefix=DIR],
 109                 [specifies directory to put local include])],
 110 [case "${withval}" in
 111 yes)    AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
 112 no)     ;;
 113 *)      local_prefix=$with_local_prefix ;;
 114 esac])
 115
 116 # Default local prefix if it is empty
 117 if test x$local_prefix = x; then
 118         local_prefix=/usr/local
 119 fi
 120
 121 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
 122 # passed in by the toplevel make and thus we'd get different behavior
 123 # depending on where we built the sources.
 124 gcc_gxx_include_dir=
 125 # Specify the g++ header file directory
 126 AC_ARG_WITH(gxx-include-dir,
 127 [AS_HELP_STRING([--with-gxx-include-dir=DIR],
 128                 [specifies directory to put g++ header files])],
 129 [case "${withval}" in
 130 yes)    AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
 131 no)     ;;
 132 *)      gcc_gxx_include_dir=$with_gxx_include_dir ;;
 133 esac])
 134
 135 # This logic must match libstdc++-v3/acinclude.m4:GLIBCXX_EXPORT_INSTALL_INFO.
 136 if test x${gcc_gxx_include_dir} = x; then
 137   if test x${enable_version_specific_runtime_libs} = xyes; then
 138     gcc_gxx_include_dir='${libsubdir}/include/c++'
 139   else
 140     libstdcxx_incdir='include/c++/$(version)'
 141     if test x$host != x$target; then
 142        libstdcxx_incdir="$target_alias/$libstdcxx_incdir"
 143     fi
 144     gcc_gxx_include_dir="\$(libsubdir)/\$(libsubdir_to_prefix)$libstdcxx_incdir"
 145   fi
 146 fi
 147
 148 AC_ARG_WITH(cpp_install_dir,
 149 [AC_HELP_STRING([--with-cpp-install-dir=DIR],
 150                 [install the user visible C preprocessor in DIR
 151                  (relative to PREFIX) as well as PREFIX/bin])],
 152 [if test x$withval = xyes; then
 153   AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
 154 elif test x$withval != xno; then
 155   cpp_install_dir=$withval
 156 fi])
 157
 158 # We would like to our source tree to be readonly.  However when releases or
 159 # pre-releases are generated, the flex/bison generated files as well as the
 160 # various formats of manuals need to be included along with the rest of the
 161 # sources.  Therefore we have --enable-generated-files-in-srcdir to do
 162 # just that.
 163
 164 AC_MSG_CHECKING([whether to place generated files in the source directory])
 165   dnl generated-files-in-srcdir is disabled by default
 166   AC_ARG_ENABLE(generated-files-in-srcdir,
 167     [AS_HELP_STRING([--enable-generated-files-in-srcdir],
 168                     [put copies of generated files in source dir
 169                      intended for creating source tarballs for users
 170                      without texinfo bison or flex])],
 171       generated_files_in_srcdir=$enableval,
 172       generated_files_in_srcdir=no)
 173
 174 AC_MSG_RESULT($generated_files_in_srcdir)
 175
 176 if test "$generated_files_in_srcdir" = "yes"; then
 177   GENINSRC=''
 178 else
 179   GENINSRC='#'
 180 fi
 181 AC_SUBST(GENINSRC)
 182
 183 # -------------------
 184 # Find default linker
 185 # -------------------
 186
 187 # With GNU ld
 188 AC_ARG_WITH(gnu-ld,
 189 [AS_HELP_STRING([--with-gnu-ld], [arrange to work with GNU ld])],
 190 gnu_ld_flag="$with_gnu_ld",
 191 gnu_ld_flag=no)
 192
 193 # With pre-defined ld
 194 AC_ARG_WITH(ld,
 195 [AS_HELP_STRING([--with-ld], [arrange to use the specified ld (full pathname)])],
 196 DEFAULT_LINKER="$with_ld")
 197 if test x"${DEFAULT_LINKER+set}" = x"set"; then
 198   if test ! -x "$DEFAULT_LINKER"; then
 199     AC_MSG_ERROR([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
 200   elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
 201     gnu_ld_flag=yes
 202   fi
 203   AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
 204         [Define to enable the use of a default linker.])
 205 fi
 206
 207 gnu_ld=`if test x"$gnu_ld_flag" = x"yes"; then echo 1; else echo 0; fi`
 208 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld, [Define if using GNU ld.])
 209
 210 AC_MSG_CHECKING([whether a default linker was specified])
 211 if test x"${DEFAULT_LINKER+set}" = x"set"; then
 212   if test x"$gnu_ld_flag" = x"no"; then
 213     AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
 214   else
 215     AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
 216   fi
 217 else
 218   AC_MSG_RESULT(no)
 219 fi
 220
 221 # With demangler in GNU ld
 222 AC_ARG_WITH(demangler-in-ld,
 223 [AS_HELP_STRING([--with-demangler-in-ld], [try to use demangler in GNU ld])],
 224 demangler_in_ld="$with_demangler_in_ld",
 225 demangler_in_ld=yes)
 226
 227 # ----------------------
 228 # Find default assembler
 229 # ----------------------
 230
 231 # With GNU as
 232 AC_ARG_WITH(gnu-as,
 233 [AS_HELP_STRING([--with-gnu-as], [arrange to work with GNU as])],
 234 gas_flag="$with_gnu_as",
 235 gas_flag=no)
 236
 237 AC_ARG_WITH(as,
 238 [AS_HELP_STRING([--with-as], [arrange to use the specified as (full pathname)])],
 239 DEFAULT_ASSEMBLER="$with_as")
 240 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
 241   if test ! -x "$DEFAULT_ASSEMBLER"; then
 242     AC_MSG_ERROR([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
 243   elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
 244     gas_flag=yes
 245   fi
 246   AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
 247         [Define to enable the use of a default assembler.])
 248 fi
 249
 250 gnu_as=`if test x"$gas_flag" = x"yes"; then echo 1; else echo 0; fi`
 251 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as, [Define if using GNU as.])
 252
 253 AC_MSG_CHECKING([whether a default assembler was specified])
 254 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
 255   if test x"$gas_flag" = x"no"; then
 256     AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
 257   else
 258     AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
 259   fi
 260 else
 261   AC_MSG_RESULT(no)
 262 fi
 263
 264 # ---------------
 265 # Find C compiler
 266 # ---------------
 267
 268 # If a non-executable a.out is present (e.g. created by GNU as above even if
 269 # invoked with -v only), the IRIX 6 native ld just overwrites the existing
 270 # file, even when creating an executable, so an execution test fails.
 271 # Remove possible default executable files to avoid this.
 272 #
 273 # FIXME: This really belongs into AC_PROG_CC and can be removed once
 274 # Autoconf includes it.
 275 rm -f a.out a.exe b.out
 276
 277 # Find the native compiler
 278 AC_PROG_CC
 279 AM_PROG_CC_C_O
 280 AC_PROG_CXX
 281 ACX_PROG_GNAT([-I"$srcdir"/ada])
 282
 283 # autoconf is lame and doesn't give us any substitution variable for this.
 284 if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = no"; then
 285   NO_MINUS_C_MINUS_O=yes
 286 else
 287   OUTPUT_OPTION='-o $@'
 288 fi
 289 AC_SUBST(NO_MINUS_C_MINUS_O)
 290 AC_SUBST(OUTPUT_OPTION)
 291
 292 # Remove the -O2: for historical reasons, unless bootstrapping we prefer
 293 # optimizations to be activated explicitly by the toplevel.
 294 case "$CC" in
 295   */prev-gcc/xgcc*) ;;
 296   *) CFLAGS=`echo $CFLAGS | sed "s/-O[[s0-9]]* *//" ` ;;
 297 esac
 298 AC_SUBST(CFLAGS)
 299
 300 # Determine PICFLAG for target gnatlib.
 301 GCC_PICFLAG_FOR_TARGET
 302 AC_SUBST(PICFLAG_FOR_TARGET)
 303
 304 # -------------------------
 305 # Check C compiler features
 306 # -------------------------
 307
 308 AC_USE_SYSTEM_EXTENSIONS
 309 AC_PROG_CPP
 310 AC_C_INLINE
 311
 312 AC_SYS_LARGEFILE
 313
 314 # sizeof(char) is 1 by definition.
 315 AC_CHECK_SIZEOF(void *)
 316 AC_CHECK_SIZEOF(short)
 317 AC_CHECK_SIZEOF(int)
 318 AC_CHECK_SIZEOF(long)
 319 AC_CHECK_TYPES([long long], [AC_CHECK_SIZEOF(long long)])
 320 AC_CHECK_TYPES([__int64], [AC_CHECK_SIZEOF(__int64)])
 321 GCC_STDINT_TYPES
 322
 323 # ---------------------
 324 # Warnings and checking
 325 # ---------------------
 326
 327 # Check $CC warning features (if it's GCC).
 328 # We want to use -pedantic, but we don't want warnings about
 329 # * 'long long'
 330 # * variadic macros
 331 # * overlong strings
 332 # * C++11 narrowing conversions in { }
 333 # So, we only use -pedantic if we can disable those warnings.
 334
 335 ACX_PROG_CC_WARNING_OPTS(
 336         m4_quote(m4_do([-W -Wall -Wno-narrowing -Wwrite-strings -Wcast-qual])), [loose_warn])
 337 ACX_PROG_CC_WARNING_OPTS(
 338         m4_quote(m4_do([-Wstrict-prototypes -Wmissing-prototypes])),
 339         [c_loose_warn])
 340 ACX_PROG_CC_WARNING_OPTS(
 341         m4_quote(m4_do([-Wmissing-format-attribute])), [strict_warn])
 342 ACX_PROG_CC_WARNING_OPTS(
 343         m4_quote(m4_do([-Wold-style-definition -Wc++-compat])), [c_strict_warn])
 344 ACX_PROG_CC_WARNING_ALMOST_PEDANTIC(
 345         m4_quote(m4_do([-Wno-long-long -Wno-variadic-macros ],
 346                        [-Wno-overlength-strings])), [strict_warn])
 347 ACX_PROG_CC_WARNINGS_ARE_ERRORS([manual], [strict_warn])
 348
 349 # The above macros do nothing if the compiler is not GCC.  However, the
 350 # Makefile has more goo to add other flags, so these variables are used
 351 # to enable warnings only for GCC.
 352 warn_cflags=
 353 warn_cxxflags=
 354 if test "x$GCC" = "xyes"; then
 355   warn_cflags='$(GCC_WARN_CFLAGS)'
 356   warn_cxxflags='$(GCC_WARN_CXXFLAGS)'
 357 fi
 358 AC_SUBST(warn_cflags)
 359 AC_SUBST(warn_cxxflags)
 360
 361 # Disable exceptions and RTTI if building with g++
 362 ACX_PROG_CC_WARNING_OPTS(
 363         m4_quote(m4_do([-fno-exceptions -fno-rtti])), [noexception_flags])
 364
 365 # Enable expensive internal checks
 366 is_release=
 367 if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then
 368   is_release=yes
 369 fi
 370
 371 AC_ARG_ENABLE(checking,
 372 [AS_HELP_STRING([[--enable-checking[=LIST]]],
 373                 [enable expensive run-time checks.  With LIST,
 374                  enable only specific categories of checks.
 375                  Categories are: yes,no,all,none,release.
 376                  Flags are: assert,df,fold,gc,gcac,gimple,misc,
 377                  rtlflag,rtl,runtime,tree,valgrind,types])],
 378 [ac_checking_flags="${enableval}"],[
 379 # Determine the default checks.
 380 if test x$is_release = x ; then
 381   ac_checking_flags=yes
 382 else
 383   ac_checking_flags=release
 384 fi])
 385 IFS="${IFS=     }"; ac_save_IFS="$IFS"; IFS="$IFS,"
 386 for check in release $ac_checking_flags
 387 do
 388         case $check in
 389         # these set all the flags to specific states
 390         yes)            ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking= ;
 391                         ac_fold_checking= ; ac_gc_checking=1 ;
 392                         ac_gc_always_collect= ; ac_gimple_checking=1 ; ac_rtl_checking= ;
 393                         ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
 394                         ac_tree_checking=1 ; ac_valgrind_checking= ;
 395                         ac_types_checking=1 ;;
 396         no|none)        ac_assert_checking= ; ac_checking= ; ac_df_checking= ;
 397                         ac_fold_checking= ; ac_gc_checking= ;
 398                         ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
 399                         ac_rtlflag_checking= ; ac_runtime_checking= ;
 400                         ac_tree_checking= ; ac_valgrind_checking= ;
 401                         ac_types_checking= ;;
 402         all)            ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking=1 ;
 403                         ac_fold_checking=1 ; ac_gc_checking=1 ;
 404                         ac_gc_always_collect=1 ; ac_gimple_checking=1 ; ac_rtl_checking=1 ;
 405                         ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
 406                         ac_tree_checking=1 ; ac_valgrind_checking= ;
 407                         ac_types_checking=1 ;;
 408         release)        ac_assert_checking=1 ; ac_checking= ; ac_df_checking= ;
 409                         ac_fold_checking= ; ac_gc_checking= ;
 410                         ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
 411                         ac_rtlflag_checking= ; ac_runtime_checking=1 ;
 412                         ac_tree_checking= ; ac_valgrind_checking= ;
 413                         ac_types_checking= ;;
 414         # these enable particular checks
 415         assert)         ac_assert_checking=1 ;;
 416         df)             ac_df_checking=1 ;;
 417         fold)           ac_fold_checking=1 ;;
 418         gc)             ac_gc_checking=1 ;;
 419         gcac)           ac_gc_always_collect=1 ;;
 420         gimple)         ac_gimple_checking=1 ;;
 421         misc)           ac_checking=1 ;;
 422         rtl)            ac_rtl_checking=1 ;;
 423         rtlflag)        ac_rtlflag_checking=1 ;;
 424         runtime)        ac_runtime_checking=1 ;;
 425         tree)           ac_tree_checking=1 ;;
 426         types)          ac_types_checking=1 ;;
 427         valgrind)       ac_valgrind_checking=1 ;;
 428         *)      AC_MSG_ERROR(unknown check category $check) ;;
 429         esac
 430 done
 431 IFS="$ac_save_IFS"
 432
 433 nocommon_flag=""
 434 if test x$ac_checking != x ; then
 435   AC_DEFINE(ENABLE_CHECKING, 1,
 436 [Define if you want more run-time sanity checks.  This one gets a grab
 437    bag of miscellaneous but relatively cheap checks.])
 438   nocommon_flag=-fno-common
 439 fi
 440 AC_SUBST(nocommon_flag)
 441 if test x$ac_df_checking != x ; then
 442   AC_DEFINE(ENABLE_DF_CHECKING, 1,
 443 [Define if you want more run-time sanity checks for dataflow.])
 444 fi
 445 if test x$ac_assert_checking != x ; then
 446   AC_DEFINE(ENABLE_ASSERT_CHECKING, 1,
 447 [Define if you want assertions enabled.  This is a cheap check.])
 448 fi
 449 if test x$ac_gimple_checking != x ; then
 450   AC_DEFINE(ENABLE_GIMPLE_CHECKING, 1,
 451 [Define if you want operations on GIMPLE (the basic data structure of
 452 the high-level optimizers) to be checked for dynamic type safety at
 453 runtime.  This is moderately expensive.])
 454 fi
 455 GCC_TARGET_TEMPLATE(ENABLE_RUNTIME_CHECKING)
 456 if test x$ac_runtime_checking != x ; then
 457   AC_DEFINE(ENABLE_RUNTIME_CHECKING, 1,
 458 [Define if you want runtime assertions enabled.  This is a cheap check.])
 459 fi
 460 if test x$ac_tree_checking != x ; then
 461   AC_DEFINE(ENABLE_TREE_CHECKING, 1,
 462 [Define if you want all operations on trees (the basic data
 463    structure of the front ends) to be checked for dynamic type safety
 464    at runtime.  This is moderately expensive.  The tree browser debugging
 465    routines will also be enabled by this option.
 466    ])
 467   TREEBROWSER=tree-browser.o
 468 fi
 469 if test x$ac_types_checking != x ; then
 470   AC_DEFINE(ENABLE_TYPES_CHECKING, 1,
 471 [Define if you want all gimple types to be verified after gimplifiation.
 472    This is cheap.
 473    ])
 474 fi
 475 AC_SUBST(TREEBROWSER)
 476 if test x$ac_rtl_checking != x ; then
 477   AC_DEFINE(ENABLE_RTL_CHECKING, 1,
 478 [Define if you want all operations on RTL (the basic data structure
 479    of the optimizer and back end) to be checked for dynamic type safety
 480    at runtime.  This is quite expensive.])
 481 fi
 482 if test x$ac_rtlflag_checking != x ; then
 483   AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
 484 [Define if you want RTL flag accesses to be checked against the RTL
 485    codes that are supported for each access macro.  This is relatively
 486    cheap.])
 487 fi
 488 if test x$ac_gc_checking != x ; then
 489   AC_DEFINE(ENABLE_GC_CHECKING, 1,
 490 [Define if you want the garbage collector to do object poisoning and
 491    other memory allocation checks.  This is quite expensive.])
 492 fi
 493 if test x$ac_gc_always_collect != x ; then
 494   AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
 495 [Define if you want the garbage collector to operate in maximally
 496    paranoid mode, validating the entire heap and collecting garbage at
 497    every opportunity.  This is extremely expensive.])
 498 fi
 499 if test x$ac_fold_checking != x ; then
 500   AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
 501 [Define if you want fold checked that it never destructs its argument.
 502    This is quite expensive.])
 503 fi
 504 valgrind_path_defines=
 505 valgrind_command=
 506
 507 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
 508 dnl # an if statement.  This was the source of very frustrating bugs
 509 dnl # in converting to autoconf 2.5x!
 510 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
 511
 512 if test x$ac_valgrind_checking != x ; then
 513   # It is certainly possible that there's valgrind but no valgrind.h.
 514   # GCC relies on making annotations so we must have both.
 515   AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
 516   AC_PREPROC_IFELSE([AC_LANG_SOURCE(
 517     [[#include <valgrind/memcheck.h>
 518 #ifndef VALGRIND_DISCARD
 519 #error VALGRIND_DISCARD not defined
 520 #endif]])],
 521   [gcc_cv_header_valgrind_memcheck_h=yes],
 522   [gcc_cv_header_valgrind_memcheck_h=no])
 523   AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
 524   AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
 525   AC_PREPROC_IFELSE([AC_LANG_SOURCE(
 526     [[#include <memcheck.h>
 527 #ifndef VALGRIND_DISCARD
 528 #error VALGRIND_DISCARD not defined
 529 #endif]])],
 530   [gcc_cv_header_memcheck_h=yes],
 531   [gcc_cv_header_memcheck_h=no])
 532   AC_MSG_RESULT($gcc_cv_header_memcheck_h)
 533   AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
 534         [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
 535   if test "x$valgrind_path" = "x" \
 536     || (test $have_valgrind_h = no \
 537         && test $gcc_cv_header_memcheck_h = no \
 538         && test $gcc_cv_header_valgrind_memcheck_h = no); then
 539         AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
 540   fi
 541   valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
 542   valgrind_command="$valgrind_path -q"
 543   AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
 544 [Define if you want to run subprograms and generated programs
 545    through valgrind (a memory checker).  This is extremely expensive.])
 546   if test $gcc_cv_header_valgrind_memcheck_h = yes; then
 547     AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
 548         [Define if valgrind's valgrind/memcheck.h header is installed.])
 549   fi
 550   if test $gcc_cv_header_memcheck_h = yes; then
 551     AC_DEFINE(HAVE_MEMCHECK_H, 1,
 552         [Define if valgrind's memcheck.h header is installed.])
 553   fi
 554 fi
 555 AC_SUBST(valgrind_path_defines)
 556 AC_SUBST(valgrind_command)
 557
 558 # Enable code coverage collection
 559 AC_ARG_ENABLE(coverage,
 560 [AS_HELP_STRING([[--enable-coverage[=LEVEL]]],
 561                 [enable compiler's code coverage collection.
 562                  Use to measure compiler performance and locate
 563                  unused parts of the compiler. With LEVEL, specify
 564                  optimization. Values are opt, noopt,
 565                  default is noopt])],
 566 [case "${enableval}" in
 567   yes|noopt)
 568     coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
 569     ;;
 570   opt)
 571     coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
 572     ;;
 573   no)
 574     # a.k.a. --disable-coverage
 575     coverage_flags=""
 576     ;;
 577   *)
 578     AC_MSG_ERROR(unknown coverage setting $enableval)
 579     ;;
 580 esac],
 581 [coverage_flags=""])
 582 AC_SUBST(coverage_flags)
 583
 584 AC_ARG_ENABLE(gather-detailed-mem-stats,
 585 [AS_HELP_STRING([--enable-gather-detailed-mem-stats],
 586                 [enable detailed memory allocation stats gathering])], [],
 587 [enable_gather_detailed_mem_stats=no])
 588 if test x$enable_gather_detailed_mem_stats = xyes ; then
 589   AC_DEFINE(GATHER_STATISTICS, 1,
 590         [Define to enable detailed memory allocation stats gathering.])
 591 fi
 592
 593 # -------------------------------
 594 # Miscenalleous configure options
 595 # -------------------------------
 596
 597 # See if we are building gcc with C++.
 598 AC_ARG_ENABLE(build-with-cxx,
 599 [AS_HELP_STRING([--enable-build-with-cxx],
 600                 [build with C++ compiler instead of C compiler])],
 601 ENABLE_BUILD_WITH_CXX=$enableval,
 602 ENABLE_BUILD_WITH_CXX=no)
 603 AC_SUBST(ENABLE_BUILD_WITH_CXX)
 604 if test "$ENABLE_BUILD_WITH_CXX" = "yes"; then
 605   AC_DEFINE(ENABLE_BUILD_WITH_CXX, 1,
 606             [Define if building with C++.])
 607 fi
 608
 609 # With stabs
 610 AC_ARG_WITH(stabs,
 611 [AS_HELP_STRING([--with-stabs],
 612                 [arrange to use stabs instead of host debug format])],
 613 stabs="$with_stabs",
 614 stabs=no)
 615
 616 # Determine whether or not multilibs are enabled.
 617 AC_ARG_ENABLE(multilib,
 618 [AS_HELP_STRING([--enable-multilib],
 619                 [enable library support for multiple ABIs])],
 620 [], [enable_multilib=yes])
 621 AC_SUBST(enable_multilib)
 622
 623 # Enable __cxa_atexit for C++.
 624 AC_ARG_ENABLE(__cxa_atexit,
 625 [AS_HELP_STRING([--enable-__cxa_atexit], [enable __cxa_atexit for C++])],
 626 [], [])
 627
 628 # Enable C extension for decimal float if target supports it.
 629 GCC_AC_ENABLE_DECIMAL_FLOAT([$target])
 630
 631 dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi`
 632 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp,
 633 [Define to 1 to enable decimal float extension to C.])
 634
 635 # Use default_decimal_float for dependency.
 636 enable_decimal_float=$default_decimal_float
 637
 638 bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi`
 639 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid,
 640 [Define to 1 to specify that we are using the BID decimal floating
 641 point format instead of DPD])
 642
 643 # Enable C extension for fixed-point arithmetic.
 644 AC_ARG_ENABLE(fixed-point,
 645 [AS_HELP_STRING([--enable-fixed-point],
 646                 [enable fixed-point arithmetic extension to C])],
 647 [],
 648 [
 649   case $target in
 650     arm*)
 651       enable_fixed_point=yes
 652       ;;
 653
 654     mips*-*-*)
 655       case $host in
 656         mips*-sgi-irix*)
 657           AC_MSG_WARN([fixed-point is not supported on IRIX, ignored])
 658           enable_fixed_point=no
 659           ;;
 660         *)
 661           enable_fixed_point=yes
 662           ;;
 663       esac
 664       ;;
 665     *)
 666       AC_MSG_WARN([fixed-point is not supported for this target, ignored])
 667       enable_fixed_point=no
 668       ;;
 669   esac
 670 ])
 671 AC_SUBST(enable_fixed_point)
 672
 673 fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi`
 674 AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint,
 675 [Define to 1 to enable fixed-point arithmetic extension to C.])
 676
 677 # Enable threads
 678 # Pass with no value to take the default
 679 # Pass with a value to specify a thread package
 680 AC_ARG_ENABLE(threads,
 681 [AS_HELP_STRING([[--enable-threads[=LIB]]],
 682                 [enable thread usage for target GCC,
 683                  using LIB thread package])],,
 684 [enable_threads=''])
 685
 686 AC_ARG_ENABLE(tls,
 687 [AS_HELP_STRING([--enable-tls],
 688                 [enable or disable generation of tls code
 689                  overriding the assembler check for tls support])],
 690 [
 691   case $enable_tls in
 692     yes | no) ;;
 693     *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
 694 Valid choices are 'yes' and 'no'.]) ;;
 695   esac
 696 ], [enable_tls=''])
 697
 698 AC_ARG_ENABLE(objc-gc,
 699 [AS_HELP_STRING([--enable-objc-gc],
 700                 [enable the use of Boehm's garbage collector with
 701                  the GNU Objective-C runtime])],
 702 if test x$enable_objc_gc = xno; then
 703         objc_boehm_gc=''
 704 else
 705         objc_boehm_gc=1
 706 fi,
 707 objc_boehm_gc='')
 708
 709 AC_ARG_WITH(dwarf2,
 710 [AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2])],
 711 dwarf2="$with_dwarf2",
 712 dwarf2=no)
 713
 714 AC_ARG_ENABLE(shared,
 715 [AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])],
 716 [
 717   case $enable_shared in
 718   yes | no) ;;
 719   *)
 720     enable_shared=no
 721     IFS="${IFS=         }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
 722     for pkg in $enableval; do
 723       if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
 724         enable_shared=yes
 725       fi
 726     done
 727     IFS="$ac_save_ifs"
 728     ;;
 729   esac
 730 ], [enable_shared=yes])
 731 AC_SUBST(enable_shared)
 732
 733 AC_ARG_WITH([native-system-header-dir],
 734   [  --with-native-system-header-dir=dir
 735                           use dir as the directory to look for standard
 736                           system header files in.  Defaults to /usr/include.],
 737 [
 738  case ${with_native_system_header_dir} in
 739  yes|no) AC_MSG_ERROR([bad value ${withval} given for --with-native-system-header-dir]) ;;
 740  /* | [[A-Za-z]]:[[\\/]]*) ;;
 741  *) AC_MSG_ERROR([--with-native-system-header-dir argument ${withval} must be an absolute directory]) ;;
 742  esac
 743  configured_native_system_header_dir="${withval}"
 744 ], [configured_native_system_header_dir=])
 745
 746 AC_ARG_WITH(build-sysroot,
 747   [AS_HELP_STRING([--with-build-sysroot=sysroot],
 748                   [use sysroot as the system root during the build])],
 749   [if test x"$withval" != x ; then
 750      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
 751    fi],
 752   [SYSROOT_CFLAGS_FOR_TARGET=])
 753 AC_SUBST(SYSROOT_CFLAGS_FOR_TARGET)
 754
 755 AC_ARG_WITH(sysroot,
 756 [AS_HELP_STRING([[--with-sysroot[=DIR]]],
 757                 [search for usr/lib, usr/include, et al, within DIR])],
 758 [
 759  case ${with_sysroot} in
 760  yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
 761  *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
 762  esac
 763
 764  TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
 765  CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
 766
 767  if test "x$prefix" = xNONE; then
 768   test_prefix=/usr/local
 769  else
 770   test_prefix=$prefix
 771  fi
 772  if test "x$exec_prefix" = xNONE; then
 773   test_exec_prefix=$test_prefix
 774  else
 775   test_exec_prefix=$exec_prefix
 776  fi
 777  case ${TARGET_SYSTEM_ROOT} in
 778  "${test_prefix}"|"${test_prefix}/"*|\
 779  "${test_exec_prefix}"|"${test_exec_prefix}/"*|\
 780  '${prefix}'|'${prefix}/'*|\
 781  '${exec_prefix}'|'${exec_prefix}/'*)
 782    t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
 783    TARGET_SYSTEM_ROOT_DEFINE="$t"
 784    ;;
 785  esac
 786 ], [
 787  TARGET_SYSTEM_ROOT=
 788  TARGET_SYSTEM_ROOT_DEFINE=
 789  CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
 790 ])
 791 AC_SUBST(TARGET_SYSTEM_ROOT)
 792 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
 793 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
 794
 795 AC_ARG_WITH(specs,
 796   [AS_HELP_STRING([--with-specs=SPECS],
 797                   [add SPECS to driver command-line processing])],
 798   [CONFIGURE_SPECS=$withval],
 799   [CONFIGURE_SPECS=]
 800 )
 801 AC_SUBST(CONFIGURE_SPECS)
 802
 803 ACX_PKGVERSION([GCC])
 804 ACX_BUGURL([http://gcc.gnu.org/bugs.html])
 805
 806 # Sanity check enable_languages in case someone does not run the toplevel
 807 # configure # script.
 808 AC_ARG_ENABLE(languages,
 809 [AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])],
 810 [case ,${enable_languages}, in
 811        ,,|,yes,)
 812                 # go safe -- we cannot be much sure without the toplevel
 813                 # configure's
 814                 # analysis of which target libs are present and usable
 815                 enable_languages=c
 816                 ;;
 817          *,all,*)
 818                 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
 819                 ;;
 820         *,c,*)
 821                 ;;
 822         *)
 823                 enable_languages=c,${enable_languages}
 824                 ;;
 825 esac],
 826 [enable_languages=c])
 827
 828 AC_ARG_WITH(multilib-list,
 829 [AS_HELP_STRING([--with-multilib-list], [select multilibs (SH and x86-64 only)])],
 830 :,
 831 with_multilib_list=default)
 832
 833 # -------------------------
 834 # Checks for other programs
 835 # -------------------------
 836
 837 AC_PROG_MAKE_SET
 838
 839 # Find some useful tools
 840 AC_PROG_AWK
 841 # We need awk to create options.c and options.h.
 842 # Bail out if it's missing.
 843 case ${AWK} in
 844   "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
 845 esac
 846
 847 gcc_AC_PROG_LN_S
 848 ACX_PROG_LN($LN_S)
 849 AC_PROG_RANLIB
 850 ranlib_flags=""
 851 AC_SUBST(ranlib_flags)
 852
 853 gcc_AC_PROG_INSTALL
 854
 855 # See if cmp has --ignore-initial.
 856 gcc_AC_PROG_CMP_IGNORE_INITIAL
 857
 858 # See if we have the mktemp command.
 859 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
 860
 861 # See if makeinfo has been installed and is modern enough
 862 # that we can use it.
 863 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
 864   [GNU texinfo.* \([0-9][0-9.]*\)],
 865   [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
 866 if test $gcc_cv_prog_makeinfo_modern = no; then
 867   AC_MSG_WARN([
 868 *** Makeinfo is missing or too old.
 869 *** Info documentation will not be built.])
 870   BUILD_INFO=
 871 else
 872   BUILD_INFO=info
 873 fi
 874 AC_SUBST(BUILD_INFO)
 875
 876 # Is pod2man recent enough to regenerate manpages?
 877 AC_MSG_CHECKING([for recent Pod::Man])
 878 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
 879   AC_MSG_RESULT(yes)
 880   GENERATED_MANPAGES=generated-manpages
 881 else
 882   AC_MSG_RESULT(no)
 883   GENERATED_MANPAGES=
 884 fi
 885 AC_SUBST(GENERATED_MANPAGES)
 886
 887 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
 888
 889 # How about lex?
 890 dnl Don't use AC_PROG_LEX; we insist on flex.
 891 dnl LEXLIB is not useful in gcc.
 892 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
 893
 894 # Bison?
 895 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
 896
 897 # Binutils are not build modules, unlike bison/flex/makeinfo.  So we
 898 # check for build == host before using them.
 899
 900 # NM
 901 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
 902   && test -d ../binutils ; then
 903   NM='${objdir}/../binutils/nm-new'
 904 else
 905   AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
 906 fi
 907
 908 # AR
 909 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
 910   && test -d ../binutils ; then
 911   AR='${objdir}/../binutils/ar'
 912 else
 913   AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
 914 fi
 915
 916
 917 # --------------------
 918 # Checks for C headers
 919 # --------------------
 920
 921 # Need to reject headers which give warnings, so that the -Werror bootstrap
 922 # works later. *sigh*  This needs to come before all header checks.
 923 AC_PROG_CPP_WERROR
 924
 925 AC_HEADER_STDC
 926 AC_HEADER_TIME
 927 ACX_HEADER_STRING
 928 AC_HEADER_SYS_WAIT
 929 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
 930                  fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
 931                  sys/resource.h sys/param.h sys/times.h sys/stat.h \
 932                  direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
 933
 934 # Check for thread headers.
 935 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
 936 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
 937
 938 # These tests can't be done till we know if we have limits.h.
 939 gcc_AC_C_CHAR_BIT
 940 AC_C_BIGENDIAN
 941
 942 # ----------------------
 943 # Checks for C++ headers
 944 # ----------------------
 945
 946 dnl Autoconf will give an error in the configure script if there is no
 947 dnl C++ preprocessor.  Hack to prevent that.
 948 m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl
 949 AC_PROG_CXXCPP
 950 m4_popdef([AC_MSG_ERROR])[]dnl
 951
 952 AC_LANG_PUSH(C++)
 953
 954 AC_CHECK_HEADERS(unordered_map)
 955 AC_CHECK_HEADERS(tr1/unordered_map)
 956 AC_CHECK_HEADERS(ext/hash_map)
 957
 958 AC_LANG_POP(C++)
 959
 960 # --------
 961 # UNSORTED
 962 # --------
 963
 964
 965 # These libraries may be used by collect2.
 966 # We may need a special search path to get them linked.
 967 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
 968 [save_LIBS="$LIBS"
 969 for libs in '' -lld -lmld \
 970                 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
 971                 '-L/usr/lib/cmplrs/cc3.11 -lmld'
 972 do
 973         LIBS="$libs"
 974         AC_TRY_LINK_FUNC(ldopen,
 975                 [gcc_cv_collect2_libs="$libs"; break])
 976 done
 977 LIBS="$save_LIBS"
 978 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
 979 case $gcc_cv_collect2_libs in
 980         "none required")        ;;
 981         *)      COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
 982 esac
 983 AC_SUBST(COLLECT2_LIBS)
 984
 985 # When building Ada code on Alpha, we need exc_resume which is usually in
 986 # -lexc.  So test for it.
 987 save_LIBS="$LIBS"
 988 LIBS=
 989 AC_SEARCH_LIBS(exc_resume, exc)
 990 GNAT_LIBEXC="$LIBS"
 991 LIBS="$save_LIBS"
 992 AC_SUBST(GNAT_LIBEXC)
 993
 994 # To support -mcpu=native on Solaris/SPARC, we need libkstat.
 995 save_LIBS="$LIBS"
 996 LIBS=
 997 AC_SEARCH_LIBS(kstat_open, kstat)
 998 EXTRA_GCC_LIBS="$LIBS"
 999 LIBS="$save_LIBS"
1000 AC_SUBST(EXTRA_GCC_LIBS)
1001
1002 # Some systems put ldexp and frexp in libm instead of libc; assume
1003 # they're both in the same place.  jcf-dump needs them.
1004 save_LIBS="$LIBS"
1005 LIBS=
1006 AC_SEARCH_LIBS(ldexp, m)
1007 LDEXP_LIB="$LIBS"
1008 LIBS="$save_LIBS"
1009 AC_SUBST(LDEXP_LIB)
1010
1011 # Use <inttypes.h> only if it exists,
1012 # doesn't clash with <sys/types.h>, and declares intmax_t.
1013 AC_MSG_CHECKING(for inttypes.h)
1014 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
1015 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1016 [[#include <sys/types.h>
1017 #include <inttypes.h>]],
1018   [[intmax_t i = -1;]])],
1019   [gcc_cv_header_inttypes_h=yes],
1020   [gcc_cv_header_inttypes_h=no])])
1021 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
1022 if test $gcc_cv_header_inttypes_h = yes; then
1023   AC_DEFINE(HAVE_INTTYPES_H, 1,
1024         [Define if you have a working <inttypes.h> header file.])
1025 fi
1026
1027 dnl Disabled until we have a complete test for buggy enum bitfields.
1028 dnl gcc_AC_C_ENUM_BF_UNSIGNED
1029
1030 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
1031   ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
1032   fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
1033   fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
1034   putchar_unlocked putc_unlocked)
1035 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoll atoq \
1036         sysconf strsignal getrusage nl_langinfo \
1037         gettimeofday mbstowcs wcswidth mmap setlocale \
1038         gcc_UNLOCKED_FUNCS madvise)
1039
1040 if test x$ac_cv_func_mbstowcs = xyes; then
1041   AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
1042 [    AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
1043 int main()
1044 {
1045   mbstowcs(0, "", 0);
1046   return 0;
1047 }]])],
1048     [gcc_cv_func_mbstowcs_works=yes],
1049     [gcc_cv_func_mbstowcs_works=no],
1050     [gcc_cv_func_mbstowcs_works=yes])])
1051   if test x$gcc_cv_func_mbstowcs_works = xyes; then
1052     AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
1053   [Define this macro if mbstowcs does not crash when its
1054    first argument is NULL.])
1055   fi
1056 fi
1057
1058 AC_CHECK_TYPE(ssize_t, int)
1059 AC_CHECK_TYPE(caddr_t, char *)
1060
1061 gcc_AC_FUNC_MMAP_BLACKLIST
1062
1063 case "${host}" in
1064 *-*-*vms*)
1065   # Under VMS, vfork works very differently than on Unix. The standard test
1066   # won't work, and it isn't easily adaptable. It makes more sense to
1067   # just force it.
1068   ac_cv_func_vfork_works=yes
1069   ;;
1070 esac
1071 AC_FUNC_FORK
1072
1073 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which exposes a different
1074 # iconv() prototype.
1075 AS_IF([test "$ENABLE_BUILD_WITH_CXX" = "yes"],
1076   [AC_LANG_PUSH([C++])
1077    AM_ICONV
1078    AC_LANG_POP([C++])],
1079   [AM_ICONV])
1080
1081 # Until we have in-tree GNU iconv:
1082 LIBICONV_DEP=
1083 AC_SUBST(LIBICONV_DEP)
1084
1085 AM_LC_MESSAGES
1086
1087 AM_LANGINFO_CODESET
1088
1089 # We will need to find libiberty.h and ansidecl.h
1090 saved_CFLAGS="$CFLAGS"
1091 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include"
1092 saved_CXXFLAGS="$CXXFLAGS"
1093 CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include"
1094 gcc_AC_CHECK_DECLS(getenv atol asprintf sbrk abort atof getcwd getwd \
1095         strsignal strstr stpcpy strverscmp \
1096         errno snprintf vsnprintf vasprintf malloc realloc calloc \
1097         free basename getopt clock getpagesize gcc_UNLOCKED_FUNCS, , ,[
1098 #include "ansidecl.h"
1099 #include "system.h"])
1100
1101 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1102 #include "ansidecl.h"
1103 #include "system.h"
1104 #ifdef HAVE_SYS_RESOURCE_H
1105 #include <sys/resource.h>
1106 #endif
1107 ])
1108
1109 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1110 #include "ansidecl.h"
1111 #include "system.h"
1112 #ifdef HAVE_SYS_RESOURCE_H
1113 #include <sys/resource.h>
1114 #endif
1115 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1116 [Define to `long' if <sys/resource.h> doesn't define.])])
1117
1118 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1119 # FREAD and FWRITE macros.  Fortunately, for GCC's single usage of ldgetname
1120 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1121 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1122 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1123 #include "ansidecl.h"
1124 #include "system.h"
1125 #ifdef HAVE_LDFCN_H
1126 #undef FREAD
1127 #undef FWRITE
1128 #include <ldfcn.h>
1129 #endif
1130 ])
1131
1132 gcc_AC_CHECK_DECLS(times, , ,[
1133 #include "ansidecl.h"
1134 #include "system.h"
1135 #ifdef HAVE_SYS_TIMES_H
1136 #include <sys/times.h>
1137 #endif
1138 ])
1139
1140 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1141 #include "ansidecl.h"
1142 #include "system.h"
1143 #include <signal.h>
1144 ])
1145
1146 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which hides the madvise()
1147 # prototype.
1148 AS_IF([test "$ENABLE_BUILD_WITH_CXX" = "yes"],
1149   [AC_LANG_PUSH([C++])
1150    gcc_AC_CHECK_DECLS(madvise, , ,[
1151      #include "ansidecl.h"
1152      #include "system.h"
1153    ])
1154    AC_LANG_POP([C++])],
1155   [gcc_AC_CHECK_DECLS(madvise, , ,[
1156      #include "ansidecl.h"
1157      #include "system.h"
1158    ])
1159 ])
1160
1161 # More time-related stuff.
1162 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1163 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1164 #include "ansidecl.h"
1165 #include "system.h"
1166 #ifdef HAVE_SYS_TIMES_H
1167 #include <sys/times.h>
1168 #endif
1169 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1170 if test $ac_cv_struct_tms = yes; then
1171   AC_DEFINE(HAVE_STRUCT_TMS, 1,
1172   [Define if <sys/times.h> defines struct tms.])
1173 fi
1174
1175 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1176 # revisit after autoconf 2.50.
1177 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1178 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1179 #include "ansidecl.h"
1180 #include "system.h"
1181 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1182 if test $gcc_cv_type_clock_t = yes; then
1183   AC_DEFINE(HAVE_CLOCK_T, 1,
1184   [Define if <time.h> defines clock_t.])
1185 fi
1186
1187 # Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1188 CFLAGS="$saved_CFLAGS"
1189 CXXFLAGS="$saved_CXXFLAGS"
1190
1191 gcc_AC_INITFINI_ARRAY
1192
1193 # mkdir takes a single argument on some systems.
1194 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1195
1196 # File extensions
1197 manext='.1'
1198 objext='.o'
1199 AC_SUBST(manext)
1200 AC_SUBST(objext)
1201
1202 # With Setjmp/Longjmp based exception handling.
1203 AC_ARG_ENABLE(sjlj-exceptions,
1204 [AS_HELP_STRING([--enable-sjlj-exceptions],
1205                 [arrange to use setjmp/longjmp exception handling])],
1206 [case $target in
1207   *-*-hpux10*)
1208     if test $enableval != yes; then
1209       AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1210       enableval=yes
1211     fi
1212     ;;
1213 esac
1214 force_sjlj_exceptions=yes],
1215 [case $target in
1216   *-*-hpux10*)
1217     force_sjlj_exceptions=yes
1218     enableval=yes
1219     ;;
1220   *)
1221     force_sjlj_exceptions=no
1222     ;;
1223 esac])
1224 if test $force_sjlj_exceptions = yes; then
1225   sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1226   AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1227     [Define 0/1 to force the choice for exception handling model.])
1228 fi
1229
1230 # --------------------------------------------------------
1231 # Build, host, and target specific configuration fragments
1232 # --------------------------------------------------------
1233
1234 # Collect build-machine-specific information.
1235 . ${srcdir}/config.build
1236
1237 # Collect host-machine-specific information.
1238 . ${srcdir}/config.host
1239
1240 target_gtfiles=
1241
1242 # Collect target-machine-specific information.
1243 . ${srcdir}/config.gcc
1244
1245 extra_objs="${host_extra_objs} ${extra_objs}"
1246 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1247
1248 # Default the target-machine variables that were not explicitly set.
1249 if test x"$tm_file" = x
1250 then tm_file=$cpu_type/$cpu_type.h; fi
1251
1252 if test x"$extra_headers" = x
1253 then extra_headers=; fi
1254
1255 if test x$md_file = x
1256 then md_file=$cpu_type/$cpu_type.md; fi
1257
1258 if test x$out_file = x
1259 then out_file=$cpu_type/$cpu_type.c; fi
1260
1261 if test x"$tmake_file" = x
1262 then tmake_file=$cpu_type/t-$cpu_type
1263 fi
1264
1265 if test x"$dwarf2" = xyes
1266 then tm_file="$tm_file tm-dwarf2.h"
1267 fi
1268
1269 # Say what files are being used for the output code and MD file.
1270 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1271 echo "Using \`$srcdir/config/$md_file' as machine description file."
1272
1273 # If any of the xm_file variables contain nonexistent files, warn
1274 # about them and drop them.
1275
1276 bx=
1277 for x in $build_xm_file; do
1278   if    test -f $srcdir/config/$x
1279   then      bx="$bx $x"
1280   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1281   fi
1282 done
1283 build_xm_file="$bx"
1284
1285 hx=
1286 for x in $host_xm_file; do
1287   if    test -f $srcdir/config/$x
1288   then      hx="$hx $x"
1289   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1290   fi
1291 done
1292 host_xm_file="$hx"
1293
1294 tx=
1295 for x in $xm_file; do
1296   if    test -f $srcdir/config/$x
1297   then      tx="$tx $x"
1298   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1299   fi
1300 done
1301 xm_file="$tx"
1302
1303 count=a
1304 for f in $tm_file; do
1305         count=${count}x
1306 done
1307 if test $count = ax; then
1308         echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1309 else
1310         echo "Using the following target machine macro files:"
1311         for f in $tm_file; do
1312                 echo "  $srcdir/config/$f"
1313         done
1314 fi
1315
1316 if test x$need_64bit_hwint = xyes; then
1317         AC_DEFINE(NEED_64BIT_HOST_WIDE_INT, 1,
1318 [Define to 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h).])
1319 fi
1320
1321 if test x$use_long_long_for_widest_fast_int = xyes; then
1322         AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1323 [Define to 1 if the 'long long' (or '__int64') is wider than 'long' but still
1324 efficiently supported by the host hardware.])
1325 fi
1326
1327 count=a
1328 for f in $host_xm_file; do
1329         count=${count}x
1330 done
1331 if test $count = a; then
1332         :
1333 elif test $count = ax; then
1334         echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1335 else
1336         echo "Using the following host machine macro files:"
1337         for f in $host_xm_file; do
1338                 echo "  $srcdir/config/$f"
1339         done
1340 fi
1341 echo "Using ${out_host_hook_obj} for host machine hooks."
1342
1343 if test "$host_xm_file" != "$build_xm_file"; then
1344         count=a
1345         for f in $build_xm_file; do
1346                 count=${count}x
1347         done
1348         if test $count = a; then
1349                 :
1350         elif test $count = ax; then
1351                 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1352         else
1353                 echo "Using the following build machine macro files:"
1354                 for f in $build_xm_file; do
1355                         echo "  $srcdir/config/$f"
1356                 done
1357         fi
1358 fi
1359
1360 if test -n "$configured_native_system_header_dir"; then
1361   native_system_header_dir=$configured_native_system_header_dir
1362 fi
1363 NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir"
1364 AC_SUBST(NATIVE_SYSTEM_HEADER_DIR)
1365
1366 case ${host} in
1367   powerpc*-*-darwin*)
1368     AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1369       gcc_cv_mcontext_underscores,
1370       AC_COMPILE_IFELSE([
1371 #include <sys/cdefs.h>
1372 #include <sys/signal.h>
1373 #include <ucontext.h>
1374 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1375 ],
1376         gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1377       if test $gcc_cv_mcontext_underscores = yes; then
1378         AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1379           [mcontext_t fields start with __])
1380       fi
1381     ;;
1382 esac
1383
1384 # ---------
1385 # Threading
1386 # ---------
1387
1388 # Check if a valid thread package
1389 case ${enable_threads} in
1390   "" | no)
1391     # No threads
1392     target_thread_file='single'
1393     ;;
1394   yes)
1395     # default
1396     target_thread_file='single'
1397     ;;
1398   aix | dce | lynx | mipssde | posix | rtems | \
1399   single | tpf | vxworks | win32)
1400     target_thread_file=${enable_threads}
1401     ;;
1402   *)
1403     echo "${enable_threads} is an unknown thread package" 1>&2
1404     exit 1
1405     ;;
1406 esac
1407
1408 if test x${thread_file} = x; then
1409   # No thread file set by target-specific clauses in config.gcc,
1410   # so use file chosen by default logic above
1411   thread_file=${target_thread_file}
1412 fi
1413
1414 # --------
1415 # UNSORTED
1416 # --------
1417
1418 use_cxa_atexit=no
1419 if test x$enable___cxa_atexit = xyes || \
1420    test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1421   if test x$host = x$target; then
1422     case $host in
1423       # mingw32 doesn't have __cxa_atexit but uses atexit registration
1424       # keyed to flag_use_cxa_atexit
1425       *-*-mingw32*)
1426         use_cxa_atexit=yes
1427         ;;
1428       *)
1429         AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1430           [echo "__cxa_atexit can't be enabled on this target"])
1431         ;;
1432     esac
1433   else
1434     # We can't check for __cxa_atexit when building a cross, so assume
1435     # it is available
1436     use_cxa_atexit=yes
1437   fi
1438   if test x$use_cxa_atexit = xyes; then
1439     AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1440       [Define if you want to use __cxa_atexit, rather than atexit, to
1441       register C++ destructors for local statics and global objects.
1442       This is essential for fully standards-compliant handling of
1443       destructors, but requires __cxa_atexit in libc.])
1444   fi
1445 fi
1446
1447 # Look for a file containing extra machine modes.
1448 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1449   extra_modes_file='$(srcdir)'/config/${extra_modes}
1450   AC_SUBST(extra_modes_file)
1451   AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1452   [Define to the name of a file containing a list of extra machine modes
1453    for this architecture.])
1454 fi
1455
1456 # Convert extra_options into a form suitable for Makefile use.
1457 extra_opt_files=
1458 all_opt_files=
1459 for f in $extra_options; do
1460   extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1461   all_opt_files="$all_opt_files $srcdir/config/$f"
1462 done
1463 AC_SUBST(extra_opt_files)
1464
1465 # auto-host.h is the file containing items generated by autoconf and is
1466 # the first file included by config.h.
1467 # If host=build, it is correct to have bconfig include auto-host.h
1468 # as well.  If host!=build, we are in error and need to do more
1469 # work to find out the build config parameters.
1470 if test x$host = x$build
1471 then
1472         build_auto=auto-host.h
1473 else
1474         # We create a subdir, then run autoconf in the subdir.
1475         # To prevent recursion we set host and build for the new
1476         # invocation of configure to the build for this invocation
1477         # of configure.
1478         tempdir=build.$$
1479         rm -rf $tempdir
1480         mkdir $tempdir
1481         cd $tempdir
1482         case ${srcdir} in
1483         /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1484         *) realsrcdir=../${srcdir};;
1485         esac
1486         saved_CFLAGS="${CFLAGS}"
1487         CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1488         LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1489         ${realsrcdir}/configure \
1490                 --enable-languages=${enable_languages-all} \
1491                 --target=$target_alias --host=$build_alias --build=$build_alias
1492         CFLAGS="${saved_CFLAGS}"
1493
1494         # We just finished tests for the build machine, so rename
1495         # the file auto-build.h in the gcc directory.
1496         mv auto-host.h ../auto-build.h
1497         cd ..
1498         rm -rf $tempdir
1499         build_auto=auto-build.h
1500 fi
1501 AC_SUBST(build_subdir)
1502
1503 tm_file="${tm_file} defaults.h"
1504 tm_p_file="${tm_p_file} tm-preds.h"
1505 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1506 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1507 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1508 # put this back in temporarily.
1509 xm_file="auto-host.h ansidecl.h ${xm_file}"
1510
1511 # --------
1512 # UNSORTED
1513 # --------
1514
1515 changequote(,)dnl
1516 # Compile in configure arguments.
1517 if test -f configargs.h ; then
1518         # Being re-configured.
1519         gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1520         gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1521 else
1522         gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1523 fi
1524
1525 # Double all backslashes and backslash all quotes to turn
1526 # gcc_config_arguments into a C string.
1527 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1528 $gcc_config_arguments
1529 EOF
1530 gcc_config_arguments_str=`cat conftest.out`
1531 rm -f conftest.out
1532
1533 cat > configargs.h <<EOF
1534 /* Generated automatically. */
1535 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1536 static const char thread_model[] = "$thread_file";
1537
1538 static const struct {
1539   const char *name, *value;
1540 } configure_default_options[] = $configure_default_options;
1541 EOF
1542 changequote([,])dnl
1543
1544 changequote(,)dnl
1545 gcc_BASEVER=`cat $srcdir/BASE-VER`
1546 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
1547 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
1548 if test -f $srcdir/REVISION ; then
1549         gcc_REVISION=`cat $srcdir/REVISION`
1550 else
1551         gcc_REVISION=""
1552 fi
1553 cat > plugin-version.h <<EOF
1554 #include "configargs.h"
1555
1556 #define GCCPLUGIN_VERSION_MAJOR   `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'`
1557 #define GCCPLUGIN_VERSION_MINOR   `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'`
1558 #define GCCPLUGIN_VERSION_PATCHLEVEL   `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'`
1559 #define GCCPLUGIN_VERSION  (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR)
1560
1561 static char basever[] = "$gcc_BASEVER";
1562 static char datestamp[] = "$gcc_DATESTAMP";
1563 static char devphase[] = "$gcc_DEVPHASE";
1564 static char revision[] = "$gcc_REVISION";
1565
1566 /* FIXME plugins: We should make the version information more precise.
1567    One way to do is to add a checksum. */
1568
1569 static struct plugin_gcc_version gcc_version = {basever, datestamp,
1570                                                 devphase, revision,
1571                                                 configuration_arguments};
1572 EOF
1573 changequote([,])dnl
1574
1575 # Internationalization
1576 ZW_GNU_GETTEXT_SISTER_DIR
1577
1578 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1579 # -liconv on the link line twice.
1580 case "$LIBINTL" in *$LIBICONV*)
1581         LIBICONV= ;;
1582 esac
1583
1584 AC_ARG_ENABLE(secureplt,
1585 [AS_HELP_STRING([--enable-secureplt],
1586                 [enable -msecure-plt by default for PowerPC])],
1587 [], [])
1588
1589 AC_ARG_ENABLE(leading-mingw64-underscores,
1590   AS_HELP_STRING([--enable-leading-mingw64-underscores],
1591                  [enable leading underscores on 64 bit mingw targets]),
1592   [],[])
1593 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
1594   [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
1595     [Define if we should use leading underscore on 64 bit mingw targets])])
1596
1597 AC_ARG_ENABLE(cld,
1598 [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [],
1599 [enable_cld=no])
1600
1601 AC_ARG_ENABLE(frame-pointer,
1602 [AS_HELP_STRING([--enable-frame-pointer],
1603                 [enable -fno-omit-frame-pointer by default for 32bit x86])], [],
1604 [
1605 case $target_os in
1606 linux* | darwin[[8912]]*)
1607   # Enable -fomit-frame-pointer by default for Linux and Darwin with
1608   # DWARF2.
1609   enable_frame_pointer=no
1610   ;;
1611 *)
1612   enable_frame_pointer=yes
1613   ;;
1614 esac
1615 ])
1616
1617 # Windows32 Registry support for specifying GCC installation paths.
1618 AC_ARG_ENABLE(win32-registry,
1619 [AS_HELP_STRING([--disable-win32-registry],
1620                 [disable lookup of installation paths in the
1621                  Registry on Windows hosts])
1622 AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)])
1623 AS_HELP_STRING([--enable-win32-registry=KEY],
1624                [use KEY instead of GCC version as the last portion
1625                 of the registry key])],,)
1626
1627 case $host_os in
1628   win32 | pe | cygwin* | mingw32* | uwin*)
1629     if test "x$enable_win32_registry" != xno; then
1630       AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1631     fi
1632
1633     if test "x$enable_win32_registry" != xno; then
1634       AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1635   [Define to 1 if installation paths should be looked up in the Windows
1636    Registry. Ignored on non-Windows hosts.])
1637
1638       if test "x$enable_win32_registry" != xyes \
1639          && test "x$enable_win32_registry" != x; then
1640         AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1641   [Define to be the last component of the Windows registry key under which
1642    to look for installation paths.  The full key used will be
1643    HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1644    The default is the GCC version number.])
1645       fi
1646     fi
1647   ;;
1648 esac
1649
1650 # Get an absolute path to the GCC top-level source directory
1651 holddir=`${PWDCMD-pwd}`
1652 cd $srcdir
1653 topdir=`${PWDCMD-pwd}`
1654 cd $holddir
1655
1656 # Conditionalize the makefile for this host machine.
1657 xmake_file=
1658 for f in ${host_xmake_file}
1659 do
1660         if test -f ${srcdir}/config/$f
1661         then
1662                 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1663         fi
1664 done
1665
1666 # Conditionalize the makefile for this target machine.
1667 tmake_file_=
1668 for f in ${tmake_file}
1669 do
1670         if test -f ${srcdir}/config/$f
1671         then
1672                 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1673         fi
1674 done
1675 tmake_file="${tmake_file_}"
1676
1677 out_object_file=`basename $out_file .c`.o
1678 common_out_object_file=`basename $common_out_file .c`.o
1679
1680 tm_file_list="options.h"
1681 tm_include_list="options.h insn-constants.h"
1682 for f in $tm_file; do
1683   case $f in
1684     ./* )
1685        f=`echo $f | sed 's/^..//'`
1686        tm_file_list="${tm_file_list} $f"
1687        tm_include_list="${tm_include_list} $f"
1688        ;;
1689     defaults.h )
1690        tm_file_list="${tm_file_list} \$(srcdir)/$f"
1691        tm_include_list="${tm_include_list} $f"
1692        ;;
1693     * )
1694        tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1695        tm_include_list="${tm_include_list} config/$f"
1696        ;;
1697   esac
1698 done
1699
1700 tm_p_file_list=
1701 tm_p_include_list=
1702 for f in $tm_p_file; do
1703   case $f in
1704     tm-preds.h )
1705        tm_p_file_list="${tm_p_file_list} $f"
1706        tm_p_include_list="${tm_p_include_list} $f"
1707        ;;
1708     * )
1709        tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1710        tm_p_include_list="${tm_p_include_list} config/$f"
1711   esac
1712 done
1713
1714 xm_file_list=
1715 xm_include_list=
1716 for f in $xm_file; do
1717   case $f in
1718     ansidecl.h )
1719        xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1720        xm_include_list="${xm_include_list} $f"
1721        ;;
1722     auto-host.h )
1723        xm_file_list="${xm_file_list} $f"
1724        xm_include_list="${xm_include_list} $f"
1725        ;;
1726     * )
1727        xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1728        xm_include_list="${xm_include_list} config/$f"
1729        ;;
1730   esac
1731 done
1732
1733 host_xm_file_list=
1734 host_xm_include_list=
1735 for f in $host_xm_file; do
1736   case $f in
1737     ansidecl.h )
1738        host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1739        host_xm_include_list="${host_xm_include_list} $f"
1740        ;;
1741     auto-host.h )
1742        host_xm_file_list="${host_xm_file_list} $f"
1743        host_xm_include_list="${host_xm_include_list} $f"
1744        ;;
1745     * )
1746        host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1747        host_xm_include_list="${host_xm_include_list} config/$f"
1748        ;;
1749   esac
1750 done
1751
1752 build_xm_file_list=
1753 for f in $build_xm_file; do
1754   case $f in
1755     ansidecl.h )
1756        build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1757        build_xm_include_list="${build_xm_include_list} $f"
1758        ;;
1759     auto-build.h | auto-host.h )
1760        build_xm_file_list="${build_xm_file_list} $f"
1761        build_xm_include_list="${build_xm_include_list} $f"
1762        ;;
1763     * )
1764        build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1765        build_xm_include_list="${build_xm_include_list} config/$f"
1766        ;;
1767   esac
1768 done
1769
1770 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1771 # cross-compiler which does not use the native headers and libraries.
1772 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1773 CROSS=                                          AC_SUBST(CROSS)
1774 ALL=all.internal                                AC_SUBST(ALL)
1775 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1776
1777 if test "x$with_build_sysroot" != x; then
1778   build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1779 else
1780   # This value is used, even on a native system, because
1781   # CROSS_SYSTEM_HEADER_DIR is just
1782   # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1783   build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1784 fi
1785
1786 if test x$host != x$target
1787 then
1788         CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1789         ALL=all.cross
1790         SYSTEM_HEADER_DIR=$build_system_header_dir
1791         case "$host","$target" in
1792         # Darwin crosses can use the host system's libraries and headers,
1793         # because of the fat library support.  Of course, it must be the
1794         # same version of Darwin on both sides.  Allow the user to
1795         # just say --target=foo-darwin without a version number to mean
1796         # "the version on this system".
1797             *-*-darwin*,*-*-darwin*)
1798                 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1799                 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1800                 if test $hostos = $targetos -o $targetos = darwin ; then
1801                     CROSS=
1802                     SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1803                     with_headers=yes
1804                 fi
1805                 ;;
1806
1807             i?86-*-*,x86_64-*-* \
1808             | powerpc*-*-*,powerpc64*-*-*)
1809                 CROSS="$CROSS -DNATIVE_CROSS" ;;
1810         esac
1811
1812         case $target in
1813                 *-*-mingw*)
1814                         if test "x$with_headers" = x; then
1815                                 with_headers=yes
1816                         fi
1817                         ;;
1818                 *)
1819                         ;;
1820         esac
1821 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1822         SYSTEM_HEADER_DIR=$build_system_header_dir
1823 fi
1824
1825 # If this is a cross-compiler that does not
1826 # have its own set of headers then define
1827 # inhibit_libc
1828
1829 # If this is using newlib, without having the headers available now,
1830 # then define inhibit_libc in LIBGCC2_CFLAGS.
1831 # This prevents libgcc2 from containing any code which requires libc
1832 # support.
1833 : ${inhibit_libc=false}
1834 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1835        test x$with_newlib = xyes ; } &&
1836      { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1837        inhibit_libc=true
1838 fi
1839 AC_SUBST(inhibit_libc)
1840
1841 # When building gcc with a cross-compiler, we need to adjust things so
1842 # that the generator programs are still built with the native compiler.
1843 # Also, we cannot run fixincludes.
1844
1845 # These are the normal (build=host) settings:
1846 CC_FOR_BUILD='$(CC)'            AC_SUBST(CC_FOR_BUILD)
1847 BUILD_CFLAGS='$(ALL_CFLAGS)'    AC_SUBST(BUILD_CFLAGS)
1848 BUILD_LDFLAGS='$(LDFLAGS)'      AC_SUBST(BUILD_LDFLAGS)
1849 STMP_FIXINC=stmp-fixinc         AC_SUBST(STMP_FIXINC)
1850
1851 # And these apply if build != host, or we are generating coverage data
1852 if test x$build != x$host || test "x$coverage_flags" != x
1853 then
1854     BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1855     BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
1856 fi
1857
1858 # Expand extra_headers to include complete path.
1859 # This substitutes for lots of t-* files.
1860 extra_headers_list=
1861 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1862 for file in ${extra_headers} ; do
1863   extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1864 done
1865
1866 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
1867 if test x"$use_gcc_tgmath" = xyes
1868 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
1869 fi
1870
1871 # Define collect2 in Makefile.
1872 case $host_can_use_collect2 in
1873   no) collect2= ;;
1874   *) collect2='collect2$(exeext)' ;;
1875 esac
1876 AC_SUBST([collect2])
1877
1878 # Add a definition of USE_COLLECT2 if system wants one.
1879 case $use_collect2 in
1880   no) use_collect2= ;;
1881   "") ;;
1882   *)
1883     host_xm_defines="${host_xm_defines} USE_COLLECT2"
1884     xm_defines="${xm_defines} USE_COLLECT2"
1885     case $host_can_use_collect2 in
1886       no)
1887         AC_MSG_ERROR([collect2 is required but cannot be built on this system])
1888         ;;
1889     esac
1890     ;;
1891 esac
1892
1893 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
1894 [Define to the name of the LTO plugin DSO that must be
1895   passed to the linker's -plugin=LIB option.])
1896
1897 # ---------------------------
1898 # Assembler & linker features
1899 # ---------------------------
1900
1901 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
1902 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
1903 # However when ld-new is first executed from the build tree, libtool will
1904 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
1905 # to the build tree.  While doing this we need to use the previous-stage
1906 # linker, or we have an infinite loop.  The presence of a shell script as
1907 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
1908 # the gcc/collect-ld script.  So we need to know how libtool works, or
1909 # exec-tool will fail.
1910
1911 m4_defun([_LT_CONFIG_COMMANDS], [])
1912 AC_PROG_LIBTOOL
1913 AC_SUBST(objdir)
1914 AC_SUBST(enable_fast_install)
1915
1916 # Identify the assembler which will work hand-in-glove with the newly
1917 # built GCC, so that we can examine its features.  This is the assembler
1918 # which will be driven by the driver program.
1919 #
1920 # If build != host, and we aren't building gas in-tree, we identify a
1921 # build->target assembler and hope that it will have the same features
1922 # as the host->target assembler we'll be using.
1923 gcc_cv_gas_major_version=
1924 gcc_cv_gas_minor_version=
1925 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1926
1927 m4_pattern_allow([AS_FOR_TARGET])dnl
1928 AS_VAR_SET_IF(gcc_cv_as,, [
1929 if test -x "$DEFAULT_ASSEMBLER"; then
1930         gcc_cv_as="$DEFAULT_ASSEMBLER"
1931 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
1932      && test -f ../gas/Makefile \
1933      && test x$build = x$host; then
1934         gcc_cv_as=../gas/as-new$build_exeext
1935 elif test -x as$build_exeext; then
1936         # Build using assembler in the current directory.
1937         gcc_cv_as=./as$build_exeext
1938 elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then
1939         gcc_cv_as="$AS_FOR_TARGET"
1940 else
1941         AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
1942 fi])
1943
1944 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
1945 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
1946 case "$ORIGINAL_AS_FOR_TARGET" in
1947   ./as | ./as$build_exeext) ;;
1948   *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
1949 esac
1950
1951 AC_MSG_CHECKING(what assembler to use)
1952 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
1953   # Single tree build which includes gas.  We want to prefer it
1954   # over whatever linker top-level may have detected, since
1955   # we'll use what we're building after installation anyway.
1956   AC_MSG_RESULT(newly built gas)
1957   in_tree_gas=yes
1958   _gcc_COMPUTE_GAS_VERSION
1959   in_tree_gas_is_elf=no
1960   if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
1961      || (grep 'obj_format = multi' ../gas/Makefile \
1962          && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
1963   then
1964     in_tree_gas_is_elf=yes
1965   fi
1966 else
1967   AC_MSG_RESULT($gcc_cv_as)
1968   in_tree_gas=no
1969 fi
1970
1971 # Identify the linker which will work hand-in-glove with the newly
1972 # built GCC, so that we can examine its features.  This is the linker
1973 # which will be driven by the driver program.
1974 #
1975 # If build != host, and we aren't building gas in-tree, we identify a
1976 # build->target linker and hope that it will have the same features
1977 # as the host->target linker we'll be using.
1978 gcc_cv_gld_major_version=
1979 gcc_cv_gld_minor_version=
1980 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1981 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1982
1983 AS_VAR_SET_IF(gcc_cv_ld,, [
1984 if test -x "$DEFAULT_LINKER"; then
1985         gcc_cv_ld="$DEFAULT_LINKER"
1986 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
1987      && test -f ../ld/Makefile \
1988      && test x$build = x$host; then
1989         gcc_cv_ld=../ld/ld-new$build_exeext
1990 elif test -x collect-ld$build_exeext; then
1991         # Build using linker in the current directory.
1992         gcc_cv_ld=./collect-ld$build_exeext
1993 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
1994         gcc_cv_ld="$LD_FOR_TARGET"
1995 else
1996         AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
1997 fi])
1998
1999 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
2000 PLUGIN_LD=`basename $gcc_cv_ld`
2001 AC_ARG_WITH(plugin-ld,
2002 [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])],
2003 [if test x"$withval" != x; then
2004    ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
2005    PLUGIN_LD="$withval"
2006  fi])
2007 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
2008 AC_DEFINE_UNQUOTED(PLUGIN_LD, "$PLUGIN_LD", [Specify plugin linker])
2009
2010 # Check to see if we are using gold instead of ld
2011 AC_MSG_CHECKING(whether we are using gold)
2012 ld_is_gold=no
2013 if test x$gcc_cv_ld != x; then
2014   if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2015      | grep "GNU gold" > /dev/null; then
2016     ld_is_gold=yes
2017   fi
2018 fi
2019 AC_MSG_RESULT($ld_is_gold)
2020
2021 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
2022 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
2023 case "$ORIGINAL_LD_FOR_TARGET" in
2024   ./collect-ld | ./collect-ld$build_exeext) ;;
2025   *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
2026 esac
2027
2028 AC_MSG_CHECKING(what linker to use)
2029 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \
2030    || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then
2031         # Single tree build which includes ld.  We want to prefer it
2032         # over whatever linker top-level may have detected, since
2033         # we'll use what we're building after installation anyway.
2034         AC_MSG_RESULT(newly built ld)
2035         in_tree_ld=yes
2036         in_tree_ld_is_elf=no
2037         if (grep 'EMUL = .*elf' ../ld/Makefile \
2038             || grep 'EMUL = .*linux' ../ld/Makefile \
2039             || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
2040           in_tree_ld_is_elf=yes
2041         elif test "$ld_is_gold" = yes; then
2042           in_tree_ld_is_elf=yes
2043         fi
2044         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
2045         do
2046 changequote(,)dnl
2047                 gcc_cv_gld_version=`sed -n -e 's/^[     ]*\(VERSION=[0-9]*\.[0-9]*.*\)/\1/p' < $f`
2048                 if test x$gcc_cv_gld_version != x; then
2049                         break
2050                 fi
2051         done
2052         gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2053         gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2054 changequote([,])dnl
2055 else
2056         AC_MSG_RESULT($gcc_cv_ld)
2057         in_tree_ld=no
2058 fi
2059
2060 # Figure out what nm we will be using.
2061 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2062 AS_VAR_SET_IF(gcc_cv_nm,, [
2063 if test -f $gcc_cv_binutils_srcdir/configure.in \
2064      && test -f ../binutils/Makefile \
2065      && test x$build = x$host; then
2066         gcc_cv_nm=../binutils/nm-new$build_exeext
2067 elif test -x nm$build_exeext; then
2068         gcc_cv_nm=./nm$build_exeext
2069 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
2070         gcc_cv_nm="$NM_FOR_TARGET"
2071 else
2072         AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2073 fi])
2074
2075 AC_MSG_CHECKING(what nm to use)
2076 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2077         # Single tree build which includes binutils.
2078         AC_MSG_RESULT(newly built nm)
2079         in_tree_nm=yes
2080 else
2081         AC_MSG_RESULT($gcc_cv_nm)
2082         in_tree_nm=no
2083 fi
2084
2085 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2086 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2087 case "$ORIGINAL_NM_FOR_TARGET" in
2088   ./nm | ./nm$build_exeext) ;;
2089   *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2090 esac
2091
2092
2093 # Figure out what objdump we will be using.
2094 AS_VAR_SET_IF(gcc_cv_objdump,, [
2095 if test -f $gcc_cv_binutils_srcdir/configure.in \
2096      && test -f ../binutils/Makefile \
2097      && test x$build = x$host; then
2098         # Single tree build which includes binutils.
2099         gcc_cv_objdump=../binutils/objdump$build_exeext
2100 elif test -x objdump$build_exeext; then
2101         gcc_cv_objdump=./objdump$build_exeext
2102 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2103         gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2104 else
2105         AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2106 fi])
2107
2108 AC_MSG_CHECKING(what objdump to use)
2109 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2110         # Single tree build which includes binutils.
2111         AC_MSG_RESULT(newly built objdump)
2112 elif test x$gcc_cv_objdump = x; then
2113         AC_MSG_RESULT(not found)
2114 else
2115         AC_MSG_RESULT($gcc_cv_objdump)
2116 fi
2117
2118 # Figure out what readelf we will be using.
2119 AS_VAR_SET_IF(gcc_cv_readelf,, [
2120 if test -f $gcc_cv_binutils_srcdir/configure.in \
2121      && test -f ../binutils/Makefile \
2122      && test x$build = x$host; then
2123         # Single tree build which includes binutils.
2124         gcc_cv_readelf=../binutils/readelf$build_exeext
2125 elif test -x readelf$build_exeext; then
2126         gcc_cv_readelf=./readelf$build_exeext
2127 else
2128         AC_PATH_PROG(gcc_cv_readelf, readelf)
2129 fi])
2130
2131 AC_MSG_CHECKING(what readelf to use)
2132 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2133         # Single tree build which includes binutils.
2134         AC_MSG_RESULT(newly built readelf)
2135 elif test x$gcc_cv_readelf = x; then
2136         AC_MSG_RESULT(not found)
2137 else
2138         AC_MSG_RESULT($gcc_cv_readelf)
2139 fi
2140
2141 # Figure out what assembler alignment features are present.
2142 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2143  [2,6,0],,
2144 [.balign 4
2145 .p2align 2],,
2146 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2147   [Define if your assembler supports .balign and .p2align.])])
2148
2149 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2150  [2,8,0],,
2151  [.p2align 4,,7],,
2152 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2153   [Define if your assembler supports specifying the maximum number
2154    of bytes to skip when using the GAS .p2align command.])])
2155
2156 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2157  [2,8,0],,
2158  [.literal16],,
2159 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2160   [Define if your assembler supports .literal16.])])
2161
2162 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2163  [elf,2,9,0],,
2164  [conftest_label1: .word 0
2165 .subsection -1
2166 conftest_label2: .word 0
2167 .previous],
2168  [if test x$gcc_cv_nm != x; then
2169     $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2170     $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2171     if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2172     then :
2173     else gcc_cv_as_subsection_m1=yes
2174     fi
2175     rm -f conftest.nm1 conftest.nm2
2176   fi],
2177  [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2178   [Define if your assembler supports .subsection and .subsection -1 starts
2179    emitting at the beginning of your section.])])
2180
2181 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2182  [2,2,0],,
2183  [      .weak foobar],,
2184 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2185
2186 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2187  [2,17,0],,
2188  [      .weakref foobar, barfnot],,
2189 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2190
2191 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2192  [2,15,91],,
2193  [      .SPACE $TEXT$
2194         .NSUBSPA $CODE$,COMDAT],,
2195 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2196
2197 # .hidden needs to be supported in both the assembler and the linker,
2198 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2199 # This is irritatingly difficult to feature test for; we have to check the
2200 # date string after the version number.  If we've got an in-tree
2201 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2202 # to be safe.
2203 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2204 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2205  [elf,2,13,0],,
2206 [       .hidden foobar
2207 foobar:],[
2208 # Solaris 9/x86 as incorrectly emits an alias for a hidden symbol with
2209 # STV_HIDDEN, so disable .hidden support if so.
2210 case "${target}" in
2211   i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2212     if test x$gcc_cv_as != x && test x$gcc_cv_objdump != x; then
2213       cat > conftest.s <<EOF
2214 .globl hidden
2215         .hidden hidden
2216 hidden:
2217 .globl default
2218         .set    default,hidden
2219 EOF
2220       if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
2221         && $gcc_cv_objdump -t conftest.o 2>/dev/null | \
2222         grep '\.hidden default' > /dev/null; then
2223         gcc_cv_as_hidden=no
2224       else
2225         gcc_cv_as_hidden=yes
2226       fi
2227     else
2228       # Assume bug is present if objdump is missing.
2229       gcc_cv_as_hidden=no
2230     fi
2231     ;;
2232   *)
2233     gcc_cv_as_hidden=yes
2234     ;;
2235 esac])
2236 case "${target}" in
2237   *-*-darwin*)
2238     # Darwin as has some visibility support, though with a different syntax.
2239     gcc_cv_as_hidden=yes
2240     ;;
2241 esac
2242
2243 # gnu_indirect_function type is an extension proposed at
2244 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2245 # selection of function implementation
2246 AC_ARG_ENABLE(gnu-indirect-function,
2247  [AS_HELP_STRING([--enable-gnu-indirect-function],
2248                  [enable the use of the @gnu_indirect_function to glibc systems])],
2249  [case $enable_gnu_indirect_function in
2250     yes | no) ;;
2251     *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2252 Valid choices are 'yes' and 'no'.]) ;;
2253   esac],
2254  [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2255 if test x$enable_gnu_indirect_function = xyes; then
2256   AC_DEFINE(HAVE_GNU_INDIRECT_FUNCTION, 1,
2257    [Define if your system supports gnu indirect functions.])
2258 fi
2259
2260 changequote(,)dnl
2261 if test $in_tree_ld != yes ; then
2262   ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2263   if echo "$ld_ver" | grep GNU > /dev/null; then
2264     if test x"$ld_is_gold" = xyes; then
2265       # GNU gold --version looks like this:
2266       #
2267       # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
2268       #
2269       # We extract the binutils version which is more familiar and specific
2270       # than the gold version.
2271       ld_vers=`echo $ld_ver | sed -n \
2272           -e 's,^[^)]*[  ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
2273     else
2274       # GNU ld --version looks like this:
2275       #
2276       # GNU ld (GNU Binutils) 2.21.51.20110225
2277       ld_vers=`echo $ld_ver | sed -n \
2278           -e 's,^.*[     ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2279     fi
2280     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'`
2281     ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2282     ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2283     ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2284   else
2285     case "${target}" in
2286       *-*-solaris2*)
2287         #
2288         # Solaris 2 ld -V output looks like this for a regular version:
2289         #
2290         # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1699
2291         #
2292         # but test versions add stuff at the end:
2293         #
2294         # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1701:onnv-ab196087-6931056-03/25/10
2295         #
2296         ld_ver=`$gcc_cv_ld -V 2>&1`
2297         if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2298           ld_vers=`echo $ld_ver | sed -n \
2299             -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2300           ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2301           ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2302         fi
2303         ;;
2304     esac
2305   fi
2306 fi
2307 changequote([,])dnl
2308
2309 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2310 [[if test $in_tree_ld = yes ; then
2311   gcc_cv_ld_hidden=no
2312   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 \
2313      && test $in_tree_ld_is_elf = yes; then
2314      gcc_cv_ld_hidden=yes
2315   fi
2316 else
2317   gcc_cv_ld_hidden=yes
2318   if test x"$ld_is_gold" = xyes; then
2319     :
2320   elif echo "$ld_ver" | grep GNU > /dev/null; then
2321     if test 0"$ld_date" -lt 20020404; then
2322       if test -n "$ld_date"; then
2323         # If there was date string, but was earlier than 2002-04-04, fail
2324         gcc_cv_ld_hidden=no
2325       elif test -z "$ld_vers"; then
2326         # If there was no date string nor ld version number, something is wrong
2327         gcc_cv_ld_hidden=no
2328       else
2329         test -z "$ld_vers_patch" && ld_vers_patch=0
2330         if test "$ld_vers_major" -lt 2; then
2331           gcc_cv_ld_hidden=no
2332         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2333           gcc_cv_ld_hidden="no"
2334         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2335           gcc_cv_ld_hidden=no
2336         fi
2337       fi
2338     fi
2339   else
2340     case "${target}" in
2341       *-*-darwin*)
2342         # Darwin ld has some visibility support.
2343         gcc_cv_ld_hidden=yes
2344         ;;
2345       hppa64*-*-hpux* | ia64*-*-hpux*)
2346         gcc_cv_ld_hidden=yes
2347         ;;
2348       *-*-solaris2.8*)
2349         # .hidden support was backported to Solaris 8, starting with ld
2350         # version 1.276.
2351         if test "$ld_vers_minor" -ge 276; then
2352           gcc_cv_ld_hidden=yes
2353         else
2354           gcc_cv_ld_hidden=no
2355         fi
2356         ;;
2357       *-*-solaris2.9* | *-*-solaris2.1[0-9]*)
2358         # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2359         # .symbolic was only added in Solaris 9 12/02.
2360         gcc_cv_ld_hidden=yes
2361         ;;
2362       *)
2363         gcc_cv_ld_hidden=no
2364         ;;
2365     esac
2366   fi
2367 fi]])
2368 libgcc_visibility=no
2369 AC_SUBST(libgcc_visibility)
2370 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2371 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2372   libgcc_visibility=yes
2373   AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2374   [Define if your assembler and linker support .hidden.])
2375 fi
2376
2377 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2378 gcc_cv_ld_ro_rw_mix=unknown
2379 if test $in_tree_ld = yes ; then
2380   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 \
2381      && test $in_tree_ld_is_elf = yes; then
2382     gcc_cv_ld_ro_rw_mix=read-write
2383   fi
2384 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2385   echo '.section myfoosect, "a"' > conftest1.s
2386   echo '.section myfoosect, "aw"' > conftest2.s
2387   echo '.byte 1' >> conftest2.s
2388   echo '.section myfoosect, "a"' > conftest3.s
2389   echo '.byte 0' >> conftest3.s
2390   if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2391      && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2392      && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2393      && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2394         conftest2.o conftest3.o > /dev/null 2>&1; then
2395     gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2396                          | sed -e '/myfoosect/!d' -e N`
2397     if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2398       if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2399         gcc_cv_ld_ro_rw_mix=read-only
2400       else
2401         gcc_cv_ld_ro_rw_mix=read-write
2402       fi
2403     fi
2404   fi
2405 changequote(,)dnl
2406   rm -f conftest.* conftest[123].*
2407 changequote([,])dnl
2408 fi
2409 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2410         AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2411   [Define if your linker links a mix of read-only
2412    and read-write sections into a read-write section.])
2413 fi
2414 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2415
2416 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2417 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2418   [elf,2,11,0],,
2419 [       .data
2420         .uleb128 L2 - L1
2421 L1:
2422         .uleb128 1280
2423         .sleb128 -1010
2424 L2:],
2425 [[# GAS versions before 2.11 do not support uleb128,
2426   # despite appearing to.
2427   # ??? There exists an elf-specific test that will crash
2428   # the assembler.  Perhaps it's better to figure out whether
2429   # arbitrary sections are supported and try the test.
2430   as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2431   if echo "$as_ver" | grep GNU > /dev/null; then
2432     as_vers=`echo $as_ver | sed -n \
2433         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2434     as_major=`expr "$as_vers" : '\([0-9]*\)'`
2435     as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2436     if test $as_major -eq 2 && test $as_minor -lt 11
2437     then :
2438     else gcc_cv_as_leb128=yes
2439     fi
2440   fi]],
2441   [AC_DEFINE(HAVE_AS_LEB128, 1,
2442     [Define if your assembler supports .sleb128 and .uleb128.])])
2443
2444 # Check if we have assembler support for unwind directives.
2445 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2446   ,,
2447 [       .text
2448         .cfi_startproc
2449         .cfi_offset 0, 0
2450         .cfi_same_value 1
2451         .cfi_def_cfa 1, 2
2452         .cfi_escape 1, 2, 3, 4, 5
2453         .cfi_endproc],
2454 [case "$target" in
2455   *-*-solaris*)
2456     # If the linker used on Solaris (like Sun ld) isn't capable of merging
2457     # read-only and read-write sections, we need to make sure that the
2458     # assembler used emits read-write .eh_frame sections.
2459     if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2460       if test "x$gcc_cv_objdump" != x; then
2461         if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2462                 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2463           gcc_cv_as_cfi_directive=no
2464         else
2465           case "$target" in
2466             i?86-*-solaris2.1[[0-9]]* | x86_64-*-solaris2.1[[0-9]]*)
2467               # On Solaris/x86, make sure that GCC and gas agree on using
2468               # read-only .eh_frame sections for 64-bit.
2469               if $gcc_cv_as --64 -o conftest.o conftest.s > /dev/null 2>&1 && \
2470                 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2471                         sed -e /.eh_frame/!d -e N | \
2472                         grep READONLY > /dev/null; then
2473                 gcc_cv_as_cfi_directive=yes
2474               else
2475                 gcc_cv_as_cfi_directive=no
2476               fi
2477               ;;
2478             *)
2479               gcc_cv_as_cfi_directive=yes
2480               ;;
2481           esac
2482         fi
2483       else
2484         # no objdump, err on the side of caution
2485         gcc_cv_as_cfi_directive=no
2486       fi
2487     else
2488       gcc_cv_as_cfi_directive=yes
2489     fi
2490     ;;
2491   *-*-*)
2492     gcc_cv_as_cfi_directive=yes
2493     ;;
2494 esac])
2495 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
2496 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2497   ,,
2498 [       .text
2499         .cfi_startproc
2500         .cfi_adjust_cfa_offset 64
2501         .skip 75040, 0
2502         .cfi_adjust_cfa_offset 128
2503         .cfi_endproc],
2504 [[
2505 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
2506     | grep 'DW_CFA_advance_loc[24]:[    ][      ]*75040[        ]' >/dev/null; then
2507    gcc_cv_as_cfi_advance_working=yes
2508 fi
2509 ]])
2510 else
2511   # no objdump, err on the side of caution
2512   gcc_cv_as_cfi_advance_working=no
2513 fi
2514 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
2515 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2516   [`if test $gcc_cv_as_cfi_directive = yes \
2517        && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2518   [Define 0/1 if your assembler supports CFI directives.])
2519
2520 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
2521 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2522   gcc_cv_as_cfi_personality_directive, ,,
2523 [       .text
2524         .cfi_startproc
2525         .cfi_personality 0, symbol
2526         .cfi_endproc])
2527 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2528   [`if test $gcc_cv_as_cfi_personality_directive = yes;
2529     then echo 1; else echo 0; fi`],
2530   [Define 0/1 if your assembler supports .cfi_personality.])
2531
2532 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2533   gcc_cv_as_cfi_sections_directive, ,,
2534 [       .text
2535         .cfi_sections .debug_frame, .eh_frame
2536         .cfi_startproc
2537         .cfi_endproc],
2538 [case $target_os in
2539   win32 | pe | cygwin* | mingw32* | uwin*)
2540     # Need to check that we generated the correct relocation for the
2541     # .debug_frame section.  This was fixed for binutils 2.21.
2542     gcc_cv_as_cfi_sections_directive=no
2543     if test "x$gcc_cv_objdump" != x; then
2544      if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
2545         grep secrel > /dev/null; then
2546       gcc_cv_as_cfi_sections_directive=yes
2547      fi
2548     fi
2549     ;;
2550   *)
2551     gcc_cv_as_cfi_sections_directive=yes
2552     ;;
2553 esac])
2554 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
2555 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2556   [`if test $gcc_cv_as_cfi_sections_directive = yes;
2557     then echo 1; else echo 0; fi`],
2558   [Define 0/1 if your assembler supports .cfi_sections.])
2559
2560 # GAS versions up to and including 2.11.0 may mis-optimize
2561 # .eh_frame data.
2562 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2563   [elf,2,12,0],,
2564 [       .text
2565 .LFB1:
2566         .4byte  0
2567 .L1:
2568         .4byte  0
2569 .LFE1:
2570         .section        .eh_frame,"aw",@progbits
2571 __FRAME_BEGIN__:
2572         .4byte  .LECIE1-.LSCIE1
2573 .LSCIE1:
2574         .4byte  0x0
2575         .byte   0x1
2576         .ascii "z\0"
2577         .byte   0x1
2578         .byte   0x78
2579         .byte   0x1a
2580         .byte   0x0
2581         .byte   0x4
2582         .4byte  1
2583         .p2align 1
2584 .LECIE1:
2585 .LSFDE1:
2586         .4byte  .LEFDE1-.LASFDE1
2587 .LASFDE1:
2588         .4byte  .LASFDE1-__FRAME_BEGIN__
2589         .4byte  .LFB1
2590         .4byte  .LFE1-.LFB1
2591         .byte   0x4
2592         .4byte  .LFE1-.LFB1
2593         .byte   0x4
2594         .4byte  .L1-.LFB1
2595 .LEFDE1:],
2596 [  dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2597 cat > conftest.lit <<EOF
2598  0000 10000000 00000000 017a0001 781a0004  .........z..x...
2599  0010 01000000 12000000 18000000 00000000  ................
2600  0020 08000000 04080000 0044               .........D      @&t@
2601 EOF
2602 cat > conftest.big <<EOF
2603  0000 00000010 00000000 017a0001 781a0004  .........z..x...
2604  0010 00000001 00000012 00000018 00000000  ................
2605  0020 00000008 04000000 0844               .........D      @&t@
2606 EOF
2607   # If the assembler didn't choke, and we can objdump,
2608   # and we got the correct data, then succeed.
2609   # The text in the here-document typically retains its unix-style line
2610   # endings, while the output of objdump will use host line endings.
2611   # Therefore, use diff -b for the comparisons.
2612   if test x$gcc_cv_objdump != x \
2613   && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2614      | tail -3 > conftest.got \
2615   && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2616     || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2617   then
2618     gcc_cv_as_eh_frame=yes
2619   elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2620     gcc_cv_as_eh_frame=buggy
2621   else
2622     # Uh oh, what do we do now?
2623     gcc_cv_as_eh_frame=no
2624   fi])
2625
2626 if test $gcc_cv_as_eh_frame = buggy; then
2627   AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2628   [Define if your assembler mis-optimizes .eh_frame data.])
2629 fi
2630
2631 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2632  [elf,2,12,0], [--fatal-warnings],
2633  [.section .rodata.str, "aMS", @progbits, 1])
2634 if test $gcc_cv_as_shf_merge = no; then
2635   gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2636     [elf,2,12,0], [--fatal-warnings],
2637     [.section .rodata.str, "aMS", %progbits, 1])
2638 fi
2639 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2640   [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2641 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2642
2643 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)],
2644  gcc_cv_as_comdat_group,
2645  [elf,2,16,0], [--fatal-warnings],
2646  [.section .text,"axG",@progbits,.foo,comdat])
2647 if test $gcc_cv_as_comdat_group = yes; then
2648   gcc_cv_as_comdat_group_percent=no
2649   gcc_cv_as_comdat_group_group=no
2650 else
2651  gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
2652    gcc_cv_as_comdat_group_percent,
2653    [elf,2,16,0], [--fatal-warnings],
2654    [.section .text,"axG",%progbits,.foo,comdat])
2655  if test $gcc_cv_as_comdat_group_percent = yes; then
2656    gcc_cv_as_comdat_group_group=no
2657  else
2658    case "${target}" in
2659      # Sun as uses a completely different syntax.
2660      *-*-solaris2*)
2661        case "${target}" in
2662          sparc*-*-solaris2*)
2663            conftest_s='
2664                .group foo,".text%foo",#comdat
2665                .section ".text%foo", #alloc,#execinstr,#progbits
2666                .globl foo
2667              foo:
2668              '
2669            ;;
2670          i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2671            conftest_s='
2672                .group foo,.text%foo,#comdat
2673                .section .text%foo, "ax", @progbits
2674                .globl  foo
2675              foo:
2676              '
2677            ;;
2678        esac
2679        gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
2680          gcc_cv_as_comdat_group_group,
2681          ,, [$conftest_s])
2682        ;;
2683    esac
2684  fi
2685 fi
2686 if test x"$ld_is_gold" = xyes; then
2687   comdat_group=yes
2688 elif test $in_tree_ld = yes ; then
2689   comdat_group=no
2690   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 \
2691      && test $in_tree_ld_is_elf = yes; then
2692      comdat_group=yes
2693   fi
2694 elif echo "$ld_ver" | grep GNU > /dev/null; then
2695   comdat_group=yes
2696   if test 0"$ld_date" -lt 20050308; then
2697     if test -n "$ld_date"; then
2698       # If there was date string, but was earlier than 2005-03-08, fail
2699       comdat_group=no
2700     elif test "$ld_vers_major" -lt 2; then
2701       comdat_group=no
2702     elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2703       comdat_group=no
2704     fi
2705   fi
2706 else
2707 changequote(,)dnl
2708   case "${target}" in
2709     *-*-solaris2.1[1-9]*)
2710       comdat_group=no
2711       # Sun ld has COMDAT group support since Solaris 9, but it doesn't
2712       # interoperate with GNU as until Solaris 11 build 130, i.e. ld
2713       # version 1.688.
2714       #
2715       # If using Sun as for COMDAT group as emitted by GCC, one needs at
2716       # least ld version 1.2267.
2717       if test "$ld_vers_major" -gt 1; then
2718         comdat_group=yes
2719       elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
2720         comdat_group=yes
2721       elif test "$ld_vers_minor" -ge 2267; then
2722         comdat_group=yes
2723       fi
2724       ;;
2725     *)
2726       # Assume linkers other than GNU ld don't support COMDAT group.
2727       comdat_group=no
2728       ;;
2729   esac
2730 changequote([,])dnl
2731 fi
2732 # Allow overriding the automatic COMDAT group tests above.
2733 AC_ARG_ENABLE(comdat,
2734   [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
2735   [comdat_group="$enable_comdat"])
2736 if test $comdat_group = no; then
2737   gcc_cv_as_comdat_group=no
2738   gcc_cv_as_comdat_group_percent=no
2739   gcc_cv_as_comdat_group_group=no
2740 fi
2741 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2742   [`if test $gcc_cv_as_comdat_group = yes \
2743     || test $gcc_cv_as_comdat_group_percent = yes \
2744     || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`],
2745 [Define 0/1 if your assembler and linker support COMDAT groups.])
2746
2747 gcc_GAS_CHECK_FEATURE([line table discriminator support],
2748  gcc_cv_as_discriminator,
2749  [2,19,51],,
2750 [       .text
2751         .file 1 "conf.c"
2752         .loc 1 1 0 discriminator 1],,
2753 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
2754   [Define if your assembler supports the .loc discriminator sub-directive.])])
2755
2756 # Thread-local storage - the check is heavily parameterized.
2757 conftest_s=
2758 tls_first_major=
2759 tls_first_minor=
2760 tls_as_opt=
2761 case "$target" in
2762 changequote(,)dnl
2763   alpha*-*-*)
2764     conftest_s='
2765         .section ".tdata","awT",@progbits
2766 foo:    .long   25
2767         .text
2768         ldq     $27,__tls_get_addr($29)         !literal!1
2769         lda     $16,foo($29)                    !tlsgd!1
2770         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
2771         ldq     $27,__tls_get_addr($29)         !literal!2
2772         lda     $16,foo($29)                    !tlsldm!2
2773         jsr     $26,($27),__tls_get_addr        !lituse_tlsldm!2
2774         ldq     $1,foo($29)                     !gotdtprel
2775         ldah    $2,foo($29)                     !dtprelhi
2776         lda     $3,foo($2)                      !dtprello
2777         lda     $4,foo($29)                     !dtprel
2778         ldq     $1,foo($29)                     !gottprel
2779         ldah    $2,foo($29)                     !tprelhi
2780         lda     $3,foo($2)                      !tprello
2781         lda     $4,foo($29)                     !tprel'
2782         tls_first_major=2
2783         tls_first_minor=13
2784         tls_as_opt=--fatal-warnings
2785         ;;
2786   cris-*-*|crisv32-*-*)
2787     conftest_s='
2788         .section ".tdata","awT",@progbits
2789 x:      .long   25
2790         .text
2791         move.d x:IE,$r10
2792         nop'
2793         tls_first_major=2
2794         tls_first_minor=20
2795         tls_as_opt=--fatal-warnings
2796         ;;
2797   frv*-*-*)
2798     conftest_s='
2799         .section ".tdata","awT",@progbits
2800 x:      .long   25
2801         .text
2802         call    #gettlsoff(x)'
2803         tls_first_major=2
2804         tls_first_minor=14
2805         ;;
2806   hppa*-*-linux*)
2807     conftest_s='
2808 t1:     .reg    %r20
2809 t2:     .reg    %r21
2810 gp:     .reg    %r19
2811         .section ".tdata","awT",@progbits
2812 foo:    .long   25
2813         .text
2814         .align  4
2815         addil LT%foo-$tls_gdidx$,gp
2816         ldo RT%foo-$tls_gdidx$(%r1),%arg0
2817         b __tls_get_addr
2818         nop
2819         addil LT%foo-$tls_ldidx$,gp
2820         b __tls_get_addr
2821         ldo RT%foo-$tls_ldidx$(%r1),%arg0
2822         addil LR%foo-$tls_dtpoff$,%ret0
2823         ldo RR%foo-$tls_dtpoff$(%r1),%t1
2824         mfctl %cr27,%t1
2825         addil LT%foo-$tls_ieoff$,gp
2826         ldw RT%foo-$tls_ieoff$(%r1),%t2
2827         add %t1,%t2,%t3
2828         mfctl %cr27,%t1
2829         addil LR%foo-$tls_leoff$,%t1
2830         ldo RR%foo-$tls_leoff$(%r1),%t2'
2831         tls_first_major=2
2832         tls_first_minor=15
2833         tls_as_opt=--fatal-warnings
2834         ;;
2835   arm*-*-*)
2836     conftest_s='
2837         .section ".tdata","awT",%progbits
2838 foo:    .long   25
2839         .text
2840 .word foo(gottpoff)
2841 .word foo(tpoff)
2842 .word foo(tlsgd)
2843 .word foo(tlsldm)
2844 .word foo(tlsldo)'
2845         tls_first_major=2
2846         tls_first_minor=17
2847         ;;
2848   i[34567]86-*-* | x86_64-*-solaris2.1[0-9]*)
2849     case "$target" in
2850       i[34567]86-*-solaris2.*)
2851         on_solaris=yes
2852         tga_func=___tls_get_addr
2853         ;;
2854       x86_64-*-solaris2.1[0-9]*)
2855         on_solaris=yes
2856         tga_func=__tls_get_addr
2857         ;;
2858       *)
2859         on_solaris=no
2860         ;;
2861     esac
2862     if test x$on_solaris = xyes && test x$gas_flag = xno; then
2863       conftest_s='
2864         .section .tdata,"awt",@progbits'
2865       tls_first_major=0
2866       tls_first_minor=0
2867 changequote([,])dnl
2868       AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
2869 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
2870 changequote(,)dnl
2871     else
2872       conftest_s='
2873         .section ".tdata","awT",@progbits'
2874       tls_first_major=2
2875       tls_first_minor=14
2876       tls_as_opt="--fatal-warnings"
2877     fi
2878     conftest_s="$conftest_s
2879 foo:    .long   25
2880         .text
2881         movl    %gs:0, %eax
2882         leal    foo@tlsgd(,%ebx,1), %eax
2883         leal    foo@tlsldm(%ebx), %eax
2884         leal    foo@dtpoff(%eax), %edx
2885         movl    foo@gottpoff(%ebx), %eax
2886         subl    foo@gottpoff(%ebx), %eax
2887         addl    foo@gotntpoff(%ebx), %eax
2888         movl    foo@indntpoff, %eax
2889         movl    \$foo@tpoff, %eax
2890         subl    \$foo@tpoff, %eax
2891         leal    foo@ntpoff(%ecx), %eax"
2892     ;;
2893   x86_64-*-*)
2894     conftest_s='
2895         .section ".tdata","awT",@progbits
2896 foo:    .long   25
2897         .text
2898         movq    %fs:0, %rax
2899         leaq    foo@TLSGD(%rip), %rdi
2900         leaq    foo@TLSLD(%rip), %rdi
2901         leaq    foo@DTPOFF(%rax), %rdx
2902         movq    foo@GOTTPOFF(%rip), %rax
2903         movq    $foo@TPOFF, %rax'
2904         tls_first_major=2
2905         tls_first_minor=14
2906         tls_as_opt=--fatal-warnings
2907         ;;
2908   ia64-*-*)
2909     conftest_s='
2910         .section ".tdata","awT",@progbits
2911 foo:    data8   25
2912         .text
2913         addl    r16 = @ltoff(@dtpmod(foo#)), gp
2914         addl    r17 = @ltoff(@dtprel(foo#)), gp
2915         addl    r18 = @ltoff(@tprel(foo#)), gp
2916         addl    r19 = @dtprel(foo#), gp
2917         adds    r21 = @dtprel(foo#), r13
2918         movl    r23 = @dtprel(foo#)
2919         addl    r20 = @tprel(foo#), gp
2920         adds    r22 = @tprel(foo#), r13
2921         movl    r24 = @tprel(foo#)'
2922         tls_first_major=2
2923         tls_first_minor=13
2924         tls_as_opt=--fatal-warnings
2925         ;;
2926   mips*-*-*)
2927     conftest_s='
2928         .section .tdata,"awT",@progbits
2929 x:
2930         .word 2
2931         .text
2932         addiu $4, $28, %tlsgd(x)
2933         addiu $4, $28, %tlsldm(x)
2934         lui $4, %dtprel_hi(x)
2935         addiu $4, $4, %dtprel_lo(x)
2936         lw $4, %gottprel(x)($28)
2937         lui $4, %tprel_hi(x)
2938         addiu $4, $4, %tprel_lo(x)'
2939         tls_first_major=2
2940         tls_first_minor=16
2941         tls_as_opt='-32 --fatal-warnings'
2942         ;;
2943   m68k-*-*)
2944     conftest_s='
2945         .section .tdata,"awT",@progbits
2946 x:
2947         .word 2
2948         .text
2949 foo:
2950         move.l x@TLSGD(%a5),%a0
2951         move.l x@TLSLDM(%a5),%a0
2952         move.l x@TLSLDO(%a5),%a0
2953         move.l x@TLSIE(%a5),%a0
2954         move.l x@TLSLE(%a5),%a0'
2955         tls_first_major=2
2956         tls_first_minor=19
2957         tls_as_opt='--fatal-warnings'
2958         ;;
2959   powerpc-*-*)
2960     conftest_s='
2961         .section ".tdata","awT",@progbits
2962         .align 2
2963 ld0:    .space 4
2964 ld1:    .space 4
2965 x1:     .space 4
2966 x2:     .space 4
2967 x3:     .space 4
2968         .text
2969         addi 3,31,ld0@got@tlsgd
2970         bl __tls_get_addr
2971         addi 3,31,x1@got@tlsld
2972         bl __tls_get_addr
2973         addi 9,3,x1@dtprel
2974         addis 9,3,x2@dtprel@ha
2975         addi 9,9,x2@dtprel@l
2976         lwz 9,x3@got@tprel(31)
2977         add 9,9,x@tls
2978         addi 9,2,x1@tprel
2979         addis 9,2,x2@tprel@ha
2980         addi 9,9,x2@tprel@l'
2981         tls_first_major=2
2982         tls_first_minor=14
2983         tls_as_opt="-a32 --fatal-warnings"
2984         ;;
2985   powerpc64-*-*)
2986     conftest_s='
2987         .section ".tdata","awT",@progbits
2988         .align 3
2989 ld0:    .space 8
2990 ld1:    .space 8
2991 x1:     .space 8
2992 x2:     .space 8
2993 x3:     .space 8
2994         .text
2995         addi 3,2,ld0@got@tlsgd
2996         bl .__tls_get_addr
2997         nop
2998         addi 3,2,ld1@toc
2999         bl .__tls_get_addr
3000         nop
3001         addi 3,2,x1@got@tlsld
3002         bl .__tls_get_addr
3003         nop
3004         addi 9,3,x1@dtprel
3005         bl .__tls_get_addr
3006         nop
3007         addis 9,3,x2@dtprel@ha
3008         addi 9,9,x2@dtprel@l
3009         bl .__tls_get_addr
3010         nop
3011         ld 9,x3@got@dtprel(2)
3012         add 9,9,3
3013         bl .__tls_get_addr
3014         nop'
3015         tls_first_major=2
3016         tls_first_minor=14
3017         tls_as_opt="-a64 --fatal-warnings"
3018         ;;
3019   s390-*-*)
3020     conftest_s='
3021         .section ".tdata","awT",@progbits
3022 foo:    .long   25
3023         .text
3024         .long   foo@TLSGD
3025         .long   foo@TLSLDM
3026         .long   foo@DTPOFF
3027         .long   foo@NTPOFF
3028         .long   foo@GOTNTPOFF
3029         .long   foo@INDNTPOFF
3030         l       %r1,foo@GOTNTPOFF(%r12)
3031         l       %r1,0(%r1):tls_load:foo
3032         bas     %r14,0(%r1,%r13):tls_gdcall:foo
3033         bas     %r14,0(%r1,%r13):tls_ldcall:foo'
3034         tls_first_major=2
3035         tls_first_minor=14
3036         tls_as_opt="-m31 --fatal-warnings"
3037         ;;
3038   s390x-*-*)
3039     conftest_s='
3040         .section ".tdata","awT",@progbits
3041 foo:    .long   25
3042         .text
3043         .quad   foo@TLSGD
3044         .quad   foo@TLSLDM
3045         .quad   foo@DTPOFF
3046         .quad   foo@NTPOFF
3047         .quad   foo@GOTNTPOFF
3048         lg      %r1,foo@GOTNTPOFF(%r12)
3049         larl    %r1,foo@INDNTPOFF
3050         brasl   %r14,__tls_get_offset@PLT:tls_gdcall:foo
3051         brasl   %r14,__tls_get_offset@PLT:tls_ldcall:foo'
3052         tls_first_major=2
3053         tls_first_minor=14
3054         tls_as_opt="-m64 -Aesame --fatal-warnings"
3055         ;;
3056   sh-*-* | sh[34]-*-*)
3057     conftest_s='
3058         .section ".tdata","awT",@progbits
3059 foo:    .long   25
3060         .text
3061         .long   foo@TLSGD
3062         .long   foo@TLSLDM
3063         .long   foo@DTPOFF
3064         .long   foo@GOTTPOFF
3065         .long   foo@TPOFF'
3066         tls_first_major=2
3067         tls_first_minor=13
3068         tls_as_opt=--fatal-warnings
3069         ;;
3070   sparc*-*-*)
3071     case "$target" in
3072       sparc*-sun-solaris2.*)
3073         on_solaris=yes
3074         tga_func=__tls_get_addr
3075         ;;
3076       *)
3077         on_solaris=no
3078         ;;
3079     esac
3080     if test x$on_solaris = xyes && test x$gas_flag = xno; then
3081       conftest_s='
3082         .section ".tdata",#alloc,#write,#tls'
3083         tls_first_major=0
3084         tls_first_minor=0
3085     else
3086       conftest_s='
3087         .section ".tdata","awT",@progbits'
3088         tls_first_major=2
3089         tls_first_minor=14
3090         tls_as_opt="-32 --fatal-warnings"
3091     fi
3092     conftest_s="$conftest_s
3093 foo:    .long   25
3094         .text
3095         sethi   %tgd_hi22(foo), %o0
3096         add     %o0, %tgd_lo10(foo), %o1
3097         add     %l7, %o1, %o0, %tgd_add(foo)
3098         call    __tls_get_addr, %tgd_call(foo)
3099         sethi   %tldm_hi22(foo), %l1
3100         add     %l1, %tldm_lo10(foo), %l2
3101         add     %l7, %l2, %o0, %tldm_add(foo)
3102         call    __tls_get_addr, %tldm_call(foo)
3103         sethi   %tldo_hix22(foo), %l3
3104         xor     %l3, %tldo_lox10(foo), %l4
3105         add     %o0, %l4, %l5, %tldo_add(foo)
3106         sethi   %tie_hi22(foo), %o3
3107         add     %o3, %tie_lo10(foo), %o3
3108         ld      [%l7 + %o3], %o2, %tie_ld(foo)
3109         add     %g7, %o2, %o4, %tie_add(foo)
3110         sethi   %tle_hix22(foo), %l1
3111         xor     %l1, %tle_lox10(foo), %o5
3112         ld      [%g7 + %o5], %o1"
3113         ;;
3114   xtensa*-*-*)
3115     conftest_s='
3116         .section ".tdata","awT",@progbits
3117 foo:    .long   25
3118         .text
3119         movi    a8, foo@TLSFUNC
3120         movi    a10, foo@TLSARG
3121         callx8.tls a8, foo@TLSCALL'
3122         tls_first_major=2
3123         tls_first_minor=19
3124         ;;
3125 changequote([,])dnl
3126 esac
3127 set_have_as_tls=no
3128 if test "x$enable_tls" = xno ; then
3129   : # TLS explicitly disabled.
3130 elif test "x$enable_tls" = xyes ; then
3131   set_have_as_tls=yes # TLS explicitly enabled.
3132 elif test -z "$tls_first_major"; then
3133   : # If we don't have a check, assume no support.
3134 else
3135   gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
3136   [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
3137   [set_have_as_tls=yes])
3138 fi
3139 case "$target" in
3140   *-*-irix6*)
3141     # IRIX 6.5 rld and libc.so lack TLS support, so even if gas and gld
3142     # with TLS support are in use, native TLS cannot work.
3143     set_have_as_tls=no
3144     ;;
3145   *-*-osf*)
3146     # Tru64 UNIX loader and libc.so lack TLS support, so even if gas and
3147     # gld with TLS support are in use, native TLS cannot work.
3148     set_have_as_tls=no
3149     ;;
3150   # TLS was introduced in the Solaris 9 FCS release and backported to
3151   # Solaris 8 patches.  Support for GNU-style TLS on x86 was only
3152   # introduced in Solaris 9 4/04, replacing the earlier Sun style that Sun
3153   # ld and GCC don't support any longer.
3154   *-*-solaris2.*)
3155     AC_MSG_CHECKING(linker and ld.so.1 TLS support)
3156     ld_tls_support=no
3157     # Check ld and ld.so.1 TLS support.
3158     if echo "$ld_ver" | grep GNU > /dev/null; then
3159       # Assume all interesting versions of GNU ld have TLS support.
3160       # FIXME: still need ld.so.1 support, i.e. ld version checks below.
3161       ld_tls_support=yes
3162     else
3163       case "$target" in
3164         # Solaris 8/x86 ld has GNU style TLS support since version 1.280.
3165         i?86-*-solaris2.8)
3166           min_tls_ld_vers_minor=280
3167           ;;
3168         # Solaris 8/SPARC ld has TLS support since version 1.272.
3169         sparc*-*-solaris2.8)
3170           min_tls_ld_vers_minor=272
3171           ;;
3172         # Solaris 9/x86 ld has GNU style TLS support since version 1.374.
3173         i?86-*-solaris2.9)
3174           min_tls_ld_vers_minor=374
3175           ;;
3176         # Solaris 9/SPARC and Solaris 10+ ld have TLS support since FCS.
3177         sparc*-*-solaris2.9 | *-*-solaris2.1[[0-9]]*)
3178           min_tls_ld_vers_minor=343
3179           ;;
3180       esac
3181       if test "$ld_vers_major" -gt 1 || \
3182         test "$ld_vers_minor" -ge "$min_tls_ld_vers_minor"; then
3183         ld_tls_support=yes
3184       else
3185         set_have_as_tls=no
3186       fi
3187     fi
3188     AC_MSG_RESULT($ld_tls_support)
3189
3190     save_LIBS="$LIBS"
3191     save_LDFLAGS="$LDFLAGS"
3192     LIBS=
3193     LDFLAGS=
3194
3195     AC_MSG_CHECKING(alternate thread library)
3196     case "$target" in
3197       # TLS support was backported to Solaris 8 patches, but only lives in
3198       # the alternate thread library which became the default in Solaris 9.
3199       # We want to always use that, irrespective of TLS support.
3200       *-*-solaris2.8)
3201         # Take multilib subdir into account.  There's no spec to handle
3202         # this.  The 64 symlink exists since Solaris 8.
3203         lwp_dir=/usr/lib/lwp
3204         lwp_spec="-L$lwp_dir%{m64:/64} -R$lwp_dir%{m64:/64}"
3205         LDFLAGS="-L$lwp_dir -R$lwp_dir"
3206         ;;
3207       *-*-solaris2*)
3208         lwp_dir="none"
3209         lwp_spec=""
3210         ;;
3211     esac
3212     # Always define LIB_THREAD_LDFLAGS_SPEC, even without TLS support.
3213     AC_DEFINE_UNQUOTED(LIB_THREAD_LDFLAGS_SPEC, "$lwp_spec",
3214         [Define to the linker flags to use for -pthread.])
3215     AC_MSG_RESULT($lwp_dir)
3216
3217     AC_MSG_CHECKING(library containing $tga_func)
3218     # Before Solaris 10, __tls_get_addr (SPARC/x64) resp. ___tls_get_addr
3219     # (32-bit x86) only lived in libthread, so check for that.  Keep
3220     # set_have_as_tls if found, disable if not.
3221     AC_SEARCH_LIBS([$tga_func], [thread],, [set_have_as_tls=no])
3222     # Clear LIBS if we cannot support TLS.
3223     if test $set_have_as_tls = no; then
3224       LIBS=
3225     fi
3226     # Always define LIB_TLS_SPEC, even without TLS support.
3227     AC_DEFINE_UNQUOTED(LIB_TLS_SPEC, "$LIBS",
3228         [Define to the library containing __tls_get_addr/___tls_get_addr.])
3229     AC_MSG_RESULT($LIBS)
3230
3231     LIBS="$save_LIBS"
3232     LDFLAGS="$save_LDFLAGS"
3233     ;;
3234 esac
3235 if test $set_have_as_tls = yes ; then
3236   AC_DEFINE(HAVE_AS_TLS, 1,
3237             [Define if your assembler and linker support thread-local storage.])
3238 fi
3239
3240 # Target-specific assembler checks.
3241
3242 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3243 gcc_cv_ld_static_dynamic=no
3244 gcc_cv_ld_static_option='-Bstatic'
3245 gcc_cv_ld_dynamic_option='-Bdynamic'
3246 if test $in_tree_ld = yes ; then
3247   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; then
3248     gcc_cv_ld_static_dynamic=yes
3249   fi
3250 elif test x$gcc_cv_ld != x; then
3251   # Check if linker supports -Bstatic/-Bdynamic option
3252   if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
3253      && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
3254       gcc_cv_ld_static_dynamic=yes
3255   else
3256     case "$target" in
3257       # Tru64 UNIX support -noso/-so_archive instead of -Bstatic/-Bdynamic.
3258       alpha*-dec-osf*)
3259         gcc_cv_ld_static_dynamic=yes
3260         gcc_cv_ld_static_option="-noso"
3261         gcc_cv_ld_dynamic_option="-so_archive"
3262         ;;
3263       # HP-UX ld uses -a flags to select between shared and archive.
3264       *-*-hpux*)
3265         if test x"$gnu_ld" = xno; then
3266           gcc_cv_ld_static_dynamic=yes
3267           gcc_cv_ld_static_option="-aarchive_shared"
3268           gcc_cv_ld_dynamic_option="-adefault"
3269         fi
3270         ;;
3271       # IRIX 6 ld supports -Bstatic/-Bdynamic.
3272       mips-sgi-irix6*)
3273         gcc_cv_ld_static_dynamic=yes
3274         ;;
3275       # Solaris 2 ld always supports -Bstatic/-Bdynamic.
3276       *-*-solaris2*)
3277         gcc_cv_ld_static_dynamic=yes
3278         ;;
3279     esac
3280   fi
3281 fi
3282 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3283         AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3284 [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.])
3285         AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option",
3286 [Define to the linker option to disable use of shared objects.])
3287         AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option",
3288 [Define to the linker option to enable use of shared objects.])
3289 fi
3290 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3291
3292 if test x"$demangler_in_ld" = xyes; then
3293   AC_MSG_CHECKING(linker --demangle support)
3294   gcc_cv_ld_demangle=no
3295   if test $in_tree_ld = yes; then
3296     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 \
3297       gcc_cv_ld_demangle=yes
3298     fi
3299   elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3300     # Check if the GNU linker supports --demangle option
3301     if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3302       gcc_cv_ld_demangle=yes
3303     fi
3304   fi
3305   if test x"$gcc_cv_ld_demangle" = xyes; then
3306     AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3307 [Define if your linker supports --demangle option.])
3308   fi
3309   AC_MSG_RESULT($gcc_cv_ld_demangle)
3310 fi
3311
3312 AC_MSG_CHECKING(linker plugin support)
3313 gcc_cv_lto_plugin=0
3314 if test -f liblto_plugin.la; then
3315   save_ld_ver="$ld_ver"
3316   save_ld_vers_major="$ld_vers_major"
3317   save_ld_vers_minor="$ld_vers_minor"
3318   save_ld_is_gold="$ld_is_gold"
3319
3320   ld_is_gold=no
3321
3322   if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
3323     ld_ver="GNU ld"
3324     # FIXME: ld_is_gold?
3325     ld_vers_major="$gcc_cv_gld_major_version"
3326     ld_vers_minor="$gcc_cv_gld_minor_version"
3327   else
3328     # Determine plugin linker version.
3329     # FIXME: Partial duplicate from above, generalize.
3330 changequote(,)dnl
3331     ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q`
3332     if echo "$ld_ver" | grep GNU > /dev/null; then
3333       if echo "$ld_ver" | grep "GNU gold" > /dev/null; then
3334         ld_is_gold=yes
3335         ld_vers=`echo $ld_ver | sed -n \
3336             -e 's,^[^)]*[        ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
3337       else
3338         ld_vers=`echo $ld_ver | sed -n \
3339             -e 's,^.*[   ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
3340       fi
3341       ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
3342       ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
3343     fi
3344 changequote([,])dnl
3345   fi
3346
3347   # Determine plugin support.
3348   if echo "$ld_ver" | grep GNU > /dev/null; then
3349     # Require GNU ld or gold 2.21+ for plugin support by default.
3350     if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then
3351       gcc_cv_lto_plugin=2
3352     # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20.
3353     elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then
3354       gcc_cv_lto_plugin=1
3355     fi
3356   fi
3357
3358   ld_ver="$save_ld_ver"
3359   ld_vers_major="$save_ld_vers_major"
3360   ld_vers_minor="$save_ld_vers_minor"
3361   ld_is_gold="$save_ld_is_gold"
3362 fi
3363 AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin,
3364   [Define to the level of your linker's plugin support.])
3365 AC_MSG_RESULT($gcc_cv_lto_plugin)
3366
3367 case "$target" in
3368   # All TARGET_ABI_OSF targets.
3369   alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
3370     gcc_GAS_CHECK_FEATURE([explicit relocation support],
3371         gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3372 [       .set nomacro
3373         .text
3374         extbl   $3, $2, $3      !lituse_bytoff!1
3375         ldq     $2, a($29)      !literal!1
3376         ldq     $4, b($29)      !literal!2
3377         ldq_u   $3, 0($2)       !lituse_base!1
3378         ldq     $27, f($29)     !literal!5
3379         jsr     $26, ($27), f   !lituse_jsr!5
3380         ldah    $29, 0($26)     !gpdisp!3
3381         lda     $0, c($29)      !gprel
3382         ldah    $1, d($29)      !gprelhigh
3383         lda     $1, d($1)       !gprellow
3384         lda     $29, 0($29)     !gpdisp!3],,
3385     [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3386   [Define if your assembler supports explicit relocations.])])
3387     gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3388         gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3389 [       .set nomacro
3390         .text
3391         ldq     $27, a($29)     !literal!1
3392         jsr     $26, ($27), a   !lituse_jsrdirect!1],,
3393     [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3394   [Define if your assembler supports the lituse_jsrdirect relocation.])])
3395     ;;
3396
3397   cris-*-*)
3398     gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3399       gcc_cv_as_cris_no_mul_bug,[2,15,91],
3400       [-no-mul-bug-abort], [.text],,
3401       [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3402                 [Define if your assembler supports the -no-mul-bug-abort option.])])
3403     ;;
3404
3405   sparc*-*-*)
3406     gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3407       [.register %g2, #scratch],,
3408       [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3409                 [Define if your assembler supports .register.])])
3410
3411     gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3412       [-relax], [.text],,
3413       [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3414                 [Define if your assembler supports -relax option.])])
3415
3416     gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3417       gcc_cv_as_sparc_gotdata_op,,
3418       [-K PIC],
3419 [.text
3420 .align 4
3421 foo:
3422         nop
3423 bar:
3424         sethi %gdop_hix22(foo), %g1
3425         xor    %g1, %gdop_lox10(foo), %g1
3426         ld    [[%l7 + %g1]], %g2, %gdop(foo)],
3427       [if test x$gcc_cv_ld != x \
3428        && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3429          if test x$gcc_cv_objdump != x; then
3430            if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3431               | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3432                gcc_cv_as_sparc_gotdata_op=no
3433            else
3434                gcc_cv_as_sparc_gotdata_op=yes
3435            fi
3436          fi
3437        fi
3438        rm -f conftest],
3439       [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3440                 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3441
3442     gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3443       gcc_cv_as_sparc_ua_pcrel,,
3444       [-K PIC],
3445 [.text
3446 foo:
3447         nop
3448 .data
3449 .align 4
3450 .byte 0
3451 .uaword %r_disp32(foo)],
3452       [if test x$gcc_cv_ld != x \
3453        && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3454          gcc_cv_as_sparc_ua_pcrel=yes
3455        fi
3456        rm -f conftest],
3457       [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3458                 [Define if your assembler and linker support unaligned PC relative relocs.])
3459
3460       gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3461         gcc_cv_as_sparc_ua_pcrel_hidden,,
3462         [-K PIC],
3463 [.data
3464 .align 4
3465 .byte 0x31
3466 .uaword %r_disp32(foo)
3467 .byte 0x32, 0x33, 0x34
3468 .global foo
3469 .hidden foo
3470 foo:
3471 .skip 4],
3472         [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3473          && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3474          && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3475             | grep ' 31000000 07323334' > /dev/null 2>&1; then
3476             if $gcc_cv_objdump -R conftest 2> /dev/null \
3477                | grep 'DISP32' > /dev/null 2>&1; then
3478                 :
3479             else
3480                 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3481             fi
3482          fi
3483          rm -f conftest],
3484          [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3485                    [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3486     ]) # unaligned pcrel relocs
3487
3488     gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3489       gcc_cv_as_sparc_offsetable_lo10,,
3490       [-xarch=v9],
3491 [.text
3492         or %g1, %lo(ab) + 12, %g1
3493         or %g1, %lo(ab + 12), %g1],
3494       [if test x$gcc_cv_objdump != x \
3495        && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3496           | grep ' 82106000 82106000' > /dev/null 2>&1; then
3497          gcc_cv_as_sparc_offsetable_lo10=yes
3498        fi],
3499        [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3500                  [Define if your assembler supports offsetable %lo().])])
3501
3502     gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions],
3503       gcc_cv_as_sparc_fmaf,,
3504       [-xarch=v9d],
3505       [.text
3506        .register %g2, #scratch
3507        .register %g3, #scratch
3508        .align 4
3509        fmaddd %f0, %f2, %f4, %f6
3510        addxccc %g1, %g2, %g3
3511        fsrl32 %f2, %f4, %f8
3512        fnaddd %f10, %f12, %f14],,
3513       [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1,
3514                 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])])
3515     ;;
3516
3517 changequote(,)dnl
3518   i[34567]86-*-* | x86_64-*-*)
3519 changequote([,])dnl
3520     case $target_os in
3521       cygwin*)
3522         # Full C++ conformance when using a shared libstdc++-v3 requires some
3523         # support from the Cygwin DLL, which in more recent versions exports
3524         # wrappers to aid in interposing and redirecting operators new, delete,
3525         # etc., as per n2800 #17.6.4.6 [replacement.functions].  Check if we
3526         # are configuring for a version of Cygwin that exports the wrappers.
3527         if test x$host = x$target; then
3528           AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3529         else
3530           # Can't check presence of libc functions during cross-compile, so
3531           # we just have to assume we're building for an up-to-date target.
3532           gcc_ac_cygwin_dll_wrappers=yes
3533         fi
3534         AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3535           [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3536           [Define if you want to generate code by default that assumes that the
3537            Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3538     esac
3539     case $target_os in
3540       cygwin* | pe | mingw32*)
3541         # Recent binutils allows the three-operand form of ".comm" on PE.  This
3542         # definition is used unconditionally to initialise the default state of
3543         # the target option variable that governs usage of the feature.
3544         gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3545          [2,19,52],,[.comm foo,1,32])
3546         AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3547           [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3548           [Define if your assembler supports specifying the alignment
3549            of objects allocated using the GAS .comm command.])
3550         # Used for DWARF 2 in PE
3551         gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3552           gcc_cv_as_ix86_pe_secrel32,
3553           [2,15,91],,
3554 [.text
3555 foo:    nop
3556 .data
3557         .secrel32 foo],
3558           [if test x$gcc_cv_ld != x \
3559            && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3560              gcc_cv_as_ix86_pe_secrel32=yes
3561            fi
3562            rm -f conftest],
3563           [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3564             [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3565         # Test if the assembler supports the extended form of the .section
3566         # directive that specifies section alignment.  LTO support uses this,
3567         # but normally only after installation, so we warn but don't fail the
3568         # configure if LTO is enabled but the assembler does not support it.
3569         gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3570           [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3571         if test x$gcc_cv_as_section_has_align != xyes; then
3572           case ",$enable_languages," in
3573             *,lto,*)
3574               AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3575               ;;
3576           esac
3577         fi
3578         # Test if the assembler supports the section flag 'e' for specifying
3579         # an excluded section.
3580         gcc_GAS_CHECK_FEATURE([.section with e], gcc_cv_as_section_has_e,
3581           [2,22,51],,
3582 [.section foo1,"e"
3583 .byte 0,0,0,0])
3584         AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3585           [`if test $gcc_cv_as_section_has_e = yes; then echo 1; else echo 0; fi`],
3586           [Define if your assembler supports specifying the section flag e.])
3587         ;;
3588     esac
3589
3590     gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3591        gcc_cv_as_ix86_filds,,,
3592        [filds mem; fists mem],,
3593        [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3594          [Define if your assembler uses filds and fists mnemonics.])])
3595
3596     gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3597        gcc_cv_as_ix86_fildq,,,
3598        [fildq mem; fistpq mem],,
3599        [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3600          [Define if your assembler uses fildq and fistq mnemonics.])])
3601
3602     gcc_GAS_CHECK_FEATURE([cmov syntax],
3603       gcc_cv_as_ix86_cmov_sun_syntax,,,
3604       [cmovl.l %edx, %eax],,
3605       [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3606         [Define if your assembler supports the Sun syntax for cmov.])])
3607
3608     gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3609       gcc_cv_as_ix86_ffreep,,,
3610       [ffreep %st(1)],,
3611       [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3612         [Define if your assembler supports the ffreep mnemonic.])])
3613
3614     gcc_GAS_CHECK_FEATURE([.quad directive],
3615       gcc_cv_as_ix86_quad,,,
3616       [.quad 0],,
3617       [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
3618         [Define if your assembler supports the .quad directive.])])
3619
3620     gcc_GAS_CHECK_FEATURE([sahf mnemonic],
3621       gcc_cv_as_ix86_sahf,,,
3622       [.code64
3623        sahf],,
3624       [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
3625         [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
3626
3627     gcc_GAS_CHECK_FEATURE([swap suffix],
3628       gcc_cv_as_ix86_swap,,,
3629       [movl.s %esp, %ebp],,
3630       [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
3631         [Define if your assembler supports the swap suffix.])])
3632
3633     gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
3634       gcc_cv_as_ix86_diff_sect_delta,,,
3635       [.section .rodata
3636 .L1:
3637         .long .L2-.L1
3638         .long .L3-.L1
3639         .text
3640 .L3:    nop
3641 .L2:    nop],,
3642       [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
3643         [Define if your assembler supports the subtraction of symbols in different sections.])])
3644
3645     # These two are used unconditionally by i386.[ch]; it is to be defined
3646     # to 1 if the feature is present, 0 otherwise.
3647     gcc_GAS_CHECK_FEATURE([GOTOFF in data],
3648         gcc_cv_as_ix86_gotoff_in_data, [2,11,0],,
3649 [       .text
3650 .L0:
3651         nop
3652         .data
3653         .long .L0@GOTOFF])
3654     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
3655       [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
3656       [Define true if the assembler supports '.long foo@GOTOFF'.])
3657
3658     gcc_GAS_CHECK_FEATURE([rep and lock prefix],
3659         gcc_cv_as_ix86_rep_lock_prefix,,,
3660         [rep movsl
3661          lock addl %edi, (%eax,%esi)
3662          lock orl $0, (%esp)],,
3663         [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
3664           [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
3665
3666     gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
3667         gcc_cv_as_ix86_tlsgdplt,,,
3668         [call    tls_gd@tlsgdplt],,
3669       [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
3670         [Define if your assembler supports @tlsgdplt.])])
3671
3672     gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
3673         gcc_cv_as_ix86_tlsldmplt,,,
3674         [call    tls_ld@tlsldmplt],,
3675       [AC_DEFINE(HAVE_AS_IX86_TLSLDMPLT, 1,
3676         [Define if your assembler supports @tlsldmplt.])])
3677
3678     ;;
3679
3680   ia64*-*-*)
3681     gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
3682         gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
3683 [       .text
3684         addl r15 = @ltoffx(x#), gp
3685         ;;
3686         ld8.mov r16 = [[r15]], x#],,
3687     [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
3688           [Define if your assembler supports ltoffx and ldxmov relocations.])])
3689
3690     ;;
3691
3692   powerpc*-*-*)
3693     case $target in
3694       *-*-aix*) conftest_s='    .machine "pwr5"
3695         .csect .text[[PR]]
3696         mfcr 3,128';;
3697       *-*-darwin*)
3698         gcc_GAS_CHECK_FEATURE([.machine directive support],
3699           gcc_cv_as_machine_directive,,,
3700           [     .machine ppc7400])
3701         if test x$gcc_cv_as_machine_directive != xyes; then
3702           echo "*** This target requires an assembler supporting \".machine\"" >&2
3703           echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
3704           test x$build = x$target && exit 1
3705         fi
3706         conftest_s='    .text
3707         mfcr r3,128';;
3708       *) conftest_s='   .machine power4
3709         .text
3710         mfcr 3,128';;
3711     esac
3712
3713     gcc_GAS_CHECK_FEATURE([mfcr field support],
3714       gcc_cv_as_powerpc_mfcrf, [2,14,0],,
3715       [$conftest_s],,
3716       [AC_DEFINE(HAVE_AS_MFCRF, 1,
3717           [Define if your assembler supports mfcr field.])])
3718
3719     case $target in
3720       *-*-aix*) conftest_s='    .machine "pwr5"
3721         .csect .text[[PR]]
3722         popcntb 3,3';;
3723       *) conftest_s='   .machine power5
3724         .text
3725         popcntb 3,3';;
3726     esac
3727
3728     gcc_GAS_CHECK_FEATURE([popcntb support],
3729       gcc_cv_as_powerpc_popcntb, [2,17,0],,
3730       [$conftest_s],,
3731       [AC_DEFINE(HAVE_AS_POPCNTB, 1,
3732           [Define if your assembler supports popcntb field.])])
3733
3734     case $target in
3735       *-*-aix*) conftest_s='    .machine "pwr5x"
3736         .csect .text[[PR]]
3737         frin 1,1';;
3738       *) conftest_s='   .machine power5
3739         .text
3740         frin 1,1';;
3741     esac
3742
3743     gcc_GAS_CHECK_FEATURE([fp round support],
3744       gcc_cv_as_powerpc_fprnd, [2,17,0],,
3745       [$conftest_s],,
3746       [AC_DEFINE(HAVE_AS_FPRND, 1,
3747           [Define if your assembler supports fprnd.])])
3748
3749     case $target in
3750       *-*-aix*) conftest_s='    .machine "pwr6"
3751         .csect .text[[PR]]
3752         mffgpr 1,3';;
3753       *) conftest_s='   .machine power6
3754         .text
3755         mffgpr 1,3';;
3756     esac
3757
3758     gcc_GAS_CHECK_FEATURE([move fp gpr support],
3759       gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
3760       [$conftest_s],,
3761       [AC_DEFINE(HAVE_AS_MFPGPR, 1,
3762           [Define if your assembler supports mffgpr and mftgpr.])])
3763
3764     case $target in
3765       *-*-aix*) conftest_s='    .csect .text[[PR]]
3766 LCF..0:
3767         addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
3768       *-*-darwin*)
3769         conftest_s='    .text
3770 LCF0:
3771         addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
3772       *) conftest_s='   .text
3773 .LCF0:
3774         addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
3775     esac
3776
3777     gcc_GAS_CHECK_FEATURE([rel16 relocs],
3778       gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
3779       [$conftest_s],,
3780       [AC_DEFINE(HAVE_AS_REL16, 1,
3781           [Define if your assembler supports R_PPC_REL16 relocs.])])
3782
3783     case $target in
3784       *-*-aix*) conftest_s='    .machine "pwr6"
3785         .csect .text[[PR]]
3786         cmpb 3,4,5';;
3787       *) conftest_s='   .machine power6
3788         .text
3789         cmpb 3,4,5';;
3790     esac
3791
3792     gcc_GAS_CHECK_FEATURE([compare bytes support],
3793       gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
3794       [$conftest_s],,
3795       [AC_DEFINE(HAVE_AS_CMPB, 1,
3796           [Define if your assembler supports cmpb.])])
3797
3798     case $target in
3799       *-*-aix*) conftest_s='    .machine "pwr6"
3800         .csect .text[[PR]]
3801         dadd 1,2,3';;
3802       *) conftest_s='   .machine power6
3803         .text
3804         dadd 1,2,3';;
3805     esac
3806
3807     gcc_GAS_CHECK_FEATURE([decimal float support],
3808       gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
3809       [$conftest_s],,
3810       [AC_DEFINE(HAVE_AS_DFP, 1,
3811           [Define if your assembler supports DFP instructions.])])
3812
3813     case $target in
3814       *-*-aix*) conftest_s='    .machine "pwr7"
3815         .csect .text[[PR]]
3816         lxvd2x 1,2,3';;
3817       *) conftest_s='   .machine power7
3818         .text
3819         lxvd2x 1,2,3';;
3820     esac
3821
3822     gcc_GAS_CHECK_FEATURE([vector-scalar support],
3823       gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
3824       [$conftest_s],,
3825       [AC_DEFINE(HAVE_AS_VSX, 1,
3826           [Define if your assembler supports VSX instructions.])])
3827
3828     case $target in
3829       *-*-aix*) conftest_s='    .machine "pwr7"
3830         .csect .text[[PR]]
3831         popcntd 3,3';;
3832       *) conftest_s='   .machine power7
3833         .text
3834         popcntd 3,3';;
3835     esac
3836
3837     gcc_GAS_CHECK_FEATURE([popcntd support],
3838       gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
3839       [$conftest_s],,
3840       [AC_DEFINE(HAVE_AS_POPCNTD, 1,
3841           [Define if your assembler supports POPCNTD instructions.])])
3842
3843     case $target in
3844       *-*-aix*) conftest_s='    .csect .text[[PR]]
3845         lwsync';;
3846       *) conftest_s='   .text
3847         lwsync';;
3848     esac
3849
3850     gcc_GAS_CHECK_FEATURE([lwsync support],
3851       gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
3852       [$conftest_s],,
3853       [AC_DEFINE(HAVE_AS_LWSYNC, 1,
3854           [Define if your assembler supports LWSYNC instructions.])])
3855
3856     case $target in
3857       *-*-aix*) conftest_s='    .machine "476"
3858         .csect .text[[PR]]
3859         dci 0';;
3860       *) conftest_s='   .machine "476"
3861         .text
3862         dci 0';;
3863     esac
3864
3865     gcc_GAS_CHECK_FEATURE([data cache invalidate support],
3866       gcc_cv_as_powerpc_dci, [9,99,0], -a32,
3867       [$conftest_s],,
3868       [AC_DEFINE(HAVE_AS_DCI, 1,
3869           [Define if your assembler supports the DCI/ICI instructions.])])
3870
3871     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3872       gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
3873       [.gnu_attribute 4,1],,
3874       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3875           [Define if your assembler supports .gnu_attribute.])])
3876
3877     gcc_GAS_CHECK_FEATURE([tls marker support],
3878       gcc_cv_as_powerpc_tls_markers, [2,20,0],,
3879       [ bl __tls_get_addr(x@tlsgd)],,
3880       [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
3881           [Define if your assembler supports arg info for __tls_get_addr.])])
3882
3883     case $target in
3884       *-*-aix*)
3885         gcc_GAS_CHECK_FEATURE([.ref support],
3886           gcc_cv_as_aix_ref, [2.21.0],,
3887           [     .csect stuff[[rw]]
3888              stuff:
3889                 .long 1
3890                 .extern sym
3891                 .ref sym
3892           ],,
3893           [AC_DEFINE(HAVE_AS_REF, 1,
3894             [Define if your assembler supports .ref])])
3895         ;;
3896     esac
3897     ;;
3898
3899   mips*-*-*)
3900     gcc_GAS_CHECK_FEATURE([explicit relocation support],
3901       gcc_cv_as_mips_explicit_relocs, [2,14,0],,
3902 [       lw $4,%gp_rel(foo)($4)],,
3903       [if test x$target_cpu_default = x
3904        then target_cpu_default=MASK_EXPLICIT_RELOCS
3905        else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
3906        fi])
3907     gcc_GAS_CHECK_FEATURE([-mno-shared support],
3908       gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
3909       [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
3910                  [Define if the assembler understands -mno-shared.])])
3911
3912     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3913       gcc_cv_as_mips_gnu_attribute, [2,18,0],,
3914       [.gnu_attribute 4,1],,
3915       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3916           [Define if your assembler supports .gnu_attribute.])])
3917
3918     gcc_GAS_CHECK_FEATURE([.dtprelword support],
3919       gcc_cv_as_mips_dtprelword, [2,18,0],,
3920       [.section .tdata,"awT",@progbits
3921 x:
3922         .word 2
3923         .text
3924         .dtprelword x+0x8000],,
3925       [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
3926           [Define if your assembler supports .dtprelword.])])
3927
3928     gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
3929       gcc_cv_as_mips_dspr1_mult,,,
3930 [       .set    mips32r2
3931         .set    nodspr2
3932         .set    dsp
3933         madd    $ac3,$4,$5
3934         maddu   $ac3,$4,$5
3935         msub    $ac3,$4,$5
3936         msubu   $ac3,$4,$5
3937         mult    $ac3,$4,$5
3938         multu   $ac3,$4,$5],,
3939       [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
3940           [Define if your assembler supports DSPR1 mult.])])
3941
3942     AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
3943     gcc_cv_as_ld_jalr_reloc=no
3944     if test $gcc_cv_as_mips_explicit_relocs = yes; then
3945       if test $in_tree_ld = yes ; then
3946         if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 20 -o "$gcc_cv_gld_major_version" -gt 2 \
3947            && test $in_tree_ld_is_elf = yes; then
3948           gcc_cv_as_ld_jalr_reloc=yes
3949         fi
3950       elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
3951         echo '  .ent x' > conftest.s
3952         echo 'x:        ld $2,%got_disp(y)($3)' >> conftest.s
3953         echo '  ld $25,%call16(y)($28)' >> conftest.s
3954         echo '  .reloc  1f,R_MIPS_JALR,y' >> conftest.s
3955         echo '1:        jalr $25' >> conftest.s
3956         echo '  .reloc  1f,R_MIPS_JALR,x' >> conftest.s
3957         echo '1:        jalr $25' >> conftest.s
3958         echo '  .end x' >> conftest.s
3959         if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
3960            && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
3961           if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
3962              && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
3963             gcc_cv_as_ld_jalr_reloc=yes
3964           fi
3965         fi
3966         rm -f conftest.*
3967       fi
3968     fi
3969     if test $gcc_cv_as_ld_jalr_reloc = yes; then
3970       if test x$target_cpu_default = x; then
3971         target_cpu_default=MASK_RELAX_PIC_CALLS
3972       else
3973         target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
3974       fi
3975     fi
3976     AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
3977
3978     AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
3979       [gcc_cv_ld_mips_personality_relaxation],
3980       [gcc_cv_ld_mips_personality_relaxation=no
3981        if test $in_tree_ld = yes ; then
3982          if test "$gcc_cv_gld_major_version" -eq 2 \
3983                  -a "$gcc_cv_gld_minor_version" -ge 21 \
3984                  -o "$gcc_cv_gld_major_version" -gt 2; then
3985            gcc_cv_ld_mips_personality_relaxation=yes
3986          fi
3987        elif test x$gcc_cv_as != x \
3988                  -a x$gcc_cv_ld != x \
3989                  -a x$gcc_cv_readelf != x ; then
3990          cat > conftest.s <<EOF
3991         .cfi_startproc
3992         .cfi_personality 0x80,indirect_ptr
3993         .ent test
3994 test:
3995         nop
3996         .end test
3997         .cfi_endproc
3998
3999         .section .data,"aw",@progbits
4000 indirect_ptr:
4001         .dc.a personality
4002 EOF
4003          if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
4004             && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
4005            if $gcc_cv_readelf -d conftest 2>&1 \
4006               | grep TEXTREL > /dev/null 2>&1; then
4007              :
4008            elif $gcc_cv_readelf --relocs conftest 2>&1 \
4009                 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
4010              :
4011            else
4012              gcc_cv_ld_mips_personality_relaxation=yes
4013            fi
4014          fi
4015        fi
4016        rm -f conftest.s conftest.o conftest])
4017     if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
4018             AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
4019       [Define if your linker can relax absolute .eh_frame personality
4020 pointers into PC-relative form.])
4021     fi
4022     ;;
4023 esac
4024
4025 # Mips and HP-UX need the GNU assembler.
4026 # Linux on IA64 might be able to use the Intel assembler.
4027
4028 case "$target" in
4029   mips*-*-* | *-*-hpux* )
4030     if test x$gas_flag = xyes \
4031        || test x"$host" != x"$build" \
4032        || test ! -x "$gcc_cv_as" \
4033        || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
4034       :
4035     else
4036       echo "*** This configuration requires the GNU assembler" >&2
4037       exit 1
4038     fi
4039     ;;
4040 esac
4041
4042 # ??? Not all targets support dwarf2 debug_line, even within a version
4043 # of gas.  Moreover, we need to emit a valid instruction to trigger any
4044 # info to the output file.  So, as supported targets are added to gas 2.11,
4045 # add some instruction here to (also) show we expect this might work.
4046 # ??? Once 2.11 is released, probably need to add first known working
4047 # version to the per-target configury.
4048 case "$cpu_type" in
4049   alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze | mips \
4050   | pa | rs6000 | score | sparc | spu | xstormy16 | xtensa)
4051     insn="nop"
4052     ;;
4053   ia64 | s390)
4054     insn="nop 0"
4055     ;;
4056   mmix)
4057     insn="swym 0"
4058     ;;
4059 esac
4060 if test x"$insn" != x; then
4061  conftest_s="\
4062         .file 1 \"conftest.s\"
4063         .loc 1 3 0
4064         $insn"
4065  gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
4066   gcc_cv_as_dwarf2_debug_line,
4067   [elf,2,11,0],, [$conftest_s],
4068   [if test x$gcc_cv_objdump != x \
4069    && $gcc_cv_objdump -h conftest.o 2> /dev/null \
4070       | grep debug_line > /dev/null 2>&1; then
4071      gcc_cv_as_dwarf2_debug_line=yes
4072    fi])
4073
4074 # The .debug_line file table must be in the exact order that
4075 # we specified the files, since these indices are also used
4076 # by DW_AT_decl_file.  Approximate this test by testing if
4077 # the assembler bitches if the same index is assigned twice.
4078  gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
4079   gcc_cv_as_dwarf2_file_buggy,,,
4080 [       .file 1 "foo.s"
4081         .file 1 "bar.s"])
4082
4083  if test $gcc_cv_as_dwarf2_debug_line = yes \
4084  && test $gcc_cv_as_dwarf2_file_buggy = no; then
4085         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
4086   [Define if your assembler supports dwarf2 .file/.loc directives,
4087    and preserves file table indices exactly as given.])
4088  fi
4089
4090  gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
4091   gcc_cv_as_gdwarf2_flag,
4092   [elf,2,11,0], [--gdwarf2], [$insn],,
4093   [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
4094 [Define if your assembler supports the --gdwarf2 option.])])
4095
4096  gcc_GAS_CHECK_FEATURE([--gstabs option],
4097   gcc_cv_as_gstabs_flag,
4098   [elf,2,11,0], [--gstabs], [$insn],
4099   [# The native Solaris 9/Intel assembler doesn't understand --gstabs
4100    # and warns about it, but still exits successfully.  So check for
4101    # this.
4102    if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
4103    then :
4104    else gcc_cv_as_gstabs_flag=yes
4105    fi],
4106   [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
4107 [Define if your assembler supports the --gstabs option.])])
4108
4109  gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
4110   gcc_cv_as_debug_prefix_map_flag,
4111   [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
4112   [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
4113 [Define if your assembler supports the --debug-prefix-map option.])])
4114 fi
4115
4116 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
4117  ,,
4118 [.lcomm bar,4,16],,
4119 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
4120   [Define if your assembler supports .lcomm with an alignment field.])])
4121
4122 AC_ARG_ENABLE(gnu-unique-object,
4123  [AS_HELP_STRING([--enable-gnu-unique-object],
4124    [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
4125  [case $enable_gnu_unique_object in
4126     yes | no) ;;
4127     *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
4128 Valid choices are 'yes' and 'no'.]) ;;
4129   esac],
4130  [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
4131    [elf,2,19,52],,
4132    [.type foo, @gnu_unique_object],,
4133 # Also check for ld.so support, i.e. glibc 2.11 or higher.
4134    [[if test x$host = x$build -a x$host = x$target &&
4135        ldd --version 2>/dev/null &&
4136        glibcver=`ldd --version 2>/dev/null | sed 's/.* //;q'`; then
4137       glibcmajor=`expr "$glibcver" : "\([0-9]*\)"`
4138       glibcminor=`expr "$glibcver" : "[2-9]*\.\([0-9]*\)"`
4139       glibcnum=`expr $glibcmajor \* 1000 + $glibcminor`
4140       if test "$glibcnum" -ge 2011 ; then
4141         enable_gnu_unique_object=yes
4142       fi
4143     fi]])])
4144 if test x$enable_gnu_unique_object = xyes; then
4145   AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
4146    [Define if your assembler supports @gnu_unique_object.])
4147 fi
4148
4149 AC_CACHE_CHECK([assembler for tolerance to line number 0],
4150  [gcc_cv_as_line_zero],
4151  [gcc_cv_as_line_zero=no
4152   if test $in_tree_gas = yes; then
4153     gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
4154   elif test "x$gcc_cv_as" != x; then
4155     { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
4156     if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
4157        test "x`cat conftest.out`" = x
4158     then
4159       gcc_cv_as_line_zero=yes
4160     else
4161       echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
4162       cat conftest.s >&AS_MESSAGE_LOG_FD
4163       echo "configure: error output was" >&AS_MESSAGE_LOG_FD
4164       cat conftest.out >&AS_MESSAGE_LOG_FD
4165     fi
4166     rm -f conftest.o conftest.s conftest.out
4167   fi])
4168 if test "x$gcc_cv_as_line_zero" = xyes; then
4169   AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
4170 [Define if the assembler won't complain about a line such as # 0 "" 2.])
4171 fi
4172
4173 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
4174 gcc_cv_ld_eh_frame_hdr=no
4175 if test $in_tree_ld = yes ; then
4176   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 \
4177      && test $in_tree_ld_is_elf = yes; then
4178     gcc_cv_ld_eh_frame_hdr=yes
4179   fi
4180 elif test x$gcc_cv_ld != x; then
4181   if echo "$ld_ver" | grep GNU > /dev/null; then
4182     # Check if linker supports --eh-frame-hdr option
4183     if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
4184       gcc_cv_ld_eh_frame_hdr=yes
4185     fi
4186   else
4187     case "$target" in
4188       *-*-solaris2*)
4189         # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
4190         if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
4191           gcc_cv_ld_eh_frame_hdr=yes
4192         fi
4193         ;;
4194     esac
4195   fi
4196 fi
4197 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
4198 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
4199         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
4200 [Define if your linker supports .eh_frame_hdr.])
4201 fi
4202 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
4203
4204 AC_MSG_CHECKING(linker position independent executable support)
4205 gcc_cv_ld_pie=no
4206 if test $in_tree_ld = yes ; then
4207   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 \
4208      && test $in_tree_ld_is_elf = yes; then
4209     gcc_cv_ld_pie=yes
4210   fi
4211 elif test x$gcc_cv_ld != x; then
4212         # Check if linker supports -pie option
4213         if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
4214                 gcc_cv_ld_pie=yes
4215         fi
4216 fi
4217 if test x"$gcc_cv_ld_pie" = xyes; then
4218         AC_DEFINE(HAVE_LD_PIE, 1,
4219 [Define if your linker supports -pie option.])
4220 fi
4221 AC_MSG_RESULT($gcc_cv_ld_pie)
4222
4223 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
4224 gcc_cv_ld_eh_gc_sections=no
4225 if test $in_tree_ld = yes ; then
4226   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 17 -o "$gcc_cv_gld_major_version" -gt 2 \
4227      && test $in_tree_ld_is_elf = yes; then
4228     gcc_cv_ld_eh_gc_sections=yes
4229   fi
4230 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
4231   cat > conftest.s <<EOF
4232         .section        .text
4233 .globl _start
4234         .type _start, @function
4235 _start:
4236         .long foo
4237         .size _start, .-_start
4238         .section        .text.foo,"ax",@progbits
4239         .type foo, @function
4240 foo:
4241         .long 0
4242         .size foo, .-foo
4243         .section        .gcc_except_table.foo,"a",@progbits
4244 .L0:
4245         .long 0
4246         .section        .eh_frame,"a",@progbits
4247         .long .L0
4248 EOF
4249   if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4250     if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4251          | grep "gc-sections option ignored" > /dev/null; then
4252       gcc_cv_ld_eh_gc_sections=no
4253     elif $gcc_cv_objdump -h conftest 2> /dev/null \
4254          | grep gcc_except_table > /dev/null; then
4255       gcc_cv_ld_eh_gc_sections=yes
4256       # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
4257       if test x$gcc_cv_as_comdat_group != xyes; then
4258         gcc_cv_ld_eh_gc_sections=no
4259         cat > conftest.s <<EOF
4260         .section        .text
4261 .globl _start
4262         .type _start, @function
4263 _start:
4264         .long foo
4265         .size _start, .-_start
4266         .section        .gnu.linkonce.t.foo,"ax",@progbits
4267         .type foo, @function
4268 foo:
4269         .long 0
4270         .size foo, .-foo
4271         .section        .gcc_except_table.foo,"a",@progbits
4272 .L0:
4273         .long 0
4274         .section        .eh_frame,"a",@progbits
4275         .long .L0
4276 EOF
4277         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4278           if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4279                | grep "gc-sections option ignored" > /dev/null; then
4280             gcc_cv_ld_eh_gc_sections=no
4281           elif $gcc_cv_objdump -h conftest 2> /dev/null \
4282                | grep gcc_except_table > /dev/null; then
4283             gcc_cv_ld_eh_gc_sections=yes
4284           fi
4285         fi
4286       fi
4287     fi
4288   fi
4289   rm -f conftest.s conftest.o conftest
4290 fi
4291 case "$target" in
4292   hppa*-*-linux*)
4293     # ??? This apparently exposes a binutils bug with PC-relative relocations.
4294     gcc_cv_ld_eh_gc_sections=no
4295     ;;
4296 esac
4297 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
4298         AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
4299   [Define if your linker supports garbage collection of
4300    sections in presence of EH frames.])
4301 fi
4302 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
4303
4304 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
4305 gcc_cv_ld_eh_gc_sections_bug=no
4306 if test $in_tree_ld = yes ; then
4307   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -lt 19 -o "$gcc_cv_gld_major_version" -lt 2 \
4308      && test $in_tree_ld_is_elf = yes; then
4309     gcc_cv_ld_eh_gc_sections_bug=yes
4310   fi
4311 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x -a x$gcc_cv_as_comdat_group = xyes; then
4312   gcc_cv_ld_eh_gc_sections_bug=yes
4313   cat > conftest.s <<EOF
4314         .section        .text
4315 .globl _start
4316         .type _start, @function
4317 _start:
4318         .long foo
4319         .size _start, .-_start
4320         .section        .text.startup.foo,"ax",@progbits
4321         .type foo, @function
4322 foo:
4323         .long 0
4324         .size foo, .-foo
4325         .section        .gcc_except_table.foo,"a",@progbits
4326 .L0:
4327         .long 0
4328         .section        .eh_frame,"a",@progbits
4329         .long .L0
4330 EOF
4331   if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4332     if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4333          | grep "gc-sections option ignored" > /dev/null; then
4334       :
4335     elif $gcc_cv_objdump -h conftest 2> /dev/null \
4336          | grep gcc_except_table > /dev/null; then
4337       gcc_cv_ld_eh_gc_sections_bug=no
4338     fi
4339   fi
4340   rm -f conftest.s conftest.o conftest
4341 fi
4342 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
4343         AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
4344   [Define if your linker has buggy garbage collection of
4345    sections support when .text.startup.foo like sections are used.])
4346 fi
4347 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
4348
4349 # --------
4350 # UNSORTED
4351 # --------
4352
4353 AC_CACHE_CHECK(linker --as-needed support,
4354 gcc_cv_ld_as_needed,
4355 [gcc_cv_ld_as_needed=no
4356 if test $in_tree_ld = yes ; then
4357   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 \
4358      && test $in_tree_ld_is_elf = yes; then
4359     gcc_cv_ld_as_needed=yes
4360   fi
4361 elif test x$gcc_cv_ld != x; then
4362         # Check if linker supports --as-needed and --no-as-needed options
4363         if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
4364                 gcc_cv_ld_as_needed=yes
4365         fi
4366 fi
4367 ])
4368 if test x"$gcc_cv_ld_as_needed" = xyes; then
4369         AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
4370 [Define if your linker supports --as-needed and --no-as-needed options.])
4371 fi
4372
4373 case "$target:$tm_file" in
4374   powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
4375     AC_CACHE_CHECK(linker support for omitting dot symbols,
4376     gcc_cv_ld_no_dot_syms,
4377     [gcc_cv_ld_no_dot_syms=no
4378     if test $in_tree_ld = yes ; then
4379       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
4380         gcc_cv_ld_no_dot_syms=yes
4381       fi
4382     elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4383       cat > conftest1.s <<EOF
4384         .text
4385         bl .foo
4386 EOF
4387       cat > conftest2.s <<EOF
4388         .section ".opd","aw"
4389         .align 3
4390         .globl foo
4391         .type foo,@function
4392 foo:
4393         .quad .LEfoo,.TOC.@tocbase,0
4394         .text
4395 .LEfoo:
4396         blr
4397         .size foo,.-.LEfoo
4398 EOF
4399       if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4400          && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4401          && $gcc_cv_ld -melf64ppc -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
4402         gcc_cv_ld_no_dot_syms=yes
4403       fi
4404       rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
4405     fi
4406     ])
4407     if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
4408       AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
4409     [Define if your PowerPC64 linker only needs function descriptor syms.])
4410     fi
4411
4412     AC_CACHE_CHECK(linker large toc support,
4413     gcc_cv_ld_large_toc,
4414     [gcc_cv_ld_large_toc=no
4415     if test $in_tree_ld = yes ; then
4416       if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 21 -o "$gcc_cv_gld_major_version" -gt 2; then
4417         gcc_cv_ld_large_toc=yes
4418       fi
4419     elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4420       cat > conftest.s <<EOF
4421         .section ".tbss","awT",@nobits
4422         .align 3
4423 ie0:    .space 8
4424         .global _start
4425         .text
4426 _start:
4427         addis 9,13,ie0@got@tprel@ha
4428         ld 9,ie0@got@tprel@l(9)
4429 EOF
4430       if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
4431          && $gcc_cv_ld -melf64ppc --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
4432         gcc_cv_ld_large_toc=yes
4433       fi
4434       rm -f conftest conftest.o conftest.s
4435     fi
4436     ])
4437     if test x"$gcc_cv_ld_large_toc" = xyes; then
4438       AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4439     [Define if your PowerPC64 linker supports a large TOC.])
4440     fi
4441     ;;
4442 esac
4443
4444 AC_CACHE_CHECK(linker --build-id support,
4445   gcc_cv_ld_buildid,
4446   [gcc_cv_ld_buildid=no
4447   if test $in_tree_ld = yes ; then
4448     if test "$gcc_cv_gld_major_version" -eq 2 -a \
4449        "$gcc_cv_gld_minor_version" -ge 18 -o \
4450        "$gcc_cv_gld_major_version" -gt 2 \
4451        && test $in_tree_ld_is_elf = yes; then
4452       gcc_cv_ld_buildid=yes
4453     fi
4454   elif test x$gcc_cv_ld != x; then
4455     if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
4456       gcc_cv_ld_buildid=yes
4457     fi
4458   fi])
4459 if test x"$gcc_cv_ld_buildid" = xyes; then
4460   AC_DEFINE(HAVE_LD_BUILDID, 1,
4461   [Define if your linker supports --build-id.])
4462 fi
4463
4464 AC_ARG_ENABLE(linker-build-id,
4465 [AS_HELP_STRING([--enable-linker-build-id],
4466                 [compiler will always pass --build-id to linker])],
4467 [],
4468 enable_linker_build_id=no)
4469
4470 if test x"$enable_linker_build_id" = xyes; then
4471   if test x"$gcc_cv_ld_buildid" = xyes; then
4472     AC_DEFINE(ENABLE_LD_BUILDID, 1,
4473     [Define if gcc should always pass --build-id to linker.])
4474   else
4475     AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
4476   fi
4477 fi
4478
4479 # In binutils 2.21, GNU ld gained support for new emulations fully
4480 # supporting the Solaris 2 ABI.  Detect their presence in the linker used.
4481 AC_CACHE_CHECK(linker *_sol2 emulation support,
4482   gcc_cv_ld_sol2_emulation,
4483   [gcc_cv_ld_sol2_emulation=no
4484   if test $in_tree_ld = yes ; then
4485     if test "$gcc_cv_gld_major_version" -eq 2 -a \
4486        "$gcc_cv_gld_minor_version" -ge 21 -o \
4487        "$gcc_cv_gld_major_version" -gt 2 \
4488        && test $in_tree_ld_is_elf = yes; then
4489       gcc_cv_ld_sol2_emulation=yes
4490     fi
4491   elif test x$gcc_cv_ld != x; then
4492     if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
4493        grep _sol2 > /dev/null; then
4494       gcc_cv_ld_sol2_emulation=yes
4495     fi
4496   fi])
4497 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
4498   AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
4499   [Define if your linker supports the *_sol2 emulations.])
4500 fi
4501
4502 AC_CACHE_CHECK(linker --sysroot support,
4503   gcc_cv_ld_sysroot,
4504   [gcc_cv_ld_sysroot=no
4505   if test $in_tree_ld = yes ; then
4506       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
4507         gcc_cv_ld_sysroot=yes
4508       fi
4509   elif test x$gcc_cv_ld != x; then
4510     if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
4511       gcc_cv_ld_sysroot=yes
4512     fi
4513   fi])
4514 if test x"$gcc_cv_ld_sysroot" = xyes; then
4515   AC_DEFINE(HAVE_LD_SYSROOT, 1,
4516   [Define if your linker supports --sysroot.])
4517 fi
4518
4519 if test x$with_sysroot = x && test x$host = x$target \
4520    && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4521    && test "$prefix" != "NONE"; then
4522   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4523 [Define to PREFIX/include if cpp should also search that directory.])
4524 fi
4525
4526 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4527   if test "x$with_headers" != x; then
4528     target_header_dir=$with_headers
4529   elif test "x$with_sysroot" = x; then
4530     target_header_dir="${exec_prefix}/${target_noncanonical}/sys-include"
4531   elif test "x$with_build_sysroot" != "x"; then
4532     target_header_dir="${with_build_sysroot}${native_system_header_dir}"
4533   elif test "x$with_sysroot" = xyes; then
4534     target_header_dir="${exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
4535   else
4536     target_header_dir="${with_sysroot}${native_system_header_dir}"
4537   fi
4538 else
4539   target_header_dir=${native_system_header_dir}
4540 fi
4541
4542 # Test for stack protector support in target C library.
4543 AC_CACHE_CHECK(__stack_chk_fail in target C library,
4544       gcc_cv_libc_provides_ssp,
4545       [gcc_cv_libc_provides_ssp=no
4546     case "$target" in
4547        *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
4548       [# glibc 2.4 and later provides __stack_chk_fail and
4549       # either __stack_chk_guard, or TLS access to stack guard canary.
4550       if test -f $target_header_dir/features.h \
4551          && $EGREP '^[  ]*#[    ]*define[       ]+__GNU_LIBRARY__[      ]+([1-9][0-9]|[6-9])' \
4552             $target_header_dir/features.h > /dev/null; then
4553         if $EGREP '^[   ]*#[    ]*define[       ]+__GLIBC__[    ]+([1-9][0-9]|[3-9])' \
4554            $target_header_dir/features.h > /dev/null; then
4555           gcc_cv_libc_provides_ssp=yes
4556         elif $EGREP '^[         ]*#[    ]*define[       ]+__GLIBC__[    ]+2' \
4557              $target_header_dir/features.h > /dev/null \
4558              && $EGREP '^[      ]*#[    ]*define[       ]+__GLIBC_MINOR__[      ]+([1-9][0-9]|[4-9])' \
4559              $target_header_dir/features.h > /dev/null; then
4560           gcc_cv_libc_provides_ssp=yes
4561         elif $EGREP '^[         ]*#[    ]*define[       ]+__UCLIBC__[   ]+1' \
4562              $target_header_dir/features.h > /dev/null && \
4563              test -f $target_header_dir/bits/uClibc_config.h && \
4564              $EGREP '^[         ]*#[    ]*define[       ]+__UCLIBC_HAS_SSP__[   ]+1' \
4565              $target_header_dir/bits/uClibc_config.h > /dev/null; then
4566           gcc_cv_libc_provides_ssp=yes
4567         fi
4568       fi]
4569         ;;
4570        *-*-gnu*)
4571          # Avoid complicated tests (see
4572          # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
4573          # simply assert that glibc does provide this, which is true for all
4574          # realistically usable GNU/Hurd configurations.
4575          gcc_cv_libc_provides_ssp=yes;;
4576        *-*-darwin* | *-*-freebsd*)
4577          AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
4578            [echo "no __stack_chk_fail on this target"])
4579         ;;
4580   *) gcc_cv_libc_provides_ssp=no ;;
4581     esac])
4582
4583 if test x$gcc_cv_libc_provides_ssp = xyes; then
4584   AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
4585             [Define if your target C library provides stack protector support])
4586 fi
4587
4588 # Test for <sys/sdt.h> on the target.
4589 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
4590 AC_MSG_CHECKING(sys/sdt.h in the target C library)
4591 have_sys_sdt_h=no
4592 if test -f $target_header_dir/sys/sdt.h; then
4593   have_sys_sdt_h=yes
4594   AC_DEFINE(HAVE_SYS_SDT_H, 1,
4595             [Define if your target C library provides sys/sdt.h])
4596 fi
4597 AC_MSG_RESULT($have_sys_sdt_h)
4598
4599 # Check if TFmode long double should be used by default or not.
4600 # Some glibc targets used DFmode long double, but with glibc 2.4
4601 # and later they can use TFmode.
4602 case "$target" in
4603   powerpc*-*-linux* | \
4604   sparc*-*-linux* | \
4605   s390*-*-linux* | \
4606   alpha*-*-linux*)
4607     AC_ARG_WITH(long-double-128,
4608       [AS_HELP_STRING([--with-long-double-128],
4609                       [use 128-bit long double by default])],
4610       gcc_cv_target_ldbl128="$with_long_double_128",
4611       [[gcc_cv_target_ldbl128=no
4612       grep '^[  ]*#[    ]*define[       ][      ]*__LONG_DOUBLE_MATH_OPTIONAL' \
4613         $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
4614       && gcc_cv_target_ldbl128=yes
4615       ]])
4616     ;;
4617 esac
4618 if test x$gcc_cv_target_ldbl128 = xyes; then
4619   AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
4620             [Define if TFmode long double should be the default])
4621 fi
4622
4623 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
4624 gcc_cv_target_dl_iterate_phdr=unknown
4625 case "$target" in
4626   *-*-solaris2*)
4627     # <link.h> needs both a dl_iterate_phdr declaration and support for
4628     # compilation with largefile support.
4629     if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
4630       && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
4631       gcc_cv_target_dl_iterate_phdr=yes
4632     else
4633       gcc_cv_target_dl_iterate_phdr=no
4634     fi
4635     ;;
4636 esac
4637 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
4638 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
4639    AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
4640 [Define if your target C library provides the `dl_iterate_phdr' function.])
4641 fi
4642 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
4643
4644 # Find out what GC implementation we want, or may, use.
4645 AC_ARG_WITH(gc,
4646 [AS_HELP_STRING([--with-gc={page,zone}],
4647                 [choose the garbage collection mechanism to use
4648                  with the compiler])],
4649 [case "$withval" in
4650   page)
4651     GGC=ggc-$withval
4652     ;;
4653   zone)
4654     GGC=ggc-$withval
4655     AC_DEFINE(GGC_ZONE, 1, [Define if the zone collector is in use])
4656     ;;
4657   *)
4658     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
4659     ;;
4660 esac],
4661 [GGC=ggc-page])
4662 AC_SUBST(GGC)
4663 echo "Using $GGC for garbage collection."
4664
4665 # Libraries to use on the host.  This will normally be set by the top
4666 # level Makefile.  Here we simply capture the value for our Makefile.
4667 if test -z "${HOST_LIBS+set}"; then
4668   HOST_LIBS=
4669 fi
4670 AC_SUBST(HOST_LIBS)
4671
4672 # Use the system's zlib library.
4673 zlibdir=-L../zlib
4674 zlibinc="-I\$(srcdir)/../zlib"
4675 AC_ARG_WITH(system-zlib,
4676 [AS_HELP_STRING([--with-system-zlib], [use installed libz])],
4677 zlibdir=
4678 zlibinc=
4679 )
4680 AC_SUBST(zlibdir)
4681 AC_SUBST(zlibinc)
4682
4683 dnl Very limited version of automake's enable-maintainer-mode
4684
4685 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
4686   dnl maintainer-mode is disabled by default
4687   AC_ARG_ENABLE(maintainer-mode,
4688 [AS_HELP_STRING([--enable-maintainer-mode],
4689                 [enable make rules and dependencies not useful
4690                  (and sometimes confusing) to the casual installer])],
4691       maintainer_mode=$enableval,
4692       maintainer_mode=no)
4693
4694 AC_MSG_RESULT($maintainer_mode)
4695
4696 if test "$maintainer_mode" = "yes"; then
4697   MAINT=''
4698 else
4699   MAINT='#'
4700 fi
4701 AC_SUBST(MAINT)dnl
4702
4703 # --------------
4704 # Language hooks
4705 # --------------
4706
4707 # Make empty files to contain the specs and options for each language.
4708 # Then add #include lines to for a compiler that has specs and/or options.
4709
4710 subdirs=
4711 lang_opt_files=
4712 lang_specs_files=
4713 lang_tree_files=
4714 # These (without "all_") are set in each config-lang.in.
4715 # `language' must be a single word so is spelled singularly.
4716 all_languages=
4717 all_compilers=
4718 all_outputs='Makefile'
4719 # List of language makefile fragments.
4720 all_lang_makefrags=
4721 # Additional files for gengtype
4722 all_gtfiles="$target_gtfiles"
4723
4724 # These are the languages that are set in --enable-languages,
4725 # and are available in the GCC tree.
4726 all_selected_languages=
4727
4728 # Add the language fragments.
4729 # Languages are added via two mechanisms.  Some information must be
4730 # recorded in makefile variables, these are defined in config-lang.in.
4731 # We accumulate them and plug them into the main Makefile.
4732 # The other mechanism is a set of hooks for each of the main targets
4733 # like `clean', `install', etc.
4734
4735 language_hooks="Make-hooks"
4736
4737 for lang in ${srcdir}/*/config-lang.in
4738 do
4739 changequote(,)dnl
4740         test "$lang" = "${srcdir}/*/config-lang.in" && continue
4741
4742         lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
4743         if test "x$lang_alias" = x
4744         then
4745               echo "$lang doesn't set \$language." 1>&2
4746               exit 1
4747         fi
4748         subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
4749         subdirs="$subdirs $subdir"
4750
4751         # $gcc_subdir is where the gcc integration files are to be found
4752         # for a language, both for internal compiler purposes (compiler
4753         # sources implementing front-end to GCC tree converters), and for
4754         # build infrastructure purposes (Make-lang.in, etc.)
4755         #
4756         # This will be <subdir> (relative to $srcdir) if a line like
4757         # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
4758         # is found in <langdir>/config-lang.in, and will remain <langdir>
4759         # otherwise.
4760         #
4761         # Except for the language alias (fetched above), the regular
4762         # "config-lang.in" contents are always retrieved from $gcc_subdir,
4763         # so a <langdir>/config-lang.in setting gcc_subdir typically sets
4764         # only this and the language alias.
4765
4766         gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^   ]*\).*$,\1,p' $lang`
4767         if [ "$gcc_subdir" = "" ]; then
4768            gcc_subdir="$subdir"
4769         fi
4770
4771         case ",$enable_languages," in
4772         *,$lang_alias,*)
4773             all_selected_languages="$all_selected_languages $lang_alias"
4774             if test -f $srcdir/$gcc_subdir/lang-specs.h; then
4775                 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
4776             fi
4777             ;;
4778         esac
4779 changequote([,])dnl
4780
4781         language=
4782         boot_language=
4783         compilers=
4784         outputs=
4785         gtfiles=
4786         subdir_requires=
4787         . ${srcdir}/$gcc_subdir/config-lang.in
4788         if test "x$language" = x
4789         then
4790                 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
4791                 exit 1
4792         fi
4793
4794         ok=:
4795         case ",$enable_languages," in
4796                 *,$lang_alias,*) ;;
4797                 *)
4798                         for i in $subdir_requires; do
4799                                 test -f "${srcdir}/$i/config-lang.in" && continue
4800                                 ok=false
4801                                 break
4802                         done
4803                 ;;
4804         esac
4805         $ok || continue
4806
4807         all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
4808         if test -f $srcdir/$gcc_subdir/lang.opt; then
4809             lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
4810             all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
4811         fi
4812         if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
4813             lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
4814         fi
4815         all_languages="$all_languages $language"
4816         all_compilers="$all_compilers $compilers"
4817         all_outputs="$all_outputs $outputs"
4818         all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
4819         case ",$enable_languages," in
4820                 *,lto,*)
4821                     AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
4822                     enable_lto=yes
4823                     AC_SUBST(enable_lto)
4824                     ;;
4825                 *) ;;
4826         esac
4827 done
4828
4829 # Pick up gtfiles for c
4830 gtfiles=
4831 . ${srcdir}/c-config-lang.in
4832 all_gtfiles="$all_gtfiles [[c]] $gtfiles"
4833
4834 check_languages=
4835 for language in $all_selected_languages
4836 do
4837         check_languages="$check_languages check-$language"
4838 done
4839
4840 # We link each language in with a set of hooks, reached indirectly via
4841 # lang.${target}.  Only do so for selected languages.
4842
4843 rm -f Make-hooks
4844 touch Make-hooks
4845 target_list="all.cross start.encap rest.encap tags \
4846         install-common install-man install-info install-pdf install-html dvi \
4847         pdf html uninstall info man srcextra srcman srcinfo \
4848         mostlyclean clean distclean maintainer-clean install-plugin"
4849
4850 for t in $target_list
4851 do
4852         x=
4853         for lang in $all_selected_languages
4854         do
4855                 x="$x $lang.$t"
4856         done
4857         echo "lang.$t: $x" >> Make-hooks
4858 done
4859
4860 # --------
4861 # Option include files
4862 # --------
4863
4864 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
4865 option_includes="option-includes.mk"
4866 AC_SUBST_FILE(option_includes)
4867
4868 # --------
4869 # UNSORTED
4870 # --------
4871
4872 # Create .gdbinit.
4873
4874 echo "dir ." > .gdbinit
4875 echo "dir ${srcdir}" >> .gdbinit
4876 if test x$gdb_needs_out_file_path = xyes
4877 then
4878         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
4879 fi
4880 if test "x$subdirs" != x; then
4881         for s in $subdirs
4882         do
4883                 echo "dir ${srcdir}/$s" >> .gdbinit
4884         done
4885 fi
4886 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
4887
4888 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
4889 AC_SUBST(gcc_tooldir)
4890 AC_SUBST(dollar)
4891
4892 # Find a directory in which to install a shared libgcc.
4893
4894 AC_ARG_ENABLE(version-specific-runtime-libs,
4895 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
4896                 [specify that runtime libraries should be
4897                  installed in a compiler-specific directory])])
4898
4899 # Substitute configuration variables
4900 AC_SUBST(subdirs)
4901 AC_SUBST(srcdir)
4902 AC_SUBST(all_compilers)
4903 AC_SUBST(all_gtfiles)
4904 AC_SUBST(all_lang_makefrags)
4905 AC_SUBST(all_languages)
4906 AC_SUBST(all_selected_languages)
4907 AC_SUBST(build_exeext)
4908 AC_SUBST(build_install_headers_dir)
4909 AC_SUBST(build_xm_file_list)
4910 AC_SUBST(build_xm_include_list)
4911 AC_SUBST(build_xm_defines)
4912 AC_SUBST(build_file_translate)
4913 AC_SUBST(check_languages)
4914 AC_SUBST(cpp_install_dir)
4915 AC_SUBST(xmake_file)
4916 AC_SUBST(tmake_file)
4917 AC_SUBST(TM_ENDIAN_CONFIG)
4918 AC_SUBST(TM_MULTILIB_CONFIG)
4919 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
4920 AC_SUBST(extra_gcc_objs)
4921 AC_SUBST(user_headers_inc_next_pre)
4922 AC_SUBST(user_headers_inc_next_post)
4923 AC_SUBST(extra_headers_list)
4924 AC_SUBST(extra_objs)
4925 AC_SUBST(extra_passes)
4926 AC_SUBST(extra_programs)
4927 AC_SUBST(float_h_file)
4928 AC_SUBST(gcc_config_arguments)
4929 AC_SUBST(gcc_gxx_include_dir)
4930 AC_SUBST(host_exeext)
4931 AC_SUBST(host_xm_file_list)
4932 AC_SUBST(host_xm_include_list)
4933 AC_SUBST(host_xm_defines)
4934 AC_SUBST(out_host_hook_obj)
4935 AC_SUBST(install)
4936 AC_SUBST(lang_opt_files)
4937 AC_SUBST(lang_specs_files)
4938 AC_SUBST(lang_tree_files)
4939 AC_SUBST(local_prefix)
4940 AC_SUBST(md_file)
4941 AC_SUBST(objc_boehm_gc)
4942 AC_SUBST(out_file)
4943 AC_SUBST(out_object_file)
4944 AC_SUBST(common_out_file)
4945 AC_SUBST(common_out_object_file)
4946 AC_SUBST(tm_file_list)
4947 AC_SUBST(tm_include_list)
4948 AC_SUBST(tm_defines)
4949 AC_SUBST(tm_p_file_list)
4950 AC_SUBST(tm_p_include_list)
4951 AC_SUBST(xm_file_list)
4952 AC_SUBST(xm_include_list)
4953 AC_SUBST(xm_defines)
4954 AC_SUBST(use_gcc_stdint)
4955 AC_SUBST(c_target_objs)
4956 AC_SUBST(cxx_target_objs)
4957 AC_SUBST(fortran_target_objs)
4958 AC_SUBST(target_cpu_default)
4959
4960 AC_SUBST_FILE(language_hooks)
4961
4962 # Echo link setup.
4963 if test x${build} = x${host} ; then
4964   if test x${host} = x${target} ; then
4965     echo "Links are now set up to build a native compiler for ${target}." 1>&2
4966   else
4967     echo "Links are now set up to build a cross-compiler" 1>&2
4968     echo " from ${host} to ${target}." 1>&2
4969   fi
4970 else
4971   if test x${host} = x${target} ; then
4972     echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
4973     echo " for ${target}." 1>&2
4974   else
4975     echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
4976     echo " from ${host} to ${target}." 1>&2
4977   fi
4978 fi
4979
4980 AC_ARG_VAR(GMPLIBS,[How to link GMP])
4981 AC_ARG_VAR(GMPINC,[How to find GMP include files])
4982
4983 AC_ARG_VAR(PPLLIBS,[How to link PPL])
4984 AC_ARG_VAR(PPLINC,[How to find PPL include files])
4985
4986 AC_ARG_VAR(CLOOGLIBS,[How to link CLOOG])
4987 AC_ARG_VAR(CLOOGINC,[How to find CLOOG include files])
4988 if test "x${CLOOGLIBS}" != "x" ; then
4989    AC_DEFINE(HAVE_cloog, 1, [Define if cloog is in use.])
4990 fi
4991
4992 # Check for plugin support
4993 AC_ARG_ENABLE(plugin,
4994 [AS_HELP_STRING([--enable-plugin], [enable plugin support])],
4995 enable_plugin=$enableval,
4996 enable_plugin=yes; default_plugin=yes)
4997
4998 pluginlibs=
4999
5000 case "${host}" in
5001   *-*-darwin*)
5002     if test x$build = x$host; then
5003       export_sym_check="nm${exeext} -g"
5004     elif test x$host = x$target; then
5005       export_sym_check="$gcc_cv_nm -g"
5006     else
5007       export_sym_check=
5008     fi
5009   ;;
5010   *)
5011     if test x$build = x$host; then
5012       export_sym_check="objdump${exeext} -T"
5013     elif test x$host = x$target; then
5014       export_sym_check="$gcc_cv_objdump -T"
5015     else
5016       export_sym_check=
5017     fi
5018   ;;
5019 esac
5020
5021 if test x"$enable_plugin" = x"yes"; then
5022
5023   AC_MSG_CHECKING([for exported symbols])
5024   if test "x$export_sym_check" != x; then
5025     echo "int main() {return 0;} int foobar() {return 0;}" > conftest.c
5026     ${CC} ${CFLAGS} ${LDFLAGS} conftest.c -o conftest > /dev/null 2>&1
5027     if $export_sym_check conftest | grep foobar > /dev/null; then
5028       : # No need to use a flag
5029       AC_MSG_RESULT([yes])
5030     else
5031       AC_MSG_RESULT([yes])
5032       AC_MSG_CHECKING([for -rdynamic])
5033       ${CC} ${CFLAGS} ${LDFLAGS} -rdynamic conftest.c -o conftest > /dev/null 2>&1
5034       if $export_sym_check conftest | grep foobar > /dev/null; then
5035         plugin_rdynamic=yes
5036         pluginlibs="-rdynamic"
5037       else
5038         plugin_rdynamic=no
5039         enable_plugin=no
5040       fi
5041       AC_MSG_RESULT([$plugin_rdynamic])
5042     fi
5043   else
5044     AC_MSG_RESULT([unable to check])
5045   fi
5046
5047   # Check -ldl
5048   saved_LIBS="$LIBS"
5049   AC_SEARCH_LIBS([dlopen], [dl])
5050   if test x"$ac_cv_search_dlopen" = x"-ldl"; then
5051     pluginlibs="$pluginlibs -ldl"
5052   fi
5053   LIBS="$saved_LIBS"
5054
5055   # Check that we can build shared objects with -fPIC -shared
5056   saved_LDFLAGS="$LDFLAGS"
5057   saved_CFLAGS="$CFLAGS"
5058   case "${host}" in
5059     *-*-darwin*)
5060       CFLAGS=`echo $CFLAGS | sed s/-mdynamic-no-pic//g`
5061       CFLAGS="$CFLAGS -fPIC"
5062       LDFLAGS="$LDFLAGS -shared -undefined dynamic_lookup"
5063     ;;
5064     *)
5065       CFLAGS="$CFLAGS -fPIC"
5066       LDFLAGS="$LDFLAGS -fPIC -shared"
5067     ;;
5068   esac
5069   AC_MSG_CHECKING([for -fPIC -shared])
5070   AC_TRY_LINK(
5071     [extern int X;],[return X == 0;],
5072     [AC_MSG_RESULT([yes]); have_pic_shared=yes],
5073     [AC_MSG_RESULT([no]); have_pic_shared=no])
5074   if test x"$have_pic_shared" != x"yes" -o x"$ac_cv_search_dlopen" = x"no"; then
5075     pluginlibs=
5076     enable_plugin=no
5077   fi
5078   LDFLAGS="$saved_LDFLAGS"
5079   CFLAGS="$saved_CFLAGS"
5080
5081   # If plugin support had been requested but not available, fail.
5082   if test x"$enable_plugin" = x"no" ; then
5083     if test x"$default_plugin" != x"yes"; then
5084       AC_MSG_ERROR([
5085 Building GCC with plugin support requires a host that supports
5086 -fPIC, -shared, -ldl and -rdynamic.])
5087     fi
5088   fi
5089 fi
5090
5091 AC_SUBST(pluginlibs)
5092 AC_SUBST(enable_plugin)
5093 if test x"$enable_plugin" = x"yes"; then
5094   AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
5095 fi
5096
5097
5098 AC_ARG_ENABLE(libquadmath-support,
5099 [AS_HELP_STRING([--disable-libquadmath-support],
5100   [disable libquadmath support for Fortran])],
5101 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
5102 ENABLE_LIBQUADMATH_SUPPORT=yes)
5103 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
5104   AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
5105             [Define to 1 to enable libquadmath support])
5106 fi
5107
5108
5109 # Specify what hash style to use by default.
5110 AC_ARG_WITH([linker-hash-style],
5111 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
5112                 [specify the linker hash style])],
5113 [case x"$withval" in
5114    xsysv)
5115      LINKER_HASH_STYLE=sysv
5116      ;;
5117    xgnu)
5118      LINKER_HASH_STYLE=gnu
5119      ;;
5120    xboth)
5121      LINKER_HASH_STYLE=both
5122      ;;
5123    *)
5124      AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
5125      ;;
5126  esac],
5127 [LINKER_HASH_STYLE=''])
5128 if test x"${LINKER_HASH_STYLE}" != x; then
5129   AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
5130                                          [The linker hash style])
5131 fi
5132
5133 # Configure the subdirectories
5134 # AC_CONFIG_SUBDIRS($subdirs)
5135
5136 # Create the Makefile
5137 # and configure language subdirectories
5138 AC_CONFIG_FILES($all_outputs)
5139
5140 AC_CONFIG_COMMANDS([default],
5141 [
5142 case ${CONFIG_HEADERS} in
5143   *auto-host.h:config.in*)
5144   echo > cstamp-h ;;
5145 esac
5146 # Make sure all the subdirs exist.
5147 for d in $subdirs doc build common c-family
5148 do
5149     test -d $d || mkdir $d
5150 done
5151 ],
5152 [subdirs='$subdirs'])
5153 AC_OUTPUT
5154