gcc/configure.ac

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