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