gcc/configure.ac

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