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