gcc/configure.ac

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