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