gcc/configure.ac

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