gcc/configure.ac

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