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 | xgnat)
 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 # Identify the assembler which will work hand-in-glove with the newly
1441 # built GCC, so that we can examine its features.  This is the assembler
1442 # which will be driven by the driver program.
1443 #
1444 # If build != host, and we aren't building gas in-tree, we identify a
1445 # build->target assembler and hope that it will have the same features
1446 # as the host->target assembler we'll be using.
1447 AC_MSG_CHECKING(what assembler to use)
1448 in_tree_gas=no
1449 gcc_cv_as=
1450 gcc_cv_gas_major_version=
1451 gcc_cv_gas_minor_version=
1452 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1453 if test -x "$DEFAULT_ASSEMBLER"; then
1454         gcc_cv_as="$DEFAULT_ASSEMBLER"
1455 elif test -x "$AS"; then
1456         gcc_cv_as="$AS"
1457 elif test -x as$host_exeext; then
1458         # Build using assembler in the current directory.
1459         gcc_cv_as=./as$host_exeext
1460 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
1461      && test -f ../gas/Makefile; then
1462   # Single tree build which includes gas.
1463   in_tree_gas=yes
1464   _gcc_COMPUTE_GAS_VERSION
1465   rm -f as$host_exeext
1466   $symbolic_link ../gas/as-new$host_exeext as$host_exeext 2>/dev/null
1467 fi
1468
1469 if test "x$gcc_cv_as" = x; then
1470         # Search the same directories that the installed compiler will
1471         # search.  Else we may find the wrong assembler and lose.  If we
1472         # do not find a suitable assembler binary, then try the user's
1473         # path.
1474         #
1475         # Also note we have to check MD_EXEC_PREFIX before checking the
1476         # user's path.  Unfortunately, there is no good way to get at the
1477         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1478         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1479         # to be fixed as part of the make/configure rewrite too.
1480
1481         if test "x$exec_prefix" = xNONE; then
1482                 if test "x$prefix" = xNONE; then
1483                         test_prefix=/usr/local
1484                 else
1485                         test_prefix=$prefix
1486                 fi
1487         else
1488                 test_prefix=$exec_prefix
1489         fi
1490
1491         # If the loop below does not find an assembler, then use whatever
1492         # one we can find in the users's path.
1493         # user's path.
1494         if test "x$program_prefix" != xNONE; then
1495                 gcc_cv_as=${program_prefix}as$host_exeext
1496         else
1497                 gcc_cv_as=`echo as | sed ${program_transform_name}`$host_exeext
1498         fi
1499
1500         test_dirs="$test_prefix/lib/gcc-lib/$target_alias/$gcc_version \
1501                    $test_prefix/lib/gcc-lib/$target_alias \
1502                    /usr/lib/gcc/$target_alias/$gcc_version \
1503                    /usr/lib/gcc/$target_alias \
1504                    $test_prefix/$target_alias/bin/$target_alias/$gcc_version \
1505                    $test_prefix/$target_alias/bin"
1506
1507         if test x$host = x$target; then
1508             test_dirs="$test_dirs \
1509                    /usr/libexec \
1510                    /usr/ccs/gcc \
1511                    /usr/ccs/bin \
1512                    /udk/usr/ccs/bin \
1513                    /bsd43/usr/lib/cmplrs/cc \
1514                    /usr/cross64/usr/bin \
1515                    /usr/lib/cmplrs/cc \
1516                    /sysv/usr/lib/cmplrs/cc \
1517                    /svr4/usr/lib/cmplrs/cc \
1518                    /usr/bin"
1519         fi
1520
1521         for dir in $test_dirs; do
1522                 if test -x $dir/as$host_exeext; then
1523                         gcc_cv_as=$dir/as$host_exeext
1524                         break;
1525                 fi
1526         done
1527 fi
1528 case $in_tree_gas in
1529   yes)
1530     AC_MSG_RESULT("newly built gas")
1531     ;;
1532   no)
1533     AC_MSG_RESULT($gcc_cv_as)
1534     ;;
1535 esac
1536
1537 # Identify the linker which will work hand-in-glove with the newly
1538 # built GCC, so that we can examine its features.  This is the linker
1539 # which will be driven by the driver program.
1540 #
1541 # If build != host, and we aren't building gas in-tree, we identify a
1542 # build->target linker and hope that it will have the same features
1543 # as the host->target linker we'll be using.
1544 AC_MSG_CHECKING(what linker to use)
1545 in_tree_ld=no
1546 gcc_cv_ld=
1547 gcc_cv_gld_major_version=
1548 gcc_cv_gld_minor_version=
1549 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1550 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1551 if test -x "$DEFAULT_LINKER"; then
1552         gcc_cv_ld="$DEFAULT_LINKER"
1553 elif test -x "$LD"; then
1554         gcc_cv_ld="$LD"
1555 elif test -x collect-ld$host_exeext; then
1556         # Build using linker in the current directory.
1557         gcc_cv_ld=./collect-ld$host_exeext
1558 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
1559      && test -f ../ld/Makefile; then
1560         # Single tree build which includes ld.
1561         in_tree_ld=yes
1562         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
1563         do
1564 changequote(,)dnl
1565                 gcc_cv_gld_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
1566 changequote([,])dnl
1567                 if test x$gcc_cv_gld_version != x; then
1568                         break
1569                 fi
1570         done
1571 changequote(,)dnl
1572         gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
1573         gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1574 changequote([,])dnl
1575         rm -f collect-ld$host_exeext
1576         $symbolic_link ../ld/ld-new$host_exeext collect-ld$host_exeext \
1577                 2>/dev/null
1578 fi
1579
1580 if test "x$gcc_cv_ld" = x; then
1581         # Search the same directories that the installed compiler will
1582         # search.  Else we may find the wrong linker and lose.  If we
1583         # do not find a suitable linker binary, then try the user's
1584         # path.
1585         #
1586         # Also note we have to check MD_EXEC_PREFIX before checking the
1587         # user's path.  Unfortunately, there is no good way to get at the
1588         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1589         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1590         # to be fixed as part of the make/configure rewrite too.
1591
1592         if test "x$exec_prefix" = xNONE; then
1593                 if test "x$prefix" = xNONE; then
1594                         test_prefix=/usr/local
1595                 else
1596                         test_prefix=$prefix
1597                 fi
1598         else
1599                 test_prefix=$exec_prefix
1600         fi
1601
1602         # If the loop below does not find an linker, then use whatever
1603         # one we can find in the users's path.
1604         # user's path.
1605         if test "x$program_prefix" != xNONE; then
1606                 gcc_cv_ld=${program_prefix}ld$host_exeext
1607         else
1608                 gcc_cv_ld=`echo ld | sed ${program_transform_name}`$host_exeext
1609         fi
1610
1611         test_dirs="$test_prefix/lib/gcc-lib/$target_alias/$gcc_version \
1612                    $test_prefix/lib/gcc-lib/$target_alias \
1613                    /usr/lib/gcc/$target_alias/$gcc_version \
1614                    /usr/lib/gcc/$target_alias \
1615                    $test_prefix/$target_alias/bin/$target_alias/$gcc_version \
1616                    $test_prefix/$target_alias/bin"
1617
1618         if test x$host = x$target; then
1619             test_dirs="$test_dirs \
1620                    /usr/libexec \
1621                    /usr/ccs/gcc \
1622                    /usr/ccs/bin \
1623                    /udk/usr/ccs/bin \
1624                    /bsd43/usr/lib/cmplrs/cc \
1625                    /usr/cross64/usr/bin \
1626                    /usr/lib/cmplrs/cc \
1627                    /sysv/usr/lib/cmplrs/cc \
1628                    /svr4/usr/lib/cmplrs/cc \
1629                    /usr/bin"
1630         fi
1631
1632         for dir in $test_dirs; do
1633                 if test -x $dir/ld$host_exeext; then
1634                         gcc_cv_ld=$dir/ld$host_exeext
1635                         break;
1636                 fi
1637         done
1638 fi
1639 case $in_tree_ld in
1640   yes)
1641     AC_MSG_RESULT("newly built ld")
1642     ;;
1643   no)
1644     AC_MSG_RESULT($gcc_cv_ld)
1645     ;;
1646 esac
1647
1648 # Figure out what nm we will be using.
1649 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
1650 AC_MSG_CHECKING(what nm to use)
1651 in_tree_nm=no
1652 if test -x nm$host_exeext; then
1653         gcc_cv_nm=./nm$host_exeext
1654 elif test -f $gcc_cv_binutils_srcdir/configure.in \
1655      && test -f ../binutils/Makefile; then
1656         # Single tree build which includes binutils.
1657         in_tree_nm=yes
1658         gcc_cv_nm=./nm$host_exeext
1659         rm -f nm$host_exeext
1660         $symbolic_link ../binutils/nm-new$host_exeext nm$host_exeext 2>/dev/null
1661 elif test "x$program_prefix" != xNONE; then
1662         gcc_cv_nm=${program_prefix}nm$host_exeext
1663 else
1664         gcc_cv_nm=`echo nm | sed ${program_transform_name}`$host_exeext
1665 fi
1666 case $in_tree_nm in
1667   yes) AC_MSG_RESULT("newly built nm") ;;
1668   no)  AC_MSG_RESULT($gcc_cv_nm) ;;
1669 esac
1670
1671 # Figure out what objdump we will be using.
1672 AC_MSG_CHECKING(what objdump to use)
1673 in_tree_objdump=no
1674 if test -x objdump$host_exeext; then
1675         gcc_cv_objdump=./objdump$host_exeext
1676 elif test -f $gcc_cv_binutils_srcdir/configure.in \
1677      && test -f ../binutils/Makefile; then
1678         # Single tree build which includes binutils.
1679         in_tree_objdump=yes
1680         gcc_cv_objdump=./objdump$host_exeext
1681         rm -f objdump$host_exeext
1682         $symbolic_link ../binutils/objdump$host_exeext \
1683                 objdump$host_exeext 2>/dev/null
1684 elif test "x$program_prefix" != xNONE; then
1685         gcc_cv_objdump=${program_prefix}objdump$host_exeext
1686 else
1687         gcc_cv_objdump=`echo objdump | \
1688                 sed ${program_transform_name}`$host_exeext
1689 fi
1690 case $in_tree_objdump in
1691   yes) AC_MSG_RESULT("newly built objdump") ;;
1692   no)  AC_MSG_RESULT($gcc_cv_objdump) ;;
1693 esac
1694
1695 # Figure out what assembler alignment features are present.
1696 AC_MSG_CHECKING(assembler alignment features)
1697 gcc_cv_as_alignment_features=none
1698 if test $in_tree_gas = yes; then
1699   # Gas version 2.6 and later support for .balign and .p2align.
1700   gcc_GAS_VERSION_GTE_IFELSE(2,6,0,[
1701     gcc_cv_as_alignment_features=".balign and .p2align"
1702     AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN)
1703   ])
1704   # Gas version 2.8 and later support specifying the maximum
1705   # bytes to skip when using .p2align.
1706   gcc_GAS_VERSION_GTE_IFELSE(2,8,0,[
1707     gcc_cv_as_alignment_features=".p2align including maximum skip"
1708     AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN)
1709   ])
1710 elif test x$gcc_cv_as != x; then
1711         # Check if we have .balign and .p2align
1712         echo ".balign  4" > conftest.s
1713         echo ".p2align  2" >> conftest.s
1714         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1715                 gcc_cv_as_alignment_features=".balign and .p2align"
1716                 AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN)
1717         fi
1718         rm -f conftest.s conftest.o
1719         # Check if specifying the maximum bytes to skip when
1720         # using .p2align is supported.
1721         echo ".p2align 4,,7" > conftest.s
1722         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1723                 gcc_cv_as_alignment_features=".p2align including maximum skip"
1724                 AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN)
1725         fi
1726         rm -f conftest.s conftest.o
1727 fi
1728 AC_MSG_RESULT($gcc_cv_as_alignment_features)
1729
1730 AC_MSG_CHECKING(assembler subsection support)
1731 gcc_cv_as_subsections=no
1732 if test $in_tree_gas = yes ; then
1733   gcc_GAS_VERSION_GTE_IFELSE(2,9,0,[
1734     if grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
1735       gcc_cv_as_subsections="working .subsection -1"
1736     fi
1737   ])
1738 elif test x$gcc_cv_as != x; then
1739         # Check if we have .subsection
1740         echo ".subsection 1" > conftest.s
1741         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1742                 gcc_cv_as_subsections=".subsection"
1743                 if test x$gcc_cv_nm != x; then
1744                         cat > conftest.s <<EOF
1745 conftest_label1: .word 0
1746 .subsection -1
1747 conftest_label2: .word 0
1748 .previous
1749 EOF
1750                         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1751                                 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
1752                                 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
1753                                 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1; then
1754                                         :
1755                                 else
1756                                         gcc_cv_as_subsections="working .subsection -1"
1757                                 fi
1758                         fi
1759                 fi
1760         fi
1761         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1762 fi
1763 if test x"$gcc_cv_as_subsections" = x"working .subsection -1"; then
1764         AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
1765 [Define if your assembler supports .subsection and .subsection -1 starts
1766    emitting at the beginning of your section.])
1767 fi
1768 AC_MSG_RESULT($gcc_cv_as_subsections)
1769
1770 AC_MSG_CHECKING(assembler weak support)
1771 gcc_cv_as_weak=no
1772 if test $in_tree_gas = yes ; then
1773   gcc_GAS_VERSION_GTE_IFELSE(2,2,0,[
1774     gcc_cv_as_weak="yes"
1775   ])
1776 elif test x$gcc_cv_as != x; then
1777         # Check if we have .weak
1778         echo "  .weak foobar" > conftest.s
1779         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1780                 gcc_cv_as_weak="yes"
1781         fi
1782         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1783 fi
1784 if test x"$gcc_cv_as_weak" = xyes; then
1785         AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])
1786 fi
1787 AC_MSG_RESULT($gcc_cv_as_weak)
1788
1789 AC_MSG_CHECKING(assembler hidden support)
1790 gcc_cv_as_hidden=no
1791 if test $in_tree_gas = yes ; then
1792   gcc_GAS_VERSION_GTE_IFELSE(2,12,1,[
1793     if grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
1794       gcc_cv_as_hidden="yes"
1795     fi
1796   ])
1797 elif test x$gcc_cv_as != x; then
1798         # Check if we have .hidden
1799         echo "  .hidden foobar" > conftest.s
1800         echo "foobar:" >> conftest.s
1801         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1802                 gcc_cv_as_hidden="yes"
1803         fi
1804         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1805
1806         # GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
1807         # This is irritatingly difficult to feature test for.  Look for
1808         # the date string after the version number.
1809         ld_ver=`$gcc_cv_ld --version 2>/dev/null | head -1`
1810         if echo "$ld_ver" | grep GNU > /dev/null; then
1811 changequote(,)dnl
1812                 ld_vers=`echo $ld_ver | sed -n 's,^.*[  ]\([0-9][0-9]*\.[0-9][0-9]*\(\|\.[0-9][0-9]*\)\)\([     ].*\|\)$,\1,p'`
1813                 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'`
1814                 if test 0"$ld_date" -lt 20020404; then
1815                         if test -n "$ld_date"; then
1816                                 # If there was date string, but was earlier than 2002-04-04, fail
1817                                 gcc_cv_as_hidden="no"
1818                         elif test -z "$ld_vers"; then
1819                                 # If there was no date string nor ld version number, something is wrong
1820                                 gcc_cv_as_hidden="no"
1821                         else
1822                                 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
1823                                 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
1824                                 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
1825                                 test -z "$ld_vers_patch" && ld_vers_patch=0
1826                                 if test "$ld_vers_major" -lt 2; then
1827                                         gcc_cv_as_hidden="no"
1828                                 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
1829                                         gcc_cv_as_hidden="no"
1830                                 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 \
1831                                           -a "$ld_vers_patch" -eq 0; then
1832                                         gcc_cv_as_hidden="no"
1833                                 fi
1834                         fi
1835                 fi
1836 changequote([,])dnl
1837         fi
1838 fi
1839 if test x"$gcc_cv_as_hidden" = xyes; then
1840         AC_DEFINE(HAVE_GAS_HIDDEN, 1,
1841                 [Define if your assembler supports .hidden.])
1842 fi
1843 AC_MSG_RESULT($gcc_cv_as_hidden)
1844 libgcc_visibility=$gcc_cv_as_hidden
1845 case "$target" in
1846   mips-sgi-irix6*)
1847     if test x"$gnu_ld_flag" = x"no"; then
1848       # Even if using gas with .hidden support, the resulting object files
1849       # cannot be linked with the IRIX 6 O32 linker.  With the N32 and
1850       # N64 linkers, the problem is that the linker refuses to accept
1851       # -call_shared (passed by default to the linker) and -r (used to
1852       # link the object file generated without .hidden directives with
1853       # one that hides symbols), so we also lose.
1854       libgcc_visibility=no
1855     fi
1856     ;;
1857 esac
1858 AC_SUBST(libgcc_visibility)
1859
1860 AC_MSG_CHECKING(assembler leb128 support)
1861 gcc_cv_as_leb128=no
1862 if test $in_tree_gas = yes ; then
1863   gcc_GAS_VERSION_GTE_IFELSE(2,11,0,[
1864     if grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
1865       gcc_cv_as_leb128="yes"
1866     fi
1867   ])
1868 elif test x$gcc_cv_as != x; then
1869         # Check if we have .[us]leb128, and support symbol arithmetic with it.
1870         cat > conftest.s <<EOF
1871         .data
1872         .uleb128 L2 - L1
1873 L1:
1874         .uleb128 1280
1875         .sleb128 -1010
1876 L2:
1877 EOF
1878         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1879                 gcc_cv_as_leb128="yes"
1880
1881                 # GAS versions before 2.11 do not support uleb128,
1882                 # despite appearing to.
1883                 # ??? There exists an elf-specific test that will crash
1884                 # the assembler.  Perhaps it's better to figure out whether
1885                 # arbitrary sections are supported and try the test.
1886                 as_ver=`$gcc_cv_as --version 2>/dev/null | head -1`
1887                 if echo "$as_ver" | grep GNU > /dev/null; then
1888 changequote(,)dnl
1889                         as_ver=`echo $as_ver | sed -e 's/GNU assembler \([0-9.][0-9.]*\).*/\1/'`
1890                         as_major=`echo $as_ver | sed 's/\..*//'`
1891                         as_minor=`echo $as_ver | sed 's/[^.]*\.\([0-9]*\).*/\1/'`
1892 changequote([,])dnl
1893                         if test $as_major -eq 2 -a $as_minor -lt 11; then
1894                                 gcc_cv_as_leb128="no"
1895                         fi
1896                 fi
1897         fi
1898         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1899 fi
1900 if test x"$gcc_cv_as_leb128" = xyes; then
1901         AC_DEFINE(HAVE_AS_LEB128, 1,
1902                 [Define if your assembler supports .uleb128.])
1903 fi
1904 AC_MSG_RESULT($gcc_cv_as_leb128)
1905
1906 AC_MSG_CHECKING(assembler eh_frame optimization)
1907 gcc_cv_as_eh_frame=no
1908 if test $in_tree_gas = yes ; then
1909   gcc_GAS_VERSION_GTE_IFELSE(2,12,0,[
1910     if grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
1911       gcc_cv_as_eh_frame="yes"
1912     fi
1913   ])
1914 elif test x$gcc_cv_as != x; then
1915         # Check if this is GAS.
1916         as_ver=`$gcc_cv_as --version < /dev/null 2> /dev/null | head -1`
1917         rm -f a.out 2> /dev/null
1918         if echo "$as_ver" | grep GNU > /dev/null; then
1919                 # Versions up to and including 2.11.0 may mis-optimize
1920                 # .eh_frame data.  Try something.
1921                 cat > conftest.s <<EOF
1922         .text
1923 .LFB1:
1924         .4byte  0
1925 .L1:
1926         .4byte  0
1927 .LFE1:
1928         .section        .eh_frame,"aw",@progbits
1929 __FRAME_BEGIN__:
1930         .4byte  .LECIE1-.LSCIE1
1931 .LSCIE1:
1932         .4byte  0x0
1933         .byte   0x1
1934         .ascii "z\0"
1935         .byte   0x1
1936         .byte   0x78
1937         .byte   0x1a
1938         .byte   0x0
1939         .byte   0x4
1940         .4byte  1
1941         .p2align 1
1942 .LECIE1:
1943 .LSFDE1:
1944         .4byte  .LEFDE1-.LASFDE1
1945 .LASFDE1:
1946         .4byte  .LASFDE1-__FRAME_BEGIN__
1947         .4byte  .LFB1
1948         .4byte  .LFE1-.LFB1
1949         .byte   0x4
1950         .4byte  .LFE1-.LFB1
1951         .byte   0x4
1952         .4byte  .L1-.LFB1
1953 .LEFDE1:
1954 EOF
1955                 cat > conftest.lit <<EOF
1956  0000 10000000 00000000 017a0001 781a0004  .........z..x...
1957  0010 01000000 12000000 18000000 00000000  ................
1958  0020 08000000 04080000 0044               .........D
1959 EOF
1960                 cat > conftest.big <<EOF
1961  0000 00000010 00000000 017a0001 781a0004  .........z..x...
1962  0010 00000001 00000012 00000018 00000000  ................
1963  0020 00000008 04000000 0844               .........D
1964 EOF
1965                 # If the assembler didn't choke, and we can objdump,
1966                 # and we got the correct data, then succeed.
1967                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
1968                    && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
1969                       | tail -3 > conftest.got \
1970                    && { cmp conftest.lit conftest.got > /dev/null 2>&1 \
1971                         || cmp conftest.big conftest.got > /dev/null 2>&1; }
1972                 then
1973                         gcc_cv_as_eh_frame="yes"
1974                 else
1975                         gcc_cv_as_eh_frame="bad"
1976                         if $gcc_cv_as -o conftest.o --traditional-format /dev/null; then
1977                                 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
1978         [Define if your assembler mis-optimizes .eh_frame data.])
1979                         fi
1980                 fi
1981         fi
1982         rm -f conftest.*
1983 fi
1984 AC_MSG_RESULT($gcc_cv_as_eh_frame)
1985
1986 AC_MSG_CHECKING(assembler section merging support)
1987 gcc_cv_as_shf_merge=no
1988 if test $in_tree_gas = yes ; then
1989   gcc_GAS_VERSION_GTE_IFELSE(2,12,0,[
1990     if grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
1991       gcc_cv_as_shf_merge=yes
1992     fi
1993   ])
1994 elif test x$gcc_cv_as != x; then
1995         # Check if we support SHF_MERGE sections
1996         echo '.section .rodata.str, "aMS", @progbits, 1' > conftest.s
1997         if $gcc_cv_as --fatal-warnings -o conftest.o conftest.s > /dev/null 2>&1; then
1998                 gcc_cv_as_shf_merge=yes
1999         fi
2000         rm -f conftest.s conftest.o
2001 fi
2002 if test x"$gcc_cv_as_shf_merge" = xyes; then
2003         AC_DEFINE(HAVE_GAS_SHF_MERGE, 1,
2004 [Define if your assembler supports marking sections with SHF_MERGE flag.])
2005 fi
2006 AC_MSG_RESULT($gcc_cv_as_shf_merge)
2007
2008 AC_MSG_CHECKING(assembler thread-local storage support)
2009 gcc_cv_as_tls=no
2010 conftest_s=
2011 tls_first_major=
2012 tls_first_minor=
2013 case "$target" in
2014 changequote(,)dnl
2015   alpha*-*-*)
2016     conftest_s='
2017         .section ".tdata","awT",@progbits
2018 foo:    .long   25
2019         .text
2020         ldq     $27,__tls_get_addr($29)         !literal!1
2021         lda     $16,foo($29)                    !tlsgd!1
2022         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
2023         ldq     $27,__tls_get_addr($29)         !literal!2
2024         lda     $16,foo($29)                    !tlsldm!2
2025         jsr     $26,($27),__tls_get_addr        !lituse_tlsldm!2
2026         ldq     $1,foo($29)                     !gotdtprel
2027         ldah    $2,foo($29)                     !dtprelhi
2028         lda     $3,foo($2)                      !dtprello
2029         lda     $4,foo($29)                     !dtprel
2030         ldq     $1,foo($29)                     !gottprel
2031         ldah    $2,foo($29)                     !tprelhi
2032         lda     $3,foo($2)                      !tprello
2033         lda     $4,foo($29)                     !tprel'
2034         tls_first_major=2
2035         tls_first_minor=13
2036         ;;
2037   i[34567]86-*-*)
2038 changequote([,])dnl
2039     conftest_s='
2040         .section ".tdata","awT",@progbits
2041 foo:    .long   25
2042         .text
2043         movl    %gs:0, %eax
2044         leal    foo@TLSGD(,%ebx,1), %eax
2045         leal    foo@TLSLDM(%ebx), %eax
2046         leal    foo@DTPOFF(%eax), %edx
2047         movl    foo@GOTTPOFF(%ebx), %eax
2048         subl    foo@GOTTPOFF(%ebx), %eax
2049         addl    foo@GOTNTPOFF(%ebx), %eax
2050         movl    foo@INDNTPOFF, %eax
2051         movl    $foo@TPOFF, %eax
2052         subl    $foo@TPOFF, %eax
2053         leal    foo@NTPOFF(%ecx), %eax'
2054         tls_first_major=2
2055         tls_first_minor=14
2056         ;;
2057   x86_64-*-*)
2058     conftest_s='
2059         .section ".tdata","awT",@progbits
2060 foo:    .long   25
2061         .text
2062         movq    %fs:0, %rax
2063         leaq    foo@TLSGD(%rip), %rdi
2064         leaq    foo@TLSLD(%rip), %rdi
2065         leaq    foo@DTPOFF(%rax), %rdx
2066         movq    foo@GOTTPOFF(%rip), %rax
2067         movq    $foo@TPOFF, %rax'
2068         tls_first_major=2
2069         tls_first_minor=14
2070         ;;
2071   ia64-*-*)
2072     conftest_s='
2073         .section ".tdata","awT",@progbits
2074 foo:    data8   25
2075         .text
2076         addl    r16 = @ltoff(@dtpmod(foo#)), gp
2077         addl    r17 = @ltoff(@dtprel(foo#)), gp
2078         addl    r18 = @ltoff(@tprel(foo#)), gp
2079         addl    r19 = @dtprel(foo#), gp
2080         adds    r21 = @dtprel(foo#), r13
2081         movl    r23 = @dtprel(foo#)
2082         addl    r20 = @tprel(foo#), gp
2083         adds    r22 = @tprel(foo#), r13
2084         movl    r24 = @tprel(foo#)'
2085         tls_first_major=2
2086         tls_first_minor=13
2087         ;;
2088   s390-*-*)
2089     conftest_s='
2090         .section ".tdata","awT",@progbits
2091 foo:    .long   25
2092         .text
2093         .long   foo@TLSGD
2094         .long   foo@TLSLDM
2095         .long   foo@DTPOFF
2096         .long   foo@NTPOFF
2097         .long   foo@GOTNTPOFF
2098         .long   foo@INDNTPOFF
2099         l       %r1,foo@GOTNTPOFF(%r12)
2100         l       %r1,0(%r1):tls_load:foo
2101         bas     %r14,0(%r1,%r13):tls_gdcall:foo
2102         bas     %r14,0(%r1,%r13):tls_ldcall:foo'
2103         tls_first_major=2
2104         tls_first_minor=14
2105         ;;
2106   s390x-*-*)
2107     conftest_s='
2108         .section ".tdata","awT",@progbits
2109 foo:    .long   25
2110         .text
2111         .quad   foo@TLSGD
2112         .quad   foo@TLSLDM
2113         .quad   foo@DTPOFF
2114         .quad   foo@NTPOFF
2115         .quad   foo@GOTNTPOFF
2116         lg      %r1,foo@GOTNTPOFF(%r12)
2117         larl    %r1,foo@INDNTPOFF
2118         brasl   %r14,__tls_get_offset@PLT:tls_gdcall:foo
2119         brasl   %r14,__tls_get_offset@PLT:tls_ldcall:foo'
2120         tls_first_major=2
2121         tls_first_minor=14
2122         ;;
2123 esac
2124 if test -z "$tls_first_major"; then
2125   :
2126 elif test $in_tree_gas = yes ; then
2127   gcc_GAS_VERSION_GTE_IFELSE($tls_first_major,$tls_first_minor,0,[
2128     gcc_cv_as_tls=yes
2129   ])
2130 elif test x$gcc_cv_as != x; then
2131   echo "$conftest_s" > conftest.s
2132   if $gcc_cv_as --fatal-warnings -o conftest.o conftest.s > /dev/null 2>&1
2133   then
2134     gcc_cv_as_tls=yes
2135   fi
2136   rm -f conftest.s conftest.o
2137 fi
2138 if test "$gcc_cv_as_tls" = yes; then
2139   AC_DEFINE(HAVE_AS_TLS, 1,
2140             [Define if your assembler supports thread-local storage.])
2141 fi
2142 AC_MSG_RESULT($gcc_cv_as_tls)
2143
2144 case "$target" in
2145   # All TARGET_ABI_OSF targets.
2146   alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
2147     AC_CACHE_CHECK([assembler supports explicit relocations],
2148         gcc_cv_as_explicit_relocs, [
2149         gcc_cv_as_explicit_relocs=unknown
2150         if test $in_tree_gas = yes ; then
2151            gcc_GAS_VERSION_GTE_IFELSE(2,12,0,[
2152               gcc_cv_as_explicit_relocs=yes
2153            ])
2154         elif test x$gcc_cv_as != x; then
2155             cat > conftest.s << 'EOF'
2156         .set nomacro
2157         .text
2158         extbl   $3, $2, $3      !lituse_bytoff!1
2159         ldq     $2, a($29)      !literal!1
2160         ldq     $4, b($29)      !literal!2
2161         ldq_u   $3, 0($2)       !lituse_base!1
2162         ldq     $27, f($29)     !literal!5
2163         jsr     $26, ($27), f   !lituse_jsr!5
2164         ldah    $29, 0($26)     !gpdisp!3
2165         lda     $0, c($29)      !gprel
2166         ldah    $1, d($29)      !gprelhigh
2167         lda     $1, d($1)       !gprellow
2168         lda     $29, 0($29)     !gpdisp!3
2169 EOF
2170             if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2171                 gcc_cv_as_explicit_relocs=yes
2172             else
2173                 gcc_cv_as_explicit_relocs=no
2174             fi
2175             rm -f conftest.s conftest.o
2176         fi
2177     ])
2178     if test "x$gcc_cv_as_explicit_relocs" = xyes; then
2179         AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
2180                 [Define if your assembler supports explicit relocations.])
2181     fi
2182     ;;
2183   sparc*-*-*)
2184     AC_CACHE_CHECK([assembler .register pseudo-op support],
2185         gcc_cv_as_register_pseudo_op, [
2186         gcc_cv_as_register_pseudo_op=unknown
2187         if test x$gcc_cv_as != x; then
2188             # Check if we have .register
2189             echo ".register %g2, #scratch" > conftest.s
2190             if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2191                 gcc_cv_as_register_pseudo_op=yes
2192             else
2193                 gcc_cv_as_register_pseudo_op=no
2194             fi
2195             rm -f conftest.s conftest.o
2196         fi
2197     ])
2198     if test "x$gcc_cv_as_register_pseudo_op" = xyes; then
2199         AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
2200                 [Define if your assembler supports .register.])
2201     fi
2202
2203     AC_CACHE_CHECK([assembler supports -relax],
2204         gcc_cv_as_relax_opt, [
2205         gcc_cv_as_relax_opt=unknown
2206         if test x$gcc_cv_as != x; then
2207             # Check if gas supports -relax
2208             echo ".text" > conftest.s
2209             if $gcc_cv_as -relax -o conftest.o conftest.s > /dev/null 2>&1; then
2210                 gcc_cv_as_relax_opt=yes
2211             else
2212                 gcc_cv_as_relax_opt=no
2213             fi
2214             rm -f conftest.s conftest.o
2215         fi
2216     ])
2217     if test "x$gcc_cv_as_relax_opt" = xyes; then
2218         AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
2219                 [Define if your assembler supports -relax option.])
2220     fi
2221
2222     AC_CACHE_CHECK([assembler and linker support unaligned pc related relocs],
2223         gcc_cv_as_sparc_ua_pcrel, [
2224         gcc_cv_as_sparc_ua_pcrel=unknown
2225         if test x$gcc_cv_as != x -a x$gcc_cv_ld != x; then
2226             gcc_cv_as_sparc_ua_pcrel=no
2227             echo ".text; foo: nop; .data; .align 4; .byte 0; .uaword %r_disp32(foo)" > conftest.s
2228             if $gcc_cv_as -K PIC -o conftest.o conftest.s > /dev/null 2>&1 \
2229                && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
2230                 gcc_cv_as_sparc_ua_pcrel=yes
2231             fi
2232             rm -f conftest.s conftest.o conftest
2233         fi
2234     ])
2235     if test "x$gcc_cv_as_sparc_ua_pcrel" = xyes; then
2236         AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
2237                 [Define if your assembler and linker support unaligned PC relative relocs.])
2238     fi
2239
2240     AC_CACHE_CHECK([assembler and linker support unaligned pc related relocs against hidden symbols],
2241         gcc_cv_as_sparc_ua_pcrel_hidden, [
2242         if test "x$gcc_cv_as_sparc_ua_pcrel" = xyes; then
2243             gcc_cv_as_sparc_ua_pcrel_hidden=unknown
2244             if test x$gcc_cv_objdump != x; then
2245                 gcc_cv_as_sparc_ua_pcrel_hidden=no
2246                 echo ".data; .align 4; .byte 0x31; .uaword %r_disp32(foo)" > conftest.s
2247                 echo ".byte 0x32, 0x33, 0x34; .global foo; .hidden foo" >> conftest.s
2248                 echo "foo: .skip 4" >> conftest.s
2249                 if $gcc_cv_as -K PIC -o conftest.o conftest.s > /dev/null 2>&1 \
2250                    && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
2251                    && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
2252                       | grep ' 31000000 07323334' > /dev/null 2>&1; then
2253                     if $gcc_cv_objdump -R conftest 2> /dev/null \
2254                        | grep 'DISP32' > /dev/null 2>&1; then
2255                         :
2256                     else
2257                         gcc_cv_as_sparc_ua_pcrel_hidden=yes
2258                     fi
2259                 fi
2260             fi
2261             rm -f conftest.s conftest.o conftest
2262         else
2263             gcc_cv_as_sparc_ua_pcrel_hidden="$gcc_cv_as_sparc_ua_pcrel"
2264         fi
2265     ])
2266     if test "x$gcc_cv_as_sparc_ua_pcrel_hidden" = xyes; then
2267         AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
2268                 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])
2269     fi
2270
2271     AC_CACHE_CHECK([for assembler offsetable %lo() support],
2272         gcc_cv_as_offsetable_lo10, [
2273         gcc_cv_as_offsetable_lo10=unknown
2274         if test "x$gcc_cv_as" != x; then
2275             # Check if assembler has offsetable %lo()
2276             echo "or %g1, %lo(ab) + 12, %g1" > conftest.s
2277             echo "or %g1, %lo(ab + 12), %g1" > conftest1.s
2278             if $gcc_cv_as -xarch=v9 -o conftest.o conftest.s \
2279                     > /dev/null 2>&1 &&
2280                $gcc_cv_as -xarch=v9 -o conftest1.o conftest1.s \
2281                     > /dev/null 2>&1; then
2282                 if cmp conftest.o conftest1.o > /dev/null 2>&1; then
2283                     gcc_cv_as_offsetable_lo10=no
2284                 else
2285                     gcc_cv_as_offsetable_lo10=yes
2286                 fi
2287             else
2288                 gcc_cv_as_offsetable_lo10=no
2289             fi
2290             rm -f conftest.s conftest.o conftest1.s conftest1.o
2291         fi
2292     ])
2293     if test "x$gcc_cv_as_offsetable_lo10" = xyes; then
2294         AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
2295             [Define if your assembler supports offsetable %lo().])
2296     fi
2297
2298     ;;
2299
2300 changequote(,)dnl
2301   i[34567]86-*-* | x86_64-*-*)
2302 changequote([,])dnl
2303     AC_MSG_CHECKING(assembler instructions)
2304     gcc_cv_as_instructions=
2305     if test $in_tree_gas = yes ; then
2306       gcc_GAS_VERSION_GTE_IFELSE(2,9,0,[
2307         gcc_cv_as_instructions="filds fists"
2308       ])
2309     elif test x$gcc_cv_as != x; then
2310         set "filds fists" "filds mem; fists mem"
2311         while test $# -gt 0
2312         do
2313                 echo "$2" > conftest.s
2314                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2315                         gcc_cv_as_instructions=${gcc_cv_as_instructions}$1" "
2316                 fi
2317                 shift 2
2318         done
2319         rm -f conftest.s conftest.o
2320     fi
2321     if test x"$gcc_cv_as_instructions" != x; then
2322         AC_DEFINE_UNQUOTED(HAVE_GAS_`echo "$gcc_cv_as_instructions" | sed -e 's/ $//' | tr '[a-z ]' '[A-Z_]'`)
2323     fi
2324     AC_MSG_RESULT($gcc_cv_as_instructions)
2325
2326     AC_MSG_CHECKING(assembler GOTOFF in data directives)
2327     gcc_cv_as_gotoff_in_data=no
2328     if test $in_tree_gas = yes ; then
2329       gcc_GAS_VERSION_GTE_IFELSE(2,11,0,[
2330         gcc_cv_as_gotoff_in_data=yes
2331       ])
2332     elif test x$gcc_cv_as != x; then
2333         cat > conftest.s <<EOF
2334         .text
2335 .L0:
2336         nop
2337         .data
2338         .long .L0@GOTOFF
2339 EOF
2340         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2341           gcc_cv_as_gotoff_in_data=yes
2342         fi
2343     fi
2344     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
2345       [`if test $gcc_cv_as_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
2346       [Define true if the assembler supports '.long foo@GOTOFF'.])
2347     AC_MSG_RESULT($gcc_cv_as_gotoff_in_data)
2348     ;;
2349
2350   ia64*-*-*)
2351     AC_CACHE_CHECK([assembler supports ltoffx and ldxmov],
2352         gcc_cv_as_ltoffx_ldxmov_relocs, [
2353         gcc_cv_as_ltoffx_ldxmov_relocs=unknown
2354         if test $in_tree_gas = yes ; then
2355           gcc_GAS_VERSION_GTE_IFELSE(2,14,0,[
2356             gcc_cv_as_ltoffx_ldxmov_relocs=yes
2357           ])
2358         elif test x$gcc_cv_as != x; then
2359             cat > conftest.s << 'EOF'
2360 changequote(,)dnl
2361         .text
2362         addl r15 = @ltoffx(x#), gp
2363         ;;
2364         ld8.mov r16 = [r15], x#
2365 EOF
2366 changequote([,])dnl
2367             if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2368                 gcc_cv_as_ltoffx_ldxmov_relocs=yes
2369             else
2370                 gcc_cv_as_ltoffx_ldxmov_relocs=no
2371             fi
2372             rm -f conftest.s conftest.o
2373         fi
2374     ])
2375     if test "x$gcc_cv_as_ltoffx_ldxmov_relocs" = xyes; then
2376         AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
2377           [Define if your assembler supports ltoffx and ldxmov relocations.])
2378     fi
2379     ;;
2380 esac
2381
2382 AC_MSG_CHECKING(assembler dwarf2 debug_line support)
2383 gcc_cv_as_dwarf2_debug_line=no
2384 # ??? Not all targets support dwarf2 debug_line, even within a version
2385 # of gas.  Moreover, we need to emit a valid instruction to trigger any
2386 # info to the output file.  So, as supported targets are added to gas 2.11,
2387 # add some instruction here to (also) show we expect this might work.
2388 # ??? Once 2.11 is released, probably need to add first known working
2389 # version to the per-target configury.
2390 case "$target" in
2391   i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* \
2392   | x86_64*-*-* | hppa*-*-* | arm*-*-* | strongarm*-*-* | xscale*-*-*)
2393     insn="nop"
2394     ;;
2395   ia64*-*-*)
2396     insn="nop 0"
2397     ;;
2398   esac
2399 if test $in_tree_gas = yes ; then
2400   gcc_GAS_VERSION_GTE_IFELSE(2,11,0,[
2401     if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2402         && test x"$insn" != x ; then
2403       gcc_cv_as_dwarf2_debug_line="yes"
2404     fi
2405   ])
2406 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2407         echo '  .file 1 "conftest.s"' > conftest.s
2408         echo '  .loc 1 3 0' >> conftest.s
2409         echo "  $insn" >> conftest.s
2410         # ??? This fails with non-gnu grep.
2411         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
2412            && grep debug_line conftest.o > /dev/null 2>&1 ; then
2413                 # The .debug_line file table must be in the exact order that
2414                 # we specified the files, since these indices are also used
2415                 # by DW_AT_decl_file.  Approximate this test by testing if
2416                 # the assembler bitches if the same index is assigned twice.
2417                 echo '  .file 1 "foo.s"' > conftest.s
2418                 echo '  .file 1 "bar.s"' >> conftest.s
2419                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1
2420                 then
2421                   gcc_cv_as_dwarf2_debug_line="no"
2422                 else
2423                   gcc_cv_as_dwarf2_debug_line="yes"
2424                 fi
2425         fi
2426         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
2427 fi
2428 if test x"$gcc_cv_as_dwarf2_debug_line" = xyes; then
2429         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
2430 [Define if your assembler supports dwarf2 .file/.loc directives,
2431    and preserves file table indices exactly as given.])
2432 fi
2433 AC_MSG_RESULT($gcc_cv_as_dwarf2_debug_line)
2434
2435 AC_MSG_CHECKING(assembler --gdwarf2 support)
2436 gcc_cv_as_gdwarf2_flag=no
2437 if test $in_tree_gas = yes ; then
2438   gcc_GAS_VERSION_GTE_IFELSE(2,11,0,[
2439     if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2440         && test x"$insn" != x ; then
2441       gcc_cv_as_gdwarf2_flag="yes"
2442     fi
2443   ])
2444 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2445         echo '' > conftest.s
2446         # ??? This fails with non-gnu grep.
2447         if $gcc_cv_as --gdwarf2 -o conftest.o conftest.s > /dev/null 2>&1
2448           then
2449           gcc_cv_as_gdwarf2_flag="yes"
2450         fi
2451         rm -f conftest.s conftest.o
2452 fi
2453 if test x"$gcc_cv_as_gdwarf2_flag" = xyes; then
2454         AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
2455 [Define if your assembler supports the --gdwarf2 option.])
2456 fi
2457 AC_MSG_RESULT($gcc_cv_as_gdwarf2_flag)
2458
2459 AC_MSG_CHECKING(assembler --gstabs support)
2460 gcc_cv_as_gstabs_flag=no
2461 if test $in_tree_gas = yes ; then
2462   gcc_GAS_VERSION_GTE_IFELSE(2,11,0,[
2463     if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2464         && test x"$insn" != x ; then
2465       gcc_cv_as_gstabs_flag="yes"
2466     fi
2467   ])
2468 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2469         echo '' > conftest.s
2470         # ??? This fails with non-gnu grep.
2471         if $gcc_cv_as --gstabs -o conftest.o conftest.s > /dev/null 2>&1 ; then
2472           gcc_cv_as_gstabs_flag="yes"
2473         fi
2474         rm -f conftest.s conftest.o
2475 fi
2476 if test x"$gcc_cv_as_gstabs_flag" = xyes; then
2477         AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
2478 [Define if your assembler supports the --gstabs option.])
2479 fi
2480 AC_MSG_RESULT($gcc_cv_as_gstabs_flag)
2481
2482 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2483 gcc_cv_ld_ro_rw_mix=unknown
2484 if test $in_tree_ld = yes ; then
2485   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
2486     gcc_cv_ld_ro_rw_mix=read-write
2487   fi
2488 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2489   echo '.section "myfoosect", "a"' > conftest1.s
2490   echo '.section "myfoosect", "aw"' > conftest2.s
2491   echo '.byte 1' >> conftest2.s
2492   echo '.section "myfoosect", "a"' > conftest3.s
2493   echo '.byte 0' >> conftest3.s
2494   if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2495      && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2496      && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2497      && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2498         conftest2.o conftest3.o; then
2499     gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2500                          | grep -A1 myfoosect`
2501     if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2502       if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2503         gcc_cv_ld_ro_rw_mix=read-only
2504       else
2505         gcc_cv_ld_ro_rw_mix=read-write
2506       fi
2507     fi
2508   fi
2509 changequote(,)dnl
2510   rm -f conftest.* conftest[123].*
2511 changequote([,])dnl
2512 fi
2513 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2514         AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2515   [Define if your linker links a mix of read-only
2516    and read-write sections into a read-write section.])
2517 fi
2518 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2519
2520 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
2521 gcc_cv_ld_eh_frame_hdr=no
2522 if test $in_tree_ld = yes ; then
2523   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
2524     gcc_cv_ld_eh_frame_hdr=yes
2525   fi
2526 elif test x$gcc_cv_ld != x; then
2527         # Check if linker supports --eh-frame-hdr option
2528         if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
2529                 gcc_cv_ld_eh_frame_hdr=yes
2530         fi
2531 fi
2532 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
2533         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
2534 [Define if your linker supports --eh-frame-hdr option.])
2535 fi
2536 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
2537
2538 # Miscellaneous target-specific checks.
2539 case "$target" in
2540   mips*-*-*)
2541     AC_MSG_CHECKING(whether libgloss uses STARTUP directives consistently)
2542     gcc_cv_mips_libgloss_startup=no
2543     gcc_cv_libgloss_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/libgloss
2544     if test "x$exec_prefix" = xNONE; then
2545       if test "x$prefix" = xNONE; then
2546         test_prefix=/usr/local
2547       else
2548         test_prefix=$prefix
2549       fi
2550     else
2551       test_prefix=$exec_prefix
2552     fi
2553     for f in $gcc_cv_libgloss_srcdir/mips/idt.ld $test_prefix/$target_alias/lib/idt.ld
2554     do
2555       if grep '^STARTUP' $f > /dev/null 2>&1; then
2556         gcc_cv_mips_libgloss_startup=yes
2557         break
2558       fi
2559     done
2560     if test x"$gcc_cv_mips_libgloss_startup" = xyes; then
2561       AC_DEFINE(HAVE_MIPS_LIBGLOSS_STARTUP_DIRECTIVES, 1,
2562         [Define if your MIPS libgloss linker scripts consistently include STARTUP directives.])
2563     fi
2564     AC_MSG_RESULT($gcc_cv_mips_libgloss_startup)
2565     ;;
2566 esac
2567
2568 if test x$with_sysroot = x && test x$host = x$target \
2569    && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" ; then
2570   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include")
2571 fi
2572
2573 # Figure out what language subdirectories are present.
2574 # Look if the user specified --enable-languages="..."; if not, use
2575 # the environment variable $LANGUAGES if defined. $LANGUAGES might
2576 # go away some day.
2577 # NB:  embedded tabs in this IF block -- do not untabify
2578 if test x"${enable_languages+set}" != xset; then
2579         if test x"${LANGUAGES+set}" = xset; then
2580                 enable_languages="${LANGUAGES}"
2581                 AC_MSG_WARN([setting LANGUAGES is deprecated, use --enable-languages instead])
2582
2583         else
2584                 enable_languages=all
2585         fi
2586 else
2587         if test x"${enable_languages}" = x \
2588         || test x"${enable_languages}" = xyes;
2589         then
2590                 AC_MSG_ERROR([--enable-languages needs at least one language argument])
2591         fi
2592 fi
2593 enable_languages=`echo "${enable_languages}" | sed -e 's/[[     ,]][[   ,]]*/,/g' -e 's/,$//'`
2594
2595 # First scan to see if an enabled language requires some other language.
2596 # We assume that a given config-lang.in will list all the language
2597 # front ends it requires, even if some are required indirectly.
2598 for lang in ${srcdir}/*/config-lang.in ..
2599 do
2600    case $lang in
2601     ..)
2602        ;;
2603     # The odd quoting in the next line works around
2604     # an apparent bug in bash 1.12 on linux.
2605 changequote(,)dnl
2606     ${srcdir}/[*]/config-lang.in)
2607        ;;
2608     *)
2609        lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^      ]*\).*$,\1,p' $lang`
2610        this_lang_requires=`sed -n -e 's,^lang_requires=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^lang_requires=\([^    ]*\).*$,\1,p' $lang`
2611        for other in $this_lang_requires
2612        do
2613           case ,${enable_languages}, in
2614            *,$other,*)
2615               ;;
2616            *,all,*)
2617               ;;
2618            *,$lang_alias,*)
2619               enable_languages="$enable_languages,$other"
2620               ;;
2621           esac
2622        done
2623        ;;
2624 changequote([,])dnl
2625    esac
2626 done
2627
2628 expected_languages=`echo ,${enable_languages}, | sed -e 's:,: :g' -e 's:  *: :g' -e 's:  *: :g' -e 's:^ ::' -e 's: $::'`
2629 found_languages=
2630 subdirs=
2631 for lang in ${srcdir}/*/config-lang.in ..
2632 do
2633         case $lang in
2634         ..) ;;
2635         # The odd quoting in the next line works around
2636         # an apparent bug in bash 1.12 on linux.
2637 changequote(,)dnl
2638         ${srcdir}/[*]/config-lang.in) ;;
2639         *)
2640           lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
2641           this_lang_libs=`sed -n -e 's,^target_libs=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^target_libs=\([^         ]*\).*$,\1,p' $lang`
2642           build_by_default=`sed -n -e 's,^build_by_default=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^build_by_default=\([^     ]*\).*$,\1,p' $lang`
2643           if test "x$lang_alias" = x
2644           then
2645                 echo "$lang doesn't set \$language." 1>&2
2646                 exit 1
2647           fi
2648           case ${build_by_default},${enable_languages}, in
2649           *,$lang_alias,*) add_this_lang=yes ;;
2650           no,*) add_this_lang=no ;;
2651           *,all,*) add_this_lang=yes ;;
2652           *) add_this_lang=no ;;
2653           esac
2654           found_languages="${found_languages} ${lang_alias}"
2655           if test x"${add_this_lang}" = xyes; then
2656                 case $lang in
2657                     ${srcdir}/ada/config-lang.in)
2658                         if test x$have_gnat = xyes ; then
2659                                 subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2660                         fi
2661                         ;;
2662                     *)
2663                         subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2664                         ;;
2665                 esac
2666           fi
2667           ;;
2668 changequote([,])dnl
2669         esac
2670 done
2671
2672 missing_languages=
2673 for expected_language in ${expected_languages} ..
2674 do
2675     if test "${expected_language}" != ..; then
2676         missing_language="${expected_language}"
2677         if test "${expected_language}" = "c" \
2678            || test "${expected_language}" = "all"; then
2679                 missing_language=
2680         fi
2681         for found_language in ${found_languages} ..
2682         do
2683             if test "${found_language}" != ..; then
2684                 if test "${expected_language}" = "${found_language}"; then
2685                     missing_language=
2686                 fi
2687             fi
2688         done
2689         if test "x${missing_language}" != x; then
2690            missing_languages="${missing_languages} ${missing_language}"
2691         fi
2692     fi
2693 done
2694
2695 if test "x$missing_languages" != x; then
2696   AC_MSG_ERROR([
2697 The following requested languages were not found:${missing_languages}
2698 The following languages were available: c${found_languages}])
2699 fi
2700
2701 # Make gthr-default.h if we have a thread file.
2702 gthread_flags=
2703 if test $thread_file != single; then
2704     rm -f gthr-default.h
2705     echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h
2706     gthread_flags=-DHAVE_GTHR_DEFAULT
2707 fi
2708 AC_SUBST(gthread_flags)
2709
2710 # Find out what GC implementation we want, or may, use.
2711 AC_ARG_WITH(gc,
2712 [  --with-gc={simple,page} choose the garbage collection mechanism to use
2713                           with the compiler],
2714 [case "$withval" in
2715   simple | page)
2716     GGC=ggc-$withval
2717     ;;
2718   *)
2719     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
2720     ;;
2721 esac],
2722 [GGC=ggc-page])
2723 AC_SUBST(GGC)
2724 echo "Using $GGC for garbage collection."
2725
2726 # Use the system's zlib library.
2727 zlibdir=-L../zlib
2728 zlibinc="-I\$(srcdir)/../zlib"
2729 AC_ARG_WITH(system-zlib,
2730 [  --with-system-zlib      use installed libz],
2731 zlibdir=
2732 zlibinc=
2733 )
2734 AC_SUBST(zlibdir)
2735 AC_SUBST(zlibinc)
2736
2737 dnl Very limited version of automake's enable-maintainer-mode
2738
2739 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
2740   dnl maintainer-mode is disabled by default
2741   AC_ARG_ENABLE(maintainer-mode,
2742 [  --enable-maintainer-mode
2743                           enable make rules and dependencies not useful
2744                           (and sometimes confusing) to the casual installer],
2745       maintainer_mode=$enableval,
2746       maintainer_mode=no)
2747
2748 AC_MSG_RESULT($maintainer_mode)
2749
2750 if test "$maintainer_mode" = "yes"; then
2751   MAINT=''
2752 else
2753   MAINT='#'
2754 fi
2755 AC_SUBST(MAINT)dnl
2756
2757 # Make empty files to contain the specs and options for each language.
2758 # Then add #include lines to for a compiler that has specs and/or options.
2759
2760 lang_specs_files=
2761 lang_options_files=
2762 lang_tree_files=
2763 for subdir in . $subdirs
2764 do
2765         if test -f $srcdir/$subdir/lang-specs.h; then
2766             lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
2767         fi
2768         if test -f $srcdir/$subdir/lang-options.h; then
2769             lang_options_files="$lang_options_files $srcdir/$subdir/lang-options.h"
2770         fi
2771         if test -f $srcdir/$subdir/$subdir-tree.def; then
2772             lang_tree_files="$lang_tree_files $srcdir/$subdir/$subdir-tree.def"
2773         fi
2774 done
2775
2776 # These (without "all_") are set in each config-lang.in.
2777 # `language' must be a single word so is spelled singularly.
2778 all_languages=
2779 all_boot_languages=
2780 all_compilers=
2781 all_stagestuff=
2782 all_outputs='Makefile intl/Makefile fixinc/Makefile gccbug mklibgcc mkheaders'
2783 # List of language makefile fragments.
2784 all_lang_makefiles=
2785 # Files for gengtype
2786 all_gtfiles="$target_gtfiles"
2787 # Files for gengtype with language
2788 all_gtfiles_files_langs=
2789 all_gtfiles_files_files=
2790
2791 # Add the language fragments.
2792 # Languages are added via two mechanisms.  Some information must be
2793 # recorded in makefile variables, these are defined in config-lang.in.
2794 # We accumulate them and plug them into the main Makefile.
2795 # The other mechanism is a set of hooks for each of the main targets
2796 # like `clean', `install', etc.
2797
2798 language_fragments="Make-lang"
2799 language_hooks="Make-hooks"
2800
2801 for s in .. $subdirs
2802 do
2803         if test $s != ".."
2804         then
2805                 language=
2806                 boot_language=
2807                 compilers=
2808                 stagestuff=
2809                 outputs=
2810                 gtfiles=
2811                 . ${srcdir}/$s/config-lang.in
2812                 if test "x$language" = x
2813                 then
2814                         echo "${srcdir}/$s/config-lang.in doesn't set \$language." 1>&2
2815                         exit 1
2816                 fi
2817                 all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Make-lang.in"
2818                 if test -f ${srcdir}/$s/Makefile.in
2819                 then all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Makefile.in"
2820                 fi
2821                 all_languages="$all_languages $language"
2822                 if test "x$boot_language" = xyes
2823                 then
2824                         all_boot_languages="$all_boot_languages $language"
2825                 fi
2826                 all_compilers="$all_compilers $compilers"
2827                 all_stagestuff="$all_stagestuff $stagestuff"
2828                 all_outputs="$all_outputs $outputs"
2829                 all_gtfiles="$all_gtfiles $gtfiles"
2830                 for f in .. $gtfiles
2831                 do
2832                      if test $f != ".."
2833                      then
2834                          all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2835                          all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2836                      fi
2837                 done
2838         fi
2839 done
2840
2841 # Pick up gtfiles for c
2842 gtfiles=
2843 s="c"
2844 . ${srcdir}/c-config-lang.in
2845 all_gtfiles="$all_gtfiles $gtfiles"
2846 for f in .. $gtfiles
2847 do
2848      if test $f != ".."
2849      then
2850         all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2851         all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2852      fi
2853 done
2854
2855 check_languages=
2856 for language in .. $all_languages
2857 do
2858         if test $language != ".."
2859         then
2860                 check_languages="$check_languages check-$language"
2861         fi
2862 done
2863
2864 # Since we can't use `::' targets, we link each language in
2865 # with a set of hooks, reached indirectly via lang.${target}.
2866
2867 rm -f Make-hooks
2868 touch Make-hooks
2869 target_list="all.build all.cross start.encap rest.encap tags \
2870         info dvi generated-manpages \
2871         install-normal install-common install-info install-man \
2872         uninstall \
2873         mostlyclean clean distclean extraclean maintainer-clean \
2874         stage1 stage2 stage3 stage4"
2875 for t in $target_list
2876 do
2877         x=
2878         for lang in .. $all_languages
2879         do
2880                 if test $lang != ".."; then
2881                         x="$x $lang.$t"
2882                 fi
2883         done
2884         echo "lang.$t: $x" >> Make-hooks
2885 done
2886
2887 # Create .gdbinit.
2888
2889 echo "dir ." > .gdbinit
2890 echo "dir ${srcdir}" >> .gdbinit
2891 if test x$gdb_needs_out_file_path = xyes
2892 then
2893         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
2894 fi
2895 if test "x$subdirs" != x; then
2896         for s in $subdirs
2897         do
2898                 echo "dir ${srcdir}/$s" >> .gdbinit
2899         done
2900 fi
2901 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
2902
2903 # If $(exec_prefix) exists and is not the same as $(prefix), then compute an
2904 # absolute path for gcc_tooldir based on inserting the number of up-directory
2905 # movements required to get from $(exec_prefix) to $(prefix) into the basic
2906 # $(libsubdir)/@(unlibsubdir) based path.
2907 # Don't set gcc_tooldir to tooldir since that's only passed in by the toplevel
2908 # make and thus we'd get different behavior depending on where we built the
2909 # sources.
2910 if test x$exec_prefix = xNONE -o x$exec_prefix = x$prefix; then
2911     gcc_tooldir='$(libsubdir)/$(unlibsubdir)/../$(target_alias)'
2912 else
2913 changequote(<<, >>)dnl
2914 # An explanation of the sed strings:
2915 #  -e 's|^\$(prefix)||'   matches and eliminates 'prefix' from 'exec_prefix'
2916 #  -e 's|/$||'            match a trailing forward slash and eliminates it
2917 #  -e 's|^[^/]|/|'        forces the string to start with a forward slash (*)
2918 #  -e 's|/[^/]*|../|g'    replaces each occurrence of /<directory> with ../
2919 #
2920 # (*) Note this pattern overwrites the first character of the string
2921 # with a forward slash if one is not already present.  This is not a
2922 # problem because the exact names of the sub-directories concerned is
2923 # unimportant, just the number of them matters.
2924 #
2925 # The practical upshot of these patterns is like this:
2926 #
2927 #  prefix     exec_prefix        result
2928 #  ------     -----------        ------
2929 #   /foo        /foo/bar          ../
2930 #   /foo/       /foo/bar          ../
2931 #   /foo        /foo/bar/         ../
2932 #   /foo/       /foo/bar/         ../
2933 #   /foo        /foo/bar/ugg      ../../
2934 #
2935     dollar='$$'
2936     gcc_tooldir="\$(libsubdir)/\$(unlibsubdir)/\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/\$(dollar)||' -e 's|^[^/]|/|' -e 's|/[^/]*|../|g'\`\$(target_alias)"
2937 changequote([, ])dnl
2938 fi
2939 AC_SUBST(gcc_tooldir)
2940 AC_SUBST(dollar)
2941
2942 # Find a directory in which to install a shared libgcc.
2943
2944 AC_ARG_ENABLE(version-specific-runtime-libs,
2945 [  --enable-version-specific-runtime-libs
2946                           specify that runtime libraries should be
2947                           installed in a compiler-specific directory])
2948
2949 AC_ARG_WITH(slibdir,
2950 [  --with-slibdir=DIR      shared libraries in DIR [LIBDIR]],
2951 slibdir="$with_slibdir",
2952 if test "${enable_version_specific_runtime_libs+set}" = set; then
2953   slibdir='$(libsubdir)'
2954 elif test "$host" != "$target"; then
2955   slibdir='$(build_tooldir)/lib'
2956 else
2957   slibdir='$(libdir)'
2958 fi)
2959 AC_SUBST(slibdir)
2960
2961 objdir=`${PWDCMD-pwd}`
2962 AC_SUBST(objdir)
2963
2964 # Process the language and host/target makefile fragments.
2965 ${CONFIG_SHELL-/bin/sh} $srcdir/configure.frag $srcdir "$subdirs" "$dep_host_xmake_file" "$dep_tmake_file"
2966
2967 # Substitute configuration variables
2968 AC_SUBST(subdirs)
2969 AC_SUBST(srcdir)
2970 AC_SUBST(all_boot_languages)
2971 AC_SUBST(all_compilers)
2972 AC_SUBST(all_gtfiles)
2973 AC_SUBST(all_gtfiles_files_langs)
2974 AC_SUBST(all_gtfiles_files_files)
2975 AC_SUBST(all_lang_makefiles)
2976 AC_SUBST(all_languages)
2977 AC_SUBST(all_stagestuff)
2978 AC_SUBST(build_exeext)
2979 AC_SUBST(build_install_headers_dir)
2980 AC_SUBST(build_xm_file_list)
2981 AC_SUBST(build_xm_file)
2982 AC_SUBST(build_xm_defines)
2983 AC_SUBST(check_languages)
2984 AC_SUBST(cc_set_by_configure)
2985 AC_SUBST(quoted_cc_set_by_configure)
2986 AC_SUBST(cpp_install_dir)
2987 AC_SUBST(dep_host_xmake_file)
2988 AC_SUBST(dep_tmake_file)
2989 AC_SUBST(extra_headers_list)
2990 AC_SUBST(extra_objs)
2991 AC_SUBST(extra_parts)
2992 AC_SUBST(extra_passes)
2993 AC_SUBST(extra_programs)
2994 AC_SUBST(float_h_file)
2995 AC_SUBST(gcc_config_arguments)
2996 AC_SUBST(gcc_gxx_include_dir)
2997 AC_SUBST(libstdcxx_incdir)
2998 AC_SUBST(gcc_version)
2999 AC_SUBST(gcc_version_full)
3000 AC_SUBST(gcc_version_trigger)
3001 AC_SUBST(host_exeext)
3002 AC_SUBST(host_extra_gcc_objs)
3003 AC_SUBST(host_xm_file_list)
3004 AC_SUBST(host_xm_file)
3005 AC_SUBST(host_xm_defines)
3006 AC_SUBST(out_host_hook_obj)
3007 AC_SUBST(install)
3008 AC_SUBST(lang_options_files)
3009 AC_SUBST(lang_specs_files)
3010 AC_SUBST(lang_tree_files)
3011 AC_SUBST(local_prefix)
3012 AC_SUBST(md_file)
3013 AC_SUBST(objc_boehm_gc)
3014 AC_SUBST(out_file)
3015 AC_SUBST(out_object_file)
3016 AC_SUBST(stage_prefix_set_by_configure)
3017 AC_SUBST(quoted_stage_prefix_set_by_configure)
3018 AC_SUBST(symbolic_link)
3019 AC_SUBST(thread_file)
3020 AC_SUBST(tm_file_list)
3021 AC_SUBST(tm_file)
3022 AC_SUBST(tm_defines)
3023 AC_SUBST(tm_p_file_list)
3024 AC_SUBST(tm_p_file)
3025 AC_SUBST(xm_file)
3026 AC_SUBST(xm_defines)
3027 AC_SUBST(target_alias)
3028 AC_SUBST(c_target_objs)
3029 AC_SUBST(cxx_target_objs)
3030 AC_SUBST(target_cpu_default)
3031
3032 AC_SUBST_FILE(target_overrides)
3033 AC_SUBST_FILE(host_overrides)
3034 AC_SUBST_FILE(language_fragments)
3035 AC_SUBST_FILE(language_hooks)
3036
3037 # Echo that links are built
3038 if test x$host = x$target
3039 then
3040         str1="native "
3041 else
3042         str1="cross-"
3043         str2=" from $host"
3044 fi
3045
3046 if test x$host != x$build
3047 then
3048         str3=" on a $build system"
3049 fi
3050
3051 if test "x$str2" != x || test "x$str3" != x
3052 then
3053         str4=
3054 fi
3055
3056 echo "Links are now set up to build a ${str1}compiler for ${target}$str4" 1>&2
3057
3058 if test "x$str2" != x || test "x$str3" != x
3059 then
3060         echo " ${str2}${str3}." 1>&2
3061 fi
3062
3063 # Truncate the target if necessary
3064 if test x$host_truncate_target != x; then
3065         target=`echo $target | sed -e 's/\(..............\).*/\1/'`
3066 fi
3067
3068 # Configure the subdirectories
3069 # AC_CONFIG_SUBDIRS($subdirs)
3070
3071 # Create the Makefile
3072 # and configure language subdirectories
3073 AC_OUTPUT($all_outputs,
3074 [
3075 case x$CONFIG_HEADERS in
3076 xauto-host.h:config.in)
3077 echo > cstamp-h ;;
3078 esac
3079 # If the host supports symlinks, point stage[1234] at ../stage[1234] so
3080 # bootstrapping and the installation procedure can still use
3081 # CC="stage1/xgcc -Bstage1/".  If the host doesn't support symlinks,
3082 # FLAGS_TO_PASS has been modified to solve the problem there.
3083 # This is virtually a duplicate of what happens in configure.lang; we do
3084 # an extra check to make sure this only happens if ln -s can be used.
3085 if test "$symbolic_link" = "ln -s"; then
3086  for d in .. ${subdirs} fixinc ; do
3087    if test $d != ..; then
3088         STARTDIR=`${PWDCMD-pwd}`
3089         cd $d
3090         for t in stage1 stage2 stage3 stage4 include
3091         do
3092                 rm -f $t
3093                 $symbolic_link ../$t $t 2>/dev/null
3094         done
3095         cd $STARTDIR
3096    fi
3097  done
3098 else true ; fi
3099 # Avoid having to add intl to our include paths.
3100 if test -f intl/libintl.h; then
3101   echo creating libintl.h
3102   echo '#include "intl/libintl.h"' >libintl.h
3103 fi
3104 ],
3105 [subdirs='$subdirs'
3106 symbolic_link='$symbolic_link'
3107 ])