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