gcc/configure.ac

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