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