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