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