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 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1040 #xm_file="ansidecl.h ${xm_file}"
1041
1042 # Truncate the target if necessary
1043 if test x$host_truncate_target != x; then
1044         target=`echo $target | sed -e 's/\(..............\).*/\1/'`
1045 fi
1046
1047 # Get the version trigger filename from the toplevel
1048 if test "${with_gcc_version_trigger+set}" = set; then
1049         gcc_version_trigger=$with_gcc_version_trigger
1050 else
1051         gcc_version_trigger=${srcdir}/version.c
1052 fi
1053 changequote(,)dnl
1054 gcc_version_full=`grep version_string ${gcc_version_trigger} | sed -e 's/.*"\([^"]*\)".*/\1/'`
1055 gcc_version=`echo ${gcc_version_full} | sed -e 's/\([^ ]*\) .*/\1/'`
1056
1057 # Compile in configure arguments.
1058 if test -f configargs.h ; then
1059         # Being re-configured.
1060         gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1061         gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1062 else
1063         gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1064 fi
1065 cat > configargs.h <<EOF
1066 /* Generated automatically. */
1067 static const char configuration_arguments[] = "$gcc_config_arguments";
1068 static const char thread_model[] = "$thread_file";
1069 EOF
1070 changequote([,])dnl
1071
1072 # Internationalization
1073 PACKAGE=gcc
1074 VERSION="$gcc_version"
1075 AC_SUBST(PACKAGE)
1076 AC_SUBST(VERSION)
1077
1078 # Enable NLS support by default
1079 AC_ARG_ENABLE(nls,
1080   [  --enable-nls            use Native Language Support (default)],
1081   , enable_nls=yes)
1082
1083 # if cross compiling, disable NLS support.
1084 # It's not worth the trouble, at least for now.
1085
1086 if test "${build}" != "${host}" && test "x$enable_nls" = "xyes"; then
1087   AC_MSG_WARN(Disabling NLS support for canadian cross compiler.)
1088   enable_nls=no
1089 fi
1090
1091 AM_GNU_GETTEXT
1092
1093 # Windows32 Registry support for specifying GCC installation paths.
1094 AC_ARG_ENABLE(win32-registry,
1095 [  --disable-win32-registry
1096                           disable lookup of installation paths in the
1097                           Registry on Windows hosts
1098   --enable-win32-registry enable registry lookup (default)
1099   --enable-win32-registry=KEY
1100                           use KEY instead of GCC version as the last portion
1101                           of the registry key],,)
1102 case $host_os in
1103         win32 | pe | cygwin* | mingw32* | uwin*)
1104 AC_MSG_CHECKING(whether windows registry support is requested)
1105 if test "x$enable_win32_registry" != xno; then
1106   AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1107 [Define to 1 if installation paths should be looked up in Windows32
1108    Registry. Ignored on non windows32 hosts.])
1109   AC_MSG_RESULT(yes)
1110   AC_SEARCH_LIBS(RegOpenKeyExA, advapi32)
1111 else
1112   AC_MSG_RESULT(no)
1113 fi
1114
1115 # Check if user specified a different registry key.
1116 case "x${enable_win32_registry}" in
1117 x | xyes)
1118   # default.
1119   gcc_cv_win32_registry_key="$VERSION"
1120   ;;
1121 xno)
1122   # no registry lookup.
1123   gcc_cv_win32_registry_key=''
1124   ;;
1125 *)
1126   # user-specified key.
1127   gcc_cv_win32_registry_key="$enable_win32_registry"
1128   ;;
1129 esac
1130
1131 if test "x$enable_win32_registry" != xno; then
1132   AC_MSG_CHECKING(registry key on windows hosts)
1133   AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$gcc_cv_win32_registry_key",
1134         [Define to be the last portion of registry key on windows hosts.])
1135   AC_MSG_RESULT($gcc_cv_win32_registry_key)
1136 fi
1137 ;;
1138 esac
1139
1140 # Get an absolute path to the GCC top-level source directory
1141 holddir=`${PWDCMD-pwd}`
1142 cd $srcdir
1143 topdir=`${PWDCMD-pwd}`
1144 cd $holddir
1145
1146 # Conditionalize the makefile for this host machine.
1147 # Make-host contains the concatenation of all host makefile fragments
1148 # [there can be more than one].  This file is built by configure.frag.
1149 host_overrides=Make-host
1150 dep_host_xmake_file=
1151 for f in .. ${host_xmake_file}
1152 do
1153         if test -f ${srcdir}/config/$f
1154         then
1155                 dep_host_xmake_file="${dep_host_xmake_file} ${srcdir}/config/$f"
1156         fi
1157 done
1158
1159 # Conditionalize the makefile for this target machine.
1160 # Make-target contains the concatenation of all host makefile fragments
1161 # [there can be more than one].  This file is built by configure.frag.
1162 target_overrides=Make-target
1163 dep_tmake_file=
1164 for f in .. ${tmake_file}
1165 do
1166         if test -f ${srcdir}/config/$f
1167         then
1168                 dep_tmake_file="${dep_tmake_file} ${srcdir}/config/$f"
1169         fi
1170 done
1171
1172 # If the host doesn't support symlinks, modify CC in
1173 # FLAGS_TO_PASS so CC="stage1/xgcc -Bstage1/" works.
1174 # Otherwise, we can use "CC=$(CC)".
1175 rm -f symtest.tem
1176 if $symbolic_link $srcdir/gcc.c symtest.tem 2>/dev/null
1177 then
1178         cc_set_by_configure="\$(CC)"
1179         quoted_cc_set_by_configure="\$(CC)"
1180         stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1181         quoted_stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1182 else
1183         rm -f symtest.tem
1184         if cp -p $srcdir/gcc.c symtest.tem 2>/dev/null
1185         then
1186                 symbolic_link="cp -p"
1187         else
1188                 symbolic_link="cp"
1189         fi
1190         cc_set_by_configure="\`case '\$(CC)' in stage*) echo '\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\$(CC)';; esac\`"
1191         quoted_cc_set_by_configure="\\\`case '\\\$(CC)' in stage*) echo '\\\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(CC)';; esac\\\`"
1192         stage_prefix_set_by_configure="\`case '\$(STAGE_PREFIX)' in stage*) echo '\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\$(STAGE_PREFIX)';; esac\`"
1193         quoted_stage_prefix_set_by_configure="\\\`case '\\\$(STAGE_PREFIX)' in stage*) echo '\\\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(STAGE_PREFIX)';; esac\\\`"
1194 fi
1195 rm -f symtest.tem
1196
1197 out_object_file=`basename $out_file .c`.o
1198
1199 tm_file_list=
1200 for f in $tm_file; do
1201   case $f in
1202     ansidecl.h )
1203        tm_file_list="${tm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
1204     defaults.h )
1205        tm_file_list="${tm_file_list} \$(srcdir)/$f" ;;
1206     *) tm_file_list="${tm_file_list} \$(srcdir)/config/$f" ;;
1207   esac
1208 done
1209
1210 tm_p_file_list=
1211 for f in $tm_p_file; do
1212   case $f in
1213     tm-preds.h )
1214        tm_p_file_list="${tm_p_file_list} $f" ;;
1215     *) tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f" ;;
1216   esac
1217 done
1218
1219 host_xm_file_list=
1220 for f in $host_xm_file; do
1221   case $f in
1222     ansidecl.h )
1223        host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
1224     auto-host.h )
1225        host_xm_file_list="${host_xm_file_list} $f" ;;
1226     defaults.h )
1227        host_xm_file_list="${host_xm_file_list} \$(srcdir)/$f" ;;
1228     *) host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f" ;;
1229   esac
1230 done
1231
1232 build_xm_file_list=
1233 for f in $build_xm_file; do
1234   case $f in
1235     ansidecl.h )
1236        build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
1237     auto-build.h | auto-host.h )
1238        build_xm_file_list="${build_xm_file_list} $f" ;;
1239     defaults.h )
1240        host_xm_file_list="${host_xm_file_list} \$(srcdir)/$f" ;;
1241     *) build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f" ;;
1242   esac
1243 done
1244
1245 # Define macro CROSS_COMPILE in compilation if this is a cross-compiler.
1246 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1247 CROSS=                                          AC_SUBST(CROSS)
1248 ALL=all.internal                                AC_SUBST(ALL)
1249 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1250 if test x$host != x$target
1251 then
1252         CROSS="-DCROSS_COMPILE"
1253         ALL=all.cross
1254         SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1255         case "$host","$target" in
1256             i?86-*-*,x86_64-*-* \
1257             | powerpc*-*-*,powerpc64*-*-*)
1258                 CROSS="$CROSS -DNATIVE_CROSS" ;;
1259         esac
1260 fi
1261
1262 # If this is a cross-compiler that does not
1263 # have its own set of headers then define
1264 # inhibit_libc
1265
1266 # If this is using newlib, then define inhibit_libc in LIBGCC2_CFLAGS.
1267 # This prevents libgcc2 from containing any code which requires libc
1268 # support.
1269 inhibit_libc=
1270 if { test x$host != x$target && test "x$with_headers" = x &&
1271      test "x$with_sysroot" = x ; } || test x$with_newlib = xyes ; then
1272        inhibit_libc=-Dinhibit_libc
1273 fi
1274 AC_SUBST(inhibit_libc)
1275
1276 # When building gcc with a cross-compiler, we need to adjust things so
1277 # that the generator programs are still built with the native compiler.
1278 # Also, we cannot run fixincludes or fix-header.
1279
1280 # These are the normal (build=host) settings:
1281 BUILD_PREFIX=                   AC_SUBST(BUILD_PREFIX)
1282 BUILD_PREFIX_1=ignore-          AC_SUBST(BUILD_PREFIX_1)
1283 BUILD_CC='$(CC)'                AC_SUBST(BUILD_CC)
1284 BUILD_CFLAGS='$(ALL_CFLAGS)'    AC_SUBST(BUILD_CFLAGS)
1285
1286 STMP_FIXINC=stmp-fixinc         AC_SUBST(STMP_FIXINC)
1287 STMP_FIXPROTO=stmp-fixproto     AC_SUBST(STMP_FIXPROTO)
1288
1289 # And these apply if build != host.
1290 if test x$build != x$host
1291 then
1292     BUILD_PREFIX=build-
1293     BUILD_PREFIX_1=build-
1294     BUILD_CC='$(CC_FOR_BUILD)'
1295     BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD) $(XCFLAGS)'
1296
1297     STMP_FIXINC=
1298     STMP_FIXPROTO=
1299 fi
1300
1301 # Expand extra_headers to include complete path.
1302 # This substitutes for lots of t-* files.
1303 extra_headers_list=
1304 if test "x$extra_headers" = x
1305 then true
1306 else
1307         # Prepend ${srcdir}/config/${cpu_type}/ to every entry in extra_headers.
1308         for file in $extra_headers;
1309         do
1310                 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1311         done
1312 fi
1313
1314 if test x$use_collect2 = xno; then
1315         use_collect2=
1316 fi
1317
1318 # Add a definition of USE_COLLECT2 if system wants one.
1319 if test x$use_collect2 != x
1320 then
1321         host_xm_defines="${host_xm_defines} USE_COLLECT2"
1322         xm_defines="${xm_defines} USE_COLLECT2"
1323 fi
1324
1325 # If we have gas in the build tree, make a link to it.
1326 if test -f ../gas/Makefile; then
1327         rm -f as; $symbolic_link ../gas/as-new$host_exeext as$host_exeext 2>/dev/null
1328 fi
1329
1330 # If we have nm and objdump in the build tree, make a link to them.
1331 if test -f ../binutils/Makefile; then
1332         rm -f nm; $symbolic_link ../binutils/nm-new$host_exeext nm$host_exeext 2>/dev/null
1333         rm -f objdump; $symbolic_link ../binutils/objdump$host_exeext objdump$host_exeext 2>/dev/null
1334 fi
1335
1336 # If we have ld in the build tree, make a link to it.
1337 if test -f ../ld/Makefile; then
1338         rm -f collect-ld; $symbolic_link ../ld/ld-new$host_exeext collect-ld$host_exeext 2>/dev/null
1339 fi
1340
1341 # Figure out what assembler we will be using.
1342 AC_MSG_CHECKING(what assembler to use)
1343 gcc_cv_as=
1344 gcc_cv_gas_major_version=
1345 gcc_cv_gas_minor_version=
1346 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1347 gcc_cv_as_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1348 if test -x "$DEFAULT_ASSEMBLER"; then
1349         gcc_cv_as="$DEFAULT_ASSEMBLER"
1350 elif test -x "$AS"; then
1351         gcc_cv_as="$AS"
1352 elif test -x as$host_exeext; then
1353         # Build using assembler in the current directory.
1354         gcc_cv_as=./as$host_exeext
1355 elif test -f $gcc_cv_as_gas_srcdir/configure.in -a -f ../gas/Makefile; then
1356         # Single tree build which includes gas.
1357         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
1358         do
1359 changequote(,)dnl
1360                 gcc_cv_gas_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
1361 changequote([,])dnl
1362                 if test x$gcc_cv_gas_version != x; then
1363                         break
1364                 fi
1365         done
1366 changequote(,)dnl
1367         gcc_cv_gas_major_version=`expr "$gcc_cv_gas_version" : "VERSION=\([0-9]*\)"`
1368         gcc_cv_gas_minor_version=`expr "$gcc_cv_gas_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1369         gcc_cv_gas_patch_version=`expr "$gcc_cv_gas_version" : "VERSION=[0-9]*\.[0-9]*\.\([0-9]*\)"`
1370 changequote([,])dnl
1371 fi
1372
1373 if test "x$gcc_cv_as" = x; then
1374         # Search the same directories that the installed compiler will
1375         # search.  Else we may find the wrong assembler and lose.  If we
1376         # do not find a suitable assembler binary, then try the user's
1377         # path.
1378         #
1379         # Also note we have to check MD_EXEC_PREFIX before checking the
1380         # user's path.  Unfortunately, there is no good way to get at the
1381         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1382         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1383         # to be fixed as part of the make/configure rewrite too.
1384
1385         if test "x$exec_prefix" = xNONE; then
1386                 if test "x$prefix" = xNONE; then
1387                         test_prefix=/usr/local
1388                 else
1389                         test_prefix=$prefix
1390                 fi
1391         else
1392                 test_prefix=$exec_prefix
1393         fi
1394
1395         # If the loop below does not find an assembler, then use whatever
1396         # one we can find in the users's path.
1397         # user's path.
1398         if test "x$program_prefix" != xNONE; then
1399                 gcc_cv_as=${program_prefix}as$host_exeext
1400         else
1401                 gcc_cv_as=`echo as | sed ${program_transform_name}`$host_exeext
1402         fi
1403
1404         test_dirs="$test_prefix/lib/gcc-lib/$target_alias/$gcc_version \
1405                    $test_prefix/lib/gcc-lib/$target_alias \
1406                    /usr/lib/gcc/$target_alias/$gcc_version \
1407                    /usr/lib/gcc/$target_alias \
1408                    $test_prefix/$target_alias/bin/$target_alias/$gcc_version \
1409                    $test_prefix/$target_alias/bin"
1410
1411         if test x$host = x$target; then
1412             test_dirs="$test_dirs \
1413                    /usr/libexec \
1414                    /usr/ccs/gcc \
1415                    /usr/ccs/bin \
1416                    /udk/usr/ccs/bin \
1417                    /bsd43/usr/lib/cmplrs/cc \
1418                    /usr/cross64/usr/bin \
1419                    /usr/lib/cmplrs/cc \
1420                    /sysv/usr/lib/cmplrs/cc \
1421                    /svr4/usr/lib/cmplrs/cc \
1422                    /usr/bin"
1423         fi
1424
1425         for dir in $test_dirs; do
1426                 if test -x $dir/as$host_exeext; then
1427                         gcc_cv_as=$dir/as$host_exeext
1428                         break;
1429                 fi
1430         done
1431 fi
1432 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1433   AC_MSG_RESULT("newly built gas")
1434 else
1435   AC_MSG_RESULT($gcc_cv_as)
1436 fi
1437
1438 # Figure out what linker we will be using.
1439 AC_MSG_CHECKING(what linker to use)
1440 gcc_cv_ld=
1441 gcc_cv_gld_major_version=
1442 gcc_cv_gld_minor_version=
1443 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1444 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1445 if test -x "$DEFAULT_LINKER"; then
1446         gcc_cv_ld="$DEFAULT_LINKER"
1447 elif test -x "$LD"; then
1448         gcc_cv_ld="$LD"
1449 elif test -x ld$host_exeext; then
1450         # Build using linker in the current directory.
1451         gcc_cv_ld=./ld$host_exeext
1452 elif test -f $gcc_cv_ld_gld_srcdir/configure.in -a -f ../ld/Makefile; then
1453         # Single tree build which includes ld.
1454         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
1455         do
1456 changequote(,)dnl
1457                 gcc_cv_gld_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
1458 changequote([,])dnl
1459                 if test x$gcc_cv_gld_version != x; then
1460                         break
1461                 fi
1462         done
1463 changequote(,)dnl
1464         gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
1465         gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1466 changequote([,])dnl
1467 fi
1468
1469 if test "x$gcc_cv_ld" = x; then
1470         # Search the same directories that the installed compiler will
1471         # search.  Else we may find the wrong linker and lose.  If we
1472         # do not find a suitable linker binary, then try the user's
1473         # path.
1474         #
1475         # Also note we have to check MD_EXEC_PREFIX before checking the
1476         # user's path.  Unfortunately, there is no good way to get at the
1477         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1478         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1479         # to be fixed as part of the make/configure rewrite too.
1480
1481         if test "x$exec_prefix" = xNONE; then
1482                 if test "x$prefix" = xNONE; then
1483                         test_prefix=/usr/local
1484                 else
1485                         test_prefix=$prefix
1486                 fi
1487         else
1488                 test_prefix=$exec_prefix
1489         fi
1490
1491         # If the loop below does not find an linker, then use whatever
1492         # one we can find in the users's path.
1493         # user's path.
1494         if test "x$program_prefix" != xNONE; then
1495                 gcc_cv_ld=${program_prefix}ld$host_exeext
1496         else
1497                 gcc_cv_ld=`echo ld | sed ${program_transform_name}`$host_exeext
1498         fi
1499
1500         test_dirs="$test_prefix/lib/gcc-lib/$target_alias/$gcc_version \
1501                    $test_prefix/lib/gcc-lib/$target_alias \
1502                    /usr/lib/gcc/$target_alias/$gcc_version \
1503                    /usr/lib/gcc/$target_alias \
1504                    $test_prefix/$target_alias/bin/$target_alias/$gcc_version \
1505                    $test_prefix/$target_alias/bin"
1506
1507         if test x$host = x$target; then
1508             test_dirs="$test_dirs \
1509                    /usr/libexec \
1510                    /usr/ccs/gcc \
1511                    /usr/ccs/bin \
1512                    /udk/usr/ccs/bin \
1513                    /bsd43/usr/lib/cmplrs/cc \
1514                    /usr/cross64/usr/bin \
1515                    /usr/lib/cmplrs/cc \
1516                    /sysv/usr/lib/cmplrs/cc \
1517                    /svr4/usr/lib/cmplrs/cc \
1518                    /usr/bin"
1519         fi
1520
1521         for dir in $test_dirs; do
1522                 if test -x $dir/ld$host_exeext; then
1523                         gcc_cv_ld=$dir/ld$host_exeext
1524                         break;
1525                 fi
1526         done
1527 fi
1528 if test x$gcc_cv_gld_major_version != x -a x$gcc_cv_gld_minor_version != x; then
1529   AC_MSG_RESULT("newly built ld")
1530 else
1531   AC_MSG_RESULT($gcc_cv_ld)
1532 fi
1533
1534 # Figure out what nm we will be using.
1535 AC_MSG_CHECKING(what nm to use)
1536 if test -x nm$host_exeext; then
1537         gcc_cv_nm=./nm$host_exeext
1538 elif test "x$program_prefix" != xNONE; then
1539         gcc_cv_nm=${program_prefix}nm$host_exeext
1540 else
1541         gcc_cv_nm=`echo nm | sed ${program_transform_name}`$host_exeext
1542 fi
1543 AC_MSG_RESULT($gcc_cv_nm)
1544
1545 # Figure out what objdump we will be using.
1546 AC_MSG_CHECKING(what objdump to use)
1547 if test -x objdump$host_exeext; then
1548         gcc_cv_objdump=./objdump$host_exeext
1549 elif test "x$program_prefix" != xNONE; then
1550         gcc_cv_objdump=${program_prefix}objdump$host_exeext
1551 else
1552         gcc_cv_objdump=`echo objdump | sed ${program_transform_name}`$host_exeext
1553 fi
1554 AC_MSG_RESULT($gcc_cv_objdump)
1555
1556 # Figure out what assembler alignment features are present.
1557 AC_MSG_CHECKING(assembler alignment features)
1558 gcc_cv_as_alignment_features=none
1559 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1560         # Gas version 2.6 and later support for .balign and .p2align.
1561         # bytes to skip when using .p2align.
1562         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
1563                 gcc_cv_as_alignment_features=".balign and .p2align"
1564                 AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN)
1565         fi
1566         # Gas version 2.8 and later support specifying the maximum
1567         # bytes to skip when using .p2align.
1568         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
1569                 gcc_cv_as_alignment_features=".p2align including maximum skip"
1570                 AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN)
1571         fi
1572 elif test x$gcc_cv_as != x; then
1573         # Check if we have .balign and .p2align
1574         echo ".balign  4" > conftest.s
1575         echo ".p2align  2" >> conftest.s
1576         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1577                 gcc_cv_as_alignment_features=".balign and .p2align"
1578                 AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN)
1579         fi
1580         rm -f conftest.s conftest.o
1581         # Check if specifying the maximum bytes to skip when
1582         # using .p2align is supported.
1583         echo ".p2align 4,,7" > conftest.s
1584         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1585                 gcc_cv_as_alignment_features=".p2align including maximum skip"
1586                 AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN)
1587         fi
1588         rm -f conftest.s conftest.o
1589 fi
1590 AC_MSG_RESULT($gcc_cv_as_alignment_features)
1591
1592 AC_MSG_CHECKING(assembler subsection support)
1593 gcc_cv_as_subsections=no
1594 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1595   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
1596     gcc_cv_as_subsections="working .subsection -1"
1597   fi
1598 elif test x$gcc_cv_as != x; then
1599         # Check if we have .subsection
1600         echo ".subsection 1" > conftest.s
1601         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1602                 gcc_cv_as_subsections=".subsection"
1603                 if test x$gcc_cv_nm != x; then
1604                         cat > conftest.s <<EOF
1605 conftest_label1: .word 0
1606 .subsection -1
1607 conftest_label2: .word 0
1608 .previous
1609 EOF
1610                         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1611                                 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
1612                                 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
1613                                 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1; then
1614                                         :
1615                                 else
1616                                         gcc_cv_as_subsections="working .subsection -1"
1617                                 fi
1618                         fi
1619                 fi
1620         fi
1621         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1622 fi
1623 if test x"$gcc_cv_as_subsections" = x"working .subsection -1"; then
1624         AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
1625 [Define if your assembler supports .subsection and .subsection -1 starts
1626    emitting at the beginning of your section.])
1627 fi
1628 AC_MSG_RESULT($gcc_cv_as_subsections)
1629
1630 AC_MSG_CHECKING(assembler weak support)
1631 gcc_cv_as_weak=no
1632 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1633   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
1634     gcc_cv_as_weak="yes"
1635   fi
1636 elif test x$gcc_cv_as != x; then
1637         # Check if we have .weak
1638         echo "  .weak foobar" > conftest.s
1639         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1640                 gcc_cv_as_weak="yes"
1641         fi
1642         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1643 fi
1644 if test x"$gcc_cv_as_weak" = xyes; then
1645         AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])
1646 fi
1647 AC_MSG_RESULT($gcc_cv_as_weak)
1648
1649 AC_MSG_CHECKING(assembler hidden support)
1650 gcc_cv_as_hidden=no
1651 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1652   if test "$gcc_cv_gas_major_version" -eq 2     \
1653           -a "$gcc_cv_gas_minor_version" -eq 12 \
1654           -a "$gcc_cv_gas_patch_version" -ge 1  \
1655           -o "$gcc_cv_gas_major_version" -eq 2  \
1656           -a "$gcc_cv_gas_minor_version" -gt 12 \
1657           -o "$gcc_cv_gas_major_version" -gt 2  \
1658     && grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
1659     gcc_cv_as_hidden="yes"
1660   fi
1661 elif test x$gcc_cv_as != x; then
1662         # Check if we have .hidden
1663         echo "  .hidden foobar" > conftest.s
1664         echo "foobar:" >> conftest.s
1665         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1666                 gcc_cv_as_hidden="yes"
1667         fi
1668         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1669
1670         # GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
1671         # This is irritatingly difficult to feature test for.  Look for
1672         # the date string after the version number.
1673         ld_ver=`$gcc_cv_ld --version 2>/dev/null | head -1`
1674         if echo "$ld_ver" | grep GNU > /dev/null; then
1675 changequote(,)dnl
1676                 ld_vers=`echo $ld_ver | sed -n 's,^.*[  ]\([0-9][0-9]*\.[0-9][0-9]*\(\|\.[0-9][0-9]*\)\)\([     ].*\|\)$,\1,p'`
1677                 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'`
1678                 if test 0"$ld_date" -lt 20020404; then
1679                         if test -n "$ld_date"; then
1680                                 # If there was date string, but was earlier than 2002-04-04, fail
1681                                 gcc_cv_as_hidden="no"
1682                         elif test -z "$ld_vers"; then
1683                                 # If there was no date string nor ld version number, something is wrong
1684                                 gcc_cv_as_hidden="no"
1685                         else
1686                                 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
1687                                 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
1688                                 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
1689                                 test -z "$ld_vers_patch" && ld_vers_patch=0
1690                                 if test "$ld_vers_major" -lt 2; then
1691                                         gcc_cv_as_hidden="no"
1692                                 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
1693                                         gcc_cv_as_hidden="no"
1694                                 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 \
1695                                           -a "$ld_vers_patch" -eq 0; then
1696                                         gcc_cv_as_hidden="no"
1697                                 fi
1698                         fi
1699                 fi
1700 changequote([,])dnl
1701         fi
1702 fi
1703 if test x"$gcc_cv_as_hidden" = xyes; then
1704         AC_DEFINE(HAVE_GAS_HIDDEN, 1,
1705                 [Define if your assembler supports .hidden.])
1706 fi
1707 AC_MSG_RESULT($gcc_cv_as_hidden)
1708 libgcc_visibility=$gcc_cv_as_hidden
1709 case "$target" in
1710   mips-sgi-irix6*)
1711     if test x"$gnu_ld_flag" = x"no"; then
1712       # Even if using gas with .hidden support, the resulting object files
1713       # cannot be linked with the IRIX 6 O32 linker.  With the N32 and
1714       # N64 linkers, the problem is that the linker refuses to accept
1715       # -call_shared (passed by default to the linker) and -r (used to
1716       # link the object file generated without .hidden directives with
1717       # one that hides symbols), so we also lose.
1718       libgcc_visibility=no
1719     fi
1720     ;;
1721 esac
1722 AC_SUBST(libgcc_visibility)
1723
1724 AC_MSG_CHECKING(assembler leb128 support)
1725 gcc_cv_as_leb128=no
1726 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1727   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
1728     gcc_cv_as_leb128="yes"
1729   fi
1730 elif test x$gcc_cv_as != x; then
1731         # Check if we have .[us]leb128, and support symbol arithmetic with it.
1732         cat > conftest.s <<EOF
1733         .data
1734         .uleb128 L2 - L1
1735 L1:
1736         .uleb128 1280
1737         .sleb128 -1010
1738 L2:
1739 EOF
1740         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1741                 gcc_cv_as_leb128="yes"
1742
1743                 # GAS versions before 2.11 do not support uleb128,
1744                 # despite appearing to.
1745                 # ??? There exists an elf-specific test that will crash
1746                 # the assembler.  Perhaps it's better to figure out whether
1747                 # arbitrary sections are supported and try the test.
1748                 as_ver=`$gcc_cv_as --version 2>/dev/null | head -1`
1749                 if echo "$as_ver" | grep GNU > /dev/null; then
1750 changequote(,)dnl
1751                         as_ver=`echo $as_ver | sed -e 's/GNU assembler \([0-9.][0-9.]*\).*/\1/'`
1752                         as_major=`echo $as_ver | sed 's/\..*//'`
1753                         as_minor=`echo $as_ver | sed 's/[^.]*\.\([0-9]*\).*/\1/'`
1754 changequote([,])dnl
1755                         if test $as_major -eq 2 -a $as_minor -lt 11; then
1756                                 gcc_cv_as_leb128="no"
1757                         fi
1758                 fi
1759         fi
1760         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1761 fi
1762 if test x"$gcc_cv_as_leb128" = xyes; then
1763         AC_DEFINE(HAVE_AS_LEB128, 1,
1764                 [Define if your assembler supports .uleb128.])
1765 fi
1766 AC_MSG_RESULT($gcc_cv_as_leb128)
1767
1768 AC_MSG_CHECKING(assembler eh_frame optimization)
1769 gcc_cv_as_eh_frame=no
1770 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1771   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
1772     gcc_cv_as_eh_frame="yes"
1773   fi
1774 elif test x$gcc_cv_as != x; then
1775         # Check if this is GAS.
1776         as_ver=`$gcc_cv_as --version < /dev/null 2> /dev/null | head -1`
1777         rm -f a.out 2> /dev/null
1778         if echo "$as_ver" | grep GNU > /dev/null; then
1779                 # Versions up to and including 2.11.0 may mis-optimize
1780                 # .eh_frame data.  Try something.
1781                 cat > conftest.s <<EOF
1782         .text
1783 .LFB1:
1784         .4byte  0
1785 .L1:
1786         .4byte  0
1787 .LFE1:
1788         .section        .eh_frame,"aw",@progbits
1789 __FRAME_BEGIN__:
1790         .4byte  .LECIE1-.LSCIE1
1791 .LSCIE1:
1792         .4byte  0x0
1793         .byte   0x1
1794         .ascii "z\0"
1795         .byte   0x1
1796         .byte   0x78
1797         .byte   0x1a
1798         .byte   0x0
1799         .byte   0x4
1800         .4byte  1
1801         .p2align 1
1802 .LECIE1:
1803 .LSFDE1:
1804         .4byte  .LEFDE1-.LASFDE1
1805 .LASFDE1:
1806         .4byte  .LASFDE1-__FRAME_BEGIN__
1807         .4byte  .LFB1
1808         .4byte  .LFE1-.LFB1
1809         .byte   0x4
1810         .4byte  .LFE1-.LFB1
1811         .byte   0x4
1812         .4byte  .L1-.LFB1
1813 .LEFDE1:
1814 EOF
1815                 cat > conftest.lit <<EOF
1816  0000 10000000 00000000 017a0001 781a0004  .........z..x...
1817  0010 01000000 12000000 18000000 00000000  ................
1818  0020 08000000 04080000 0044               .........D
1819 EOF
1820                 cat > conftest.big <<EOF
1821  0000 00000010 00000000 017a0001 781a0004  .........z..x...
1822  0010 00000001 00000012 00000018 00000000  ................
1823  0020 00000008 04000000 0844               .........D
1824 EOF
1825                 # If the assembler didn't choke, and we can objdump,
1826                 # and we got the correct data, then succeed.
1827                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
1828                    && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
1829                       | tail -3 > conftest.got \
1830                    && { cmp conftest.lit conftest.got > /dev/null 2>&1 \
1831                         || cmp conftest.big conftest.got > /dev/null 2>&1; }
1832                 then
1833                         gcc_cv_as_eh_frame="yes"
1834                 else
1835                         gcc_cv_as_eh_frame="bad"
1836                         if $gcc_cv_as -o conftest.o --traditional-format /dev/null; then
1837                                 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
1838         [Define if your assembler mis-optimizes .eh_frame data.])
1839                         fi
1840                 fi
1841         fi
1842         rm -f conftest.*
1843 fi
1844 AC_MSG_RESULT($gcc_cv_as_eh_frame)
1845
1846 AC_MSG_CHECKING(assembler section merging support)
1847 gcc_cv_as_shf_merge=no
1848 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1849   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
1850     gcc_cv_as_shf_merge=yes
1851   fi
1852 elif test x$gcc_cv_as != x; then
1853         # Check if we support SHF_MERGE sections
1854         echo '.section .rodata.str, "aMS", @progbits, 1' > conftest.s
1855         if $gcc_cv_as --fatal-warnings -o conftest.o conftest.s > /dev/null 2>&1; then
1856                 gcc_cv_as_shf_merge=yes
1857         fi
1858         rm -f conftest.s conftest.o
1859 fi
1860 if test x"$gcc_cv_as_shf_merge" = xyes; then
1861         AC_DEFINE(HAVE_GAS_SHF_MERGE, 1,
1862 [Define if your assembler supports marking sections with SHF_MERGE flag.])
1863 fi
1864 AC_MSG_RESULT($gcc_cv_as_shf_merge)
1865
1866 AC_MSG_CHECKING(assembler thread-local storage support)
1867 gcc_cv_as_tls=no
1868 conftest_s=
1869 tls_first_major=
1870 tls_first_minor=
1871 case "$target" in
1872 changequote(,)dnl
1873   alpha*-*-*)
1874     conftest_s='
1875         .section ".tdata","awT",@progbits
1876 foo:    .long   25
1877         .text
1878         ldq     $27,__tls_get_addr($29)         !literal!1
1879         lda     $16,foo($29)                    !tlsgd!1
1880         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
1881         ldq     $27,__tls_get_addr($29)         !literal!2
1882         lda     $16,foo($29)                    !tlsldm!2
1883         jsr     $26,($27),__tls_get_addr        !lituse_tlsldm!2
1884         ldq     $1,foo($29)                     !gotdtprel
1885         ldah    $2,foo($29)                     !dtprelhi
1886         lda     $3,foo($2)                      !dtprello
1887         lda     $4,foo($29)                     !dtprel
1888         ldq     $1,foo($29)                     !gottprel
1889         ldah    $2,foo($29)                     !tprelhi
1890         lda     $3,foo($2)                      !tprello
1891         lda     $4,foo($29)                     !tprel'
1892         tls_first_major=2
1893         tls_first_minor=13
1894         ;;
1895   i[34567]86-*-*)
1896 changequote([,])dnl
1897     conftest_s='
1898         .section ".tdata","awT",@progbits
1899 foo:    .long   25
1900         .text
1901         movl    %gs:0, %eax
1902         leal    foo@TLSGD(,%ebx,1), %eax
1903         leal    foo@TLSLDM(%ebx), %eax
1904         leal    foo@DTPOFF(%eax), %edx
1905         movl    foo@GOTTPOFF(%ebx), %eax
1906         subl    foo@GOTTPOFF(%ebx), %eax
1907         addl    foo@GOTNTPOFF(%ebx), %eax
1908         movl    foo@INDNTPOFF, %eax
1909         movl    $foo@TPOFF, %eax
1910         subl    $foo@TPOFF, %eax
1911         leal    foo@NTPOFF(%ecx), %eax'
1912         tls_first_major=2
1913         tls_first_minor=14
1914         ;;
1915   x86_64-*-*)
1916     conftest_s='
1917         .section ".tdata","awT",@progbits
1918 foo:    .long   25
1919         .text
1920         movq    %fs:0, %rax
1921         leaq    foo@TLSGD(%rip), %rdi
1922         leaq    foo@TLSLD(%rip), %rdi
1923         leaq    foo@DTPOFF(%rax), %rdx
1924         movq    foo@GOTTPOFF(%rip), %rax
1925         movq    $foo@TPOFF, %rax'
1926         tls_first_major=2
1927         tls_first_minor=14
1928         ;;
1929   ia64-*-*)
1930     conftest_s='
1931         .section ".tdata","awT",@progbits
1932 foo:    data8   25
1933         .text
1934         addl    r16 = @ltoff(@dtpmod(foo#)), gp
1935         addl    r17 = @ltoff(@dtprel(foo#)), gp
1936         addl    r18 = @ltoff(@tprel(foo#)), gp
1937         addl    r19 = @dtprel(foo#), gp
1938         adds    r21 = @dtprel(foo#), r13
1939         movl    r23 = @dtprel(foo#)
1940         addl    r20 = @tprel(foo#), gp
1941         adds    r22 = @tprel(foo#), r13
1942         movl    r24 = @tprel(foo#)'
1943         tls_first_major=2
1944         tls_first_minor=13
1945         ;;
1946 esac
1947 if test -z "$tls_first_major"; then
1948   :
1949 elif test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x
1950 then
1951   if test "$gcc_cv_gas_major_version" -eq "$tls_first_major" \
1952           -a "$gcc_cv_gas_minor_version" -ge "$tls_first_minor" \
1953           -o "$gcc_cv_gas_major_version" -gt "$tls_first_major"; then
1954     gcc_cv_as_tls=yes
1955   fi
1956 elif test x$gcc_cv_as != x; then
1957   echo "$conftest_s" > conftest.s
1958   if $gcc_cv_as --fatal-warnings -o conftest.o conftest.s > /dev/null 2>&1
1959   then
1960     gcc_cv_as_tls=yes
1961   fi
1962   rm -f conftest.s conftest.o
1963 fi
1964 if test "$gcc_cv_as_tls" = yes; then
1965   AC_DEFINE(HAVE_AS_TLS, 1,
1966             [Define if your assembler supports thread-local storage.])
1967 fi
1968 AC_MSG_RESULT($gcc_cv_as_tls)
1969
1970 case "$target" in
1971   # All TARGET_ABI_OSF targets.
1972   alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
1973     AC_CACHE_CHECK([assembler supports explicit relocations],
1974         gcc_cv_as_explicit_relocs, [
1975         gcc_cv_as_explicit_relocs=unknown
1976         if test x$gcc_cv_gas_major_version != x \
1977                 -a x$gcc_cv_gas_minor_version != x
1978         then
1979            if test "$gcc_cv_gas_major_version" -eq 2 \
1980                    -a "$gcc_cv_gas_minor_version" -ge 12 \
1981                    -o "$gcc_cv_gas_major_version" -gt 2; then
1982               gcc_cv_as_explicit_relocs=yes
1983            fi
1984         elif test x$gcc_cv_as != x; then
1985             cat > conftest.s << 'EOF'
1986         .set nomacro
1987         .text
1988         extbl   $3, $2, $3      !lituse_bytoff!1
1989         ldq     $2, a($29)      !literal!1
1990         ldq     $4, b($29)      !literal!2
1991         ldq_u   $3, 0($2)       !lituse_base!1
1992         ldq     $27, f($29)     !literal!5
1993         jsr     $26, ($27), f   !lituse_jsr!5
1994         ldah    $29, 0($26)     !gpdisp!3
1995         lda     $0, c($29)      !gprel
1996         ldah    $1, d($29)      !gprelhigh
1997         lda     $1, d($1)       !gprellow
1998         lda     $29, 0($29)     !gpdisp!3
1999 EOF
2000             if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2001                 gcc_cv_as_explicit_relocs=yes
2002             else
2003                 gcc_cv_as_explicit_relocs=no
2004             fi
2005             rm -f conftest.s conftest.o
2006         fi
2007     ])
2008     if test "x$gcc_cv_as_explicit_relocs" = xyes; then
2009         AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
2010                 [Define if your assembler supports explicit relocations.])
2011     fi
2012     ;;
2013   sparc*-*-*)
2014     AC_CACHE_CHECK([assembler .register pseudo-op support],
2015         gcc_cv_as_register_pseudo_op, [
2016         gcc_cv_as_register_pseudo_op=unknown
2017         if test x$gcc_cv_as != x; then
2018             # Check if we have .register
2019             echo ".register %g2, #scratch" > conftest.s
2020             if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2021                 gcc_cv_as_register_pseudo_op=yes
2022             else
2023                 gcc_cv_as_register_pseudo_op=no
2024             fi
2025             rm -f conftest.s conftest.o
2026         fi
2027     ])
2028     if test "x$gcc_cv_as_register_pseudo_op" = xyes; then
2029         AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
2030                 [Define if your assembler supports .register.])
2031     fi
2032
2033     AC_CACHE_CHECK([assembler supports -relax],
2034         gcc_cv_as_relax_opt, [
2035         gcc_cv_as_relax_opt=unknown
2036         if test x$gcc_cv_as != x; then
2037             # Check if gas supports -relax
2038             echo ".text" > conftest.s
2039             if $gcc_cv_as -relax -o conftest.o conftest.s > /dev/null 2>&1; then
2040                 gcc_cv_as_relax_opt=yes
2041             else
2042                 gcc_cv_as_relax_opt=no
2043             fi
2044             rm -f conftest.s conftest.o
2045         fi
2046     ])
2047     if test "x$gcc_cv_as_relax_opt" = xyes; then
2048         AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
2049                 [Define if your assembler supports -relax option.])
2050     fi
2051
2052     AC_CACHE_CHECK([assembler and linker support unaligned pc related relocs],
2053         gcc_cv_as_sparc_ua_pcrel, [
2054         gcc_cv_as_sparc_ua_pcrel=unknown
2055         if test x$gcc_cv_as != x -a x$gcc_cv_ld != x; then
2056             gcc_cv_as_sparc_ua_pcrel=no
2057             echo ".text; foo: nop; .data; .align 4; .byte 0; .uaword %r_disp32(foo)" > conftest.s
2058             if $gcc_cv_as -K PIC -o conftest.o conftest.s > /dev/null 2>&1 \
2059                && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
2060                 gcc_cv_as_sparc_ua_pcrel=yes
2061             fi
2062             rm -f conftest.s conftest.o conftest
2063         fi
2064     ])
2065     if test "x$gcc_cv_as_sparc_ua_pcrel" = xyes; then
2066         AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
2067                 [Define if your assembler and linker support unaligned PC relative relocs.])
2068     fi
2069
2070     AC_CACHE_CHECK([assembler and linker support unaligned pc related relocs against hidden symbols],
2071         gcc_cv_as_sparc_ua_pcrel_hidden, [
2072         if test "x$gcc_cv_as_sparc_ua_pcrel" = xyes; then
2073             gcc_cv_as_sparc_ua_pcrel_hidden=unknown
2074             if test x$gcc_cv_objdump != x; then
2075                 gcc_cv_as_sparc_ua_pcrel_hidden=no
2076                 echo ".data; .align 4; .byte 0x31; .uaword %r_disp32(foo)" > conftest.s
2077                 echo ".byte 0x32, 0x33, 0x34; .global foo; .hidden foo" >> conftest.s
2078                 echo "foo: .skip 4" >> conftest.s
2079                 if $gcc_cv_as -K PIC -o conftest.o conftest.s > /dev/null 2>&1 \
2080                    && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
2081                    && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
2082                       | grep ' 31000000 07323334' > /dev/null 2>&1; then
2083                     if $gcc_cv_objdump -R conftest 2> /dev/null \
2084                        | grep 'DISP32' > /dev/null 2>&1; then
2085                         :
2086                     else
2087                         gcc_cv_as_sparc_ua_pcrel_hidden=yes
2088                     fi
2089                 fi
2090             fi
2091             rm -f conftest.s conftest.o conftest
2092         else
2093             gcc_cv_as_sparc_ua_pcrel_hidden="$gcc_cv_as_sparc_ua_pcrel"
2094         fi
2095     ])
2096     if test "x$gcc_cv_as_sparc_ua_pcrel_hidden" = xyes; then
2097         AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
2098                 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])
2099     fi
2100
2101     AC_CACHE_CHECK([for assembler offsetable %lo() support],
2102         gcc_cv_as_offsetable_lo10, [
2103         gcc_cv_as_offsetable_lo10=unknown
2104         if test "x$gcc_cv_as" != x; then
2105             # Check if assembler has offsetable %lo()
2106             echo "or %g1, %lo(ab) + 12, %g1" > conftest.s
2107             echo "or %g1, %lo(ab + 12), %g1" > conftest1.s
2108             if $gcc_cv_as -xarch=v9 -o conftest.o conftest.s \
2109                     > /dev/null 2>&1 &&
2110                $gcc_cv_as -xarch=v9 -o conftest1.o conftest1.s \
2111                     > /dev/null 2>&1; then
2112                 if cmp conftest.o conftest1.o > /dev/null 2>&1; then
2113                     gcc_cv_as_offsetable_lo10=no
2114                 else
2115                     gcc_cv_as_offsetable_lo10=yes
2116                 fi
2117             else
2118                 gcc_cv_as_offsetable_lo10=no
2119             fi
2120             rm -f conftest.s conftest.o conftest1.s conftest1.o
2121         fi
2122     ])
2123     if test "x$gcc_cv_as_offsetable_lo10" = xyes; then
2124         AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
2125             [Define if your assembler supports offsetable %lo().])
2126     fi
2127
2128     ;;
2129
2130 changequote(,)dnl
2131   i[34567]86-*-* | x86_64-*-*)
2132 changequote([,])dnl
2133     AC_MSG_CHECKING(assembler instructions)
2134     gcc_cv_as_instructions=
2135     if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
2136       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
2137         gcc_cv_as_instructions="filds fists"
2138       fi
2139     elif test x$gcc_cv_as != x; then
2140         set "filds fists" "filds mem; fists mem"
2141         while test $# -gt 0
2142         do
2143                 echo "$2" > conftest.s
2144                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2145                         gcc_cv_as_instructions=${gcc_cv_as_instructions}$1" "
2146                 fi
2147                 shift 2
2148         done
2149         rm -f conftest.s conftest.o
2150     fi
2151     if test x"$gcc_cv_as_instructions" != x; then
2152         AC_DEFINE_UNQUOTED(HAVE_GAS_`echo "$gcc_cv_as_instructions" | sed -e 's/ $//' | tr '[a-z ]' '[A-Z_]'`)
2153     fi
2154     AC_MSG_RESULT($gcc_cv_as_instructions)
2155
2156     AC_MSG_CHECKING(assembler GOTOFF in data directives)
2157     gcc_cv_as_gotoff_in_data=no
2158     if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x
2159     then
2160       if test "$gcc_cv_gas_major_version" -eq 2 \
2161          -a "$gcc_cv_gas_minor_version" -ge 11 \
2162          -o "$gcc_cv_gas_major_version" -gt 2; then
2163         gcc_cv_as_gotoff_in_data=yes
2164       fi
2165     elif test x$gcc_cv_as != x; then
2166         cat > conftest.s <<EOF
2167         .text
2168 .L0:
2169         nop
2170         .data
2171         .long .L0@GOTOFF
2172 EOF
2173         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2174           gcc_cv_as_gotoff_in_data=yes
2175         fi
2176     fi
2177     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
2178       [`if test $gcc_cv_as_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
2179       [Define true if the assembler supports '.long foo@GOTOFF'.])
2180     AC_MSG_RESULT($gcc_cv_as_gotoff_in_data)
2181     ;;
2182 esac
2183
2184 AC_MSG_CHECKING(assembler dwarf2 debug_line support)
2185 gcc_cv_as_dwarf2_debug_line=no
2186 # ??? Not all targets support dwarf2 debug_line, even within a version
2187 # of gas.  Moreover, we need to emit a valid instruction to trigger any
2188 # info to the output file.  So, as supported targets are added to gas 2.11,
2189 # add some instruction here to (also) show we expect this might work.
2190 # ??? Once 2.11 is released, probably need to add first known working
2191 # version to the per-target configury.
2192 case "$target" in
2193   i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* \
2194   | x86_64*-*-* | hppa*-*-* | arm*-*-* | strongarm*-*-* | xscale*-*-*)
2195     insn="nop"
2196     ;;
2197   ia64*-*-*)
2198     insn="nop 0"
2199     ;;
2200   esac
2201 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x;
2202 then
2203   if test "$gcc_cv_gas_major_version" -eq 2 \
2204         -a "$gcc_cv_gas_minor_version" -ge 11 \
2205         -o "$gcc_cv_gas_major_version" -gt 2 \
2206      && grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2207      && test x"$insn" != x ; then
2208     gcc_cv_as_dwarf2_debug_line="yes"
2209   fi
2210 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2211         echo '  .file 1 "conftest.s"' > conftest.s
2212         echo '  .loc 1 3 0' >> conftest.s
2213         echo "  $insn" >> conftest.s
2214         # ??? This fails with non-gnu grep.
2215         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
2216            && grep debug_line conftest.o > /dev/null 2>&1 ; then
2217                 # The .debug_line file table must be in the exact order that
2218                 # we specified the files, since these indices are also used
2219                 # by DW_AT_decl_file.  Approximate this test by testing if
2220                 # the assembler bitches if the same index is assigned twice.
2221                 echo '  .file 1 "foo.s"' > conftest.s
2222                 echo '  .file 1 "bar.s"' >> conftest.s
2223                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1
2224                 then
2225                   gcc_cv_as_dwarf2_debug_line="no"
2226                 else
2227                   gcc_cv_as_dwarf2_debug_line="yes"
2228                 fi
2229         fi
2230         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
2231 fi
2232 if test x"$gcc_cv_as_dwarf2_debug_line" = xyes; then
2233         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
2234 [Define if your assembler supports dwarf2 .file/.loc directives,
2235    and preserves file table indices exactly as given.])
2236 fi
2237 AC_MSG_RESULT($gcc_cv_as_dwarf2_debug_line)
2238
2239 AC_MSG_CHECKING(assembler --gdwarf2 support)
2240 gcc_cv_as_gdwarf2_flag=no
2241 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x;
2242 then
2243   if test "$gcc_cv_gas_major_version" -eq 2 \
2244         -a "$gcc_cv_gas_minor_version" -ge 11 \
2245         -o "$gcc_cv_gas_major_version" -gt 2 \
2246      && grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2247      && test x"$insn" != x ; then
2248     gcc_cv_as_gdwarf2_flag="yes"
2249   fi
2250 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2251         echo '' > conftest.s
2252         # ??? This fails with non-gnu grep.
2253         if $gcc_cv_as --gdwarf2 -o conftest.o conftest.s > /dev/null 2>&1
2254           then
2255           gcc_cv_as_gdwarf2_flag="yes"
2256         fi
2257         rm -f conftest.s conftest.o
2258 fi
2259 if test x"$gcc_cv_as_gdwarf2_flag" = xyes; then
2260         AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
2261 [Define if your assembler supports the --gdwarf2 option.])
2262 fi
2263 AC_MSG_RESULT($gcc_cv_as_gdwarf2_flag)
2264
2265 AC_MSG_CHECKING(assembler --gstabs support)
2266 gcc_cv_as_gstabs_flag=no
2267 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x;
2268 then
2269   if test "$gcc_cv_gas_major_version" -eq 2 \
2270         -a "$gcc_cv_gas_minor_version" -ge 11 \
2271         -o "$gcc_cv_gas_major_version" -gt 2 \
2272      && grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2273      && test x"$insn" != x ; then
2274     gcc_cv_as_gstabs_flag="yes"
2275   fi
2276 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2277         echo '' > conftest.s
2278         # ??? This fails with non-gnu grep.
2279         if $gcc_cv_as --gstabs -o conftest.o conftest.s > /dev/null 2>&1 ; then
2280           gcc_cv_as_gstabs_flag="yes"
2281         fi
2282         rm -f conftest.s conftest.o
2283 fi
2284 if test x"$gcc_cv_as_gstabs_flag" = xyes; then
2285         AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
2286 [Define if your assembler supports the --gstabs option.])
2287 fi
2288 AC_MSG_RESULT($gcc_cv_as_gstabs_flag)
2289
2290 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2291 gcc_cv_ld_ro_rw_mix=unknown
2292 if test x$gcc_cv_gld_major_version != x -a x$gcc_cv_gld_minor_version != x; then
2293   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
2294     gcc_cv_ld_ro_rw_mix=read-write
2295   fi
2296 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2297   echo '.section "myfoosect", "a"' > conftest1.s
2298   echo '.section "myfoosect", "aw"' > conftest2.s
2299   echo '.byte 1' >> conftest2.s
2300   echo '.section "myfoosect", "a"' > conftest3.s
2301   echo '.byte 0' >> conftest3.s
2302   if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2303      && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2304      && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2305      && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2306         conftest2.o conftest3.o; then
2307     gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2308                          | grep -A1 myfoosect`
2309     if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2310       if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2311         gcc_cv_ld_ro_rw_mix=read-only
2312       else
2313         gcc_cv_ld_ro_rw_mix=read-write
2314       fi
2315     fi
2316   fi
2317 changequote(,)dnl
2318   rm -f conftest.* conftest[123].*
2319 changequote([,])dnl
2320 fi
2321 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2322         AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2323   [Define if your linker links a mix of read-only
2324    and read-write sections into a read-write section.])
2325 fi
2326 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2327
2328 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
2329 gcc_cv_ld_eh_frame_hdr=no
2330 if test x$gcc_cv_gld_major_version != x -a x$gcc_cv_gld_minor_version != x; then
2331   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
2332     gcc_cv_ld_eh_frame_hdr=yes
2333   fi
2334 elif test x$gcc_cv_ld != x; then
2335         # Check if linker supports --eh-frame-hdr option
2336         if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
2337                 gcc_cv_ld_eh_frame_hdr=yes
2338         fi
2339 fi
2340 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
2341         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
2342 [Define if your linker supports --eh-frame-hdr option.])
2343 fi
2344 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
2345
2346 # Miscellaneous target-specific checks.
2347 case "$target" in
2348   mips*-*-*)
2349     AC_MSG_CHECKING(whether libgloss uses STARTUP directives consistently)
2350     gcc_cv_mips_libgloss_startup=no
2351     gcc_cv_libgloss_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/libgloss
2352     if test "x$exec_prefix" = xNONE; then
2353       if test "x$prefix" = xNONE; then
2354         test_prefix=/usr/local
2355       else
2356         test_prefix=$prefix
2357       fi
2358     else
2359       test_prefix=$exec_prefix
2360     fi
2361     for f in $gcc_cv_libgloss_srcdir/mips/idt.ld $test_prefix/$target_alias/lib/idt.ld
2362     do
2363       if grep '^STARTUP' $f > /dev/null 2>&1; then
2364         gcc_cv_mips_libgloss_startup=yes
2365         break
2366       fi
2367     done
2368     if test x"$gcc_cv_mips_libgloss_startup" = xyes; then
2369       AC_DEFINE(HAVE_MIPS_LIBGLOSS_STARTUP_DIRECTIVES, 1,
2370         [Define if your MIPS libgloss linker scripts consistently include STARTUP directives.])
2371     fi
2372     AC_MSG_RESULT($gcc_cv_mips_libgloss_startup)
2373     ;;
2374 esac
2375
2376 if test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" ; then
2377   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include")
2378 fi
2379
2380 # Figure out what language subdirectories are present.
2381 # Look if the user specified --enable-languages="..."; if not, use
2382 # the environment variable $LANGUAGES if defined. $LANGUAGES might
2383 # go away some day.
2384 # NB:  embedded tabs in this IF block -- do not untabify
2385 if test x"${enable_languages+set}" != xset; then
2386         if test x"${LANGUAGES+set}" = xset; then
2387                 enable_languages="${LANGUAGES}"
2388                 AC_MSG_WARN([setting LANGUAGES is deprecated, use --enable-languages instead])
2389
2390         else
2391                 enable_languages=all
2392         fi
2393 else
2394         if test x"${enable_languages}" = x \
2395         || test x"${enable_languages}" = xyes;
2396         then
2397                 AC_MSG_ERROR([--enable-languages needs at least one language argument])
2398         fi
2399 fi
2400 enable_languages=`echo "${enable_languages}" | sed -e 's/[[     ,]][[   ,]]*/,/g' -e 's/,$//'`
2401
2402 # First scan to see if an enabled language requires some other language.
2403 # We assume that a given config-lang.in will list all the language
2404 # front ends it requires, even if some are required indirectly.
2405 for lang in ${srcdir}/*/config-lang.in ..
2406 do
2407    case $lang in
2408     ..)
2409        ;;
2410     # The odd quoting in the next line works around
2411     # an apparent bug in bash 1.12 on linux.
2412 changequote(,)dnl
2413     ${srcdir}/[*]/config-lang.in)
2414        ;;
2415     *)
2416        lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^      ]*\).*$,\1,p' $lang`
2417        this_lang_requires=`sed -n -e 's,^lang_requires=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^lang_requires=\([^    ]*\).*$,\1,p' $lang`
2418        for other in $this_lang_requires
2419        do
2420           case ,${enable_languages}, in
2421            *,$other,*)
2422               ;;
2423            *,all,*)
2424               ;;
2425            *,$lang_alias,*)
2426               enable_languages="$enable_languages,$other"
2427               ;;
2428           esac
2429        done
2430        ;;
2431 changequote([,])dnl
2432    esac
2433 done
2434
2435 expected_languages=`echo ,${enable_languages}, | sed -e 's:,: :g' -e 's:  *: :g' -e 's:  *: :g' -e 's:^ ::' -e 's: $::'`
2436 found_languages=
2437 subdirs=
2438 for lang in ${srcdir}/*/config-lang.in ..
2439 do
2440         case $lang in
2441         ..) ;;
2442         # The odd quoting in the next line works around
2443         # an apparent bug in bash 1.12 on linux.
2444 changequote(,)dnl
2445         ${srcdir}/[*]/config-lang.in) ;;
2446         *)
2447           lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
2448           this_lang_libs=`sed -n -e 's,^target_libs=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^target_libs=\([^         ]*\).*$,\1,p' $lang`
2449           build_by_default=`sed -n -e 's,^build_by_default=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^build_by_default=\([^     ]*\).*$,\1,p' $lang`
2450           if test "x$lang_alias" = x
2451           then
2452                 echo "$lang doesn't set \$language." 1>&2
2453                 exit 1
2454           fi
2455           case ${build_by_default},${enable_languages}, in
2456           *,$lang_alias,*) add_this_lang=yes ;;
2457           no,*) add_this_lang=no ;;
2458           *,all,*) add_this_lang=yes ;;
2459           *) add_this_lang=no ;;
2460           esac
2461           found_languages="${found_languages} ${lang_alias}"
2462           if test x"${add_this_lang}" = xyes; then
2463                 case $lang in
2464                     ${srcdir}/ada/config-lang.in)
2465                         if test x$have_gnat = xyes ; then
2466                                 subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2467                         fi
2468                         ;;
2469                     *)
2470                         subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2471                         ;;
2472                 esac
2473           fi
2474           ;;
2475 changequote([,])dnl
2476         esac
2477 done
2478
2479 missing_languages=
2480 for expected_language in ${expected_languages} ..
2481 do
2482     if test "${expected_language}" != ..; then
2483         missing_language="${expected_language}"
2484         if test "${expected_language}" = "c" \
2485            || test "${expected_language}" = "all"; then
2486                 missing_language=
2487         fi
2488         for found_language in ${found_languages} ..
2489         do
2490             if test "${found_language}" != ..; then
2491                 if test "${expected_language}" = "${found_language}"; then
2492                     missing_language=
2493                 fi
2494             fi
2495         done
2496         if test "x${missing_language}" != x; then
2497            missing_languages="${missing_languages} ${missing_language}"
2498         fi
2499     fi
2500 done
2501
2502 if test "x$missing_languages" != x; then
2503   AC_MSG_ERROR([
2504 The following requested languages were not found:${missing_languages}
2505 The following languages were available: c${found_languages}])
2506 fi
2507
2508 # Make gthr-default.h if we have a thread file.
2509 gthread_flags=
2510 if test $thread_file != single; then
2511     rm -f gthr-default.h
2512     echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h
2513     gthread_flags=-DHAVE_GTHR_DEFAULT
2514 fi
2515 AC_SUBST(gthread_flags)
2516
2517 # Find out what GC implementation we want, or may, use.
2518 AC_ARG_WITH(gc,
2519 [  --with-gc={simple,page} choose the garbage collection mechanism to use
2520                           with the compiler],
2521 [case "$withval" in
2522   simple | page)
2523     GGC=ggc-$withval
2524     ;;
2525   *)
2526     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
2527     ;;
2528 esac],
2529 [GGC=ggc-page])
2530 AC_SUBST(GGC)
2531 echo "Using $GGC for garbage collection."
2532
2533 # Use the system's zlib library.
2534 zlibdir=-L../zlib
2535 zlibinc="-I\$(srcdir)/../zlib"
2536 AC_ARG_WITH(system-zlib,
2537 [  --with-system-zlib      use installed libz],
2538 zlibdir=
2539 zlibinc=
2540 )
2541 AC_SUBST(zlibdir)
2542 AC_SUBST(zlibinc)
2543
2544 dnl Very limited version of automake's enable-maintainer-mode
2545
2546 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
2547   dnl maintainer-mode is disabled by default
2548   AC_ARG_ENABLE(maintainer-mode,
2549 [  --enable-maintainer-mode
2550                           enable make rules and dependencies not useful
2551                           (and sometimes confusing) to the casual installer],
2552       maintainer_mode=$enableval,
2553       maintainer_mode=no)
2554
2555 AC_MSG_RESULT($maintainer_mode)
2556
2557 if test "$maintainer_mode" = "yes"; then
2558   MAINT=''
2559 else
2560   MAINT='#'
2561 fi
2562 AC_SUBST(MAINT)dnl
2563
2564 # Make empty files to contain the specs and options for each language.
2565 # Then add #include lines to for a compiler that has specs and/or options.
2566
2567 lang_specs_files=
2568 lang_options_files=
2569 lang_tree_files=
2570 for subdir in . $subdirs
2571 do
2572         if test -f $srcdir/$subdir/lang-specs.h; then
2573             lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
2574         fi
2575         if test -f $srcdir/$subdir/lang-options.h; then
2576             lang_options_files="$lang_options_files $srcdir/$subdir/lang-options.h"
2577         fi
2578         if test -f $srcdir/$subdir/$subdir-tree.def; then
2579             lang_tree_files="$lang_tree_files $srcdir/$subdir/$subdir-tree.def"
2580         fi
2581 done
2582
2583 # These (without "all_") are set in each config-lang.in.
2584 # `language' must be a single word so is spelled singularly.
2585 all_languages=
2586 all_boot_languages=
2587 all_compilers=
2588 all_stagestuff=
2589 all_outputs='Makefile intl/Makefile fixinc/Makefile gccbug mklibgcc mkheaders'
2590 # List of language makefile fragments.
2591 all_lang_makefiles=
2592 # Files for gengtype
2593 all_gtfiles="$target_gtfiles"
2594 # Files for gengtype with language
2595 all_gtfiles_files_langs=
2596 all_gtfiles_files_files=
2597
2598 # Add the language fragments.
2599 # Languages are added via two mechanisms.  Some information must be
2600 # recorded in makefile variables, these are defined in config-lang.in.
2601 # We accumulate them and plug them into the main Makefile.
2602 # The other mechanism is a set of hooks for each of the main targets
2603 # like `clean', `install', etc.
2604
2605 language_fragments="Make-lang"
2606 language_hooks="Make-hooks"
2607
2608 for s in .. $subdirs
2609 do
2610         if test $s != ".."
2611         then
2612                 language=
2613                 boot_language=
2614                 compilers=
2615                 stagestuff=
2616                 outputs=
2617                 gtfiles=
2618                 . ${srcdir}/$s/config-lang.in
2619                 if test "x$language" = x
2620                 then
2621                         echo "${srcdir}/$s/config-lang.in doesn't set \$language." 1>&2
2622                         exit 1
2623                 fi
2624                 all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Make-lang.in"
2625                 if test -f ${srcdir}/$s/Makefile.in
2626                 then all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Makefile.in"
2627                 fi
2628                 all_languages="$all_languages $language"
2629                 if test "x$boot_language" = xyes
2630                 then
2631                         all_boot_languages="$all_boot_languages $language"
2632                 fi
2633                 all_compilers="$all_compilers $compilers"
2634                 all_stagestuff="$all_stagestuff $stagestuff"
2635                 all_outputs="$all_outputs $outputs"
2636                 all_gtfiles="$all_gtfiles $gtfiles"
2637                 for f in .. $gtfiles
2638                 do
2639                      if test $f != ".."
2640                      then
2641                          all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2642                          all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2643                      fi
2644                 done
2645         fi
2646 done
2647
2648 # Pick up gtfiles for c
2649 gtfiles=
2650 s="c"
2651 . ${srcdir}/c-config-lang.in
2652 all_gtfiles="$all_gtfiles $gtfiles"
2653 for f in .. $gtfiles
2654 do
2655      if test $f != ".."
2656      then
2657         all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2658         all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2659      fi
2660 done
2661
2662 check_languages=
2663 for language in .. $all_languages
2664 do
2665         if test $language != ".."
2666         then
2667                 check_languages="$check_languages check-$language"
2668         fi
2669 done
2670
2671 # Since we can't use `::' targets, we link each language in
2672 # with a set of hooks, reached indirectly via lang.${target}.
2673
2674 rm -f Make-hooks
2675 touch Make-hooks
2676 target_list="all.build all.cross start.encap rest.encap \
2677         info dvi generated-manpages \
2678         install-normal install-common install-info install-man \
2679         uninstall \
2680         mostlyclean clean distclean extraclean maintainer-clean \
2681         stage1 stage2 stage3 stage4"
2682 for t in $target_list
2683 do
2684         x=
2685         for lang in .. $all_languages
2686         do
2687                 if test $lang != ".."; then
2688                         x="$x $lang.$t"
2689                 fi
2690         done
2691         echo "lang.$t: $x" >> Make-hooks
2692 done
2693
2694 # Create .gdbinit.
2695
2696 echo "dir ." > .gdbinit
2697 echo "dir ${srcdir}" >> .gdbinit
2698 if test x$gdb_needs_out_file_path = xyes
2699 then
2700         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
2701 fi
2702 if test "x$subdirs" != x; then
2703         for s in $subdirs
2704         do
2705                 echo "dir ${srcdir}/$s" >> .gdbinit
2706         done
2707 fi
2708 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
2709
2710 # Define variables host_canonical and build_canonical
2711 # because some Cygnus local changes in the Makefile depend on them.
2712 build_canonical=${build}
2713 host_canonical=${host}
2714 target_subdir=
2715 if test "${host}" != "${target}" ; then
2716     target_subdir=${target_alias}/
2717 fi
2718 AC_SUBST(build_canonical)
2719 AC_SUBST(host_canonical)
2720 AC_SUBST(target_subdir)
2721
2722 # If $(exec_prefix) exists and is not the same as $(prefix), then compute an
2723 # absolute path for gcc_tooldir based on inserting the number of up-directory
2724 # movements required to get from $(exec_prefix) to $(prefix) into the basic
2725 # $(libsubdir)/@(unlibsubdir) based path.
2726 # Don't set gcc_tooldir to tooldir since that's only passed in by the toplevel
2727 # make and thus we'd get different behavior depending on where we built the
2728 # sources.
2729 if test x$exec_prefix = xNONE -o x$exec_prefix = x$prefix; then
2730     gcc_tooldir='$(libsubdir)/$(unlibsubdir)/../$(target_alias)'
2731 else
2732 changequote(<<, >>)dnl
2733 # An explanation of the sed strings:
2734 #  -e 's|^\$(prefix)||'   matches and eliminates 'prefix' from 'exec_prefix'
2735 #  -e 's|/$||'            match a trailing forward slash and eliminates it
2736 #  -e 's|^[^/]|/|'        forces the string to start with a forward slash (*)
2737 #  -e 's|/[^/]*|../|g'    replaces each occurrence of /<directory> with ../
2738 #
2739 # (*) Note this pattern overwrites the first character of the string
2740 # with a forward slash if one is not already present.  This is not a
2741 # problem because the exact names of the sub-directories concerned is
2742 # unimportant, just the number of them matters.
2743 #
2744 # The practical upshot of these patterns is like this:
2745 #
2746 #  prefix     exec_prefix        result
2747 #  ------     -----------        ------
2748 #   /foo        /foo/bar          ../
2749 #   /foo/       /foo/bar          ../
2750 #   /foo        /foo/bar/         ../
2751 #   /foo/       /foo/bar/         ../
2752 #   /foo        /foo/bar/ugg      ../../
2753 #
2754     dollar='$$'
2755     gcc_tooldir="\$(libsubdir)/\$(unlibsubdir)/\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/\$(dollar)||' -e 's|^[^/]|/|' -e 's|/[^/]*|../|g'\`\$(target_alias)"
2756 changequote([, ])dnl
2757 fi
2758 AC_SUBST(gcc_tooldir)
2759 AC_SUBST(dollar)
2760
2761 # Find a directory in which to install a shared libgcc.
2762
2763 AC_ARG_ENABLE(version-specific-runtime-libs,
2764 [  --enable-version-specific-runtime-libs
2765                           specify that runtime libraries should be
2766                           installed in a compiler-specific directory])
2767
2768 AC_ARG_WITH(slibdir,
2769 [  --with-slibdir=DIR      shared libraries in DIR [LIBDIR]],
2770 slibdir="$with_slibdir",
2771 if test "${enable_version_specific_runtime_libs+set}" = set; then
2772   slibdir='$(libsubdir)'
2773 elif test "$host" != "$target"; then
2774   slibdir='$(build_tooldir)/lib'
2775 else
2776   slibdir='$(libdir)'
2777 fi)
2778 AC_SUBST(slibdir)
2779
2780 objdir=`${PWDCMD-pwd}`
2781 AC_SUBST(objdir)
2782
2783 # Process the language and host/target makefile fragments.
2784 ${CONFIG_SHELL-/bin/sh} $srcdir/configure.frag $srcdir "$subdirs" "$dep_host_xmake_file" "$dep_tmake_file"
2785
2786 # Substitute configuration variables
2787 AC_SUBST(subdirs)
2788 AC_SUBST(srcdir)
2789 AC_SUBST(all_boot_languages)
2790 AC_SUBST(all_compilers)
2791 AC_SUBST(all_gtfiles)
2792 AC_SUBST(all_gtfiles_files_langs)
2793 AC_SUBST(all_gtfiles_files_files)
2794 AC_SUBST(all_lang_makefiles)
2795 AC_SUBST(all_languages)
2796 AC_SUBST(all_stagestuff)
2797 AC_SUBST(build_exeext)
2798 AC_SUBST(build_install_headers_dir)
2799 AC_SUBST(build_xm_file_list)
2800 AC_SUBST(build_xm_file)
2801 AC_SUBST(build_xm_defines)
2802 AC_SUBST(check_languages)
2803 AC_SUBST(cc_set_by_configure)
2804 AC_SUBST(quoted_cc_set_by_configure)
2805 AC_SUBST(cpp_install_dir)
2806 AC_SUBST(dep_host_xmake_file)
2807 AC_SUBST(dep_tmake_file)
2808 AC_SUBST(extra_headers_list)
2809 AC_SUBST(extra_objs)
2810 AC_SUBST(extra_parts)
2811 AC_SUBST(extra_passes)
2812 AC_SUBST(extra_programs)
2813 AC_SUBST(float_h_file)
2814 AC_SUBST(gcc_config_arguments)
2815 AC_SUBST(gcc_gxx_include_dir)
2816 AC_SUBST(libstdcxx_incdir)
2817 AC_SUBST(gcc_version)
2818 AC_SUBST(gcc_version_full)
2819 AC_SUBST(gcc_version_trigger)
2820 AC_SUBST(host_exeext)
2821 AC_SUBST(host_extra_gcc_objs)
2822 AC_SUBST(host_xm_file_list)
2823 AC_SUBST(host_xm_file)
2824 AC_SUBST(host_xm_defines)
2825 AC_SUBST(install)
2826 AC_SUBST(lang_options_files)
2827 AC_SUBST(lang_specs_files)
2828 AC_SUBST(lang_tree_files)
2829 AC_SUBST(local_prefix)
2830 AC_SUBST(md_file)
2831 AC_SUBST(objc_boehm_gc)
2832 AC_SUBST(out_file)
2833 AC_SUBST(out_object_file)
2834 AC_SUBST(stage_prefix_set_by_configure)
2835 AC_SUBST(quoted_stage_prefix_set_by_configure)
2836 AC_SUBST(symbolic_link)
2837 AC_SUBST(thread_file)
2838 AC_SUBST(tm_file_list)
2839 AC_SUBST(tm_file)
2840 AC_SUBST(tm_defines)
2841 AC_SUBST(tm_p_file_list)
2842 AC_SUBST(tm_p_file)
2843 AC_SUBST(xm_file)
2844 AC_SUBST(xm_defines)
2845 AC_SUBST(target_alias)
2846 AC_SUBST(c_target_objs)
2847 AC_SUBST(cxx_target_objs)
2848 AC_SUBST(target_cpu_default)
2849
2850 AC_SUBST_FILE(target_overrides)
2851 AC_SUBST_FILE(host_overrides)
2852 AC_SUBST_FILE(language_fragments)
2853 AC_SUBST_FILE(language_hooks)
2854
2855 # Echo that links are built
2856 if test x$host = x$target
2857 then
2858         str1="native "
2859 else
2860         str1="cross-"
2861         str2=" from $host"
2862 fi
2863
2864 if test x$host != x$build
2865 then
2866         str3=" on a $build system"
2867 fi
2868
2869 if test "x$str2" != x || test "x$str3" != x
2870 then
2871         str4=
2872 fi
2873
2874 echo "Links are now set up to build a ${str1}compiler for ${target}$str4" 1>&2
2875
2876 if test "x$str2" != x || test "x$str3" != x
2877 then
2878         echo " ${str2}${str3}." 1>&2
2879 fi
2880
2881 # Truncate the target if necessary
2882 if test x$host_truncate_target != x; then
2883         target=`echo $target | sed -e 's/\(..............\).*/\1/'`
2884 fi
2885
2886 # Configure the subdirectories
2887 # AC_CONFIG_SUBDIRS($subdirs)
2888
2889 # Create the Makefile
2890 # and configure language subdirectories
2891 AC_OUTPUT($all_outputs,
2892 [
2893 case x$CONFIG_HEADERS in
2894 xauto-host.h:config.in)
2895 echo > cstamp-h ;;
2896 esac
2897 # If the host supports symlinks, point stage[1234] at ../stage[1234] so
2898 # bootstrapping and the installation procedure can still use
2899 # CC="stage1/xgcc -Bstage1/".  If the host doesn't support symlinks,
2900 # FLAGS_TO_PASS has been modified to solve the problem there.
2901 # This is virtually a duplicate of what happens in configure.lang; we do
2902 # an extra check to make sure this only happens if ln -s can be used.
2903 if test "$symbolic_link" = "ln -s"; then
2904  for d in .. ${subdirs} fixinc ; do
2905    if test $d != ..; then
2906         STARTDIR=`${PWDCMD-pwd}`
2907         cd $d
2908         for t in stage1 stage2 stage3 stage4 include
2909         do
2910                 rm -f $t
2911                 $symbolic_link ../$t $t 2>/dev/null
2912         done
2913         cd $STARTDIR
2914    fi
2915  done
2916 else true ; fi
2917 # Avoid having to add intl to our include paths.
2918 if test -f intl/libintl.h; then
2919   echo creating libintl.h
2920   echo '#include "intl/libintl.h"' >libintl.h
2921 fi
2922 ],
2923 [subdirs='$subdirs'
2924 symbolic_link='$symbolic_link'
2925 ])