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