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