gcc/configure.ac

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