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 [case $target in
1167   *-*-hpux10*)
1168     if test $enableval != yes; then
1169       AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1170       enableval=yes
1171     fi
1172     ;;
1173 esac
1174 force_sjlj_exceptions=yes],
1175 [case $target in
1176   *-*-hpux10*)
1177     force_sjlj_exceptions=yes
1178     enableval=yes
1179     ;;
1180   *)
1181     force_sjlj_exceptions=no
1182     ;;
1183 esac])
1184 if test $force_sjlj_exceptions = yes; then
1185   sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1186   AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1187     [Define 0/1 to force the choice for exception handling model.])
1188 fi
1189
1190 # For platforms with the unwind ABI which includes an unwind library,
1191 # libunwind, we can choose to use the system libunwind.
1192 AC_ARG_WITH(system-libunwind,
1193 [  --with-system-libunwind use installed libunwind])
1194
1195 # config.gcc also contains tests of with_system_libunwind.
1196 if test x$with_system_libunwind = xyes; then
1197         AC_DEFINE(HAVE_GETIPINFO, 1,
1198 [Define to 1 if system unwind library has _Unwind_GetIPInfo.])
1199 fi
1200
1201 # --------------------------------------------------------
1202 # Build, host, and target specific configuration fragments
1203 # --------------------------------------------------------
1204
1205 # Collect build-machine-specific information.
1206 . ${srcdir}/config.build
1207
1208 # Collect host-machine-specific information.
1209 . ${srcdir}/config.host
1210
1211 target_gtfiles=
1212
1213 # Collect target-machine-specific information.
1214 . ${srcdir}/config.gcc
1215
1216 extra_objs="${host_extra_objs} ${extra_objs}"
1217 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1218
1219 # Default the target-machine variables that were not explicitly set.
1220 if test x"$tm_file" = x
1221 then tm_file=$cpu_type/$cpu_type.h; fi
1222
1223 if test x"$extra_headers" = x
1224 then extra_headers=; fi
1225
1226 if test x$md_file = x
1227 then md_file=$cpu_type/$cpu_type.md; fi
1228
1229 if test x$out_file = x
1230 then out_file=$cpu_type/$cpu_type.c; fi
1231
1232 if test x"$tmake_file" = x
1233 then tmake_file=$cpu_type/t-$cpu_type
1234 fi
1235
1236 if test x"$dwarf2" = xyes
1237 then tm_file="$tm_file tm-dwarf2.h"
1238 fi
1239
1240 # Say what files are being used for the output code and MD file.
1241 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1242 echo "Using \`$srcdir/config/$md_file' as machine description file."
1243
1244 # If any of the xm_file variables contain nonexistent files, warn
1245 # about them and drop them.
1246
1247 bx=
1248 for x in $build_xm_file; do
1249   if    test -f $srcdir/config/$x
1250   then      bx="$bx $x"
1251   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1252   fi
1253 done
1254 build_xm_file="$bx"
1255
1256 hx=
1257 for x in $host_xm_file; do
1258   if    test -f $srcdir/config/$x
1259   then      hx="$hx $x"
1260   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1261   fi
1262 done
1263 host_xm_file="$hx"
1264
1265 tx=
1266 for x in $xm_file; do
1267   if    test -f $srcdir/config/$x
1268   then      tx="$tx $x"
1269   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1270   fi
1271 done
1272 xm_file="$tx"
1273
1274 count=a
1275 for f in $tm_file; do
1276         count=${count}x
1277 done
1278 if test $count = ax; then
1279         echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1280 else
1281         echo "Using the following target machine macro files:"
1282         for f in $tm_file; do
1283                 echo "  $srcdir/config/$f"
1284         done
1285 fi
1286
1287 if test x$need_64bit_hwint = xyes; then
1288         AC_DEFINE(NEED_64BIT_HOST_WIDE_INT, 1,
1289 [Define to 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h).])
1290 fi
1291
1292 if test x$use_long_long_for_widest_fast_int = xyes; then
1293         AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1294 [Define to 1 if the 'long long' (or '__int64') is wider than 'long' but still
1295 efficiently supported by the host hardware.])
1296 fi
1297
1298 count=a
1299 for f in $host_xm_file; do
1300         count=${count}x
1301 done
1302 if test $count = a; then
1303         :
1304 elif test $count = ax; then
1305         echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1306 else
1307         echo "Using the following host machine macro files:"
1308         for f in $host_xm_file; do
1309                 echo "  $srcdir/config/$f"
1310         done
1311 fi
1312 echo "Using ${out_host_hook_obj} for host machine hooks."
1313
1314 if test "$host_xm_file" != "$build_xm_file"; then
1315         count=a
1316         for f in $build_xm_file; do
1317                 count=${count}x
1318         done
1319         if test $count = a; then
1320                 :
1321         elif test $count = ax; then
1322                 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1323         else
1324                 echo "Using the following build machine macro files:"
1325                 for f in $build_xm_file; do
1326                         echo "  $srcdir/config/$f"
1327                 done
1328         fi
1329 fi
1330
1331 case ${host} in
1332   powerpc*-*-darwin*)
1333     AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1334       gcc_cv_mcontext_underscores,
1335       AC_COMPILE_IFELSE([
1336 #include <sys/cdefs.h>
1337 #include <sys/signal.h>
1338 #include <ucontext.h>
1339 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1340 ],
1341         gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1342       if test $gcc_cv_mcontext_underscores = yes; then
1343         AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1344           [mcontext_t fields start with __])
1345       fi
1346     ;;
1347 esac
1348
1349 # ---------
1350 # Threading
1351 # ---------
1352
1353 # Check if a valid thread package
1354 case ${enable_threads} in
1355   "" | no)
1356     # No threads
1357     target_thread_file='single'
1358     ;;
1359   yes)
1360     # default
1361     target_thread_file='single'
1362     ;;
1363   aix | dce | gnat | irix | posix | posix95 | rtems | \
1364   single | solaris | vxworks | win32 | mipssde)
1365     target_thread_file=${enable_threads}
1366     ;;
1367   *)
1368     echo "${enable_threads} is an unknown thread package" 1>&2
1369     exit 1
1370     ;;
1371 esac
1372
1373 if test x${thread_file} = x; then
1374   # No thread file set by target-specific clauses in config.gcc,
1375   # so use file chosen by default logic above
1376   thread_file=${target_thread_file}
1377 fi
1378
1379 # Make gthr-default.h if we have a thread file.
1380 gthread_flags=
1381 if test $thread_file != single; then
1382   rm -f gthr-default.h
1383   echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h
1384   gthread_flags=-DHAVE_GTHR_DEFAULT
1385 fi
1386 AC_SUBST(gthread_flags)
1387
1388 # --------
1389 # UNSORTED
1390 # --------
1391
1392 use_cxa_atexit=no
1393 if test x$enable___cxa_atexit = xyes || \
1394    test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1395   if test x$host = x$target; then
1396     case $host in
1397       # mingw32 doesn't have __cxa_atexit but uses atexit registration
1398       # keyed to flag_use_cxa_atexit
1399       *-*-mingw32*)
1400         use_cxa_atexit=yes
1401         ;;
1402       *)
1403         AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1404           [echo "__cxa_atexit can't be enabled on this target"])
1405         ;;
1406     esac
1407   else
1408     # We can't check for __cxa_atexit when building a cross, so assume
1409     # it is available
1410     use_cxa_atexit=yes
1411   fi
1412   if test x$use_cxa_atexit = xyes; then
1413     AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1414       [Define if you want to use __cxa_atexit, rather than atexit, to
1415       register C++ destructors for local statics and global objects.
1416       This is essential for fully standards-compliant handling of
1417       destructors, but requires __cxa_atexit in libc.])
1418   fi
1419 fi
1420
1421 use_getipinfo=yes
1422 if test x$with_system_libunwind = xyes; then
1423    if test x$host = x$target; then
1424      AC_SEARCH_LIBS(_Unwind_GetIPInfo, unwind,, [use_getipinfo=no])
1425    fi
1426 fi
1427 GCC_TARGET_TEMPLATE(HAVE_GETIPINFO)
1428 if test x$use_getipinfo = xyes; then
1429    AC_DEFINE(HAVE_GETIPINFO, 1,
1430         [Define to 1 if system unwind library has _Unwind_GetIPInfo.])
1431 else
1432    echo "The system unwind library does not support _Unwind_GetIPInfo."
1433 fi
1434
1435 # Look for a file containing extra machine modes.
1436 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1437   extra_modes_file='$(srcdir)'/config/${extra_modes}
1438   AC_SUBST(extra_modes_file)
1439   AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1440   [Define to the name of a file containing a list of extra machine modes
1441    for this architecture.])
1442 fi
1443
1444 # Convert extra_options into a form suitable for Makefile use.
1445 extra_opt_files=
1446 for f in $extra_options; do
1447   extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1448 done
1449 AC_SUBST(extra_opt_files)
1450
1451 # auto-host.h is the file containing items generated by autoconf and is
1452 # the first file included by config.h.
1453 # If host=build, it is correct to have bconfig include auto-host.h
1454 # as well.  If host!=build, we are in error and need to do more
1455 # work to find out the build config parameters.
1456 if test x$host = x$build
1457 then
1458         build_auto=auto-host.h
1459 else
1460         # We create a subdir, then run autoconf in the subdir.
1461         # To prevent recursion we set host and build for the new
1462         # invocation of configure to the build for this invocation
1463         # of configure.
1464         tempdir=build.$$
1465         rm -rf $tempdir
1466         mkdir $tempdir
1467         cd $tempdir
1468         case ${srcdir} in
1469         /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1470         *) realsrcdir=../${srcdir};;
1471         esac
1472         saved_CFLAGS="${CFLAGS}"
1473         CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1474         ${realsrcdir}/configure \
1475                 --enable-languages=${enable_languages-all} \
1476                 --target=$target_alias --host=$build_alias --build=$build_alias
1477         CFLAGS="${saved_CFLAGS}"
1478
1479         # We just finished tests for the build machine, so rename
1480         # the file auto-build.h in the gcc directory.
1481         mv auto-host.h ../auto-build.h
1482         cd ..
1483         rm -rf $tempdir
1484         build_auto=auto-build.h
1485 fi
1486 AC_SUBST(build_subdir)
1487
1488 tm_file="${tm_file} defaults.h"
1489 tm_p_file="${tm_p_file} tm-preds.h"
1490 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1491 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1492 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1493 # put this back in temporarily.
1494 xm_file="auto-host.h ansidecl.h ${xm_file}"
1495
1496 # --------
1497 # UNSORTED
1498 # --------
1499
1500 changequote(,)dnl
1501 # Compile in configure arguments.
1502 if test -f configargs.h ; then
1503         # Being re-configured.
1504         gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1505         gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1506 else
1507         gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1508 fi
1509
1510 # Double all backslashes and backslash all quotes to turn
1511 # gcc_config_arguments into a C string.
1512 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1513 $gcc_config_arguments
1514 EOF
1515 gcc_config_arguments_str=`cat conftest.out`
1516 rm -f conftest.out
1517
1518 cat > configargs.h <<EOF
1519 /* Generated automatically. */
1520 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1521 static const char thread_model[] = "$thread_file";
1522
1523 static const struct {
1524   const char *name, *value;
1525 } configure_default_options[] = $configure_default_options;
1526 EOF
1527 changequote([,])dnl
1528
1529 # Internationalization
1530 ZW_GNU_GETTEXT_SISTER_DIR
1531
1532 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1533 # -liconv on the link line twice.
1534 case "$LIBINTL" in *$LIBICONV*)
1535         LIBICONV= ;;
1536 esac
1537
1538 AC_ARG_ENABLE(secureplt,
1539 [  --enable-secureplt      enable -msecure-plt by default for PowerPC],
1540 [], [])
1541
1542 # Windows32 Registry support for specifying GCC installation paths.
1543 AC_ARG_ENABLE(win32-registry,
1544 [  --disable-win32-registry
1545                           disable lookup of installation paths in the
1546                           Registry on Windows hosts
1547   --enable-win32-registry enable registry lookup (default)
1548   --enable-win32-registry=KEY
1549                           use KEY instead of GCC version as the last portion
1550                           of the registry key],,)
1551
1552 case $host_os in
1553   win32 | pe | cygwin* | mingw32* | uwin*)
1554     if test "x$enable_win32_registry" != xno; then
1555       AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1556     fi
1557
1558     if test "x$enable_win32_registry" != xno; then
1559       AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1560   [Define to 1 if installation paths should be looked up in the Windows
1561    Registry. Ignored on non-Windows hosts.])
1562
1563       if test "x$enable_win32_registry" != xyes \
1564          && test "x$enable_win32_registry" != x; then
1565         AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1566   [Define to be the last component of the Windows registry key under which
1567    to look for installation paths.  The full key used will be
1568    HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1569    The default is the GCC version number.])
1570       fi
1571     fi
1572   ;;
1573 esac
1574
1575 # Get an absolute path to the GCC top-level source directory
1576 holddir=`${PWDCMD-pwd}`
1577 cd $srcdir
1578 topdir=`${PWDCMD-pwd}`
1579 cd $holddir
1580
1581 # Conditionalize the makefile for this host machine.
1582 xmake_file=
1583 for f in ${host_xmake_file}
1584 do
1585         if test -f ${srcdir}/config/$f
1586         then
1587                 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1588         fi
1589 done
1590
1591 # Conditionalize the makefile for this target machine.
1592 tmake_file_=
1593 for f in ${tmake_file}
1594 do
1595         if test -f ${srcdir}/config/$f
1596         then
1597                 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1598         fi
1599 done
1600 tmake_file="${tmake_file_}"
1601
1602 # This is a terrible hack which will go away some day.
1603 host_cc_for_libada=${CC}
1604 AC_SUBST(host_cc_for_libada)
1605
1606 out_object_file=`basename $out_file .c`.o
1607
1608 tm_file_list="options.h"
1609 tm_include_list="options.h"
1610 for f in $tm_file; do
1611   case $f in
1612     ./* )
1613        f=`echo $f | sed 's/^..//'`
1614        tm_file_list="${tm_file_list} $f"
1615        tm_include_list="${tm_include_list} $f"
1616        ;;
1617     defaults.h )
1618        tm_file_list="${tm_file_list} \$(srcdir)/$f"
1619        tm_include_list="${tm_include_list} $f"
1620        ;;
1621     * )
1622        tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1623        tm_include_list="${tm_include_list} config/$f"
1624        ;;
1625   esac
1626 done
1627
1628 tm_p_file_list=
1629 tm_p_include_list=
1630 for f in $tm_p_file; do
1631   case $f in
1632     tm-preds.h )
1633        tm_p_file_list="${tm_p_file_list} $f"
1634        tm_p_include_list="${tm_p_include_list} $f"
1635        ;;
1636     * )
1637        tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1638        tm_p_include_list="${tm_p_include_list} config/$f"
1639   esac
1640 done
1641
1642 xm_file_list=
1643 xm_include_list=
1644 for f in $xm_file; do
1645   case $f in
1646     ansidecl.h )
1647        xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1648        xm_include_list="${xm_include_list} $f"
1649        ;;
1650     auto-host.h )
1651        xm_file_list="${xm_file_list} $f"
1652        xm_include_list="${xm_include_list} $f"
1653        ;;
1654     * )
1655        xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1656        xm_include_list="${xm_include_list} config/$f"
1657        ;;
1658   esac
1659 done
1660
1661 host_xm_file_list=
1662 host_xm_include_list=
1663 for f in $host_xm_file; do
1664   case $f in
1665     ansidecl.h )
1666        host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1667        host_xm_include_list="${host_xm_include_list} $f"
1668        ;;
1669     auto-host.h )
1670        host_xm_file_list="${host_xm_file_list} $f"
1671        host_xm_include_list="${host_xm_include_list} $f"
1672        ;;
1673     * )
1674        host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1675        host_xm_include_list="${host_xm_include_list} config/$f"
1676        ;;
1677   esac
1678 done
1679
1680 build_xm_file_list=
1681 for f in $build_xm_file; do
1682   case $f in
1683     ansidecl.h )
1684        build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1685        build_xm_include_list="${build_xm_include_list} $f"
1686        ;;
1687     auto-build.h | auto-host.h )
1688        build_xm_file_list="${build_xm_file_list} $f"
1689        build_xm_include_list="${build_xm_include_list} $f"
1690        ;;
1691     * )
1692        build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1693        build_xm_include_list="${build_xm_include_list} config/$f"
1694        ;;
1695   esac
1696 done
1697
1698 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1699 # cross-compiler which does not use the native headers and libraries.
1700 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1701 CROSS=                                          AC_SUBST(CROSS)
1702 ALL=all.internal                                AC_SUBST(ALL)
1703 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1704
1705 if test "x$with_build_sysroot" != x; then
1706   build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1707 else
1708   # This value is used, even on a native system, because
1709   # CROSS_SYSTEM_HEADER_DIR is just
1710   # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1711   build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1712 fi
1713
1714 if test x$host != x$target
1715 then
1716         CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1717         ALL=all.cross
1718         SYSTEM_HEADER_DIR=$build_system_header_dir
1719         case "$host","$target" in
1720         # Darwin crosses can use the host system's libraries and headers,
1721         # because of the fat library support.  Of course, it must be the
1722         # same version of Darwin on both sides.  Allow the user to
1723         # just say --target=foo-darwin without a version number to mean
1724         # "the version on this system".
1725             *-*-darwin*,*-*-darwin*)
1726                 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1727                 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1728                 if test $hostos = $targetos -o $targetos = darwin ; then
1729                     CROSS=
1730                     SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1731                     with_headers=yes
1732                 fi
1733                 ;;
1734
1735             i?86-*-*,x86_64-*-* \
1736             | powerpc*-*-*,powerpc64*-*-*)
1737                 CROSS="$CROSS -DNATIVE_CROSS" ;;
1738         esac
1739 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1740         SYSTEM_HEADER_DIR=$build_system_header_dir
1741 fi
1742
1743 # If this is a cross-compiler that does not
1744 # have its own set of headers then define
1745 # inhibit_libc
1746
1747 # If this is using newlib, without having the headers available now,
1748 # then define inhibit_libc in LIBGCC2_CFLAGS.
1749 # This prevents libgcc2 from containing any code which requires libc
1750 # support.
1751 inhibit_libc=false
1752 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1753        test x$with_newlib = xyes ; } &&
1754      { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1755        inhibit_libc=true
1756 fi
1757 AC_SUBST(inhibit_libc)
1758
1759 # When building gcc with a cross-compiler, we need to adjust things so
1760 # that the generator programs are still built with the native compiler.
1761 # Also, we cannot run fixincludes or fix-header.
1762
1763 # These are the normal (build=host) settings:
1764 CC_FOR_BUILD='$(CC)'            AC_SUBST(CC_FOR_BUILD)
1765 BUILD_CFLAGS='$(ALL_CFLAGS)'    AC_SUBST(BUILD_CFLAGS)
1766 STMP_FIXINC=stmp-fixinc         AC_SUBST(STMP_FIXINC)
1767
1768 # Possibly disable fixproto, on a per-target basis.
1769 case ${use_fixproto} in
1770   no)
1771     STMP_FIXPROTO=
1772     ;;
1773   yes)
1774     STMP_FIXPROTO=stmp-fixproto
1775     ;;
1776 esac
1777 AC_SUBST(STMP_FIXPROTO)
1778
1779 # And these apply if build != host, or we are generating coverage data
1780 if test x$build != x$host || test "x$coverage_flags" != x
1781 then
1782     BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1783
1784     if test "x$TARGET_SYSTEM_ROOT" = x; then
1785         if test "x$STMP_FIXPROTO" != x; then
1786           STMP_FIXPROTO=stmp-install-fixproto
1787         fi
1788     fi
1789 fi
1790
1791 # Expand extra_headers to include complete path.
1792 # This substitutes for lots of t-* files.
1793 extra_headers_list=
1794 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1795 for file in ${extra_headers} ; do
1796   extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1797 done
1798
1799 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
1800 if test x"$use_gcc_tgmath" = xyes
1801 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
1802 fi
1803
1804 # Define collect2 in Makefile.
1805 case $host_can_use_collect2 in
1806   no) collect2= ;;
1807   *) collect2='collect2$(exeext)' ;;
1808 esac
1809 AC_SUBST([collect2])
1810
1811 # Add a definition of USE_COLLECT2 if system wants one.
1812 case $use_collect2 in
1813   no) use_collect2= ;;
1814   "") ;;
1815   *)
1816     host_xm_defines="${host_xm_defines} USE_COLLECT2"
1817     xm_defines="${xm_defines} USE_COLLECT2"
1818     case $host_can_use_collect2 in
1819       no)
1820         AC_MSG_ERROR([collect2 is required but cannot be built on this system])
1821         ;;
1822     esac
1823     ;;
1824 esac
1825
1826 # ---------------------------
1827 # Assembler & linker features
1828 # ---------------------------
1829
1830 # Identify the assembler which will work hand-in-glove with the newly
1831 # built GCC, so that we can examine its features.  This is the assembler
1832 # which will be driven by the driver program.
1833 #
1834 # If build != host, and we aren't building gas in-tree, we identify a
1835 # build->target assembler and hope that it will have the same features
1836 # as the host->target assembler we'll be using.
1837 gcc_cv_gas_major_version=
1838 gcc_cv_gas_minor_version=
1839 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1840
1841 m4_pattern_allow([AS_FOR_TARGET])dnl
1842 AS_VAR_SET_IF(gcc_cv_as,, [
1843 if test -x "$DEFAULT_ASSEMBLER"; then
1844         gcc_cv_as="$DEFAULT_ASSEMBLER"
1845 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
1846      && test -f ../gas/Makefile \
1847      && test x$build = x$host; then
1848         gcc_cv_as=../gas/as-new$build_exeext
1849 elif test -x as$build_exeext; then
1850         # Build using assembler in the current directory.
1851         gcc_cv_as=./as$build_exeext
1852 elif test -x $AS_FOR_TARGET; then
1853         gcc_cv_as="$AS_FOR_TARGET"
1854 else
1855         AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
1856 fi])
1857
1858 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
1859 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
1860 case "$ORIGINAL_AS_FOR_TARGET" in
1861   ./as | ./as$build_exeext) ;;
1862   *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
1863 esac
1864
1865 AC_MSG_CHECKING(what assembler to use)
1866 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
1867   # Single tree build which includes gas.  We want to prefer it
1868   # over whatever linker top-level may have detected, since
1869   # we'll use what we're building after installation anyway.
1870   AC_MSG_RESULT(newly built gas)
1871   in_tree_gas=yes
1872   _gcc_COMPUTE_GAS_VERSION
1873   in_tree_gas_is_elf=no
1874   if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
1875      || (grep 'obj_format = multi' ../gas/Makefile \
1876          && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
1877   then
1878     in_tree_gas_is_elf=yes
1879   fi
1880 else
1881   AC_MSG_RESULT($gcc_cv_as)
1882   in_tree_gas=no
1883 fi
1884
1885 # Identify the linker which will work hand-in-glove with the newly
1886 # built GCC, so that we can examine its features.  This is the linker
1887 # which will be driven by the driver program.
1888 #
1889 # If build != host, and we aren't building gas in-tree, we identify a
1890 # build->target linker and hope that it will have the same features
1891 # as the host->target linker we'll be using.
1892 gcc_cv_gld_major_version=
1893 gcc_cv_gld_minor_version=
1894 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1895 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1896
1897 AS_VAR_SET_IF(gcc_cv_ld,, [
1898 if test -x "$DEFAULT_LINKER"; then
1899         gcc_cv_ld="$DEFAULT_LINKER"
1900 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
1901      && test -f ../ld/Makefile \
1902      && test x$build = x$host; then
1903         gcc_cv_ld=../ld/ld-new$build_exeext
1904 elif test -x collect-ld$build_exeext; then
1905         # Build using linker in the current directory.
1906         gcc_cv_ld=./collect-ld$build_exeext
1907 elif test -x $LD_FOR_TARGET; then
1908         gcc_cv_ld="$LD_FOR_TARGET"
1909 else
1910         AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
1911 fi])
1912
1913 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
1914 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
1915 case "$ORIGINAL_LD_FOR_TARGET" in
1916   ./collect-ld | ./collect-ld$build_exeext) ;;
1917   *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
1918 esac
1919
1920 AC_MSG_CHECKING(what linker to use)
1921 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext; then
1922         # Single tree build which includes ld.  We want to prefer it
1923         # over whatever linker top-level may have detected, since
1924         # we'll use what we're building after installation anyway.
1925         AC_MSG_RESULT(newly built ld)
1926         in_tree_ld=yes
1927         in_tree_ld_is_elf=no
1928         if (grep 'EMUL = .*elf' ../ld/Makefile \
1929             || grep 'EMUL = .*linux' ../ld/Makefile \
1930             || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
1931           in_tree_ld_is_elf=yes
1932         fi
1933         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
1934         do
1935 changequote(,)dnl
1936                 gcc_cv_gld_version=`sed -n -e 's/^[     ]*\(VERSION=[0-9]*\.[0-9]*.*\)/\1/p' < $f`
1937                 if test x$gcc_cv_gld_version != x; then
1938                         break
1939                 fi
1940         done
1941         gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
1942         gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1943 changequote([,])dnl
1944 else
1945         AC_MSG_RESULT($gcc_cv_ld)
1946         in_tree_ld=no
1947 fi
1948
1949 # Figure out what nm we will be using.
1950 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
1951 AS_VAR_SET_IF(gcc_cv_nm,, [
1952 if test -f $gcc_cv_binutils_srcdir/configure.in \
1953      && test -f ../binutils/Makefile \
1954      && test x$build = x$host; then
1955         gcc_cv_nm=../binutils/nm-new$build_exeext
1956 elif test -x nm$build_exeext; then
1957         gcc_cv_nm=./nm$build_exeext
1958 elif test -x $NM_FOR_TARGET; then
1959         gcc_cv_nm="$NM_FOR_TARGET"
1960 else
1961         AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
1962 fi])
1963
1964 AC_MSG_CHECKING(what nm to use)
1965 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
1966         # Single tree build which includes binutils.
1967         AC_MSG_RESULT(newly built nm)
1968         in_tree_nm=yes
1969 else
1970         AC_MSG_RESULT($gcc_cv_nm)
1971         in_tree_nm=no
1972 fi
1973
1974 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
1975 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
1976 case "$ORIGINAL_NM_FOR_TARGET" in
1977   ./nm | ./nm$build_exeext) ;;
1978   *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
1979 esac
1980
1981
1982 # Figure out what objdump we will be using.
1983 AS_VAR_SET_IF(gcc_cv_objdump,, [
1984 if test -f $gcc_cv_binutils_srcdir/configure.in \
1985      && test -f ../binutils/Makefile \
1986      && test x$build = x$host; then
1987         # Single tree build which includes binutils.
1988         gcc_cv_objdump=../binutils/objdump$build_exeext
1989 elif test -x objdump$build_exeext; then
1990         gcc_cv_objdump=./objdump$build_exeext
1991 elif test -x $OBJDUMP_FOR_TARGET; then
1992         gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
1993 else
1994         AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
1995 fi])
1996
1997 AC_MSG_CHECKING(what objdump to use)
1998 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
1999         # Single tree build which includes binutils.
2000         AC_MSG_RESULT(newly built objdump)
2001 elif test x$gcc_cv_objdump = x; then
2002         AC_MSG_RESULT(not found)
2003 else
2004         AC_MSG_RESULT($gcc_cv_objdump)
2005 fi
2006
2007 # Figure out what assembler alignment features are present.
2008 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2009  [2,6,0],,
2010 [.balign 4
2011 .p2align 2],,
2012 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2013   [Define if your assembler supports .balign and .p2align.])])
2014
2015 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2016  [2,8,0],,
2017  [.p2align 4,,7],,
2018 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2019   [Define if your assembler supports specifying the maximum number
2020    of bytes to skip when using the GAS .p2align command.])])
2021
2022 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2023  [2,8,0],,
2024  [.literal16],,
2025 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2026   [Define if your assembler supports .literal16.])])
2027
2028 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2029  [elf,2,9,0],,
2030  [conftest_label1: .word 0
2031 .subsection -1
2032 conftest_label2: .word 0
2033 .previous],
2034  [if test x$gcc_cv_nm != x; then
2035     $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2036     $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2037     if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2038     then :
2039     else gcc_cv_as_subsection_m1=yes
2040     fi
2041     rm -f conftest.nm1 conftest.nm2
2042   fi],
2043  [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2044   [Define if your assembler supports .subsection and .subsection -1 starts
2045    emitting at the beginning of your section.])])
2046
2047 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2048  [2,2,0],,
2049  [      .weak foobar],,
2050 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2051
2052 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2053  [2,17,0],,
2054  [      .weakref foobar, barfnot],,
2055 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2056
2057 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2058  [2,15,91],,
2059  [      .SPACE $TEXT$
2060         .NSUBSPA $CODE$,COMDAT],,
2061 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2062
2063 # .hidden needs to be supported in both the assembler and the linker,
2064 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2065 # This is irritatingly difficult to feature test for; we have to check the
2066 # date string after the version number.  If we've got an in-tree
2067 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2068 # to be safe.
2069 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2070 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2071  [elf,2,13,0],,
2072 [       .hidden foobar
2073 foobar:])
2074
2075 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2076 [if test $in_tree_ld = yes ; then
2077   gcc_cv_ld_hidden=no
2078   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 \
2079      && test $in_tree_ld_is_elf = yes; then
2080      gcc_cv_ld_hidden=yes
2081   fi
2082 else
2083   gcc_cv_ld_hidden=yes
2084   ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2085   if echo "$ld_ver" | grep GNU > /dev/null; then
2086 changequote(,)dnl
2087     ld_vers=`echo $ld_ver | sed -n \
2088         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2089     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'`
2090     ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2091     ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2092     ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2093     if test 0"$ld_date" -lt 20020404; then
2094       if test -n "$ld_date"; then
2095         # If there was date string, but was earlier than 2002-04-04, fail
2096         gcc_cv_ld_hidden=no
2097       elif test -z "$ld_vers"; then
2098         # If there was no date string nor ld version number, something is wrong
2099         gcc_cv_ld_hidden=no
2100       else
2101         test -z "$ld_vers_patch" && ld_vers_patch=0
2102         if test "$ld_vers_major" -lt 2; then
2103           gcc_cv_ld_hidden=no
2104         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2105           gcc_cv_ld_hidden="no"
2106         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2107           gcc_cv_ld_hidden=no
2108         fi
2109       fi
2110 changequote([,])dnl
2111     fi
2112   else
2113     case "${target}" in
2114       hppa64*-*-hpux* | ia64*-*-hpux*)
2115         gcc_cv_ld_hidden=yes
2116         ;;
2117       *)
2118         gcc_cv_ld_hidden=no
2119         ;;
2120     esac
2121   fi
2122 fi])
2123 libgcc_visibility=no
2124 AC_SUBST(libgcc_visibility)
2125 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2126 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2127   libgcc_visibility=yes
2128   AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2129   [Define if your assembler and linker support .hidden.])
2130 fi
2131
2132 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2133 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2134   [elf,2,11,0],,
2135 [       .data
2136         .uleb128 L2 - L1
2137 L1:
2138         .uleb128 1280
2139         .sleb128 -1010
2140 L2:],
2141  [# GAS versions before 2.11 do not support uleb128,
2142   # despite appearing to.
2143   # ??? There exists an elf-specific test that will crash
2144   # the assembler.  Perhaps it's better to figure out whether
2145   # arbitrary sections are supported and try the test.
2146   as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2147   if echo "$as_ver" | grep GNU > /dev/null; then
2148 changequote(,)dnl
2149     as_vers=`echo $as_ver | sed -n \
2150         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2151     as_major=`expr "$as_vers" : '\([0-9]*\)'`
2152     as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2153 changequote([,])dnl
2154     if test $as_major -eq 2 && test $as_minor -lt 11
2155     then :
2156     else gcc_cv_as_leb128=yes
2157     fi
2158   fi],
2159   [AC_DEFINE(HAVE_AS_LEB128, 1,
2160     [Define if your assembler supports .sleb128 and .uleb128.])])
2161
2162 # GAS versions up to and including 2.11.0 may mis-optimize
2163 # .eh_frame data.
2164 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2165   [elf,2,12,0],,
2166 [       .text
2167 .LFB1:
2168         .4byte  0
2169 .L1:
2170         .4byte  0
2171 .LFE1:
2172         .section        .eh_frame,"aw",@progbits
2173 __FRAME_BEGIN__:
2174         .4byte  .LECIE1-.LSCIE1
2175 .LSCIE1:
2176         .4byte  0x0
2177         .byte   0x1
2178         .ascii "z\0"
2179         .byte   0x1
2180         .byte   0x78
2181         .byte   0x1a
2182         .byte   0x0
2183         .byte   0x4
2184         .4byte  1
2185         .p2align 1
2186 .LECIE1:
2187 .LSFDE1:
2188         .4byte  .LEFDE1-.LASFDE1
2189 .LASFDE1:
2190         .4byte  .LASFDE1-__FRAME_BEGIN__
2191         .4byte  .LFB1
2192         .4byte  .LFE1-.LFB1
2193         .byte   0x4
2194         .4byte  .LFE1-.LFB1
2195         .byte   0x4
2196         .4byte  .L1-.LFB1
2197 .LEFDE1:],
2198 [  dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2199 cat > conftest.lit <<EOF
2200  0000 10000000 00000000 017a0001 781a0004  .........z..x...
2201  0010 01000000 12000000 18000000 00000000  ................
2202  0020 08000000 04080000 0044               .........D      @&t@
2203 EOF
2204 cat > conftest.big <<EOF
2205  0000 00000010 00000000 017a0001 781a0004  .........z..x...
2206  0010 00000001 00000012 00000018 00000000  ................
2207  0020 00000008 04000000 0844               .........D      @&t@
2208 EOF
2209   # If the assembler didn't choke, and we can objdump,
2210   # and we got the correct data, then succeed.
2211   # The text in the here-document typically retains its unix-style line
2212   # endings, while the output of objdump will use host line endings.
2213   # Therefore, use diff -b for the comparisons.
2214   if test x$gcc_cv_objdump != x \
2215   && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2216      | tail -3 > conftest.got \
2217   && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2218     || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2219   then
2220     gcc_cv_as_eh_frame=yes
2221   elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2222     gcc_cv_as_eh_frame=buggy
2223   else
2224     # Uh oh, what do we do now?
2225     gcc_cv_as_eh_frame=no
2226   fi])
2227
2228 if test $gcc_cv_as_eh_frame = buggy; then
2229   AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2230   [Define if your assembler mis-optimizes .eh_frame data.])
2231 fi
2232
2233 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2234  [elf,2,12,0], [--fatal-warnings],
2235  [.section .rodata.str, "aMS", @progbits, 1])
2236 if test $gcc_cv_as_shf_merge = no; then
2237   gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2238     [elf,2,12,0], [--fatal-warnings],
2239     [.section .rodata.str, "aMS", %progbits, 1])
2240 fi
2241 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2242   [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2243 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2244
2245 gcc_GAS_CHECK_FEATURE(COMDAT group support, gcc_cv_as_comdat_group,
2246  [elf,2,16,0], [--fatal-warnings],
2247  [.section .text,"axG",@progbits,.foo,comdat])
2248 if test $gcc_cv_as_comdat_group = yes; then
2249   gcc_cv_as_comdat_group_percent=no
2250 else
2251  gcc_GAS_CHECK_FEATURE(COMDAT group support, gcc_cv_as_comdat_group_percent,
2252    [elf,2,16,0], [--fatal-warnings],
2253    [.section .text,"axG",%progbits,.foo,comdat])
2254 fi
2255 if test $in_tree_ld != yes && test x"$ld_vers" != x; then
2256   comdat_group=yes
2257   if test 0"$ld_date" -lt 20050308; then
2258     if test -n "$ld_date"; then
2259       # If there was date string, but was earlier than 2005-03-08, fail
2260       comdat_group=no
2261     elif test "$ld_vers_major" -lt 2; then
2262       comdat_group=no
2263     elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2264       comdat_group=no
2265     fi
2266   fi
2267 else
2268   # assume linkers other than GNU ld don't support COMDAT group
2269   comdat_group=no
2270 fi
2271 if test $comdat_group = no; then
2272   gcc_cv_as_comdat_group=no
2273   gcc_cv_as_comdat_group_percent=no
2274 fi
2275 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2276   [`if test $gcc_cv_as_comdat_group = yes || test $gcc_cv_as_comdat_group_percent = yes; then echo 1; else echo 0; fi`],
2277 [Define 0/1 if your assembler and linker support COMDAT groups.])
2278
2279 # Thread-local storage - the check is heavily parametrized.
2280 conftest_s=
2281 tls_first_major=
2282 tls_first_minor=
2283 tls_as_opt=
2284 case "$target" in
2285 changequote(,)dnl
2286   alpha*-*-*)
2287     conftest_s='
2288         .section ".tdata","awT",@progbits
2289 foo:    .long   25
2290         .text
2291         ldq     $27,__tls_get_addr($29)         !literal!1
2292         lda     $16,foo($29)                    !tlsgd!1
2293         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
2294         ldq     $27,__tls_get_addr($29)         !literal!2
2295         lda     $16,foo($29)                    !tlsldm!2
2296         jsr     $26,($27),__tls_get_addr        !lituse_tlsldm!2
2297         ldq     $1,foo($29)                     !gotdtprel
2298         ldah    $2,foo($29)                     !dtprelhi
2299         lda     $3,foo($2)                      !dtprello
2300         lda     $4,foo($29)                     !dtprel
2301         ldq     $1,foo($29)                     !gottprel
2302         ldah    $2,foo($29)                     !tprelhi
2303         lda     $3,foo($2)                      !tprello
2304         lda     $4,foo($29)                     !tprel'
2305         tls_first_major=2
2306         tls_first_minor=13
2307         tls_as_opt=--fatal-warnings
2308         ;;
2309   frv*-*-*)
2310     conftest_s='
2311         .section ".tdata","awT",@progbits
2312 x:      .long   25
2313         .text
2314         call    #gettlsoff(x)'
2315         tls_first_major=2
2316         tls_first_minor=14
2317         ;;
2318   hppa*-*-linux*)
2319     conftest_s='
2320 t1:     .reg    %r20
2321 t2:     .reg    %r21
2322 gp:     .reg    %r19
2323         .section ".tdata","awT",@progbits
2324 foo:    .long   25
2325         .text
2326         .align  4
2327         addil LT%foo-$tls_gdidx$,gp
2328         ldo RT%foo-$tls_gdidx$(%r1),%arg0
2329         b __tls_get_addr
2330         nop
2331         addil LT%foo-$tls_ldidx$,gp
2332         b __tls_get_addr
2333         ldo RT%foo-$tls_ldidx$(%r1),%arg0
2334         addil LR%foo-$tls_dtpoff$,%ret0
2335         ldo RR%foo-$tls_dtpoff$(%r1),%t1
2336         mfctl %cr27,%t1
2337         addil LT%foo-$tls_ieoff$,gp
2338         ldw RT%foo-$tls_ieoff$(%r1),%t2
2339         add %t1,%t2,%t3
2340         mfctl %cr27,%t1
2341         addil LR%foo-$tls_leoff$,%t1
2342         ldo RR%foo-$tls_leoff$(%r1),%t2'
2343         tls_first_major=2
2344         tls_first_minor=15
2345         tls_as_opt=--fatal-warnings
2346         ;;
2347   arm*-*-*)
2348     conftest_s='
2349         .section ".tdata","awT",%progbits
2350 foo:    .long   25
2351         .text
2352 .word foo(gottpoff)
2353 .word foo(tpoff)
2354 .word foo(tlsgd)
2355 .word foo(tlsldm)
2356 .word foo(tlsldo)'
2357         tls_first_major=2
2358         tls_first_minor=17
2359         ;;
2360   i[34567]86-*-*)
2361     conftest_s='
2362         .section ".tdata","awT",@progbits
2363 foo:    .long   25
2364         .text
2365         movl    %gs:0, %eax
2366         leal    foo@TLSGD(,%ebx,1), %eax
2367         leal    foo@TLSLDM(%ebx), %eax
2368         leal    foo@DTPOFF(%eax), %edx
2369         movl    foo@GOTTPOFF(%ebx), %eax
2370         subl    foo@GOTTPOFF(%ebx), %eax
2371         addl    foo@GOTNTPOFF(%ebx), %eax
2372         movl    foo@INDNTPOFF, %eax
2373         movl    $foo@TPOFF, %eax
2374         subl    $foo@TPOFF, %eax
2375         leal    foo@NTPOFF(%ecx), %eax'
2376         tls_first_major=2
2377         tls_first_minor=14
2378         tls_as_opt=--fatal-warnings
2379         ;;
2380   x86_64-*-*)
2381     conftest_s='
2382         .section ".tdata","awT",@progbits
2383 foo:    .long   25
2384         .text
2385         movq    %fs:0, %rax
2386         leaq    foo@TLSGD(%rip), %rdi
2387         leaq    foo@TLSLD(%rip), %rdi
2388         leaq    foo@DTPOFF(%rax), %rdx
2389         movq    foo@GOTTPOFF(%rip), %rax
2390         movq    $foo@TPOFF, %rax'
2391         tls_first_major=2
2392         tls_first_minor=14
2393         tls_as_opt=--fatal-warnings
2394         ;;
2395   ia64-*-*)
2396     conftest_s='
2397         .section ".tdata","awT",@progbits
2398 foo:    data8   25
2399         .text
2400         addl    r16 = @ltoff(@dtpmod(foo#)), gp
2401         addl    r17 = @ltoff(@dtprel(foo#)), gp
2402         addl    r18 = @ltoff(@tprel(foo#)), gp
2403         addl    r19 = @dtprel(foo#), gp
2404         adds    r21 = @dtprel(foo#), r13
2405         movl    r23 = @dtprel(foo#)
2406         addl    r20 = @tprel(foo#), gp
2407         adds    r22 = @tprel(foo#), r13
2408         movl    r24 = @tprel(foo#)'
2409         tls_first_major=2
2410         tls_first_minor=13
2411         tls_as_opt=--fatal-warnings
2412         ;;
2413   mips*-*-*)
2414     conftest_s='
2415         .section .tdata,"awT",@progbits
2416 x:
2417         .word 2
2418         .text
2419         addiu $4, $28, %tlsgd(x)
2420         addiu $4, $28, %tlsldm(x)
2421         lui $4, %dtprel_hi(x)
2422         addiu $4, $4, %dtprel_lo(x)
2423         lw $4, %gottprel(x)($28)
2424         lui $4, %tprel_hi(x)
2425         addiu $4, $4, %tprel_lo(x)'
2426         tls_first_major=2
2427         tls_first_minor=16
2428         tls_as_opt='-32 --fatal-warnings'
2429         ;;
2430   powerpc-*-*)
2431     conftest_s='
2432         .section ".tdata","awT",@progbits
2433         .align 2
2434 ld0:    .space 4
2435 ld1:    .space 4
2436 x1:     .space 4
2437 x2:     .space 4
2438 x3:     .space 4
2439         .text
2440         addi 3,31,ld0@got@tlsgd
2441         bl __tls_get_addr
2442         addi 3,31,x1@got@tlsld
2443         bl __tls_get_addr
2444         addi 9,3,x1@dtprel
2445         addis 9,3,x2@dtprel@ha
2446         addi 9,9,x2@dtprel@l
2447         lwz 9,x3@got@tprel(31)
2448         add 9,9,x@tls
2449         addi 9,2,x1@tprel
2450         addis 9,2,x2@tprel@ha
2451         addi 9,9,x2@tprel@l'
2452         tls_first_major=2
2453         tls_first_minor=14
2454         tls_as_opt="-a32 --fatal-warnings"
2455         ;;
2456   powerpc64-*-*)
2457     conftest_s='
2458         .section ".tdata","awT",@progbits
2459         .align 3
2460 ld0:    .space 8
2461 ld1:    .space 8
2462 x1:     .space 8
2463 x2:     .space 8
2464 x3:     .space 8
2465         .text
2466         addi 3,2,ld0@got@tlsgd
2467         bl .__tls_get_addr
2468         nop
2469         addi 3,2,ld1@toc
2470         bl .__tls_get_addr
2471         nop
2472         addi 3,2,x1@got@tlsld
2473         bl .__tls_get_addr
2474         nop
2475         addi 9,3,x1@dtprel
2476         bl .__tls_get_addr
2477         nop
2478         addis 9,3,x2@dtprel@ha
2479         addi 9,9,x2@dtprel@l
2480         bl .__tls_get_addr
2481         nop
2482         ld 9,x3@got@dtprel(2)
2483         add 9,9,3
2484         bl .__tls_get_addr
2485         nop'
2486         tls_first_major=2
2487         tls_first_minor=14
2488         tls_as_opt="-a64 --fatal-warnings"
2489         ;;
2490   s390-*-*)
2491     conftest_s='
2492         .section ".tdata","awT",@progbits
2493 foo:    .long   25
2494         .text
2495         .long   foo@TLSGD
2496         .long   foo@TLSLDM
2497         .long   foo@DTPOFF
2498         .long   foo@NTPOFF
2499         .long   foo@GOTNTPOFF
2500         .long   foo@INDNTPOFF
2501         l       %r1,foo@GOTNTPOFF(%r12)
2502         l       %r1,0(%r1):tls_load:foo
2503         bas     %r14,0(%r1,%r13):tls_gdcall:foo
2504         bas     %r14,0(%r1,%r13):tls_ldcall:foo'
2505         tls_first_major=2
2506         tls_first_minor=14
2507         tls_as_opt="-m31 --fatal-warnings"
2508         ;;
2509   s390x-*-*)
2510     conftest_s='
2511         .section ".tdata","awT",@progbits
2512 foo:    .long   25
2513         .text
2514         .quad   foo@TLSGD
2515         .quad   foo@TLSLDM
2516         .quad   foo@DTPOFF
2517         .quad   foo@NTPOFF
2518         .quad   foo@GOTNTPOFF
2519         lg      %r1,foo@GOTNTPOFF(%r12)
2520         larl    %r1,foo@INDNTPOFF
2521         brasl   %r14,__tls_get_offset@PLT:tls_gdcall:foo
2522         brasl   %r14,__tls_get_offset@PLT:tls_ldcall:foo'
2523         tls_first_major=2
2524         tls_first_minor=14
2525         tls_as_opt="-m64 -Aesame --fatal-warnings"
2526         ;;
2527   sh-*-* | sh[34]-*-*)
2528     conftest_s='
2529         .section ".tdata","awT",@progbits
2530 foo:    .long   25
2531         .text
2532         .long   foo@TLSGD
2533         .long   foo@TLSLDM
2534         .long   foo@DTPOFF
2535         .long   foo@GOTTPOFF
2536         .long   foo@TPOFF'
2537         tls_first_major=2
2538         tls_first_minor=13
2539         tls_as_opt=--fatal-warnings
2540         ;;
2541   sparc*-*-*)
2542     case "$target" in
2543       sparc*-sun-solaris2.[56789]*)
2544         # TLS was introduced in the Solaris 9 4/04 release but
2545         # we do not enable it by default on Solaris 9 either.
2546         if test "x$enable_tls" = xyes ; then
2547           on_solaris=yes
2548         else
2549           enable_tls=no;
2550         fi
2551         ;;
2552       sparc*-sun-solaris2.*)
2553         on_solaris=yes
2554         ;;
2555       *)
2556         on_solaris=no
2557         ;;
2558     esac
2559     if test x$on_solaris = xyes && test x$gas_flag = xno; then
2560       conftest_s='
2561         .section ".tdata",#alloc,#write,#tls
2562 foo:    .long   25
2563         .text
2564         sethi   %tgd_hi22(foo), %o0
2565         add     %o0, %tgd_lo10(foo), %o1
2566         add     %l7, %o1, %o0, %tgd_add(foo)
2567         call    __tls_get_addr, %tgd_call(foo)
2568         sethi   %tldm_hi22(foo), %l1
2569         add     %l1, %tldm_lo10(foo), %l2
2570         add     %l7, %l2, %o0, %tldm_add(foo)
2571         call    __tls_get_addr, %tldm_call(foo)
2572         sethi   %tldo_hix22(foo), %l3
2573         xor     %l3, %tldo_lox10(foo), %l4
2574         add     %o0, %l4, %l5, %tldo_add(foo)
2575         sethi   %tie_hi22(foo), %o3
2576         add     %o3, %tie_lo10(foo), %o3
2577         ld      [%l7 + %o3], %o2, %tie_ld(foo)
2578         add     %g7, %o2, %o4, %tie_add(foo)
2579         sethi   %tle_hix22(foo), %l1
2580         xor     %l1, %tle_lox10(foo), %o5
2581         ld      [%g7 + %o5], %o1'
2582         tls_first_major=0
2583         tls_first_minor=0
2584     else
2585       conftest_s='
2586         .section ".tdata","awT",@progbits
2587 foo:    .long   25
2588         .text
2589         sethi   %tgd_hi22(foo), %o0
2590         add     %o0, %tgd_lo10(foo), %o1
2591         add     %l7, %o1, %o0, %tgd_add(foo)
2592         call    __tls_get_addr, %tgd_call(foo)
2593         sethi   %tldm_hi22(foo), %l1
2594         add     %l1, %tldm_lo10(foo), %l2
2595         add     %l7, %l2, %o0, %tldm_add(foo)
2596         call    __tls_get_addr, %tldm_call(foo)
2597         sethi   %tldo_hix22(foo), %l3
2598         xor     %l3, %tldo_lox10(foo), %l4
2599         add     %o0, %l4, %l5, %tldo_add(foo)
2600         sethi   %tie_hi22(foo), %o3
2601         add     %o3, %tie_lo10(foo), %o3
2602         ld      [%l7 + %o3], %o2, %tie_ld(foo)
2603         add     %g7, %o2, %o4, %tie_add(foo)
2604         sethi   %tle_hix22(foo), %l1
2605         xor     %l1, %tle_lox10(foo), %o5
2606         ld      [%g7 + %o5], %o1'
2607         tls_first_major=2
2608         tls_first_minor=14
2609         tls_as_opt="-32 --fatal-warnings"
2610       fi
2611         ;;
2612 changequote([,])dnl
2613 esac
2614 set_have_as_tls=no
2615 if test "x$enable_tls" = xno ; then
2616   : # TLS explicitly disabled.
2617 elif test "x$enable_tls" = xyes ; then
2618   set_have_as_tls=yes # TLS explicitly enabled.
2619 elif test -z "$tls_first_major"; then
2620   : # If we don't have a check, assume no support.
2621 else
2622   gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
2623   [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
2624   [set_have_as_tls=yes])
2625 fi
2626 if test $set_have_as_tls = yes ; then
2627   AC_DEFINE(HAVE_AS_TLS, 1,
2628             [Define if your assembler supports thread-local storage.])
2629 fi
2630
2631 # Target-specific assembler checks.
2632
2633 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
2634 gcc_cv_ld_static_dynamic=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 10; then
2637     gcc_cv_ld_static_dynamic=yes
2638   fi
2639 elif test x$gcc_cv_ld != x; then
2640         # Check if linker supports -Bstatic/-Bdynamic option
2641         if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
2642           && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
2643                 gcc_cv_ld_static_dynamic=yes
2644         fi
2645 fi
2646 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
2647         AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
2648 [Define if your linker supports -Bstatic/-Bdynamic option.])
2649 fi
2650 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
2651
2652 if test x"$demangler_in_ld" = xyes; then
2653   AC_MSG_CHECKING(linker --demangle support)
2654   gcc_cv_ld_demangle=no
2655   if test $in_tree_ld = yes; then
2656     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 \
2657       gcc_cv_ld_demangle=yes
2658     fi
2659   elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
2660     # Check if the GNU linker supports --demangle option
2661     if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
2662       gcc_cv_ld_demangle=yes
2663     fi
2664   fi
2665   if test x"$gcc_cv_ld_demangle" = xyes; then
2666     AC_DEFINE(HAVE_LD_DEMANGLE, 1,
2667 [Define if your linker supports --demangle option.])
2668   fi
2669   AC_MSG_RESULT($gcc_cv_ld_demangle)
2670 fi
2671
2672 case "$target" in
2673   # All TARGET_ABI_OSF targets.
2674   alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
2675     gcc_GAS_CHECK_FEATURE([explicit relocation support],
2676         gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
2677 [       .set nomacro
2678         .text
2679         extbl   $3, $2, $3      !lituse_bytoff!1
2680         ldq     $2, a($29)      !literal!1
2681         ldq     $4, b($29)      !literal!2
2682         ldq_u   $3, 0($2)       !lituse_base!1
2683         ldq     $27, f($29)     !literal!5
2684         jsr     $26, ($27), f   !lituse_jsr!5
2685         ldah    $29, 0($26)     !gpdisp!3
2686         lda     $0, c($29)      !gprel
2687         ldah    $1, d($29)      !gprelhigh
2688         lda     $1, d($1)       !gprellow
2689         lda     $29, 0($29)     !gpdisp!3],,
2690     [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
2691   [Define if your assembler supports explicit relocations.])])
2692     gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
2693         gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
2694 [       .set nomacro
2695         .text
2696         ldq     $27, a($29)     !literal!1
2697         jsr     $26, ($27), a   !lituse_jsrdirect!1],,
2698     [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
2699   [Define if your assembler supports the lituse_jsrdirect relocation.])])
2700     ;;
2701
2702   cris-*-*)
2703     gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
2704       gcc_cv_as_cris_no_mul_bug,[2,15,91],
2705       [-no-mul-bug-abort], [.text],,
2706       [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
2707                 [Define if your assembler supports the -no-mul-bug-abort option.])])
2708     ;;
2709
2710   sparc*-*-*)
2711     gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
2712       [.register %g2, #scratch],,
2713       [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
2714                 [Define if your assembler supports .register.])])
2715
2716     gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
2717       [-relax], [.text],,
2718       [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
2719                 [Define if your assembler supports -relax option.])])
2720
2721     gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
2722       gcc_cv_as_sparc_ua_pcrel,,
2723       [-K PIC],
2724 [.text
2725 foo:
2726         nop
2727 .data
2728 .align 4
2729 .byte 0
2730 .uaword %r_disp32(foo)],
2731       [if test x$gcc_cv_ld != x \
2732        && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
2733          gcc_cv_as_sparc_ua_pcrel=yes
2734        fi
2735        rm -f conftest],
2736       [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
2737                 [Define if your assembler and linker support unaligned PC relative relocs.])
2738
2739       gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
2740         gcc_cv_as_sparc_ua_pcrel_hidden,,
2741         [-K PIC],
2742 [.data
2743 .align 4
2744 .byte 0x31
2745 .uaword %r_disp32(foo)
2746 .byte 0x32, 0x33, 0x34
2747 .global foo
2748 .hidden foo
2749 foo:
2750 .skip 4],
2751         [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
2752          && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
2753          && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
2754             | grep ' 31000000 07323334' > /dev/null 2>&1; then
2755             if $gcc_cv_objdump -R conftest 2> /dev/null \
2756                | grep 'DISP32' > /dev/null 2>&1; then
2757                 :
2758             else
2759                 gcc_cv_as_sparc_ua_pcrel_hidden=yes
2760             fi
2761          fi
2762          rm -f conftest],
2763          [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
2764                    [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
2765     ]) # unaligned pcrel relocs
2766
2767     gcc_GAS_CHECK_FEATURE([offsetable %lo()],
2768       gcc_cv_as_sparc_offsetable_lo10,,
2769       [-xarch=v9],
2770 [.text
2771         or %g1, %lo(ab) + 12, %g1
2772         or %g1, %lo(ab + 12), %g1],
2773       [if test x$gcc_cv_objdump != x \
2774        && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
2775           | grep ' 82106000 82106000' > /dev/null 2>&1; then
2776          gcc_cv_as_sparc_offsetable_lo10=yes
2777        fi],
2778        [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
2779                  [Define if your assembler supports offsetable %lo().])])
2780     ;;
2781
2782 changequote(,)dnl
2783   i[34567]86-*-* | x86_64-*-*)
2784 changequote([,])dnl
2785     case $target_os in
2786       cygwin* | pe | mingw32*)
2787         # Used for DWARF 2 in PE
2788         gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
2789           gcc_cv_as_ix86_pe_secrel32,
2790           [2,15,91],,
2791 [.text
2792 foo:    nop
2793 .data
2794         .secrel32 foo],
2795           [if test x$gcc_cv_ld != x \
2796            && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
2797              gcc_cv_as_ix86_pe_secrel32=yes
2798            fi
2799            rm -f conftest],
2800           [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
2801             [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
2802         ;;
2803     esac
2804
2805     gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
2806        gcc_cv_as_ix86_filds_fists,
2807       [2,9,0],, [filds mem; fists mem],,
2808       [AC_DEFINE(HAVE_GAS_FILDS_FISTS, 1,
2809         [Define if your assembler uses the new HImode fild and fist notation.])])
2810
2811     gcc_GAS_CHECK_FEATURE([cmov syntax],
2812       gcc_cv_as_ix86_cmov_sun_syntax,,,
2813       [cmovl.l %edx, %eax],,
2814       [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
2815         [Define if your assembler supports the Sun syntax for cmov.])])
2816
2817     gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
2818       gcc_cv_as_ix86_ffreep,,,
2819       [ffreep %st(1)],,
2820       [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
2821         [Define if your assembler supports the ffreep mnemonic.])])
2822
2823     gcc_GAS_CHECK_FEATURE([sahf mnemonic],
2824       gcc_cv_as_ix86_sahf,,,
2825       [sahf],,
2826       [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
2827         [Define if your assembler supports the sahf mnemonic.])])
2828
2829     gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
2830       gcc_cv_as_ix86_diff_sect_delta,,,
2831       [.section .rodata
2832 .L1:
2833         .long .L2-.L1
2834         .long .L3-.L1
2835         .text
2836 .L3:    nop
2837 .L2:    nop],,
2838       [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
2839         [Define if your assembler supports the subtraction of symbols in different sections.])])
2840
2841     # This one is used unconditionally by i386.[ch]; it is to be defined
2842     # to 1 if the feature is present, 0 otherwise.
2843     gcc_GAS_CHECK_FEATURE([GOTOFF in data],
2844         gcc_cv_as_ix86_gotoff_in_data, [2,11,0],,
2845 [       .text
2846 .L0:
2847         nop
2848         .data
2849         .long .L0@GOTOFF])
2850     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
2851       [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
2852       [Define true if the assembler supports '.long foo@GOTOFF'.])
2853     ;;
2854
2855   ia64*-*-*)
2856     gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
2857         gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
2858 [       .text
2859         addl r15 = @ltoffx(x#), gp
2860         ;;
2861         ld8.mov r16 = [[r15]], x#],,
2862     [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
2863           [Define if your assembler supports ltoffx and ldxmov relocations.])])
2864
2865     ;;
2866
2867   powerpc*-*-*)
2868     case $target in
2869       *-*-aix*) conftest_s='    .machine "pwr5"
2870         .csect .text[[PR]]
2871         mfcr 3,128';;
2872       *-*-darwin*)
2873         gcc_GAS_CHECK_FEATURE([.machine directive support],
2874           gcc_cv_as_machine_directive,,,
2875           [     .machine ppc7400])
2876         if test x$gcc_cv_as_machine_directive != xyes; then
2877           echo "*** This target requires an assembler supporting \".machine\"" >&2
2878           echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
2879           test x$build = x$target && exit 1
2880         fi
2881         conftest_s='    .text
2882         mfcr r3,128';;
2883       *) conftest_s='   .machine power4
2884         .text
2885         mfcr 3,128';;
2886     esac
2887
2888     gcc_GAS_CHECK_FEATURE([mfcr field support],
2889       gcc_cv_as_powerpc_mfcrf, [2,14,0],,
2890       [$conftest_s],,
2891       [AC_DEFINE(HAVE_AS_MFCRF, 1,
2892           [Define if your assembler supports mfcr field.])])
2893
2894     case $target in
2895       *-*-aix*) conftest_s='    .machine "pwr5"
2896         .csect .text[[PR]]
2897         popcntb 3,3';;
2898       *) conftest_s='   .machine power5
2899         .text
2900         popcntb 3,3';;
2901     esac
2902
2903     gcc_GAS_CHECK_FEATURE([popcntb support],
2904       gcc_cv_as_powerpc_popcntb, [2,17,0],,
2905       [$conftest_s],,
2906       [AC_DEFINE(HAVE_AS_POPCNTB, 1,
2907           [Define if your assembler supports popcntb field.])])
2908
2909     case $target in
2910       *-*-aix*) conftest_s='    .machine "pwr5x"
2911         .csect .text[[PR]]
2912         frin 1,1';;
2913       *) conftest_s='   .machine power5
2914         .text
2915         frin 1,1';;
2916     esac
2917
2918     gcc_GAS_CHECK_FEATURE([fp round support],
2919       gcc_cv_as_powerpc_fprnd, [2,17,0],,
2920       [$conftest_s],,
2921       [AC_DEFINE(HAVE_AS_FPRND, 1,
2922           [Define if your assembler supports fprnd.])])
2923
2924     case $target in
2925       *-*-aix*) conftest_s='    .machine "pwr6"
2926         .csect .text[[PR]]
2927         mffgpr 1,3';;
2928       *) conftest_s='   .machine power6
2929         .text
2930         mffgpr 1,3';;
2931     esac
2932
2933     gcc_GAS_CHECK_FEATURE([move fp gpr support],
2934       gcc_cv_as_powerpc_mfpgpr, [9,99,0],,
2935       [$conftest_s],,
2936       [AC_DEFINE(HAVE_AS_MFPGPR, 1,
2937           [Define if your assembler supports mffgpr and mftgpr.])])
2938
2939     case $target in
2940       *-*-aix*) conftest_s='    .csect .text[[PR]]
2941 LCF..0:
2942         addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
2943       *-*-darwin*)
2944         conftest_s='    .text
2945 LCF0:
2946         addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
2947       *) conftest_s='   .text
2948 .LCF0:
2949         addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
2950     esac
2951
2952     gcc_GAS_CHECK_FEATURE([rel16 relocs],
2953       gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
2954       [$conftest_s],,
2955       [AC_DEFINE(HAVE_AS_REL16, 1,
2956           [Define if your assembler supports R_PPC_REL16 relocs.])])
2957
2958     case $target in
2959       *-*-aix*) conftest_s='    .machine "pwr6"
2960         .csect .text[[PR]]
2961         cmpb 3,4,5';;
2962       *) conftest_s='   .machine power6
2963         .text
2964         cmpb 3,4,5';;
2965     esac
2966
2967     gcc_GAS_CHECK_FEATURE([compare bytes support],
2968       gcc_cv_as_powerpc_cmpb, [9,99,0], -a32,
2969       [$conftest_s],,
2970       [AC_DEFINE(HAVE_AS_CMPB, 1,
2971           [Define if your assembler supports cmpb.])])
2972
2973     case $target in
2974       *-*-aix*) conftest_s='    .machine "pwr6"
2975         .csect .text[[PR]]
2976         dadd 1,2,3';;
2977       *) conftest_s='   .machine power6
2978         .text
2979         dadd 1,2,3';;
2980     esac
2981
2982     gcc_GAS_CHECK_FEATURE([decimal float support],
2983       gcc_cv_as_powerpc_dfp, [9,99,0], -a32,
2984       [$conftest_s],,
2985       [AC_DEFINE(HAVE_AS_DFP, 1,
2986           [Define if your assembler supports DFP instructions.])])
2987
2988     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
2989       gcc_cv_as_powerpc_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
2995   mips*-*-*)
2996     gcc_GAS_CHECK_FEATURE([explicit relocation support],
2997       gcc_cv_as_mips_explicit_relocs, [2,14,0],,
2998 [       lw $4,%gp_rel(foo)($4)],,
2999       [if test x$target_cpu_default = x
3000        then target_cpu_default=MASK_EXPLICIT_RELOCS
3001        else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
3002        fi])
3003     gcc_GAS_CHECK_FEATURE([-mno-shared support],
3004       gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
3005       [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
3006                  [Define if the assembler understands -mno-shared.])])
3007
3008     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3009       gcc_cv_as_mips_gnu_attribute, [2,18,0],,
3010       [.gnu_attribute 4,1],,
3011       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3012           [Define if your assembler supports .gnu_attribute.])])
3013
3014     gcc_GAS_CHECK_FEATURE([.dtprelword support],
3015       gcc_cv_as_mips_dtprelword, [2,18,0],,
3016       [.section .tdata,"awT",@progbits
3017 x:
3018         .word 2
3019         .text
3020         .dtprelword x+0x8000],,
3021       [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
3022           [Define if your assembler supports .dtprelword.])])
3023     ;;
3024 esac
3025
3026 # Mips and HP-UX need the GNU assembler.
3027 # Linux on IA64 might be able to use the Intel assembler.
3028
3029 case "$target" in
3030   mips*-*-* | *-*-hpux* )
3031     if test x$gas_flag = xyes \
3032        || test x"$host" != x"$build" \
3033        || test ! -x "$gcc_cv_as" \
3034        || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
3035       :
3036     else
3037       echo "*** This configuration requires the GNU assembler" >&2
3038       exit 1
3039     fi
3040     ;;
3041 esac
3042
3043 # ??? Not all targets support dwarf2 debug_line, even within a version
3044 # of gas.  Moreover, we need to emit a valid instruction to trigger any
3045 # info to the output file.  So, as supported targets are added to gas 2.11,
3046 # add some instruction here to (also) show we expect this might work.
3047 # ??? Once 2.11 is released, probably need to add first known working
3048 # version to the per-target configury.
3049 case "$target" in
3050   i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* \
3051   | x86_64*-*-* | hppa*-*-* | arm*-*-* | strongarm*-*-* | xscale*-*-* \
3052   | xstormy16*-*-* | cris-*-* | xtensa-*-* | bfin-*-* | score*-*-* | spu-*-*)
3053     insn="nop"
3054     ;;
3055   ia64*-*-* | s390*-*-*)
3056     insn="nop 0"
3057     ;;
3058   mmix-*-*)
3059     insn="swym 0"
3060     ;;
3061 esac
3062 if test x"$insn" != x; then
3063  conftest_s="\
3064         .file 1 \"conftest.s\"
3065         .loc 1 3 0
3066         $insn"
3067  gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
3068   gcc_cv_as_dwarf2_debug_line,
3069   [elf,2,11,0],, [$conftest_s],
3070   [if test x$gcc_cv_objdump != x \
3071    && $gcc_cv_objdump -h conftest.o 2> /dev/null \
3072       | grep debug_line > /dev/null 2>&1; then
3073      gcc_cv_as_dwarf2_debug_line=yes
3074    fi])
3075
3076 # The .debug_line file table must be in the exact order that
3077 # we specified the files, since these indices are also used
3078 # by DW_AT_decl_file.  Approximate this test by testing if
3079 # the assembler bitches if the same index is assigned twice.
3080  gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
3081   gcc_cv_as_dwarf2_file_buggy,,,
3082 [       .file 1 "foo.s"
3083         .file 1 "bar.s"])
3084
3085  if test $gcc_cv_as_dwarf2_debug_line = yes \
3086  && test $gcc_cv_as_dwarf2_file_buggy = no; then
3087         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
3088   [Define if your assembler supports dwarf2 .file/.loc directives,
3089    and preserves file table indices exactly as given.])
3090  fi
3091
3092  gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
3093   gcc_cv_as_gdwarf2_flag,
3094   [elf,2,11,0], [--gdwarf2], [$insn],,
3095   [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
3096 [Define if your assembler supports the --gdwarf2 option.])])
3097
3098  gcc_GAS_CHECK_FEATURE([--gstabs option],
3099   gcc_cv_as_gstabs_flag,
3100   [elf,2,11,0], [--gstabs], [$insn],
3101   [# The native Solaris 9/Intel assembler doesn't understand --gstabs
3102    # and warns about it, but still exits successfully.  So check for
3103    # this.
3104    if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
3105    then :
3106    else gcc_cv_as_gstabs_flag=yes
3107    fi],
3108   [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
3109 [Define if your assembler supports the --gstabs option.])])
3110
3111  gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
3112   gcc_cv_as_debug_prefix_map_flag,
3113   [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
3114   [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
3115 [Define if your assembler supports the --debug-prefix-map option.])])
3116 fi
3117
3118 AC_CACHE_CHECK([assembler for tolerance to line number 0],
3119  [gcc_cv_as_line_zero],
3120  [gcc_cv_as_line_zero=no
3121   if test $in_tree_gas = yes; then
3122     gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
3123   elif test "x$gcc_cv_as" != x; then
3124     { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
3125     if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
3126        test "x`cat conftest.out`" = x
3127     then
3128       gcc_cv_as_line_zero=yes
3129     else
3130       echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
3131       cat conftest.s >&AS_MESSAGE_LOG_FD
3132       echo "configure: error output was" >&AS_MESSAGE_LOG_FD
3133       cat conftest.out >&AS_MESSAGE_LOG_FD
3134     fi
3135     rm -f conftest.o conftest.s conftest.out
3136   fi])
3137 if test "x$gcc_cv_as_line_zero" = xyes; then
3138   AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
3139 [Define if the assembler won't complain about a line such as # 0 "" 2.])
3140 fi
3141
3142 AC_MSG_CHECKING(linker read-only and read-write section mixing)
3143 gcc_cv_ld_ro_rw_mix=unknown
3144 if test $in_tree_ld = yes ; then
3145   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 \
3146      && test $in_tree_ld_is_elf = yes; then
3147     gcc_cv_ld_ro_rw_mix=read-write
3148   fi
3149 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
3150   echo '.section myfoosect, "a"' > conftest1.s
3151   echo '.section myfoosect, "aw"' > conftest2.s
3152   echo '.byte 1' >> conftest2.s
3153   echo '.section myfoosect, "a"' > conftest3.s
3154   echo '.byte 0' >> conftest3.s
3155   if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
3156      && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
3157      && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
3158      && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
3159         conftest2.o conftest3.o > /dev/null 2>&1; then
3160     gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
3161                          | sed -e '/myfoosect/!d' -e N`
3162     if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
3163       if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
3164         gcc_cv_ld_ro_rw_mix=read-only
3165       else
3166         gcc_cv_ld_ro_rw_mix=read-write
3167       fi
3168     fi
3169   fi
3170 changequote(,)dnl
3171   rm -f conftest.* conftest[123].*
3172 changequote([,])dnl
3173 fi
3174 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
3175         AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
3176   [Define if your linker links a mix of read-only
3177    and read-write sections into a read-write section.])
3178 fi
3179 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
3180
3181 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
3182 gcc_cv_ld_eh_frame_hdr=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 12 -o "$gcc_cv_gld_major_version" -gt 2 \
3185      && test $in_tree_ld_is_elf = yes; then
3186     gcc_cv_ld_eh_frame_hdr=yes
3187   fi
3188 elif test x$gcc_cv_ld != x; then
3189         # Check if linker supports --eh-frame-hdr option
3190         if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
3191                 gcc_cv_ld_eh_frame_hdr=yes
3192         fi
3193 fi
3194 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
3195 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
3196         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
3197 [Define if your linker supports --eh-frame-hdr option.])
3198 fi
3199 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
3200
3201 AC_MSG_CHECKING(linker position independent executable support)
3202 gcc_cv_ld_pie=no
3203 if test $in_tree_ld = yes ; then
3204   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 \
3205      && test $in_tree_ld_is_elf = yes; then
3206     gcc_cv_ld_pie=yes
3207   fi
3208 elif test x$gcc_cv_ld != x; then
3209         # Check if linker supports -pie option
3210         if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
3211                 gcc_cv_ld_pie=yes
3212         fi
3213 fi
3214 if test x"$gcc_cv_ld_pie" = xyes; then
3215         AC_DEFINE(HAVE_LD_PIE, 1,
3216 [Define if your linker supports -pie option.])
3217 fi
3218 AC_MSG_RESULT($gcc_cv_ld_pie)
3219
3220 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
3221 gcc_cv_ld_eh_gc_sections=no
3222 if test $in_tree_ld = yes ; then
3223   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 \
3224      && test $in_tree_ld_is_elf = yes; then
3225     gcc_cv_ld_eh_gc_sections=yes
3226   fi
3227 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
3228   cat > conftest.s <<EOF
3229         .section        .text
3230 .globl _start
3231         .type _start, @function
3232 _start:
3233         .long foo
3234         .size _start, .-_start
3235         .section        .text.foo,"ax",@progbits
3236         .type foo, @function
3237 foo:
3238         .long 0
3239         .size foo, .-foo
3240         .section        .gcc_except_table.foo,"a",@progbits
3241 .L0:
3242         .long 0
3243         .section        .eh_frame,"a",@progbits
3244         .long .L0
3245 EOF
3246   if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
3247     if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
3248          | grep "gc-sections option ignored" > /dev/null; then
3249       gcc_cv_ld_eh_gc_sections=no
3250     elif $gcc_cv_objdump -h conftest | grep gcc_except_table > /dev/null; then
3251       gcc_cv_ld_eh_gc_sections=yes
3252       # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
3253       if test x$gcc_cv_as_comdat_group != xyes; then
3254         gcc_cv_ld_eh_gc_sections=no
3255         cat > conftest.s <<EOF
3256         .section        .text
3257 .globl _start
3258         .type _start, @function
3259 _start:
3260         .long foo
3261         .size _start, .-_start
3262         .section        .gnu.linkonce.t.foo,"ax",@progbits
3263         .type foo, @function
3264 foo:
3265         .long 0
3266         .size foo, .-foo
3267         .section        .gcc_except_table.foo,"a",@progbits
3268 .L0:
3269         .long 0
3270         .section        .eh_frame,"a",@progbits
3271         .long .L0
3272 EOF
3273         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
3274           if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
3275                | grep "gc-sections option ignored" > /dev/null; then
3276             gcc_cv_ld_eh_gc_sections=no
3277           elif $gcc_cv_objdump -h conftest | grep gcc_except_table > /dev/null; then
3278             gcc_cv_ld_eh_gc_sections=yes
3279           fi
3280         fi
3281       fi
3282     fi
3283   fi
3284   rm -f conftest.s conftest.o conftest
3285 fi
3286 case "$target" in
3287   hppa*-*-linux*)
3288     # ??? This apparently exposes a binutils bug with PC-relative relocations.
3289     gcc_cv_ld_eh_gc_sections=no
3290     ;;
3291 esac
3292 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
3293         AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
3294   [Define if your linker supports garbage collection of
3295    sections in presence of EH frames.])
3296 fi
3297 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
3298
3299 # --------
3300 # UNSORTED
3301 # --------
3302
3303 AC_CACHE_CHECK(linker --as-needed support,
3304 gcc_cv_ld_as_needed,
3305 [gcc_cv_ld_as_needed=no
3306 if test $in_tree_ld = yes ; then
3307   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 \
3308      && test $in_tree_ld_is_elf = yes; then
3309     gcc_cv_ld_as_needed=yes
3310   fi
3311 elif test x$gcc_cv_ld != x; then
3312         # Check if linker supports --as-needed and --no-as-needed options
3313         if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
3314                 gcc_cv_ld_as_needed=yes
3315         fi
3316 fi
3317 ])
3318 if test x"$gcc_cv_ld_as_needed" = xyes; then
3319         AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
3320 [Define if your linker supports --as-needed and --no-as-needed options.])
3321 fi
3322
3323 case "$target:$tm_file" in
3324   powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
3325     AC_CACHE_CHECK(linker support for omitting dot symbols,
3326     gcc_cv_ld_no_dot_syms,
3327     [gcc_cv_ld_no_dot_syms=no
3328     if test $in_tree_ld = yes ; then
3329       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
3330         gcc_cv_ld_no_dot_syms=yes
3331       fi
3332     elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
3333       cat > conftest1.s <<EOF
3334         .text
3335         bl .foo
3336 EOF
3337       cat > conftest2.s <<EOF
3338         .section ".opd","aw"
3339         .align 3
3340         .globl foo
3341         .type foo,@function
3342 foo:
3343         .quad .LEfoo,.TOC.@tocbase,0
3344         .text
3345 .LEfoo:
3346         blr
3347         .size foo,.-.LEfoo
3348 EOF
3349       if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
3350          && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
3351          && $gcc_cv_ld -melf64ppc -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
3352         gcc_cv_ld_no_dot_syms=yes
3353       fi
3354       rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
3355     fi
3356     ])
3357     if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
3358       AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
3359     [Define if your PowerPC64 linker only needs function descriptor syms.])
3360     fi
3361     ;;
3362 esac
3363
3364 AC_CACHE_CHECK(linker --sysroot support,
3365   gcc_cv_ld_sysroot,
3366   [gcc_cv_ld_sysroot=no
3367   if test $in_tree_ld = yes ; then
3368       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
3369         gcc_cv_ld_sysroot=yes
3370       fi
3371   elif test x$gcc_cv_ld != x; then
3372     if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
3373       gcc_cv_ld_sysroot=yes
3374     fi
3375   fi])
3376 if test x"$gcc_cv_ld_sysroot" = xyes; then
3377   AC_DEFINE(HAVE_LD_SYSROOT, 1,
3378   [Define if your linker supports --sysroot.])
3379 fi
3380
3381 if test x$with_sysroot = x && test x$host = x$target \
3382    && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
3383    && test "$prefix" != "NONE"; then
3384   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
3385 [Define to PREFIX/include if cpp should also search that directory.])
3386 fi
3387
3388 # Test for stack protector support in target C library.
3389 AC_CACHE_CHECK(__stack_chk_fail in target C library,
3390       gcc_cv_libc_provides_ssp,
3391       [gcc_cv_libc_provides_ssp=no
3392     case "$target" in
3393        *-*-linux*)
3394       if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
3395         if test "x$with_sysroot" = x; then
3396           glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-include"
3397         elif test "x$with_build_sysroot" != "x"; then
3398           glibc_header_dir="${with_build_sysroot}/usr/include"
3399         elif test "x$with_sysroot" = xyes; then
3400           glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-root/usr/include"
3401         else
3402           glibc_header_dir="${with_sysroot}/usr/include"
3403         fi
3404       else
3405         glibc_header_dir=/usr/include
3406       fi
3407       # glibc 2.4 and later provides __stack_chk_fail and
3408       # either __stack_chk_guard, or TLS access to stack guard canary.
3409       if test -f $glibc_header_dir/features.h \
3410          && $EGREP '^@<:@       @:>@*#[         ]*define[       ]+__GNU_LIBRARY__[      ]+([1-9][0-9]|[6-9])' \
3411             $glibc_header_dir/features.h > /dev/null; then
3412         if $EGREP '^@<:@        @:>@*#[         ]*define[       ]+__GLIBC__[    ]+([1-9][0-9]|[3-9])' \
3413            $glibc_header_dir/features.h > /dev/null; then
3414           gcc_cv_libc_provides_ssp=yes
3415         elif $EGREP '^@<:@      @:>@*#[         ]*define[       ]+__GLIBC__[    ]+2' \
3416              $glibc_header_dir/features.h > /dev/null \
3417              && $EGREP '^@<:@   @:>@*#[         ]*define[       ]+__GLIBC_MINOR__[      ]+([1-9][0-9]|[4-9])' \
3418              $glibc_header_dir/features.h > /dev/null; then
3419           gcc_cv_libc_provides_ssp=yes
3420         elif $EGREP '^@<:@      @:>@*#[         ]*define[       ]+__UCLIBC__[   ]+1' \
3421              $glibc_header_dir/features.h > /dev/null && \
3422              test -f $glibc_header_dir/bits/uClibc_config.h && \
3423              $EGREP '^@<:@      @:>@*#[         ]*define[       ]+__UCLIBC_HAS_SSP__[   ]+1' \
3424              $glibc_header_dir/bits/uClibc_config.h > /dev/null; then
3425           gcc_cv_libc_provides_ssp=yes
3426         fi
3427       fi
3428         ;;
3429        *-*-darwin*)
3430          AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
3431            [echo "no __stack_chk_fail on this target"])
3432         ;;
3433   *) gcc_cv_libc_provides_ssp=no ;;
3434     esac])
3435
3436 if test x$gcc_cv_libc_provides_ssp = xyes; then
3437   AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
3438             [Define if your target C library provides stack protector support])
3439 fi
3440
3441 # Check if TFmode long double should be used by default or not.
3442 # Some glibc targets used DFmode long double, but with glibc 2.4
3443 # and later they can use TFmode.
3444 case "$target" in
3445   powerpc*-*-linux* | \
3446   powerpc*-*-gnu* | \
3447   sparc*-*-linux* | \
3448   s390*-*-linux* | \
3449   alpha*-*-linux*)
3450     AC_ARG_WITH(long-double-128,
3451 [  --with-long-double-128  Use 128-bit long double by default.],
3452       gcc_cv_target_ldbl128="$with_long_double_128",
3453       [gcc_cv_target_ldbl128=no
3454       if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
3455         if test "x$with_sysroot" = x; then
3456           glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-include"
3457         elif test "x$with_build_sysroot" != "x"; then
3458           glibc_header_dir="${with_build_sysroot}/usr/include"
3459         elif test "x$with_sysroot" = xyes; then
3460           glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-root/usr/include"
3461         else
3462           glibc_header_dir="${with_sysroot}/usr/include"
3463         fi
3464       else
3465         glibc_header_dir=/usr/include
3466       fi
3467 changequote(,)dnl
3468       grep '^[  ]*#[    ]*define[       ][      ]*__LONG_DOUBLE_MATH_OPTIONAL' \
3469         $glibc_header_dir/bits/wordsize.h > /dev/null 2>&1 \
3470       && gcc_cv_target_ldbl128=yes
3471 changequote([,])dnl
3472       ])
3473     ;;
3474 esac
3475 if test x$gcc_cv_target_ldbl128 = xyes; then
3476   AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
3477             [Define if TFmode long double should be the default])
3478 fi
3479
3480 # Find out what GC implementation we want, or may, use.
3481 AC_ARG_WITH(gc,
3482 [  --with-gc={page,zone}   choose the garbage collection mechanism to use
3483                           with the compiler],
3484 [case "$withval" in
3485   page)
3486     GGC=ggc-$withval
3487     ;;
3488   zone)
3489     GGC=ggc-$withval
3490     AC_DEFINE(GGC_ZONE, 1, [Define if the zone collector is in use])
3491     ;;
3492   *)
3493     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
3494     ;;
3495 esac],
3496 [GGC=ggc-page])
3497 AC_SUBST(GGC)
3498 echo "Using $GGC for garbage collection."
3499
3500 # Use the system's zlib library.
3501 zlibdir=-L../zlib
3502 zlibinc="-I\$(srcdir)/../zlib"
3503 AC_ARG_WITH(system-zlib,
3504 [  --with-system-zlib      use installed libz],
3505 zlibdir=
3506 zlibinc=
3507 )
3508 AC_SUBST(zlibdir)
3509 AC_SUBST(zlibinc)
3510
3511 dnl Very limited version of automake's enable-maintainer-mode
3512
3513 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
3514   dnl maintainer-mode is disabled by default
3515   AC_ARG_ENABLE(maintainer-mode,
3516 [  --enable-maintainer-mode
3517                           enable make rules and dependencies not useful
3518                           (and sometimes confusing) to the casual installer],
3519       maintainer_mode=$enableval,
3520       maintainer_mode=no)
3521
3522 AC_MSG_RESULT($maintainer_mode)
3523
3524 if test "$maintainer_mode" = "yes"; then
3525   MAINT=''
3526 else
3527   MAINT='#'
3528 fi
3529 AC_SUBST(MAINT)dnl
3530
3531 # --------------
3532 # Language hooks
3533 # --------------
3534
3535 # Make empty files to contain the specs and options for each language.
3536 # Then add #include lines to for a compiler that has specs and/or options.
3537
3538 subdirs=
3539 lang_opt_files=
3540 lang_specs_files=
3541 lang_tree_files=
3542 # These (without "all_") are set in each config-lang.in.
3543 # `language' must be a single word so is spelled singularly.
3544 all_languages=
3545 all_compilers=
3546 all_outputs='Makefile gccbug libada-mk'
3547 # List of language makefile fragments.
3548 all_lang_makefrags=
3549 # List of language subdirectory makefiles.  Deprecated.
3550 all_lang_makefiles=
3551 # Additional files for gengtype
3552 all_gtfiles="$target_gtfiles"
3553
3554 # These are the languages that are set in --enable-languages,
3555 # and are available in the GCC tree.
3556 all_selected_languages=
3557
3558 # Add the language fragments.
3559 # Languages are added via two mechanisms.  Some information must be
3560 # recorded in makefile variables, these are defined in config-lang.in.
3561 # We accumulate them and plug them into the main Makefile.
3562 # The other mechanism is a set of hooks for each of the main targets
3563 # like `clean', `install', etc.
3564
3565 language_hooks="Make-hooks"
3566
3567 for lang in ${srcdir}/*/config-lang.in
3568 do
3569 changequote(,)dnl
3570         test "$lang" = "${srcdir}/*/config-lang.in" && continue
3571
3572         lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
3573         if test "x$lang_alias" = x
3574         then
3575               echo "$lang doesn't set \$language." 1>&2
3576               exit 1
3577         fi
3578         subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
3579         subdirs="$subdirs $subdir"
3580         case ",$enable_languages," in
3581         *,$lang_alias,*)
3582             all_selected_languages="$all_selected_languages $lang_alias"
3583             if test -f $srcdir/$subdir/lang-specs.h; then
3584                 lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
3585             fi
3586             ;;
3587         esac
3588 changequote([,])dnl
3589
3590         language=
3591         boot_language=
3592         compilers=
3593         outputs=
3594         gtfiles=
3595         subdir_requires=
3596         . ${srcdir}/$subdir/config-lang.in
3597         if test "x$language" = x
3598         then
3599                 echo "${srcdir}/$subdir/config-lang.in doesn't set \$language." 1>&2
3600                 exit 1
3601         fi
3602
3603         ok=:
3604         case ",$enable_languages," in
3605                 *,$lang_alias,*) ;;
3606                 *)
3607                         for i in $subdir_requires; do
3608                                 test -f "${srcdir}/$i/config-lang.in" && continue
3609                                 ok=false
3610                                 break
3611                         done
3612                 ;;
3613         esac
3614         $ok || continue
3615
3616         all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$subdir/Make-lang.in"
3617         if test -f $srcdir/$subdir/lang.opt; then
3618             lang_opt_files="$lang_opt_files $srcdir/$subdir/lang.opt"
3619         fi
3620         if test -f $srcdir/$subdir/$subdir-tree.def; then
3621             lang_tree_files="$lang_tree_files $srcdir/$subdir/$subdir-tree.def"
3622         fi
3623         if test -f ${srcdir}/$subdir/Makefile.in
3624                 then all_lang_makefiles="$subdir/Makefile"
3625         fi
3626         all_languages="$all_languages $language"
3627         all_compilers="$all_compilers $compilers"
3628         all_outputs="$all_outputs $outputs"
3629         all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
3630 done
3631