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