gcc/configure.in

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