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