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