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