gcc/configure.ac

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