gcc/configure.ac

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