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