gcc/configure.ac

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