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