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