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