gcc/configure.in

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