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