gcc/configure.ac

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