gcc/configure.in

   1 # configure.in for GCC
   2 # Process this file with autoconf to generate a configuration script.
   3
   4 # Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003
   5 # Free Software Foundation, Inc.
   6
   7 #This file is part of GCC.
   8
   9 #GCC is free software; you can redistribute it and/or modify it under
  10 #the terms of the GNU General Public License as published by the Free
  11 #Software Foundation; either version 2, or (at your option) any later
  12 #version.
  13
  14 #GCC is distributed in the hope that it will be useful, but WITHOUT
  15 #ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 #FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 #for more details.
  18
  19 #You should have received a copy of the GNU General Public License
  20 #along with GCC; see the file COPYING.  If not, write to the Free
  21 #Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  22 #02111-1307, USA.
  23
  24 # --------------------------------
  25 # Initialization and sanity checks
  26 # --------------------------------
  27
  28 AC_PREREQ(2.13)
  29 AC_INIT(tree.c)
  30 AC_CONFIG_HEADER(auto-host.h:config.in)
  31
  32 # Determine the host, build, and target systems
  33 AC_CANONICAL_SYSTEM
  34
  35 # Determine the noncanonical target name, for directory use.
  36 _GCC_TOPLEV_NONCANONICAL_TARGET
  37
  38 # Determine the target- and build-specific subdirectories
  39 GCC_TOPLEV_SUBDIRS
  40
  41 # Set program_transform_name
  42 AC_ARG_PROGRAM
  43
  44 # Check for bogus environment variables.
  45 # Test if LIBRARY_PATH contains the notation for the current directory
  46 # since this would lead to problems installing/building glibc.
  47 # LIBRARY_PATH contains the current directory if one of the following
  48 # is true:
  49 # - one of the terminals (":" and ";") is the first or last sign
  50 # - two terminals occur directly after each other
  51 # - the path contains an element with a dot in it
  52 AC_MSG_CHECKING(LIBRARY_PATH variable)
  53 changequote(,)dnl
  54 case ${LIBRARY_PATH} in
  55   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
  56     library_path_setting="contains current directory"
  57     ;;
  58   *)
  59     library_path_setting="ok"
  60     ;;
  61 esac
  62 changequote([,])dnl
  63 AC_MSG_RESULT($library_path_setting)
  64 if test "$library_path_setting" != "ok"; then
  65 AC_MSG_ERROR([
  66 *** LIBRARY_PATH shouldn't contain the current directory when
  67 *** building gcc. Please change the environment variable
  68 *** and run configure again.])
  69 fi
  70
  71 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
  72 # since this would lead to problems installing/building glibc.
  73 # GCC_EXEC_PREFIX contains the current directory if one of the following
  74 # is true:
  75 # - one of the terminals (":" and ";") is the first or last sign
  76 # - two terminals occur directly after each other
  77 # - the path contains an element with a dot in it
  78 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
  79 changequote(,)dnl
  80 case ${GCC_EXEC_PREFIX} in
  81   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
  82     gcc_exec_prefix_setting="contains current directory"
  83     ;;
  84   *)
  85     gcc_exec_prefix_setting="ok"
  86     ;;
  87 esac
  88 changequote([,])dnl
  89 AC_MSG_RESULT($gcc_exec_prefix_setting)
  90 if test "$gcc_exec_prefix_setting" != "ok"; then
  91 AC_MSG_ERROR([
  92 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
  93 *** building gcc. Please change the environment variable
  94 *** and run configure again.])
  95 fi
  96
  97 # -----------
  98 # Directories
  99 # -----------
 100
 101 # Specify the local prefix
 102 local_prefix=
 103 AC_ARG_WITH(local-prefix,
 104 [  --with-local-prefix=DIR specifies directory to put local include],
 105 [case "${withval}" in
 106 yes)    AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
 107 no)     ;;
 108 *)      local_prefix=$with_local_prefix ;;
 109 esac])
 110
 111 # Default local prefix if it is empty
 112 if test x$local_prefix = x; then
 113         local_prefix=/usr/local
 114 fi
 115
 116 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
 117 # passed in by the toplevel make and thus we'd get different behavior
 118 # depending on where we built the sources.
 119 gcc_gxx_include_dir=
 120 # Specify the g++ header file directory
 121 AC_ARG_WITH(gxx-include-dir,
 122 [  --with-gxx-include-dir=DIR
 123                           specifies directory to put g++ header files],
 124 [case "${withval}" in
 125 yes)    AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
 126 no)     ;;
 127 *)      gcc_gxx_include_dir=$with_gxx_include_dir ;;
 128 esac])
 129
 130 if test x${gcc_gxx_include_dir} = x; then
 131   if test x${enable_version_specific_runtime_libs} = xyes; then
 132     gcc_gxx_include_dir='${libsubdir}/include/c++'
 133   else
 134     topsrcdir=${srcdir}/.. . ${srcdir}/../config.if
 135 changequote(<<, >>)dnl
 136     gcc_gxx_include_dir="\$(libsubdir)/\$(unlibsubdir)/..\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/[^/]*|/..|g'\`/include/"${libstdcxx_incdir}
 137 changequote([, ])dnl
 138   fi
 139 fi
 140
 141 AC_ARG_WITH(cpp_install_dir,
 142 [  --with-cpp-install-dir=DIR
 143                           install the user visible C preprocessor in DIR
 144                           (relative to PREFIX) as well as PREFIX/bin],
 145 [if test x$withval = xyes; then
 146   AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
 147 elif test x$withval != xno; then
 148   cpp_install_dir=$withval
 149 fi])
 150
 151 # We would like to our source tree to be readonly.  However when releases or
 152 # pre-releases are generated, the flex/bison generated files as well as the
 153 # various formats of manuals need to be included along with the rest of the
 154 # sources.  Therefore we have --enable-generated-files-in-srcdir to do
 155 # just that.
 156
 157 AC_ARG_ENABLE(generated-files-in-srcdir,
 158 [  --enable-generated-files-in-srcdir  Put generated files in source dir],
 159 [case ${enableval} in
 160   no)    parsedir='$(objdir)'; docobjdir='$(objdir)/doc';;
 161   *)     parsedir='$(srcdir)'; docobjdir='$(srcdir)/doc';;
 162 esac],
 163 [parsedir='$(objdir)'; docobjdir='$(objdir)/doc';])
 164
 165 # -------------------
 166 # Find default linker
 167 # -------------------
 168
 169 # With GNU ld
 170 AC_ARG_WITH(gnu-ld,
 171 [  --with-gnu-ld           arrange to work with GNU ld.],
 172 gnu_ld_flag="$with_gnu_ld",
 173 gnu_ld_flag=no)
 174
 175 # With pre-defined ld
 176 AC_ARG_WITH(ld,
 177 [  --with-ld               arrange to use the specified ld (full pathname)],
 178 DEFAULT_LINKER="$with_ld")
 179 if test x"${DEFAULT_LINKER+set}" = x"set"; then
 180   if test ! -x "$DEFAULT_LINKER"; then
 181     AC_MSG_WARN([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
 182   elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
 183     gnu_ld_flag=yes
 184   fi
 185   AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
 186         [Define to enable the use of a default linker.])
 187 fi
 188
 189 AC_MSG_CHECKING([whether a default linker was specified])
 190 if test x"${DEFAULT_LINKER+set}" = x"set"; then
 191   if test x"$gnu_ld_flag" = x"no"; then
 192     AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
 193   else
 194     AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
 195   fi
 196 else
 197   AC_MSG_RESULT(no)
 198 fi
 199
 200 # ----------------------
 201 # Find default assembler
 202 # ----------------------
 203
 204 # With GNU as
 205 AC_ARG_WITH(gnu-as,
 206 [  --with-gnu-as           arrange to work with GNU as],
 207 gas_flag="$with_gnu_as",
 208 gas_flag=no)
 209
 210 AC_ARG_WITH(as,
 211 [  --with-as               arrange to use the specified as (full pathname)],
 212 DEFAULT_ASSEMBLER="$with_as")
 213 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
 214   if test ! -x "$DEFAULT_ASSEMBLER"; then
 215     AC_MSG_WARN([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
 216   elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
 217     gas_flag=yes
 218   fi
 219   AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
 220         [Define to enable the use of a default assembler.])
 221 fi
 222
 223 AC_MSG_CHECKING([whether a default assembler was specified])
 224 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
 225   if test x"$gas_flag" = x"no"; then
 226     AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
 227   else
 228     AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
 229   fi
 230 else
 231   AC_MSG_RESULT(no)
 232 fi
 233
 234 # ---------------
 235 # Find C compiler
 236 # ---------------
 237
 238 # Find the native compiler
 239 AC_PROG_CC
 240 AC_PROG_CC_C_O
 241 # autoconf is lame and doesn't give us any substitution variable for this.
 242 if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = no"; then
 243   NO_MINUS_C_MINUS_O=yes
 244 else
 245   OUTPUT_OPTION='-o $@'
 246 fi
 247 AC_SUBST(NO_MINUS_C_MINUS_O)
 248 AC_SUBST(OUTPUT_OPTION)
 249
 250 # -------------------------
 251 # Check C compiler features
 252 # -------------------------
 253
 254 AC_CACHE_CHECK(whether ${CC-cc} accepts -Wno-long-long,
 255 ac_cv_prog_cc_no_long_long,
 256 [save_CFLAGS="$CFLAGS"
 257 CFLAGS="-Wno-long-long"
 258 AC_TRY_COMPILE(,,ac_cv_prog_cc_no_long_long=yes,
 259                ac_cv_prog_cc_no_long_long=no)
 260 CFLAGS="$save_CFLAGS"])
 261
 262 AC_PROG_CPP
 263 AC_C_INLINE
 264
 265 gcc_AC_C_LONG_LONG
 266 gcc_AC_C__BOOL
 267
 268 # sizeof(char) is 1 by definition.
 269 AC_COMPILE_CHECK_SIZEOF(void *)
 270 AC_COMPILE_CHECK_SIZEOF(short)
 271 AC_COMPILE_CHECK_SIZEOF(int)
 272 AC_COMPILE_CHECK_SIZEOF(long)
 273 if test $ac_cv_c_long_long = yes; then
 274   AC_COMPILE_CHECK_SIZEOF(long long)
 275 fi
 276 if test $ac_cv_c___int64 = yes; then
 277   AC_COMPILE_CHECK_SIZEOF(__int64)
 278 fi
 279
 280 # -----------------
 281 # Find Ada compiler
 282 # -----------------
 283
 284 # See if GNAT has been installed
 285 gcc_AC_PROG_GNAT
 286
 287 # ---------------------
 288 # Warnings and checking
 289 # ---------------------
 290
 291 strict1_warn=
 292 if test $ac_cv_prog_cc_no_long_long = yes ; then
 293   strict1_warn="-pedantic -Wno-long-long"
 294 fi
 295 AC_SUBST(strict1_warn)
 296
 297 # If the native compiler is GCC, we can enable warnings even in stage1.
 298 # That's useful for people building cross-compilers, or just running a
 299 # quick `make'.
 300 warn_cflags=
 301 if test "x$GCC" = "xyes"; then
 302   warn_cflags='$(GCC_WARN_CFLAGS)'
 303 fi
 304 AC_SUBST(warn_cflags)
 305
 306 # Enable -Werror in bootstrap stage2 and later.
 307 # Change the default to "no" on release branches.
 308 AC_ARG_ENABLE(werror,
 309 [  --enable-werror         enable -Werror in bootstrap stage2 and later], [],
 310 [enable_werror=yes])
 311 if test x$enable_werror = xyes ; then
 312   WERROR=-Werror
 313 fi
 314 AC_SUBST(WERROR)
 315
 316 # Enable expensive internal checks
 317 AC_ARG_ENABLE(checking,
 318 [  --enable-checking[=LIST]
 319                           enable expensive run-time checks.  With LIST,
 320                           enable only specific categories of checks.
 321                           Categories are: misc,tree,rtl,rtlflag,gc,gcac,fold;
 322                           default is misc,tree,gc,rtlflag],
 323 [ac_checking=
 324 ac_tree_checking=
 325 ac_rtl_checking=
 326 ac_rtlflag_checking=
 327 ac_gc_checking=
 328 ac_gc_always_collect=
 329 ac_fold_checking=
 330 case "${enableval}" in
 331 yes)    ac_checking=1 ; ac_tree_checking=1 ; ac_gc_checking=1 ;
 332         ac_rtlflag_checking=1 ;;
 333 no)     ;;
 334 *)      IFS="${IFS=     }"; ac_save_IFS="$IFS"; IFS="$IFS,"
 335         set fnord $enableval; shift
 336         IFS="$ac_save_IFS"
 337         for check
 338         do
 339                 case $check in
 340                 misc)   ac_checking=1 ;;
 341                 tree)   ac_tree_checking=1 ;;
 342                 rtlflag)        ac_rtlflag_checking=1 ;;
 343                 rtl)    ac_rtl_checking=1 ;;
 344                 gc)     ac_gc_checking=1 ;;
 345                 gcac)   ac_gc_always_collect=1 ;;
 346                 fold)   ac_fold_checking=1 ;;
 347                 valgrind)       ac_checking_valgrind=1 ;;
 348                 *)      AC_MSG_ERROR(unknown check category $check) ;;
 349                 esac
 350         done
 351         ;;
 352 esac
 353 ],
 354 # Enable some checks by default for development versions of GCC
 355 [ac_checking=1; ac_tree_checking=1; ac_gc_checking=1; ac_rtlflag_checking=1;])
 356 nocommon_flag=""
 357 if test x$ac_checking != x ; then
 358   AC_DEFINE(ENABLE_CHECKING, 1,
 359 [Define if you want more run-time sanity checks.  This one gets a grab
 360    bag of miscellaneous but relatively cheap checks.])
 361   nocommon_flag=-fno-common
 362 fi
 363 AC_SUBST(nocommon_flag)
 364 if test x$ac_tree_checking != x ; then
 365   AC_DEFINE(ENABLE_TREE_CHECKING, 1,
 366 [Define if you want all operations on trees (the basic data
 367    structure of the front ends) to be checked for dynamic type safety
 368    at runtime.  This is moderately expensive.])
 369 fi
 370 if test x$ac_rtl_checking != x ; then
 371   AC_DEFINE(ENABLE_RTL_CHECKING, 1,
 372 [Define if you want all operations on RTL (the basic data structure
 373    of the optimizer and back end) to be checked for dynamic type safety
 374    at runtime.  This is quite expensive.])
 375 fi
 376 if test x$ac_rtlflag_checking != x ; then
 377   AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
 378 [Define if you want RTL flag accesses to be checked against the RTL
 379    codes that are supported for each access macro.  This is relatively
 380    cheap.])
 381 fi
 382 if test x$ac_gc_checking != x ; then
 383   AC_DEFINE(ENABLE_GC_CHECKING, 1,
 384 [Define if you want the garbage collector to do object poisoning and
 385    other memory allocation checks.  This is quite expensive.])
 386 fi
 387 if test x$ac_gc_always_collect != x ; then
 388   AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
 389 [Define if you want the garbage collector to operate in maximally
 390    paranoid mode, validating the entire heap and collecting garbage at
 391    every opportunity.  This is extremely expensive.])
 392 fi
 393 if test x$ac_fold_checking != x ; then
 394   AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
 395 [Define if you want fold checked that it never destructs its argument.
 396    This is quite expensive.])
 397 fi
 398 valgrind_path_defines=
 399 valgrind_command=
 400
 401 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
 402 dnl # an if statement.  This was the source of very frustrating bugs
 403 dnl # in converting to autoconf 2.5x!
 404 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
 405
 406 if test x$ac_checking_valgrind != x ; then
 407   # It is certainly possible that there's valgrind but no valgrind.h.
 408   # GCC relies on making annotations so we must have both.
 409   AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
 410   AC_TRY_CPP(
 411     [#include <valgrind/memcheck.h>
 412 #ifndef VALGRIND_DISCARD
 413 #error VALGRIND_DISCARD not defined
 414 #endif],
 415   [gcc_cv_header_valgrind_memcheck_h=yes],
 416   [gcc_cv_header_valgrind_memcheck_h=no])
 417   AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
 418   AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
 419   AC_TRY_CPP(
 420     [#include <memcheck.h>
 421 #ifndef VALGRIND_DISCARD
 422 #error VALGRIND_DISCARD not defined
 423 #endif],
 424   [gcc_cv_header_memcheck_h=yes],
 425   gcc_cv_header_memcheck_h=no)
 426   AC_MSG_RESULT($gcc_cv_header_memcheck_h)
 427   AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
 428         [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
 429   if test "x$valgrind_path" = "x" \
 430     || (test $have_valgrind_h = no \
 431         && test $gcc_cv_header_memcheck_h = no \
 432         && test $gcc_cv_header_valgrind_memcheck_h = no); then
 433         AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
 434   fi
 435   valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
 436   valgrind_command="$valgrind_path -q"
 437   AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
 438 [Define if you want to run subprograms and generated programs
 439    through valgrind (a memory checker).  This is extremely expensive.])
 440   if test $gcc_cv_header_valgrind_memcheck_h = yes; then
 441     AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
 442         [Define if valgrind's valgrind/memcheck.h header is installed.])
 443   fi
 444   if test $gcc_cv_header_memcheck_h = yes; then
 445     AC_DEFINE(HAVE_MEMCHECK_H, 1,
 446         [Define if valgrind's memcheck.h header is installed.])
 447   fi
 448 fi
 449 AC_SUBST(valgrind_path_defines)
 450 AC_SUBST(valgrind_command)
 451
 452 # Enable code coverage collection
 453 AC_ARG_ENABLE(coverage,
 454 [  --enable-coverage[=LEVEL]
 455                           enable compiler\'s code coverage collection.
 456                           Use to measure compiler performance and locate
 457                           unused parts of the compiler. With LEVEL, specify
 458                           optimization. Values are opt, noopt,
 459                           default is noopt],
 460 [case "${enableval}" in
 461 yes|noopt)
 462         coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
 463         ;;
 464 opt)
 465         coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
 466         ;;
 467 *)
 468         AC_MSG_ERROR(unknown coverage setting $enableval)
 469         ;;
 470 esac],
 471 [coverage_flags=""])
 472 AC_SUBST(coverage_flags)
 473
 474 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 [  cat > conftest.lit <<EOF
1977  0000 10000000 00000000 017a0001 781a0004  .........z..x...
1978  0010 01000000 12000000 18000000 00000000  ................
1979  0020 08000000 04080000 0044               .........D
1980 EOF
1981   cat > conftest.big <<EOF
1982  0000 00000010 00000000 017a0001 781a0004  .........z..x...
1983  0010 00000001 00000012 00000018 00000000  ................
1984  0020 00000008 04000000 0844               .........D
1985 EOF
1986   # If the assembler didn't choke, and we can objdump,
1987   # and we got the correct data, then succeed.
1988   if test x$gcc_cv_objdump != x \
1989   && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
1990      | tail -3 > conftest.got \
1991   && { cmp conftest.lit conftest.got > /dev/null 2>&1 \
1992     || cmp conftest.big conftest.got > /dev/null 2>&1; }
1993   then
1994     gcc_cv_as_eh_frame=yes
1995   elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
1996     gcc_cv_as_eh_frame=buggy
1997   else
1998     # Uh oh, what do we do now?
1999     gcc_cv_as_eh_frame=no
2000   fi])
2001
2002 if test $gcc_cv_as_eh_frame = buggy; then
2003   AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2004   [Define if your assembler mis-optimizes .eh_frame data.])
2005 fi
2006
2007 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2008  [elf,2,12,0], [--fatal-warnings],
2009  [.section .rodata.str, "aMS", @progbits, 1])
2010 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2011   [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2012 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2013
2014 # Thread-local storage - the check is heavily parametrized.
2015 conftest_s=
2016 tls_first_major=
2017 tls_first_minor=
2018 tls_as_opt=
2019 case "$target" in
2020 changequote(,)dnl
2021   alpha*-*-*)
2022     conftest_s='
2023         .section ".tdata","awT",@progbits
2024 foo:    .long   25
2025         .text
2026         ldq     $27,__tls_get_addr($29)         !literal!1
2027         lda     $16,foo($29)                    !tlsgd!1
2028         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
2029         ldq     $27,__tls_get_addr($29)         !literal!2
2030         lda     $16,foo($29)                    !tlsldm!2
2031         jsr     $26,($27),__tls_get_addr        !lituse_tlsldm!2
2032         ldq     $1,foo($29)                     !gotdtprel
2033         ldah    $2,foo($29)                     !dtprelhi
2034         lda     $3,foo($2)                      !dtprello
2035         lda     $4,foo($29)                     !dtprel
2036         ldq     $1,foo($29)                     !gottprel
2037         ldah    $2,foo($29)                     !tprelhi
2038         lda     $3,foo($2)                      !tprello
2039         lda     $4,foo($29)                     !tprel'
2040         tls_first_major=2
2041         tls_first_minor=13
2042         ;;
2043   i[34567]86-*-*)
2044     conftest_s='
2045         .section ".tdata","awT",@progbits
2046 foo:    .long   25
2047         .text
2048         movl    %gs:0, %eax
2049         leal    foo@TLSGD(,%ebx,1), %eax
2050         leal    foo@TLSLDM(%ebx), %eax
2051         leal    foo@DTPOFF(%eax), %edx
2052         movl    foo@GOTTPOFF(%ebx), %eax
2053         subl    foo@GOTTPOFF(%ebx), %eax
2054         addl    foo@GOTNTPOFF(%ebx), %eax
2055         movl    foo@INDNTPOFF, %eax
2056         movl    $foo@TPOFF, %eax
2057         subl    $foo@TPOFF, %eax
2058         leal    foo@NTPOFF(%ecx), %eax'
2059         tls_first_major=2
2060         tls_first_minor=14
2061         ;;
2062   x86_64-*-*)
2063     conftest_s='
2064         .section ".tdata","awT",@progbits
2065 foo:    .long   25
2066         .text
2067         movq    %fs:0, %rax
2068         leaq    foo@TLSGD(%rip), %rdi
2069         leaq    foo@TLSLD(%rip), %rdi
2070         leaq    foo@DTPOFF(%rax), %rdx
2071         movq    foo@GOTTPOFF(%rip), %rax
2072         movq    $foo@TPOFF, %rax'
2073         tls_first_major=2
2074         tls_first_minor=14
2075         ;;
2076   ia64-*-*)
2077     conftest_s='
2078         .section ".tdata","awT",@progbits
2079 foo:    data8   25
2080         .text
2081         addl    r16 = @ltoff(@dtpmod(foo#)), gp
2082         addl    r17 = @ltoff(@dtprel(foo#)), gp
2083         addl    r18 = @ltoff(@tprel(foo#)), gp
2084         addl    r19 = @dtprel(foo#), gp
2085         adds    r21 = @dtprel(foo#), r13
2086         movl    r23 = @dtprel(foo#)
2087         addl    r20 = @tprel(foo#), gp
2088         adds    r22 = @tprel(foo#), r13
2089         movl    r24 = @tprel(foo#)'
2090         tls_first_major=2
2091         tls_first_minor=13
2092         ;;
2093   powerpc-*-*)
2094     conftest_s='
2095         .section ".tdata","awT",@progbits
2096         .align 2
2097 ld0:    .space 4
2098 ld1:    .space 4
2099 x1:     .space 4
2100 x2:     .space 4
2101 x3:     .space 4
2102         .text
2103         addi 3,31,ld0@got@tlsgd
2104         bl __tls_get_addr
2105         addi 3,31,x1@got@tlsld
2106         bl __tls_get_addr
2107         addi 9,3,x1@dtprel
2108         addis 9,3,x2@dtprel@ha
2109         addi 9,9,x2@dtprel@l
2110         lwz 9,x3@got@tprel(31)
2111         add 9,9,x@tls
2112         addi 9,2,x1@tprel
2113         addis 9,2,x2@tprel@ha
2114         addi 9,9,x2@tprel@l'
2115         tls_first_major=2
2116         tls_first_minor=14
2117         tls_as_opt=-a32
2118         ;;
2119   powerpc64-*-*)
2120     conftest_s='
2121         .section ".tdata","awT",@progbits
2122         .align 3
2123 ld0:    .space 8
2124 ld1:    .space 8
2125 x1:     .space 8
2126 x2:     .space 8
2127 x3:     .space 8
2128         .text
2129         addi 3,2,ld0@got@tlsgd
2130         bl .__tls_get_addr
2131         nop
2132         addi 3,2,ld1@toc
2133         bl .__tls_get_addr
2134         nop
2135         addi 3,2,x1@got@tlsld
2136         bl .__tls_get_addr
2137         nop
2138         addi 9,3,x1@dtprel
2139         bl .__tls_get_addr
2140         nop
2141         addis 9,3,x2@dtprel@ha
2142         addi 9,9,x2@dtprel@l
2143         bl .__tls_get_addr
2144         nop
2145         ld 9,x3@got@dtprel(2)
2146         add 9,9,3
2147         bl .__tls_get_addr
2148         nop'
2149         tls_first_major=2
2150         tls_first_minor=14
2151         tls_as_opt=-a64
2152         ;;
2153   s390-*-*)
2154     conftest_s='
2155         .section ".tdata","awT",@progbits
2156 foo:    .long   25
2157         .text
2158         .long   foo@TLSGD
2159         .long   foo@TLSLDM
2160         .long   foo@DTPOFF
2161         .long   foo@NTPOFF
2162         .long   foo@GOTNTPOFF
2163         .long   foo@INDNTPOFF
2164         l       %r1,foo@GOTNTPOFF(%r12)
2165         l       %r1,0(%r1):tls_load:foo
2166         bas     %r14,0(%r1,%r13):tls_gdcall:foo
2167         bas     %r14,0(%r1,%r13):tls_ldcall:foo'
2168         tls_first_major=2
2169         tls_first_minor=14
2170         tls_as_opt=-m31
2171         ;;
2172   s390x-*-*)
2173     conftest_s='
2174         .section ".tdata","awT",@progbits
2175 foo:    .long   25
2176         .text
2177         .quad   foo@TLSGD
2178         .quad   foo@TLSLDM
2179         .quad   foo@DTPOFF
2180         .quad   foo@NTPOFF
2181         .quad   foo@GOTNTPOFF
2182         lg      %r1,foo@GOTNTPOFF(%r12)
2183         larl    %r1,foo@INDNTPOFF
2184         brasl   %r14,__tls_get_offset@PLT:tls_gdcall:foo
2185         brasl   %r14,__tls_get_offset@PLT:tls_ldcall:foo'
2186         tls_first_major=2
2187         tls_first_minor=14
2188         tls_as_opt="-m64 -Aesame"
2189         ;;
2190   sh-*-* | sh[34]-*-*)
2191     conftest_s='
2192         .section ".tdata","awT",@progbits
2193 foo:    .long   25
2194         .text
2195         .long   foo@TLSGD
2196         .long   foo@TLSLDM
2197         .long   foo@DTPOFF
2198         .long   foo@GOTTPOFF
2199         .long   foo@TPOFF'
2200         tls_first_major=2
2201         tls_first_minor=13
2202         ;;
2203   sparc*-*-*)
2204     conftest_s='
2205         .section ".tdata","awT",@progbits
2206 foo:    .long   25
2207         .text
2208         sethi   %tgd_hi22(foo), %o0
2209         add     %o0, %tgd_lo10(foo), %o1
2210         add     %l7, %o1, %o0, %tgd_add(foo)
2211         call    __tls_get_addr, %tgd_call(foo)
2212         sethi   %tldm_hi22(foo), %l1
2213         add     %l1, %tldm_lo10(foo), %l2
2214         add     %l7, %l2, %o0, %tldm_add(foo)
2215         call    __tls_get_addr, %tldm_call(foo)
2216         sethi   %tldo_hix22(foo), %l3
2217         xor     %l3, %tldo_lox10(foo), %l4
2218         add     %o0, %l4, %l5, %tldo_add(foo)
2219         sethi   %tie_hi22(foo), %o3
2220         add     %o3, %tie_lo10(foo), %o3
2221         ld      [%l7 + %o3], %o2, %tie_ld(foo)
2222         add     %g7, %o2, %o4, %tie_add(foo)
2223         sethi   %tle_hix22(foo), %l1
2224         xor     %l1, %tle_lox10(foo), %o5
2225         ld      [%g7 + %o5], %o1'
2226         tls_first_major=2
2227         tls_first_minor=14
2228         tls_as_opt=-32
2229         ;;
2230 changequote([,])dnl
2231 esac
2232 if test -z "$tls_first_major"; then
2233   : # If we don't have a check, assume no support.
2234 else
2235   gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
2236   [$tls_first_major,$tls_first_minor,0], [$tls_as_opt --fatal-warnings],
2237   [$conftest_s],,
2238   [AC_DEFINE(HAVE_AS_TLS, 1,
2239             [Define if your assembler supports thread-local storage.])])
2240 fi
2241
2242 # Target-specific assembler checks.
2243
2244 case "$target" in
2245   # All TARGET_ABI_OSF targets.
2246   alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
2247     gcc_GAS_CHECK_FEATURE([explicit relocation support],
2248         gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
2249 [       .set nomacro
2250         .text
2251         extbl   $3, $2, $3      !lituse_bytoff!1
2252         ldq     $2, a($29)      !literal!1
2253         ldq     $4, b($29)      !literal!2
2254         ldq_u   $3, 0($2)       !lituse_base!1
2255         ldq     $27, f($29)     !literal!5
2256         jsr     $26, ($27), f   !lituse_jsr!5
2257         ldah    $29, 0($26)     !gpdisp!3
2258         lda     $0, c($29)      !gprel
2259         ldah    $1, d($29)      !gprelhigh
2260         lda     $1, d($1)       !gprellow
2261         lda     $29, 0($29)     !gpdisp!3],,
2262     [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
2263   [Define if your assembler supports explicit relocations.])])
2264     ;;
2265
2266   sparc*-*-*)
2267     gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
2268       [.register %g2, #scratch],,
2269       [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
2270                 [Define if your assembler supports .register.])])
2271
2272     gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
2273       [-relax], [.text],,
2274       [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
2275                 [Define if your assembler supports -relax option.])])
2276
2277     gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
2278       gcc_cv_as_sparc_ua_pcrel,,
2279       [-K PIC],
2280 [.text
2281 foo:
2282         nop
2283 .data
2284 .align 4
2285 .byte 0
2286 .uaword %r_disp32(foo)],
2287       [if test x$gcc_cv_ld != x \
2288        && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
2289          gcc_cv_as_sparc_ua_pcrel=yes
2290        fi
2291        rm -f conftest],
2292       [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
2293                 [Define if your assembler and linker support unaligned PC relative relocs.])
2294
2295       gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
2296         gcc_cv_as_sparc_ua_pcrel_hidden,,
2297         [-K PIC],
2298 [.data
2299 .align 4
2300 .byte 0x31
2301 .uaword %r_disp32(foo)
2302 .byte 0x32, 0x33, 0x34
2303 .global foo
2304 .hidden foo
2305 foo:
2306 .skip 4],
2307         [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
2308          && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
2309          && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
2310             | grep ' 31000000 07323334' > /dev/null 2>&1; then
2311             if $gcc_cv_objdump -R conftest 2> /dev/null \
2312                | grep 'DISP32' > /dev/null 2>&1; then
2313                 :
2314             else
2315                 gcc_cv_as_sparc_ua_pcrel_hidden=yes
2316             fi
2317          fi
2318          rm -f conftest],
2319          [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
2320                    [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
2321     ]) # unaligned pcrel relocs
2322
2323     gcc_GAS_CHECK_FEATURE([offsetable %lo()],
2324       gcc_cv_as_sparc_offsetable_lo10,,
2325       [-xarch=v9],
2326 [.text
2327         or %g1, %lo(ab) + 12, %g1
2328         or %g1, %lo(ab + 12), %g1],
2329       [if test x$gcc_cv_objdump != x \
2330        && %gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
2331           | grep ' 82106000 82106000' > /dev/null 2>&1; then
2332          gcc_cv_as_offsetable_lo10=yes
2333        fi],
2334        [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
2335                  [Define if your assembler supports offsetable %lo().])])
2336     ;;
2337
2338 changequote(,)dnl
2339   i[34567]86-*-* | x86_64-*-*)
2340 changequote([,])dnl
2341     gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
2342        gcc_cv_as_ix86_filds_fists,
2343       [2,9,0],, [filds mem; fists mem],,
2344       [AC_DEFINE(HAVE_GAS_FILDS_FISTS, 1,
2345         [Define if your assembler uses the new HImode fild and fist notation.])])
2346
2347     gcc_GAS_CHECK_FEATURE([cmov syntax],
2348       gcc_cv_as_ix86_cmov_sun_syntax,,,
2349       [cmovl.l %edx, %eax],,
2350       [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
2351         [Define if your assembler supports the Sun syntax for cmov.])])
2352
2353     # This one is used unconditionally by i386.[ch]; it is to be defined
2354     # to 1 if the feature is present, 0 otherwise.
2355     gcc_GAS_CHECK_FEATURE([GOTOFF in data],
2356         gcc_cv_as_ix86_gotoff_in_data, [2,11,0],,
2357 [       .text
2358 .L0:
2359         nop
2360         .data
2361         .long .L0@GOTOFF])
2362     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
2363       [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
2364       [Define true if the assembler supports '.long foo@GOTOFF'.])
2365     ;;
2366
2367   ia64*-*-*)
2368     gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
2369         gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
2370 [       .text
2371         addl r15 = @ltoffx(x#), gp
2372         ;;
2373         ld8.mov r16 = [[r15]], x#],,
2374     [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
2375           [Define if your assembler supports ltoffx and ldxmov relocations.])])
2376
2377     ;;
2378
2379   powerpc*-*-*)
2380     case $target in
2381       *-*-aix) conftest_s='     .csect .text[PR]';;
2382       *)       conftest_s='     .text';;
2383     esac
2384     conftest_s="$conftest_s
2385         mfcr 3,128"
2386
2387     gcc_GAS_CHECK_FEATURE([mfcr field support],
2388       gcc_cv_as_powerpc_mfcrf, [2,14,0],,
2389       [$conftest_s],,
2390       [AC_DEFINE(HAVE_AS_MFCRF, 1,
2391           [Define if your assembler supports mfcr field.])])
2392     ;;
2393
2394   mips*-*-*)
2395     gcc_GAS_CHECK_FEATURE([explicit relocation support],
2396       gcc_cv_as_mips_explicit_relocs, [2,14,0],,
2397 [       lw $4,%gp_rel(foo)($4)],,
2398       [if test x$target_cpu_default = x
2399        then target_cpu_default=MASK_EXPLICIT_RELOCS
2400        else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
2401        fi])
2402
2403     ;;
2404 esac
2405 # ??? Not all targets support dwarf2 debug_line, even within a version
2406 # of gas.  Moreover, we need to emit a valid instruction to trigger any
2407 # info to the output file.  So, as supported targets are added to gas 2.11,
2408 # add some instruction here to (also) show we expect this might work.
2409 # ??? Once 2.11 is released, probably need to add first known working
2410 # version to the per-target configury.
2411 case "$target" in
2412   i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* \
2413   | x86_64*-*-* | hppa*-*-* | arm*-*-* | strongarm*-*-* | xscale*-*-* \
2414   | xstormy16*-*-* | cris-*-* | xtensa-*-*)
2415     insn="nop"
2416     ;;
2417   ia64*-*-*)
2418     insn="nop 0"
2419     ;;
2420   mmix-*-*)
2421     insn="swym 0"
2422     ;;
2423 esac
2424 if test x"$insn" != x; then
2425  conftest_s="\
2426         .file 1 \"conftest.s\"
2427         .loc 1 3 0
2428         $insn"
2429  gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
2430   gcc_cv_as_dwarf2_debug_line,
2431   [elf,2,11,0],, [$conftest_s],
2432   [# ??? This fails with non-gnu grep.  Maybe use objdump?
2433    if grep debug_line conftest.o > /dev/null 2>&1; then
2434      gcc_cv_as_dwarf2_debug_line=yes
2435    fi])
2436
2437 # The .debug_line file table must be in the exact order that
2438 # we specified the files, since these indices are also used
2439 # by DW_AT_decl_file.  Approximate this test by testing if
2440 # the assembler bitches if the same index is assigned twice.
2441  gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
2442   gcc_cv_as_dwarf2_file_buggy,,,
2443 [       .file 1 "foo.s"
2444         .file 1 "bar.s"])
2445
2446  if test $gcc_cv_as_dwarf2_debug_line = yes \
2447  && test $gcc_cv_as_dwarf2_file_buggy = no; then
2448         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
2449   [Define if your assembler supports dwarf2 .file/.loc directives,
2450    and preserves file table indices exactly as given.])
2451  fi
2452
2453  gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
2454   gcc_cv_as_gdwarf2_flag,
2455   [elf,2,11,0], [--gdwarf2], [$insn],,
2456   [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
2457 [Define if your assembler supports the --gdwarf2 option.])])
2458
2459  gcc_GAS_CHECK_FEATURE([--gstabs option],
2460   gcc_cv_as_gstabs_flag,
2461   [elf,2,11,0], [--gstabs], [$insn],
2462   [# The native Solaris 9/Intel assembler doesn't understand --gstabs
2463    # and warns about it, but still exits successfully.  So check for
2464    # this.
2465    if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
2466    then :
2467    else gcc_cv_as_gstabs_flag=yes
2468    fi],
2469   [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
2470 [Define if your assembler supports the --gstabs option.])])
2471 fi
2472
2473 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2474 gcc_cv_ld_ro_rw_mix=unknown
2475 if test $in_tree_ld = yes ; then
2476   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 \
2477      && test $in_tree_ld_is_elf = yes; then
2478     gcc_cv_ld_ro_rw_mix=read-write
2479   fi
2480 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2481   echo '.section myfoosect, "a"' > conftest1.s
2482   echo '.section myfoosect, "aw"' > conftest2.s
2483   echo '.byte 1' >> conftest2.s
2484   echo '.section myfoosect, "a"' > conftest3.s
2485   echo '.byte 0' >> conftest3.s
2486   if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2487      && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2488      && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2489      && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2490         conftest2.o conftest3.o > /dev/null 2>&1; then
2491     gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2492                          | sed -e '/myfoosect/!d' -e N`
2493     if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2494       if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2495         gcc_cv_ld_ro_rw_mix=read-only
2496       else
2497         gcc_cv_ld_ro_rw_mix=read-write
2498       fi
2499     fi
2500   fi
2501 changequote(,)dnl
2502   rm -f conftest.* conftest[123].*
2503 changequote([,])dnl
2504 fi
2505 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2506         AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2507   [Define if your linker links a mix of read-only
2508    and read-write sections into a read-write section.])
2509 fi
2510 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2511
2512 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
2513 gcc_cv_ld_eh_frame_hdr=no
2514 if test $in_tree_ld = yes ; then
2515   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 \
2516      && test $in_tree_ld_is_elf = yes; then
2517     gcc_cv_ld_eh_frame_hdr=yes
2518   fi
2519 elif test x$gcc_cv_ld != x; then
2520         # Check if linker supports --eh-frame-hdr option
2521         if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
2522                 gcc_cv_ld_eh_frame_hdr=yes
2523         fi
2524 fi
2525 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
2526         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
2527 [Define if your linker supports --eh-frame-hdr option.])
2528 fi
2529 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
2530
2531 AC_MSG_CHECKING(linker position independent executable support)
2532 gcc_cv_ld_pie=no
2533 if test $in_tree_ld = yes ; then
2534   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 \
2535      && test $in_tree_ld_is_elf = yes; then
2536     gcc_cv_ld_pie=yes
2537   fi
2538 elif test x$gcc_cv_ld != x; then
2539         # Check if linker supports -pie option
2540         if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
2541                 gcc_cv_ld_pie=yes
2542         fi
2543 fi
2544 if test x"$gcc_cv_ld_pie" = xyes; then
2545         AC_DEFINE(HAVE_LD_PIE, 1,
2546 [Define if your linker supports -pie option.])
2547 fi
2548 AC_MSG_RESULT($gcc_cv_ld_pie)
2549
2550 if test x$with_sysroot = x && test x$host = x$target \
2551    && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" ; then
2552   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
2553 [Define to PREFIX/include if cpp should also search that directory.])
2554 fi
2555
2556 # Figure out what language subdirectories are present.
2557 # Look if the user specified --enable-languages="..."; if not, use
2558 # the environment variable $LANGUAGES if defined. $LANGUAGES might
2559 # go away some day.
2560 # NB:  embedded tabs in this IF block -- do not untabify
2561 if test x"${enable_languages+set}" != xset; then
2562         if test x"${LANGUAGES+set}" = xset; then
2563                 enable_languages="${LANGUAGES}"
2564                 AC_MSG_WARN([setting LANGUAGES is deprecated, use --enable-languages instead])
2565
2566         else
2567                 enable_languages=all
2568         fi
2569 else
2570         if test x"${enable_languages}" = x \
2571         || test x"${enable_languages}" = xyes;
2572         then
2573                 AC_MSG_ERROR([--enable-languages needs at least one language argument])
2574         fi
2575 fi
2576 enable_languages=`echo "${enable_languages}" | sed -e 's/[[     ,]][[   ,]]*/,/g' -e 's/,$//'`
2577
2578 # First scan to see if an enabled language requires some other language.
2579 # We assume that a given config-lang.in will list all the language
2580 # front ends it requires, even if some are required indirectly.
2581 for lang in ${srcdir}/*/config-lang.in
2582 do
2583    case $lang in
2584     # The odd quoting in the next line works around
2585     # an apparent bug in bash 1.12 on linux.
2586 changequote(,)dnl
2587     ${srcdir}/[*]/config-lang.in)
2588        ;;
2589     *)
2590        lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^      ]*\).*$,\1,p' $lang`
2591        this_lang_requires=`sed -n -e 's,^lang_requires=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^lang_requires=\([^    ]*\).*$,\1,p' $lang`
2592        for other in $this_lang_requires
2593        do
2594           case ,${enable_languages}, in
2595            *,$other,*)
2596               ;;
2597            *,all,*)
2598               ;;
2599            *,$lang_alias,*)
2600               enable_languages="$enable_languages,$other"
2601               ;;
2602           esac
2603        done
2604        ;;
2605 changequote([,])dnl
2606    esac
2607 done
2608
2609 expected_languages=`echo ,${enable_languages}, | sed -e 's:,: :g' -e 's:  *: :g' -e 's:  *: :g' -e 's:^ ::' -e 's: $::'`
2610 found_languages=
2611 subdirs=
2612 for lang in ${srcdir}/*/config-lang.in
2613 do
2614         case $lang in
2615         # The odd quoting in the next line works around
2616         # an apparent bug in bash 1.12 on linux.
2617 changequote(,)dnl
2618         ${srcdir}/[*]/config-lang.in) ;;
2619         *)
2620           lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
2621           this_lang_libs=`sed -n -e 's,^target_libs=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^target_libs=\([^         ]*\).*$,\1,p' $lang`
2622           build_by_default=`sed -n -e 's,^build_by_default=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^build_by_default=\([^     ]*\).*$,\1,p' $lang`
2623           if test "x$lang_alias" = x
2624           then
2625                 echo "$lang doesn't set \$language." 1>&2
2626                 exit 1
2627           fi
2628           case ${build_by_default},${enable_languages}, in
2629           *,$lang_alias,*) add_this_lang=yes ;;
2630           no,*) add_this_lang=no ;;
2631           *,all,*) add_this_lang=yes ;;
2632           *) add_this_lang=no ;;
2633           esac
2634           found_languages="${found_languages} ${lang_alias}"
2635           if test x"${add_this_lang}" = xyes; then
2636                 case $lang in
2637                     ${srcdir}/ada/config-lang.in)
2638                         if test x$have_gnat = xyes ; then
2639                                 subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2640                         fi
2641                         ;;
2642                     *)
2643                         subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2644                         ;;
2645                 esac
2646           fi
2647           ;;
2648 changequote([,])dnl
2649         esac
2650 done
2651
2652 missing_languages=
2653 for expected_language in ${expected_languages} ..
2654 do
2655     if test "${expected_language}" != ..; then
2656         missing_language="${expected_language}"
2657         if test "${expected_language}" = "c" \
2658            || test "${expected_language}" = "all"; then
2659                 missing_language=
2660         fi
2661         for found_language in ${found_languages} ..
2662         do
2663             if test "${found_language}" != ..; then
2664                 if test "${expected_language}" = "${found_language}"; then
2665                     missing_language=
2666                 fi
2667             fi
2668         done
2669         if test "x${missing_language}" != x; then
2670            missing_languages="${missing_languages} ${missing_language}"
2671         fi
2672     fi
2673 done
2674
2675 if test "x$missing_languages" != x; then
2676   AC_MSG_ERROR([
2677 The following requested languages were not found:${missing_languages}
2678 The following languages were available: c${found_languages}])
2679 fi
2680
2681 # Make gthr-default.h if we have a thread file.
2682 gthread_flags=
2683 if test $thread_file != single; then
2684     rm -f gthr-default.h
2685     echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h
2686     gthread_flags=-DHAVE_GTHR_DEFAULT
2687 fi
2688 AC_SUBST(gthread_flags)
2689
2690 # Find out what GC implementation we want, or may, use.
2691 AC_ARG_WITH(gc,
2692 [  --with-gc={simple,page,zone} choose the garbage collection mechanism to use
2693                           with the compiler],
2694 [case "$withval" in
2695   simple | page | zone)
2696     GGC=ggc-$withval
2697     ;;
2698   *)
2699     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
2700     ;;
2701 esac],
2702 [GGC=ggc-page])
2703 AC_SUBST(GGC)
2704 echo "Using $GGC for garbage collection."
2705
2706 # Use the system's zlib library.
2707 zlibdir=-L../zlib
2708 zlibinc="-I\$(srcdir)/../zlib"
2709 AC_ARG_WITH(system-zlib,
2710 [  --with-system-zlib      use installed libz],
2711 zlibdir=
2712 zlibinc=
2713 )
2714 AC_SUBST(zlibdir)
2715 AC_SUBST(zlibinc)
2716
2717 dnl Very limited version of automake's enable-maintainer-mode
2718
2719 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
2720   dnl maintainer-mode is disabled by default
2721   AC_ARG_ENABLE(maintainer-mode,
2722 [  --enable-maintainer-mode
2723                           enable make rules and dependencies not useful
2724                           (and sometimes confusing) to the casual installer],
2725       maintainer_mode=$enableval,
2726       maintainer_mode=no)
2727
2728 AC_MSG_RESULT($maintainer_mode)
2729
2730 if test "$maintainer_mode" = "yes"; then
2731   MAINT=''
2732 else
2733   MAINT='#'
2734 fi
2735 AC_SUBST(MAINT)dnl
2736
2737 # Make empty files to contain the specs and options for each language.
2738 # Then add #include lines to for a compiler that has specs and/or options.
2739
2740 lang_opt_files=
2741 lang_specs_files=
2742 lang_tree_files=
2743 for subdir in . $subdirs
2744 do
2745         if test -f $srcdir/$subdir/lang.opt; then
2746             lang_opt_files="$lang_opt_files $srcdir/$subdir/lang.opt"
2747         fi
2748         if test -f $srcdir/$subdir/lang-specs.h; then
2749             lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
2750         fi
2751         if test -f $srcdir/$subdir/$subdir-tree.def; then
2752             lang_tree_files="$lang_tree_files $srcdir/$subdir/$subdir-tree.def"
2753         fi
2754 done
2755
2756 # These (without "all_") are set in each config-lang.in.
2757 # `language' must be a single word so is spelled singularly.
2758 all_languages=
2759 all_boot_languages=
2760 all_compilers=
2761 all_stagestuff=
2762 all_outputs='Makefile fixinc/Makefile gccbug mklibgcc mkheaders'
2763 # List of language makefile fragments.
2764 all_lang_makefrags=
2765 # List of language subdirectory makefiles.  Deprecated.
2766 all_lang_makefiles=
2767 # Files for gengtype
2768 all_gtfiles="$target_gtfiles"
2769 # Files for gengtype with language
2770 all_gtfiles_files_langs=
2771 all_gtfiles_files_files=
2772
2773 # Add the language fragments.
2774 # Languages are added via two mechanisms.  Some information must be
2775 # recorded in makefile variables, these are defined in config-lang.in.
2776 # We accumulate them and plug them into the main Makefile.
2777 # The other mechanism is a set of hooks for each of the main targets
2778 # like `clean', `install', etc.
2779
2780 language_hooks="Make-hooks"
2781
2782 for s in $subdirs
2783 do
2784                 language=
2785                 boot_language=
2786                 compilers=
2787                 stagestuff=
2788                 outputs=
2789                 gtfiles=
2790                 . ${srcdir}/$s/config-lang.in
2791                 if test "x$language" = x
2792                 then
2793                         echo "${srcdir}/$s/config-lang.in doesn't set \$language." 1>&2
2794                         exit 1
2795                 fi
2796                 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$s/Make-lang.in"
2797                 if test -f ${srcdir}/$s/Makefile.in
2798                 then all_lang_makefiles="$s/Makefile"
2799                 fi
2800                 all_languages="$all_languages $language"
2801                 if test "x$boot_language" = xyes
2802                 then
2803                         all_boot_languages="$all_boot_languages $language"
2804                 fi
2805                 all_compilers="$all_compilers $compilers"
2806                 all_stagestuff="$all_stagestuff $stagestuff"
2807                 all_outputs="$all_outputs $outputs"
2808                 all_gtfiles="$all_gtfiles $gtfiles"
2809                 for f in $gtfiles
2810                 do
2811                          all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2812                          all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2813                 done
2814 done
2815
2816 # Pick up gtfiles for c
2817 gtfiles=
2818 s="c"
2819 . ${srcdir}/c-config-lang.in
2820 all_gtfiles="$all_gtfiles $gtfiles"
2821 for f in $gtfiles
2822 do
2823         all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2824         all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2825 done
2826
2827 check_languages=
2828 for language in $all_languages
2829 do
2830                 check_languages="$check_languages check-$language"
2831 done
2832
2833 # We link each language in with a set of hooks, reached indirectly via
2834 # lang.${target}.
2835
2836 rm -f Make-hooks
2837 touch Make-hooks
2838 target_list="all.build all.cross start.encap rest.encap tags \
2839         install-normal install-common install-man \
2840         uninstall \
2841         mostlyclean clean distclean maintainer-clean \
2842         stage1 stage2 stage3 stage4 stageprofile stagefeedback"
2843 for t in $target_list
2844 do
2845         x=
2846         for lang in $all_languages
2847         do
2848                         x="$x $lang.$t"
2849         done
2850         echo "lang.$t: $x" >> Make-hooks
2851 done
2852
2853 # Create .gdbinit.
2854
2855 echo "dir ." > .gdbinit
2856 echo "dir ${srcdir}" >> .gdbinit
2857 if test x$gdb_needs_out_file_path = xyes
2858 then
2859         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
2860 fi
2861 if test "x$subdirs" != x; then
2862         for s in $subdirs
2863         do
2864                 echo "dir ${srcdir}/$s" >> .gdbinit
2865         done
2866 fi
2867 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
2868
2869 # If $(exec_prefix) exists and is not the same as $(prefix), then compute an
2870 # absolute path for gcc_tooldir based on inserting the number of up-directory
2871 # movements required to get from $(exec_prefix) to $(prefix) into the basic
2872 # $(libsubdir)/@(unlibsubdir) based path.
2873 # Don't set gcc_tooldir to tooldir since that's only passed in by the toplevel
2874 # make and thus we'd get different behavior depending on where we built the
2875 # sources.
2876 if test x$exec_prefix = xNONE -o x$exec_prefix = x$prefix; then
2877     gcc_tooldir='$(libsubdir)/$(unlibsubdir)/../$(target_noncanonical)'
2878 else
2879 changequote(<<, >>)dnl
2880 # An explanation of the sed strings:
2881 #  -e 's|^\$(prefix)||'   matches and eliminates 'prefix' from 'exec_prefix'
2882 #  -e 's|/$||'            match a trailing forward slash and eliminates it
2883 #  -e 's|^[^/]|/|'        forces the string to start with a forward slash (*)
2884 #  -e 's|/[^/]*|../|g'    replaces each occurrence of /<directory> with ../
2885 #
2886 # (*) Note this pattern overwrites the first character of the string
2887 # with a forward slash if one is not already present.  This is not a
2888 # problem because the exact names of the sub-directories concerned is
2889 # unimportant, just the number of them matters.
2890 #
2891 # The practical upshot of these patterns is like this:
2892 #
2893 #  prefix     exec_prefix        result
2894 #  ------     -----------        ------
2895 #   /foo        /foo/bar          ../
2896 #   /foo/       /foo/bar          ../
2897 #   /foo        /foo/bar/         ../
2898 #   /foo/       /foo/bar/         ../
2899 #   /foo        /foo/bar/ugg      ../../
2900 #
2901     dollar='$$'
2902     gcc_tooldir="\$(libsubdir)/\$(unlibsubdir)/\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/\$(dollar)||' -e 's|^[^/]|/|' -e 's|/[^/]*|../|g'\`\$(target_noncanonical)"
2903 changequote([, ])dnl
2904 fi
2905 AC_SUBST(gcc_tooldir)
2906 AC_SUBST(dollar)
2907
2908 # Find a directory in which to install a shared libgcc.
2909
2910 AC_ARG_ENABLE(version-specific-runtime-libs,
2911 [  --enable-version-specific-runtime-libs
2912                           specify that runtime libraries should be
2913                           installed in a compiler-specific directory])
2914
2915 AC_ARG_WITH(slibdir,
2916 [  --with-slibdir=DIR      shared libraries in DIR [LIBDIR]],
2917 slibdir="$with_slibdir",
2918 if test "${enable_version_specific_runtime_libs+set}" = set; then
2919   slibdir='$(libsubdir)'
2920 elif test "$host" != "$target"; then
2921   slibdir='$(build_tooldir)/lib'
2922 else
2923   slibdir='$(libdir)'
2924 fi)
2925 AC_SUBST(slibdir)
2926
2927 objdir=`${PWDCMD-pwd}`
2928 AC_SUBST(objdir)
2929
2930 # Substitute configuration variables
2931 AC_SUBST(subdirs)
2932 AC_SUBST(srcdir)
2933 AC_SUBST(docobjdir)
2934 AC_SUBST(parsedir)
2935 AC_SUBST(all_boot_languages)
2936 AC_SUBST(all_compilers)
2937 AC_SUBST(all_gtfiles)
2938 AC_SUBST(all_gtfiles_files_langs)
2939 AC_SUBST(all_gtfiles_files_files)
2940 AC_SUBST(all_lang_makefrags)
2941 AC_SUBST(all_lang_makefiles)
2942 AC_SUBST(all_languages)
2943 AC_SUBST(all_stagestuff)
2944 AC_SUBST(build_exeext)
2945 AC_SUBST(build_install_headers_dir)
2946 AC_SUBST(build_xm_file_list)
2947 AC_SUBST(build_xm_include_list)
2948 AC_SUBST(build_xm_defines)
2949 AC_SUBST(check_languages)
2950 AC_SUBST(cc_set_by_configure)
2951 AC_SUBST(quoted_cc_set_by_configure)
2952 AC_SUBST(cpp_install_dir)
2953 AC_SUBST(xmake_file)
2954 AC_SUBST(tmake_file)
2955 AC_SUBST(extra_headers_list)
2956 AC_SUBST(extra_objs)
2957 AC_SUBST(extra_parts)
2958 AC_SUBST(extra_passes)
2959 AC_SUBST(extra_programs)
2960 AC_SUBST(float_h_file)
2961 AC_SUBST(gcc_config_arguments)
2962 AC_SUBST(gcc_gxx_include_dir)
2963 AC_SUBST(libstdcxx_incdir)
2964 AC_SUBST(gcc_version)
2965 AC_SUBST(gcc_version_full)
2966 AC_SUBST(gcc_version_trigger)
2967 AC_SUBST(host_exeext)
2968 AC_SUBST(host_extra_gcc_objs)
2969 AC_SUBST(host_xm_file_list)
2970 AC_SUBST(host_xm_include_list)
2971 AC_SUBST(host_xm_defines)
2972 AC_SUBST(out_host_hook_obj)
2973 AC_SUBST(install)
2974 AC_SUBST(lang_opt_files)
2975 AC_SUBST(lang_specs_files)
2976 AC_SUBST(lang_tree_files)
2977 AC_SUBST(local_prefix)
2978 AC_SUBST(md_file)
2979 AC_SUBST(objc_boehm_gc)
2980 AC_SUBST(out_file)
2981 AC_SUBST(out_object_file)
2982 AC_SUBST(stage_prefix_set_by_configure)
2983 AC_SUBST(quoted_stage_prefix_set_by_configure)
2984 AC_SUBST(symbolic_link)
2985 AC_SUBST(thread_file)
2986 AC_SUBST(tm_file_list)
2987 AC_SUBST(tm_include_list)
2988 AC_SUBST(tm_defines)
2989 AC_SUBST(tm_p_file_list)
2990 AC_SUBST(tm_p_include_list)
2991 AC_SUBST(xm_file_list)
2992 AC_SUBST(xm_include_list)
2993 AC_SUBST(xm_defines)
2994 AC_SUBST(target_noncanonical)
2995 AC_SUBST(c_target_objs)
2996 AC_SUBST(cxx_target_objs)
2997 AC_SUBST(target_cpu_default)
2998
2999 AC_SUBST_FILE(language_hooks)
3000
3001 # Echo link setup.
3002 if test x${build} = x${host} ; then
3003   if test x${host} = x${target} ; then
3004     echo "Links are now set up to build a native compiler for ${target}." 1>&2
3005   else
3006     echo "Links are now set up to build a cross-compiler" 1>&2
3007     echo " from ${host} to ${target}." 1>&2
3008   fi
3009 else
3010   if test x${host} = x${target} ; then
3011     echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
3012     echo " for ${target}." 1>&2
3013   else
3014     echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
3015     echo " from ${host} to ${target}." 1>&2
3016   fi
3017 fi
3018
3019 # Configure the subdirectories
3020 # AC_CONFIG_SUBDIRS($subdirs)
3021
3022 # Create the Makefile
3023 # and configure language subdirectories
3024 AC_OUTPUT($all_outputs,
3025 [
3026 case ${CONFIG_HEADERS} in
3027   *auto-host.h:config.in*)
3028   echo > cstamp-h ;;
3029 esac
3030 # Make sure all the subdirs exist.
3031 for d in $subdirs
3032 do
3033     test -d $d || mkdir $d
3034 done
3035 # If the host supports symlinks, point stage[1234] at ../stage[1234] so
3036 # bootstrapping and the installation procedure can still use
3037 # CC="stage1/xgcc -Bstage1/".  If the host doesn't support symlinks,
3038 # FLAGS_TO_PASS has been modified to solve the problem there.
3039 # This is virtually a duplicate of what happens in configure.lang; we do
3040 # an extra check to make sure this only happens if ln -s can be used.
3041 if test "$symbolic_link" = "ln -s"; then
3042  for d in ${subdirs} fixinc ; do
3043         STARTDIR=`${PWDCMD-pwd}`
3044         cd $d
3045         for t in stage1 stage2 stage3 stage4 stageprofile stagefeedback include
3046         do
3047                 rm -f $t
3048                 $symbolic_link ../$t $t 2>/dev/null
3049         done
3050         cd $STARTDIR
3051  done
3052 else true ; fi
3053 ],
3054 [subdirs='$subdirs'
3055 symbolic_link='$symbolic_link'
3056 ])