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