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