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