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