gcc/configure.ac

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