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