gcc/configure.in

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