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