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