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 if test x$float_format = x
 802 then float_format=i64
 803 fi
 804
 805 if test $float_format = none
 806 then float_h_file=Makefile.in
 807 else float_h_file=float-$float_format.h
 808 fi
 809
 810 # Say what files are being used for the output code and MD file.
 811 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
 812 echo "Using \`$srcdir/config/$md_file' as machine description file."
 813
 814 # If any of the xm_file variables contain nonexistent files, warn
 815 # about them and drop them.
 816
 817 bx=
 818 for x in $build_xm_file; do
 819   if    test -f $srcdir/config/$x
 820   then      bx="$bx $x"
 821   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
 822   fi
 823 done
 824 build_xm_file="$bx"
 825
 826 hx=
 827 for x in $host_xm_file; do
 828   if    test -f $srcdir/config/$x
 829   then      hx="$hx $x"
 830   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
 831   fi
 832 done
 833 host_xm_file="$hx"
 834
 835 tx=
 836 for x in $xm_file; do
 837   if    test -f $srcdir/config/$x
 838   then      tx="$tx $x"
 839   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
 840   fi
 841 done
 842 xm_file="$tx"
 843
 844 count=a
 845 for f in $tm_file; do
 846         count=${count}x
 847 done
 848 if test $count = ax; then
 849         echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
 850 else
 851         echo "Using the following target machine macro files:"
 852         for f in $tm_file; do
 853                 echo "  $srcdir/config/$f"
 854         done
 855 fi
 856
 857 count=a
 858 for f in $host_xm_file; do
 859         count=${count}x
 860 done
 861 if test $count = a; then
 862         :
 863 elif test $count = ax; then
 864         echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
 865 else
 866         echo "Using the following host machine macro files:"
 867         for f in $host_xm_file; do
 868                 echo "  $srcdir/config/$f"
 869         done
 870 fi
 871
 872 if test "$host_xm_file" != "$build_xm_file"; then
 873         count=a
 874         for f in $build_xm_file; do
 875                 count=${count}x
 876         done
 877         if test $count = a; then
 878                 :
 879         elif test $count = ax; then
 880                 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
 881         else
 882                 echo "Using the following build machine macro files:"
 883                 for f in $build_xm_file; do
 884                         echo "  $srcdir/config/$f"
 885                 done
 886         fi
 887 fi
 888
 889 if test x$thread_file = x; then
 890         if test x$target_thread_file != x; then
 891                 thread_file=$target_thread_file
 892         else
 893                 thread_file='single'
 894         fi
 895 fi
 896
 897 # Look for a file containing extra machine modes.
 898 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
 899   extra_modes_file='$(srcdir)'/config/${extra_modes}
 900   AC_SUBST(extra_modes_file)
 901   AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "$extra_modes",
 902   [Define to the name of a file containing a list of extra machine modes
 903    for this architecture.])
 904   AC_DEFINE(EXTRA_CC_MODES, 1,
 905   [Define if the target architecture needs extra machine modes to represent
 906    the results of comparisons.])
 907 fi
 908
 909 # auto-host.h is the file containing items generated by autoconf and is
 910 # the first file included by config.h.
 911 # If host=build, it is correct to have hconfig include auto-host.h
 912 # as well.  If host!=build, we are in error and need to do more
 913 # work to find out the build config parameters.
 914 if test x$host = x$build
 915 then
 916         build_auto=auto-host.h
 917         FORBUILD=..
 918 else
 919         # We create a subdir, then run autoconf in the subdir.
 920         # To prevent recursion we set host and build for the new
 921         # invocation of configure to the build for this invocation
 922         # of configure.
 923         tempdir=build.$$
 924         rm -rf $tempdir
 925         mkdir $tempdir
 926         cd $tempdir
 927         case ${srcdir} in
 928         /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
 929         *) realsrcdir=../${srcdir};;
 930         esac
 931         saved_CFLAGS="${CFLAGS}"
 932         CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
 933         ${realsrcdir}/configure \
 934                 --target=$target_alias --host=$build_alias --build=$build_alias
 935         CFLAGS="${saved_CFLAGS}"
 936
 937         # We just finished tests for the build machine, so rename
 938         # the file auto-build.h in the gcc directory.
 939         mv auto-host.h ../auto-build.h
 940         cd ..
 941         rm -rf $tempdir
 942         build_auto=auto-build.h
 943         FORBUILD=../$build_alias
 944 fi
 945 AC_SUBST(FORBUILD)
 946
 947 tm_file="${tm_file} defaults.h"
 948 host_xm_file="auto-host.h ansidecl.h ${host_xm_file} ${tm_file}"
 949 build_xm_file="${build_auto} ansidecl.h ${build_xm_file} ${tm_file}"
 950 xm_file="ansidecl.h ${xm_file} ${tm_file}"
 951
 952 # Truncate the target if necessary
 953 if test x$host_truncate_target != x; then
 954         target=`echo $target | sed -e 's/\(..............\).*/\1/'`
 955 fi
 956
 957 # Get the version trigger filename from the toplevel
 958 if test "${with_gcc_version_trigger+set}" = set; then
 959         gcc_version_trigger=$with_gcc_version_trigger
 960 else
 961         gcc_version_trigger=${srcdir}/version.c
 962 fi
 963 changequote(,)dnl
 964 gcc_version_full=`grep version_string ${gcc_version_trigger} | sed -e 's/.*"\([^"]*\)".*/\1/'`
 965 gcc_version=`echo ${gcc_version_full} | sed -e 's/\([^ ]*\) .*/\1/'`
 966
 967 # Compile in configure arguments.
 968 if test -f configargs.h ; then
 969         # Being re-configured.
 970         gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
 971         gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
 972 else
 973         gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
 974 fi
 975 cat > configargs.h <<EOF
 976 /* Generated automatically. */
 977 static const char configuration_arguments[] = "$gcc_config_arguments";
 978 static const char thread_model[] = "$thread_file";
 979 EOF
 980 changequote([,])dnl
 981
 982 # Internationalization
 983 PACKAGE=gcc
 984 VERSION="$gcc_version"
 985 AC_SUBST(PACKAGE)
 986 AC_SUBST(VERSION)
 987
 988 # Enable NLS support by default
 989 AC_ARG_ENABLE(nls,
 990   [  --enable-nls            use Native Language Support (default)],
 991   , enable_nls=yes)
 992
 993 # if cross compiling, disable NLS support.
 994 # It's not worth the trouble, at least for now.
 995
 996 if test "${build}" != "${host}" && test "x$enable_nls" = "xyes"; then
 997   AC_MSG_WARN(Disabling NLS support for canadian cross compiler.)
 998   enable_nls=no
 999 fi
1000
1001 AM_GNU_GETTEXT
1002
1003 # Windows32 Registry support for specifying GCC installation paths.
1004 AC_ARG_ENABLE(win32-registry,
1005 [  --disable-win32-registry
1006                           disable lookup of installation paths in the
1007                           Registry on Windows hosts
1008   --enable-win32-registry enable registry lookup (default)
1009   --enable-win32-registry=KEY
1010                           use KEY instead of GCC version as the last portion
1011                           of the registry key],,)
1012 case $host_os in
1013         win32 | pe | cygwin* | mingw32* | uwin*)
1014 AC_MSG_CHECKING(whether windows registry support is requested)
1015 if test "x$enable_win32_registry" != xno; then
1016   AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1017 [Define to 1 if installation paths should be looked up in Windows32
1018    Registry. Ignored on non windows32 hosts.])
1019   AC_MSG_RESULT(yes)
1020   AC_SEARCH_LIBS(RegOpenKeyExA, advapi32)
1021 else
1022   AC_MSG_RESULT(no)
1023 fi
1024
1025 # Check if user specified a different registry key.
1026 case "x${enable_win32_registry}" in
1027 x | xyes)
1028   # default.
1029   gcc_cv_win32_registry_key="$VERSION"
1030   ;;
1031 xno)
1032   # no registry lookup.
1033   gcc_cv_win32_registry_key=''
1034   ;;
1035 *)
1036   # user-specified key.
1037   gcc_cv_win32_registry_key="$enable_win32_registry"
1038   ;;
1039 esac
1040
1041 if test "x$enable_win32_registry" != xno; then
1042   AC_MSG_CHECKING(registry key on windows hosts)
1043   AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$gcc_cv_win32_registry_key",
1044         [Define to be the last portion of registry key on windows hosts.])
1045   AC_MSG_RESULT($gcc_cv_win32_registry_key)
1046 fi
1047 ;;
1048 esac
1049
1050 # Get an absolute path to the GCC top-level source directory
1051 holddir=`${PWDCMD-pwd}`
1052 cd $srcdir
1053 topdir=`${PWDCMD-pwd}`
1054 cd $holddir
1055
1056 # Conditionalize the makefile for this host machine.
1057 # Make-host contains the concatenation of all host makefile fragments
1058 # [there can be more than one].  This file is built by configure.frag.
1059 host_overrides=Make-host
1060 dep_host_xmake_file=
1061 for f in .. ${host_xmake_file}
1062 do
1063         if test -f ${srcdir}/config/$f
1064         then
1065                 dep_host_xmake_file="${dep_host_xmake_file} ${srcdir}/config/$f"
1066         fi
1067 done
1068
1069 # Conditionalize the makefile for this target machine.
1070 # Make-target contains the concatenation of all host makefile fragments
1071 # [there can be more than one].  This file is built by configure.frag.
1072 target_overrides=Make-target
1073 dep_tmake_file=
1074 for f in .. ${tmake_file}
1075 do
1076         if test -f ${srcdir}/config/$f
1077         then
1078                 dep_tmake_file="${dep_tmake_file} ${srcdir}/config/$f"
1079         fi
1080 done
1081
1082 # If the host doesn't support symlinks, modify CC in
1083 # FLAGS_TO_PASS so CC="stage1/xgcc -Bstage1/" works.
1084 # Otherwise, we can use "CC=$(CC)".
1085 rm -f symtest.tem
1086 if $symbolic_link $srcdir/gcc.c symtest.tem 2>/dev/null
1087 then
1088         cc_set_by_configure="\$(CC)"
1089         quoted_cc_set_by_configure="\$(CC)"
1090         stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1091         quoted_stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1092 else
1093         rm -f symtest.tem
1094         if cp -p $srcdir/gcc.c symtest.tem 2>/dev/null
1095         then
1096                 symbolic_link="cp -p"
1097         else
1098                 symbolic_link="cp"
1099         fi
1100         cc_set_by_configure="\`case '\$(CC)' in stage*) echo '\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\$(CC)';; esac\`"
1101         quoted_cc_set_by_configure="\\\`case '\\\$(CC)' in stage*) echo '\\\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(CC)';; esac\\\`"
1102         stage_prefix_set_by_configure="\`case '\$(STAGE_PREFIX)' in stage*) echo '\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\$(STAGE_PREFIX)';; esac\`"
1103         quoted_stage_prefix_set_by_configure="\\\`case '\\\$(STAGE_PREFIX)' in stage*) echo '\\\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(STAGE_PREFIX)';; esac\\\`"
1104 fi
1105 rm -f symtest.tem
1106
1107 out_object_file=`basename $out_file .c`.o
1108
1109 tm_file_list=
1110 for f in $tm_file; do
1111   case $f in
1112     ansidecl.h )
1113        tm_file_list="${tm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
1114     defaults.h )
1115        tm_file_list="${tm_file_list} \$(srcdir)/$f" ;;
1116     *) tm_file_list="${tm_file_list} \$(srcdir)/config/$f" ;;
1117   esac
1118 done
1119
1120 tm_p_file_list=
1121 for f in $tm_p_file; do
1122     tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1123 done
1124
1125 host_xm_file_list=
1126 for f in $host_xm_file; do
1127   case $f in
1128     ansidecl.h )
1129        host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
1130     auto-host.h )
1131        host_xm_file_list="${host_xm_file_list} $f" ;;
1132     defaults.h )
1133        host_xm_file_list="${host_xm_file_list} \$(srcdir)/$f" ;;
1134     *) host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f" ;;
1135   esac
1136 done
1137
1138 build_xm_file_list=
1139 for f in $build_xm_file; do
1140   case $f in
1141     ansidecl.h )
1142        build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
1143     auto-build.h | auto-host.h )
1144        build_xm_file_list="${build_xm_file_list} $f" ;;
1145     defaults.h )
1146        host_xm_file_list="${host_xm_file_list} \$(srcdir)/$f" ;;
1147     *) build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f" ;;
1148   esac
1149 done
1150
1151 # Define macro CROSS_COMPILE in compilation if this is a cross-compiler.
1152 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1153 CROSS=                                          AC_SUBST(CROSS)
1154 ALL=all.internal                                AC_SUBST(ALL)
1155 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1156 if test x$host != x$target
1157 then
1158         CROSS="-DCROSS_COMPILE"
1159         ALL=all.cross
1160         SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1161         case "$host","$target" in
1162             i?86-*-*,x86_64-*-* \
1163             | powerpc*-*-*,powerpc64*-*-*)
1164                 CROSS="$CROSS -DNATIVE_CROSS" ;;
1165         esac
1166 fi
1167
1168 # If this is a cross-compiler that does not
1169 # have its own set of headers then define
1170 # inhibit_libc
1171
1172 # If this is using newlib, then define inhibit_libc in LIBGCC2_CFLAGS.
1173 # This prevents libgcc2 from containing any code which requires libc
1174 # support.
1175 inhibit_libc=
1176 if [test x$host != x$target] && [test x$with_headers = x]; then
1177        inhibit_libc=-Dinhibit_libc
1178 else
1179        if [test x$with_newlib = xyes]; then
1180                inhibit_libc=-Dinhibit_libc
1181        fi
1182 fi
1183 AC_SUBST(inhibit_libc)
1184
1185 # When building gcc with a cross-compiler, we need to adjust things so
1186 # that the generator programs are still built with the native compiler.
1187 # Also, we cannot run fixincludes or fix-header.
1188 # Note that the terminology here is wrong; it should be BUILD_* throughout.
1189 # FIXME.
1190
1191 # These are the normal (build=host) settings:
1192 BUILD_PREFIX=                   AC_SUBST(BUILD_PREFIX)
1193 BUILD_PREFIX_1=ignore-          AC_SUBST(BUILD_PREFIX_1)
1194 HOST_CC='$(CC)'                 AC_SUBST(HOST_CC)
1195 HOST_CFLAGS='$(ALL_CFLAGS)'     AC_SUBST(HOST_CFLAGS)
1196
1197 STMP_FIXINC=stmp-fixinc         AC_SUBST(STMP_FIXINC)
1198 STMP_FIXPROTO=stmp-fixproto     AC_SUBST(STMP_FIXPROTO)
1199
1200 # And these apply if build != host.
1201 if test x$build != x$host
1202 then
1203     BUILD_PREFIX=build-
1204     BUILD_PREFIX_1=build-
1205     HOST_CC='$(CC_FOR_BUILD)'
1206     HOST_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD) $(XCFLAGS)'
1207
1208     STMP_FIXINC=
1209     STMP_FIXPROTO=
1210 fi
1211
1212 # Expand extra_headers to include complete path.
1213 # This substitutes for lots of t-* files.
1214 extra_headers_list=
1215 if test "x$extra_headers" = x
1216 then true
1217 else
1218         # Prepend ${srcdir}/config/${cpu_type}/ to every entry in extra_headers.
1219         for file in $extra_headers;
1220         do
1221                 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1222         done
1223 fi
1224
1225 if test x$use_collect2 = xno; then
1226         use_collect2=
1227 fi
1228
1229 # Add a definition of USE_COLLECT2 if system wants one.
1230 if test x$use_collect2 != x
1231 then
1232         host_xm_defines="${host_xm_defines} USE_COLLECT2"
1233         xm_defines="${xm_defines} USE_COLLECT2"
1234 fi
1235
1236 # If we have gas in the build tree, make a link to it.
1237 if test -f ../gas/Makefile; then
1238         rm -f as; $symbolic_link ../gas/as-new$host_exeext as$host_exeext 2>/dev/null
1239 fi
1240
1241 # If we have nm and objdump in the build tree, make a link to them.
1242 if test -f ../binutils/Makefile; then
1243         rm -f nm; $symbolic_link ../binutils/nm-new$host_exeext nm$host_exeext 2>/dev/null
1244         rm -f objdump; $symbolic_link ../binutils/objdump$host_exeext objdump$host_exeext 2>/dev/null
1245 fi
1246
1247 # If we have ld in the build tree, make a link to it.
1248 if test -f ../ld/Makefile; then
1249         rm -f collect-ld; $symbolic_link ../ld/ld-new$host_exeext collect-ld$host_exeext 2>/dev/null
1250 fi
1251
1252 # Figure out what assembler we will be using.
1253 AC_MSG_CHECKING(what assembler to use)
1254 gcc_cv_as=
1255 gcc_cv_gas_major_version=
1256 gcc_cv_gas_minor_version=
1257 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1258 gcc_cv_as_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1259 if test -x "$DEFAULT_ASSEMBLER"; then
1260         gcc_cv_as="$DEFAULT_ASSEMBLER"
1261 elif test -x "$AS"; then
1262         gcc_cv_as="$AS"
1263 elif test -x as$host_exeext; then
1264         # Build using assembler in the current directory.
1265         gcc_cv_as=./as$host_exeext
1266 elif test -f $gcc_cv_as_gas_srcdir/configure.in -a -f ../gas/Makefile; then
1267         # Single tree build which includes gas.
1268         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
1269         do
1270 changequote(,)dnl
1271                 gcc_cv_gas_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
1272 changequote([,])dnl
1273                 if test x$gcc_cv_gas_version != x; then
1274                         break
1275                 fi
1276         done
1277 changequote(,)dnl
1278         gcc_cv_gas_major_version=`expr "$gcc_cv_gas_version" : "VERSION=\([0-9]*\)"`
1279         gcc_cv_gas_minor_version=`expr "$gcc_cv_gas_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1280         gcc_cv_gas_patch_version=`expr "$gcc_cv_gas_version" : "VERSION=[0-9]*\.[0-9]*\.\([0-9]*\)"`
1281 changequote([,])dnl
1282 fi
1283
1284 if test "x$gcc_cv_as" = x; then
1285         # Search the same directories that the installed compiler will
1286         # search.  Else we may find the wrong assembler and lose.  If we
1287         # do not find a suitable assembler binary, then try the user's
1288         # path.
1289         #
1290         # Also note we have to check MD_EXEC_PREFIX before checking the
1291         # user's path.  Unfortunately, there is no good way to get at the
1292         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1293         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1294         # to be fixed as part of the make/configure rewrite too.
1295
1296         if test "x$exec_prefix" = xNONE; then
1297                 if test "x$prefix" = xNONE; then
1298                         test_prefix=/usr/local
1299                 else
1300                         test_prefix=$prefix
1301                 fi
1302         else
1303                 test_prefix=$exec_prefix
1304         fi
1305
1306         # If the loop below does not find an assembler, then use whatever
1307         # one we can find in the users's path.
1308         # user's path.
1309         if test "x$program_prefix" != xNONE; then
1310                 gcc_cv_as=${program_prefix}as$host_exeext
1311         else
1312                 gcc_cv_as=`echo as | sed ${program_transform_name}`$host_exeext
1313         fi
1314
1315         test_dirs="$test_prefix/lib/gcc-lib/$target_alias/$gcc_version \
1316                    $test_prefix/lib/gcc-lib/$target_alias \
1317                    /usr/lib/gcc/$target_alias/$gcc_version \
1318                    /usr/lib/gcc/$target_alias \
1319                    $test_prefix/$target_alias/bin/$target_alias/$gcc_version \
1320                    $test_prefix/$target_alias/bin"
1321
1322         if test x$host = x$target; then
1323             test_dirs="$test_dirs \
1324                    /usr/libexec \
1325                    /usr/ccs/gcc \
1326                    /usr/ccs/bin \
1327                    /udk/usr/ccs/bin \
1328                    /bsd43/usr/lib/cmplrs/cc \
1329                    /usr/cross64/usr/bin \
1330                    /usr/lib/cmplrs/cc \
1331                    /sysv/usr/lib/cmplrs/cc \
1332                    /svr4/usr/lib/cmplrs/cc \
1333                    /usr/bin"
1334         fi
1335
1336         for dir in $test_dirs; do
1337                 if test -x $dir/as$host_exeext; then
1338                         gcc_cv_as=$dir/as$host_exeext
1339                         break;
1340                 fi
1341         done
1342 fi
1343 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1344   AC_MSG_RESULT("newly built gas")
1345 else
1346   AC_MSG_RESULT($gcc_cv_as)
1347 fi
1348
1349 # Figure out what linker we will be using.
1350 AC_MSG_CHECKING(what linker to use)
1351 gcc_cv_ld=
1352 gcc_cv_gld_major_version=
1353 gcc_cv_gld_minor_version=
1354 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1355 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1356 if test -x "$DEFAULT_LINKER"; then
1357         gcc_cv_ld="$DEFAULT_LINKER"
1358 elif test -x "$LD"; then
1359         gcc_cv_ld="$LD"
1360 elif test -x ld$host_exeext; then
1361         # Build using linker in the current directory.
1362         gcc_cv_ld=./ld$host_exeext
1363 elif test -f $gcc_cv_ld_gld_srcdir/configure.in -a -f ../ld/Makefile; then
1364         # Single tree build which includes ld.
1365         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
1366         do
1367 changequote(,)dnl
1368                 gcc_cv_gld_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
1369 changequote([,])dnl
1370                 if test x$gcc_cv_gld_version != x; then
1371                         break
1372                 fi
1373         done
1374 changequote(,)dnl
1375         gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
1376         gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1377 changequote([,])dnl
1378 fi
1379
1380 if test "x$gcc_cv_ld" = x; then
1381         # Search the same directories that the installed compiler will
1382         # search.  Else we may find the wrong linker and lose.  If we
1383         # do not find a suitable linker binary, then try the user's
1384         # path.
1385         #
1386         # Also note we have to check MD_EXEC_PREFIX before checking the
1387         # user's path.  Unfortunately, there is no good way to get at the
1388         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1389         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1390         # to be fixed as part of the make/configure rewrite too.
1391
1392         if test "x$exec_prefix" = xNONE; then
1393                 if test "x$prefix" = xNONE; then
1394                         test_prefix=/usr/local
1395                 else
1396                         test_prefix=$prefix
1397                 fi
1398         else
1399                 test_prefix=$exec_prefix
1400         fi
1401
1402         # If the loop below does not find an linker, then use whatever
1403         # one we can find in the users's path.
1404         # user's path.
1405         if test "x$program_prefix" != xNONE; then
1406                 gcc_cv_ld=${program_prefix}ld$host_exeext
1407         else
1408                 gcc_cv_ld=`echo ld | sed ${program_transform_name}`$host_exeext
1409         fi
1410
1411         test_dirs="$test_prefix/lib/gcc-lib/$target_alias/$gcc_version \
1412                    $test_prefix/lib/gcc-lib/$target_alias \
1413                    /usr/lib/gcc/$target_alias/$gcc_version \
1414                    /usr/lib/gcc/$target_alias \
1415                    $test_prefix/$target_alias/bin/$target_alias/$gcc_version \
1416                    $test_prefix/$target_alias/bin"
1417
1418         if test x$host = x$target; then
1419             test_dirs="$test_dirs \
1420                    /usr/libexec \
1421                    /usr/ccs/gcc \
1422                    /usr/ccs/bin \
1423                    /udk/usr/ccs/bin \
1424                    /bsd43/usr/lib/cmplrs/cc \
1425                    /usr/cross64/usr/bin \
1426                    /usr/lib/cmplrs/cc \
1427                    /sysv/usr/lib/cmplrs/cc \
1428                    /svr4/usr/lib/cmplrs/cc \
1429                    /usr/bin"
1430         fi
1431
1432         for dir in $test_dirs; do
1433                 if test -x $dir/ld$host_exeext; then
1434                         gcc_cv_ld=$dir/ld$host_exeext
1435                         break;
1436                 fi
1437         done
1438 fi
1439 if test x$gcc_cv_gld_major_version != x -a x$gcc_cv_gld_minor_version != x; then
1440   AC_MSG_RESULT("newly built ld")
1441 else
1442   AC_MSG_RESULT($gcc_cv_ld)
1443 fi
1444
1445 # Figure out what nm we will be using.
1446 AC_MSG_CHECKING(what nm to use)
1447 if test -x nm$host_exeext; then
1448         gcc_cv_nm=./nm$host_exeext
1449 elif test "x$program_prefix" != xNONE; then
1450         gcc_cv_nm=${program_prefix}nm$host_exeext
1451 else
1452         gcc_cv_nm=`echo nm | sed ${program_transform_name}`$host_exeext
1453 fi
1454 AC_MSG_RESULT($gcc_cv_nm)
1455
1456 # Figure out what objdump we will be using.
1457 AC_MSG_CHECKING(what objdump to use)
1458 if test -x objdump$host_exeext; then
1459         gcc_cv_objdump=./objdump$host_exeext
1460 elif test "x$program_prefix" != xNONE; then
1461         gcc_cv_objdump=${program_prefix}objdump$host_exeext
1462 else
1463         gcc_cv_objdump=`echo objdump | sed ${program_transform_name}`$host_exeext
1464 fi
1465 AC_MSG_RESULT($gcc_cv_objdump)
1466
1467 # Figure out what assembler alignment features are present.
1468 AC_MSG_CHECKING(assembler alignment features)
1469 gcc_cv_as_alignment_features=none
1470 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1471         # Gas version 2.6 and later support for .balign and .p2align.
1472         # bytes to skip when using .p2align.
1473         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
1474                 gcc_cv_as_alignment_features=".balign and .p2align"
1475                 AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN)
1476         fi
1477         # Gas version 2.8 and later support specifying the maximum
1478         # bytes to skip when using .p2align.
1479         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
1480                 gcc_cv_as_alignment_features=".p2align including maximum skip"
1481                 AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN)
1482         fi
1483 elif test x$gcc_cv_as != x; then
1484         # Check if we have .balign and .p2align
1485         echo ".balign  4" > conftest.s
1486         echo ".p2align  2" >> conftest.s
1487         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1488                 gcc_cv_as_alignment_features=".balign and .p2align"
1489                 AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN)
1490         fi
1491         rm -f conftest.s conftest.o
1492         # Check if specifying the maximum bytes to skip when
1493         # using .p2align is supported.
1494         echo ".p2align 4,,7" > conftest.s
1495         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1496                 gcc_cv_as_alignment_features=".p2align including maximum skip"
1497                 AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN)
1498         fi
1499         rm -f conftest.s conftest.o
1500 fi
1501 AC_MSG_RESULT($gcc_cv_as_alignment_features)
1502
1503 AC_MSG_CHECKING(assembler subsection support)
1504 gcc_cv_as_subsections=no
1505 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1506   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
1507     gcc_cv_as_subsections="working .subsection -1"
1508   fi
1509 elif test x$gcc_cv_as != x; then
1510         # Check if we have .subsection
1511         echo ".subsection 1" > conftest.s
1512         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1513                 gcc_cv_as_subsections=".subsection"
1514                 if test x$gcc_cv_nm != x; then
1515                         cat > conftest.s <<EOF
1516 conftest_label1: .word 0
1517 .subsection -1
1518 conftest_label2: .word 0
1519 .previous
1520 EOF
1521                         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1522                                 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
1523                                 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
1524                                 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1; then
1525                                         :
1526                                 else
1527                                         gcc_cv_as_subsections="working .subsection -1"
1528                                 fi
1529                         fi
1530                 fi
1531         fi
1532         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1533 fi
1534 if test x"$gcc_cv_as_subsections" = x"working .subsection -1"; then
1535         AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
1536 [Define if your assembler supports .subsection and .subsection -1 starts
1537    emitting at the beginning of your section.])
1538 fi
1539 AC_MSG_RESULT($gcc_cv_as_subsections)
1540
1541 AC_MSG_CHECKING(assembler weak support)
1542 gcc_cv_as_weak=no
1543 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1544   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
1545     gcc_cv_as_weak="yes"
1546   fi
1547 elif test x$gcc_cv_as != x; then
1548         # Check if we have .weak
1549         echo "  .weak foobar" > conftest.s
1550         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1551                 gcc_cv_as_weak="yes"
1552         fi
1553         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1554 fi
1555 if test x"$gcc_cv_as_weak" = xyes; then
1556         AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])
1557 fi
1558 AC_MSG_RESULT($gcc_cv_as_weak)
1559
1560 AC_MSG_CHECKING(assembler hidden support)
1561 gcc_cv_as_hidden=no
1562 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1563   if test "$gcc_cv_gas_major_version" -eq 2     \
1564           -a "$gcc_cv_gas_minor_version" -eq 12 \
1565           -a "$gcc_cv_gas_patch_version" -ge 1  \
1566           -o "$gcc_cv_gas_major_version" -eq 2  \
1567           -a "$gcc_cv_gas_minor_version" -gt 12 \
1568           -o "$gcc_cv_gas_major_version" -gt 2  \
1569     && grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
1570     gcc_cv_as_hidden="yes"
1571   fi
1572 elif test x$gcc_cv_as != x; then
1573         # Check if we have .hidden
1574         echo "  .hidden foobar" > conftest.s
1575         echo "foobar:" >> conftest.s
1576         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1577                 gcc_cv_as_hidden="yes"
1578         fi
1579         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1580
1581         # GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
1582         # This is irritatingly difficult to feature test for.  Look for
1583         # the date string after the version number.
1584         ld_ver=`$gcc_cv_ld --version 2>/dev/null | head -1`
1585         if echo "$ld_ver" | grep GNU > /dev/null; then
1586 changequote(,)dnl
1587                 ld_vers=`echo $ld_ver | sed -n 's,^.*[  ]\([0-9][0-9]*\.[0-9][0-9]*\(\|\.[0-9][0-9]*\)\)\([     ].*\|\)$,\1,p'`
1588                 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'`
1589                 if test 0"$ld_date" -lt 20020404; then
1590                         if test -n "$ld_date"; then
1591                                 # If there was date string, but was earlier than 2002-04-04, fail
1592                                 gcc_cv_as_hidden="no"
1593                         elif test -z "$ld_vers"; then
1594                                 # If there was no date string nor ld version number, something is wrong
1595                                 gcc_cv_as_hidden="no"
1596                         else
1597                                 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
1598                                 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
1599                                 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
1600                                 test -z "$ld_vers_patch" && ld_vers_patch=0
1601                                 if test "$ld_vers_major" -lt 2; then
1602                                         gcc_cv_as_hidden="no"
1603                                 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
1604                                         gcc_cv_as_hidden="no"
1605                                 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 \
1606                                           -a "$ld_vers_patch" -eq 0; then
1607                                         gcc_cv_as_hidden="no"
1608                                 fi
1609                         fi
1610                 fi
1611 changequote([,])dnl
1612         fi
1613 fi
1614 if test x"$gcc_cv_as_hidden" = xyes; then
1615         AC_DEFINE(HAVE_GAS_HIDDEN, 1,
1616                 [Define if your assembler supports .hidden.])
1617 fi
1618 AC_MSG_RESULT($gcc_cv_as_hidden)
1619 libgcc_visibility=$gcc_cv_as_hidden
1620 case "$target" in
1621   mips-sgi-irix6*o32)
1622     if test x"$gnu_ld_flag" = x"no"; then
1623       # Even if using gas with .hidden support, the resulting object files
1624       # cannot be linked with the IRIX 6 O32 linker.
1625       libgcc_visibility=no
1626     fi
1627     ;;
1628 esac
1629 AC_SUBST(libgcc_visibility)
1630
1631 AC_MSG_CHECKING(assembler leb128 support)
1632 gcc_cv_as_leb128=no
1633 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1634   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
1635     gcc_cv_as_leb128="yes"
1636   fi
1637 elif test x$gcc_cv_as != x; then
1638         # Check if we have .[us]leb128, and support symbol arithmetic with it.
1639         cat > conftest.s <<EOF
1640         .data
1641         .uleb128 L2 - L1
1642 L1:
1643         .uleb128 1280
1644         .sleb128 -1010
1645 L2:
1646 EOF
1647         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1648                 gcc_cv_as_leb128="yes"
1649
1650                 # GAS versions before 2.11 do not support uleb128,
1651                 # despite appearing to.
1652                 # ??? There exists an elf-specific test that will crash
1653                 # the assembler.  Perhaps it's better to figure out whether
1654                 # arbitrary sections are supported and try the test.
1655                 as_ver=`$gcc_cv_as --version 2>/dev/null | head -1`
1656                 if echo "$as_ver" | grep GNU > /dev/null; then
1657 changequote(,)dnl
1658                         as_ver=`echo $as_ver | sed -e 's/GNU assembler \([0-9.][0-9.]*\).*/\1/'`
1659                         as_major=`echo $as_ver | sed 's/\..*//'`
1660                         as_minor=`echo $as_ver | sed 's/[^.]*\.\([0-9]*\).*/\1/'`
1661 changequote([,])dnl
1662                         if test $as_major -eq 2 -a $as_minor -lt 11; then
1663                                 gcc_cv_as_leb128="no"
1664                         fi
1665                 fi
1666         fi
1667         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1668 fi
1669 if test x"$gcc_cv_as_leb128" = xyes; then
1670         AC_DEFINE(HAVE_AS_LEB128, 1,
1671                 [Define if your assembler supports .uleb128.])
1672 fi
1673 AC_MSG_RESULT($gcc_cv_as_leb128)
1674
1675 AC_MSG_CHECKING(assembler eh_frame optimization)
1676 gcc_cv_as_eh_frame=no
1677 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1678   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
1679     gcc_cv_as_eh_frame="yes"
1680   fi
1681 elif test x$gcc_cv_as != x; then
1682         # Check if this is GAS.
1683         as_ver=`$gcc_cv_as --version < /dev/null 2> /dev/null | head -1`
1684         rm -f a.out 2> /dev/null
1685         if echo "$as_ver" | grep GNU > /dev/null; then
1686                 # Versions up to and including 2.11.0 may mis-optimize
1687                 # .eh_frame data.  Try something.
1688                 cat > conftest.s <<EOF
1689         .text
1690 .LFB1:
1691         .4byte  0
1692 .L1:
1693         .4byte  0
1694 .LFE1:
1695         .section        .eh_frame,"aw",@progbits
1696 __FRAME_BEGIN__:
1697         .4byte  .LECIE1-.LSCIE1
1698 .LSCIE1:
1699         .4byte  0x0
1700         .byte   0x1
1701         .ascii "z\0"
1702         .byte   0x1
1703         .byte   0x78
1704         .byte   0x1a
1705         .byte   0x0
1706         .byte   0x4
1707         .4byte  1
1708         .p2align 1
1709 .LECIE1:
1710 .LSFDE1:
1711         .4byte  .LEFDE1-.LASFDE1
1712 .LASFDE1:
1713         .4byte  .LASFDE1-__FRAME_BEGIN__
1714         .4byte  .LFB1
1715         .4byte  .LFE1-.LFB1
1716         .byte   0x4
1717         .4byte  .LFE1-.LFB1
1718         .byte   0x4
1719         .4byte  .L1-.LFB1
1720 .LEFDE1:
1721 EOF
1722                 cat > conftest.lit <<EOF
1723  0000 10000000 00000000 017a0001 781a0004  .........z..x...
1724  0010 01000000 12000000 18000000 00000000  ................
1725  0020 08000000 04080000 0044               .........D
1726 EOF
1727                 cat > conftest.big <<EOF
1728  0000 00000010 00000000 017a0001 781a0004  .........z..x...
1729  0010 00000001 00000012 00000018 00000000  ................
1730  0020 00000008 04000000 0844               .........D
1731 EOF
1732                 # If the assembler didn't choke, and we can objdump,
1733                 # and we got the correct data, then succeed.
1734                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
1735                    && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
1736                       | tail -3 > conftest.got \
1737                    && { cmp conftest.lit conftest.got > /dev/null 2>&1 \
1738                         || cmp conftest.big conftest.got > /dev/null 2>&1; }
1739                 then
1740                         gcc_cv_as_eh_frame="yes"
1741                 else
1742                         gcc_cv_as_eh_frame="bad"
1743                         if $gcc_cv_as -o conftest.o --traditional-format /dev/null; then
1744                                 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
1745         [Define if your assembler mis-optimizes .eh_frame data.])
1746                         fi
1747                 fi
1748         fi
1749         rm -f conftest.*
1750 fi
1751 AC_MSG_RESULT($gcc_cv_as_eh_frame)
1752
1753 AC_MSG_CHECKING(assembler section merging support)
1754 gcc_cv_as_shf_merge=no
1755 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1756   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
1757     gcc_cv_as_shf_merge=yes
1758   fi
1759 elif test x$gcc_cv_as != x; then
1760         # Check if we support SHF_MERGE sections
1761         echo '.section .rodata.str, "aMS", @progbits, 1' > conftest.s
1762         if $gcc_cv_as --fatal-warnings -o conftest.o conftest.s > /dev/null 2>&1; then
1763                 gcc_cv_as_shf_merge=yes
1764         fi
1765         rm -f conftest.s conftest.o
1766 fi
1767 if test x"$gcc_cv_as_shf_merge" = xyes; then
1768         AC_DEFINE(HAVE_GAS_SHF_MERGE, 1,
1769 [Define if your assembler supports marking sections with SHF_MERGE flag.])
1770 fi
1771 AC_MSG_RESULT($gcc_cv_as_shf_merge)
1772
1773 AC_MSG_CHECKING(assembler thread-local storage support)
1774 gcc_cv_as_tls=no
1775 conftest_s=
1776 tls_first_major=
1777 tls_first_minor=
1778 case "$target" in
1779 changequote(,)dnl
1780   alpha*-*-*)
1781     conftest_s='
1782         .section ".tdata","awT",@progbits
1783 foo:    .long   25
1784         .text
1785         ldq     $27,__tls_get_addr($29)         !literal!1
1786         lda     $16,foo($29)                    !tlsgd!1
1787         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
1788         ldq     $27,__tls_get_addr($29)         !literal!2
1789         lda     $16,foo($29)                    !tlsldm!2
1790         jsr     $26,($27),__tls_get_addr        !lituse_tlsldm!2
1791         ldq     $1,foo($29)                     !gotdtprel
1792         ldah    $2,foo($29)                     !dtprelhi
1793         lda     $3,foo($2)                      !dtprello
1794         lda     $4,foo($29)                     !dtprel
1795         ldq     $1,foo($29)                     !gottprel
1796         ldah    $2,foo($29)                     !tprelhi
1797         lda     $3,foo($2)                      !tprello
1798         lda     $4,foo($29)                     !tprel'
1799         tls_first_major=2
1800         tls_first_minor=13
1801         ;;
1802   i[34567]86-*-*)
1803 changequote([,])dnl
1804     conftest_s='
1805         .section ".tdata","awT",@progbits
1806 foo:    .long   25
1807         .text
1808         movl    %gs:0, %eax
1809         leal    foo@TLSGD(,%ebx,1), %eax
1810         leal    foo@TLSLDM(%ebx), %eax
1811         leal    foo@DTPOFF(%eax), %edx
1812         movl    foo@GOTTPOFF(%ebx), %eax
1813         subl    foo@GOTTPOFF(%ebx), %eax
1814         movl    $foo@TPOFF, %eax
1815         subl    $foo@TPOFF, %eax
1816         leal    foo@NTPOFF(%ecx), %eax'
1817         tls_first_major=2
1818         tls_first_minor=13
1819         ;;
1820   ia64-*-*)
1821     conftest_s='
1822         .section ".tdata","awT",@progbits
1823 foo:    data8   25
1824         .text
1825         addl    r16 = @ltoff(@dtpmod(foo#)), gp
1826         addl    r17 = @ltoff(@dtprel(foo#)), gp
1827         addl    r18 = @ltoff(@tprel(foo#)), gp
1828         addl    r19 = @dtprel(foo#), gp
1829         adds    r21 = @dtprel(foo#), r13
1830         movl    r23 = @dtprel(foo#)
1831         addl    r20 = @tprel(foo#), gp
1832         adds    r22 = @tprel(foo#), r13
1833         movl    r24 = @tprel(foo#)'
1834         tls_first_major=2
1835         tls_first_minor=13
1836         ;;
1837 esac
1838 if test -z "$tls_first_major"; then
1839   :
1840 elif test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x
1841 then
1842   if test "$gcc_cv_gas_major_version" -eq "$tls_first_major" \
1843           -a "$gcc_cv_gas_minor_version" -ge "$tls_first_minor" \
1844           -o "$gcc_cv_gas_major_version" -gt "$tls_first_major"; then
1845     gcc_cv_as_tls=yes
1846   fi
1847 elif test x$gcc_cv_as != x; then
1848   echo "$conftest_s" > conftest.s
1849   if $gcc_cv_as --fatal-warnings -o conftest.o conftest.s > /dev/null 2>&1
1850   then
1851     gcc_cv_as_tls=yes
1852   fi
1853   rm -f conftest.s conftest.o
1854 fi
1855 if test "$gcc_cv_as_tls" = yes; then
1856   AC_DEFINE(HAVE_AS_TLS, 1,
1857             [Define if your assembler supports thread-local storage.])
1858 fi
1859 AC_MSG_RESULT($gcc_cv_as_tls)
1860
1861 case "$target" in
1862   # All TARGET_ABI_OSF targets.
1863   alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
1864     AC_CACHE_CHECK([assembler supports explicit relocations],
1865         gcc_cv_as_explicit_relocs, [
1866         gcc_cv_as_explicit_relocs=unknown
1867         if test x$gcc_cv_gas_major_version != x \
1868                 -a x$gcc_cv_gas_minor_version != x
1869         then
1870            if test "$gcc_cv_gas_major_version" -eq 2 \
1871                    -a "$gcc_cv_gas_minor_version" -ge 12 \
1872                    -o "$gcc_cv_gas_major_version" -gt 2; then
1873               gcc_cv_as_explicit_relocs=yes
1874            fi
1875         elif test x$gcc_cv_as != x; then
1876             cat > conftest.s << 'EOF'
1877         .set nomacro
1878         .text
1879         extbl   $3, $2, $3      !lituse_bytoff!1
1880         ldq     $2, a($29)      !literal!1
1881         ldq     $4, b($29)      !literal!2
1882         ldq_u   $3, 0($2)       !lituse_base!1
1883         ldq     $27, f($29)     !literal!5
1884         jsr     $26, ($27), f   !lituse_jsr!5
1885         ldah    $29, 0($26)     !gpdisp!3
1886         lda     $0, c($29)      !gprel
1887         ldah    $1, d($29)      !gprelhigh
1888         lda     $1, d($1)       !gprellow
1889         lda     $29, 0($29)     !gpdisp!3
1890 EOF
1891             if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1892                 gcc_cv_as_explicit_relocs=yes
1893             else
1894                 gcc_cv_as_explicit_relocs=no
1895             fi
1896             rm -f conftest.s conftest.o
1897         fi
1898     ])
1899     if test "x$gcc_cv_as_explicit_relocs" = xyes; then
1900         AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
1901                 [Define if your assembler supports explicit relocations.])
1902     fi
1903     ;;
1904   sparc*-*-*)
1905     AC_CACHE_CHECK([assembler .register pseudo-op support],
1906         gcc_cv_as_register_pseudo_op, [
1907         gcc_cv_as_register_pseudo_op=unknown
1908         if test x$gcc_cv_as != x; then
1909             # Check if we have .register
1910             echo ".register %g2, #scratch" > conftest.s
1911             if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1912                 gcc_cv_as_register_pseudo_op=yes
1913             else
1914                 gcc_cv_as_register_pseudo_op=no
1915             fi
1916             rm -f conftest.s conftest.o
1917         fi
1918     ])
1919     if test "x$gcc_cv_as_register_pseudo_op" = xyes; then
1920         AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
1921                 [Define if your assembler supports .register.])
1922     fi
1923
1924     AC_CACHE_CHECK([assembler supports -relax],
1925         gcc_cv_as_relax_opt, [
1926         gcc_cv_as_relax_opt=unknown
1927         if test x$gcc_cv_as != x; then
1928             # Check if gas supports -relax
1929             echo ".text" > conftest.s
1930             if $gcc_cv_as -relax -o conftest.o conftest.s > /dev/null 2>&1; then
1931                 gcc_cv_as_relax_opt=yes
1932             else
1933                 gcc_cv_as_relax_opt=no
1934             fi
1935             rm -f conftest.s conftest.o
1936         fi
1937     ])
1938     if test "x$gcc_cv_as_relax_opt" = xyes; then
1939         AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
1940                 [Define if your assembler supports -relax option.])
1941     fi
1942
1943     AC_CACHE_CHECK([assembler and linker support unaligned pc related relocs],
1944         gcc_cv_as_sparc_ua_pcrel, [
1945         gcc_cv_as_sparc_ua_pcrel=unknown
1946         if test x$gcc_cv_as != x -a x$gcc_cv_ld != x; then
1947             gcc_cv_as_sparc_ua_pcrel=no
1948             echo ".text; foo: nop; .data; .align 4; .byte 0; .uaword %r_disp32(foo)" > conftest.s
1949             if $gcc_cv_as -K PIC -o conftest.o conftest.s > /dev/null 2>&1 \
1950                && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
1951                 gcc_cv_as_sparc_ua_pcrel=yes
1952             fi
1953             rm -f conftest.s conftest.o conftest
1954         fi
1955     ])
1956     if test "x$gcc_cv_as_sparc_ua_pcrel" = xyes; then
1957         AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
1958                 [Define if your assembler and linker support unaligned PC relative relocs.])
1959     fi
1960
1961     AC_CACHE_CHECK([assembler and linker support unaligned pc related relocs against hidden symbols],
1962         gcc_cv_as_sparc_ua_pcrel_hidden, [
1963         if test "x$gcc_cv_as_sparc_ua_pcrel" = xyes; then
1964             gcc_cv_as_sparc_ua_pcrel_hidden=unknown
1965             if test x$gcc_cv_objdump != x; then
1966                 gcc_cv_as_sparc_ua_pcrel_hidden=no
1967                 echo ".data; .align 4; .byte 0x31; .uaword %r_disp32(foo)" > conftest.s
1968                 echo ".byte 0x32, 0x33, 0x34; .global foo; .hidden foo" >> conftest.s
1969                 echo "foo: .skip 4" >> conftest.s
1970                 if $gcc_cv_as -K PIC -o conftest.o conftest.s > /dev/null 2>&1 \
1971                    && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
1972                    && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
1973                       | grep ' 31000000 07323334' > /dev/null 2>&1; then
1974                     if $gcc_cv_objdump -R conftest 2> /dev/null \
1975                        | grep 'DISP32' > /dev/null 2>&1; then
1976                         :
1977                     else
1978                         gcc_cv_as_sparc_ua_pcrel_hidden=yes
1979                     fi
1980                 fi
1981             fi
1982             rm -f conftest.s conftest.o conftest
1983         else
1984             gcc_cv_as_sparc_ua_pcrel_hidden="$gcc_cv_as_sparc_ua_pcrel"
1985         fi
1986     ])
1987     if test "x$gcc_cv_as_sparc_ua_pcrel_hidden" = xyes; then
1988         AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
1989                 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])
1990     fi
1991
1992     if test "x$gcc_cv_as_flags64" != xno; then
1993         AC_CACHE_CHECK([for assembler offsetable %lo() support],
1994             gcc_cv_as_offsetable_lo10, [
1995             gcc_cv_as_offsetable_lo10=unknown
1996             if test "x$gcc_cv_as" != x; then
1997                 # Check if assembler has offsetable %lo()
1998                 echo "or %g1, %lo(ab) + 12, %g1" > conftest.s
1999                 echo "or %g1, %lo(ab + 12), %g1" > conftest1.s
2000                 if $gcc_cv_as $gcc_cv_as_flags64 -o conftest.o conftest.s \
2001                         > /dev/null 2>&1 &&
2002                    $gcc_cv_as $gcc_cv_as_flags64 -o conftest1.o conftest1.s \
2003                         > /dev/null 2>&1; then
2004                     if cmp conftest.o conftest1.o > /dev/null 2>&1; then
2005                         gcc_cv_as_offsetable_lo10=no
2006                     else
2007                         gcc_cv_as_offsetable_lo10=yes
2008                     fi
2009                 else
2010                     gcc_cv_as_offsetable_lo10=no
2011                 fi
2012                 rm -f conftest.s conftest.o conftest1.s conftest1.o
2013             fi
2014         ])
2015         if test "x$gcc_cv_as_offsetable_lo10" = xyes; then
2016             AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
2017                 [Define if your assembler supports offsetable %lo().])
2018         fi
2019     fi
2020
2021     ;;
2022
2023 changequote(,)dnl
2024   i[34567]86-*-* | x86_64-*-*)
2025 changequote([,])dnl
2026     AC_MSG_CHECKING(assembler instructions)
2027     gcc_cv_as_instructions=
2028     if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
2029       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
2030         gcc_cv_as_instructions="filds fists"
2031       fi
2032     elif test x$gcc_cv_as != x; then
2033         set "filds fists" "filds mem; fists mem"
2034         while test $# -gt 0
2035         do
2036                 echo "$2" > conftest.s
2037                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2038                         gcc_cv_as_instructions=${gcc_cv_as_instructions}$1" "
2039                 fi
2040                 shift 2
2041         done
2042         rm -f conftest.s conftest.o
2043     fi
2044     if test x"$gcc_cv_as_instructions" != x; then
2045         AC_DEFINE_UNQUOTED(HAVE_GAS_`echo "$gcc_cv_as_instructions" | sed -e 's/ $//' | tr '[a-z ]' '[A-Z_]'`)
2046     fi
2047     AC_MSG_RESULT($gcc_cv_as_instructions)
2048
2049     AC_MSG_CHECKING(assembler GOTOFF in data directives)
2050     gcc_cv_as_gotoff_in_data=no
2051     if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x
2052     then
2053       if test "$gcc_cv_gas_major_version" -eq 2 \
2054          -a "$gcc_cv_gas_minor_version" -ge 11 \
2055          -o "$gcc_cv_gas_major_version" -gt 2; then
2056         gcc_cv_as_gotoff_in_data=yes
2057       fi
2058     elif test x$gcc_cv_as != x; then
2059         cat > conftest.s <<EOF
2060         .text
2061 .L0:
2062         nop
2063         .data
2064         .long .L0@GOTOFF
2065 EOF
2066         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2067           gcc_cv_as_gotoff_in_data=yes
2068         fi
2069     fi
2070     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
2071       [`if test $gcc_cv_as_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
2072       [Define true if the assembler supports '.long foo@GOTOFF'.])
2073     AC_MSG_RESULT($gcc_cv_as_gotoff_in_data)
2074     ;;
2075 esac
2076
2077 AC_MSG_CHECKING(assembler dwarf2 debug_line support)
2078 gcc_cv_as_dwarf2_debug_line=no
2079 # ??? Not all targets support dwarf2 debug_line, even within a version
2080 # of gas.  Moreover, we need to emit a valid instruction to trigger any
2081 # info to the output file.  So, as supported targets are added to gas 2.11,
2082 # add some instruction here to (also) show we expect this might work.
2083 # ??? Once 2.11 is released, probably need to add first known working
2084 # version to the per-target configury.
2085 case "$target" in
2086   i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* | x86_64*-*-* | hppa*-*-*)
2087     insn="nop"
2088     ;;
2089   ia64*-*-*)
2090     insn="nop 0"
2091     ;;
2092   esac
2093 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x;
2094 then
2095   if test "$gcc_cv_gas_major_version" -eq 2 \
2096         -a "$gcc_cv_gas_minor_version" -ge 11 \
2097         -o "$gcc_cv_gas_major_version" -gt 2 \
2098      && grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2099      && test x"$insn" != x ; then
2100     gcc_cv_as_dwarf2_debug_line="yes"
2101   fi
2102 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2103         echo '  .file 1 "conftest.s"' > conftest.s
2104         echo '  .loc 1 3 0' >> conftest.s
2105         echo "  $insn" >> conftest.s
2106         # ??? This fails with non-gnu grep.
2107         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
2108            && grep debug_line conftest.o > /dev/null 2>&1 ; then
2109                 # The .debug_line file table must be in the exact order that
2110                 # we specified the files, since these indices are also used
2111                 # by DW_AT_decl_file.  Approximate this test by testing if
2112                 # the assembler bitches if the same index is assigned twice.
2113                 echo '  .file 1 "foo.s"' > conftest.s
2114                 echo '  .file 1 "bar.s"' >> conftest.s
2115                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1
2116                 then
2117                   gcc_cv_as_dwarf2_debug_line="no"
2118                 else
2119                   gcc_cv_as_dwarf2_debug_line="yes"
2120                 fi
2121         fi
2122         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
2123 fi
2124 if test x"$gcc_cv_as_dwarf2_debug_line" = xyes; then
2125         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
2126 [Define if your assembler supports dwarf2 .file/.loc directives,
2127    and preserves file table indices exactly as given.])
2128 fi
2129 AC_MSG_RESULT($gcc_cv_as_dwarf2_debug_line)
2130
2131 AC_MSG_CHECKING(assembler --gdwarf2 support)
2132 gcc_cv_as_gdwarf2_flag=no
2133 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x;
2134 then
2135   if test "$gcc_cv_gas_major_version" -eq 2 \
2136         -a "$gcc_cv_gas_minor_version" -ge 11 \
2137         -o "$gcc_cv_gas_major_version" -gt 2 \
2138      && grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2139      && test x"$insn" != x ; then
2140     gcc_cv_as_gdwarf2_flag="yes"
2141   fi
2142 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2143         echo '' > conftest.s
2144         # ??? This fails with non-gnu grep.
2145         if $gcc_cv_as --gdwarf2 -o conftest.o conftest.s > /dev/null 2>&1
2146           then
2147           gcc_cv_as_gdwarf2_flag="yes"
2148         fi
2149         rm -f conftest.s conftest.o
2150 fi
2151 if test x"$gcc_cv_as_gdwarf2_flag" = xyes; then
2152         AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
2153 [Define if your assembler supports the --gdwarf2 option.])
2154 fi
2155 AC_MSG_RESULT($gcc_cv_as_gdwarf2_flag)
2156
2157 AC_MSG_CHECKING(assembler --gstabs support)
2158 gcc_cv_as_gstabs_flag=no
2159 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x;
2160 then
2161   if test "$gcc_cv_gas_major_version" -eq 2 \
2162         -a "$gcc_cv_gas_minor_version" -ge 11 \
2163         -o "$gcc_cv_gas_major_version" -gt 2 \
2164      && grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2165      && test x"$insn" != x ; then
2166     gcc_cv_as_gstabs_flag="yes"
2167   fi
2168 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2169         echo '' > conftest.s
2170         # ??? This fails with non-gnu grep.
2171         if $gcc_cv_as --gstabs -o conftest.o conftest.s > /dev/null 2>&1 ; then
2172           gcc_cv_as_gstabs_flag="yes"
2173         fi
2174         rm -f conftest.s conftest.o
2175 fi
2176 if test x"$gcc_cv_as_gstabs_flag" = xyes; then
2177         AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
2178 [Define if your assembler supports the --gstabs option.])
2179 fi
2180 AC_MSG_RESULT($gcc_cv_as_gstabs_flag)
2181
2182 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
2183 gcc_cv_ld_eh_frame_hdr=no
2184 if test x$gcc_cv_gld_major_version != x -a x$gcc_cv_gld_minor_version != x; then
2185   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
2186     gcc_cv_ld_eh_frame_hdr=yes
2187   fi
2188 elif test x$gcc_cv_ld != x; then
2189         # Check if linker supports --eh-frame-hdr option
2190         if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
2191                 gcc_cv_ld_eh_frame_hdr=yes
2192         fi
2193 fi
2194 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
2195         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
2196 [Define if your linker supports --eh-frame-hdr option.])
2197 fi
2198 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
2199
2200 # Miscellaneous target-specific checks.
2201 case "$target" in
2202   mips*-*-*)
2203     AC_MSG_CHECKING(whether libgloss uses STARTUP directives consistently)
2204     gcc_cv_mips_libgloss_startup=no
2205     gcc_cv_libgloss_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/libgloss
2206     if test "x$exec_prefix" = xNONE; then
2207       if test "x$prefix" = xNONE; then
2208         test_prefix=/usr/local
2209       else
2210         test_prefix=$prefix
2211       fi
2212     else
2213       test_prefix=$exec_prefix
2214     fi
2215     for f in $gcc_cv_libgloss_srcdir/mips/idt.ld $test_prefix/$target_alias/lib/idt.ld
2216     do
2217       if grep '^STARTUP' $f > /dev/null 2>&1; then
2218         gcc_cv_mips_libgloss_startup=yes
2219         break
2220       fi
2221     done
2222     if test x"$gcc_cv_mips_libgloss_startup" = xyes; then
2223       AC_DEFINE(HAVE_MIPS_LIBGLOSS_STARTUP_DIRECTIVES, 1,
2224         [Define if your MIPS libgloss linker scripts consistently include STARTUP directives.])
2225     fi
2226     AC_MSG_RESULT($gcc_cv_mips_libgloss_startup)
2227     ;;
2228 esac
2229
2230 if test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" ; then
2231   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include")
2232 fi
2233
2234 # Figure out what language subdirectories are present.
2235 # Look if the user specified --enable-languages="..."; if not, use
2236 # the environment variable $LANGUAGES if defined. $LANGUAGES might
2237 # go away some day.
2238 # NB:  embedded tabs in this IF block -- do not untabify
2239 if test x"${enable_languages+set}" != xset; then
2240         if test x"${LANGUAGES+set}" = xset; then
2241                 enable_languages="${LANGUAGES}"
2242                 AC_MSG_WARN([setting LANGUAGES is deprecated, use --enable-languages instead])
2243
2244         else
2245                 enable_languages=all
2246         fi
2247 else
2248         if test x"${enable_languages}" = x \
2249         || test x"${enable_languages}" = xyes;
2250         then
2251                 AC_MSG_ERROR([--enable-languages needs at least one language argument])
2252         fi
2253 fi
2254 enable_languages=`echo "${enable_languages}" | sed -e 's/[[     ,]][[   ,]]*/,/g' -e 's/,$//'`
2255
2256 # First scan to see if an enabled language requires some other language.
2257 # We assume that a given config-lang.in will list all the language
2258 # front ends it requires, even if some are required indirectly.
2259 for lang in ${srcdir}/*/config-lang.in ..
2260 do
2261    case $lang in
2262     ..)
2263        ;;
2264     # The odd quoting in the next line works around
2265     # an apparent bug in bash 1.12 on linux.
2266 changequote(,)dnl
2267     ${srcdir}/[*]/config-lang.in)
2268        ;;
2269     *)
2270        lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^      ]*\).*$,\1,p' $lang`
2271        this_lang_requires=`sed -n -e 's,^lang_requires=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^lang_requires=\([^    ]*\).*$,\1,p' $lang`
2272        for other in $this_lang_requires
2273        do
2274           case ,${enable_languages}, in
2275            *,$other,*)
2276               ;;
2277            *,all,*)
2278               ;;
2279            *,$lang_alias,*)
2280               enable_languages="$enable_languages,$other"
2281               ;;
2282           esac
2283        done
2284        ;;
2285 changequote([,])dnl
2286    esac
2287 done
2288
2289 expected_languages=`echo ,${enable_languages}, | sed -e 's:,: :g' -e 's:  *: :g' -e 's:  *: :g' -e 's:^ ::' -e 's: $::'`
2290 found_languages=
2291 subdirs=
2292 for lang in ${srcdir}/*/config-lang.in ..
2293 do
2294         case $lang in
2295         ..) ;;
2296         # The odd quoting in the next line works around
2297         # an apparent bug in bash 1.12 on linux.
2298 changequote(,)dnl
2299         ${srcdir}/[*]/config-lang.in) ;;
2300         *)
2301           lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
2302           this_lang_libs=`sed -n -e 's,^target_libs=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^target_libs=\([^         ]*\).*$,\1,p' $lang`
2303           build_by_default=`sed -n -e 's,^build_by_default=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^build_by_default=\([^     ]*\).*$,\1,p' $lang`
2304           if test "x$lang_alias" = x
2305           then
2306                 echo "$lang doesn't set \$language." 1>&2
2307                 exit 1
2308           fi
2309           case ${build_by_default},${enable_languages}, in
2310           *,$lang_alias,*) add_this_lang=yes ;;
2311           no,*) add_this_lang=no ;;
2312           *,all,*) add_this_lang=yes ;;
2313           *) add_this_lang=no ;;
2314           esac
2315           found_languages="${found_languages} ${lang_alias}"
2316           if test x"${add_this_lang}" = xyes; then
2317                 case $lang in
2318                     ${srcdir}/ada/config-lang.in)
2319                         if test x$have_gnat = xyes ; then
2320                                 subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2321                         fi
2322                         ;;
2323                     *)
2324                         subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2325                         ;;
2326                 esac
2327           fi
2328           ;;
2329 changequote([,])dnl
2330         esac
2331 done
2332
2333 missing_languages=
2334 for expected_language in ${expected_languages} ..
2335 do
2336     if test "${expected_language}" != ..; then
2337         missing_language="${expected_language}"
2338         if test "${expected_language}" = "c" \
2339            || test "${expected_language}" = "all"; then
2340                 missing_language=
2341         fi
2342         for found_language in ${found_languages} ..
2343         do
2344             if test "${found_language}" != ..; then
2345                 if test "${expected_language}" = "${found_language}"; then
2346                     missing_language=
2347                 fi
2348             fi
2349         done
2350         if test "x${missing_language}" != x; then
2351            missing_languages="${missing_languages} ${missing_language}"
2352         fi
2353     fi
2354 done
2355
2356 if test "x$missing_languages" != x; then
2357   AC_MSG_ERROR([
2358 The following requested languages were not found:${missing_languages}
2359 The following languages were available: c${found_languages}])
2360 fi
2361
2362 # Make gthr-default.h if we have a thread file.
2363 gthread_flags=
2364 if test $thread_file != single; then
2365     rm -f gthr-default.h
2366     echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h
2367     gthread_flags=-DHAVE_GTHR_DEFAULT
2368 fi
2369 AC_SUBST(gthread_flags)
2370
2371 # Find out what GC implementation we want, or may, use.
2372 AC_ARG_WITH(gc,
2373 [  --with-gc={simple,page} choose the garbage collection mechanism to use
2374                           with the compiler],
2375 [case "$withval" in
2376   simple | page)
2377     GGC=ggc-$withval
2378     ;;
2379   *)
2380     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
2381     ;;
2382 esac],
2383 [GGC=ggc-page])
2384 AC_SUBST(GGC)
2385 echo "Using $GGC for garbage collection."
2386
2387 # Use the system's zlib library.
2388 zlibdir=-L../zlib
2389 zlibinc="-I\$(srcdir)/../zlib"
2390 AC_ARG_WITH(system-zlib,
2391 [  --with-system-zlib      use installed libz],
2392 zlibdir=
2393 zlibinc=
2394 )
2395 AC_SUBST(zlibdir)
2396 AC_SUBST(zlibinc)
2397
2398 dnl Very limited version of automake's enable-maintainer-mode
2399
2400 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
2401   dnl maintainer-mode is disabled by default
2402   AC_ARG_ENABLE(maintainer-mode,
2403 [  --enable-maintainer-mode
2404                           enable make rules and dependencies not useful
2405                           (and sometimes confusing) to the casual installer],
2406       maintainer_mode=$enableval,
2407       maintainer_mode=no)
2408
2409 AC_MSG_RESULT($maintainer_mode)
2410
2411 if test "$maintainer_mode" = "yes"; then
2412   MAINT=''
2413 else
2414   MAINT='#'
2415 fi
2416 AC_SUBST(MAINT)dnl
2417
2418 # With Setjmp/Longjmp based exception handling.
2419 AC_ARG_ENABLE(sjlj-exceptions,
2420 [  --enable-sjlj-exceptions
2421                           arrange to use setjmp/longjmp exception handling],
2422 [sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
2423 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
2424   [Define 0/1 to force the choice for exception handling model.])])
2425
2426 # Use libunwind based exception handling.
2427 AC_ARG_ENABLE(libunwind-exceptions,
2428 [  --enable-libunwind-exceptions  force use libunwind for exceptions],
2429 use_libunwind_exceptions=$enableval,
2430 use_libunwind_exceptions=no)
2431 if test x"$use_libunwind_exceptions" = xyes; then
2432    AC_DEFINE(USE_LIBUNWIND_EXCEPTIONS, 1,
2433         [Define if gcc should use -lunwind.])
2434 fi
2435
2436 # Make empty files to contain the specs and options for each language.
2437 # Then add #include lines to for a compiler that has specs and/or options.
2438
2439 lang_specs_files=
2440 lang_options_files=
2441 lang_tree_files=
2442 for subdir in . $subdirs
2443 do
2444         if test -f $srcdir/$subdir/lang-specs.h; then
2445             lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
2446         fi
2447         if test -f $srcdir/$subdir/lang-options.h; then
2448             lang_options_files="$lang_options_files $srcdir/$subdir/lang-options.h"
2449         fi
2450         if test -f $srcdir/$subdir/$subdir-tree.def; then
2451             lang_tree_files="$lang_tree_files $srcdir/$subdir/$subdir-tree.def"
2452         fi
2453 done
2454
2455 # These (without "all_") are set in each config-lang.in.
2456 # `language' must be a single word so is spelled singularly.
2457 all_languages=
2458 all_boot_languages=
2459 all_compilers=
2460 all_stagestuff=
2461 all_outputs='Makefile intl/Makefile fixinc/Makefile gccbug mklibgcc mkheaders'
2462 # List of language makefile fragments.
2463 all_lang_makefiles=
2464 # Files for gengtype
2465 all_gtfiles="$target_gtfiles"
2466 # Files for gengtype with language
2467 all_gtfiles_files_langs=
2468 all_gtfiles_files_files=
2469
2470 # Add the language fragments.
2471 # Languages are added via two mechanisms.  Some information must be
2472 # recorded in makefile variables, these are defined in config-lang.in.
2473 # We accumulate them and plug them into the main Makefile.
2474 # The other mechanism is a set of hooks for each of the main targets
2475 # like `clean', `install', etc.
2476
2477 language_fragments="Make-lang"
2478 language_hooks="Make-hooks"
2479
2480 for s in .. $subdirs
2481 do
2482         if test $s != ".."
2483         then
2484                 language=
2485                 boot_language=
2486                 compilers=
2487                 stagestuff=
2488                 outputs=
2489                 gtfiles=
2490                 . ${srcdir}/$s/config-lang.in
2491                 if test "x$language" = x
2492                 then
2493                         echo "${srcdir}/$s/config-lang.in doesn't set \$language." 1>&2
2494                         exit 1
2495                 fi
2496                 all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Make-lang.in"
2497                 if test -f ${srcdir}/$s/Makefile.in
2498                 then all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Makefile.in"
2499                 fi
2500                 all_languages="$all_languages $language"
2501                 if test "x$boot_language" = xyes
2502                 then
2503                         all_boot_languages="$all_boot_languages $language"
2504                 fi
2505                 all_compilers="$all_compilers $compilers"
2506                 all_stagestuff="$all_stagestuff $stagestuff"
2507                 all_outputs="$all_outputs $outputs"
2508                 all_gtfiles="$all_gtfiles $gtfiles"
2509                 for f in .. $gtfiles
2510                 do
2511                      if test $f != ".."
2512                      then
2513                          all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2514                          all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2515                      fi
2516                 done
2517         fi
2518 done
2519
2520 # Pick up gtfiles for c
2521 gtfiles=
2522 s="c"
2523 . ${srcdir}/c-config-lang.in
2524 all_gtfiles="$all_gtfiles $gtfiles"
2525 for f in .. $gtfiles
2526 do
2527      if test $f != ".."
2528      then
2529         all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2530         all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2531      fi
2532 done
2533
2534 check_languages=
2535 for language in .. $all_languages
2536 do
2537         if test $language != ".."
2538         then
2539                 check_languages="$check_languages check-$language"
2540         fi
2541 done
2542
2543 # Since we can't use `::' targets, we link each language in
2544 # with a set of hooks, reached indirectly via lang.${target}.
2545
2546 rm -f Make-hooks
2547 touch Make-hooks
2548 target_list="all.build all.cross start.encap rest.encap \
2549         info dvi generated-manpages \
2550         install-normal install-common install-info install-man \
2551         uninstall \
2552         mostlyclean clean distclean extraclean maintainer-clean \
2553         stage1 stage2 stage3 stage4"
2554 for t in $target_list
2555 do
2556         x=
2557         for lang in .. $all_languages
2558         do
2559                 if test $lang != ".."; then
2560                         x="$x $lang.$t"
2561                 fi
2562         done
2563         echo "lang.$t: $x" >> Make-hooks
2564 done
2565
2566 # Create .gdbinit.
2567
2568 echo "dir ." > .gdbinit
2569 echo "dir ${srcdir}" >> .gdbinit
2570 if test x$gdb_needs_out_file_path = xyes
2571 then
2572         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
2573 fi
2574 if test "x$subdirs" != x; then
2575         for s in $subdirs
2576         do
2577                 echo "dir ${srcdir}/$s" >> .gdbinit
2578         done
2579 fi
2580 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
2581
2582 # Define variables host_canonical and build_canonical
2583 # because some Cygnus local changes in the Makefile depend on them.
2584 build_canonical=${build}
2585 host_canonical=${host}
2586 target_subdir=
2587 if test "${host}" != "${target}" ; then
2588     target_subdir=${target_alias}/
2589 fi
2590 AC_SUBST(build_canonical)
2591 AC_SUBST(host_canonical)
2592 AC_SUBST(target_subdir)
2593
2594 # If $(exec_prefix) exists and is not the same as $(prefix), then compute an
2595 # absolute path for gcc_tooldir based on inserting the number of up-directory
2596 # movements required to get from $(exec_prefix) to $(prefix) into the basic
2597 # $(libsubdir)/@(unlibsubdir) based path.
2598 # Don't set gcc_tooldir to tooldir since that's only passed in by the toplevel
2599 # make and thus we'd get different behavior depending on where we built the
2600 # sources.
2601 if test x$exec_prefix = xNONE -o x$exec_prefix = x$prefix; then
2602     gcc_tooldir='$(libsubdir)/$(unlibsubdir)/../$(target_alias)'
2603 else
2604 changequote(<<, >>)dnl
2605 # An explanation of the sed strings:
2606 #  -e 's|^\$(prefix)||'   matches and eliminates 'prefix' from 'exec_prefix'
2607 #  -e 's|/$||'            match a trailing forward slash and eliminates it
2608 #  -e 's|^[^/]|/|'        forces the string to start with a forward slash (*)
2609 #  -e 's|/[^/]*|../|g'    replaces each occurrence of /<directory> with ../
2610 #
2611 # (*) Note this pattern overwrites the first character of the string
2612 # with a forward slash if one is not already present.  This is not a
2613 # problem because the exact names of the sub-directories concerned is
2614 # unimportant, just the number of them matters.
2615 #
2616 # The practical upshot of these patterns is like this:
2617 #
2618 #  prefix     exec_prefix        result
2619 #  ------     -----------        ------
2620 #   /foo        /foo/bar          ../
2621 #   /foo/       /foo/bar          ../
2622 #   /foo        /foo/bar/         ../
2623 #   /foo/       /foo/bar/         ../
2624 #   /foo        /foo/bar/ugg      ../../
2625 #
2626     dollar='$$'
2627     gcc_tooldir="\$(libsubdir)/\$(unlibsubdir)/\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/\$(dollar)||' -e 's|^[^/]|/|' -e 's|/[^/]*|../|g'\`\$(target_alias)"
2628 changequote([, ])dnl
2629 fi
2630 AC_SUBST(gcc_tooldir)
2631 AC_SUBST(dollar)
2632
2633 # Find a directory in which to install a shared libgcc.
2634
2635 AC_ARG_ENABLE(version-specific-runtime-libs,
2636 [  --enable-version-specific-runtime-libs
2637                           specify that runtime libraries should be
2638                           installed in a compiler-specific directory])
2639
2640 AC_ARG_WITH(slibdir,
2641 [  --with-slibdir=DIR      shared libraries in DIR [LIBDIR]],
2642 slibdir="$with_slibdir",
2643 if test "${enable_version_specific_runtime_libs+set}" = set; then
2644   slibdir='$(libsubdir)'
2645 elif test "$host" != "$target"; then
2646   slibdir='$(build_tooldir)/lib'
2647 else
2648   slibdir='$(libdir)'
2649 fi)
2650 AC_SUBST(slibdir)
2651
2652 # Nothing to do for FLOAT_H, float_format already handled.
2653 objdir=`${PWDCMD-pwd}`
2654 AC_SUBST(objdir)
2655
2656 # Process the language and host/target makefile fragments.
2657 ${CONFIG_SHELL-/bin/sh} $srcdir/configure.frag $srcdir "$subdirs" "$dep_host_xmake_file" "$dep_tmake_file"
2658
2659 # Substitute configuration variables
2660 AC_SUBST(subdirs)
2661 AC_SUBST(srcdir)
2662 AC_SUBST(all_boot_languages)
2663 AC_SUBST(all_compilers)
2664 AC_SUBST(all_gtfiles)
2665 AC_SUBST(all_gtfiles_files_langs)
2666 AC_SUBST(all_gtfiles_files_files)
2667 AC_SUBST(all_lang_makefiles)
2668 AC_SUBST(all_languages)
2669 AC_SUBST(all_stagestuff)
2670 AC_SUBST(build_exeext)
2671 AC_SUBST(build_install_headers_dir)
2672 AC_SUBST(build_xm_file_list)
2673 AC_SUBST(build_xm_file)
2674 AC_SUBST(build_xm_defines)
2675 AC_SUBST(check_languages)
2676 AC_SUBST(cc_set_by_configure)
2677 AC_SUBST(quoted_cc_set_by_configure)
2678 AC_SUBST(cpp_install_dir)
2679 AC_SUBST(dep_host_xmake_file)
2680 AC_SUBST(dep_tmake_file)
2681 AC_SUBST(extra_headers_list)
2682 AC_SUBST(extra_objs)
2683 AC_SUBST(extra_parts)
2684 AC_SUBST(extra_passes)
2685 AC_SUBST(extra_programs)
2686 AC_SUBST(float_h_file)
2687 AC_SUBST(gcc_config_arguments)
2688 AC_SUBST(gcc_gxx_include_dir)
2689 AC_SUBST(libstdcxx_incdir)
2690 AC_SUBST(gcc_version)
2691 AC_SUBST(gcc_version_full)
2692 AC_SUBST(gcc_version_trigger)
2693 AC_SUBST(host_exeext)
2694 AC_SUBST(host_extra_gcc_objs)
2695 AC_SUBST(host_xm_file_list)
2696 AC_SUBST(host_xm_file)
2697 AC_SUBST(host_xm_defines)
2698 AC_SUBST(install)
2699 AC_SUBST(lang_options_files)
2700 AC_SUBST(lang_specs_files)
2701 AC_SUBST(lang_tree_files)
2702 AC_SUBST(local_prefix)
2703 AC_SUBST(md_file)
2704 AC_SUBST(objc_boehm_gc)
2705 AC_SUBST(out_file)
2706 AC_SUBST(out_object_file)
2707 AC_SUBST(stage_prefix_set_by_configure)
2708 AC_SUBST(quoted_stage_prefix_set_by_configure)
2709 AC_SUBST(symbolic_link)
2710 AC_SUBST(thread_file)
2711 AC_SUBST(tm_file_list)
2712 AC_SUBST(tm_file)
2713 AC_SUBST(tm_defines)
2714 AC_SUBST(tm_p_file_list)
2715 AC_SUBST(tm_p_file)
2716 AC_SUBST(xm_file)
2717 AC_SUBST(xm_defines)
2718 AC_SUBST(target_alias)
2719 AC_SUBST(c_target_objs)
2720 AC_SUBST(cxx_target_objs)
2721 AC_SUBST(target_cpu_default)
2722
2723 AC_SUBST_FILE(target_overrides)
2724 AC_SUBST_FILE(host_overrides)
2725 AC_SUBST_FILE(language_fragments)
2726 AC_SUBST_FILE(language_hooks)
2727
2728 # Echo that links are built
2729 if test x$host = x$target
2730 then
2731         str1="native "
2732 else
2733         str1="cross-"
2734         str2=" from $host"
2735 fi
2736
2737 if test x$host != x$build
2738 then
2739         str3=" on a $build system"
2740 fi
2741
2742 if test "x$str2" != x || test "x$str3" != x
2743 then
2744         str4=
2745 fi
2746
2747 echo "Links are now set up to build a ${str1}compiler for ${target}$str4" 1>&2
2748
2749 if test "x$str2" != x || test "x$str3" != x
2750 then
2751         echo " ${str2}${str3}." 1>&2
2752 fi
2753
2754 # Truncate the target if necessary
2755 if test x$host_truncate_target != x; then
2756         target=`echo $target | sed -e 's/\(..............\).*/\1/'`
2757 fi
2758
2759 # Configure the subdirectories
2760 # AC_CONFIG_SUBDIRS($subdirs)
2761
2762 # Create the Makefile
2763 # and configure language subdirectories
2764 AC_OUTPUT($all_outputs,
2765 [
2766 case x$CONFIG_HEADERS in
2767 xauto-host.h:config.in)
2768 echo > cstamp-h ;;
2769 esac
2770 # If the host supports symlinks, point stage[1234] at ../stage[1234] so
2771 # bootstrapping and the installation procedure can still use
2772 # CC="stage1/xgcc -Bstage1/".  If the host doesn't support symlinks,
2773 # FLAGS_TO_PASS has been modified to solve the problem there.
2774 # This is virtually a duplicate of what happens in configure.lang; we do
2775 # an extra check to make sure this only happens if ln -s can be used.
2776 if test "$symbolic_link" = "ln -s"; then
2777  for d in .. ${subdirs} fixinc ; do
2778    if test $d != ..; then
2779         STARTDIR=`${PWDCMD-pwd}`
2780         cd $d
2781         for t in stage1 stage2 stage3 stage4 include
2782         do
2783                 rm -f $t
2784                 $symbolic_link ../$t $t 2>/dev/null
2785         done
2786         cd $STARTDIR
2787    fi
2788  done
2789 else true ; fi
2790 # Avoid having to add intl to our include paths.
2791 if test -f intl/libintl.h; then
2792   echo creating libintl.h
2793   echo '#include "intl/libintl.h"' >libintl.h
2794 fi
2795 ],
2796 [subdirs='$subdirs'
2797 symbolic_link='$symbolic_link'
2798 ])