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