gcc/configure.ac

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