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 # 'make compare' can be significantly faster, if cmp itself can
 649 # skip bytes instead of using tail.  The test being performed is
 650 # "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2"
 651 # but we need to sink errors and handle broken shells.
 652 AC_MSG_CHECKING([for cmp's capabilities])
 653 echo abfoo >t1
 654 echo cdfoo >t2
 655 if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
 656   if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
 657     make_compare_target=slowcompare
 658   else
 659     make_compare_target=gnucompare
 660   fi
 661 else
 662   make_compare_target=slowcompare
 663 fi
 664 rm t1 t2
 665 AC_SUBST(make_compare_target)
 666 AC_MSG_RESULT($make_compare_target)
 667
 668 # How about lex?
 669 dnl Don't use AC_PROG_LEX; we insist on flex.
 670 dnl LEXLIB is not useful in gcc.
 671 if test -f $srcdir/../flex/skel.c; then
 672   FLEX='$(objdir)/../flex/flex'
 673 else
 674   AC_CHECK_PROG(FLEX, flex, flex, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing flex)
 675 fi
 676
 677 # Bison?
 678 # The -L switch is so bison can find its skeleton file.
 679 if test -f $srcdir/../bison/bison.simple; then
 680   BISON='$(objdir)/../bison/bison -L $(srcdir)/../bison/'
 681 else
 682   AC_CHECK_PROG(BISON, bison, bison, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing bison)
 683 fi
 684
 685 # --------------------
 686 # Checks for C headers
 687 # --------------------
 688
 689 AC_MSG_CHECKING(for GNU C library)
 690 AC_CACHE_VAL(gcc_cv_glibc,
 691 [AC_TRY_COMPILE(
 692   [#include <features.h>],[
 693 #if ! (defined __GLIBC__ || defined __GNU_LIBRARY__)
 694 #error Not a GNU C library system
 695 #endif],
 696   [gcc_cv_glibc=yes],
 697   gcc_cv_glibc=no)])
 698 AC_MSG_RESULT($gcc_cv_glibc)
 699 if test $gcc_cv_glibc = yes; then
 700   AC_DEFINE(_GNU_SOURCE, 1, [Always define this when using the GNU C Library])
 701 fi
 702
 703 AC_HEADER_STDC
 704 AC_HEADER_TIME
 705 gcc_AC_HEADER_STDBOOL
 706 gcc_AC_HEADER_STRING
 707 AC_HEADER_SYS_WAIT
 708 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h \
 709                  fcntl.h unistd.h sys/file.h sys/time.h \
 710                  sys/resource.h sys/param.h sys/times.h sys/stat.h \
 711                  direct.h malloc.h langinfo.h ldfcn.h wchar.h)
 712
 713 # Check for thread headers.
 714 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
 715 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
 716
 717 # These tests can't be done till we know if we have limits.h.
 718 gcc_AC_C_CHAR_BIT
 719 AC_C_BIGENDIAN_CROSS
 720
 721 # --------
 722 # UNSORTED
 723 # --------
 724
 725 # Stage specific cflags for build.
 726 stage1_cflags=
 727 case $build in
 728 vax-*-*)
 729   if test x$GCC = xyes
 730   then
 731     stage1_cflags="-Wa,-J"
 732   else
 733     stage1_cflags="-J"
 734   fi
 735   ;;
 736 powerpc-*-darwin*)
 737   # The spiffy cpp-precomp chokes on some legitimate constructs in GCC
 738   # sources; use -no-cpp-precomp to get to GNU cpp.
 739   # Apple's GCC has bugs in designated initializer handling, so disable
 740   # that too.
 741   stage1_cflags="-no-cpp-precomp -DHAVE_DESIGNATED_INITIALIZERS=0"
 742   ;;
 743 esac
 744 AC_SUBST(stage1_cflags)
 745
 746 # These libraries may be used by collect2.
 747 # We may need a special search path to get them linked.
 748 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
 749 [save_LIBS="$LIBS"
 750 for libs in '' -lld -lmld \
 751                 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
 752                 '-L/usr/lib/cmplrs/cc3.11 -lmld'
 753 do
 754         LIBS="$libs"
 755         AC_TRY_LINK_FUNC(ldopen,
 756                 [gcc_cv_collect2_libs="$libs"; break])
 757 done
 758 LIBS="$save_LIBS"
 759 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
 760 case $gcc_cv_collect2_libs in
 761         "none required")        ;;
 762         *)      COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
 763 esac
 764 AC_SUBST(COLLECT2_LIBS)
 765
 766 # When building Ada code on Alpha, we need exc_resume which is usually in
 767 # -lexc.  So test for it.
 768 save_LIBS="$LIBS"
 769 LIBS=
 770 AC_SEARCH_LIBS(exc_resume, exc)
 771 GNAT_LIBEXC="$LIBS"
 772 LIBS="$save_LIBS"
 773 AC_SUBST(GNAT_LIBEXC)
 774
 775 # Some systems put ldexp and frexp in libm instead of libc; assume
 776 # they're both in the same place.  jcf-dump needs them.
 777 save_LIBS="$LIBS"
 778 LIBS=
 779 AC_SEARCH_LIBS(ldexp, m)
 780 LDEXP_LIB="$LIBS"
 781 LIBS="$save_LIBS"
 782 AC_SUBST(LDEXP_LIB)
 783
 784 # See if the stage1 system preprocessor understands the ANSI C
 785 # preprocessor stringification operator.  (Used by symcat.h.)
 786 AC_C_STRINGIZE
 787
 788 # Use <inttypes.h> only if it exists,
 789 # doesn't clash with <sys/types.h>, and declares intmax_t.
 790 AC_MSG_CHECKING(for inttypes.h)
 791 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
 792 [AC_TRY_COMPILE(
 793   [#include <sys/types.h>
 794 #include <inttypes.h>],
 795   [intmax_t i = -1;],
 796   [gcc_cv_header_inttypes_h=yes],
 797   gcc_cv_header_inttypes_h=no)])
 798 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
 799 if test $gcc_cv_header_inttypes_h = yes; then
 800   AC_DEFINE(HAVE_INTTYPES_H, 1,
 801         [Define if you have a working <inttypes.h> header file.])
 802 fi
 803
 804 dnl Disabled until we have a complete test for buggy enum bitfields.
 805 dnl gcc_AC_C_ENUM_BF_UNSIGNED
 806
 807 AC_CHECK_FUNCS(times clock dup2 kill getrlimit setrlimit atoll atoq \
 808         sysconf strsignal putc_unlocked fputc_unlocked fputs_unlocked \
 809         fwrite_unlocked fprintf_unlocked getrusage nl_langinfo lstat \
 810         scandir alphasort gettimeofday mbstowcs wcswidth)
 811
 812 if test x$ac_cv_func_mbstowcs = xyes; then
 813   AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
 814 [    AC_TRY_RUN([#include <stdlib.h>
 815 int main()
 816 {
 817   mbstowcs(0, "", 0);
 818   return 0;
 819 }],
 820     gcc_cv_func_mbstowcs_works=yes,
 821     gcc_cv_func_mbstowcs_works=no,
 822     gcc_cv_func_mbstowcs_works=yes)])
 823   if test x$gcc_cv_func_mbstowcs_works = xyes; then
 824     AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
 825   [Define this macro if mbstowcs does not crash when its
 826    first argument is NULL.])
 827   fi
 828 fi
 829
 830 AC_CHECK_TYPE(ssize_t, int)
 831
 832 # Try to determine the array type of the second argument of getgroups
 833 # for the target system (int or gid_t).
 834 AC_TYPE_GETGROUPS
 835 if test "${target}" = "${build}"; then
 836   TARGET_GETGROUPS_T=$ac_cv_type_getgroups
 837 else
 838   case "${target}" in
 839         # This condition may need some tweaking.  It should include all
 840         # targets where the array type of the second argument of getgroups
 841         # is int and the type of gid_t is not equivalent to int.
 842         *-*-sunos* | *-*-ultrix*)
 843                 TARGET_GETGROUPS_T=int
 844                 ;;
 845         *)
 846                 TARGET_GETGROUPS_T=gid_t
 847                 ;;
 848   esac
 849 fi
 850 AC_SUBST(TARGET_GETGROUPS_T)
 851
 852 gcc_AC_FUNC_PRINTF_PTR
 853
 854 case "${host}" in
 855 *-*-uwin*)
 856   AC_MSG_ERROR([
 857 *** UWIN may not be used as a host platform because
 858 *** linking with posix.dll is not allowed by the GNU GPL])
 859   ;;
 860 *-*-*vms*)
 861   # Under VMS, vfork works very different than on Unix. The standard test
 862   # won't work, and it isn't easily adaptable. It makes more sense to
 863   # just force it.
 864   ac_cv_func_vfork_works=yes
 865   ;;
 866 esac
 867 AC_FUNC_VFORK
 868 AC_FUNC_MMAP_ANYWHERE
 869 AC_FUNC_MMAP_FILE
 870
 871 AM_ICONV
 872
 873 # We will need to find libiberty.h and ansidecl.h
 874 saved_CFLAGS="$CFLAGS"
 875 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include"
 876 gcc_AC_CHECK_DECLS(getenv atol sbrk abort atof getcwd getwd \
 877         strsignal putc_unlocked fputs_unlocked fwrite_unlocked \
 878         fprintf_unlocked strstr errno vasprintf \
 879         malloc realloc calloc free basename getopt clock, , ,[
 880 #include "ansidecl.h"
 881 #include "system.h"])
 882
 883 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
 884 #include "ansidecl.h"
 885 #include "system.h"
 886 #ifdef HAVE_SYS_RESOURCE_H
 887 #include <sys/resource.h>
 888 #endif
 889 ])
 890
 891 AC_TRY_COMPILE([
 892 #include "ansidecl.h"
 893 #include "system.h"
 894 #ifdef HAVE_SYS_RESOURCE_H
 895 #include <sys/resource.h>
 896 #endif
 897 ],[rlim_t l = 0;],,[AC_DEFINE([rlim_t],[long],
 898 [Define to \`long' if <sys/resource.h> doesn't define.])])
 899
 900 gcc_AC_CHECK_DECLS(ldgetname, , ,[
 901 #include "ansidecl.h"
 902 #include "system.h"
 903 #ifdef HAVE_LDFCN_H
 904 #include <ldfcn.h>
 905 #endif
 906 ])
 907
 908 gcc_AC_CHECK_DECLS(times, , ,[
 909 #include "ansidecl.h"
 910 #include "system.h"
 911 #ifdef HAVE_SYS_TIMES_H
 912 #include <sys/times.h>
 913 #endif
 914 ])
 915
 916 # More time-related stuff.
 917 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
 918 AC_TRY_COMPILE([
 919 #include "ansidecl.h"
 920 #include "system.h"
 921 #ifdef HAVE_SYS_TIMES_H
 922 #include <sys/times.h>
 923 #endif
 924 ], [struct tms tms;], ac_cv_struct_tms=yes, ac_cv_struct_tms=no)])
 925 if test $ac_cv_struct_tms = yes; then
 926   AC_DEFINE(HAVE_STRUCT_TMS, 1,
 927   [Define if <sys/times.h> defines struct tms.])
 928 fi
 929
 930 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
 931 # revisit after autoconf 2.50.
 932 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
 933 AC_TRY_COMPILE([
 934 #include "ansidecl.h"
 935 #include "system.h"
 936 ], [clock_t x;], gcc_cv_type_clock_t=yes, gcc_cv_type_clock_t=no)])
 937 if test $gcc_cv_type_clock_t = yes; then
 938   AC_DEFINE(HAVE_CLOCK_T, 1,
 939   [Define if <time.h> defines clock_t.])
 940 fi
 941
 942 AC_CACHE_CHECK(for uchar, gcc_cv_type_uchar,
 943 [AC_TRY_COMPILE([
 944 #include "ansidecl.h"
 945 #include "system.h"
 946 ],
 947 [if ((uchar *)0) return 0;
 948  if (sizeof(uchar)) return 0;],
 949 ac_cv_type_uchar=yes, ac_cv_type_uchar=no)])
 950 if test $ac_cv_type_uchar = yes; then
 951   AC_DEFINE(HAVE_UCHAR, 1,
 952   [Define if <sys/types.h> defines \`uchar'.])
 953 fi
 954
 955 # Restore CFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
 956 CFLAGS="$saved_CFLAGS"
 957
 958 gcc_AC_INITFINI_ARRAY
 959
 960 # mkdir takes a single argument on some systems.
 961 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
 962
 963 # File extensions
 964 manext='.1'
 965 objext='.o'
 966 AC_SUBST(manext)
 967 AC_SUBST(objext)
 968
 969 # With Setjmp/Longjmp based exception handling.
 970 AC_ARG_ENABLE(sjlj-exceptions,
 971 [  --enable-sjlj-exceptions
 972                           arrange to use setjmp/longjmp exception handling],
 973 [sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
 974 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
 975   [Define 0/1 to force the choice for exception handling model.])])
 976
 977 AC_CHECK_LIB(unwind, main, use_libunwind_default=yes, use_libunwind_default=no)
 978 # Use libunwind based exception handling.
 979 AC_ARG_ENABLE(libunwind-exceptions,
 980 [  --enable-libunwind-exceptions  force use libunwind for exceptions],
 981 use_libunwind_exceptions=$enableval,
 982 use_libunwind_exceptions=$use_libunwind_default)
 983 if test x"$use_libunwind_exceptions" = xyes; then
 984    AC_DEFINE(USE_LIBUNWIND_EXCEPTIONS, 1,
 985         [Define if gcc should use -lunwind.])
 986 fi
 987
 988 # --------------------------------------------------------
 989 # Build, host, and target specific configuration fragments
 990 # --------------------------------------------------------
 991
 992 target_gtfiles=
 993 build_xm_file=
 994 build_xm_defines=
 995 build_install_headers_dir=install-headers-tar
 996 build_exeext=
 997 host_xm_file=
 998 host_xm_defines=
 999 host_xmake_file=
1000 host_truncate_target=
1001 host_exeext=
1002
1003 # Decode the host machine, then the target machine.
1004 # For the host machine, we save the xm_file variable as host_xm_file;
1005 # then we decode the target machine and forget everything else
1006 # that came from the host machine.
1007 for machine in $build $host $target; do
1008         . ${srcdir}/config.gcc
1009 done
1010
1011 extra_objs="${host_extra_objs} ${extra_objs}"
1012
1013 # Default the target-machine variables that were not explicitly set.
1014 if test x"$tm_file" = x
1015 then tm_file=$cpu_type/$cpu_type.h; fi
1016
1017 if test x"$extra_headers" = x
1018 then extra_headers=; fi
1019
1020 if test x$md_file = x
1021 then md_file=$cpu_type/$cpu_type.md; fi
1022
1023 if test x$out_file = x
1024 then out_file=$cpu_type/$cpu_type.c; fi
1025
1026 if test x"$tmake_file" = x
1027 then tmake_file=$cpu_type/t-$cpu_type
1028 fi
1029
1030 if test x"$dwarf2" = xyes
1031 then tm_file="$tm_file tm-dwarf2.h"
1032 fi
1033
1034 # Say what files are being used for the output code and MD file.
1035 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1036 echo "Using \`$srcdir/config/$md_file' as machine description file."
1037
1038 # If any of the xm_file variables contain nonexistent files, warn
1039 # about them and drop them.
1040
1041 bx=
1042 for x in $build_xm_file; do
1043   if    test -f $srcdir/config/$x
1044   then      bx="$bx $x"
1045   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1046   fi
1047 done
1048 build_xm_file="$bx"
1049
1050 hx=
1051 for x in $host_xm_file; do
1052   if    test -f $srcdir/config/$x
1053   then      hx="$hx $x"
1054   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1055   fi
1056 done
1057 host_xm_file="$hx"
1058
1059 tx=
1060 for x in $xm_file; do
1061   if    test -f $srcdir/config/$x
1062   then      tx="$tx $x"
1063   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1064   fi
1065 done
1066 xm_file="$tx"
1067
1068 count=a
1069 for f in $tm_file; do
1070         count=${count}x
1071 done
1072 if test $count = ax; then
1073         echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1074 else
1075         echo "Using the following target machine macro files:"
1076         for f in $tm_file; do
1077                 echo "  $srcdir/config/$f"
1078         done
1079 fi
1080
1081 if test x$need_64bit_hwint = xyes; then
1082         AC_DEFINE(NEED_64BIT_HOST_WIDE_INT, 1,
1083 [Define to 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h).])
1084 fi
1085
1086 count=a
1087 for f in $host_xm_file; do
1088         count=${count}x
1089 done
1090 if test $count = a; then
1091         :
1092 elif test $count = ax; then
1093         echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1094 else
1095         echo "Using the following host machine macro files:"
1096         for f in $host_xm_file; do
1097                 echo "  $srcdir/config/$f"
1098         done
1099 fi
1100 echo "Using ${out_host_hook_obj} for host machine hooks."
1101
1102 if test "$host_xm_file" != "$build_xm_file"; then
1103         count=a
1104         for f in $build_xm_file; do
1105                 count=${count}x
1106         done
1107         if test $count = a; then
1108                 :
1109         elif test $count = ax; then
1110                 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1111         else
1112                 echo "Using the following build machine macro files:"
1113                 for f in $build_xm_file; do
1114                         echo "  $srcdir/config/$f"
1115                 done
1116         fi
1117 fi
1118
1119 if test x$thread_file = x; then
1120         if test x$target_thread_file != x; then
1121                 thread_file=$target_thread_file
1122         else
1123                 thread_file='single'
1124         fi
1125 fi
1126
1127 # Look for a file containing extra machine modes.
1128 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1129   extra_modes_file='$(srcdir)'/config/${extra_modes}
1130   AC_SUBST(extra_modes_file)
1131   AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "$extra_modes",
1132   [Define to the name of a file containing a list of extra machine modes
1133    for this architecture.])
1134   AC_DEFINE(EXTRA_CC_MODES, 1,
1135   [Define if the target architecture needs extra machine modes to represent
1136    the results of comparisons.])
1137 fi
1138
1139 # auto-host.h is the file containing items generated by autoconf and is
1140 # the first file included by config.h.
1141 # If host=build, it is correct to have bconfig include auto-host.h
1142 # as well.  If host!=build, we are in error and need to do more
1143 # work to find out the build config parameters.
1144 if test x$host = x$build
1145 then
1146         build_auto=auto-host.h
1147         FORBUILD=..
1148 else
1149         # We create a subdir, then run autoconf in the subdir.
1150         # To prevent recursion we set host and build for the new
1151         # invocation of configure to the build for this invocation
1152         # of configure.
1153         tempdir=build.$$
1154         rm -rf $tempdir
1155         mkdir $tempdir
1156         cd $tempdir
1157         case ${srcdir} in
1158         /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1159         *) realsrcdir=../${srcdir};;
1160         esac
1161         saved_CFLAGS="${CFLAGS}"
1162         CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1163         ${realsrcdir}/configure \
1164                 --target=$target_alias --host=$build_alias --build=$build_alias
1165         CFLAGS="${saved_CFLAGS}"
1166
1167         # We just finished tests for the build machine, so rename
1168         # the file auto-build.h in the gcc directory.
1169         mv auto-host.h ../auto-build.h
1170         cd ..
1171         rm -rf $tempdir
1172         build_auto=auto-build.h
1173         FORBUILD=../build-$build_alias
1174 fi
1175 AC_SUBST(FORBUILD)
1176
1177 tm_file="${tm_file} defaults.h"
1178 tm_p_file="${tm_p_file} tm-preds.h"
1179 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1180 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1181 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1182 # put this back in temporarily.
1183 xm_file="ansidecl.h ${xm_file}"
1184
1185 # --------
1186 # UNSORTED
1187 # --------
1188
1189 # Truncate the target if necessary
1190 if test x$host_truncate_target != x; then
1191         target=`echo $target | sed -e 's/\(..............\).*/\1/'`
1192 fi
1193
1194 # Get the version trigger filename from the toplevel
1195 if test "${with_gcc_version_trigger+set}" = set; then
1196         gcc_version_trigger=$with_gcc_version_trigger
1197 else
1198         gcc_version_trigger=${srcdir}/version.c
1199 fi
1200 changequote(,)dnl
1201 gcc_version_full=`grep version_string ${gcc_version_trigger} | sed -e 's/.*"\([^"]*\)".*/\1/'`
1202 gcc_version=`echo ${gcc_version_full} | sed -e 's/\([^ ]*\) .*/\1/'`
1203
1204 # Compile in configure arguments.
1205 if test -f configargs.h ; then
1206         # Being re-configured.
1207         gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1208         gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1209 else
1210         gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1211 fi
1212 cat > configargs.h <<EOF
1213 /* Generated automatically. */
1214 static const char configuration_arguments[] = "$gcc_config_arguments";
1215 static const char thread_model[] = "$thread_file";
1216 EOF
1217 changequote([,])dnl
1218
1219 # Internationalization
1220 PACKAGE=gcc
1221 VERSION="$gcc_version"
1222 AC_SUBST(PACKAGE)
1223 AC_SUBST(VERSION)
1224
1225 # Enable NLS support by default
1226 AC_ARG_ENABLE(nls,
1227   [  --enable-nls            use Native Language Support (default)],
1228   , enable_nls=yes)
1229
1230 # if cross compiling, disable NLS support.
1231 # It's not worth the trouble, at least for now.
1232
1233 if test "${build}" != "${host}" && test "x$enable_nls" = "xyes"; then
1234   AC_MSG_WARN(Disabling NLS support for canadian cross compiler.)
1235   enable_nls=no
1236 fi
1237
1238 AM_GNU_GETTEXT
1239
1240 # Windows32 Registry support for specifying GCC installation paths.
1241 AC_ARG_ENABLE(win32-registry,
1242 [  --disable-win32-registry
1243                           disable lookup of installation paths in the
1244                           Registry on Windows hosts
1245   --enable-win32-registry enable registry lookup (default)
1246   --enable-win32-registry=KEY
1247                           use KEY instead of GCC version as the last portion
1248                           of the registry key],,)
1249 case $host_os in
1250         win32 | pe | cygwin* | mingw32* | uwin*)
1251 AC_MSG_CHECKING(whether windows registry support is requested)
1252 if test "x$enable_win32_registry" != xno; then
1253   AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1254 [Define to 1 if installation paths should be looked up in Windows32
1255    Registry. Ignored on non windows32 hosts.])
1256   AC_MSG_RESULT(yes)
1257   AC_SEARCH_LIBS(RegOpenKeyExA, advapi32)
1258 else
1259   AC_MSG_RESULT(no)
1260 fi
1261
1262 # Check if user specified a different registry key.
1263 case "x${enable_win32_registry}" in
1264 x | xyes)
1265   # default.
1266   gcc_cv_win32_registry_key="$VERSION"
1267   ;;
1268 xno)
1269   # no registry lookup.
1270   gcc_cv_win32_registry_key=''
1271   ;;
1272 *)
1273   # user-specified key.
1274   gcc_cv_win32_registry_key="$enable_win32_registry"
1275   ;;
1276 esac
1277
1278 if test "x$enable_win32_registry" != xno; then
1279   AC_MSG_CHECKING(registry key on windows hosts)
1280   AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$gcc_cv_win32_registry_key",
1281         [Define to be the last portion of registry key on windows hosts.])
1282   AC_MSG_RESULT($gcc_cv_win32_registry_key)
1283 fi
1284 ;;
1285 esac
1286
1287 # Get an absolute path to the GCC top-level source directory
1288 holddir=`${PWDCMD-pwd}`
1289 cd $srcdir
1290 topdir=`${PWDCMD-pwd}`
1291 cd $holddir
1292
1293 # Conditionalize the makefile for this host machine.
1294 # Make-host contains the concatenation of all host makefile fragments
1295 # [there can be more than one].  This file is built by configure.frag.
1296 host_overrides=Make-host
1297 dep_host_xmake_file=
1298 for f in .. ${host_xmake_file}
1299 do
1300         if test -f ${srcdir}/config/$f
1301         then
1302                 dep_host_xmake_file="${dep_host_xmake_file} ${srcdir}/config/$f"
1303         fi
1304 done
1305
1306 # Conditionalize the makefile for this target machine.
1307 # Make-target contains the concatenation of all host makefile fragments
1308 # [there can be more than one].  This file is built by configure.frag.
1309 target_overrides=Make-target
1310 dep_tmake_file=
1311 for f in .. ${tmake_file}
1312 do
1313         if test -f ${srcdir}/config/$f
1314         then
1315                 dep_tmake_file="${dep_tmake_file} ${srcdir}/config/$f"
1316         fi
1317 done
1318
1319 symbolic_link='ln -s'
1320
1321 # If the host doesn't support symlinks, modify CC in
1322 # FLAGS_TO_PASS so CC="stage1/xgcc -Bstage1/" works.
1323 # Otherwise, we can use "CC=$(CC)".
1324 rm -f symtest.tem
1325 if $symbolic_link $srcdir/gcc.c symtest.tem 2>/dev/null
1326 then
1327         cc_set_by_configure="\$(CC)"
1328         quoted_cc_set_by_configure="\$(CC)"
1329         stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1330         quoted_stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1331 else
1332         rm -f symtest.tem
1333         if cp -p $srcdir/gcc.c symtest.tem 2>/dev/null
1334         then
1335                 symbolic_link="cp -p"
1336         else
1337                 symbolic_link="cp"
1338         fi
1339         cc_set_by_configure="\`case '\$(CC)' in stage*) echo '\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\$(CC)';; esac\`"
1340         quoted_cc_set_by_configure="\\\`case '\\\$(CC)' in stage*) echo '\\\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(CC)';; esac\\\`"
1341         stage_prefix_set_by_configure="\`case '\$(STAGE_PREFIX)' in stage*) echo '\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\$(STAGE_PREFIX)';; esac\`"
1342         quoted_stage_prefix_set_by_configure="\\\`case '\\\$(STAGE_PREFIX)' in stage*) echo '\\\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(STAGE_PREFIX)';; esac\\\`"
1343 fi
1344 rm -f symtest.tem
1345
1346 out_object_file=`basename $out_file .c`.o
1347
1348 tm_file_list=
1349 for f in $tm_file; do
1350   case $f in
1351     ansidecl.h )
1352        tm_file_list="${tm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
1353     defaults.h )
1354        tm_file_list="${tm_file_list} \$(srcdir)/$f" ;;
1355     *) tm_file_list="${tm_file_list} \$(srcdir)/config/$f" ;;
1356   esac
1357 done
1358
1359 tm_p_file_list=
1360 for f in $tm_p_file; do
1361   case $f in
1362     tm-preds.h )
1363        tm_p_file_list="${tm_p_file_list} $f" ;;
1364     *) tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f" ;;
1365   esac
1366 done
1367
1368 host_xm_file_list=
1369 for f in $host_xm_file; do
1370   case $f in
1371     ansidecl.h )
1372        host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
1373     auto-host.h )
1374        host_xm_file_list="${host_xm_file_list} $f" ;;
1375     defaults.h )
1376        host_xm_file_list="${host_xm_file_list} \$(srcdir)/$f" ;;
1377     *) host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f" ;;
1378   esac
1379 done
1380
1381 build_xm_file_list=
1382 for f in $build_xm_file; do
1383   case $f in
1384     ansidecl.h )
1385        build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
1386     auto-build.h | auto-host.h )
1387        build_xm_file_list="${build_xm_file_list} $f" ;;
1388     defaults.h )
1389        host_xm_file_list="${host_xm_file_list} \$(srcdir)/$f" ;;
1390     *) build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f" ;;
1391   esac
1392 done
1393
1394 # Define macro CROSS_COMPILE in compilation if this is a cross-compiler.
1395 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1396 CROSS=                                          AC_SUBST(CROSS)
1397 ALL=all.internal                                AC_SUBST(ALL)
1398 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1399 if test x$host != x$target
1400 then
1401         CROSS="-DCROSS_COMPILE"
1402         ALL=all.cross
1403         SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1404         case "$host","$target" in
1405             i?86-*-*,x86_64-*-* \
1406             | powerpc*-*-*,powerpc64*-*-*)
1407                 CROSS="$CROSS -DNATIVE_CROSS" ;;
1408         esac
1409 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1410         # This is just $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR)
1411         SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1412 fi
1413
1414 # If this is a cross-compiler that does not
1415 # have its own set of headers then define
1416 # inhibit_libc
1417
1418 # If this is using newlib, then define inhibit_libc in LIBGCC2_CFLAGS.
1419 # This prevents libgcc2 from containing any code which requires libc
1420 # support.
1421 inhibit_libc=
1422 if { test x$host != x$target && test "x$with_headers" = x &&
1423      test "x$with_sysroot" = x ; } || test x$with_newlib = xyes ; then
1424        inhibit_libc=-Dinhibit_libc
1425 fi
1426 AC_SUBST(inhibit_libc)
1427
1428 # When building gcc with a cross-compiler, we need to adjust things so
1429 # that the generator programs are still built with the native compiler.
1430 # Also, we cannot run fixincludes or fix-header.
1431
1432 # These are the normal (build=host) settings:
1433 BUILD_PREFIX=                   AC_SUBST(BUILD_PREFIX)
1434 BUILD_PREFIX_1=ignore-          AC_SUBST(BUILD_PREFIX_1)
1435 BUILD_CC='$(CC)'                AC_SUBST(BUILD_CC)
1436 BUILD_CFLAGS='$(ALL_CFLAGS)'    AC_SUBST(BUILD_CFLAGS)
1437
1438 STMP_FIXINC=stmp-fixinc         AC_SUBST(STMP_FIXINC)
1439 STMP_FIXPROTO=stmp-fixproto     AC_SUBST(STMP_FIXPROTO)
1440
1441 # And these apply if build != host.
1442 if test x$build != x$host
1443 then
1444     BUILD_PREFIX=build-
1445     BUILD_PREFIX_1=build-
1446     BUILD_CC='$(CC_FOR_BUILD)'
1447     BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD) $(XCFLAGS)'
1448
1449     if test "x$TARGET_SYSTEM_ROOT" = x; then
1450         STMP_FIXINC=
1451         STMP_FIXPROTO=
1452     fi
1453 fi
1454
1455 # Expand extra_headers to include complete path.
1456 # This substitutes for lots of t-* files.
1457 extra_headers_list=
1458 if test "x$extra_headers" = x
1459 then true
1460 else
1461         # Prepend ${srcdir}/config/${cpu_type}/ to every entry in extra_headers.
1462         for file in $extra_headers;
1463         do
1464                 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1465         done
1466 fi
1467
1468 # Add a definition of USE_COLLECT2 if system wants one.
1469 case $use_collect2 in
1470   no) use_collect2= ;;
1471   "") ;;
1472   *)
1473     host_xm_defines="${host_xm_defines} USE_COLLECT2"
1474     xm_defines="${xm_defines} USE_COLLECT2"
1475     ;;
1476 esac
1477
1478 # Identify the assembler which will work hand-in-glove with the newly
1479 # built GCC, so that we can examine its features.  This is the assembler
1480 # which will be driven by the driver program.
1481 #
1482 # If build != host, and we aren't building gas in-tree, we identify a
1483 # build->target assembler and hope that it will have the same features
1484 # as the host->target assembler we'll be using.
1485 AC_MSG_CHECKING(what assembler to use)
1486 in_tree_gas=no
1487 gcc_cv_as=
1488 gcc_cv_gas_major_version=
1489 gcc_cv_gas_minor_version=
1490 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1491 if test -x "$DEFAULT_ASSEMBLER"; then
1492         gcc_cv_as="$DEFAULT_ASSEMBLER"
1493 elif test -x "$AS"; then
1494         gcc_cv_as="$AS"
1495 elif test -x as$host_exeext; then
1496         # Build using assembler in the current directory.
1497         gcc_cv_as=./as$host_exeext
1498 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
1499      && test -f ../gas/Makefile; then
1500   # Single tree build which includes gas.
1501   in_tree_gas=yes
1502   _gcc_COMPUTE_GAS_VERSION
1503   rm -f as$host_exeext
1504   $symbolic_link ../gas/as-new$host_exeext as$host_exeext 2>/dev/null
1505 fi
1506
1507 if test "x$gcc_cv_as" = x; then
1508         # Search the same directories that the installed compiler will
1509         # search.  Else we may find the wrong assembler and lose.  If we
1510         # do not find a suitable assembler binary, then try the user's
1511         # path.
1512         #
1513         # Also note we have to check MD_EXEC_PREFIX before checking the
1514         # user's path.  Unfortunately, there is no good way to get at the
1515         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1516         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1517         # to be fixed as part of the make/configure rewrite too.
1518
1519         if test "x$exec_prefix" = xNONE; then
1520                 if test "x$prefix" = xNONE; then
1521                         test_prefix=/usr/local
1522                 else
1523                         test_prefix=$prefix
1524                 fi
1525         else
1526                 test_prefix=$exec_prefix
1527         fi
1528
1529         # If the loop below does not find an assembler, then use whatever
1530         # one we can find in the users's path.
1531         # user's path.
1532         if test "x$program_prefix" != xNONE; then
1533                 gcc_cv_as=${program_prefix}as$host_exeext
1534         else
1535                 gcc_cv_as=`echo as | sed ${program_transform_name}`$host_exeext
1536         fi
1537
1538         test_dirs="$test_prefix/lib/gcc-lib/$target_alias/$gcc_version \
1539                    $test_prefix/lib/gcc-lib/$target_alias \
1540                    /usr/lib/gcc/$target_alias/$gcc_version \
1541                    /usr/lib/gcc/$target_alias \
1542                    $test_prefix/$target_alias/bin/$target_alias/$gcc_version \
1543                    $test_prefix/$target_alias/bin"
1544
1545         if test x$host = x$target; then
1546             test_dirs="$test_dirs \
1547                    /usr/libexec \
1548                    /usr/ccs/gcc \
1549                    /usr/ccs/bin \
1550                    /udk/usr/ccs/bin \
1551                    /bsd43/usr/lib/cmplrs/cc \
1552                    /usr/cross64/usr/bin \
1553                    /usr/lib/cmplrs/cc \
1554                    /sysv/usr/lib/cmplrs/cc \
1555                    /svr4/usr/lib/cmplrs/cc \
1556                    /usr/bin"
1557         fi
1558
1559         for dir in $test_dirs; do
1560                 if test -x $dir/as$host_exeext; then
1561                         gcc_cv_as=$dir/as$host_exeext
1562                         break;
1563                 fi
1564         done
1565 fi
1566 case $in_tree_gas in
1567   yes)
1568     AC_MSG_RESULT("newly built gas")
1569     ;;
1570   no)
1571     AC_MSG_RESULT($gcc_cv_as)
1572     ;;
1573 esac
1574
1575 # Identify the linker which will work hand-in-glove with the newly
1576 # built GCC, so that we can examine its features.  This is the linker
1577 # which will be driven by the driver program.
1578 #
1579 # If build != host, and we aren't building gas in-tree, we identify a
1580 # build->target linker and hope that it will have the same features
1581 # as the host->target linker we'll be using.
1582 AC_MSG_CHECKING(what linker to use)
1583 in_tree_ld=no
1584 gcc_cv_ld=
1585 gcc_cv_gld_major_version=
1586 gcc_cv_gld_minor_version=
1587 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1588 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1589 if test -x "$DEFAULT_LINKER"; then
1590         gcc_cv_ld="$DEFAULT_LINKER"
1591 elif test -x "$LD"; then
1592         gcc_cv_ld="$LD"
1593 elif test -x collect-ld$host_exeext; then
1594         # Build using linker in the current directory.
1595         gcc_cv_ld=./collect-ld$host_exeext
1596 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
1597      && test -f ../ld/Makefile; then
1598         # Single tree build which includes ld.
1599         in_tree_ld=yes
1600         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
1601         do
1602 changequote(,)dnl
1603                 gcc_cv_gld_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
1604 changequote([,])dnl
1605                 if test x$gcc_cv_gld_version != x; then
1606                         break
1607                 fi
1608         done
1609 changequote(,)dnl
1610         gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
1611         gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1612 changequote([,])dnl
1613         rm -f collect-ld$host_exeext
1614         $symbolic_link ../ld/ld-new$host_exeext collect-ld$host_exeext \
1615                 2>/dev/null
1616 fi
1617
1618 if test "x$gcc_cv_ld" = x; then
1619         # Search the same directories that the installed compiler will
1620         # search.  Else we may find the wrong linker and lose.  If we
1621         # do not find a suitable linker binary, then try the user's
1622         # path.
1623         #
1624         # Also note we have to check MD_EXEC_PREFIX before checking the
1625         # user's path.  Unfortunately, there is no good way to get at the
1626         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1627         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1628         # to be fixed as part of the make/configure rewrite too.
1629
1630         if test "x$exec_prefix" = xNONE; then
1631                 if test "x$prefix" = xNONE; then
1632                         test_prefix=/usr/local
1633                 else
1634                         test_prefix=$prefix
1635                 fi
1636         else
1637                 test_prefix=$exec_prefix
1638         fi
1639
1640         # If the loop below does not find an linker, then use whatever
1641         # one we can find in the users's path.
1642         # user's path.
1643         if test "x$program_prefix" != xNONE; then
1644                 gcc_cv_ld=${program_prefix}ld$host_exeext
1645         else
1646                 gcc_cv_ld=`echo ld | sed ${program_transform_name}`$host_exeext
1647         fi
1648
1649         test_dirs="$test_prefix/lib/gcc-lib/$target_alias/$gcc_version \
1650                    $test_prefix/lib/gcc-lib/$target_alias \
1651                    /usr/lib/gcc/$target_alias/$gcc_version \
1652                    /usr/lib/gcc/$target_alias \
1653                    $test_prefix/$target_alias/bin/$target_alias/$gcc_version \
1654                    $test_prefix/$target_alias/bin"
1655
1656         if test x$host = x$target; then
1657             test_dirs="$test_dirs \
1658                    /usr/libexec \
1659                    /usr/ccs/gcc \
1660                    /usr/ccs/bin \
1661                    /udk/usr/ccs/bin \
1662                    /bsd43/usr/lib/cmplrs/cc \
1663                    /usr/cross64/usr/bin \
1664                    /usr/lib/cmplrs/cc \
1665                    /sysv/usr/lib/cmplrs/cc \
1666                    /svr4/usr/lib/cmplrs/cc \
1667                    /usr/bin"
1668         fi
1669
1670         for dir in $test_dirs; do
1671                 if test -x $dir/ld$host_exeext; then
1672                         gcc_cv_ld=$dir/ld$host_exeext
1673                         break;
1674                 fi
1675         done
1676 fi
1677 case $in_tree_ld in
1678   yes)
1679     AC_MSG_RESULT("newly built ld")
1680     ;;
1681   no)
1682     AC_MSG_RESULT($gcc_cv_ld)
1683     ;;
1684 esac
1685
1686 # Figure out what nm we will be using.
1687 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
1688 AC_MSG_CHECKING(what nm to use)
1689 in_tree_nm=no
1690 if test -x nm$host_exeext; then
1691         gcc_cv_nm=./nm$host_exeext
1692 elif test -f $gcc_cv_binutils_srcdir/configure.in \
1693      && test -f ../binutils/Makefile; then
1694         # Single tree build which includes binutils.
1695         in_tree_nm=yes
1696         gcc_cv_nm=./nm$host_exeext
1697         rm -f nm$host_exeext
1698         $symbolic_link ../binutils/nm-new$host_exeext nm$host_exeext 2>/dev/null
1699 elif test "x$program_prefix" != xNONE; then
1700         gcc_cv_nm=${program_prefix}nm$host_exeext
1701 else
1702         gcc_cv_nm=`echo nm | sed ${program_transform_name}`$host_exeext
1703 fi
1704 case $in_tree_nm in
1705   yes) AC_MSG_RESULT("newly built nm") ;;
1706   no)  AC_MSG_RESULT($gcc_cv_nm) ;;
1707 esac
1708
1709 # Figure out what objdump we will be using.
1710 AC_MSG_CHECKING(what objdump to use)
1711 in_tree_objdump=no
1712 if test -x objdump$host_exeext; then
1713         gcc_cv_objdump=./objdump$host_exeext
1714 elif test -f $gcc_cv_binutils_srcdir/configure.in \
1715      && test -f ../binutils/Makefile; then
1716         # Single tree build which includes binutils.
1717         in_tree_objdump=yes
1718         gcc_cv_objdump=./objdump$host_exeext
1719         rm -f objdump$host_exeext
1720         $symbolic_link ../binutils/objdump$host_exeext \
1721                 objdump$host_exeext 2>/dev/null
1722 elif test "x$program_prefix" != xNONE; then
1723         gcc_cv_objdump=${program_prefix}objdump$host_exeext
1724 else
1725         gcc_cv_objdump=`echo objdump | \
1726                 sed ${program_transform_name}`$host_exeext
1727 fi
1728 case $in_tree_objdump in
1729   yes) AC_MSG_RESULT("newly built objdump") ;;
1730   no)  AC_MSG_RESULT($gcc_cv_objdump) ;;
1731 esac
1732
1733 # Figure out what assembler alignment features are present.
1734 AC_MSG_CHECKING(assembler alignment features)
1735 gcc_cv_as_alignment_features=none
1736 if test $in_tree_gas = yes; then
1737   # Gas version 2.6 and later support for .balign and .p2align.
1738   gcc_GAS_VERSION_GTE_IFELSE(2,6,0,[
1739     gcc_cv_as_alignment_features=".balign and .p2align"
1740     AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN)
1741   ])
1742   # Gas version 2.8 and later support specifying the maximum
1743   # bytes to skip when using .p2align.
1744   gcc_GAS_VERSION_GTE_IFELSE(2,8,0,[
1745     gcc_cv_as_alignment_features=".p2align including maximum skip"
1746     AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN)
1747   ])
1748 elif test x$gcc_cv_as != x; then
1749         # Check if we have .balign and .p2align
1750         echo ".balign  4" > conftest.s
1751         echo ".p2align  2" >> conftest.s
1752         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1753                 gcc_cv_as_alignment_features=".balign and .p2align"
1754                 AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN)
1755         fi
1756         rm -f conftest.s conftest.o
1757         # Check if specifying the maximum bytes to skip when
1758         # using .p2align is supported.
1759         echo ".p2align 4,,7" > conftest.s
1760         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1761                 gcc_cv_as_alignment_features=".p2align including maximum skip"
1762                 AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN)
1763         fi
1764         rm -f conftest.s conftest.o
1765 fi
1766 AC_MSG_RESULT($gcc_cv_as_alignment_features)
1767
1768 AC_MSG_CHECKING(assembler subsection support)
1769 gcc_cv_as_subsections=no
1770 if test $in_tree_gas = yes ; then
1771   gcc_GAS_VERSION_GTE_IFELSE(2,9,0,[
1772     if grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
1773       gcc_cv_as_subsections="working .subsection -1"
1774     fi
1775   ])
1776 elif test x$gcc_cv_as != x; then
1777         # Check if we have .subsection
1778         echo ".subsection 1" > conftest.s
1779         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1780                 gcc_cv_as_subsections=".subsection"
1781                 if test x$gcc_cv_nm != x; then
1782                         cat > conftest.s <<EOF
1783 conftest_label1: .word 0
1784 .subsection -1
1785 conftest_label2: .word 0
1786 .previous
1787 EOF
1788                         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1789                                 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
1790                                 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
1791                                 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1; then
1792                                         :
1793                                 else
1794                                         gcc_cv_as_subsections="working .subsection -1"
1795                                 fi
1796                         fi
1797                 fi
1798         fi
1799         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1800 fi
1801 if test x"$gcc_cv_as_subsections" = x"working .subsection -1"; then
1802         AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
1803 [Define if your assembler supports .subsection and .subsection -1 starts
1804    emitting at the beginning of your section.])
1805 fi
1806 AC_MSG_RESULT($gcc_cv_as_subsections)
1807
1808 AC_MSG_CHECKING(assembler weak support)
1809 gcc_cv_as_weak=no
1810 if test $in_tree_gas = yes ; then
1811   gcc_GAS_VERSION_GTE_IFELSE(2,2,0,[
1812     gcc_cv_as_weak="yes"
1813   ])
1814 elif test x$gcc_cv_as != x; then
1815         # Check if we have .weak
1816         echo "  .weak foobar" > conftest.s
1817         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1818                 gcc_cv_as_weak="yes"
1819         fi
1820         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1821 fi
1822 if test x"$gcc_cv_as_weak" = xyes; then
1823         AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])
1824 fi
1825 AC_MSG_RESULT($gcc_cv_as_weak)
1826
1827 AC_MSG_CHECKING(assembler hidden support)
1828 gcc_cv_as_hidden=no
1829 if test $in_tree_gas = yes ; then
1830   gcc_GAS_VERSION_GTE_IFELSE(2,12,1,[
1831     if grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
1832       gcc_cv_as_hidden="yes"
1833     fi
1834   ])
1835 elif test x$gcc_cv_as != x; then
1836         # Check if we have .hidden
1837         echo "  .hidden foobar" > conftest.s
1838         echo "foobar:" >> conftest.s
1839         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1840                 gcc_cv_as_hidden="yes"
1841         fi
1842         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1843
1844         # GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
1845         # This is irritatingly difficult to feature test for.  Look for
1846         # the date string after the version number.
1847         ld_ver=`$gcc_cv_ld --version 2>/dev/null | head -1`
1848         if echo "$ld_ver" | grep GNU > /dev/null; then
1849 changequote(,)dnl
1850                ld_vers=`echo $ld_ver | sed -n 's,^.*[  ]\([0-9][0-9]*\.[0-9][0-9]*\(\|\.[0-9][0-9]*\(\|\.[0-9][0-9]*\)\)\)\([  ].*\|\)$,\1,p'`
1851                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'`
1852                 if test 0"$ld_date" -lt 20020404; then
1853                         if test -n "$ld_date"; then
1854                                 # If there was date string, but was earlier than 2002-04-04, fail
1855                                 gcc_cv_as_hidden="no"
1856                         elif test -z "$ld_vers"; then
1857                                 # If there was no date string nor ld version number, something is wrong
1858                                 gcc_cv_as_hidden="no"
1859                         else
1860                                 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
1861                                 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
1862                                 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
1863                                 test -z "$ld_vers_patch" && ld_vers_patch=0
1864                                 if test "$ld_vers_major" -lt 2; then
1865                                         gcc_cv_as_hidden="no"
1866                                 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
1867                                         gcc_cv_as_hidden="no"
1868                                 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 \
1869                                           -a "$ld_vers_patch" -eq 0; then
1870                                         gcc_cv_as_hidden="no"
1871                                 fi
1872                         fi
1873                 fi
1874 changequote([,])dnl
1875         fi
1876 fi
1877 if test x"$gcc_cv_as_hidden" = xyes; then
1878         AC_DEFINE(HAVE_GAS_HIDDEN, 1,
1879                 [Define if your assembler supports .hidden.])
1880 fi
1881 AC_MSG_RESULT($gcc_cv_as_hidden)
1882 libgcc_visibility=$gcc_cv_as_hidden
1883 case "$target" in
1884   mips-sgi-irix6*)
1885     if test x"$gnu_ld_flag" = x"no"; then
1886       # Even if using gas with .hidden support, the resulting object files
1887       # cannot be linked with the IRIX 6 O32 linker.  With the N32 and
1888       # N64 linkers, the problem is that the linker refuses to accept
1889       # -call_shared (passed by default to the linker) and -r (used to
1890       # link the object file generated without .hidden directives with
1891       # one that hides symbols), so we also lose.
1892       libgcc_visibility=no
1893     fi
1894     ;;
1895 esac
1896 AC_SUBST(libgcc_visibility)
1897
1898 AC_MSG_CHECKING(assembler leb128 support)
1899 gcc_cv_as_leb128=no
1900 if test $in_tree_gas = yes ; then
1901   gcc_GAS_VERSION_GTE_IFELSE(2,11,0,[
1902     if grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
1903       gcc_cv_as_leb128="yes"
1904     fi
1905   ])
1906 elif test x$gcc_cv_as != x; then
1907         # Check if we have .[us]leb128, and support symbol arithmetic with it.
1908         cat > conftest.s <<EOF
1909         .data
1910         .uleb128 L2 - L1
1911 L1:
1912         .uleb128 1280
1913         .sleb128 -1010
1914 L2:
1915 EOF
1916         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1917                 gcc_cv_as_leb128="yes"
1918
1919                 # GAS versions before 2.11 do not support uleb128,
1920                 # despite appearing to.
1921                 # ??? There exists an elf-specific test that will crash
1922                 # the assembler.  Perhaps it's better to figure out whether
1923                 # arbitrary sections are supported and try the test.
1924                 as_ver=`$gcc_cv_as --version 2>/dev/null | head -1`
1925                 if echo "$as_ver" | grep GNU > /dev/null; then
1926 changequote(,)dnl
1927                         as_ver=`echo $as_ver | sed -e 's/GNU assembler \([0-9.][0-9.]*\).*/\1/'`
1928                         as_major=`echo $as_ver | sed 's/\..*//'`
1929                         as_minor=`echo $as_ver | sed 's/[^.]*\.\([0-9]*\).*/\1/'`
1930 changequote([,])dnl
1931                         if test $as_major -eq 2 -a $as_minor -lt 11; then
1932                                 gcc_cv_as_leb128="no"
1933                         fi
1934                 fi
1935         fi
1936         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1937 fi
1938 if test x"$gcc_cv_as_leb128" = xyes; then
1939         AC_DEFINE(HAVE_AS_LEB128, 1,
1940                 [Define if your assembler supports .uleb128.])
1941 fi
1942 AC_MSG_RESULT($gcc_cv_as_leb128)
1943
1944 AC_MSG_CHECKING(assembler eh_frame optimization)
1945 gcc_cv_as_eh_frame=no
1946 if test $in_tree_gas = yes ; then
1947   gcc_GAS_VERSION_GTE_IFELSE(2,12,0,[
1948     if grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
1949       gcc_cv_as_eh_frame="yes"
1950     fi
1951   ])
1952 elif test x$gcc_cv_as != x; then
1953         # Check if this is GAS.
1954         as_ver=`$gcc_cv_as --version < /dev/null 2> /dev/null | head -1`
1955         rm -f a.out 2> /dev/null
1956         if echo "$as_ver" | grep GNU > /dev/null; then
1957                 # Versions up to and including 2.11.0 may mis-optimize
1958                 # .eh_frame data.  Try something.
1959                 cat > conftest.s <<EOF
1960         .text
1961 .LFB1:
1962         .4byte  0
1963 .L1:
1964         .4byte  0
1965 .LFE1:
1966         .section        .eh_frame,"aw",@progbits
1967 __FRAME_BEGIN__:
1968         .4byte  .LECIE1-.LSCIE1
1969 .LSCIE1:
1970         .4byte  0x0
1971         .byte   0x1
1972         .ascii "z\0"
1973         .byte   0x1
1974         .byte   0x78
1975         .byte   0x1a
1976         .byte   0x0
1977         .byte   0x4
1978         .4byte  1
1979         .p2align 1
1980 .LECIE1:
1981 .LSFDE1:
1982         .4byte  .LEFDE1-.LASFDE1
1983 .LASFDE1:
1984         .4byte  .LASFDE1-__FRAME_BEGIN__
1985         .4byte  .LFB1
1986         .4byte  .LFE1-.LFB1
1987         .byte   0x4
1988         .4byte  .LFE1-.LFB1
1989         .byte   0x4
1990         .4byte  .L1-.LFB1
1991 .LEFDE1:
1992 EOF
1993                 cat > conftest.lit <<EOF
1994  0000 10000000 00000000 017a0001 781a0004  .........z..x...
1995  0010 01000000 12000000 18000000 00000000  ................
1996  0020 08000000 04080000 0044               .........D
1997 EOF
1998                 cat > conftest.big <<EOF
1999  0000 00000010 00000000 017a0001 781a0004  .........z..x...
2000  0010 00000001 00000012 00000018 00000000  ................
2001  0020 00000008 04000000 0844               .........D
2002 EOF
2003                 # If the assembler didn't choke, and we can objdump,
2004                 # and we got the correct data, then succeed.
2005                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
2006                    && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2007                       | tail -3 > conftest.got \
2008                    && { cmp conftest.lit conftest.got > /dev/null 2>&1 \
2009                         || cmp conftest.big conftest.got > /dev/null 2>&1; }
2010                 then
2011                         gcc_cv_as_eh_frame="yes"
2012                 else
2013                         gcc_cv_as_eh_frame="bad"
2014                         if $gcc_cv_as -o conftest.o --traditional-format /dev/null; then
2015                                 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2016         [Define if your assembler mis-optimizes .eh_frame data.])
2017                         fi
2018                 fi
2019         fi
2020         rm -f conftest.*
2021 fi
2022 AC_MSG_RESULT($gcc_cv_as_eh_frame)
2023
2024 AC_MSG_CHECKING(assembler section merging support)
2025 gcc_cv_as_shf_merge=no
2026 if test $in_tree_gas = yes ; then
2027   gcc_GAS_VERSION_GTE_IFELSE(2,12,0,[
2028     if grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
2029       gcc_cv_as_shf_merge=yes
2030     fi
2031   ])
2032 elif test x$gcc_cv_as != x; then
2033         # Check if we support SHF_MERGE sections
2034         echo '.section .rodata.str, "aMS", @progbits, 1' > conftest.s
2035         if $gcc_cv_as --fatal-warnings -o conftest.o conftest.s > /dev/null 2>&1; then
2036                 gcc_cv_as_shf_merge=yes
2037         fi
2038         rm -f conftest.s conftest.o
2039 fi
2040 if test x"$gcc_cv_as_shf_merge" = xyes; then
2041         AC_DEFINE(HAVE_GAS_SHF_MERGE, 1,
2042 [Define if your assembler supports marking sections with SHF_MERGE flag.])
2043 fi
2044 AC_MSG_RESULT($gcc_cv_as_shf_merge)
2045
2046 AC_MSG_CHECKING(assembler thread-local storage support)
2047 gcc_cv_as_tls=no
2048 conftest_s=
2049 tls_first_major=
2050 tls_first_minor=
2051 case "$target" in
2052 changequote(,)dnl
2053   alpha*-*-*)
2054     conftest_s='
2055         .section ".tdata","awT",@progbits
2056 foo:    .long   25
2057         .text
2058         ldq     $27,__tls_get_addr($29)         !literal!1
2059         lda     $16,foo($29)                    !tlsgd!1
2060         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
2061         ldq     $27,__tls_get_addr($29)         !literal!2
2062         lda     $16,foo($29)                    !tlsldm!2
2063         jsr     $26,($27),__tls_get_addr        !lituse_tlsldm!2
2064         ldq     $1,foo($29)                     !gotdtprel
2065         ldah    $2,foo($29)                     !dtprelhi
2066         lda     $3,foo($2)                      !dtprello
2067         lda     $4,foo($29)                     !dtprel
2068         ldq     $1,foo($29)                     !gottprel
2069         ldah    $2,foo($29)                     !tprelhi
2070         lda     $3,foo($2)                      !tprello
2071         lda     $4,foo($29)                     !tprel'
2072         tls_first_major=2
2073         tls_first_minor=13
2074         ;;
2075   i[34567]86-*-*)
2076 changequote([,])dnl
2077     conftest_s='
2078         .section ".tdata","awT",@progbits
2079 foo:    .long   25
2080         .text
2081         movl    %gs:0, %eax
2082         leal    foo@TLSGD(,%ebx,1), %eax
2083         leal    foo@TLSLDM(%ebx), %eax
2084         leal    foo@DTPOFF(%eax), %edx
2085         movl    foo@GOTTPOFF(%ebx), %eax
2086         subl    foo@GOTTPOFF(%ebx), %eax
2087         addl    foo@GOTNTPOFF(%ebx), %eax
2088         movl    foo@INDNTPOFF, %eax
2089         movl    $foo@TPOFF, %eax
2090         subl    $foo@TPOFF, %eax
2091         leal    foo@NTPOFF(%ecx), %eax'
2092         tls_first_major=2
2093         tls_first_minor=14
2094         ;;
2095   x86_64-*-*)
2096     conftest_s='
2097         .section ".tdata","awT",@progbits
2098 foo:    .long   25
2099         .text
2100         movq    %fs:0, %rax
2101         leaq    foo@TLSGD(%rip), %rdi
2102         leaq    foo@TLSLD(%rip), %rdi
2103         leaq    foo@DTPOFF(%rax), %rdx
2104         movq    foo@GOTTPOFF(%rip), %rax
2105         movq    $foo@TPOFF, %rax'
2106         tls_first_major=2
2107         tls_first_minor=14
2108         ;;
2109   ia64-*-*)
2110     conftest_s='
2111         .section ".tdata","awT",@progbits
2112 foo:    data8   25
2113         .text
2114         addl    r16 = @ltoff(@dtpmod(foo#)), gp
2115         addl    r17 = @ltoff(@dtprel(foo#)), gp
2116         addl    r18 = @ltoff(@tprel(foo#)), gp
2117         addl    r19 = @dtprel(foo#), gp
2118         adds    r21 = @dtprel(foo#), r13
2119         movl    r23 = @dtprel(foo#)
2120         addl    r20 = @tprel(foo#), gp
2121         adds    r22 = @tprel(foo#), r13
2122         movl    r24 = @tprel(foo#)'
2123         tls_first_major=2
2124         tls_first_minor=13
2125         ;;
2126   powerpc-*-*)
2127     conftest_s='
2128         .section ".tdata","awT",@progbits
2129         .align 2
2130 ld0:    .space 4
2131 ld1:    .space 4
2132 x1:     .space 4
2133 x2:     .space 4
2134 x3:     .space 4
2135         .text
2136         addi 3,31,ld0@got@tlsgd
2137         bl __tls_get_addr
2138         addi 3,31,x1@got@tlsld
2139         bl __tls_get_addr
2140         addi 9,3,x1@dtprel
2141         addis 9,3,x2@dtprel@ha
2142         addi 9,9,x2@dtprel@l
2143         lwz 9,x3@got@tprel(31)
2144         add 9,9,x@tls
2145         addi 9,2,x1@tprel
2146         addis 9,2,x2@tprel@ha
2147         addi 9,9,x2@tprel@l'
2148         tls_first_major=2
2149         tls_first_minor=14
2150         ;;
2151   powerpc64-*-*)
2152     conftest_s='
2153         .section ".tdata","awT",@progbits
2154         .align 3
2155 ld0:    .space 8
2156 ld1:    .space 8
2157 x1:     .space 8
2158 x2:     .space 8
2159 x3:     .space 8
2160         .text
2161         addi 3,2,ld0@got@tlsgd
2162         bl .__tls_get_addr
2163         nop
2164         addi 3,2,ld1@toc
2165         bl .__tls_get_addr
2166         nop
2167         addi 3,2,x1@got@tlsld
2168         bl .__tls_get_addr
2169         nop
2170         addi 9,3,x1@dtprel
2171         bl .__tls_get_addr
2172         nop
2173         addis 9,3,x2@dtprel@ha
2174         addi 9,9,x2@dtprel@l
2175         bl .__tls_get_addr
2176         nop
2177         ld 9,x3@got@dtprel(2)
2178         add 9,9,3
2179         bl .__tls_get_addr
2180         nop'
2181         tls_first_major=2
2182         tls_first_minor=14
2183         ;;
2184   s390-*-*)
2185     conftest_s='
2186         .section ".tdata","awT",@progbits
2187 foo:    .long   25
2188         .text
2189         .long   foo@TLSGD
2190         .long   foo@TLSLDM
2191         .long   foo@DTPOFF
2192         .long   foo@NTPOFF
2193         .long   foo@GOTNTPOFF
2194         .long   foo@INDNTPOFF
2195         l       %r1,foo@GOTNTPOFF(%r12)
2196         l       %r1,0(%r1):tls_load:foo
2197         bas     %r14,0(%r1,%r13):tls_gdcall:foo
2198         bas     %r14,0(%r1,%r13):tls_ldcall:foo'
2199         tls_first_major=2
2200         tls_first_minor=14
2201         ;;
2202   s390x-*-*)
2203     conftest_s='
2204         .section ".tdata","awT",@progbits
2205 foo:    .long   25
2206         .text
2207         .quad   foo@TLSGD
2208         .quad   foo@TLSLDM
2209         .quad   foo@DTPOFF
2210         .quad   foo@NTPOFF
2211         .quad   foo@GOTNTPOFF
2212         lg      %r1,foo@GOTNTPOFF(%r12)
2213         larl    %r1,foo@INDNTPOFF
2214         brasl   %r14,__tls_get_offset@PLT:tls_gdcall:foo
2215         brasl   %r14,__tls_get_offset@PLT:tls_ldcall:foo'
2216         tls_first_major=2
2217         tls_first_minor=14
2218         ;;
2219 esac
2220 if test -z "$tls_first_major"; then
2221   :
2222 elif test $in_tree_gas = yes ; then
2223   gcc_GAS_VERSION_GTE_IFELSE($tls_first_major,$tls_first_minor,0,[
2224     gcc_cv_as_tls=yes
2225   ])
2226 elif test x$gcc_cv_as != x; then
2227   echo "$conftest_s" > conftest.s
2228   if $gcc_cv_as --fatal-warnings -o conftest.o conftest.s > /dev/null 2>&1
2229   then
2230     gcc_cv_as_tls=yes
2231   fi
2232   rm -f conftest.s conftest.o
2233 fi
2234 if test "$gcc_cv_as_tls" = yes; then
2235   AC_DEFINE(HAVE_AS_TLS, 1,
2236             [Define if your assembler supports thread-local storage.])
2237 fi
2238 AC_MSG_RESULT($gcc_cv_as_tls)
2239
2240 case "$target" in
2241   # All TARGET_ABI_OSF targets.
2242   alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
2243     AC_CACHE_CHECK([assembler supports explicit relocations],
2244         gcc_cv_as_explicit_relocs, [
2245         gcc_cv_as_explicit_relocs=unknown
2246         if test $in_tree_gas = yes ; then
2247            gcc_GAS_VERSION_GTE_IFELSE(2,12,0,[
2248               gcc_cv_as_explicit_relocs=yes
2249            ])
2250         elif test x$gcc_cv_as != x; then
2251             cat > conftest.s << 'EOF'
2252         .set nomacro
2253         .text
2254         extbl   $3, $2, $3      !lituse_bytoff!1
2255         ldq     $2, a($29)      !literal!1
2256         ldq     $4, b($29)      !literal!2
2257         ldq_u   $3, 0($2)       !lituse_base!1
2258         ldq     $27, f($29)     !literal!5
2259         jsr     $26, ($27), f   !lituse_jsr!5
2260         ldah    $29, 0($26)     !gpdisp!3
2261         lda     $0, c($29)      !gprel
2262         ldah    $1, d($29)      !gprelhigh
2263         lda     $1, d($1)       !gprellow
2264         lda     $29, 0($29)     !gpdisp!3
2265 EOF
2266             if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2267                 gcc_cv_as_explicit_relocs=yes
2268             else
2269                 gcc_cv_as_explicit_relocs=no
2270             fi
2271             rm -f conftest.s conftest.o
2272         fi
2273     ])
2274     if test "x$gcc_cv_as_explicit_relocs" = xyes; then
2275         AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
2276                 [Define if your assembler supports explicit relocations.])
2277     fi
2278     ;;
2279   sparc*-*-*)
2280     AC_CACHE_CHECK([assembler .register pseudo-op support],
2281         gcc_cv_as_register_pseudo_op, [
2282         gcc_cv_as_register_pseudo_op=unknown
2283         if test x$gcc_cv_as != x; then
2284             # Check if we have .register
2285             echo ".register %g2, #scratch" > conftest.s
2286             if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2287                 gcc_cv_as_register_pseudo_op=yes
2288             else
2289                 gcc_cv_as_register_pseudo_op=no
2290             fi
2291             rm -f conftest.s conftest.o
2292         fi
2293     ])
2294     if test "x$gcc_cv_as_register_pseudo_op" = xyes; then
2295         AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
2296                 [Define if your assembler supports .register.])
2297     fi
2298
2299     AC_CACHE_CHECK([assembler supports -relax],
2300         gcc_cv_as_relax_opt, [
2301         gcc_cv_as_relax_opt=unknown
2302         if test x$gcc_cv_as != x; then
2303             # Check if gas supports -relax
2304             echo ".text" > conftest.s
2305             if $gcc_cv_as -relax -o conftest.o conftest.s > /dev/null 2>&1; then
2306                 gcc_cv_as_relax_opt=yes
2307             else
2308                 gcc_cv_as_relax_opt=no
2309             fi
2310             rm -f conftest.s conftest.o
2311         fi
2312     ])
2313     if test "x$gcc_cv_as_relax_opt" = xyes; then
2314         AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
2315                 [Define if your assembler supports -relax option.])
2316     fi
2317
2318     AC_CACHE_CHECK([assembler and linker support unaligned pc related relocs],
2319         gcc_cv_as_sparc_ua_pcrel, [
2320         gcc_cv_as_sparc_ua_pcrel=unknown
2321         if test x$gcc_cv_as != x -a x$gcc_cv_ld != x; then
2322             gcc_cv_as_sparc_ua_pcrel=no
2323             echo ".text; foo: nop; .data; .align 4; .byte 0; .uaword %r_disp32(foo)" > conftest.s
2324             if $gcc_cv_as -K PIC -o conftest.o conftest.s > /dev/null 2>&1 \
2325                && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
2326                 gcc_cv_as_sparc_ua_pcrel=yes
2327             fi
2328             rm -f conftest.s conftest.o conftest
2329         fi
2330     ])
2331     if test "x$gcc_cv_as_sparc_ua_pcrel" = xyes; then
2332         AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
2333                 [Define if your assembler and linker support unaligned PC relative relocs.])
2334     fi
2335
2336     AC_CACHE_CHECK([assembler and linker support unaligned pc related relocs against hidden symbols],
2337         gcc_cv_as_sparc_ua_pcrel_hidden, [
2338         if test "x$gcc_cv_as_sparc_ua_pcrel" = xyes; then
2339             gcc_cv_as_sparc_ua_pcrel_hidden=unknown
2340             if test x$gcc_cv_objdump != x; then
2341                 gcc_cv_as_sparc_ua_pcrel_hidden=no
2342                 echo ".data; .align 4; .byte 0x31; .uaword %r_disp32(foo)" > conftest.s
2343                 echo ".byte 0x32, 0x33, 0x34; .global foo; .hidden foo" >> conftest.s
2344                 echo "foo: .skip 4" >> conftest.s
2345                 if $gcc_cv_as -K PIC -o conftest.o conftest.s > /dev/null 2>&1 \
2346                    && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
2347                    && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
2348                       | grep ' 31000000 07323334' > /dev/null 2>&1; then
2349                     if $gcc_cv_objdump -R conftest 2> /dev/null \
2350                        | grep 'DISP32' > /dev/null 2>&1; then
2351                         :
2352                     else
2353                         gcc_cv_as_sparc_ua_pcrel_hidden=yes
2354                     fi
2355                 fi
2356             fi
2357             rm -f conftest.s conftest.o conftest
2358         else
2359             gcc_cv_as_sparc_ua_pcrel_hidden="$gcc_cv_as_sparc_ua_pcrel"
2360         fi
2361     ])
2362     if test "x$gcc_cv_as_sparc_ua_pcrel_hidden" = xyes; then
2363         AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
2364                 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])
2365     fi
2366
2367     AC_CACHE_CHECK([for assembler offsetable %lo() support],
2368         gcc_cv_as_offsetable_lo10, [
2369         gcc_cv_as_offsetable_lo10=unknown
2370         if test "x$gcc_cv_as" != x; then
2371             # Check if assembler has offsetable %lo()
2372             echo "or %g1, %lo(ab) + 12, %g1" > conftest.s
2373             echo "or %g1, %lo(ab + 12), %g1" > conftest1.s
2374             if $gcc_cv_as -xarch=v9 -o conftest.o conftest.s \
2375                     > /dev/null 2>&1 &&
2376                $gcc_cv_as -xarch=v9 -o conftest1.o conftest1.s \
2377                     > /dev/null 2>&1; then
2378                 if cmp conftest.o conftest1.o > /dev/null 2>&1; then
2379                     gcc_cv_as_offsetable_lo10=no
2380                 else
2381                     gcc_cv_as_offsetable_lo10=yes
2382                 fi
2383             else
2384                 gcc_cv_as_offsetable_lo10=no
2385             fi
2386             rm -f conftest.s conftest.o conftest1.s conftest1.o
2387         fi
2388     ])
2389     if test "x$gcc_cv_as_offsetable_lo10" = xyes; then
2390         AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
2391             [Define if your assembler supports offsetable %lo().])
2392     fi
2393
2394     ;;
2395
2396 changequote(,)dnl
2397   i[34567]86-*-* | x86_64-*-*)
2398 changequote([,])dnl
2399     AC_MSG_CHECKING(assembler instructions)
2400     gcc_cv_as_instructions=
2401     if test $in_tree_gas = yes ; then
2402       gcc_GAS_VERSION_GTE_IFELSE(2,9,0,[
2403         gcc_cv_as_instructions="filds fists"
2404       ])
2405     elif test x$gcc_cv_as != x; then
2406         set "filds fists" "filds mem; fists mem"
2407         while test $# -gt 0
2408         do
2409                 echo "$2" > conftest.s
2410                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2411                         gcc_cv_as_instructions=${gcc_cv_as_instructions}$1" "
2412                 fi
2413                 shift 2
2414         done
2415         rm -f conftest.s conftest.o
2416     fi
2417     if test x"$gcc_cv_as_instructions" != x; then
2418         AC_DEFINE_UNQUOTED(HAVE_GAS_`echo "$gcc_cv_as_instructions" | sed -e 's/ $//' | tr '[a-z ]' '[A-Z_]'`)
2419     fi
2420     AC_MSG_RESULT($gcc_cv_as_instructions)
2421
2422     AC_MSG_CHECKING(assembler GOTOFF in data directives)
2423     gcc_cv_as_gotoff_in_data=no
2424     if test $in_tree_gas = yes ; then
2425       gcc_GAS_VERSION_GTE_IFELSE(2,11,0,[
2426         gcc_cv_as_gotoff_in_data=yes
2427       ])
2428     elif test x$gcc_cv_as != x; then
2429         cat > conftest.s <<EOF
2430         .text
2431 .L0:
2432         nop
2433         .data
2434         .long .L0@GOTOFF
2435 EOF
2436         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2437           gcc_cv_as_gotoff_in_data=yes
2438         fi
2439     fi
2440     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
2441       [`if test $gcc_cv_as_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
2442       [Define true if the assembler supports '.long foo@GOTOFF'.])
2443     AC_MSG_RESULT($gcc_cv_as_gotoff_in_data)
2444     ;;
2445
2446   ia64*-*-*)
2447     AC_CACHE_CHECK([assembler supports ltoffx and ldxmov],
2448         gcc_cv_as_ltoffx_ldxmov_relocs, [
2449         gcc_cv_as_ltoffx_ldxmov_relocs=unknown
2450         if test $in_tree_gas = yes ; then
2451           gcc_GAS_VERSION_GTE_IFELSE(2,14,0,[
2452             gcc_cv_as_ltoffx_ldxmov_relocs=yes
2453           ])
2454         elif test x$gcc_cv_as != x; then
2455             cat > conftest.s << 'EOF'
2456 changequote(,)dnl
2457         .text
2458         addl r15 = @ltoffx(x#), gp
2459         ;;
2460         ld8.mov r16 = [r15], x#
2461 EOF
2462 changequote([,])dnl
2463             if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2464                 gcc_cv_as_ltoffx_ldxmov_relocs=yes
2465             else
2466                 gcc_cv_as_ltoffx_ldxmov_relocs=no
2467             fi
2468             rm -f conftest.s conftest.o
2469         fi
2470     ])
2471     if test "x$gcc_cv_as_ltoffx_ldxmov_relocs" = xyes; then
2472         AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
2473           [Define if your assembler supports ltoffx and ldxmov relocations.])
2474     fi
2475     ;;
2476 esac
2477
2478 AC_MSG_CHECKING(assembler dwarf2 debug_line support)
2479 gcc_cv_as_dwarf2_debug_line=no
2480 # ??? Not all targets support dwarf2 debug_line, even within a version
2481 # of gas.  Moreover, we need to emit a valid instruction to trigger any
2482 # info to the output file.  So, as supported targets are added to gas 2.11,
2483 # add some instruction here to (also) show we expect this might work.
2484 # ??? Once 2.11 is released, probably need to add first known working
2485 # version to the per-target configury.
2486 case "$target" in
2487   i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* \
2488   | x86_64*-*-* | hppa*-*-* | arm*-*-* | strongarm*-*-* | xscale*-*-* | xstormy16*-*-*)
2489     insn="nop"
2490     ;;
2491   ia64*-*-*)
2492     insn="nop 0"
2493     ;;
2494   esac
2495 if test $in_tree_gas = yes ; then
2496   gcc_GAS_VERSION_GTE_IFELSE(2,11,0,[
2497     if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2498         && test x"$insn" != x ; then
2499       gcc_cv_as_dwarf2_debug_line="yes"
2500     fi
2501   ])
2502 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2503         echo '  .file 1 "conftest.s"' > conftest.s
2504         echo '  .loc 1 3 0' >> conftest.s
2505         echo "  $insn" >> conftest.s
2506         # ??? This fails with non-gnu grep.
2507         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
2508            && grep debug_line conftest.o > /dev/null 2>&1 ; then
2509                 # The .debug_line file table must be in the exact order that
2510                 # we specified the files, since these indices are also used
2511                 # by DW_AT_decl_file.  Approximate this test by testing if
2512                 # the assembler bitches if the same index is assigned twice.
2513                 echo '  .file 1 "foo.s"' > conftest.s
2514                 echo '  .file 1 "bar.s"' >> conftest.s
2515                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1
2516                 then
2517                   gcc_cv_as_dwarf2_debug_line="no"
2518                 else
2519                   gcc_cv_as_dwarf2_debug_line="yes"
2520                 fi
2521         fi
2522         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
2523 fi
2524 if test x"$gcc_cv_as_dwarf2_debug_line" = xyes; then
2525         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
2526 [Define if your assembler supports dwarf2 .file/.loc directives,
2527    and preserves file table indices exactly as given.])
2528 fi
2529 AC_MSG_RESULT($gcc_cv_as_dwarf2_debug_line)
2530
2531 AC_MSG_CHECKING(assembler --gdwarf2 support)
2532 gcc_cv_as_gdwarf2_flag=no
2533 if test $in_tree_gas = yes ; then
2534   gcc_GAS_VERSION_GTE_IFELSE(2,11,0,[
2535     if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2536         && test x"$insn" != x ; then
2537       gcc_cv_as_gdwarf2_flag="yes"
2538     fi
2539   ])
2540 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2541         echo '' > conftest.s
2542         # ??? This fails with non-gnu grep.
2543         if $gcc_cv_as --gdwarf2 -o conftest.o conftest.s > /dev/null 2>&1
2544           then
2545           gcc_cv_as_gdwarf2_flag="yes"
2546         fi
2547         rm -f conftest.s conftest.o
2548 fi
2549 if test x"$gcc_cv_as_gdwarf2_flag" = xyes; then
2550         AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
2551 [Define if your assembler supports the --gdwarf2 option.])
2552 fi
2553 AC_MSG_RESULT($gcc_cv_as_gdwarf2_flag)
2554
2555 AC_MSG_CHECKING(assembler --gstabs support)
2556 gcc_cv_as_gstabs_flag=no
2557 if test $in_tree_gas = yes ; then
2558   gcc_GAS_VERSION_GTE_IFELSE(2,11,0,[
2559     if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2560         && test x"$insn" != x ; then
2561       gcc_cv_as_gstabs_flag="yes"
2562     fi
2563   ])
2564 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2565         echo '' > conftest.s
2566         # ??? This fails with non-gnu grep.
2567         if $gcc_cv_as --gstabs -o conftest.o conftest.s > /dev/null 2>&1 ; then
2568           gcc_cv_as_gstabs_flag="yes"
2569         fi
2570         rm -f conftest.s conftest.o
2571 fi
2572 if test x"$gcc_cv_as_gstabs_flag" = xyes; then
2573         AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
2574 [Define if your assembler supports the --gstabs option.])
2575 fi
2576 AC_MSG_RESULT($gcc_cv_as_gstabs_flag)
2577
2578 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2579 gcc_cv_ld_ro_rw_mix=unknown
2580 if test $in_tree_ld = yes ; then
2581   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
2582     gcc_cv_ld_ro_rw_mix=read-write
2583   fi
2584 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2585   echo '.section "myfoosect", "a"' > conftest1.s
2586   echo '.section "myfoosect", "aw"' > conftest2.s
2587   echo '.byte 1' >> conftest2.s
2588   echo '.section "myfoosect", "a"' > conftest3.s
2589   echo '.byte 0' >> conftest3.s
2590   if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2591      && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2592      && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2593      && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2594         conftest2.o conftest3.o; then
2595     gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2596                          | grep -A1 myfoosect`
2597     if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2598       if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2599         gcc_cv_ld_ro_rw_mix=read-only
2600       else
2601         gcc_cv_ld_ro_rw_mix=read-write
2602       fi
2603     fi
2604   fi
2605 changequote(,)dnl
2606   rm -f conftest.* conftest[123].*
2607 changequote([,])dnl
2608 fi
2609 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2610         AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2611   [Define if your linker links a mix of read-only
2612    and read-write sections into a read-write section.])
2613 fi
2614 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2615
2616 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
2617 gcc_cv_ld_eh_frame_hdr=no
2618 if test $in_tree_ld = yes ; then
2619   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
2620     gcc_cv_ld_eh_frame_hdr=yes
2621   fi
2622 elif test x$gcc_cv_ld != x; then
2623         # Check if linker supports --eh-frame-hdr option
2624         if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
2625                 gcc_cv_ld_eh_frame_hdr=yes
2626         fi
2627 fi
2628 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
2629         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
2630 [Define if your linker supports --eh-frame-hdr option.])
2631 fi
2632 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
2633
2634 # Miscellaneous target-specific checks.
2635 case "$target" in
2636   mips*-*-*)
2637     AC_MSG_CHECKING(whether libgloss uses STARTUP directives consistently)
2638     gcc_cv_mips_libgloss_startup=no
2639     gcc_cv_libgloss_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/libgloss
2640     if test "x$exec_prefix" = xNONE; then
2641       if test "x$prefix" = xNONE; then
2642         test_prefix=/usr/local
2643       else
2644         test_prefix=$prefix
2645       fi
2646     else
2647       test_prefix=$exec_prefix
2648     fi
2649     for f in $gcc_cv_libgloss_srcdir/mips/idt.ld $test_prefix/$target_alias/lib/idt.ld
2650     do
2651       if grep '^STARTUP' $f > /dev/null 2>&1; then
2652         gcc_cv_mips_libgloss_startup=yes
2653         break
2654       fi
2655     done
2656     if test x"$gcc_cv_mips_libgloss_startup" = xyes; then
2657       AC_DEFINE(HAVE_MIPS_LIBGLOSS_STARTUP_DIRECTIVES, 1,
2658         [Define if your MIPS libgloss linker scripts consistently include STARTUP directives.])
2659     fi
2660     AC_MSG_RESULT($gcc_cv_mips_libgloss_startup)
2661
2662     AC_MSG_CHECKING(whether the assembler has explicit relocation support)
2663     if test x$gcc_cv_mips_explicit_relocs = x; then
2664       gcc_cv_mips_explicit_relocs=no
2665       if test x$gcc_cv_as != x; then
2666         echo '  lw $4,%gp_rel(foo)($4)' > conftest.s
2667         if $gcc_cv_as conftest.s -o conftest.o > /dev/null 2>&1; then
2668           gcc_cv_mips_explicit_relocs=yes
2669         fi
2670         rm -f conftest.s conftest.o
2671       fi
2672     fi
2673     if test $gcc_cv_mips_explicit_relocs = yes; then
2674       test x$target_cpu_default != x || target_cpu_default=0
2675       target_cpu_default="(${target_cpu_default}|MASK_EXPLICIT_RELOCS)"
2676     fi
2677     AC_MSG_RESULT($gcc_cv_mips_explicit_relocs)
2678     ;;
2679 esac
2680
2681 if test x$with_sysroot = x && test x$host = x$target \
2682    && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" ; then
2683   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include")
2684 fi
2685
2686 # Figure out what language subdirectories are present.
2687 # Look if the user specified --enable-languages="..."; if not, use
2688 # the environment variable $LANGUAGES if defined. $LANGUAGES might
2689 # go away some day.
2690 # NB:  embedded tabs in this IF block -- do not untabify
2691 if test x"${enable_languages+set}" != xset; then
2692         if test x"${LANGUAGES+set}" = xset; then
2693                 enable_languages="${LANGUAGES}"
2694                 AC_MSG_WARN([setting LANGUAGES is deprecated, use --enable-languages instead])
2695
2696         else
2697                 enable_languages=all
2698         fi
2699 else
2700         if test x"${enable_languages}" = x \
2701         || test x"${enable_languages}" = xyes;
2702         then
2703                 AC_MSG_ERROR([--enable-languages needs at least one language argument])
2704         fi
2705 fi
2706 enable_languages=`echo "${enable_languages}" | sed -e 's/[[     ,]][[   ,]]*/,/g' -e 's/,$//'`
2707
2708 # First scan to see if an enabled language requires some other language.
2709 # We assume that a given config-lang.in will list all the language
2710 # front ends it requires, even if some are required indirectly.
2711 for lang in ${srcdir}/*/config-lang.in ..
2712 do
2713    case $lang in
2714     ..)
2715        ;;
2716     # The odd quoting in the next line works around
2717     # an apparent bug in bash 1.12 on linux.
2718 changequote(,)dnl
2719     ${srcdir}/[*]/config-lang.in)
2720        ;;
2721     *)
2722        lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^      ]*\).*$,\1,p' $lang`
2723        this_lang_requires=`sed -n -e 's,^lang_requires=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^lang_requires=\([^    ]*\).*$,\1,p' $lang`
2724        for other in $this_lang_requires
2725        do
2726           case ,${enable_languages}, in
2727            *,$other,*)
2728               ;;
2729            *,all,*)
2730               ;;
2731            *,$lang_alias,*)
2732               enable_languages="$enable_languages,$other"
2733               ;;
2734           esac
2735        done
2736        ;;
2737 changequote([,])dnl
2738    esac
2739 done
2740
2741 expected_languages=`echo ,${enable_languages}, | sed -e 's:,: :g' -e 's:  *: :g' -e 's:  *: :g' -e 's:^ ::' -e 's: $::'`
2742 found_languages=
2743 subdirs=
2744 for lang in ${srcdir}/*/config-lang.in ..
2745 do
2746         case $lang in
2747         ..) ;;
2748         # The odd quoting in the next line works around
2749         # an apparent bug in bash 1.12 on linux.
2750 changequote(,)dnl
2751         ${srcdir}/[*]/config-lang.in) ;;
2752         *)
2753           lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
2754           this_lang_libs=`sed -n -e 's,^target_libs=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^target_libs=\([^         ]*\).*$,\1,p' $lang`
2755           build_by_default=`sed -n -e 's,^build_by_default=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^build_by_default=\([^     ]*\).*$,\1,p' $lang`
2756           if test "x$lang_alias" = x
2757           then
2758                 echo "$lang doesn't set \$language." 1>&2
2759                 exit 1
2760           fi
2761           case ${build_by_default},${enable_languages}, in
2762           *,$lang_alias,*) add_this_lang=yes ;;
2763           no,*) add_this_lang=no ;;
2764           *,all,*) add_this_lang=yes ;;
2765           *) add_this_lang=no ;;
2766           esac
2767           found_languages="${found_languages} ${lang_alias}"
2768           if test x"${add_this_lang}" = xyes; then
2769                 case $lang in
2770                     ${srcdir}/ada/config-lang.in)
2771                         if test x$have_gnat = xyes ; then
2772                                 subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2773                         fi
2774                         ;;
2775                     *)
2776                         subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2777                         ;;
2778                 esac
2779           fi
2780           ;;
2781 changequote([,])dnl
2782         esac
2783 done
2784
2785 missing_languages=
2786 for expected_language in ${expected_languages} ..
2787 do
2788     if test "${expected_language}" != ..; then
2789         missing_language="${expected_language}"
2790         if test "${expected_language}" = "c" \
2791            || test "${expected_language}" = "all"; then
2792                 missing_language=
2793         fi
2794         for found_language in ${found_languages} ..
2795         do
2796             if test "${found_language}" != ..; then
2797                 if test "${expected_language}" = "${found_language}"; then
2798                     missing_language=
2799                 fi
2800             fi
2801         done
2802         if test "x${missing_language}" != x; then
2803            missing_languages="${missing_languages} ${missing_language}"
2804         fi
2805     fi
2806 done
2807
2808 if test "x$missing_languages" != x; then
2809   AC_MSG_ERROR([
2810 The following requested languages were not found:${missing_languages}
2811 The following languages were available: c${found_languages}])
2812 fi
2813
2814 # Make gthr-default.h if we have a thread file.
2815 gthread_flags=
2816 if test $thread_file != single; then
2817     rm -f gthr-default.h
2818     echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h
2819     gthread_flags=-DHAVE_GTHR_DEFAULT
2820 fi
2821 AC_SUBST(gthread_flags)
2822
2823 # Find out what GC implementation we want, or may, use.
2824 AC_ARG_WITH(gc,
2825 [  --with-gc={simple,page} choose the garbage collection mechanism to use
2826                           with the compiler],
2827 [case "$withval" in
2828   simple | page)
2829     GGC=ggc-$withval
2830     ;;
2831   *)
2832     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
2833     ;;
2834 esac],
2835 [GGC=ggc-page])
2836 AC_SUBST(GGC)
2837 echo "Using $GGC for garbage collection."
2838
2839 # Use the system's zlib library.
2840 zlibdir=-L../zlib
2841 zlibinc="-I\$(srcdir)/../zlib"
2842 AC_ARG_WITH(system-zlib,
2843 [  --with-system-zlib      use installed libz],
2844 zlibdir=
2845 zlibinc=
2846 )
2847 AC_SUBST(zlibdir)
2848 AC_SUBST(zlibinc)
2849
2850 dnl Very limited version of automake's enable-maintainer-mode
2851
2852 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
2853   dnl maintainer-mode is disabled by default
2854   AC_ARG_ENABLE(maintainer-mode,
2855 [  --enable-maintainer-mode
2856                           enable make rules and dependencies not useful
2857                           (and sometimes confusing) to the casual installer],
2858       maintainer_mode=$enableval,
2859       maintainer_mode=no)
2860
2861 AC_MSG_RESULT($maintainer_mode)
2862
2863 if test "$maintainer_mode" = "yes"; then
2864   MAINT=''
2865 else
2866   MAINT='#'
2867 fi
2868 AC_SUBST(MAINT)dnl
2869
2870 # Make empty files to contain the specs and options for each language.
2871 # Then add #include lines to for a compiler that has specs and/or options.
2872
2873 lang_specs_files=
2874 lang_options_files=
2875 lang_tree_files=
2876 for subdir in . $subdirs
2877 do
2878         if test -f $srcdir/$subdir/lang-specs.h; then
2879             lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
2880         fi
2881         if test -f $srcdir/$subdir/lang-options.h; then
2882             lang_options_files="$lang_options_files $srcdir/$subdir/lang-options.h"
2883         fi
2884         if test -f $srcdir/$subdir/$subdir-tree.def; then
2885             lang_tree_files="$lang_tree_files $srcdir/$subdir/$subdir-tree.def"
2886         fi
2887 done
2888
2889 # These (without "all_") are set in each config-lang.in.
2890 # `language' must be a single word so is spelled singularly.
2891 all_languages=
2892 all_boot_languages=
2893 all_compilers=
2894 all_stagestuff=
2895 all_outputs='Makefile intl/Makefile fixinc/Makefile gccbug mklibgcc mkheaders'
2896 # List of language makefile fragments.
2897 all_lang_makefiles=
2898 # Files for gengtype
2899 all_gtfiles="$target_gtfiles"
2900 # Files for gengtype with language
2901 all_gtfiles_files_langs=
2902 all_gtfiles_files_files=
2903
2904 # Add the language fragments.
2905 # Languages are added via two mechanisms.  Some information must be
2906 # recorded in makefile variables, these are defined in config-lang.in.
2907 # We accumulate them and plug them into the main Makefile.
2908 # The other mechanism is a set of hooks for each of the main targets
2909 # like `clean', `install', etc.
2910
2911 language_fragments="Make-lang"
2912 language_hooks="Make-hooks"
2913
2914 for s in .. $subdirs
2915 do
2916         if test $s != ".."
2917         then
2918                 language=
2919                 boot_language=
2920                 compilers=
2921                 stagestuff=
2922                 outputs=
2923                 gtfiles=
2924                 . ${srcdir}/$s/config-lang.in
2925                 if test "x$language" = x
2926                 then
2927                         echo "${srcdir}/$s/config-lang.in doesn't set \$language." 1>&2
2928                         exit 1
2929                 fi
2930                 all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Make-lang.in"
2931                 if test -f ${srcdir}/$s/Makefile.in
2932                 then all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Makefile.in"
2933                 fi
2934                 all_languages="$all_languages $language"
2935                 if test "x$boot_language" = xyes
2936                 then
2937                         all_boot_languages="$all_boot_languages $language"
2938                 fi
2939                 all_compilers="$all_compilers $compilers"
2940                 all_stagestuff="$all_stagestuff $stagestuff"
2941                 all_outputs="$all_outputs $outputs"
2942                 all_gtfiles="$all_gtfiles $gtfiles"
2943                 for f in .. $gtfiles
2944                 do
2945                      if test $f != ".."
2946                      then
2947                          all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2948                          all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2949                      fi
2950                 done
2951         fi
2952 done
2953
2954 # Pick up gtfiles for c
2955 gtfiles=
2956 s="c"
2957 . ${srcdir}/c-config-lang.in
2958 all_gtfiles="$all_gtfiles $gtfiles"
2959 for f in .. $gtfiles
2960 do
2961      if test $f != ".."
2962      then
2963         all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2964         all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2965      fi
2966 done
2967
2968 check_languages=
2969 for language in .. $all_languages
2970 do
2971         if test $language != ".."
2972         then
2973                 check_languages="$check_languages check-$language"
2974         fi
2975 done
2976
2977 # Since we can't use `::' targets, we link each language in
2978 # with a set of hooks, reached indirectly via lang.${target}.
2979
2980 rm -f Make-hooks
2981 touch Make-hooks
2982 target_list="all.build all.cross start.encap rest.encap tags \
2983         info dvi generated-manpages \
2984         install-normal install-common install-info install-man \
2985         uninstall \
2986         mostlyclean clean distclean extraclean maintainer-clean \
2987         stage1 stage2 stage3 stage4"
2988 for t in $target_list
2989 do
2990         x=
2991         for lang in .. $all_languages
2992         do
2993                 if test $lang != ".."; then
2994                         x="$x $lang.$t"
2995                 fi
2996         done
2997         echo "lang.$t: $x" >> Make-hooks
2998 done
2999
3000 # Create .gdbinit.
3001
3002 echo "dir ." > .gdbinit
3003 echo "dir ${srcdir}" >> .gdbinit
3004 if test x$gdb_needs_out_file_path = xyes
3005 then
3006         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
3007 fi
3008 if test "x$subdirs" != x; then
3009         for s in $subdirs
3010         do
3011                 echo "dir ${srcdir}/$s" >> .gdbinit
3012         done
3013 fi
3014 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
3015
3016 # If $(exec_prefix) exists and is not the same as $(prefix), then compute an
3017 # absolute path for gcc_tooldir based on inserting the number of up-directory
3018 # movements required to get from $(exec_prefix) to $(prefix) into the basic
3019 # $(libsubdir)/@(unlibsubdir) based path.
3020 # Don't set gcc_tooldir to tooldir since that's only passed in by the toplevel
3021 # make and thus we'd get different behavior depending on where we built the
3022 # sources.
3023 if test x$exec_prefix = xNONE -o x$exec_prefix = x$prefix; then
3024     gcc_tooldir='$(libsubdir)/$(unlibsubdir)/../$(target_alias)'
3025 else
3026 changequote(<<, >>)dnl
3027 # An explanation of the sed strings:
3028 #  -e 's|^\$(prefix)||'   matches and eliminates 'prefix' from 'exec_prefix'
3029 #  -e 's|/$||'            match a trailing forward slash and eliminates it
3030 #  -e 's|^[^/]|/|'        forces the string to start with a forward slash (*)
3031 #  -e 's|/[^/]*|../|g'    replaces each occurrence of /<directory> with ../
3032 #
3033 # (*) Note this pattern overwrites the first character of the string
3034 # with a forward slash if one is not already present.  This is not a
3035 # problem because the exact names of the sub-directories concerned is
3036 # unimportant, just the number of them matters.
3037 #
3038 # The practical upshot of these patterns is like this:
3039 #
3040 #  prefix     exec_prefix        result
3041 #  ------     -----------        ------
3042 #   /foo        /foo/bar          ../
3043 #   /foo/       /foo/bar          ../
3044 #   /foo        /foo/bar/         ../
3045 #   /foo/       /foo/bar/         ../
3046 #   /foo        /foo/bar/ugg      ../../
3047 #
3048     dollar='$$'
3049     gcc_tooldir="\$(libsubdir)/\$(unlibsubdir)/\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/\$(dollar)||' -e 's|^[^/]|/|' -e 's|/[^/]*|../|g'\`\$(target_alias)"
3050 changequote([, ])dnl
3051 fi
3052 AC_SUBST(gcc_tooldir)
3053 AC_SUBST(dollar)
3054
3055 # Find a directory in which to install a shared libgcc.
3056
3057 AC_ARG_ENABLE(version-specific-runtime-libs,
3058 [  --enable-version-specific-runtime-libs
3059                           specify that runtime libraries should be
3060                           installed in a compiler-specific directory])
3061
3062 AC_ARG_WITH(slibdir,
3063 [  --with-slibdir=DIR      shared libraries in DIR [LIBDIR]],
3064 slibdir="$with_slibdir",
3065 if test "${enable_version_specific_runtime_libs+set}" = set; then
3066   slibdir='$(libsubdir)'
3067 elif test "$host" != "$target"; then
3068   slibdir='$(build_tooldir)/lib'
3069 else
3070   slibdir='$(libdir)'
3071 fi)
3072 AC_SUBST(slibdir)
3073
3074 objdir=`${PWDCMD-pwd}`
3075 AC_SUBST(objdir)
3076
3077 # Process the language and host/target makefile fragments.
3078 ${CONFIG_SHELL-/bin/sh} $srcdir/configure.frag $srcdir "$subdirs" "$dep_host_xmake_file" "$dep_tmake_file"
3079
3080 # Substitute configuration variables
3081 AC_SUBST(subdirs)
3082 AC_SUBST(srcdir)
3083 AC_SUBST(all_boot_languages)
3084 AC_SUBST(all_compilers)
3085 AC_SUBST(all_gtfiles)
3086 AC_SUBST(all_gtfiles_files_langs)
3087 AC_SUBST(all_gtfiles_files_files)
3088 AC_SUBST(all_lang_makefiles)
3089 AC_SUBST(all_languages)
3090 AC_SUBST(all_stagestuff)
3091 AC_SUBST(build_exeext)
3092 AC_SUBST(build_install_headers_dir)
3093 AC_SUBST(build_xm_file_list)
3094 AC_SUBST(build_xm_file)
3095 AC_SUBST(build_xm_defines)
3096 AC_SUBST(check_languages)
3097 AC_SUBST(cc_set_by_configure)
3098 AC_SUBST(quoted_cc_set_by_configure)
3099 AC_SUBST(cpp_install_dir)
3100 AC_SUBST(dep_host_xmake_file)
3101 AC_SUBST(dep_tmake_file)
3102 AC_SUBST(extra_headers_list)
3103 AC_SUBST(extra_objs)
3104 AC_SUBST(extra_parts)
3105 AC_SUBST(extra_passes)
3106 AC_SUBST(extra_programs)
3107 AC_SUBST(float_h_file)
3108 AC_SUBST(gcc_config_arguments)
3109 AC_SUBST(gcc_gxx_include_dir)
3110 AC_SUBST(libstdcxx_incdir)
3111 AC_SUBST(gcc_version)
3112 AC_SUBST(gcc_version_full)
3113 AC_SUBST(gcc_version_trigger)
3114 AC_SUBST(host_exeext)
3115 AC_SUBST(host_extra_gcc_objs)
3116 AC_SUBST(host_xm_file_list)
3117 AC_SUBST(host_xm_file)
3118 AC_SUBST(host_xm_defines)
3119 AC_SUBST(out_host_hook_obj)
3120 AC_SUBST(install)
3121 AC_SUBST(lang_options_files)
3122 AC_SUBST(lang_specs_files)
3123 AC_SUBST(lang_tree_files)
3124 AC_SUBST(local_prefix)
3125 AC_SUBST(md_file)
3126 AC_SUBST(objc_boehm_gc)
3127 AC_SUBST(out_file)
3128 AC_SUBST(out_object_file)
3129 AC_SUBST(stage_prefix_set_by_configure)
3130 AC_SUBST(quoted_stage_prefix_set_by_configure)
3131 AC_SUBST(symbolic_link)
3132 AC_SUBST(thread_file)
3133 AC_SUBST(tm_file_list)
3134 AC_SUBST(tm_file)
3135 AC_SUBST(tm_defines)
3136 AC_SUBST(tm_p_file_list)
3137 AC_SUBST(tm_p_file)
3138 AC_SUBST(xm_file)
3139 AC_SUBST(xm_defines)
3140 AC_SUBST(target_alias)
3141 AC_SUBST(c_target_objs)
3142 AC_SUBST(cxx_target_objs)
3143 AC_SUBST(target_cpu_default)
3144
3145 AC_SUBST_FILE(target_overrides)
3146 AC_SUBST_FILE(host_overrides)
3147 AC_SUBST_FILE(language_fragments)
3148 AC_SUBST_FILE(language_hooks)
3149
3150 # Echo that links are built
3151 if test x$host = x$target
3152 then
3153         str1="native "
3154 else
3155         str1="cross-"
3156         str2=" from $host"
3157 fi
3158
3159 if test x$host != x$build
3160 then
3161         str3=" on a $build system"
3162 fi
3163
3164 if test "x$str2" != x || test "x$str3" != x
3165 then
3166         str4=
3167 fi
3168
3169 echo "Links are now set up to build a ${str1}compiler for ${target}$str4" 1>&2
3170
3171 if test "x$str2" != x || test "x$str3" != x
3172 then
3173         echo " ${str2}${str3}." 1>&2
3174 fi
3175
3176 # Truncate the target if necessary
3177 if test x$host_truncate_target != x; then
3178         target=`echo $target | sed -e 's/\(..............\).*/\1/'`
3179 fi
3180
3181 # Configure the subdirectories
3182 # AC_CONFIG_SUBDIRS($subdirs)
3183
3184 # Create the Makefile
3185 # and configure language subdirectories
3186 AC_OUTPUT($all_outputs,
3187 [
3188 case x$CONFIG_HEADERS in
3189 xauto-host.h:config.in)
3190 echo > cstamp-h ;;
3191 esac
3192 # If the host supports symlinks, point stage[1234] at ../stage[1234] so
3193 # bootstrapping and the installation procedure can still use
3194 # CC="stage1/xgcc -Bstage1/".  If the host doesn't support symlinks,
3195 # FLAGS_TO_PASS has been modified to solve the problem there.
3196 # This is virtually a duplicate of what happens in configure.lang; we do
3197 # an extra check to make sure this only happens if ln -s can be used.
3198 if test "$symbolic_link" = "ln -s"; then
3199  for d in .. ${subdirs} fixinc ; do
3200    if test $d != ..; then
3201         STARTDIR=`${PWDCMD-pwd}`
3202         cd $d
3203         for t in stage1 stage2 stage3 stage4 include
3204         do
3205                 rm -f $t
3206                 $symbolic_link ../$t $t 2>/dev/null
3207         done
3208         cd $STARTDIR
3209    fi
3210  done
3211 else true ; fi
3212 # Avoid having to add intl to our include paths.
3213 if test -f intl/libintl.h; then
3214   echo creating libintl.h
3215   echo '#include "intl/libintl.h"' >libintl.h
3216 fi
3217 ],
3218 [subdirs='$subdirs'
3219 symbolic_link='$symbolic_link'
3220 ])