embedded-4_9-branch/gcc/configure.ac

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