gcc/configure.ac

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