gcc/configure.ac

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