gcc/configure.ac

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