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