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