gcc/configure.in

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