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