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]*\)\)\([     ].*\|\)$,\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   s390-*-*)
2127     conftest_s='
2128         .section ".tdata","awT",@progbits
2129 foo:    .long   25
2130         .text
2131         .long   foo@TLSGD
2132         .long   foo@TLSLDM
2133         .long   foo@DTPOFF
2134         .long   foo@NTPOFF
2135         .long   foo@GOTNTPOFF
2136         .long   foo@INDNTPOFF
2137         l       %r1,foo@GOTNTPOFF(%r12)
2138         l       %r1,0(%r1):tls_load:foo
2139         bas     %r14,0(%r1,%r13):tls_gdcall:foo
2140         bas     %r14,0(%r1,%r13):tls_ldcall:foo'
2141         tls_first_major=2
2142         tls_first_minor=14
2143         ;;
2144   s390x-*-*)
2145     conftest_s='
2146         .section ".tdata","awT",@progbits
2147 foo:    .long   25
2148         .text
2149         .quad   foo@TLSGD
2150         .quad   foo@TLSLDM
2151         .quad   foo@DTPOFF
2152         .quad   foo@NTPOFF
2153         .quad   foo@GOTNTPOFF
2154         lg      %r1,foo@GOTNTPOFF(%r12)
2155         larl    %r1,foo@INDNTPOFF
2156         brasl   %r14,__tls_get_offset@PLT:tls_gdcall:foo
2157         brasl   %r14,__tls_get_offset@PLT:tls_ldcall:foo'
2158         tls_first_major=2
2159         tls_first_minor=14
2160         ;;
2161 esac
2162 if test -z "$tls_first_major"; then
2163   :
2164 elif test $in_tree_gas = yes ; then
2165   gcc_GAS_VERSION_GTE_IFELSE($tls_first_major,$tls_first_minor,0,[
2166     gcc_cv_as_tls=yes
2167   ])
2168 elif test x$gcc_cv_as != x; then
2169   echo "$conftest_s" > conftest.s
2170   if $gcc_cv_as --fatal-warnings -o conftest.o conftest.s > /dev/null 2>&1
2171   then
2172     gcc_cv_as_tls=yes
2173   fi
2174   rm -f conftest.s conftest.o
2175 fi
2176 if test "$gcc_cv_as_tls" = yes; then
2177   AC_DEFINE(HAVE_AS_TLS, 1,
2178             [Define if your assembler supports thread-local storage.])
2179 fi
2180 AC_MSG_RESULT($gcc_cv_as_tls)
2181
2182 case "$target" in
2183   # All TARGET_ABI_OSF targets.
2184   alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
2185     AC_CACHE_CHECK([assembler supports explicit relocations],
2186         gcc_cv_as_explicit_relocs, [
2187         gcc_cv_as_explicit_relocs=unknown
2188         if test $in_tree_gas = yes ; then
2189            gcc_GAS_VERSION_GTE_IFELSE(2,12,0,[
2190               gcc_cv_as_explicit_relocs=yes
2191            ])
2192         elif test x$gcc_cv_as != x; then
2193             cat > conftest.s << 'EOF'
2194         .set nomacro
2195         .text
2196         extbl   $3, $2, $3      !lituse_bytoff!1
2197         ldq     $2, a($29)      !literal!1
2198         ldq     $4, b($29)      !literal!2
2199         ldq_u   $3, 0($2)       !lituse_base!1
2200         ldq     $27, f($29)     !literal!5
2201         jsr     $26, ($27), f   !lituse_jsr!5
2202         ldah    $29, 0($26)     !gpdisp!3
2203         lda     $0, c($29)      !gprel
2204         ldah    $1, d($29)      !gprelhigh
2205         lda     $1, d($1)       !gprellow
2206         lda     $29, 0($29)     !gpdisp!3
2207 EOF
2208             if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2209                 gcc_cv_as_explicit_relocs=yes
2210             else
2211                 gcc_cv_as_explicit_relocs=no
2212             fi
2213             rm -f conftest.s conftest.o
2214         fi
2215     ])
2216     if test "x$gcc_cv_as_explicit_relocs" = xyes; then
2217         AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
2218                 [Define if your assembler supports explicit relocations.])
2219     fi
2220     ;;
2221   sparc*-*-*)
2222     AC_CACHE_CHECK([assembler .register pseudo-op support],
2223         gcc_cv_as_register_pseudo_op, [
2224         gcc_cv_as_register_pseudo_op=unknown
2225         if test x$gcc_cv_as != x; then
2226             # Check if we have .register
2227             echo ".register %g2, #scratch" > conftest.s
2228             if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2229                 gcc_cv_as_register_pseudo_op=yes
2230             else
2231                 gcc_cv_as_register_pseudo_op=no
2232             fi
2233             rm -f conftest.s conftest.o
2234         fi
2235     ])
2236     if test "x$gcc_cv_as_register_pseudo_op" = xyes; then
2237         AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
2238                 [Define if your assembler supports .register.])
2239     fi
2240
2241     AC_CACHE_CHECK([assembler supports -relax],
2242         gcc_cv_as_relax_opt, [
2243         gcc_cv_as_relax_opt=unknown
2244         if test x$gcc_cv_as != x; then
2245             # Check if gas supports -relax
2246             echo ".text" > conftest.s
2247             if $gcc_cv_as -relax -o conftest.o conftest.s > /dev/null 2>&1; then
2248                 gcc_cv_as_relax_opt=yes
2249             else
2250                 gcc_cv_as_relax_opt=no
2251             fi
2252             rm -f conftest.s conftest.o
2253         fi
2254     ])
2255     if test "x$gcc_cv_as_relax_opt" = xyes; then
2256         AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
2257                 [Define if your assembler supports -relax option.])
2258     fi
2259
2260     AC_CACHE_CHECK([assembler and linker support unaligned pc related relocs],
2261         gcc_cv_as_sparc_ua_pcrel, [
2262         gcc_cv_as_sparc_ua_pcrel=unknown
2263         if test x$gcc_cv_as != x -a x$gcc_cv_ld != x; then
2264             gcc_cv_as_sparc_ua_pcrel=no
2265             echo ".text; foo: nop; .data; .align 4; .byte 0; .uaword %r_disp32(foo)" > conftest.s
2266             if $gcc_cv_as -K PIC -o conftest.o conftest.s > /dev/null 2>&1 \
2267                && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
2268                 gcc_cv_as_sparc_ua_pcrel=yes
2269             fi
2270             rm -f conftest.s conftest.o conftest
2271         fi
2272     ])
2273     if test "x$gcc_cv_as_sparc_ua_pcrel" = xyes; then
2274         AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
2275                 [Define if your assembler and linker support unaligned PC relative relocs.])
2276     fi
2277
2278     AC_CACHE_CHECK([assembler and linker support unaligned pc related relocs against hidden symbols],
2279         gcc_cv_as_sparc_ua_pcrel_hidden, [
2280         if test "x$gcc_cv_as_sparc_ua_pcrel" = xyes; then
2281             gcc_cv_as_sparc_ua_pcrel_hidden=unknown
2282             if test x$gcc_cv_objdump != x; then
2283                 gcc_cv_as_sparc_ua_pcrel_hidden=no
2284                 echo ".data; .align 4; .byte 0x31; .uaword %r_disp32(foo)" > conftest.s
2285                 echo ".byte 0x32, 0x33, 0x34; .global foo; .hidden foo" >> conftest.s
2286                 echo "foo: .skip 4" >> conftest.s
2287                 if $gcc_cv_as -K PIC -o conftest.o conftest.s > /dev/null 2>&1 \
2288                    && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
2289                    && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
2290                       | grep ' 31000000 07323334' > /dev/null 2>&1; then
2291                     if $gcc_cv_objdump -R conftest 2> /dev/null \
2292                        | grep 'DISP32' > /dev/null 2>&1; then
2293                         :
2294                     else
2295                         gcc_cv_as_sparc_ua_pcrel_hidden=yes
2296                     fi
2297                 fi
2298             fi
2299             rm -f conftest.s conftest.o conftest
2300         else
2301             gcc_cv_as_sparc_ua_pcrel_hidden="$gcc_cv_as_sparc_ua_pcrel"
2302         fi
2303     ])
2304     if test "x$gcc_cv_as_sparc_ua_pcrel_hidden" = xyes; then
2305         AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
2306                 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])
2307     fi
2308
2309     AC_CACHE_CHECK([for assembler offsetable %lo() support],
2310         gcc_cv_as_offsetable_lo10, [
2311         gcc_cv_as_offsetable_lo10=unknown
2312         if test "x$gcc_cv_as" != x; then
2313             # Check if assembler has offsetable %lo()
2314             echo "or %g1, %lo(ab) + 12, %g1" > conftest.s
2315             echo "or %g1, %lo(ab + 12), %g1" > conftest1.s
2316             if $gcc_cv_as -xarch=v9 -o conftest.o conftest.s \
2317                     > /dev/null 2>&1 &&
2318                $gcc_cv_as -xarch=v9 -o conftest1.o conftest1.s \
2319                     > /dev/null 2>&1; then
2320                 if cmp conftest.o conftest1.o > /dev/null 2>&1; then
2321                     gcc_cv_as_offsetable_lo10=no
2322                 else
2323                     gcc_cv_as_offsetable_lo10=yes
2324                 fi
2325             else
2326                 gcc_cv_as_offsetable_lo10=no
2327             fi
2328             rm -f conftest.s conftest.o conftest1.s conftest1.o
2329         fi
2330     ])
2331     if test "x$gcc_cv_as_offsetable_lo10" = xyes; then
2332         AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
2333             [Define if your assembler supports offsetable %lo().])
2334     fi
2335
2336     ;;
2337
2338 changequote(,)dnl
2339   i[34567]86-*-* | x86_64-*-*)
2340 changequote([,])dnl
2341     AC_MSG_CHECKING(assembler instructions)
2342     gcc_cv_as_instructions=
2343     if test $in_tree_gas = yes ; then
2344       gcc_GAS_VERSION_GTE_IFELSE(2,9,0,[
2345         gcc_cv_as_instructions="filds fists"
2346       ])
2347     elif test x$gcc_cv_as != x; then
2348         set "filds fists" "filds mem; fists mem"
2349         while test $# -gt 0
2350         do
2351                 echo "$2" > conftest.s
2352                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2353                         gcc_cv_as_instructions=${gcc_cv_as_instructions}$1" "
2354                 fi
2355                 shift 2
2356         done
2357         rm -f conftest.s conftest.o
2358     fi
2359     if test x"$gcc_cv_as_instructions" != x; then
2360         AC_DEFINE_UNQUOTED(HAVE_GAS_`echo "$gcc_cv_as_instructions" | sed -e 's/ $//' | tr '[a-z ]' '[A-Z_]'`)
2361     fi
2362     AC_MSG_RESULT($gcc_cv_as_instructions)
2363
2364     AC_MSG_CHECKING(assembler GOTOFF in data directives)
2365     gcc_cv_as_gotoff_in_data=no
2366     if test $in_tree_gas = yes ; then
2367       gcc_GAS_VERSION_GTE_IFELSE(2,11,0,[
2368         gcc_cv_as_gotoff_in_data=yes
2369       ])
2370     elif test x$gcc_cv_as != x; then
2371         cat > conftest.s <<EOF
2372         .text
2373 .L0:
2374         nop
2375         .data
2376         .long .L0@GOTOFF
2377 EOF
2378         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2379           gcc_cv_as_gotoff_in_data=yes
2380         fi
2381     fi
2382     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
2383       [`if test $gcc_cv_as_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
2384       [Define true if the assembler supports '.long foo@GOTOFF'.])
2385     AC_MSG_RESULT($gcc_cv_as_gotoff_in_data)
2386     ;;
2387
2388   ia64*-*-*)
2389     AC_CACHE_CHECK([assembler supports ltoffx and ldxmov],
2390         gcc_cv_as_ltoffx_ldxmov_relocs, [
2391         gcc_cv_as_ltoffx_ldxmov_relocs=unknown
2392         if test $in_tree_gas = yes ; then
2393           gcc_GAS_VERSION_GTE_IFELSE(2,14,0,[
2394             gcc_cv_as_ltoffx_ldxmov_relocs=yes
2395           ])
2396         elif test x$gcc_cv_as != x; then
2397             cat > conftest.s << 'EOF'
2398 changequote(,)dnl
2399         .text
2400         addl r15 = @ltoffx(x#), gp
2401         ;;
2402         ld8.mov r16 = [r15], x#
2403 EOF
2404 changequote([,])dnl
2405             if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2406                 gcc_cv_as_ltoffx_ldxmov_relocs=yes
2407             else
2408                 gcc_cv_as_ltoffx_ldxmov_relocs=no
2409             fi
2410             rm -f conftest.s conftest.o
2411         fi
2412     ])
2413     if test "x$gcc_cv_as_ltoffx_ldxmov_relocs" = xyes; then
2414         AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
2415           [Define if your assembler supports ltoffx and ldxmov relocations.])
2416     fi
2417     ;;
2418 esac
2419
2420 AC_MSG_CHECKING(assembler dwarf2 debug_line support)
2421 gcc_cv_as_dwarf2_debug_line=no
2422 # ??? Not all targets support dwarf2 debug_line, even within a version
2423 # of gas.  Moreover, we need to emit a valid instruction to trigger any
2424 # info to the output file.  So, as supported targets are added to gas 2.11,
2425 # add some instruction here to (also) show we expect this might work.
2426 # ??? Once 2.11 is released, probably need to add first known working
2427 # version to the per-target configury.
2428 case "$target" in
2429   i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* \
2430   | x86_64*-*-* | hppa*-*-* | arm*-*-* | strongarm*-*-* | xscale*-*-*)
2431     insn="nop"
2432     ;;
2433   ia64*-*-*)
2434     insn="nop 0"
2435     ;;
2436   esac
2437 if test $in_tree_gas = yes ; then
2438   gcc_GAS_VERSION_GTE_IFELSE(2,11,0,[
2439     if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2440         && test x"$insn" != x ; then
2441       gcc_cv_as_dwarf2_debug_line="yes"
2442     fi
2443   ])
2444 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2445         echo '  .file 1 "conftest.s"' > conftest.s
2446         echo '  .loc 1 3 0' >> conftest.s
2447         echo "  $insn" >> conftest.s
2448         # ??? This fails with non-gnu grep.
2449         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
2450            && grep debug_line conftest.o > /dev/null 2>&1 ; then
2451                 # The .debug_line file table must be in the exact order that
2452                 # we specified the files, since these indices are also used
2453                 # by DW_AT_decl_file.  Approximate this test by testing if
2454                 # the assembler bitches if the same index is assigned twice.
2455                 echo '  .file 1 "foo.s"' > conftest.s
2456                 echo '  .file 1 "bar.s"' >> conftest.s
2457                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1
2458                 then
2459                   gcc_cv_as_dwarf2_debug_line="no"
2460                 else
2461                   gcc_cv_as_dwarf2_debug_line="yes"
2462                 fi
2463         fi
2464         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
2465 fi
2466 if test x"$gcc_cv_as_dwarf2_debug_line" = xyes; then
2467         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
2468 [Define if your assembler supports dwarf2 .file/.loc directives,
2469    and preserves file table indices exactly as given.])
2470 fi
2471 AC_MSG_RESULT($gcc_cv_as_dwarf2_debug_line)
2472
2473 AC_MSG_CHECKING(assembler --gdwarf2 support)
2474 gcc_cv_as_gdwarf2_flag=no
2475 if test $in_tree_gas = yes ; then
2476   gcc_GAS_VERSION_GTE_IFELSE(2,11,0,[
2477     if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2478         && test x"$insn" != x ; then
2479       gcc_cv_as_gdwarf2_flag="yes"
2480     fi
2481   ])
2482 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2483         echo '' > conftest.s
2484         # ??? This fails with non-gnu grep.
2485         if $gcc_cv_as --gdwarf2 -o conftest.o conftest.s > /dev/null 2>&1
2486           then
2487           gcc_cv_as_gdwarf2_flag="yes"
2488         fi
2489         rm -f conftest.s conftest.o
2490 fi
2491 if test x"$gcc_cv_as_gdwarf2_flag" = xyes; then
2492         AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
2493 [Define if your assembler supports the --gdwarf2 option.])
2494 fi
2495 AC_MSG_RESULT($gcc_cv_as_gdwarf2_flag)
2496
2497 AC_MSG_CHECKING(assembler --gstabs support)
2498 gcc_cv_as_gstabs_flag=no
2499 if test $in_tree_gas = yes ; then
2500   gcc_GAS_VERSION_GTE_IFELSE(2,11,0,[
2501     if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2502         && test x"$insn" != x ; then
2503       gcc_cv_as_gstabs_flag="yes"
2504     fi
2505   ])
2506 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2507         echo '' > conftest.s
2508         # ??? This fails with non-gnu grep.
2509         if $gcc_cv_as --gstabs -o conftest.o conftest.s > /dev/null 2>&1 ; then
2510           gcc_cv_as_gstabs_flag="yes"
2511         fi
2512         rm -f conftest.s conftest.o
2513 fi
2514 if test x"$gcc_cv_as_gstabs_flag" = xyes; then
2515         AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
2516 [Define if your assembler supports the --gstabs option.])
2517 fi
2518 AC_MSG_RESULT($gcc_cv_as_gstabs_flag)
2519
2520 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2521 gcc_cv_ld_ro_rw_mix=unknown
2522 if test $in_tree_ld = yes ; then
2523   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
2524     gcc_cv_ld_ro_rw_mix=read-write
2525   fi
2526 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2527   echo '.section "myfoosect", "a"' > conftest1.s
2528   echo '.section "myfoosect", "aw"' > conftest2.s
2529   echo '.byte 1' >> conftest2.s
2530   echo '.section "myfoosect", "a"' > conftest3.s
2531   echo '.byte 0' >> conftest3.s
2532   if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2533      && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2534      && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2535      && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2536         conftest2.o conftest3.o; then
2537     gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2538                          | grep -A1 myfoosect`
2539     if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2540       if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2541         gcc_cv_ld_ro_rw_mix=read-only
2542       else
2543         gcc_cv_ld_ro_rw_mix=read-write
2544       fi
2545     fi
2546   fi
2547 changequote(,)dnl
2548   rm -f conftest.* conftest[123].*
2549 changequote([,])dnl
2550 fi
2551 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2552         AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2553   [Define if your linker links a mix of read-only
2554    and read-write sections into a read-write section.])
2555 fi
2556 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2557
2558 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
2559 gcc_cv_ld_eh_frame_hdr=no
2560 if test $in_tree_ld = yes ; then
2561   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
2562     gcc_cv_ld_eh_frame_hdr=yes
2563   fi
2564 elif test x$gcc_cv_ld != x; then
2565         # Check if linker supports --eh-frame-hdr option
2566         if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
2567                 gcc_cv_ld_eh_frame_hdr=yes
2568         fi
2569 fi
2570 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
2571         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
2572 [Define if your linker supports --eh-frame-hdr option.])
2573 fi
2574 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
2575
2576 # Miscellaneous target-specific checks.
2577 case "$target" in
2578   mips*-*-*)
2579     AC_MSG_CHECKING(whether libgloss uses STARTUP directives consistently)
2580     gcc_cv_mips_libgloss_startup=no
2581     gcc_cv_libgloss_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/libgloss
2582     if test "x$exec_prefix" = xNONE; then
2583       if test "x$prefix" = xNONE; then
2584         test_prefix=/usr/local
2585       else
2586         test_prefix=$prefix
2587       fi
2588     else
2589       test_prefix=$exec_prefix
2590     fi
2591     for f in $gcc_cv_libgloss_srcdir/mips/idt.ld $test_prefix/$target_alias/lib/idt.ld
2592     do
2593       if grep '^STARTUP' $f > /dev/null 2>&1; then
2594         gcc_cv_mips_libgloss_startup=yes
2595         break
2596       fi
2597     done
2598     if test x"$gcc_cv_mips_libgloss_startup" = xyes; then
2599       AC_DEFINE(HAVE_MIPS_LIBGLOSS_STARTUP_DIRECTIVES, 1,
2600         [Define if your MIPS libgloss linker scripts consistently include STARTUP directives.])
2601     fi
2602     AC_MSG_RESULT($gcc_cv_mips_libgloss_startup)
2603
2604     AC_MSG_CHECKING(whether the assembler has explicit relocation support)
2605     if test x$gcc_cv_mips_explicit_relocs = x; then
2606       gcc_cv_mips_explicit_relocs=no
2607       if test x$gcc_cv_as != x; then
2608         echo '  lw $4,%gp_rel(foo)($4)' > conftest.s
2609         if $gcc_cv_as conftest.s -o conftest.o > /dev/null 2>&1; then
2610           gcc_cv_mips_explicit_relocs=yes
2611         fi
2612         rm -f conftest.s conftest.o
2613       fi
2614     fi
2615     if test $gcc_cv_mips_explicit_relocs = yes; then
2616       test x$target_cpu_default != x || target_cpu_default=0
2617       target_cpu_default="(${target_cpu_default}|MASK_EXPLICIT_RELOCS)"
2618     fi
2619     AC_MSG_RESULT($gcc_cv_mips_explicit_relocs)
2620     ;;
2621 esac
2622
2623 if test x$with_sysroot = x && test x$host = x$target \
2624    && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" ; then
2625   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include")
2626 fi
2627
2628 # Figure out what language subdirectories are present.
2629 # Look if the user specified --enable-languages="..."; if not, use
2630 # the environment variable $LANGUAGES if defined. $LANGUAGES might
2631 # go away some day.
2632 # NB:  embedded tabs in this IF block -- do not untabify
2633 if test x"${enable_languages+set}" != xset; then
2634         if test x"${LANGUAGES+set}" = xset; then
2635                 enable_languages="${LANGUAGES}"
2636                 AC_MSG_WARN([setting LANGUAGES is deprecated, use --enable-languages instead])
2637
2638         else
2639                 enable_languages=all
2640         fi
2641 else
2642         if test x"${enable_languages}" = x \
2643         || test x"${enable_languages}" = xyes;
2644         then
2645                 AC_MSG_ERROR([--enable-languages needs at least one language argument])
2646         fi
2647 fi
2648 enable_languages=`echo "${enable_languages}" | sed -e 's/[[     ,]][[   ,]]*/,/g' -e 's/,$//'`
2649
2650 # First scan to see if an enabled language requires some other language.
2651 # We assume that a given config-lang.in will list all the language
2652 # front ends it requires, even if some are required indirectly.
2653 for lang in ${srcdir}/*/config-lang.in ..
2654 do
2655    case $lang in
2656     ..)
2657        ;;
2658     # The odd quoting in the next line works around
2659     # an apparent bug in bash 1.12 on linux.
2660 changequote(,)dnl
2661     ${srcdir}/[*]/config-lang.in)
2662        ;;
2663     *)
2664        lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^      ]*\).*$,\1,p' $lang`
2665        this_lang_requires=`sed -n -e 's,^lang_requires=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^lang_requires=\([^    ]*\).*$,\1,p' $lang`
2666        for other in $this_lang_requires
2667        do
2668           case ,${enable_languages}, in
2669            *,$other,*)
2670               ;;
2671            *,all,*)
2672               ;;
2673            *,$lang_alias,*)
2674               enable_languages="$enable_languages,$other"
2675               ;;
2676           esac
2677        done
2678        ;;
2679 changequote([,])dnl
2680    esac
2681 done
2682
2683 expected_languages=`echo ,${enable_languages}, | sed -e 's:,: :g' -e 's:  *: :g' -e 's:  *: :g' -e 's:^ ::' -e 's: $::'`
2684 found_languages=
2685 subdirs=
2686 for lang in ${srcdir}/*/config-lang.in ..
2687 do
2688         case $lang in
2689         ..) ;;
2690         # The odd quoting in the next line works around
2691         # an apparent bug in bash 1.12 on linux.
2692 changequote(,)dnl
2693         ${srcdir}/[*]/config-lang.in) ;;
2694         *)
2695           lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
2696           this_lang_libs=`sed -n -e 's,^target_libs=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^target_libs=\([^         ]*\).*$,\1,p' $lang`
2697           build_by_default=`sed -n -e 's,^build_by_default=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^build_by_default=\([^     ]*\).*$,\1,p' $lang`
2698           if test "x$lang_alias" = x
2699           then
2700                 echo "$lang doesn't set \$language." 1>&2
2701                 exit 1
2702           fi
2703           case ${build_by_default},${enable_languages}, in
2704           *,$lang_alias,*) add_this_lang=yes ;;
2705           no,*) add_this_lang=no ;;
2706           *,all,*) add_this_lang=yes ;;
2707           *) add_this_lang=no ;;
2708           esac
2709           found_languages="${found_languages} ${lang_alias}"
2710           if test x"${add_this_lang}" = xyes; then
2711                 case $lang in
2712                     ${srcdir}/ada/config-lang.in)
2713                         if test x$have_gnat = xyes ; then
2714                                 subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2715                         fi
2716                         ;;
2717                     *)
2718                         subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2719                         ;;
2720                 esac
2721           fi
2722           ;;
2723 changequote([,])dnl
2724         esac
2725 done
2726
2727 missing_languages=
2728 for expected_language in ${expected_languages} ..
2729 do
2730     if test "${expected_language}" != ..; then
2731         missing_language="${expected_language}"
2732         if test "${expected_language}" = "c" \
2733            || test "${expected_language}" = "all"; then
2734                 missing_language=
2735         fi
2736         for found_language in ${found_languages} ..
2737         do
2738             if test "${found_language}" != ..; then
2739                 if test "${expected_language}" = "${found_language}"; then
2740                     missing_language=
2741                 fi
2742             fi
2743         done
2744         if test "x${missing_language}" != x; then
2745            missing_languages="${missing_languages} ${missing_language}"
2746         fi
2747     fi
2748 done
2749
2750 if test "x$missing_languages" != x; then
2751   AC_MSG_ERROR([
2752 The following requested languages were not found:${missing_languages}
2753 The following languages were available: c${found_languages}])
2754 fi
2755
2756 # Make gthr-default.h if we have a thread file.
2757 gthread_flags=
2758 if test $thread_file != single; then
2759     rm -f gthr-default.h
2760     echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h
2761     gthread_flags=-DHAVE_GTHR_DEFAULT
2762 fi
2763 AC_SUBST(gthread_flags)
2764
2765 # Find out what GC implementation we want, or may, use.
2766 AC_ARG_WITH(gc,
2767 [  --with-gc={simple,page} choose the garbage collection mechanism to use
2768                           with the compiler],
2769 [case "$withval" in
2770   simple | page)
2771     GGC=ggc-$withval
2772     ;;
2773   *)
2774     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
2775     ;;
2776 esac],
2777 [GGC=ggc-page])
2778 AC_SUBST(GGC)
2779 echo "Using $GGC for garbage collection."
2780
2781 # Use the system's zlib library.
2782 zlibdir=-L../zlib
2783 zlibinc="-I\$(srcdir)/../zlib"
2784 AC_ARG_WITH(system-zlib,
2785 [  --with-system-zlib      use installed libz],
2786 zlibdir=
2787 zlibinc=
2788 )
2789 AC_SUBST(zlibdir)
2790 AC_SUBST(zlibinc)
2791
2792 dnl Very limited version of automake's enable-maintainer-mode
2793
2794 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
2795   dnl maintainer-mode is disabled by default
2796   AC_ARG_ENABLE(maintainer-mode,
2797 [  --enable-maintainer-mode
2798                           enable make rules and dependencies not useful
2799                           (and sometimes confusing) to the casual installer],
2800       maintainer_mode=$enableval,
2801       maintainer_mode=no)
2802
2803 AC_MSG_RESULT($maintainer_mode)
2804
2805 if test "$maintainer_mode" = "yes"; then
2806   MAINT=''
2807 else
2808   MAINT='#'
2809 fi
2810 AC_SUBST(MAINT)dnl
2811
2812 # Make empty files to contain the specs and options for each language.
2813 # Then add #include lines to for a compiler that has specs and/or options.
2814
2815 lang_specs_files=
2816 lang_options_files=
2817 lang_tree_files=
2818 for subdir in . $subdirs
2819 do
2820         if test -f $srcdir/$subdir/lang-specs.h; then
2821             lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
2822         fi
2823         if test -f $srcdir/$subdir/lang-options.h; then
2824             lang_options_files="$lang_options_files $srcdir/$subdir/lang-options.h"
2825         fi
2826         if test -f $srcdir/$subdir/$subdir-tree.def; then
2827             lang_tree_files="$lang_tree_files $srcdir/$subdir/$subdir-tree.def"
2828         fi
2829 done
2830
2831 # These (without "all_") are set in each config-lang.in.
2832 # `language' must be a single word so is spelled singularly.
2833 all_languages=
2834 all_boot_languages=
2835 all_compilers=
2836 all_stagestuff=
2837 all_outputs='Makefile intl/Makefile fixinc/Makefile gccbug mklibgcc mkheaders'
2838 # List of language makefile fragments.
2839 all_lang_makefiles=
2840 # Files for gengtype
2841 all_gtfiles="$target_gtfiles"
2842 # Files for gengtype with language
2843 all_gtfiles_files_langs=
2844 all_gtfiles_files_files=
2845
2846 # Add the language fragments.
2847 # Languages are added via two mechanisms.  Some information must be
2848 # recorded in makefile variables, these are defined in config-lang.in.
2849 # We accumulate them and plug them into the main Makefile.
2850 # The other mechanism is a set of hooks for each of the main targets
2851 # like `clean', `install', etc.
2852
2853 language_fragments="Make-lang"
2854 language_hooks="Make-hooks"
2855
2856 for s in .. $subdirs
2857 do
2858         if test $s != ".."
2859         then
2860                 language=
2861                 boot_language=
2862                 compilers=
2863                 stagestuff=
2864                 outputs=
2865                 gtfiles=
2866                 . ${srcdir}/$s/config-lang.in
2867                 if test "x$language" = x
2868                 then
2869                         echo "${srcdir}/$s/config-lang.in doesn't set \$language." 1>&2
2870                         exit 1
2871                 fi
2872                 all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Make-lang.in"
2873                 if test -f ${srcdir}/$s/Makefile.in
2874                 then all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Makefile.in"
2875                 fi
2876                 all_languages="$all_languages $language"
2877                 if test "x$boot_language" = xyes
2878                 then
2879                         all_boot_languages="$all_boot_languages $language"
2880                 fi
2881                 all_compilers="$all_compilers $compilers"
2882                 all_stagestuff="$all_stagestuff $stagestuff"
2883                 all_outputs="$all_outputs $outputs"
2884                 all_gtfiles="$all_gtfiles $gtfiles"
2885                 for f in .. $gtfiles
2886                 do
2887                      if test $f != ".."
2888                      then
2889                          all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2890                          all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2891                      fi
2892                 done
2893         fi
2894 done
2895
2896 # Pick up gtfiles for c
2897 gtfiles=
2898 s="c"
2899 . ${srcdir}/c-config-lang.in
2900 all_gtfiles="$all_gtfiles $gtfiles"
2901 for f in .. $gtfiles
2902 do
2903      if test $f != ".."
2904      then
2905         all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2906         all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2907      fi
2908 done
2909
2910 check_languages=
2911 for language in .. $all_languages
2912 do
2913         if test $language != ".."
2914         then
2915                 check_languages="$check_languages check-$language"
2916         fi
2917 done
2918
2919 # Since we can't use `::' targets, we link each language in
2920 # with a set of hooks, reached indirectly via lang.${target}.
2921
2922 rm -f Make-hooks
2923 touch Make-hooks
2924 target_list="all.build all.cross start.encap rest.encap tags \
2925         info dvi generated-manpages \
2926         install-normal install-common install-info install-man \
2927         uninstall \
2928         mostlyclean clean distclean extraclean maintainer-clean \
2929         stage1 stage2 stage3 stage4"
2930 for t in $target_list
2931 do
2932         x=
2933         for lang in .. $all_languages
2934         do
2935                 if test $lang != ".."; then
2936                         x="$x $lang.$t"
2937                 fi
2938         done
2939         echo "lang.$t: $x" >> Make-hooks
2940 done
2941
2942 # Create .gdbinit.
2943
2944 echo "dir ." > .gdbinit
2945 echo "dir ${srcdir}" >> .gdbinit
2946 if test x$gdb_needs_out_file_path = xyes
2947 then
2948         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
2949 fi
2950 if test "x$subdirs" != x; then
2951         for s in $subdirs
2952         do
2953                 echo "dir ${srcdir}/$s" >> .gdbinit
2954         done
2955 fi
2956 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
2957
2958 # If $(exec_prefix) exists and is not the same as $(prefix), then compute an
2959 # absolute path for gcc_tooldir based on inserting the number of up-directory
2960 # movements required to get from $(exec_prefix) to $(prefix) into the basic
2961 # $(libsubdir)/@(unlibsubdir) based path.
2962 # Don't set gcc_tooldir to tooldir since that's only passed in by the toplevel
2963 # make and thus we'd get different behavior depending on where we built the
2964 # sources.
2965 if test x$exec_prefix = xNONE -o x$exec_prefix = x$prefix; then
2966     gcc_tooldir='$(libsubdir)/$(unlibsubdir)/../$(target_alias)'
2967 else
2968 changequote(<<, >>)dnl
2969 # An explanation of the sed strings:
2970 #  -e 's|^\$(prefix)||'   matches and eliminates 'prefix' from 'exec_prefix'
2971 #  -e 's|/$||'            match a trailing forward slash and eliminates it
2972 #  -e 's|^[^/]|/|'        forces the string to start with a forward slash (*)
2973 #  -e 's|/[^/]*|../|g'    replaces each occurrence of /<directory> with ../
2974 #
2975 # (*) Note this pattern overwrites the first character of the string
2976 # with a forward slash if one is not already present.  This is not a
2977 # problem because the exact names of the sub-directories concerned is
2978 # unimportant, just the number of them matters.
2979 #
2980 # The practical upshot of these patterns is like this:
2981 #
2982 #  prefix     exec_prefix        result
2983 #  ------     -----------        ------
2984 #   /foo        /foo/bar          ../
2985 #   /foo/       /foo/bar          ../
2986 #   /foo        /foo/bar/         ../
2987 #   /foo/       /foo/bar/         ../
2988 #   /foo        /foo/bar/ugg      ../../
2989 #
2990     dollar='$$'
2991     gcc_tooldir="\$(libsubdir)/\$(unlibsubdir)/\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/\$(dollar)||' -e 's|^[^/]|/|' -e 's|/[^/]*|../|g'\`\$(target_alias)"
2992 changequote([, ])dnl
2993 fi
2994 AC_SUBST(gcc_tooldir)
2995 AC_SUBST(dollar)
2996
2997 # Find a directory in which to install a shared libgcc.
2998
2999 AC_ARG_ENABLE(version-specific-runtime-libs,
3000 [  --enable-version-specific-runtime-libs
3001                           specify that runtime libraries should be
3002                           installed in a compiler-specific directory])
3003
3004 AC_ARG_WITH(slibdir,
3005 [  --with-slibdir=DIR      shared libraries in DIR [LIBDIR]],
3006 slibdir="$with_slibdir",
3007 if test "${enable_version_specific_runtime_libs+set}" = set; then
3008   slibdir='$(libsubdir)'
3009 elif test "$host" != "$target"; then
3010   slibdir='$(build_tooldir)/lib'
3011 else
3012   slibdir='$(libdir)'
3013 fi)
3014 AC_SUBST(slibdir)
3015
3016 objdir=`${PWDCMD-pwd}`
3017 AC_SUBST(objdir)
3018
3019 # Process the language and host/target makefile fragments.
3020 ${CONFIG_SHELL-/bin/sh} $srcdir/configure.frag $srcdir "$subdirs" "$dep_host_xmake_file" "$dep_tmake_file"
3021
3022 # Substitute configuration variables
3023 AC_SUBST(subdirs)
3024 AC_SUBST(srcdir)
3025 AC_SUBST(all_boot_languages)
3026 AC_SUBST(all_compilers)
3027 AC_SUBST(all_gtfiles)
3028 AC_SUBST(all_gtfiles_files_langs)
3029 AC_SUBST(all_gtfiles_files_files)
3030 AC_SUBST(all_lang_makefiles)
3031 AC_SUBST(all_languages)
3032 AC_SUBST(all_stagestuff)
3033 AC_SUBST(build_exeext)
3034 AC_SUBST(build_install_headers_dir)
3035 AC_SUBST(build_xm_file_list)
3036 AC_SUBST(build_xm_file)
3037 AC_SUBST(build_xm_defines)
3038 AC_SUBST(check_languages)
3039 AC_SUBST(cc_set_by_configure)
3040 AC_SUBST(quoted_cc_set_by_configure)
3041 AC_SUBST(cpp_install_dir)
3042 AC_SUBST(dep_host_xmake_file)
3043 AC_SUBST(dep_tmake_file)
3044 AC_SUBST(extra_headers_list)
3045 AC_SUBST(extra_objs)
3046 AC_SUBST(extra_parts)
3047 AC_SUBST(extra_passes)
3048 AC_SUBST(extra_programs)
3049 AC_SUBST(float_h_file)
3050 AC_SUBST(gcc_config_arguments)
3051 AC_SUBST(gcc_gxx_include_dir)
3052 AC_SUBST(libstdcxx_incdir)
3053 AC_SUBST(gcc_version)
3054 AC_SUBST(gcc_version_full)
3055 AC_SUBST(gcc_version_trigger)
3056 AC_SUBST(host_exeext)
3057 AC_SUBST(host_extra_gcc_objs)
3058 AC_SUBST(host_xm_file_list)
3059 AC_SUBST(host_xm_file)
3060 AC_SUBST(host_xm_defines)
3061 AC_SUBST(out_host_hook_obj)
3062 AC_SUBST(install)
3063 AC_SUBST(lang_options_files)
3064 AC_SUBST(lang_specs_files)
3065 AC_SUBST(lang_tree_files)
3066 AC_SUBST(local_prefix)
3067 AC_SUBST(md_file)
3068 AC_SUBST(objc_boehm_gc)
3069 AC_SUBST(out_file)
3070 AC_SUBST(out_object_file)
3071 AC_SUBST(stage_prefix_set_by_configure)
3072 AC_SUBST(quoted_stage_prefix_set_by_configure)
3073 AC_SUBST(symbolic_link)
3074 AC_SUBST(thread_file)
3075 AC_SUBST(tm_file_list)
3076 AC_SUBST(tm_file)
3077 AC_SUBST(tm_defines)
3078 AC_SUBST(tm_p_file_list)
3079 AC_SUBST(tm_p_file)
3080 AC_SUBST(xm_file)
3081 AC_SUBST(xm_defines)
3082 AC_SUBST(target_alias)
3083 AC_SUBST(c_target_objs)
3084 AC_SUBST(cxx_target_objs)
3085 AC_SUBST(target_cpu_default)
3086
3087 AC_SUBST_FILE(target_overrides)
3088 AC_SUBST_FILE(host_overrides)
3089 AC_SUBST_FILE(language_fragments)
3090 AC_SUBST_FILE(language_hooks)
3091
3092 # Echo that links are built
3093 if test x$host = x$target
3094 then
3095         str1="native "
3096 else
3097         str1="cross-"
3098         str2=" from $host"
3099 fi
3100
3101 if test x$host != x$build
3102 then
3103         str3=" on a $build system"
3104 fi
3105
3106 if test "x$str2" != x || test "x$str3" != x
3107 then
3108         str4=
3109 fi
3110
3111 echo "Links are now set up to build a ${str1}compiler for ${target}$str4" 1>&2
3112
3113 if test "x$str2" != x || test "x$str3" != x
3114 then
3115         echo " ${str2}${str3}." 1>&2
3116 fi
3117
3118 # Truncate the target if necessary
3119 if test x$host_truncate_target != x; then
3120         target=`echo $target | sed -e 's/\(..............\).*/\1/'`
3121 fi
3122
3123 # Configure the subdirectories
3124 # AC_CONFIG_SUBDIRS($subdirs)
3125
3126 # Create the Makefile
3127 # and configure language subdirectories
3128 AC_OUTPUT($all_outputs,
3129 [
3130 case x$CONFIG_HEADERS in
3131 xauto-host.h:config.in)
3132 echo > cstamp-h ;;
3133 esac
3134 # If the host supports symlinks, point stage[1234] at ../stage[1234] so
3135 # bootstrapping and the installation procedure can still use
3136 # CC="stage1/xgcc -Bstage1/".  If the host doesn't support symlinks,
3137 # FLAGS_TO_PASS has been modified to solve the problem there.
3138 # This is virtually a duplicate of what happens in configure.lang; we do
3139 # an extra check to make sure this only happens if ln -s can be used.
3140 if test "$symbolic_link" = "ln -s"; then
3141  for d in .. ${subdirs} fixinc ; do
3142    if test $d != ..; then
3143         STARTDIR=`${PWDCMD-pwd}`
3144         cd $d
3145         for t in stage1 stage2 stage3 stage4 include
3146         do
3147                 rm -f $t
3148                 $symbolic_link ../$t $t 2>/dev/null
3149         done
3150         cd $STARTDIR
3151    fi
3152  done
3153 else true ; fi
3154 # Avoid having to add intl to our include paths.
3155 if test -f intl/libintl.h; then
3156   echo creating libintl.h
3157   echo '#include "intl/libintl.h"' >libintl.h
3158 fi
3159 ],
3160 [subdirs='$subdirs'
3161 symbolic_link='$symbolic_link'
3162 ])