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