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