gcc/configure.ac

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