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