gcc/configure.in

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