gcc/configure.ac

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