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