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