gcc/configure.ac

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