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