gcc/configure.ac

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