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