gcc/configure.ac

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