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(leading-mingw64-underscores,
1572   AS_HELP_STRING([--enable-leading-mingw64-underscores],
1573                  [Enable leading underscores on 64 bit mingw targets]),
1574   [],[])
1575 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
1576   [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
1577     [Define if we should use leading underscore on 64 bit mingw targets])])
1578
1579 AC_ARG_ENABLE(cld,
1580 [  --enable-cld            enable -mcld by default for 32bit x86], [],
1581 [enable_cld=no])
1582
1583 # Windows32 Registry support for specifying GCC installation paths.
1584 AC_ARG_ENABLE(win32-registry,
1585 [  --disable-win32-registry
1586                           disable lookup of installation paths in the
1587                           Registry on Windows hosts
1588   --enable-win32-registry enable registry lookup (default)
1589   --enable-win32-registry=KEY
1590                           use KEY instead of GCC version as the last portion
1591                           of the registry key],,)
1592
1593 case $host_os in
1594   win32 | pe | cygwin* | mingw32* | uwin*)
1595     if test "x$enable_win32_registry" != xno; then
1596       AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1597     fi
1598
1599     if test "x$enable_win32_registry" != xno; then
1600       AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1601   [Define to 1 if installation paths should be looked up in the Windows
1602    Registry. Ignored on non-Windows hosts.])
1603
1604       if test "x$enable_win32_registry" != xyes \
1605          && test "x$enable_win32_registry" != x; then
1606         AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1607   [Define to be the last component of the Windows registry key under which
1608    to look for installation paths.  The full key used will be
1609    HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1610    The default is the GCC version number.])
1611       fi
1612     fi
1613   ;;
1614 esac
1615
1616 # Get an absolute path to the GCC top-level source directory
1617 holddir=`${PWDCMD-pwd}`
1618 cd $srcdir
1619 topdir=`${PWDCMD-pwd}`
1620 cd $holddir
1621
1622 # Conditionalize the makefile for this host machine.
1623 xmake_file=
1624 for f in ${host_xmake_file}
1625 do
1626         if test -f ${srcdir}/config/$f
1627         then
1628                 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1629         fi
1630 done
1631
1632 # Conditionalize the makefile for this target machine.
1633 tmake_file_=
1634 for f in ${tmake_file}
1635 do
1636         if test -f ${srcdir}/config/$f
1637         then
1638                 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1639         fi
1640 done
1641 tmake_file="${tmake_file_}"
1642
1643 out_object_file=`basename $out_file .c`.o
1644
1645 tm_file_list="options.h"
1646 tm_include_list="options.h"
1647 for f in $tm_file; do
1648   case $f in
1649     ./* )
1650        f=`echo $f | sed 's/^..//'`
1651        tm_file_list="${tm_file_list} $f"
1652        tm_include_list="${tm_include_list} $f"
1653        ;;
1654     defaults.h )
1655        tm_file_list="${tm_file_list} \$(srcdir)/$f"
1656        tm_include_list="${tm_include_list} $f"
1657        ;;
1658     * )
1659        tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1660        tm_include_list="${tm_include_list} config/$f"
1661        ;;
1662   esac
1663 done
1664
1665 tm_p_file_list=
1666 tm_p_include_list=
1667 for f in $tm_p_file; do
1668   case $f in
1669     tm-preds.h )
1670        tm_p_file_list="${tm_p_file_list} $f"
1671        tm_p_include_list="${tm_p_include_list} $f"
1672        ;;
1673     * )
1674        tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1675        tm_p_include_list="${tm_p_include_list} config/$f"
1676   esac
1677 done
1678
1679 xm_file_list=
1680 xm_include_list=
1681 for f in $xm_file; do
1682   case $f in
1683     ansidecl.h )
1684        xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1685        xm_include_list="${xm_include_list} $f"
1686        ;;
1687     auto-host.h )
1688        xm_file_list="${xm_file_list} $f"
1689        xm_include_list="${xm_include_list} $f"
1690        ;;
1691     * )
1692        xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1693        xm_include_list="${xm_include_list} config/$f"
1694        ;;
1695   esac
1696 done
1697
1698 host_xm_file_list=
1699 host_xm_include_list=
1700 for f in $host_xm_file; do
1701   case $f in
1702     ansidecl.h )
1703        host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1704        host_xm_include_list="${host_xm_include_list} $f"
1705        ;;
1706     auto-host.h )
1707        host_xm_file_list="${host_xm_file_list} $f"
1708        host_xm_include_list="${host_xm_include_list} $f"
1709        ;;
1710     * )
1711        host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1712        host_xm_include_list="${host_xm_include_list} config/$f"
1713        ;;
1714   esac
1715 done
1716
1717 build_xm_file_list=
1718 for f in $build_xm_file; do
1719   case $f in
1720     ansidecl.h )
1721        build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1722        build_xm_include_list="${build_xm_include_list} $f"
1723        ;;
1724     auto-build.h | auto-host.h )
1725        build_xm_file_list="${build_xm_file_list} $f"
1726        build_xm_include_list="${build_xm_include_list} $f"
1727        ;;
1728     * )
1729        build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1730        build_xm_include_list="${build_xm_include_list} config/$f"
1731        ;;
1732   esac
1733 done
1734
1735 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1736 # cross-compiler which does not use the native headers and libraries.
1737 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1738 CROSS=                                          AC_SUBST(CROSS)
1739 ALL=all.internal                                AC_SUBST(ALL)
1740 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1741
1742 if test "x$with_build_sysroot" != x; then
1743   build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1744 else
1745   # This value is used, even on a native system, because
1746   # CROSS_SYSTEM_HEADER_DIR is just
1747   # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1748   build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1749 fi
1750
1751 if test x$host != x$target
1752 then
1753         CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1754         ALL=all.cross
1755         SYSTEM_HEADER_DIR=$build_system_header_dir
1756         case "$host","$target" in
1757         # Darwin crosses can use the host system's libraries and headers,
1758         # because of the fat library support.  Of course, it must be the
1759         # same version of Darwin on both sides.  Allow the user to
1760         # just say --target=foo-darwin without a version number to mean
1761         # "the version on this system".
1762             *-*-darwin*,*-*-darwin*)
1763                 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1764                 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1765                 if test $hostos = $targetos -o $targetos = darwin ; then
1766                     CROSS=
1767                     SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1768                     with_headers=yes
1769                 fi
1770                 ;;
1771
1772             i?86-*-*,x86_64-*-* \
1773             | powerpc*-*-*,powerpc64*-*-*)
1774                 CROSS="$CROSS -DNATIVE_CROSS" ;;
1775         esac
1776 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1777         SYSTEM_HEADER_DIR=$build_system_header_dir
1778 fi
1779
1780 # If this is a cross-compiler that does not
1781 # have its own set of headers then define
1782 # inhibit_libc
1783
1784 # If this is using newlib, without having the headers available now,
1785 # then define inhibit_libc in LIBGCC2_CFLAGS.
1786 # This prevents libgcc2 from containing any code which requires libc
1787 # support.
1788 : ${inhibit_libc=false}
1789 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1790        test x$with_newlib = xyes ; } &&
1791      { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1792        inhibit_libc=true
1793 fi
1794 AC_SUBST(inhibit_libc)
1795
1796 # When building gcc with a cross-compiler, we need to adjust things so
1797 # that the generator programs are still built with the native compiler.
1798 # Also, we cannot run fixincludes.
1799
1800 # These are the normal (build=host) settings:
1801 CC_FOR_BUILD='$(CC)'            AC_SUBST(CC_FOR_BUILD)
1802 BUILD_CFLAGS='$(ALL_CFLAGS)'    AC_SUBST(BUILD_CFLAGS)
1803 BUILD_LDFLAGS='$(LDFLAGS)'      AC_SUBST(BUILD_LDFLAGS)
1804 STMP_FIXINC=stmp-fixinc         AC_SUBST(STMP_FIXINC)
1805
1806 # And these apply if build != host, or we are generating coverage data
1807 if test x$build != x$host || test "x$coverage_flags" != x
1808 then
1809     BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1810     BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
1811 fi
1812
1813 # Expand extra_headers to include complete path.
1814 # This substitutes for lots of t-* files.
1815 extra_headers_list=
1816 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1817 for file in ${extra_headers} ; do
1818   extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1819 done
1820
1821 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
1822 if test x"$use_gcc_tgmath" = xyes
1823 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
1824 fi
1825
1826 # Define collect2 in Makefile.
1827 case $host_can_use_collect2 in
1828   no) collect2= ;;
1829   *) collect2='collect2$(exeext)' ;;
1830 esac
1831 AC_SUBST([collect2])
1832
1833 # Add a definition of USE_COLLECT2 if system wants one.
1834 case $use_collect2 in
1835   no) use_collect2= ;;
1836   "") ;;
1837   *)
1838     host_xm_defines="${host_xm_defines} USE_COLLECT2"
1839     xm_defines="${xm_defines} USE_COLLECT2"
1840     case $host_can_use_collect2 in
1841       no)
1842         AC_MSG_ERROR([collect2 is required but cannot be built on this system])
1843         ;;
1844     esac
1845     ;;
1846 esac
1847
1848 # ---------------------------
1849 # Assembler & linker features
1850 # ---------------------------
1851
1852 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
1853 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
1854 # However when ld-new is first executed from the build tree, libtool will
1855 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
1856 # to the build tree.  While doing this we need to use the previous-stage
1857 # linker, or we have an infinite loop.  The presence of a shell script as
1858 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
1859 # the gcc/collect-ld script.  So we need to know how libtool works, or
1860 # exec-tool will fail.
1861
1862 m4_defun([_LT_CONFIG_COMMANDS], [])
1863 AC_PROG_LIBTOOL
1864 AC_SUBST(objdir)
1865 AC_SUBST(enable_fast_install)
1866
1867 # Identify the assembler which will work hand-in-glove with the newly
1868 # built GCC, so that we can examine its features.  This is the assembler
1869 # which will be driven by the driver program.
1870 #
1871 # If build != host, and we aren't building gas in-tree, we identify a
1872 # build->target assembler and hope that it will have the same features
1873 # as the host->target assembler we'll be using.
1874 gcc_cv_gas_major_version=
1875 gcc_cv_gas_minor_version=
1876 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1877
1878 m4_pattern_allow([AS_FOR_TARGET])dnl
1879 AS_VAR_SET_IF(gcc_cv_as,, [
1880 if test -x "$DEFAULT_ASSEMBLER"; then
1881         gcc_cv_as="$DEFAULT_ASSEMBLER"
1882 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
1883      && test -f ../gas/Makefile \
1884      && test x$build = x$host; then
1885         gcc_cv_as=../gas/as-new$build_exeext
1886 elif test -x as$build_exeext; then
1887         # Build using assembler in the current directory.
1888         gcc_cv_as=./as$build_exeext
1889 elif test -x $AS_FOR_TARGET; then
1890         gcc_cv_as="$AS_FOR_TARGET"
1891 else
1892         AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
1893 fi])
1894
1895 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
1896 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
1897 case "$ORIGINAL_AS_FOR_TARGET" in
1898   ./as | ./as$build_exeext) ;;
1899   *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
1900 esac
1901
1902 AC_MSG_CHECKING(what assembler to use)
1903 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
1904   # Single tree build which includes gas.  We want to prefer it
1905   # over whatever linker top-level may have detected, since
1906   # we'll use what we're building after installation anyway.
1907   AC_MSG_RESULT(newly built gas)
1908   in_tree_gas=yes
1909   _gcc_COMPUTE_GAS_VERSION
1910   in_tree_gas_is_elf=no
1911   if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
1912      || (grep 'obj_format = multi' ../gas/Makefile \
1913          && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
1914   then
1915     in_tree_gas_is_elf=yes
1916   fi
1917 else
1918   AC_MSG_RESULT($gcc_cv_as)
1919   in_tree_gas=no
1920 fi
1921
1922 # Identify the linker which will work hand-in-glove with the newly
1923 # built GCC, so that we can examine its features.  This is the linker
1924 # which will be driven by the driver program.
1925 #
1926 # If build != host, and we aren't building gas in-tree, we identify a
1927 # build->target linker and hope that it will have the same features
1928 # as the host->target linker we'll be using.
1929 gcc_cv_gld_major_version=
1930 gcc_cv_gld_minor_version=
1931 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1932 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1933
1934 AS_VAR_SET_IF(gcc_cv_ld,, [
1935 if test -x "$DEFAULT_LINKER"; then
1936         gcc_cv_ld="$DEFAULT_LINKER"
1937 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
1938      && test -f ../ld/Makefile \
1939      && test x$build = x$host; then
1940         gcc_cv_ld=../ld/ld-new$build_exeext
1941 elif test -x collect-ld$build_exeext; then
1942         # Build using linker in the current directory.
1943         gcc_cv_ld=./collect-ld$build_exeext
1944 elif test -x $LD_FOR_TARGET; then
1945         gcc_cv_ld="$LD_FOR_TARGET"
1946 else
1947         AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
1948 fi])
1949
1950 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
1951 PLUGIN_LD=`basename $gcc_cv_ld`
1952 AC_ARG_WITH(plugin-ld,
1953 [  --with-plugin-ld=[[ARG]]  specify the plugin linker],
1954 [if test x"$withval" != x; then
1955    ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
1956    PLUGIN_LD="$withval"
1957  fi])
1958 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
1959 AC_DEFINE_UNQUOTED(PLUGIN_LD, "$PLUGIN_LD", [Specify plugin linker])
1960
1961 # Check to see if we are using gold instead of ld
1962 AC_MSG_CHECKING(whether we are using gold)
1963 ld_is_gold=no
1964 if test x$gcc_cv_ld != x; then
1965   if $gcc_cv_ld --version 2>/dev/null | sed 1q \
1966      | grep "GNU gold" > /dev/null; then
1967     ld_is_gold=yes
1968   fi
1969 fi
1970 AC_MSG_RESULT($ld_is_gold)
1971
1972 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
1973 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
1974 case "$ORIGINAL_LD_FOR_TARGET" in
1975   ./collect-ld | ./collect-ld$build_exeext) ;;
1976   *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
1977 esac
1978
1979 AC_MSG_CHECKING(what linker to use)
1980 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext; then
1981         # Single tree build which includes ld.  We want to prefer it
1982         # over whatever linker top-level may have detected, since
1983         # we'll use what we're building after installation anyway.
1984         AC_MSG_RESULT(newly built ld)
1985         in_tree_ld=yes
1986         in_tree_ld_is_elf=no
1987         if (grep 'EMUL = .*elf' ../ld/Makefile \
1988             || grep 'EMUL = .*linux' ../ld/Makefile \
1989             || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
1990           in_tree_ld_is_elf=yes
1991         fi
1992         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
1993         do
1994 changequote(,)dnl
1995                 gcc_cv_gld_version=`sed -n -e 's/^[     ]*\(VERSION=[0-9]*\.[0-9]*.*\)/\1/p' < $f`
1996                 if test x$gcc_cv_gld_version != x; then
1997                         break
1998                 fi
1999         done
2000         gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2001         gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2002 changequote([,])dnl
2003 else
2004         AC_MSG_RESULT($gcc_cv_ld)
2005         in_tree_ld=no
2006 fi
2007
2008 # Figure out what nm we will be using.
2009 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2010 AS_VAR_SET_IF(gcc_cv_nm,, [
2011 if test -f $gcc_cv_binutils_srcdir/configure.in \
2012      && test -f ../binutils/Makefile \
2013      && test x$build = x$host; then
2014         gcc_cv_nm=../binutils/nm-new$build_exeext
2015 elif test -x nm$build_exeext; then
2016         gcc_cv_nm=./nm$build_exeext
2017 elif test -x $NM_FOR_TARGET; then
2018         gcc_cv_nm="$NM_FOR_TARGET"
2019 else
2020         AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2021 fi])
2022
2023 AC_MSG_CHECKING(what nm to use)
2024 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2025         # Single tree build which includes binutils.
2026         AC_MSG_RESULT(newly built nm)
2027         in_tree_nm=yes
2028 else
2029         AC_MSG_RESULT($gcc_cv_nm)
2030         in_tree_nm=no
2031 fi
2032
2033 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2034 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2035 case "$ORIGINAL_NM_FOR_TARGET" in
2036   ./nm | ./nm$build_exeext) ;;
2037   *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2038 esac
2039
2040
2041 # Figure out what objdump we will be using.
2042 AS_VAR_SET_IF(gcc_cv_objdump,, [
2043 if test -f $gcc_cv_binutils_srcdir/configure.in \
2044      && test -f ../binutils/Makefile \
2045      && test x$build = x$host; then
2046         # Single tree build which includes binutils.
2047         gcc_cv_objdump=../binutils/objdump$build_exeext
2048 elif test -x objdump$build_exeext; then
2049         gcc_cv_objdump=./objdump$build_exeext
2050 elif test -x $OBJDUMP_FOR_TARGET; then
2051         gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2052 else
2053         AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2054 fi])
2055
2056 AC_MSG_CHECKING(what objdump to use)
2057 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2058         # Single tree build which includes binutils.
2059         AC_MSG_RESULT(newly built objdump)
2060 elif test x$gcc_cv_objdump = x; then
2061         AC_MSG_RESULT(not found)
2062 else
2063         AC_MSG_RESULT($gcc_cv_objdump)
2064 fi
2065
2066 # Figure out what readelf we will be using.
2067 AS_VAR_SET_IF(gcc_cv_readelf,, [
2068 if test -f $gcc_cv_binutils_srcdir/configure.in \
2069      && test -f ../binutils/Makefile \
2070      && test x$build = x$host; then
2071         # Single tree build which includes binutils.
2072         gcc_cv_readelf=../binutils/readelf$build_exeext
2073 elif test -x readelf$build_exeext; then
2074         gcc_cv_readelf=./readelf$build_exeext
2075 else
2076         AC_PATH_PROG(gcc_cv_readelf, readelf)
2077 fi])
2078
2079 AC_MSG_CHECKING(what readelf to use)
2080 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2081         # Single tree build which includes binutils.
2082         AC_MSG_RESULT(newly built readelf)
2083 elif test x$gcc_cv_readelf = x; then
2084         AC_MSG_RESULT(not found)
2085 else
2086         AC_MSG_RESULT($gcc_cv_readelf)
2087 fi
2088
2089 # Figure out what assembler alignment features are present.
2090 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2091  [2,6,0],,
2092 [.balign 4
2093 .p2align 2],,
2094 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2095   [Define if your assembler supports .balign and .p2align.])])
2096
2097 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2098  [2,8,0],,
2099  [.p2align 4,,7],,
2100 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2101   [Define if your assembler supports specifying the maximum number
2102    of bytes to skip when using the GAS .p2align command.])])
2103
2104 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2105  [2,8,0],,
2106  [.literal16],,
2107 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2108   [Define if your assembler supports .literal16.])])
2109
2110 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2111  [elf,2,9,0],,
2112  [conftest_label1: .word 0
2113 .subsection -1
2114 conftest_label2: .word 0
2115 .previous],
2116  [if test x$gcc_cv_nm != x; then
2117     $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2118     $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2119     if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2120     then :
2121     else gcc_cv_as_subsection_m1=yes
2122     fi
2123     rm -f conftest.nm1 conftest.nm2
2124   fi],
2125  [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2126   [Define if your assembler supports .subsection and .subsection -1 starts
2127    emitting at the beginning of your section.])])
2128
2129 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2130  [2,2,0],,
2131  [      .weak foobar],,
2132 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2133
2134 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2135  [2,17,0],,
2136  [      .weakref foobar, barfnot],,
2137 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2138
2139 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2140  [2,15,91],,
2141  [      .SPACE $TEXT$
2142         .NSUBSPA $CODE$,COMDAT],,
2143 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2144
2145 # .hidden needs to be supported in both the assembler and the linker,
2146 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2147 # This is irritatingly difficult to feature test for; we have to check the
2148 # date string after the version number.  If we've got an in-tree
2149 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2150 # to be safe.
2151 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2152 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2153  [elf,2,13,0],,
2154 [       .hidden foobar
2155 foobar:])
2156
2157 changequote(,)dnl
2158 if test $in_tree_ld != yes ; then
2159   ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2160   if test x"$ld_is_gold" = xyes; then
2161     gcc_cv_ld_hidden=yes
2162   elif echo "$ld_ver" | grep GNU > /dev/null; then
2163     ld_vers=`echo $ld_ver | sed -n \
2164         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2165     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'`
2166     ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2167     ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2168     ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2169   else
2170     case "${target}" in
2171       *-*-solaris2*)
2172         #
2173         # Solaris 2 ld -V output looks like this for a regular version:
2174         #
2175         # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1699
2176         #
2177         # but test versions add stuff at the end:
2178         #
2179         # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1701:onnv-ab196087-6931056-03/25/10
2180         #
2181         ld_ver=`$gcc_cv_ld -V 2>&1`
2182         if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2183           ld_vers=`echo $ld_ver | sed -n \
2184             -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2185           ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2186           ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2187         fi
2188         ;;
2189     esac
2190   fi
2191 fi
2192 changequote([,])dnl
2193
2194 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2195 [[if test $in_tree_ld = yes ; then
2196   gcc_cv_ld_hidden=no
2197   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 \
2198      && test $in_tree_ld_is_elf = yes; then
2199      gcc_cv_ld_hidden=yes
2200   fi
2201 else
2202   gcc_cv_ld_hidden=yes
2203   if echo "$ld_ver" | grep GNU > /dev/null; then
2204     if test 0"$ld_date" -lt 20020404; then
2205       if test -n "$ld_date"; then
2206         # If there was date string, but was earlier than 2002-04-04, fail
2207         gcc_cv_ld_hidden=no
2208       elif test -z "$ld_vers"; then
2209         # If there was no date string nor ld version number, something is wrong
2210         gcc_cv_ld_hidden=no
2211       else
2212         test -z "$ld_vers_patch" && ld_vers_patch=0
2213         if test "$ld_vers_major" -lt 2; then
2214           gcc_cv_ld_hidden=no
2215         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2216           gcc_cv_ld_hidden="no"
2217         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2218           gcc_cv_ld_hidden=no
2219         fi
2220       fi
2221     fi
2222   else
2223     case "${target}" in
2224       hppa64*-*-hpux* | ia64*-*-hpux*)
2225         gcc_cv_ld_hidden=yes
2226         ;;
2227       *-*-solaris2.9* | *-*-solaris2.1[0-9]*)
2228         # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2229         # .symbolic was only added in Solaris 9 12/02.
2230         gcc_cv_ld_hidden=yes
2231         ;;
2232       *)
2233         gcc_cv_ld_hidden=no
2234         ;;
2235     esac
2236   fi
2237 fi]])
2238 libgcc_visibility=no
2239 AC_SUBST(libgcc_visibility)
2240 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2241 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2242   libgcc_visibility=yes
2243   AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2244   [Define if your assembler and linker support .hidden.])
2245 fi
2246
2247 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2248 gcc_cv_ld_ro_rw_mix=unknown
2249 if test $in_tree_ld = yes ; then
2250   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 \
2251      && test $in_tree_ld_is_elf = yes; then
2252     gcc_cv_ld_ro_rw_mix=read-write
2253   fi
2254 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2255   echo '.section myfoosect, "a"' > conftest1.s
2256   echo '.section myfoosect, "aw"' > conftest2.s
2257   echo '.byte 1' >> conftest2.s
2258   echo '.section myfoosect, "a"' > conftest3.s
2259   echo '.byte 0' >> conftest3.s
2260   if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2261      && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2262      && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2263      && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2264         conftest2.o conftest3.o > /dev/null 2>&1; then
2265     gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2266                          | sed -e '/myfoosect/!d' -e N`
2267     if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2268       if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2269         gcc_cv_ld_ro_rw_mix=read-only
2270       else
2271         gcc_cv_ld_ro_rw_mix=read-write
2272       fi
2273     fi
2274   fi
2275 changequote(,)dnl
2276   rm -f conftest.* conftest[123].*
2277 changequote([,])dnl
2278 fi
2279 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2280         AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2281   [Define if your linker links a mix of read-only
2282    and read-write sections into a read-write section.])
2283 fi
2284 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2285
2286 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2287 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2288   [elf,2,11,0],,
2289 [       .data
2290         .uleb128 L2 - L1
2291 L1:
2292         .uleb128 1280
2293         .sleb128 -1010
2294 L2:],
2295 [[# GAS versions before 2.11 do not support uleb128,
2296   # despite appearing to.
2297   # ??? There exists an elf-specific test that will crash
2298   # the assembler.  Perhaps it's better to figure out whether
2299   # arbitrary sections are supported and try the test.
2300   as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2301   if echo "$as_ver" | grep GNU > /dev/null; then
2302     as_vers=`echo $as_ver | sed -n \
2303         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2304     as_major=`expr "$as_vers" : '\([0-9]*\)'`
2305     as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2306     if test $as_major -eq 2 && test $as_minor -lt 11
2307     then :
2308     else gcc_cv_as_leb128=yes
2309     fi
2310   fi]],
2311   [AC_DEFINE(HAVE_AS_LEB128, 1,
2312     [Define if your assembler supports .sleb128 and .uleb128.])])
2313
2314 # Check if we have assembler support for unwind directives.
2315 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2316   ,,
2317 [       .text
2318         .cfi_startproc
2319         .cfi_offset 0, 0
2320         .cfi_same_value 1
2321         .cfi_def_cfa 1, 2
2322         .cfi_escape 1, 2, 3, 4, 5
2323         .cfi_endproc],
2324 [case "$target" in
2325   *-*-solaris*)
2326     # If the linker used on Solaris (like Sun ld) isn't capable of merging
2327     # read-only and read-write sections, we need to make sure that the
2328     # assembler used emits read-write .eh_frame sections.
2329     if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2330       if test "x$gcc_cv_objdump" != x; then
2331         if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2332                 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2333           gcc_cv_as_cfi_directive=no
2334         else
2335           case "$target" in
2336             i?86-*-solaris2.1[[0-9]]*)
2337               # On Solaris/x86, make sure that GCC and gas agree on using
2338               # read-only .eh_frame sections for 64-bit.
2339               if $gcc_cv_as --64 -o conftest.o conftest.s > /dev/null 2>&1 && \
2340                 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2341                         sed -e /.eh_frame/!d -e N | \
2342                         grep READONLY > /dev/null; then
2343                 gcc_cv_as_cfi_directive=yes
2344               else
2345                 gcc_cv_as_cfi_directive=no
2346               fi
2347               ;;
2348             *)
2349               gcc_cv_as_cfi_directive=yes
2350               ;;
2351           esac
2352         fi
2353       else
2354         # no objdump, err on the side of caution
2355         gcc_cv_as_cfi_directive=no
2356       fi
2357     else
2358       gcc_cv_as_cfi_directive=yes
2359     fi
2360     ;;
2361   *-*-*)
2362     gcc_cv_as_cfi_directive=yes
2363     ;;
2364 esac])
2365 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_readelf != x; then
2366 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2367   ,,
2368 [       .text
2369         .cfi_startproc
2370         .cfi_adjust_cfa_offset 64
2371         .skip 75040, 0
2372         .cfi_adjust_cfa_offset 128
2373         .cfi_endproc],
2374 [[
2375 if $gcc_cv_readelf -wf conftest.o 2>/dev/null \
2376     | grep 'DW_CFA_advance_loc[24]:[    ][      ]*75040[        ]' >/dev/null; then
2377    gcc_cv_as_cfi_advance_working=yes
2378 fi
2379 ]])
2380 else
2381   # no readelf, err on the side of caution
2382   gcc_cv_as_cfi_advance_working=no
2383 fi
2384 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2385   [`if test $gcc_cv_as_cfi_directive = yes \
2386        && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2387   [Define 0/1 if your assembler supports CFI directives.])
2388
2389 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2390   gcc_cv_as_cfi_personality_directive, ,,
2391 [       .text
2392         .cfi_startproc
2393         .cfi_personality 0, symbol
2394         .cfi_endproc])
2395 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2396   [`if test $gcc_cv_as_cfi_personality_directive = yes;
2397     then echo 1; else echo 0; fi`],
2398   [Define 0/1 if your assembler supports .cfi_personality.])
2399
2400 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2401   gcc_cv_as_cfi_sections_directive, ,,
2402 [       .text
2403         .cfi_sections .debug_frame, .eh_frame
2404         .cfi_startproc
2405         .cfi_endproc])
2406 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2407   [`if test $gcc_cv_as_cfi_sections_directive = yes;
2408     then echo 1; else echo 0; fi`],
2409   [Define 0/1 if your assembler supports .cfi_sections.])
2410
2411 # GAS versions up to and including 2.11.0 may mis-optimize
2412 # .eh_frame data.
2413 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2414   [elf,2,12,0],,
2415 [       .text
2416 .LFB1:
2417         .4byte  0
2418 .L1:
2419         .4byte  0
2420 .LFE1:
2421         .section        .eh_frame,"aw",@progbits
2422 __FRAME_BEGIN__:
2423         .4byte  .LECIE1-.LSCIE1
2424 .LSCIE1:
2425         .4byte  0x0
2426         .byte   0x1
2427         .ascii "z\0"
2428         .byte   0x1
2429         .byte   0x78
2430         .byte   0x1a
2431         .byte   0x0
2432         .byte   0x4
2433         .4byte  1
2434         .p2align 1
2435 .LECIE1:
2436 .LSFDE1:
2437         .4byte  .LEFDE1-.LASFDE1
2438 .LASFDE1:
2439         .4byte  .LASFDE1-__FRAME_BEGIN__
2440         .4byte  .LFB1
2441         .4byte  .LFE1-.LFB1
2442         .byte   0x4
2443         .4byte  .LFE1-.LFB1
2444         .byte   0x4
2445         .4byte  .L1-.LFB1
2446 .LEFDE1:],
2447 [  dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2448 cat > conftest.lit <<EOF
2449  0000 10000000 00000000 017a0001 781a0004  .........z..x...
2450  0010 01000000 12000000 18000000 00000000  ................
2451  0020 08000000 04080000 0044               .........D      @&t@
2452 EOF
2453 cat > conftest.big <<EOF
2454  0000 00000010 00000000 017a0001 781a0004  .........z..x...
2455  0010 00000001 00000012 00000018 00000000  ................
2456  0020 00000008 04000000 0844               .........D      @&t@
2457 EOF
2458   # If the assembler didn't choke, and we can objdump,
2459   # and we got the correct data, then succeed.
2460   # The text in the here-document typically retains its unix-style line
2461   # endings, while the output of objdump will use host line endings.
2462   # Therefore, use diff -b for the comparisons.
2463   if test x$gcc_cv_objdump != x \
2464   && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2465      | tail -3 > conftest.got \
2466   && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2467     || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2468   then
2469     gcc_cv_as_eh_frame=yes
2470   elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2471     gcc_cv_as_eh_frame=buggy
2472   else
2473     # Uh oh, what do we do now?
2474     gcc_cv_as_eh_frame=no
2475   fi])
2476
2477 if test $gcc_cv_as_eh_frame = buggy; then
2478   AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2479   [Define if your assembler mis-optimizes .eh_frame data.])
2480 fi
2481
2482 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2483  [elf,2,12,0], [--fatal-warnings],
2484  [.section .rodata.str, "aMS", @progbits, 1])
2485 if test $gcc_cv_as_shf_merge = no; then
2486   gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2487     [elf,2,12,0], [--fatal-warnings],
2488     [.section .rodata.str, "aMS", %progbits, 1])
2489 fi
2490 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2491   [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2492 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2493
2494 gcc_GAS_CHECK_FEATURE(COMDAT group support, gcc_cv_as_comdat_group,
2495  [elf,2,16,0], [--fatal-warnings],
2496  [.section .text,"axG",@progbits,.foo,comdat])
2497 if test $gcc_cv_as_comdat_group = yes; then
2498   gcc_cv_as_comdat_group_percent=no
2499 else
2500  gcc_GAS_CHECK_FEATURE(COMDAT group support, gcc_cv_as_comdat_group_percent,
2501    [elf,2,16,0], [--fatal-warnings],
2502    [.section .text,"axG",%progbits,.foo,comdat])
2503 fi
2504 if test x"$ld_is_gold" = xyes; then
2505   comdat_group=yes
2506 elif test $in_tree_ld = yes ; then
2507   comdat_group=no
2508   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 \
2509      && test $in_tree_ld_is_elf = yes; then
2510      comdat_group=yes
2511   fi
2512 elif echo "$ld_ver" | grep GNU > /dev/null; then
2513   comdat_group=yes
2514   if test 0"$ld_date" -lt 20050308; then
2515     if test -n "$ld_date"; then
2516       # If there was date string, but was earlier than 2005-03-08, fail
2517       comdat_group=no
2518     elif test "$ld_vers_major" -lt 2; then
2519       comdat_group=no
2520     elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2521       comdat_group=no
2522     fi
2523   fi
2524 else
2525 changequote(,)dnl
2526   case "${target}" in
2527     *-*-solaris2.1[1-9]*)
2528       # Sun ld has COMDAT group support since Solaris 9, but it doesn't
2529       # interoperate with GNU as until Solaris 11 build 130, i.e. ld
2530       # version 1.688.
2531       #
2532       # FIXME: Maybe need to refine later when COMDAT group support with
2533       # Sun as is implemented.
2534       if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 1688; then
2535         comdat_group=yes
2536       else
2537         comdat_group=no
2538       fi
2539       ;;
2540     *)
2541       # Assume linkers other than GNU ld don't support COMDAT group.
2542       comdat_group=no
2543       ;;
2544   esac
2545 changequote([,])dnl
2546 fi
2547 # Allow overriding the automatic COMDAT group tests above.
2548 AC_ARG_ENABLE(comdat,
2549   [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
2550   [comdat_group="$enable_comdat"])
2551 if test $comdat_group = no; then
2552   gcc_cv_as_comdat_group=no
2553   gcc_cv_as_comdat_group_percent=no
2554 fi
2555 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2556   [`if test $gcc_cv_as_comdat_group = yes || test $gcc_cv_as_comdat_group_percent = yes; then echo 1; else echo 0; fi`],
2557 [Define 0/1 if your assembler and linker support COMDAT groups.])
2558
2559 gcc_GAS_CHECK_FEATURE([line table discriminator support],
2560  gcc_cv_as_discriminator,
2561  [2,19,51],,
2562 [       .text
2563         .file 1 "conf.c"
2564         .loc 1 1 0 discriminator 1],,
2565 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
2566   [Define if your assembler supports the .loc discriminator sub-directive.])])
2567
2568 # Thread-local storage - the check is heavily parameterized.
2569 conftest_s=
2570 tls_first_major=
2571 tls_first_minor=
2572 tls_as_opt=
2573 case "$target" in
2574 changequote(,)dnl
2575   alpha*-*-*)
2576     conftest_s='
2577         .section ".tdata","awT",@progbits
2578 foo:    .long   25
2579         .text
2580         ldq     $27,__tls_get_addr($29)         !literal!1
2581         lda     $16,foo($29)                    !tlsgd!1
2582         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
2583         ldq     $27,__tls_get_addr($29)         !literal!2
2584         lda     $16,foo($29)                    !tlsldm!2
2585         jsr     $26,($27),__tls_get_addr        !lituse_tlsldm!2
2586         ldq     $1,foo($29)                     !gotdtprel
2587         ldah    $2,foo($29)                     !dtprelhi
2588         lda     $3,foo($2)                      !dtprello
2589         lda     $4,foo($29)                     !dtprel
2590         ldq     $1,foo($29)                     !gottprel
2591         ldah    $2,foo($29)                     !tprelhi
2592         lda     $3,foo($2)                      !tprello
2593         lda     $4,foo($29)                     !tprel'
2594         tls_first_major=2
2595         tls_first_minor=13
2596         tls_as_opt=--fatal-warnings
2597         ;;
2598   cris-*-*|crisv32-*-*)
2599     conftest_s='
2600         .section ".tdata","awT",@progbits
2601 x:      .long   25
2602         .text
2603         move.d x:IE,$r10
2604         nop'
2605         tls_first_major=2
2606         tls_first_minor=20
2607         tls_as_opt=--fatal-warnings
2608         ;;
2609   frv*-*-*)
2610     conftest_s='
2611         .section ".tdata","awT",@progbits
2612 x:      .long   25
2613         .text
2614         call    #gettlsoff(x)'
2615         tls_first_major=2
2616         tls_first_minor=14
2617         ;;
2618   hppa*-*-linux*)
2619     conftest_s='
2620 t1:     .reg    %r20
2621 t2:     .reg    %r21
2622 gp:     .reg    %r19
2623         .section ".tdata","awT",@progbits
2624 foo:    .long   25
2625         .text
2626         .align  4
2627         addil LT%foo-$tls_gdidx$,gp
2628         ldo RT%foo-$tls_gdidx$(%r1),%arg0
2629         b __tls_get_addr
2630         nop
2631         addil LT%foo-$tls_ldidx$,gp
2632         b __tls_get_addr
2633         ldo RT%foo-$tls_ldidx$(%r1),%arg0
2634         addil LR%foo-$tls_dtpoff$,%ret0
2635         ldo RR%foo-$tls_dtpoff$(%r1),%t1
2636         mfctl %cr27,%t1
2637         addil LT%foo-$tls_ieoff$,gp
2638         ldw RT%foo-$tls_ieoff$(%r1),%t2
2639         add %t1,%t2,%t3
2640         mfctl %cr27,%t1
2641         addil LR%foo-$tls_leoff$,%t1
2642         ldo RR%foo-$tls_leoff$(%r1),%t2'
2643         tls_first_major=2
2644         tls_first_minor=15
2645         tls_as_opt=--fatal-warnings
2646         ;;
2647   arm*-*-*)
2648     conftest_s='
2649         .section ".tdata","awT",%progbits
2650 foo:    .long   25
2651         .text
2652 .word foo(gottpoff)
2653 .word foo(tpoff)
2654 .word foo(tlsgd)
2655 .word foo(tlsldm)
2656 .word foo(tlsldo)'
2657         tls_first_major=2
2658         tls_first_minor=17
2659         ;;
2660   i[34567]86-*-*)
2661     case "$target" in
2662       i[34567]86-*-solaris2.[89]*)
2663         # TLS was introduced in the Solaris 9 4/04 release but
2664         # we do not enable it by default on Solaris 9 either.
2665         if test "x$enable_tls" = xyes ; then
2666           on_solaris=yes
2667         else
2668           enable_tls=no;
2669         fi
2670         ;;
2671       i[34567]86-*-solaris2.*)
2672         on_solaris=yes
2673         ;;
2674       *)
2675         on_solaris=no
2676         ;;
2677     esac
2678     if test x$on_solaris = xyes && test x$gas_flag = xno; then
2679       conftest_s='
2680         .section .tdata,"awt",@progbits'
2681       tls_first_major=0
2682       tls_first_minor=0
2683 changequote([,])dnl
2684       AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
2685 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
2686 changequote(,)dnl
2687     else
2688       conftest_s='
2689         .section ".tdata","awT",@progbits'
2690       tls_first_major=2
2691       tls_first_minor=14
2692       tls_as_opt="--fatal-warnings"
2693     fi
2694     conftest_s="$conftest_s
2695 foo:    .long   25
2696         .text
2697         movl    %gs:0, %eax
2698         leal    foo@tlsgd(,%ebx,1), %eax
2699         leal    foo@tlsldm(%ebx), %eax
2700         leal    foo@dtpoff(%eax), %edx
2701         movl    foo@gottpoff(%ebx), %eax
2702         subl    foo@gottpoff(%ebx), %eax
2703         addl    foo@gotntpoff(%ebx), %eax
2704         movl    foo@indntpoff, %eax
2705         movl    \$foo@tpoff, %eax
2706         subl    \$foo@tpoff, %eax
2707         leal    foo@ntpoff(%ecx), %eax"
2708     ;;
2709   x86_64-*-*)
2710     conftest_s='
2711         .section ".tdata","awT",@progbits
2712 foo:    .long   25
2713         .text
2714         movq    %fs:0, %rax
2715         leaq    foo@TLSGD(%rip), %rdi
2716         leaq    foo@TLSLD(%rip), %rdi
2717         leaq    foo@DTPOFF(%rax), %rdx
2718         movq    foo@GOTTPOFF(%rip), %rax
2719         movq    $foo@TPOFF, %rax'
2720         tls_first_major=2
2721         tls_first_minor=14
2722         tls_as_opt=--fatal-warnings
2723         ;;
2724   ia64-*-*)
2725     conftest_s='
2726         .section ".tdata","awT",@progbits
2727 foo:    data8   25
2728         .text
2729         addl    r16 = @ltoff(@dtpmod(foo#)), gp
2730         addl    r17 = @ltoff(@dtprel(foo#)), gp
2731         addl    r18 = @ltoff(@tprel(foo#)), gp
2732         addl    r19 = @dtprel(foo#), gp
2733         adds    r21 = @dtprel(foo#), r13
2734         movl    r23 = @dtprel(foo#)
2735         addl    r20 = @tprel(foo#), gp
2736         adds    r22 = @tprel(foo#), r13
2737         movl    r24 = @tprel(foo#)'
2738         tls_first_major=2
2739         tls_first_minor=13
2740         tls_as_opt=--fatal-warnings
2741         ;;
2742   mips*-*-*)
2743     conftest_s='
2744         .section .tdata,"awT",@progbits
2745 x:
2746         .word 2
2747         .text
2748         addiu $4, $28, %tlsgd(x)
2749         addiu $4, $28, %tlsldm(x)
2750         lui $4, %dtprel_hi(x)
2751         addiu $4, $4, %dtprel_lo(x)
2752         lw $4, %gottprel(x)($28)
2753         lui $4, %tprel_hi(x)
2754         addiu $4, $4, %tprel_lo(x)'
2755         tls_first_major=2
2756         tls_first_minor=16
2757         tls_as_opt='-32 --fatal-warnings'
2758         ;;
2759   m68k-*-*)
2760     conftest_s='
2761         .section .tdata,"awT",@progbits
2762 x:
2763         .word 2
2764         .text
2765 foo:
2766         move.l x@TLSGD(%a5),%a0
2767         move.l x@TLSLDM(%a5),%a0
2768         move.l x@TLSLDO(%a5),%a0
2769         move.l x@TLSIE(%a5),%a0
2770         move.l x@TLSLE(%a5),%a0'
2771         tls_first_major=2
2772         tls_first_minor=19
2773         tls_as_opt='--fatal-warnings'
2774         ;;
2775   powerpc-*-*)
2776     conftest_s='
2777         .section ".tdata","awT",@progbits
2778         .align 2
2779 ld0:    .space 4
2780 ld1:    .space 4
2781 x1:     .space 4
2782 x2:     .space 4
2783 x3:     .space 4
2784         .text
2785         addi 3,31,ld0@got@tlsgd
2786         bl __tls_get_addr
2787         addi 3,31,x1@got@tlsld
2788         bl __tls_get_addr
2789         addi 9,3,x1@dtprel
2790         addis 9,3,x2@dtprel@ha
2791         addi 9,9,x2@dtprel@l
2792         lwz 9,x3@got@tprel(31)
2793         add 9,9,x@tls
2794         addi 9,2,x1@tprel
2795         addis 9,2,x2@tprel@ha
2796         addi 9,9,x2@tprel@l'
2797         tls_first_major=2
2798         tls_first_minor=14
2799         tls_as_opt="-a32 --fatal-warnings"
2800         ;;
2801   powerpc64-*-*)
2802     conftest_s='
2803         .section ".tdata","awT",@progbits
2804         .align 3
2805 ld0:    .space 8
2806 ld1:    .space 8
2807 x1:     .space 8
2808 x2:     .space 8
2809 x3:     .space 8
2810         .text
2811         addi 3,2,ld0@got@tlsgd
2812         bl .__tls_get_addr
2813         nop
2814         addi 3,2,ld1@toc
2815         bl .__tls_get_addr
2816         nop
2817         addi 3,2,x1@got@tlsld
2818         bl .__tls_get_addr
2819         nop
2820         addi 9,3,x1@dtprel
2821         bl .__tls_get_addr
2822         nop
2823         addis 9,3,x2@dtprel@ha
2824         addi 9,9,x2@dtprel@l
2825         bl .__tls_get_addr
2826         nop
2827         ld 9,x3@got@dtprel(2)
2828         add 9,9,3
2829         bl .__tls_get_addr
2830         nop'
2831         tls_first_major=2
2832         tls_first_minor=14
2833         tls_as_opt="-a64 --fatal-warnings"
2834         ;;
2835   s390-*-*)
2836     conftest_s='
2837         .section ".tdata","awT",@progbits
2838 foo:    .long   25
2839         .text
2840         .long   foo@TLSGD
2841         .long   foo@TLSLDM
2842         .long   foo@DTPOFF
2843         .long   foo@NTPOFF
2844         .long   foo@GOTNTPOFF
2845         .long   foo@INDNTPOFF
2846         l       %r1,foo@GOTNTPOFF(%r12)
2847         l       %r1,0(%r1):tls_load:foo
2848         bas     %r14,0(%r1,%r13):tls_gdcall:foo
2849         bas     %r14,0(%r1,%r13):tls_ldcall:foo'
2850         tls_first_major=2
2851         tls_first_minor=14
2852         tls_as_opt="-m31 --fatal-warnings"
2853         ;;
2854   s390x-*-*)
2855     conftest_s='
2856         .section ".tdata","awT",@progbits
2857 foo:    .long   25
2858         .text
2859         .quad   foo@TLSGD
2860         .quad   foo@TLSLDM
2861         .quad   foo@DTPOFF
2862         .quad   foo@NTPOFF
2863         .quad   foo@GOTNTPOFF
2864         lg      %r1,foo@GOTNTPOFF(%r12)
2865         larl    %r1,foo@INDNTPOFF
2866         brasl   %r14,__tls_get_offset@PLT:tls_gdcall:foo
2867         brasl   %r14,__tls_get_offset@PLT:tls_ldcall:foo'
2868         tls_first_major=2
2869         tls_first_minor=14
2870         tls_as_opt="-m64 -Aesame --fatal-warnings"
2871         ;;
2872   sh-*-* | sh[34]-*-*)
2873     conftest_s='
2874         .section ".tdata","awT",@progbits
2875 foo:    .long   25
2876         .text
2877         .long   foo@TLSGD
2878         .long   foo@TLSLDM
2879         .long   foo@DTPOFF
2880         .long   foo@GOTTPOFF
2881         .long   foo@TPOFF'
2882         tls_first_major=2
2883         tls_first_minor=13
2884         tls_as_opt=--fatal-warnings
2885         ;;
2886   sparc*-*-*)
2887     case "$target" in
2888       sparc*-sun-solaris2.[89]*)
2889         # TLS was introduced in the Solaris 9 4/04 release but
2890         # we do not enable it by default on Solaris 9 either.
2891         if test "x$enable_tls" = xyes ; then
2892           on_solaris=yes
2893         else
2894           enable_tls=no;
2895         fi
2896         ;;
2897       sparc*-sun-solaris2.*)
2898         on_solaris=yes
2899         ;;
2900       *)
2901         on_solaris=no
2902         ;;
2903     esac
2904     if test x$on_solaris = xyes && test x$gas_flag = xno; then
2905       conftest_s='
2906         .section ".tdata",#alloc,#write,#tls
2907 foo:    .long   25
2908         .text
2909         sethi   %tgd_hi22(foo), %o0
2910         add     %o0, %tgd_lo10(foo), %o1
2911         add     %l7, %o1, %o0, %tgd_add(foo)
2912         call    __tls_get_addr, %tgd_call(foo)
2913         sethi   %tldm_hi22(foo), %l1
2914         add     %l1, %tldm_lo10(foo), %l2
2915         add     %l7, %l2, %o0, %tldm_add(foo)
2916         call    __tls_get_addr, %tldm_call(foo)
2917         sethi   %tldo_hix22(foo), %l3
2918         xor     %l3, %tldo_lox10(foo), %l4
2919         add     %o0, %l4, %l5, %tldo_add(foo)
2920         sethi   %tie_hi22(foo), %o3
2921         add     %o3, %tie_lo10(foo), %o3
2922         ld      [%l7 + %o3], %o2, %tie_ld(foo)
2923         add     %g7, %o2, %o4, %tie_add(foo)
2924         sethi   %tle_hix22(foo), %l1
2925         xor     %l1, %tle_lox10(foo), %o5
2926         ld      [%g7 + %o5], %o1'
2927         tls_first_major=0
2928         tls_first_minor=0
2929     else
2930       conftest_s='
2931         .section ".tdata","awT",@progbits
2932 foo:    .long   25
2933         .text
2934         sethi   %tgd_hi22(foo), %o0
2935         add     %o0, %tgd_lo10(foo), %o1
2936         add     %l7, %o1, %o0, %tgd_add(foo)
2937         call    __tls_get_addr, %tgd_call(foo)
2938         sethi   %tldm_hi22(foo), %l1
2939         add     %l1, %tldm_lo10(foo), %l2
2940         add     %l7, %l2, %o0, %tldm_add(foo)
2941         call    __tls_get_addr, %tldm_call(foo)
2942         sethi   %tldo_hix22(foo), %l3
2943         xor     %l3, %tldo_lox10(foo), %l4
2944         add     %o0, %l4, %l5, %tldo_add(foo)
2945         sethi   %tie_hi22(foo), %o3
2946         add     %o3, %tie_lo10(foo), %o3
2947         ld      [%l7 + %o3], %o2, %tie_ld(foo)
2948         add     %g7, %o2, %o4, %tie_add(foo)
2949         sethi   %tle_hix22(foo), %l1
2950         xor     %l1, %tle_lox10(foo), %o5
2951         ld      [%g7 + %o5], %o1'
2952         tls_first_major=2
2953         tls_first_minor=14
2954         tls_as_opt="-32 --fatal-warnings"
2955       fi
2956         ;;
2957   xtensa*-*-*)
2958     conftest_s='
2959         .section ".tdata","awT",@progbits
2960 foo:    .long   25
2961         .text
2962         movi    a8, foo@TLSFUNC
2963         movi    a10, foo@TLSARG
2964         callx8.tls a8, foo@TLSCALL'
2965         tls_first_major=2
2966         tls_first_minor=19
2967         ;;
2968 changequote([,])dnl
2969 esac
2970 set_have_as_tls=no
2971 if test "x$enable_tls" = xno ; then
2972   : # TLS explicitly disabled.
2973 elif test "x$enable_tls" = xyes ; then
2974   set_have_as_tls=yes # TLS explicitly enabled.
2975 elif test -z "$tls_first_major"; then
2976   : # If we don't have a check, assume no support.
2977 else
2978   gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
2979   [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
2980   [set_have_as_tls=yes])
2981 fi
2982 if test $set_have_as_tls = yes ; then
2983   AC_DEFINE(HAVE_AS_TLS, 1,
2984             [Define if your assembler supports thread-local storage.])
2985 fi
2986
2987 # Target-specific assembler checks.
2988
2989 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
2990 gcc_cv_ld_static_dynamic=no
2991 if test $in_tree_ld = yes ; then
2992   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
2993     gcc_cv_ld_static_dynamic=yes
2994   fi
2995 elif test x$gcc_cv_ld != x; then
2996         # Check if linker supports -Bstatic/-Bdynamic option
2997         if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
2998           && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
2999                 gcc_cv_ld_static_dynamic=yes
3000         fi
3001 fi
3002 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3003         AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3004 [Define if your linker supports -Bstatic/-Bdynamic option.])
3005 fi
3006 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3007
3008 if test x"$demangler_in_ld" = xyes; then
3009   AC_MSG_CHECKING(linker --demangle support)
3010   gcc_cv_ld_demangle=no
3011   if test $in_tree_ld = yes; then
3012     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 \
3013       gcc_cv_ld_demangle=yes
3014     fi
3015   elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3016     # Check if the GNU linker supports --demangle option
3017     if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3018       gcc_cv_ld_demangle=yes
3019     fi
3020   fi
3021   if test x"$gcc_cv_ld_demangle" = xyes; then
3022     AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3023 [Define if your linker supports --demangle option.])
3024   fi
3025   AC_MSG_RESULT($gcc_cv_ld_demangle)
3026 fi
3027
3028 case "$target" in
3029   # All TARGET_ABI_OSF targets.
3030   alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
3031     gcc_GAS_CHECK_FEATURE([explicit relocation support],
3032         gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3033 [       .set nomacro
3034         .text
3035         extbl   $3, $2, $3      !lituse_bytoff!1
3036         ldq     $2, a($29)      !literal!1
3037         ldq     $4, b($29)      !literal!2
3038         ldq_u   $3, 0($2)       !lituse_base!1
3039         ldq     $27, f($29)     !literal!5
3040         jsr     $26, ($27), f   !lituse_jsr!5
3041         ldah    $29, 0($26)     !gpdisp!3
3042         lda     $0, c($29)      !gprel
3043         ldah    $1, d($29)      !gprelhigh
3044         lda     $1, d($1)       !gprellow
3045         lda     $29, 0($29)     !gpdisp!3],,
3046     [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3047   [Define if your assembler supports explicit relocations.])])
3048     gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3049         gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3050 [       .set nomacro
3051         .text
3052         ldq     $27, a($29)     !literal!1
3053         jsr     $26, ($27), a   !lituse_jsrdirect!1],,
3054     [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3055   [Define if your assembler supports the lituse_jsrdirect relocation.])])
3056     ;;
3057
3058   cris-*-*)
3059     gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3060       gcc_cv_as_cris_no_mul_bug,[2,15,91],
3061       [-no-mul-bug-abort], [.text],,
3062       [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3063                 [Define if your assembler supports the -no-mul-bug-abort option.])])
3064     ;;
3065
3066   sparc*-*-*)
3067     gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3068       [.register %g2, #scratch],,
3069       [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3070                 [Define if your assembler supports .register.])])
3071
3072     gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3073       [-relax], [.text],,
3074       [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3075                 [Define if your assembler supports -relax option.])])
3076
3077     gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3078       gcc_cv_as_sparc_gotdata_op,,
3079       [-K PIC],
3080 [.text
3081 foo:
3082         nop
3083 bar:
3084         sethi %gdop_hix22(foo), %g1
3085         xor    %g1, %gdop_lox10(foo), %g1
3086         ld    [[%l7 + %g1]], %g2, %gdop(foo)],
3087       [if test x$gcc_cv_ld != x \
3088        && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3089          if $gcc_cv_ld -v | grep GNU >/dev/null 2>&1; then
3090            if test x$gcc_cv_objdump != x; then
3091              if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3092                 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3093                gcc_cv_as_sparc_gotdata_op=no
3094              else
3095                gcc_cv_as_sparc_gotdata_op=yes
3096              fi
3097            fi
3098          else
3099            gcc_cv_as_sparc_gotdata_op=yes
3100          fi
3101        fi
3102        rm -f conftest],
3103       [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3104                 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3105
3106     gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3107       gcc_cv_as_sparc_ua_pcrel,,
3108       [-K PIC],
3109 [.text
3110 foo:
3111         nop
3112 .data
3113 .align 4
3114 .byte 0
3115 .uaword %r_disp32(foo)],
3116       [if test x$gcc_cv_ld != x \
3117        && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3118          gcc_cv_as_sparc_ua_pcrel=yes
3119        fi
3120        rm -f conftest],
3121       [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3122                 [Define if your assembler and linker support unaligned PC relative relocs.])
3123
3124       gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3125         gcc_cv_as_sparc_ua_pcrel_hidden,,
3126         [-K PIC],
3127 [.data
3128 .align 4
3129 .byte 0x31
3130 .uaword %r_disp32(foo)
3131 .byte 0x32, 0x33, 0x34
3132 .global foo
3133 .hidden foo
3134 foo:
3135 .skip 4],
3136         [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3137          && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3138          && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3139             | grep ' 31000000 07323334' > /dev/null 2>&1; then
3140             if $gcc_cv_objdump -R conftest 2> /dev/null \
3141                | grep 'DISP32' > /dev/null 2>&1; then
3142                 :
3143             else
3144                 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3145             fi
3146          fi
3147          rm -f conftest],
3148          [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3149                    [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3150     ]) # unaligned pcrel relocs
3151
3152     gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3153       gcc_cv_as_sparc_offsetable_lo10,,
3154       [-xarch=v9],
3155 [.text
3156         or %g1, %lo(ab) + 12, %g1
3157         or %g1, %lo(ab + 12), %g1],
3158       [if test x$gcc_cv_objdump != x \
3159        && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3160           | grep ' 82106000 82106000' > /dev/null 2>&1; then
3161          gcc_cv_as_sparc_offsetable_lo10=yes
3162        fi],
3163        [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3164                  [Define if your assembler supports offsetable %lo().])])
3165     ;;
3166
3167 changequote(,)dnl
3168   i[34567]86-*-* | x86_64-*-*)
3169 changequote([,])dnl
3170     case $target_os in
3171       cygwin*)
3172         # Full C++ conformance when using a shared libstdc++-v3 requires some
3173         # support from the Cygwin DLL, which in more recent versions exports
3174         # wrappers to aid in interposing and redirecting operators new, delete,
3175         # etc., as per n2800 #17.6.4.6 [replacement.functions].  Check if we
3176         # are configuring for a version of Cygwin that exports the wrappers.
3177         if test x$host = x$target; then
3178           AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3179         else
3180           # Can't check presence of libc functions during cross-compile, so
3181           # we just have to assume we're building for an up-to-date target.
3182           gcc_ac_cygwin_dll_wrappers=yes
3183         fi
3184         AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3185           [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3186           [Define if you want to generate code by default that assumes that the
3187            Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3188     esac
3189     case $target_os in
3190       cygwin* | pe | mingw32*)
3191         # Recent binutils allows the three-operand form of ".comm" on PE.  This
3192         # definition is used unconditionally to initialise the default state of
3193         # the target option variable that governs usage of the feature.
3194         gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3195          [2,19,52],,[.comm foo,1,32])
3196         AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3197           [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3198           [Define if your assembler supports specifying the alignment
3199            of objects allocated using the GAS .comm command.])
3200         # Used for DWARF 2 in PE
3201         gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3202           gcc_cv_as_ix86_pe_secrel32,
3203           [2,15,91],,
3204 [.text
3205 foo:    nop
3206 .data
3207         .secrel32 foo],
3208           [if test x$gcc_cv_ld != x \
3209            && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3210              gcc_cv_as_ix86_pe_secrel32=yes
3211            fi
3212            rm -f conftest],
3213           [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3214             [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3215         # Test if the assembler supports the extended form of the .section
3216         # directive that specifies section alignment.  LTO support uses this,
3217         # but normally only after installation, so we warn but don't fail the
3218         # configure if LTO is enabled but the assembler does not support it.
3219         gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3220           [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3221         if test x$gcc_cv_as_section_has_align != xyes; then
3222           case ",$enable_languages," in
3223             *,lto,*)
3224               AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3225               ;;
3226           esac
3227         fi
3228         ;;
3229     esac
3230
3231     gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3232        gcc_cv_as_ix86_filds,,,
3233        [filds mem; fists mem],,
3234        [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3235          [Define if your assembler uses filds and fists mnemonics.])])
3236
3237     gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3238        gcc_cv_as_ix86_fildq,,,
3239        [fildq mem; fistpq mem],,
3240        [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3241          [Define if your assembler uses fildq and fistq mnemonics.])])
3242
3243     gcc_GAS_CHECK_FEATURE([cmov syntax],
3244       gcc_cv_as_ix86_cmov_sun_syntax,,,
3245       [cmovl.l %edx, %eax],,
3246       [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3247         [Define if your assembler supports the Sun syntax for cmov.])])
3248
3249     gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3250       gcc_cv_as_ix86_ffreep,,,
3251       [ffreep %st(1)],,
3252       [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3253         [Define if your assembler supports the ffreep mnemonic.])])
3254
3255     gcc_GAS_CHECK_FEATURE([sahf mnemonic],
3256       gcc_cv_as_ix86_sahf,,,
3257       [sahf],,
3258       [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
3259         [Define if your assembler supports the sahf mnemonic.])])
3260
3261     gcc_GAS_CHECK_FEATURE([swap suffix],
3262       gcc_cv_as_ix86_swap,,,
3263       [movl.s %esp, %ebp],,
3264       [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
3265         [Define if your assembler supports the swap suffix.])])
3266
3267     gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
3268       gcc_cv_as_ix86_diff_sect_delta,,,
3269       [.section .rodata
3270 .L1:
3271         .long .L2-.L1
3272         .long .L3-.L1
3273         .text
3274 .L3:    nop
3275 .L2:    nop],,
3276       [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
3277         [Define if your assembler supports the subtraction of symbols in different sections.])])
3278
3279     # This one is used unconditionally by i386.[ch]; it is to be defined
3280     # to 1 if the feature is present, 0 otherwise.
3281     gcc_GAS_CHECK_FEATURE([GOTOFF in data],
3282         gcc_cv_as_ix86_gotoff_in_data, [2,11,0],,
3283 [       .text
3284 .L0:
3285         nop
3286         .data
3287         .long .L0@GOTOFF])
3288     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
3289       [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
3290       [Define true if the assembler supports '.long foo@GOTOFF'.])
3291     ;;
3292
3293   ia64*-*-*)
3294     gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
3295         gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
3296 [       .text
3297         addl r15 = @ltoffx(x#), gp
3298         ;;
3299         ld8.mov r16 = [[r15]], x#],,
3300     [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
3301           [Define if your assembler supports ltoffx and ldxmov relocations.])])
3302
3303     ;;
3304
3305   powerpc*-*-*)
3306     case $target in
3307       *-*-aix*) conftest_s='    .machine "pwr5"
3308         .csect .text[[PR]]
3309         mfcr 3,128';;
3310       *-*-darwin*)
3311         gcc_GAS_CHECK_FEATURE([.machine directive support],
3312           gcc_cv_as_machine_directive,,,
3313           [     .machine ppc7400])
3314         if test x$gcc_cv_as_machine_directive != xyes; then
3315           echo "*** This target requires an assembler supporting \".machine\"" >&2
3316           echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
3317           test x$build = x$target && exit 1
3318         fi
3319         conftest_s='    .text
3320         mfcr r3,128';;
3321       *) conftest_s='   .machine power4
3322         .text
3323         mfcr 3,128';;
3324     esac
3325
3326     gcc_GAS_CHECK_FEATURE([mfcr field support],
3327       gcc_cv_as_powerpc_mfcrf, [2,14,0],,
3328       [$conftest_s],,
3329       [AC_DEFINE(HAVE_AS_MFCRF, 1,
3330           [Define if your assembler supports mfcr field.])])
3331
3332     case $target in
3333       *-*-aix*) conftest_s='    .machine "pwr5"
3334         .csect .text[[PR]]
3335         popcntb 3,3';;
3336       *) conftest_s='   .machine power5
3337         .text
3338         popcntb 3,3';;
3339     esac
3340
3341     gcc_GAS_CHECK_FEATURE([popcntb support],
3342       gcc_cv_as_powerpc_popcntb, [2,17,0],,
3343       [$conftest_s],,
3344       [AC_DEFINE(HAVE_AS_POPCNTB, 1,
3345           [Define if your assembler supports popcntb field.])])
3346
3347     case $target in
3348       *-*-aix*) conftest_s='    .machine "pwr5x"
3349         .csect .text[[PR]]
3350         frin 1,1';;
3351       *) conftest_s='   .machine power5
3352         .text
3353         frin 1,1';;
3354     esac
3355
3356     gcc_GAS_CHECK_FEATURE([fp round support],
3357       gcc_cv_as_powerpc_fprnd, [2,17,0],,
3358       [$conftest_s],,
3359       [AC_DEFINE(HAVE_AS_FPRND, 1,
3360           [Define if your assembler supports fprnd.])])
3361
3362     case $target in
3363       *-*-aix*) conftest_s='    .machine "pwr6"
3364         .csect .text[[PR]]
3365         mffgpr 1,3';;
3366       *) conftest_s='   .machine power6
3367         .text
3368         mffgpr 1,3';;
3369     esac
3370
3371     gcc_GAS_CHECK_FEATURE([move fp gpr support],
3372       gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
3373       [$conftest_s],,
3374       [AC_DEFINE(HAVE_AS_MFPGPR, 1,
3375           [Define if your assembler supports mffgpr and mftgpr.])])
3376
3377     case $target in
3378       *-*-aix*) conftest_s='    .csect .text[[PR]]
3379 LCF..0:
3380         addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
3381       *-*-darwin*)
3382         conftest_s='    .text
3383 LCF0:
3384         addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
3385       *) conftest_s='   .text
3386 .LCF0:
3387         addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
3388     esac
3389
3390     gcc_GAS_CHECK_FEATURE([rel16 relocs],
3391       gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
3392       [$conftest_s],,
3393       [AC_DEFINE(HAVE_AS_REL16, 1,
3394           [Define if your assembler supports R_PPC_REL16 relocs.])])
3395
3396     case $target in
3397       *-*-aix*) conftest_s='    .machine "pwr6"
3398         .csect .text[[PR]]
3399         cmpb 3,4,5';;
3400       *) conftest_s='   .machine power6
3401         .text
3402         cmpb 3,4,5';;
3403     esac
3404
3405     gcc_GAS_CHECK_FEATURE([compare bytes support],
3406       gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
3407       [$conftest_s],,
3408       [AC_DEFINE(HAVE_AS_CMPB, 1,
3409           [Define if your assembler supports cmpb.])])
3410
3411     case $target in
3412       *-*-aix*) conftest_s='    .machine "pwr6"
3413         .csect .text[[PR]]
3414         dadd 1,2,3';;
3415       *) conftest_s='   .machine power6
3416         .text
3417         dadd 1,2,3';;
3418     esac
3419
3420     gcc_GAS_CHECK_FEATURE([decimal float support],
3421       gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
3422       [$conftest_s],,
3423       [AC_DEFINE(HAVE_AS_DFP, 1,
3424           [Define if your assembler supports DFP instructions.])])
3425
3426     case $target in
3427       *-*-aix*) conftest_s='    .machine "pwr7"
3428         .csect .text[[PR]]
3429         lxvd2x 1,2,3';;
3430       *) conftest_s='   .machine power7
3431         .text
3432         lxvd2x 1,2,3';;
3433     esac
3434
3435     gcc_GAS_CHECK_FEATURE([vector-scalar support],
3436       gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
3437       [$conftest_s],,
3438       [AC_DEFINE(HAVE_AS_VSX, 1,
3439           [Define if your assembler supports VSX instructions.])])
3440
3441     case $target in
3442       *-*-aix*) conftest_s='    .machine "pwr7"
3443         .csect .text[[PR]]
3444         popcntd 3,3';;
3445       *) conftest_s='   .machine power7
3446         .text
3447         popcntd 3,3';;
3448     esac
3449
3450     gcc_GAS_CHECK_FEATURE([popcntd support],
3451       gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
3452       [$conftest_s],,
3453       [AC_DEFINE(HAVE_AS_POPCNTD, 1,
3454           [Define if your assembler supports POPCNTD instructions.])])
3455
3456     case $target in
3457       *-*-aix*) conftest_s='    .csect .text[[PR]]
3458         lwsync';;
3459       *) conftest_s='   .text
3460         lwsync';;
3461     esac
3462
3463     gcc_GAS_CHECK_FEATURE([lwsync support],
3464       gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
3465       [$conftest_s],,
3466       [AC_DEFINE(HAVE_AS_LWSYNC, 1,
3467           [Define if your assembler supports LWSYNC instructions.])])
3468
3469     case $target in
3470       *-*-aix*) conftest_s='    .machine "476"
3471         .csect .text[[PR]]
3472         dci 0';;
3473       *) conftest_s='   .machine "476"
3474         .text
3475         dci 0';;
3476     esac
3477
3478     gcc_GAS_CHECK_FEATURE([data cache invalidate support],
3479       gcc_cv_as_powerpc_dci, [9,99,0], -a32,
3480       [$conftest_s],,
3481       [AC_DEFINE(HAVE_AS_DCI, 1,
3482           [Define if your assembler supports the DCI/ICI instructions.])])
3483
3484     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3485       gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
3486       [.gnu_attribute 4,1],,
3487       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3488           [Define if your assembler supports .gnu_attribute.])])
3489
3490     gcc_GAS_CHECK_FEATURE([tls marker support],
3491       gcc_cv_as_powerpc_tls_markers, [2,20,0],,
3492       [ bl __tls_get_addr(x@tlsgd)],,
3493       [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
3494           [Define if your assembler supports arg info for __tls_get_addr.])])
3495
3496     case $target in
3497       *-*-aix*)
3498         gcc_GAS_CHECK_FEATURE([.ref support],
3499           gcc_cv_as_aix_ref, [2.21.0],,
3500           [     .csect stuff[[rw]]
3501              stuff:
3502                 .long 1
3503                 .extern sym
3504                 .ref sym
3505           ],,
3506           [AC_DEFINE(HAVE_AS_REF, 1,
3507             [Define if your assembler supports .ref])])
3508         ;;
3509     esac
3510     ;;
3511
3512   mips*-*-*)
3513     gcc_GAS_CHECK_FEATURE([explicit relocation support],
3514       gcc_cv_as_mips_explicit_relocs, [2,14,0],,
3515 [       lw $4,%gp_rel(foo)($4)],,
3516       [if test x$target_cpu_default = x
3517        then target_cpu_default=MASK_EXPLICIT_RELOCS
3518        else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
3519        fi])
3520     gcc_GAS_CHECK_FEATURE([-mno-shared support],
3521       gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
3522       [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
3523                  [Define if the assembler understands -mno-shared.])])
3524
3525     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3526       gcc_cv_as_mips_gnu_attribute, [2,18,0],,
3527       [.gnu_attribute 4,1],,
3528       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3529           [Define if your assembler supports .gnu_attribute.])])
3530
3531     gcc_GAS_CHECK_FEATURE([.dtprelword support],
3532       gcc_cv_as_mips_dtprelword, [2,18,0],,
3533       [.section .tdata,"awT",@progbits
3534 x:
3535         .word 2
3536         .text
3537         .dtprelword x+0x8000],,
3538       [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
3539           [Define if your assembler supports .dtprelword.])])
3540
3541     AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
3542     gcc_cv_as_ld_jalr_reloc=no
3543     if test $gcc_cv_as_mips_explicit_relocs = yes; then
3544       if test $in_tree_ld = yes ; then
3545         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 \
3546            && test $in_tree_ld_is_elf = yes; then
3547           gcc_cv_as_ld_jalr_reloc=yes
3548         fi
3549       elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
3550         echo '  .ent x' > conftest.s
3551         echo 'x:        ld $2,%got_disp(y)($3)' >> conftest.s
3552         echo '  ld $25,%call16(y)($28)' >> conftest.s
3553         echo '  .reloc  1f,R_MIPS_JALR,y' >> conftest.s
3554         echo '1:        jalr $25' >> conftest.s
3555         echo '  .reloc  1f,R_MIPS_JALR,x' >> conftest.s
3556         echo '1:        jalr $25' >> conftest.s
3557         echo '  .end x' >> conftest.s
3558         if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
3559            && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
3560           if $gcc_cv_objdump -d conftest.so | grep -q jalr \
3561              && $gcc_cv_objdump -d conftest.so | grep -q "bal.*<x>"; then
3562             gcc_cv_as_ld_jalr_reloc=yes
3563           fi
3564         fi
3565         rm -f conftest.*
3566       fi
3567     fi
3568     if test $gcc_cv_as_ld_jalr_reloc = yes; then
3569       if test x$target_cpu_default = x; then
3570         target_cpu_default=MASK_RELAX_PIC_CALLS
3571       else
3572         target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
3573       fi
3574     fi
3575     AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
3576
3577     AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
3578       [gcc_cv_ld_mips_personality_relaxation],
3579       [gcc_cv_ld_mips_personality_relaxation=no
3580        if test $in_tree_ld = yes ; then
3581          if test "$gcc_cv_gld_major_version" -eq 2 \
3582                  -a "$gcc_cv_gld_minor_version" -ge 21 \
3583                  -o "$gcc_cv_gld_major_version" -gt 2; then
3584            gcc_cv_ld_mips_personality_relaxation=yes
3585          fi
3586        elif test x$gcc_cv_as != x \
3587                  -a x$gcc_cv_ld != x \
3588                  -a x$gcc_cv_readelf != x ; then
3589          cat > conftest.s <<EOF
3590         .cfi_startproc
3591         .cfi_personality 0x80,indirect_ptr
3592         .ent test
3593 test:
3594         nop
3595         .end test
3596         .cfi_endproc
3597
3598         .section .data,"aw",@progbits
3599 indirect_ptr:
3600         .dc.a personality
3601 EOF
3602          if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
3603             && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
3604            if $gcc_cv_readelf -d conftest 2>&1 \
3605               | grep TEXTREL > /dev/null 2>&1; then
3606              :
3607            elif $gcc_cv_readelf --relocs conftest 2>&1 \
3608                 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
3609              :
3610            else
3611              gcc_cv_ld_mips_personality_relaxation=yes
3612            fi
3613          fi
3614        fi
3615        rm -f conftest.s conftest.o conftest])
3616     if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
3617             AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
3618       [Define if your linker can relax absolute .eh_frame personality
3619 pointers into PC-relative form.])
3620     fi
3621     ;;
3622 esac
3623
3624 # Mips and HP-UX need the GNU assembler.
3625 # Linux on IA64 might be able to use the Intel assembler.
3626
3627 case "$target" in
3628   mips*-*-* | *-*-hpux* )
3629     if test x$gas_flag = xyes \
3630        || test x"$host" != x"$build" \
3631        || test ! -x "$gcc_cv_as" \
3632        || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
3633       :
3634     else
3635       echo "*** This configuration requires the GNU assembler" >&2
3636       exit 1
3637     fi
3638     ;;
3639 esac
3640
3641 # ??? Not all targets support dwarf2 debug_line, even within a version
3642 # of gas.  Moreover, we need to emit a valid instruction to trigger any
3643 # info to the output file.  So, as supported targets are added to gas 2.11,
3644 # add some instruction here to (also) show we expect this might work.
3645 # ??? Once 2.11 is released, probably need to add first known working
3646 # version to the per-target configury.
3647 case "$target" in
3648   i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* \
3649   | x86_64*-*-* | hppa*-*-* | arm*-*-* \
3650   | xstormy16*-*-* | cris-*-* | crisv32-*-* | xtensa*-*-* | bfin-*-* | score*-*-* \
3651   | spu-*-* | fido*-*-* | m32c-*-*)
3652     insn="nop"
3653     ;;
3654   ia64*-*-* | s390*-*-*)
3655     insn="nop 0"
3656     ;;
3657   mmix-*-*)
3658     insn="swym 0"
3659     ;;
3660 esac
3661 if test x"$insn" != x; then
3662  conftest_s="\
3663         .file 1 \"conftest.s\"
3664         .loc 1 3 0
3665         $insn"
3666  gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
3667   gcc_cv_as_dwarf2_debug_line,
3668   [elf,2,11,0],, [$conftest_s],
3669   [if test x$gcc_cv_objdump != x \
3670    && $gcc_cv_objdump -h conftest.o 2> /dev/null \
3671       | grep debug_line > /dev/null 2>&1; then
3672      gcc_cv_as_dwarf2_debug_line=yes
3673    fi])
3674
3675 # The .debug_line file table must be in the exact order that
3676 # we specified the files, since these indices are also used
3677 # by DW_AT_decl_file.  Approximate this test by testing if
3678 # the assembler bitches if the same index is assigned twice.
3679  gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
3680   gcc_cv_as_dwarf2_file_buggy,,,
3681 [       .file 1 "foo.s"
3682         .file 1 "bar.s"])
3683
3684  if test $gcc_cv_as_dwarf2_debug_line = yes \
3685  && test $gcc_cv_as_dwarf2_file_buggy = no; then
3686         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
3687   [Define if your assembler supports dwarf2 .file/.loc directives,
3688    and preserves file table indices exactly as given.])
3689  fi
3690
3691  gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
3692   gcc_cv_as_gdwarf2_flag,
3693   [elf,2,11,0], [--gdwarf2], [$insn],,
3694   [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
3695 [Define if your assembler supports the --gdwarf2 option.])])
3696
3697  gcc_GAS_CHECK_FEATURE([--gstabs option],
3698   gcc_cv_as_gstabs_flag,
3699   [elf,2,11,0], [--gstabs], [$insn],
3700   [# The native Solaris 9/Intel assembler doesn't understand --gstabs
3701    # and warns about it, but still exits successfully.  So check for
3702    # this.
3703    if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
3704    then :
3705    else gcc_cv_as_gstabs_flag=yes
3706    fi],
3707   [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
3708 [Define if your assembler supports the --gstabs option.])])
3709
3710  gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
3711   gcc_cv_as_debug_prefix_map_flag,
3712   [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
3713   [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
3714 [Define if your assembler supports the --debug-prefix-map option.])])
3715 fi
3716
3717 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
3718  ,,
3719 [.lcomm bar,4,16],,
3720 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
3721   [Define if your assembler supports .lcomm with an alignment field.])])
3722
3723 AC_ARG_ENABLE(gnu-unique-object,
3724  [  --enable-gnu-unique-object  enable the use of the @gnu_unique_object ELF extension on
3725                                 glibc systems],
3726  [case $enable_gnu_unique_object in
3727     yes | no) ;;
3728     *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
3729 Valid choices are 'yes' and 'no'.]) ;;
3730   esac],
3731  [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
3732    [elf,2,19,52],,
3733    [.type foo, @gnu_unique_object],,
3734 # Also check for ld.so support, i.e. glibc 2.11 or higher.
3735    [[if test x$host = x$build -a x$host = x$target &&
3736        glibcver=`ldd --version 2>/dev/null | sed 's/.* //;q'`; then
3737       glibcmajor=`expr "$glibcver" : "\([0-9]*\)"`
3738       glibcminor=`expr "$glibcver" : "[2-9]*\.\([0-9]*\)"`
3739       glibcnum=`expr $glibcmajor \* 1000 + $glibcminor`
3740       if test "$glibcnum" -ge 2011 ; then
3741         enable_gnu_unique_object=yes
3742       fi
3743     fi]])])
3744 if test x$enable_gnu_unique_object = xyes; then
3745   AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
3746    [Define if your assembler supports @gnu_unique_object.])
3747 fi
3748
3749 AC_CACHE_CHECK([assembler for tolerance to line number 0],
3750  [gcc_cv_as_line_zero],
3751  [gcc_cv_as_line_zero=no
3752   if test $in_tree_gas = yes; then
3753     gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
3754   elif test "x$gcc_cv_as" != x; then
3755     { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
3756     if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
3757        test "x`cat conftest.out`" = x
3758     then
3759       gcc_cv_as_line_zero=yes
3760     else
3761       echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
3762       cat conftest.s >&AS_MESSAGE_LOG_FD
3763       echo "configure: error output was" >&AS_MESSAGE_LOG_FD
3764       cat conftest.out >&AS_MESSAGE_LOG_FD
3765     fi
3766     rm -f conftest.o conftest.s conftest.out
3767   fi])
3768 if test "x$gcc_cv_as_line_zero" = xyes; then
3769   AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
3770 [Define if the assembler won't complain about a line such as # 0 "" 2.])
3771 fi
3772
3773 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
3774 gcc_cv_ld_eh_frame_hdr=no
3775 if test $in_tree_ld = yes ; then
3776   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 \
3777      && test $in_tree_ld_is_elf = yes; then
3778     gcc_cv_ld_eh_frame_hdr=yes
3779   fi
3780 elif test x$gcc_cv_ld != x; then
3781         # Check if linker supports --eh-frame-hdr option
3782         if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
3783                 gcc_cv_ld_eh_frame_hdr=yes
3784         fi
3785 fi
3786 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
3787 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
3788         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
3789 [Define if your linker supports --eh-frame-hdr option.])
3790 fi
3791 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
3792
3793 AC_MSG_CHECKING(linker position independent executable support)
3794 gcc_cv_ld_pie=no
3795 if test $in_tree_ld = yes ; then
3796   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 \
3797      && test $in_tree_ld_is_elf = yes; then
3798     gcc_cv_ld_pie=yes
3799   fi
3800 elif test x$gcc_cv_ld != x; then
3801         # Check if linker supports -pie option
3802         if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
3803                 gcc_cv_ld_pie=yes
3804         fi
3805 fi
3806 if test x"$gcc_cv_ld_pie" = xyes; then
3807         AC_DEFINE(HAVE_LD_PIE, 1,
3808 [Define if your linker supports -pie option.])
3809 fi
3810 AC_MSG_RESULT($gcc_cv_ld_pie)
3811
3812 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
3813 gcc_cv_ld_eh_gc_sections=no
3814 if test $in_tree_ld = yes ; then
3815   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 \
3816      && test $in_tree_ld_is_elf = yes; then
3817     gcc_cv_ld_eh_gc_sections=yes
3818   fi
3819 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
3820   cat > conftest.s <<EOF
3821         .section        .text
3822 .globl _start
3823         .type _start, @function
3824 _start:
3825         .long foo
3826         .size _start, .-_start
3827         .section        .text.foo,"ax",@progbits
3828         .type foo, @function
3829 foo:
3830         .long 0
3831         .size foo, .-foo
3832         .section        .gcc_except_table.foo,"a",@progbits
3833 .L0:
3834         .long 0
3835         .section        .eh_frame,"a",@progbits
3836         .long .L0
3837 EOF
3838   if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
3839     if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
3840          | grep "gc-sections option ignored" > /dev/null; then
3841       gcc_cv_ld_eh_gc_sections=no
3842     elif $gcc_cv_objdump -h conftest 2> /dev/null \
3843          | grep gcc_except_table > /dev/null; then
3844       gcc_cv_ld_eh_gc_sections=yes
3845       # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
3846       if test x$gcc_cv_as_comdat_group != xyes; then
3847         gcc_cv_ld_eh_gc_sections=no
3848         cat > conftest.s <<EOF
3849         .section        .text
3850 .globl _start
3851         .type _start, @function
3852 _start:
3853         .long foo
3854         .size _start, .-_start
3855         .section        .gnu.linkonce.t.foo,"ax",@progbits
3856         .type foo, @function
3857 foo:
3858         .long 0
3859         .size foo, .-foo
3860         .section        .gcc_except_table.foo,"a",@progbits
3861 .L0:
3862         .long 0
3863         .section        .eh_frame,"a",@progbits
3864         .long .L0
3865 EOF
3866         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
3867           if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
3868                | grep "gc-sections option ignored" > /dev/null; then
3869             gcc_cv_ld_eh_gc_sections=no
3870           elif $gcc_cv_objdump -h conftest 2> /dev/null \
3871                | grep gcc_except_table > /dev/null; then
3872             gcc_cv_ld_eh_gc_sections=yes
3873           fi
3874         fi
3875       fi
3876     fi
3877   fi
3878   rm -f conftest.s conftest.o conftest
3879 fi
3880 case "$target" in
3881   hppa*-*-linux*)
3882     # ??? This apparently exposes a binutils bug with PC-relative relocations.
3883     gcc_cv_ld_eh_gc_sections=no
3884     ;;
3885 esac
3886 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
3887         AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
3888   [Define if your linker supports garbage collection of
3889    sections in presence of EH frames.])
3890 fi
3891 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
3892
3893 # --------
3894 # UNSORTED
3895 # --------
3896
3897 AC_CACHE_CHECK(linker --as-needed support,
3898 gcc_cv_ld_as_needed,
3899 [gcc_cv_ld_as_needed=no
3900 if test $in_tree_ld = yes ; then
3901   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 \
3902      && test $in_tree_ld_is_elf = yes; then
3903     gcc_cv_ld_as_needed=yes
3904   fi
3905 elif test x$gcc_cv_ld != x; then
3906         # Check if linker supports --as-needed and --no-as-needed options
3907         if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
3908                 gcc_cv_ld_as_needed=yes
3909         fi
3910 fi
3911 ])
3912 if test x"$gcc_cv_ld_as_needed" = xyes; then
3913         AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
3914 [Define if your linker supports --as-needed and --no-as-needed options.])
3915 fi
3916
3917 case "$target:$tm_file" in
3918   powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
3919     AC_CACHE_CHECK(linker support for omitting dot symbols,
3920     gcc_cv_ld_no_dot_syms,
3921     [gcc_cv_ld_no_dot_syms=no
3922     if test $in_tree_ld = yes ; then
3923       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
3924         gcc_cv_ld_no_dot_syms=yes
3925       fi
3926     elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
3927       cat > conftest1.s <<EOF
3928         .text
3929         bl .foo
3930 EOF
3931       cat > conftest2.s <<EOF
3932         .section ".opd","aw"
3933         .align 3
3934         .globl foo
3935         .type foo,@function
3936 foo:
3937         .quad .LEfoo,.TOC.@tocbase,0
3938         .text
3939 .LEfoo:
3940         blr
3941         .size foo,.-.LEfoo
3942 EOF
3943       if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
3944          && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
3945          && $gcc_cv_ld -melf64ppc -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
3946         gcc_cv_ld_no_dot_syms=yes
3947       fi
3948       rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
3949     fi
3950     ])
3951     if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
3952       AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
3953     [Define if your PowerPC64 linker only needs function descriptor syms.])
3954     fi
3955     ;;
3956 esac
3957
3958 AC_CACHE_CHECK(linker --build-id support,
3959   gcc_cv_ld_buildid,
3960   [gcc_cv_ld_buildid=no
3961   if test $in_tree_ld = yes ; then
3962     if test "$gcc_cv_gld_major_version" -eq 2 -a \
3963        "$gcc_cv_gld_minor_version" -ge 18 -o \
3964        "$gcc_cv_gld_major_version" -gt 2 \
3965        && test $in_tree_ld_is_elf = yes; then
3966       gcc_cv_ld_buildid=yes
3967     fi
3968   elif test x$gcc_cv_ld != x; then
3969     if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
3970       gcc_cv_ld_buildid=yes
3971     fi
3972   fi])
3973 if test x"$gcc_cv_ld_buildid" = xyes; then
3974   AC_DEFINE(HAVE_LD_BUILDID, 1,
3975   [Define if your linker supports --build-id.])
3976 fi
3977
3978 AC_ARG_ENABLE(linker-build-id,
3979 [  --enable-linker-build-id
3980                           compiler will always pass --build-id to linker],
3981 [],
3982 enable_linker_build_id=no)
3983
3984 if test x"$enable_linker_build_id" = xyes; then
3985   if test x"$gcc_cv_ld_buildid" = xyes; then
3986     AC_DEFINE(ENABLE_LD_BUILDID, 1,
3987     [Define if gcc should always pass --build-id to linker.])
3988   else
3989     AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
3990   fi
3991 fi
3992
3993 AC_CACHE_CHECK(linker --sysroot support,
3994   gcc_cv_ld_sysroot,
3995   [gcc_cv_ld_sysroot=no
3996   if test $in_tree_ld = yes ; then
3997       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
3998         gcc_cv_ld_sysroot=yes
3999       fi
4000   elif test x$gcc_cv_ld != x; then
4001     if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
4002       gcc_cv_ld_sysroot=yes
4003     fi
4004   fi])
4005 if test x"$gcc_cv_ld_sysroot" = xyes; then
4006   AC_DEFINE(HAVE_LD_SYSROOT, 1,
4007   [Define if your linker supports --sysroot.])
4008 fi
4009
4010 if test x$with_sysroot = x && test x$host = x$target \
4011    && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4012    && test "$prefix" != "NONE"; then
4013   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4014 [Define to PREFIX/include if cpp should also search that directory.])
4015 fi
4016
4017 # Test for stack protector support in target C library.
4018 AC_CACHE_CHECK(__stack_chk_fail in target C library,
4019       gcc_cv_libc_provides_ssp,
4020       [gcc_cv_libc_provides_ssp=no
4021     case "$target" in
4022        *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
4023       if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4024         if test "x$with_headers" != x; then
4025           glibc_header_dir=$with_headers
4026         elif test "x$with_sysroot" = x; then
4027           glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-include"
4028         elif test "x$with_build_sysroot" != "x"; then
4029           glibc_header_dir="${with_build_sysroot}/usr/include"
4030         elif test "x$with_sysroot" = xyes; then
4031           glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-root/usr/include"
4032         else
4033           glibc_header_dir="${with_sysroot}/usr/include"
4034         fi
4035       else
4036         glibc_header_dir=/usr/include
4037       fi
4038       [# glibc 2.4 and later provides __stack_chk_fail and
4039       # either __stack_chk_guard, or TLS access to stack guard canary.
4040       if test -f $glibc_header_dir/features.h \
4041          && $EGREP '^[  ]*#[    ]*define[       ]+__GNU_LIBRARY__[      ]+([1-9][0-9]|[6-9])' \
4042             $glibc_header_dir/features.h > /dev/null; then
4043         if $EGREP '^[   ]*#[    ]*define[       ]+__GLIBC__[    ]+([1-9][0-9]|[3-9])' \
4044            $glibc_header_dir/features.h > /dev/null; then
4045           gcc_cv_libc_provides_ssp=yes
4046         elif $EGREP '^[         ]*#[    ]*define[       ]+__GLIBC__[    ]+2' \
4047              $glibc_header_dir/features.h > /dev/null \
4048              && $EGREP '^[      ]*#[    ]*define[       ]+__GLIBC_MINOR__[      ]+([1-9][0-9]|[4-9])' \
4049              $glibc_header_dir/features.h > /dev/null; then
4050           gcc_cv_libc_provides_ssp=yes
4051         elif $EGREP '^[         ]*#[    ]*define[       ]+__UCLIBC__[   ]+1' \
4052              $glibc_header_dir/features.h > /dev/null && \
4053              test -f $glibc_header_dir/bits/uClibc_config.h && \
4054              $EGREP '^[         ]*#[    ]*define[       ]+__UCLIBC_HAS_SSP__[   ]+1' \
4055              $glibc_header_dir/bits/uClibc_config.h > /dev/null; then
4056           gcc_cv_libc_provides_ssp=yes
4057         fi
4058       fi]
4059         ;;
4060        *-*-gnu*)
4061          # Avoid complicated tests (see
4062          # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
4063          # simply assert that glibc does provide this, which is true for all
4064          # realistically usable GNU/Hurd configurations.
4065          gcc_cv_libc_provides_ssp=yes;;
4066        *-*-darwin* | *-*-freebsd*)
4067          AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
4068            [echo "no __stack_chk_fail on this target"])
4069         ;;
4070   *) gcc_cv_libc_provides_ssp=no ;;
4071     esac])
4072
4073 if test x$gcc_cv_libc_provides_ssp = xyes; then
4074   AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
4075             [Define if your target C library provides stack protector support])
4076 fi
4077
4078 # Check if TFmode long double should be used by default or not.
4079 # Some glibc targets used DFmode long double, but with glibc 2.4
4080 # and later they can use TFmode.
4081 case "$target" in
4082   powerpc*-*-linux* | \
4083   powerpc*-*-gnu* | \
4084   sparc*-*-linux* | \
4085   s390*-*-linux* | \
4086   alpha*-*-linux*)
4087     AC_ARG_WITH(long-double-128,
4088 [  --with-long-double-128  Use 128-bit long double by default.],
4089       gcc_cv_target_ldbl128="$with_long_double_128",
4090       [[gcc_cv_target_ldbl128=no
4091       if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4092         if test "x$with_sysroot" = x; then
4093           glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-include"
4094         elif test "x$with_build_sysroot" != "x"; then
4095           glibc_header_dir="${with_build_sysroot}/usr/include"
4096         elif test "x$with_sysroot" = xyes; then
4097           glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-root/usr/include"
4098         else
4099           glibc_header_dir="${with_sysroot}/usr/include"
4100         fi
4101       else
4102         glibc_header_dir=/usr/include
4103       fi
4104       grep '^[  ]*#[    ]*define[       ][      ]*__LONG_DOUBLE_MATH_OPTIONAL' \
4105         $glibc_header_dir/bits/wordsize.h > /dev/null 2>&1 \
4106       && gcc_cv_target_ldbl128=yes
4107       ]])
4108     ;;
4109 esac
4110 if test x$gcc_cv_target_ldbl128 = xyes; then
4111   AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
4112             [Define if TFmode long double should be the default])
4113 fi
4114
4115 # Find out what GC implementation we want, or may, use.
4116 AC_ARG_WITH(gc,
4117 [  --with-gc={page,zone}   choose the garbage collection mechanism to use
4118                           with the compiler],
4119 [case "$withval" in
4120   page)
4121     GGC=ggc-$withval
4122     ;;
4123   zone)
4124     GGC=ggc-$withval
4125     AC_DEFINE(GGC_ZONE, 1, [Define if the zone collector is in use])
4126     ;;
4127   *)
4128     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
4129     ;;
4130 esac],
4131 [GGC=ggc-page])
4132 AC_SUBST(GGC)
4133 echo "Using $GGC for garbage collection."
4134
4135 # Libraries to use on the host.  This will normally be set by the top
4136 # level Makefile.  Here we simply capture the value for our Makefile.
4137 if test -z "${HOST_LIBS+set}"; then
4138   HOST_LIBS=
4139 fi
4140 AC_SUBST(HOST_LIBS)
4141
4142 # Use the system's zlib library.
4143 zlibdir=-L../zlib
4144 zlibinc="-I\$(srcdir)/../zlib"
4145 AC_ARG_WITH(system-zlib,
4146 [  --with-system-zlib      use installed libz],
4147 zlibdir=
4148 zlibinc=
4149 )
4150 AC_SUBST(zlibdir)
4151 AC_SUBST(zlibinc)
4152
4153 dnl Very limited version of automake's enable-maintainer-mode
4154
4155 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
4156   dnl maintainer-mode is disabled by default
4157   AC_ARG_ENABLE(maintainer-mode,
4158 [  --enable-maintainer-mode
4159                           enable make rules and dependencies not useful
4160                           (and sometimes confusing) to the casual installer],
4161       maintainer_mode=$enableval,
4162       maintainer_mode=no)
4163
4164 AC_MSG_RESULT($maintainer_mode)
4165
4166 if test "$maintainer_mode" = "yes"; then
4167   MAINT=''
4168 else
4169   MAINT='#'
4170 fi
4171 AC_SUBST(MAINT)dnl
4172
4173 # --------------
4174 # Language hooks
4175 # --------------
4176
4177 # Make empty files to contain the specs and options for each language.
4178 # Then add #include lines to for a compiler that has specs and/or options.
4179
4180 subdirs=
4181 lang_opt_files=
4182 lang_specs_files=
4183 lang_tree_files=
4184 # These (without "all_") are set in each config-lang.in.
4185 # `language' must be a single word so is spelled singularly.
4186 all_languages=
4187 all_compilers=
4188 all_outputs='Makefile gccbug'
4189 # List of language makefile fragments.
4190 all_lang_makefrags=
4191 # List of language subdirectory makefiles.  Deprecated.
4192 all_lang_makefiles=
4193 # Additional files for gengtype
4194 all_gtfiles="$target_gtfiles"
4195
4196 # These are the languages that are set in --enable-languages,
4197 # and are available in the GCC tree.
4198 all_selected_languages=
4199
4200 # Add the language fragments.
4201 # Languages are added via two mechanisms.  Some information must be
4202 # recorded in makefile variables, these are defined in config-lang.in.
4203 # We accumulate them and plug them into the main Makefile.
4204 # The other mechanism is a set of hooks for each of the main targets
4205 # like `clean', `install', etc.
4206
4207 language_hooks="Make-hooks"
4208
4209 for lang in ${srcdir}/*/config-lang.in
4210 do
4211 changequote(,)dnl
4212         test "$lang" = "${srcdir}/*/config-lang.in" && continue
4213
4214         lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
4215         if test "x$lang_alias" = x
4216         then
4217               echo "$lang doesn't set \$language." 1>&2
4218               exit 1
4219         fi
4220         subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
4221         subdirs="$subdirs $subdir"
4222
4223         # $gcc_subdir is where the gcc integration files are to be found
4224         # for a language, both for internal compiler purposes (compiler
4225         # sources implementing front-end to GCC tree converters), and for
4226         # build infrastructure purposes (Make-lang.in, etc.)
4227         #
4228         # This will be <subdir> (relative to $srcdir) if a line like
4229         # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
4230         # is found in <langdir>/config-lang.in, and will remain <langdir>
4231         # otherwise.
4232         #
4233         # Except for the language alias (fetched above), the regular
4234         # "config-lang.in" contents are always retrieved from $gcc_subdir,
4235         # so a <langdir>/config-lang.in setting gcc_subdir typically sets
4236         # only this and the language alias.
4237
4238         gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^   ]*\).*$,\1,p' $lang`
4239         if [ "$gcc_subdir" = "" ]; then
4240            gcc_subdir="$subdir"
4241         fi
4242
4243         case ",$enable_languages," in
4244         *,$lang_alias,*)
4245             all_selected_languages="$all_selected_languages $lang_alias"
4246             if test -f $srcdir/$gcc_subdir/lang-specs.h; then
4247                 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
4248             fi
4249             ;;
4250         esac
4251 changequote([,])dnl
4252
4253         language=
4254         boot_language=
4255         compilers=
4256         outputs=
4257         gtfiles=
4258         subdir_requires=
4259         . ${srcdir}/$gcc_subdir/config-lang.in
4260         if test "x$language" = x
4261         then
4262                 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
4263                 exit 1
4264         fi
4265
4266         ok=:
4267         case ",$enable_languages," in
4268                 *,$lang_alias,*) ;;
4269                 *)
4270                         for i in $subdir_requires; do
4271                                 test -f "${srcdir}/$i/config-lang.in" && continue
4272                                 ok=false
4273                                 break
4274                         done
4275                 ;;
4276         esac
4277         $ok || continue
4278
4279         all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
4280         if test -f $srcdir/$gcc_subdir/lang.opt; then
4281             lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
4282         fi
4283         if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
4284             lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
4285         fi
4286         if test -f ${srcdir}/$gcc_subdir/Makefile.in
4287                 then all_lang_makefiles="$gcc_subdir/Makefile"
4288         fi
4289         all_languages="$all_languages $language"
4290         all_compilers="$all_compilers $compilers"
4291         all_outputs="$all_outputs $outputs"
4292         all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
4293         case ",$enable_languages," in
4294                 *,lto,*)
4295                     AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
4296                     enable_lto=yes
4297                     AC_SUBST(enable_lto)
4298                     # LTO needs to speak the platform's object file format, and has a
4299                     # number of implementations of the required binary file access APIs.
4300                     # ELF is the most common, and default.  We only link libelf if ELF
4301                     # is indeed the selected format.
4302                     LTO_BINARY_READER=${lto_binary_reader}
4303                     LTO_USE_LIBELF=-lelf
4304                     if test "x$lto_binary_reader" != "xlto-elf" ; then
4305                       LTO_USE_LIBELF=
4306                     fi
4307                     AC_SUBST(LTO_BINARY_READER)
4308                     AC_SUBST(LTO_USE_LIBELF)
4309                     ;;
4310                 *) ;;
4311         esac
4312 done
4313
4314 # Pick up gtfiles for c
4315 gtfiles=
4316 . ${srcdir}/c-config-lang.in
4317 all_gtfiles="$all_gtfiles [[c]] $gtfiles"
4318
4319 check_languages=
4320 for language in $all_selected_languages
4321 do
4322         check_languages="$check_languages check-$language"
4323 done
4324
4325 # We link each language in with a set of hooks, reached indirectly via
4326 # lang.${target}.  Only do so for selected languages.
4327
4328 rm -f Make-hooks
4329 touch Make-hooks
4330 target_list="all.cross start.encap rest.encap tags \
4331         install-common install-man install-info install-pdf install-html dvi \
4332         pdf html uninstall info man srcextra srcman srcinfo \
4333         mostlyclean clean distclean maintainer-clean install-plugin"
4334
4335 for t in $target_list
4336 do
4337         x=
4338         for lang in $all_selected_languages
4339         do
4340                 x="$x $lang.$t"
4341         done
4342         echo "lang.$t: $x" >> Make-hooks
4343 done
4344
4345 # --------
4346 # UNSORTED
4347 # --------
4348
4349 # Create .gdbinit.
4350
4351 echo "dir ." > .gdbinit
4352 echo "dir ${srcdir}" >> .gdbinit
4353 if test x$gdb_needs_out_file_path = xyes
4354 then
4355         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
4356 fi
4357 if test "x$subdirs" != x; then
4358         for s in $subdirs
4359         do
4360                 echo "dir ${srcdir}/$s" >> .gdbinit
4361         done
4362 fi
4363 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
4364
4365 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
4366 AC_SUBST(gcc_tooldir)
4367 AC_SUBST(dollar)
4368
4369 # Find a directory in which to install a shared libgcc.
4370
4371 AC_ARG_ENABLE(version-specific-runtime-libs,
4372 [  --enable-version-specific-runtime-libs
4373                           specify that runtime libraries should be
4374                           installed in a compiler-specific directory])
4375
4376 AC_ARG_WITH(slibdir,
4377 [  --with-slibdir=DIR      shared libraries in DIR [[LIBDIR]]],
4378 slibdir="$with_slibdir",
4379 if test "${enable_version_specific_runtime_libs+set}" = set; then
4380   slibdir='$(libsubdir)'
4381 elif test "$host" != "$target"; then
4382   slibdir='$(build_tooldir)/lib'
4383 else
4384   slibdir='$(libdir)'
4385 fi)
4386 AC_SUBST(slibdir)
4387
4388 # Substitute configuration variables
4389 AC_SUBST(subdirs)
4390 AC_SUBST(srcdir)
4391 AC_SUBST(all_compilers)
4392 AC_SUBST(all_gtfiles)
4393 AC_SUBST(all_lang_makefrags)
4394 AC_SUBST(all_lang_makefiles)
4395 AC_SUBST(all_languages)
4396 AC_SUBST(all_selected_languages)
4397 AC_SUBST(build_exeext)
4398 AC_SUBST(build_install_headers_dir)
4399 AC_SUBST(build_xm_file_list)
4400 AC_SUBST(build_xm_include_list)
4401 AC_SUBST(build_xm_defines)
4402 AC_SUBST(build_file_translate)
4403 AC_SUBST(check_languages)
4404 AC_SUBST(cpp_install_dir)
4405 AC_SUBST(xmake_file)
4406 AC_SUBST(tmake_file)
4407 AC_SUBST(TM_ENDIAN_CONFIG)
4408 AC_SUBST(TM_MULTILIB_CONFIG)
4409 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
4410 AC_SUBST(extra_gcc_objs)
4411 AC_SUBST(extra_headers_list)
4412 AC_SUBST(extra_objs)
4413 AC_SUBST(extra_parts)
4414 AC_SUBST(extra_passes)
4415 AC_SUBST(extra_programs)
4416 AC_SUBST(float_h_file)
4417 AC_SUBST(gcc_config_arguments)
4418 AC_SUBST(gcc_gxx_include_dir)
4419 AC_SUBST(host_exeext)
4420 AC_SUBST(host_xm_file_list)
4421 AC_SUBST(host_xm_include_list)
4422 AC_SUBST(host_xm_defines)
4423 AC_SUBST(out_host_hook_obj)
4424 AC_SUBST(install)
4425 AC_SUBST(lang_opt_files)
4426 AC_SUBST(lang_specs_files)
4427 AC_SUBST(lang_tree_files)
4428 AC_SUBST(local_prefix)
4429 AC_SUBST(md_file)
4430 AC_SUBST(objc_boehm_gc)
4431 AC_SUBST(out_file)
4432 AC_SUBST(out_object_file)
4433 AC_SUBST(thread_file)
4434 AC_SUBST(tm_file_list)
4435 AC_SUBST(tm_include_list)
4436 AC_SUBST(tm_defines)
4437 AC_SUBST(tm_p_file_list)
4438 AC_SUBST(tm_p_include_list)
4439 AC_SUBST(xm_file_list)
4440 AC_SUBST(xm_include_list)
4441 AC_SUBST(xm_defines)
4442 AC_SUBST(use_gcc_stdint)
4443 AC_SUBST(c_target_objs)
4444 AC_SUBST(cxx_target_objs)
4445 AC_SUBST(fortran_target_objs)
4446 AC_SUBST(target_cpu_default)
4447
4448 AC_SUBST_FILE(language_hooks)
4449
4450 # Echo link setup.
4451 if test x${build} = x${host} ; then
4452   if test x${host} = x${target} ; then
4453     echo "Links are now set up to build a native compiler for ${target}." 1>&2
4454   else
4455     echo "Links are now set up to build a cross-compiler" 1>&2
4456     echo " from ${host} to ${target}." 1>&2
4457   fi
4458 else
4459   if test x${host} = x${target} ; then
4460     echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
4461     echo " for ${target}." 1>&2
4462   else
4463     echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
4464     echo " from ${host} to ${target}." 1>&2
4465   fi
4466 fi
4467
4468 AC_ARG_VAR(GMPLIBS,[How to link GMP])
4469 AC_ARG_VAR(GMPINC,[How to find GMP include files])
4470
4471 AC_ARG_VAR(PPLLIBS,[How to link PPL])
4472 AC_ARG_VAR(PPLINC,[How to find PPL include files])
4473
4474 AC_ARG_VAR(CLOOGLIBS,[How to link CLOOG])
4475 AC_ARG_VAR(CLOOGINC,[How to find CLOOG include files])
4476 if test "x${CLOOGLIBS}" != "x" ; then
4477    AC_DEFINE(HAVE_cloog, 1, [Define if cloog is in use.])
4478 fi
4479
4480 AC_ARG_VAR(LIBELFLIBS,[How to link libelf])
4481 AC_ARG_VAR(LIBELFINC,[How to find libelf include files])
4482 if test "x${LIBELFLIBS}" != "x" ; then
4483    AC_DEFINE(HAVE_libelf, 1, [Define if libelf is in use.])
4484 fi
4485
4486 # Check for plugin support
4487 AC_ARG_ENABLE(plugin,
4488 [  --enable-plugin         enable plugin support],
4489 enable_plugin=$enableval,
4490 enable_plugin=yes; default_plugin=yes)
4491
4492 pluginlibs=
4493 if test x"$enable_plugin" = x"yes"; then
4494
4495   case "${host}" in
4496     *-*-darwin*)
4497       export_sym_check="$gcc_cv_nm -g"
4498     ;;
4499     *)
4500       export_sym_check="$gcc_cv_objdump -T"
4501     ;;
4502   esac
4503   AC_MSG_CHECKING([for exported symbols])
4504   echo "int main() {return 0;} int foobar() {return 0;}" > conftest.c
4505   ${CC} ${CFLAGS} ${LDFLAGS} conftest.c -o conftest > /dev/null 2>&1
4506   if $export_sym_check conftest | grep foobar > /dev/null; then
4507     : # No need to use a flag
4508   else
4509     AC_MSG_CHECKING([for -rdynamic])
4510     ${CC} ${CFLAGS} ${LDFLAGS} -rdynamic conftest.c -o conftest > /dev/null 2>&1
4511     if $export_sym_check conftest | grep foobar > /dev/null; then
4512       plugin_rdynamic=yes
4513       pluginlibs="-rdynamic"
4514     else
4515       plugin_rdynamic=no
4516       enable_plugin=no
4517     fi
4518     AC_MSG_RESULT([$plugin_rdynamic])
4519   fi
4520
4521   # Check -ldl
4522   saved_LIBS="$LIBS"
4523   AC_SEARCH_LIBS([dlopen], [dl])
4524   if test x"$ac_cv_search_dlopen" = x"-ldl"; then
4525     pluginlibs="$pluginlibs -ldl"
4526   fi
4527   LIBS="$saved_LIBS"
4528
4529   # Check that we can build shared objects with -fPIC -shared
4530   saved_LDFLAGS="$LDFLAGS"
4531   case "${host}" in
4532     *-*-darwin*)
4533       LDFLAGS="$LDFLAGS -fPIC -shared -undefined dynamic_lookup"
4534     ;;
4535     *)
4536       LDFLAGS="$LDFLAGS -fPIC -shared"
4537     ;;
4538   esac
4539   AC_MSG_CHECKING([for -fPIC -shared])
4540   AC_TRY_LINK(
4541     [extern int X;],[return X == 0;],
4542     [AC_MSG_RESULT([yes]); have_pic_shared=yes],
4543     [AC_MSG_RESULT([no]); have_pic_shared=no])
4544   if test x"$have_pic_shared" != x"yes" -o x"$ac_cv_search_dlopen" = x"no"; then
4545     pluginlibs=
4546     enable_plugin=no
4547   fi
4548   LDFLAGS="$saved_LDFLAGS"
4549
4550   # If plugin support had been requested but not available, fail.
4551   if test x"$enable_plugin" = x"no" ; then
4552     if test x"$default_plugin" != x"yes"; then
4553       AC_MSG_ERROR([
4554 Building GCC with plugin support requires a host that supports
4555 -fPIC, -shared, -ldl and -rdynamic.])
4556     fi
4557   fi
4558 fi
4559
4560 AC_SUBST(pluginlibs)
4561 AC_SUBST(enable_plugin)
4562 if test x"$enable_plugin" = x"yes"; then
4563   AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
4564 fi
4565
4566 # Configure the subdirectories
4567 # AC_CONFIG_SUBDIRS($subdirs)
4568
4569 # Create the Makefile
4570 # and configure language subdirectories
4571 AC_CONFIG_FILES($all_outputs)
4572
4573 AC_CONFIG_COMMANDS([default],
4574 [
4575 case ${CONFIG_HEADERS} in
4576   *auto-host.h:config.in*)
4577   echo > cstamp-h ;;
4578 esac
4579 # Make sure all the subdirs exist.
4580 for d in $subdirs doc build
4581 do
4582     test -d $d || mkdir $d
4583 done
4584 ],
4585 [subdirs='$subdirs'])
4586 AC_OUTPUT