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