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(void *)
 253 AC_COMPILE_CHECK_SIZEOF(short)
 254 AC_COMPILE_CHECK_SIZEOF(int)
 255 AC_COMPILE_CHECK_SIZEOF(long)
 256 if test $ac_cv_c_long_long = yes; then
 257   AC_COMPILE_CHECK_SIZEOF(long long)
 258 fi
 259 if test $ac_cv_c___int64 = yes; then
 260   AC_COMPILE_CHECK_SIZEOF(__int64)
 261 fi
 262
 263 # -----------------
 264 # Find Ada compiler
 265 # -----------------
 266
 267 # See if GNAT has been installed
 268 gcc_AC_PROG_GNAT
 269
 270 if test x$have_gnat != xno ; then
 271 AC_CACHE_CHECK(whether ${ADAC} accepts -Wno-long-long,
 272 ac_cv_prog_adac_no_long_long,
 273 [cat >conftest.adb <<EOF
 274 procedure conftest is begin null; end conftest;
 275 EOF
 276 if $ADAC -Wno-long-long -c conftest.adb 1>&5 2>&5 ; then
 277   ac_cv_prog_adac_no_long_long=yes
 278 else
 279   ac_cv_prog_adac_no_long_long=no
 280 fi
 281 rm -f conftest*])
 282 else
 283   ac_cv_prog_adac_no_long_long=yes
 284 fi
 285
 286 # ---------------------
 287 # Warnings and checking
 288 # ---------------------
 289
 290 strict1_warn=
 291 if test $ac_cv_prog_cc_no_long_long = yes && \
 292     test $ac_cv_prog_adac_no_long_long = yes ; then
 293   strict1_warn="-pedantic -Wno-long-long"
 294 fi
 295 AC_SUBST(strict1_warn)
 296
 297 # If the native compiler is GCC, we can enable warnings even in stage1.
 298 # That's useful for people building cross-compilers, or just running a
 299 # quick `make'.
 300 warn_cflags=
 301 if test "x$GCC" = "xyes"; then
 302   warn_cflags='$(GCC_WARN_CFLAGS)'
 303 fi
 304 AC_SUBST(warn_cflags)
 305
 306 # Enable -Werror in bootstrap stage2 and later.
 307 # Change the default to "no" on release branches.
 308 AC_ARG_ENABLE(werror,
 309 [  --enable-werror         enable -Werror in bootstrap stage2 and later], [],
 310 [enable_werror=yes])
 311 if test x$enable_werror = xyes ; then
 312   WERROR=-Werror
 313 fi
 314 AC_SUBST(WERROR)
 315
 316 # Enable expensive internal checks
 317 AC_ARG_ENABLE(checking,
 318 [  --enable-checking[=LIST]
 319                           enable expensive run-time checks.  With LIST,
 320                           enable only specific categories of checks.
 321                           Categories are: misc,tree,rtl,rtlflag,gc,gcac;
 322                           default is misc,tree,gc,rtlflag],
 323 [ac_checking=
 324 ac_tree_checking=
 325 ac_rtl_checking=
 326 ac_rtlflag_checking=
 327 ac_gc_checking=
 328 ac_gc_always_collect=
 329 case "${enableval}" in
 330 yes)    ac_checking=1 ; ac_tree_checking=1 ; ac_gc_checking=1 ;
 331         ac_rtlflag_checking=1 ;;
 332 no)     ;;
 333 *)      IFS="${IFS=     }"; ac_save_IFS="$IFS"; IFS="$IFS,"
 334         set fnord $enableval; shift
 335         IFS="$ac_save_IFS"
 336         for check
 337         do
 338                 case $check in
 339                 misc)   ac_checking=1 ;;
 340                 tree)   ac_tree_checking=1 ;;
 341                 rtlflag)        ac_rtlflag_checking=1 ;;
 342                 rtl)    ac_rtl_checking=1 ;;
 343                 gc)     ac_gc_checking=1 ;;
 344                 gcac)   ac_gc_always_collect=1 ;;
 345                 valgrind)       ac_checking_valgrind=1 ;;
 346                 *)      AC_MSG_ERROR(unknown check category $check) ;;
 347                 esac
 348         done
 349         ;;
 350 esac
 351 ],
 352 # Enable some checks by default for development versions of GCC
 353 [ac_checking=1; ac_tree_checking=1; ac_gc_checking=1; ac_rtlflag_checking=1;])
 354 nocommon_flag=""
 355 if test x$ac_checking != x ; then
 356   AC_DEFINE(ENABLE_CHECKING, 1,
 357 [Define if you want more run-time sanity checks.  This one gets a grab
 358    bag of miscellaneous but relatively cheap checks.])
 359   nocommon_flag=-fno-common
 360 fi
 361 AC_SUBST(nocommon_flag)
 362 if test x$ac_tree_checking != x ; then
 363   AC_DEFINE(ENABLE_TREE_CHECKING, 1,
 364 [Define if you want all operations on trees (the basic data
 365    structure of the front ends) to be checked for dynamic type safety
 366    at runtime.  This is moderately expensive.])
 367 fi
 368 if test x$ac_rtl_checking != x ; then
 369   AC_DEFINE(ENABLE_RTL_CHECKING, 1,
 370 [Define if you want all operations on RTL (the basic data structure
 371    of the optimizer and back end) to be checked for dynamic type safety
 372    at runtime.  This is quite expensive.])
 373 fi
 374 if test x$ac_rtlflag_checking != x ; then
 375   AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
 376 [Define if you want RTL flag accesses to be checked against the RTL
 377    codes that are supported for each access macro.  This is relatively
 378    cheap.])
 379 fi
 380 if test x$ac_gc_checking != x ; then
 381   AC_DEFINE(ENABLE_GC_CHECKING, 1,
 382 [Define if you want the garbage collector to do object poisoning and
 383    other memory allocation checks.  This is quite expensive.])
 384 fi
 385 if test x$ac_gc_always_collect != x ; then
 386   AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
 387 [Define if you want the garbage collector to operate in maximally
 388    paranoid mode, validating the entire heap and collecting garbage at
 389    every opportunity.  This is extremely expensive.])
 390 fi
 391 valgrind_path_defines=
 392 valgrind_command=
 393 if test x$ac_checking_valgrind != x ; then
 394   # It is certainly possible that there's valgrind but no valgrind.h.
 395   # GCC relies on making annotations so we must have both.
 396   AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
 397   AC_TRY_CPP(
 398     [#include <memcheck.h>
 399 #ifndef VALGRIND_DISCARD
 400 #error VALGRIND_DISCARD not defined
 401 #endif],
 402   [gcc_cv_header_memcheck_h=yes],
 403   gcc_cv_header_memcheck_h=no)
 404   AC_MSG_RESULT($gcc_cv_header_memcheck_h)
 405   AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
 406   AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
 407         [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
 408   if test "x$valgrind_path" = "x" || (test $have_valgrind_h = no && test $gcc_cv_header_memcheck_h = no); then
 409         AC_MSG_ERROR([*** Can't find both valgrind and valgrind.h/memcheck.h])
 410   fi
 411   valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
 412   valgrind_command="$valgrind_path -q"
 413   AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
 414 [Define if you want to run subprograms and generated programs
 415    through valgrind (a memory checker).  This is extremely expensive.])
 416   if test $gcc_cv_header_memcheck_h = yes; then
 417     AC_DEFINE(HAVE_MEMCHECK_H, 1,
 418         [Define if valgrind's memcheck.h header is installed.])
 419   fi
 420 fi
 421 AC_SUBST(valgrind_path_defines)
 422 AC_SUBST(valgrind_command)
 423
 424 # Enable code coverage collection
 425 AC_ARG_ENABLE(coverage,
 426 [  --enable-coverage[=LEVEL]
 427                           enable compiler\'s code coverage collection.
 428                           Use to measure compiler performance and locate
 429                           unused parts of the compiler. With LEVEL, specify
 430                           optimization. Values are opt, noopt,
 431                           default is noopt],
 432 [case "${enableval}" in
 433 yes|noopt)
 434         coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
 435         ;;
 436 opt)
 437         coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
 438         ;;
 439 *)
 440         AC_MSG_ERROR(unknown coverage setting $enableval)
 441         ;;
 442 esac],
 443 [coverage_flags=""])
 444 AC_SUBST(coverage_flags)
 445
 446 # -------------------------------
 447 # Miscenalleous configure options
 448 # -------------------------------
 449
 450 # With stabs
 451 AC_ARG_WITH(stabs,
 452 [  --with-stabs            arrange to use stabs instead of host debug format],
 453 stabs="$with_stabs",
 454 stabs=no)
 455
 456 # With ELF
 457 AC_ARG_WITH(elf,
 458 [  --with-elf              arrange to use ELF instead of host debug format],
 459 elf="$with_elf",
 460 elf=no)
 461
 462 # Determine whether or not multilibs are enabled.
 463 AC_ARG_ENABLE(multilib,
 464 [  --enable-multilib       enable library support for multiple ABIs],
 465 [], [enable_multilib=yes])
 466 AC_SUBST(enable_multilib)
 467
 468 # Enable __cxa_atexit for C++.
 469 AC_ARG_ENABLE(__cxa_atexit,
 470 [  --enable-__cxa_atexit   enable __cxa_atexit for C++],
 471 [], [])
 472
 473 # Enable threads
 474 # Pass with no value to take the default
 475 # Pass with a value to specify a thread package
 476 AC_ARG_ENABLE(threads,
 477 [  --enable-threads        enable thread usage for target GCC
 478   --enable-threads=LIB    use LIB thread package for target GCC],,
 479 enable_threads='')
 480
 481 enable_threads_flag=$enable_threads
 482 # Check if a valid thread package
 483 case x${enable_threads_flag} in
 484         x | xno)
 485                 # No threads
 486                 target_thread_file='single'
 487                 ;;
 488         xyes)
 489                 # default
 490                 target_thread_file=''
 491                 ;;
 492         xdecosf1 | xirix | xmach | xos2 | xposix | xpthreads | xsingle | \
 493         xsolaris | xwin32 | xdce | xrtems| xvxworks | xaix | xgnat)
 494                 target_thread_file=$enable_threads_flag
 495                 ;;
 496         *)
 497                 echo "$enable_threads is an unknown thread package" 1>&2
 498                 exit 1
 499                 ;;
 500 esac
 501
 502 AC_ARG_ENABLE(objc-gc,
 503 [  --enable-objc-gc       enable the use of Boehm's garbage collector with
 504                           the GNU Objective-C runtime],
 505 if test x$enable_objc_gc = xno; then
 506         objc_boehm_gc=''
 507 else
 508         objc_boehm_gc=1
 509 fi,
 510 objc_boehm_gc='')
 511
 512 AC_ARG_WITH(dwarf2,
 513 [  --with-dwarf2           force the default debug format to be DWARF 2],
 514 dwarf2="$with_dwarf2",
 515 dwarf2=no)
 516
 517 AC_ARG_ENABLE(shared,
 518 [  --disable-shared        don't provide a shared libgcc],
 519 [
 520   case $enable_shared in
 521   yes | no) ;;
 522   *)
 523     enable_shared=no
 524     IFS="${IFS=         }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
 525     for pkg in $enableval; do
 526       if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
 527         enable_shared=yes
 528       fi
 529     done
 530     IFS="$ac_save_ifs"
 531     ;;
 532   esac
 533 ], [enable_shared=yes])
 534 AC_SUBST(enable_shared)
 535
 536 AC_ARG_WITH(sysroot,
 537 [  --with-sysroot[=DIR] Search for usr/lib, usr/include, et al, within DIR.],
 538 [
 539  case ${with_sysroot} in
 540  yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_alias}/sys-root' ;;
 541  *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
 542  esac
 543
 544  TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
 545  CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR)'
 546
 547  if test "x$exec_prefix" = xNONE; then
 548   if test "x$prefix" = xNONE; then
 549    test_prefix=/usr/local
 550   else
 551    test_prefix=$prefix
 552   fi
 553  else
 554   test_prefix=$exec_prefix
 555  fi
 556  case ${TARGET_SYSTEM_ROOT} in
 557  "${test_prefix}"|"${test_prefix}/"*|\
 558  '${exec_prefix}'|'${exec_prefix}/'*)
 559    t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
 560    TARGET_SYSTEM_ROOT_DEFINE="$t"
 561    ;;
 562  esac
 563 ], [
 564  TARGET_SYSTEM_ROOT=
 565  TARGET_SYSTEM_ROOT_DEFINE=
 566  CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
 567 ])
 568 AC_SUBST(TARGET_SYSTEM_ROOT)
 569 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
 570 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
 571
 572 # Build with intermodule optimisations
 573 AC_ARG_ENABLE(intermodule,
 574 [  --enable-intermodule    build the compiler in one step],
 575 [case "${enable_intermodule}" in
 576   yes) onestep=-onestep : ;;
 577   *) onestep= : ;;
 578 esac])
 579 AC_SUBST(onestep)
 580
 581 # -------------------------
 582 # Checks for other programs
 583 # -------------------------
 584
 585 AC_PROG_MAKE_SET
 586
 587 # Find some useful tools
 588 AC_PROG_AWK
 589 gcc_AC_PROG_LN
 590 gcc_AC_PROG_LN_S
 591 AC_PROG_RANLIB
 592 gcc_AC_PROG_INSTALL
 593
 594 # See if we have the mktemp command.
 595 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
 596
 597 # Do we have a single-tree copy of texinfo?
 598 if test -f $srcdir/../texinfo/Makefile.in; then
 599   MAKEINFO='$(objdir)/../texinfo/makeinfo/makeinfo'
 600   gcc_cv_prog_makeinfo_modern=yes
 601   AC_MSG_RESULT([Using makeinfo from the unified source tree.])
 602 else
 603   # See if makeinfo has been installed and is modern enough
 604   # that we can use it.
 605   gcc_AC_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
 606   [GNU texinfo.* \([0-9][0-9.]*\)],
 607   [4.[2-9]*])
 608 fi
 609
 610 if test $gcc_cv_prog_makeinfo_modern = no; then
 611   AC_MSG_WARN([
 612 *** Makeinfo is missing or too old.
 613 *** Info documentation will not be built.])
 614   BUILD_INFO=
 615 else
 616   BUILD_INFO=info               AC_SUBST(BUILD_INFO)
 617 fi
 618
 619 # Is pod2man recent enough to regenerate manpages?
 620 AC_MSG_CHECKING([for recent Pod::Man])
 621 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
 622   AC_MSG_RESULT(yes)
 623   GENERATED_MANPAGES=generated-manpages         AC_SUBST(GENERATED_MANPAGES)
 624 else
 625   AC_MSG_RESULT(no)
 626   GENERATED_MANPAGES=
 627 fi
 628
 629 # 'make compare' can be significantly faster, if cmp itself can
 630 # skip bytes instead of using tail.  The test being performed is
 631 # "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2"
 632 # but we need to sink errors and handle broken shells.
 633 AC_MSG_CHECKING([for cmp's capabilities])
 634 echo abfoo >t1
 635 echo cdfoo >t2
 636 if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
 637   if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
 638     make_compare_target=slowcompare
 639   else
 640     make_compare_target=gnucompare
 641   fi
 642 else
 643   make_compare_target=slowcompare
 644 fi
 645 rm t1 t2
 646 AC_SUBST(make_compare_target)
 647 AC_MSG_RESULT($make_compare_target)
 648
 649 # How about lex?
 650 dnl Don't use AC_PROG_LEX; we insist on flex.
 651 dnl LEXLIB is not useful in gcc.
 652 if test -f $srcdir/../flex/skel.c; then
 653   FLEX='$(objdir)/../flex/flex'
 654 else
 655   AC_CHECK_PROG(FLEX, flex, flex, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing flex)
 656 fi
 657
 658 # Bison?
 659 # The -L switch is so bison can find its skeleton file.
 660 if test -f $srcdir/../bison/bison.simple; then
 661   BISON='$(objdir)/../bison/bison -L $(srcdir)/../bison/'
 662 else
 663   AC_CHECK_PROG(BISON, bison, bison, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing bison)
 664 fi
 665
 666 # --------------------
 667 # Checks for C headers
 668 # --------------------
 669
 670 AC_MSG_CHECKING(for GNU C library)
 671 AC_CACHE_VAL(gcc_cv_glibc,
 672 [AC_TRY_COMPILE(
 673   [#include <features.h>],[
 674 #if ! (defined __GLIBC__ || defined __GNU_LIBRARY__)
 675 #error Not a GNU C library system
 676 #endif],
 677   [gcc_cv_glibc=yes],
 678   gcc_cv_glibc=no)])
 679 AC_MSG_RESULT($gcc_cv_glibc)
 680 if test $gcc_cv_glibc = yes; then
 681   AC_DEFINE(_GNU_SOURCE, 1, [Always define this when using the GNU C Library])
 682 fi
 683
 684 AC_HEADER_STDC
 685 AC_HEADER_TIME
 686 gcc_AC_HEADER_STDBOOL
 687 gcc_AC_HEADER_STRING
 688 AC_HEADER_SYS_WAIT
 689 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h \
 690                  fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
 691                  sys/resource.h sys/param.h sys/times.h sys/stat.h \
 692                  direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
 693
 694 # Check for thread headers.
 695 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
 696 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
 697
 698 # These tests can't be done till we know if we have limits.h.
 699 gcc_AC_C_CHAR_BIT
 700 AC_C_BIGENDIAN_CROSS
 701
 702 # --------
 703 # UNSORTED
 704 # --------
 705
 706 # Stage specific cflags for build.
 707 stage1_cflags=
 708 case $build in
 709 vax-*-*)
 710   if test x$GCC = xyes
 711   then
 712     stage1_cflags="-Wa,-J"
 713   else
 714     stage1_cflags="-J"
 715   fi
 716   ;;
 717 powerpc-*-darwin*)
 718   # The spiffy cpp-precomp chokes on some legitimate constructs in GCC
 719   # sources; use -no-cpp-precomp to get to GNU cpp.
 720   # Apple's GCC has bugs in designated initializer handling, so disable
 721   # that too.
 722   stage1_cflags="-no-cpp-precomp -DHAVE_DESIGNATED_INITIALIZERS=0"
 723   ;;
 724 esac
 725 AC_SUBST(stage1_cflags)
 726
 727 # These libraries may be used by collect2.
 728 # We may need a special search path to get them linked.
 729 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
 730 [save_LIBS="$LIBS"
 731 for libs in '' -lld -lmld \
 732                 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
 733                 '-L/usr/lib/cmplrs/cc3.11 -lmld'
 734 do
 735         LIBS="$libs"
 736         AC_TRY_LINK_FUNC(ldopen,
 737                 [gcc_cv_collect2_libs="$libs"; break])
 738 done
 739 LIBS="$save_LIBS"
 740 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
 741 case $gcc_cv_collect2_libs in
 742         "none required")        ;;
 743         *)      COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
 744 esac
 745 AC_SUBST(COLLECT2_LIBS)
 746
 747 # When building Ada code on Alpha, we need exc_resume which is usually in
 748 # -lexc.  So test for it.
 749 save_LIBS="$LIBS"
 750 LIBS=
 751 AC_SEARCH_LIBS(exc_resume, exc)
 752 GNAT_LIBEXC="$LIBS"
 753 LIBS="$save_LIBS"
 754 AC_SUBST(GNAT_LIBEXC)
 755
 756 # Some systems put ldexp and frexp in libm instead of libc; assume
 757 # they're both in the same place.  jcf-dump needs them.
 758 save_LIBS="$LIBS"
 759 LIBS=
 760 AC_SEARCH_LIBS(ldexp, m)
 761 LDEXP_LIB="$LIBS"
 762 LIBS="$save_LIBS"
 763 AC_SUBST(LDEXP_LIB)
 764
 765 # Use <inttypes.h> only if it exists,
 766 # doesn't clash with <sys/types.h>, and declares intmax_t.
 767 AC_MSG_CHECKING(for inttypes.h)
 768 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
 769 [AC_TRY_COMPILE(
 770   [#include <sys/types.h>
 771 #include <inttypes.h>],
 772   [intmax_t i = -1;],
 773   [gcc_cv_header_inttypes_h=yes],
 774   gcc_cv_header_inttypes_h=no)])
 775 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
 776 if test $gcc_cv_header_inttypes_h = yes; then
 777   AC_DEFINE(HAVE_INTTYPES_H, 1,
 778         [Define if you have a working <inttypes.h> header file.])
 779 fi
 780
 781 dnl Disabled until we have a complete test for buggy enum bitfields.
 782 dnl gcc_AC_C_ENUM_BF_UNSIGNED
 783
 784 AC_CHECK_FUNCS(times clock dup2 kill getrlimit setrlimit atoll atoq \
 785         sysconf strsignal putc_unlocked fputc_unlocked fputs_unlocked \
 786         fwrite_unlocked fprintf_unlocked getrusage nl_langinfo lstat \
 787         scandir alphasort gettimeofday mbstowcs wcswidth mmap mincore \
 788         setlocale)
 789
 790 if test x$ac_cv_func_mbstowcs = xyes; then
 791   AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
 792 [    AC_TRY_RUN([#include <stdlib.h>
 793 int main()
 794 {
 795   mbstowcs(0, "", 0);
 796   return 0;
 797 }],
 798     gcc_cv_func_mbstowcs_works=yes,
 799     gcc_cv_func_mbstowcs_works=no,
 800     gcc_cv_func_mbstowcs_works=yes)])
 801   if test x$gcc_cv_func_mbstowcs_works = xyes; then
 802     AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
 803   [Define this macro if mbstowcs does not crash when its
 804    first argument is NULL.])
 805   fi
 806 fi
 807
 808 AC_CHECK_TYPE(ssize_t, int)
 809
 810 # Try to determine the array type of the second argument of getgroups
 811 # for the target system (int or gid_t).
 812 AC_TYPE_GETGROUPS
 813 if test "${target}" = "${build}"; then
 814   TARGET_GETGROUPS_T=$ac_cv_type_getgroups
 815 else
 816   case "${target}" in
 817         # This condition may need some tweaking.  It should include all
 818         # targets where the array type of the second argument of getgroups
 819         # is int and the type of gid_t is not equivalent to int.
 820         *-*-sunos* | *-*-ultrix*)
 821                 TARGET_GETGROUPS_T=int
 822                 ;;
 823         *)
 824                 TARGET_GETGROUPS_T=gid_t
 825                 ;;
 826   esac
 827 fi
 828 AC_SUBST(TARGET_GETGROUPS_T)
 829
 830 gcc_AC_FUNC_PRINTF_PTR
 831 gcc_AC_FUNC_MMAP_BLACKLIST
 832
 833 case "${host}" in
 834 *-*-uwin*)
 835   AC_MSG_ERROR([
 836 *** UWIN may not be used as a host platform because
 837 *** linking with posix.dll is not allowed by the GNU GPL])
 838   ;;
 839 *-*-*vms*)
 840   # Under VMS, vfork works very different than on Unix. The standard test
 841   # won't work, and it isn't easily adaptable. It makes more sense to
 842   # just force it.
 843   ac_cv_func_vfork_works=yes
 844   ;;
 845 esac
 846 AC_FUNC_VFORK
 847
 848 AM_ICONV
 849 # Until we have in-tree GNU iconv:
 850 LIBICONV_DEP=
 851 AC_SUBST(LIBICONV_DEP)
 852
 853 AM_LC_MESSAGES
 854
 855 # We will need to find libiberty.h and ansidecl.h
 856 saved_CFLAGS="$CFLAGS"
 857 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include"
 858 gcc_AC_CHECK_DECLS(getenv atol sbrk abort atof getcwd getwd \
 859         strsignal putc_unlocked fputs_unlocked fwrite_unlocked \
 860         fprintf_unlocked strstr errno vasprintf \
 861         malloc realloc calloc free basename getopt clock, , ,[
 862 #include "ansidecl.h"
 863 #include "system.h"])
 864
 865 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
 866 #include "ansidecl.h"
 867 #include "system.h"
 868 #ifdef HAVE_SYS_RESOURCE_H
 869 #include <sys/resource.h>
 870 #endif
 871 ])
 872
 873 AC_TRY_COMPILE([
 874 #include "ansidecl.h"
 875 #include "system.h"
 876 #ifdef HAVE_SYS_RESOURCE_H
 877 #include <sys/resource.h>
 878 #endif
 879 ],[rlim_t l = 0;],,[AC_DEFINE([rlim_t],[long],
 880 [Define to \`long' if <sys/resource.h> doesn't define.])])
 881
 882 gcc_AC_CHECK_DECLS(ldgetname, , ,[
 883 #include "ansidecl.h"
 884 #include "system.h"
 885 #ifdef HAVE_LDFCN_H
 886 #include <ldfcn.h>
 887 #endif
 888 ])
 889
 890 gcc_AC_CHECK_DECLS(times, , ,[
 891 #include "ansidecl.h"
 892 #include "system.h"
 893 #ifdef HAVE_SYS_TIMES_H
 894 #include <sys/times.h>
 895 #endif
 896 ])
 897
 898 # More time-related stuff.
 899 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
 900 AC_TRY_COMPILE([
 901 #include "ansidecl.h"
 902 #include "system.h"
 903 #ifdef HAVE_SYS_TIMES_H
 904 #include <sys/times.h>
 905 #endif
 906 ], [struct tms tms;], ac_cv_struct_tms=yes, ac_cv_struct_tms=no)])
 907 if test $ac_cv_struct_tms = yes; then
 908   AC_DEFINE(HAVE_STRUCT_TMS, 1,
 909   [Define if <sys/times.h> defines struct tms.])
 910 fi
 911
 912 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
 913 # revisit after autoconf 2.50.
 914 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
 915 AC_TRY_COMPILE([
 916 #include "ansidecl.h"
 917 #include "system.h"
 918 ], [clock_t x;], gcc_cv_type_clock_t=yes, gcc_cv_type_clock_t=no)])
 919 if test $gcc_cv_type_clock_t = yes; then
 920   AC_DEFINE(HAVE_CLOCK_T, 1,
 921   [Define if <time.h> defines clock_t.])
 922 fi
 923
 924 AC_CACHE_CHECK(for uchar, gcc_cv_type_uchar,
 925 [AC_TRY_COMPILE([
 926 #include "ansidecl.h"
 927 #include "system.h"
 928 ],
 929 [if ((uchar *)0) return 0;
 930  if (sizeof(uchar)) return 0;],
 931 ac_cv_type_uchar=yes, ac_cv_type_uchar=no)])
 932 if test $ac_cv_type_uchar = yes; then
 933   AC_DEFINE(HAVE_UCHAR, 1,
 934   [Define if <sys/types.h> defines \`uchar'.])
 935 fi
 936
 937 # Restore CFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
 938 CFLAGS="$saved_CFLAGS"
 939
 940 gcc_AC_INITFINI_ARRAY
 941
 942 # mkdir takes a single argument on some systems.
 943 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
 944
 945 # File extensions
 946 manext='.1'
 947 objext='.o'
 948 AC_SUBST(manext)
 949 AC_SUBST(objext)
 950
 951 # With Setjmp/Longjmp based exception handling.
 952 AC_ARG_ENABLE(sjlj-exceptions,
 953 [  --enable-sjlj-exceptions
 954                           arrange to use setjmp/longjmp exception handling],
 955 [sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
 956 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
 957   [Define 0/1 to force the choice for exception handling model.])])
 958
 959 AC_CHECK_LIB(unwind, main, use_libunwind_default=yes, use_libunwind_default=no)
 960 # Use libunwind based exception handling.
 961 AC_ARG_ENABLE(libunwind-exceptions,
 962 [  --enable-libunwind-exceptions  force use libunwind for exceptions],
 963 use_libunwind_exceptions=$enableval,
 964 use_libunwind_exceptions=$use_libunwind_default)
 965 if test x"$use_libunwind_exceptions" = xyes; then
 966    AC_DEFINE(USE_LIBUNWIND_EXCEPTIONS, 1,
 967         [Define if gcc should use -lunwind.])
 968 fi
 969
 970 # --------------------------------------------------------
 971 # Build, host, and target specific configuration fragments
 972 # --------------------------------------------------------
 973
 974 target_gtfiles=
 975 build_xm_file=
 976 build_xm_defines=
 977 build_install_headers_dir=install-headers-tar
 978 build_exeext=
 979 host_xm_file=
 980 host_xm_defines=
 981 host_xmake_file=
 982 host_exeext=
 983
 984 # Decode the host machine, then the target machine.
 985 # For the host machine, we save the xm_file variable as host_xm_file;
 986 # then we decode the target machine and forget everything else
 987 # that came from the host machine.
 988 for machine in $build $host $target; do
 989         . ${srcdir}/config.gcc
 990 done
 991
 992 extra_objs="${host_extra_objs} ${extra_objs}"
 993
 994 # Default the target-machine variables that were not explicitly set.
 995 if test x"$tm_file" = x
 996 then tm_file=$cpu_type/$cpu_type.h; fi
 997
 998 if test x"$extra_headers" = x
 999 then extra_headers=; fi
1000
1001 if test x$md_file = x
1002 then md_file=$cpu_type/$cpu_type.md; fi
1003
1004 if test x$out_file = x
1005 then out_file=$cpu_type/$cpu_type.c; fi
1006
1007 if test x"$tmake_file" = x
1008 then tmake_file=$cpu_type/t-$cpu_type
1009 fi
1010
1011 if test x"$dwarf2" = xyes
1012 then tm_file="$tm_file tm-dwarf2.h"
1013 fi
1014
1015 # Say what files are being used for the output code and MD file.
1016 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1017 echo "Using \`$srcdir/config/$md_file' as machine description file."
1018
1019 # If any of the xm_file variables contain nonexistent files, warn
1020 # about them and drop them.
1021
1022 bx=
1023 for x in $build_xm_file; do
1024   if    test -f $srcdir/config/$x
1025   then      bx="$bx $x"
1026   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1027   fi
1028 done
1029 build_xm_file="$bx"
1030
1031 hx=
1032 for x in $host_xm_file; do
1033   if    test -f $srcdir/config/$x
1034   then      hx="$hx $x"
1035   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1036   fi
1037 done
1038 host_xm_file="$hx"
1039
1040 tx=
1041 for x in $xm_file; do
1042   if    test -f $srcdir/config/$x
1043   then      tx="$tx $x"
1044   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1045   fi
1046 done
1047 xm_file="$tx"
1048
1049 count=a
1050 for f in $tm_file; do
1051         count=${count}x
1052 done
1053 if test $count = ax; then
1054         echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1055 else
1056         echo "Using the following target machine macro files:"
1057         for f in $tm_file; do
1058                 echo "  $srcdir/config/$f"
1059         done
1060 fi
1061
1062 if test x$need_64bit_hwint = xyes; then
1063         AC_DEFINE(NEED_64BIT_HOST_WIDE_INT, 1,
1064 [Define to 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h).])
1065 fi
1066
1067 count=a
1068 for f in $host_xm_file; do
1069         count=${count}x
1070 done
1071 if test $count = a; then
1072         :
1073 elif test $count = ax; then
1074         echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1075 else
1076         echo "Using the following host machine macro files:"
1077         for f in $host_xm_file; do
1078                 echo "  $srcdir/config/$f"
1079         done
1080 fi
1081 echo "Using ${out_host_hook_obj} for host machine hooks."
1082
1083 if test "$host_xm_file" != "$build_xm_file"; then
1084         count=a
1085         for f in $build_xm_file; do
1086                 count=${count}x
1087         done
1088         if test $count = a; then
1089                 :
1090         elif test $count = ax; then
1091                 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1092         else
1093                 echo "Using the following build machine macro files:"
1094                 for f in $build_xm_file; do
1095                         echo "  $srcdir/config/$f"
1096                 done
1097         fi
1098 fi
1099
1100 if test x$thread_file = x; then
1101         if test x$target_thread_file != x; then
1102                 thread_file=$target_thread_file
1103         else
1104                 thread_file='single'
1105         fi
1106 fi
1107
1108 if test x$enable___cxa_atexit = xyes || \
1109    test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1110   AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 1,
1111   [Define if you want to use __cxa_atexit, rather than atexit, to
1112    register C++ destructors for local statics and global objects.
1113    This is essential for fully standards-compliant handling of
1114    destructors, but requires __cxa_atexit in libc.])
1115 fi
1116
1117 # Look for a file containing extra machine modes.
1118 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1119   extra_modes_file='$(srcdir)'/config/${extra_modes}
1120   AC_SUBST(extra_modes_file)
1121   AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "$extra_modes",
1122   [Define to the name of a file containing a list of extra machine modes
1123    for this architecture.])
1124   AC_DEFINE(EXTRA_CC_MODES, 1,
1125   [Define if the target architecture needs extra machine modes to represent
1126    the results of comparisons.])
1127 fi
1128
1129 # auto-host.h is the file containing items generated by autoconf and is
1130 # the first file included by config.h.
1131 # If host=build, it is correct to have bconfig include auto-host.h
1132 # as well.  If host!=build, we are in error and need to do more
1133 # work to find out the build config parameters.
1134 if test x$host = x$build
1135 then
1136         build_auto=auto-host.h
1137         FORBUILD=..
1138 else
1139         # We create a subdir, then run autoconf in the subdir.
1140         # To prevent recursion we set host and build for the new
1141         # invocation of configure to the build for this invocation
1142         # of configure.
1143         tempdir=build.$$
1144         rm -rf $tempdir
1145         mkdir $tempdir
1146         cd $tempdir
1147         case ${srcdir} in
1148         /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1149         *) realsrcdir=../${srcdir};;
1150         esac
1151         saved_CFLAGS="${CFLAGS}"
1152         CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1153         ${realsrcdir}/configure \
1154                 --target=$target_alias --host=$build_alias --build=$build_alias
1155         CFLAGS="${saved_CFLAGS}"
1156
1157         # We just finished tests for the build machine, so rename
1158         # the file auto-build.h in the gcc directory.
1159         mv auto-host.h ../auto-build.h
1160         cd ..
1161         rm -rf $tempdir
1162         build_auto=auto-build.h
1163         FORBUILD=../${build_subdir}
1164 fi
1165 AC_SUBST(FORBUILD)
1166
1167 tm_file="${tm_file} defaults.h"
1168 tm_p_file="${tm_p_file} tm-preds.h"
1169 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1170 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1171 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1172 # put this back in temporarily.
1173 xm_file="ansidecl.h ${xm_file}"
1174
1175 # --------
1176 # UNSORTED
1177 # --------
1178
1179 # Get the version trigger filename from the toplevel
1180 if test "${with_gcc_version_trigger+set}" = set; then
1181         gcc_version_trigger=$with_gcc_version_trigger
1182 else
1183         gcc_version_trigger=${srcdir}/version.c
1184 fi
1185 changequote(,)dnl
1186 gcc_version_full=`grep version_string ${gcc_version_trigger} | sed -e 's/.*"\([^"]*\)".*/\1/'`
1187 gcc_version=`echo ${gcc_version_full} | sed -e 's/\([^ ]*\) .*/\1/'`
1188
1189 # Compile in configure arguments.
1190 if test -f configargs.h ; then
1191         # Being re-configured.
1192         gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1193         gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1194 else
1195         gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1196 fi
1197 cat > configargs.h <<EOF
1198 /* Generated automatically. */
1199 static const char configuration_arguments[] = "$gcc_config_arguments";
1200 static const char thread_model[] = "$thread_file";
1201
1202 static const struct {
1203   const char *name, *value;
1204 } configure_default_options[] = $configure_default_options;
1205 EOF
1206 changequote([,])dnl
1207
1208 # Internationalization
1209 PACKAGE=gcc
1210 VERSION="$gcc_version"
1211 AC_SUBST(PACKAGE)
1212 AC_SUBST(VERSION)
1213
1214 ZW_GNU_GETTEXT_SISTER_DIR
1215
1216 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1217 # -liconv on the link line twice.
1218 case "$LIBINTL" in *$LIBICONV*)
1219         LIBICONV= ;;
1220 esac
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, or we are generating coverage data
1426 if test x$build != x$host || test "x$coverage_flags" != x
1427 then
1428     BUILD_PREFIX=build-
1429     BUILD_PREFIX_1=build-
1430     BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
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   powerpc*-*-*)
2474     AC_CACHE_CHECK([assembler supports mfcr field],
2475         gcc_cv_as_mfcrf, [
2476         gcc_cv_as_mfcrf=unknown
2477         if test $in_tree_gas = yes ; then
2478           gcc_GAS_VERSION_GTE_IFELSE(2,14,0,[
2479             gcc_cv_as_mfcrf=yes
2480           ])
2481         elif test x$gcc_cv_as != x; then
2482             cat > conftest.s << 'EOF'
2483               case "$target" in
2484 changequote(,)dnl
2485                 *-*-aix*)
2486         .csect .text[PR]
2487                 ;;
2488                 *)
2489         .text
2490                 ;;
2491               esac
2492         mfcr 3,128
2493 EOF
2494 changequote([,])dnl
2495             if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2496                 gcc_cv_as_mfcrf=yes
2497             else
2498                 gcc_cv_as_mfcrf=no
2499             fi
2500             rm -f conftest.s conftest.o
2501         fi
2502     ])
2503     if test "x$gcc_cv_as_mfcrf" = xyes; then
2504         AC_DEFINE(HAVE_AS_MFCRF, 1,
2505           [Define if your assembler supports mfcr field.])
2506     fi
2507     ;;
2508 esac
2509
2510 AC_MSG_CHECKING(assembler dwarf2 debug_line support)
2511 gcc_cv_as_dwarf2_debug_line=no
2512 # ??? Not all targets support dwarf2 debug_line, even within a version
2513 # of gas.  Moreover, we need to emit a valid instruction to trigger any
2514 # info to the output file.  So, as supported targets are added to gas 2.11,
2515 # add some instruction here to (also) show we expect this might work.
2516 # ??? Once 2.11 is released, probably need to add first known working
2517 # version to the per-target configury.
2518 case "$target" in
2519   i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* \
2520   | x86_64*-*-* | hppa*-*-* | arm*-*-* | strongarm*-*-* | xscale*-*-* \
2521   | xstormy16*-*-* | cris-*-*)
2522     insn="nop"
2523     ;;
2524   ia64*-*-*)
2525     insn="nop 0"
2526     ;;
2527   mmix-*-*)
2528     insn="swym 0"
2529     ;;
2530   esac
2531 if test $in_tree_gas = yes ; then
2532   gcc_GAS_VERSION_GTE_IFELSE(2,11,0,[
2533     test $in_tree_gas_is_elf = yes && test x"$insn" != x \
2534         && gcc_cv_as_dwarf2_debug_line="yes"
2535   ])
2536 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2537         echo '  .file 1 "conftest.s"' > conftest.s
2538         echo '  .loc 1 3 0' >> conftest.s
2539         echo "  $insn" >> conftest.s
2540         # ??? This fails with non-gnu grep.
2541         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
2542            && grep debug_line conftest.o > /dev/null 2>&1 ; then
2543                 # The .debug_line file table must be in the exact order that
2544                 # we specified the files, since these indices are also used
2545                 # by DW_AT_decl_file.  Approximate this test by testing if
2546                 # the assembler bitches if the same index is assigned twice.
2547                 echo '  .file 1 "foo.s"' > conftest.s
2548                 echo '  .file 1 "bar.s"' >> conftest.s
2549                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1
2550                 then
2551                   gcc_cv_as_dwarf2_debug_line="no"
2552                 else
2553                   gcc_cv_as_dwarf2_debug_line="yes"
2554                 fi
2555         fi
2556         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
2557 fi
2558 if test x"$gcc_cv_as_dwarf2_debug_line" = xyes; then
2559         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
2560 [Define if your assembler supports dwarf2 .file/.loc directives,
2561    and preserves file table indices exactly as given.])
2562 fi
2563 AC_MSG_RESULT($gcc_cv_as_dwarf2_debug_line)
2564
2565 AC_MSG_CHECKING(assembler --gdwarf2 support)
2566 gcc_cv_as_gdwarf2_flag=no
2567 if test $in_tree_gas = yes ; then
2568   gcc_GAS_VERSION_GTE_IFELSE(2,11,0,[
2569     test $in_tree_gas_is_elf = yes && test x"$insn" != x \
2570         && gcc_cv_as_gdwarf2_flag="yes"
2571   ])
2572 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2573         echo '' > conftest.s
2574         # ??? This fails with non-gnu grep.
2575         if $gcc_cv_as --gdwarf2 -o conftest.o conftest.s > /dev/null 2>&1
2576           then
2577           gcc_cv_as_gdwarf2_flag="yes"
2578         fi
2579         rm -f conftest.s conftest.o
2580 fi
2581 if test x"$gcc_cv_as_gdwarf2_flag" = xyes; then
2582         AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
2583 [Define if your assembler supports the --gdwarf2 option.])
2584 fi
2585 AC_MSG_RESULT($gcc_cv_as_gdwarf2_flag)
2586
2587 AC_MSG_CHECKING(assembler --gstabs support)
2588 gcc_cv_as_gstabs_flag=no
2589 if test $in_tree_gas = yes ; then
2590   gcc_GAS_VERSION_GTE_IFELSE(2,11,0,[
2591     test $in_tree_gas_is_elf = yes && test x"$insn" != x \
2592         && gcc_cv_as_gstabs_flag="yes"
2593   ])
2594 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2595         echo '' > conftest.s
2596         # ??? This fails with non-gnu grep.
2597         if $gcc_cv_as --gstabs -o conftest.o conftest.s > /dev/null 2>&1 ; then
2598           gcc_cv_as_gstabs_flag="yes"
2599           # The native Solaris 9/Intel assembler doesn't understand --gstabs
2600           # and warns about it, but still exits successfully.  So check for
2601           # this.
2602           if $gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | \
2603                 grep -i warning > /dev/null ; then
2604             gcc_cv_as_gstabs_flag="no"
2605           fi
2606         fi
2607         rm -f conftest.s conftest.o
2608 fi
2609 if test x"$gcc_cv_as_gstabs_flag" = xyes; then
2610         AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
2611 [Define if your assembler supports the --gstabs option.])
2612 fi
2613 AC_MSG_RESULT($gcc_cv_as_gstabs_flag)
2614
2615 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2616 gcc_cv_ld_ro_rw_mix=unknown
2617 if test $in_tree_ld = yes ; then
2618   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 10 -o "$gcc_cv_gld_major_version" -gt 2 \
2619      && test $in_tree_ld_is_elf = yes; then
2620     gcc_cv_ld_ro_rw_mix=read-write
2621   fi
2622 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2623   echo '.section myfoosect, "a"' > conftest1.s
2624   echo '.section myfoosect, "aw"' > conftest2.s
2625   echo '.byte 1' >> conftest2.s
2626   echo '.section myfoosect, "a"' > conftest3.s
2627   echo '.byte 0' >> conftest3.s
2628   if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2629      && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2630      && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2631      && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2632         conftest2.o conftest3.o > /dev/null 2>&1; then
2633     gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2634                          | sed -e '/myfoosect/!d' -e N`
2635     if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2636       if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2637         gcc_cv_ld_ro_rw_mix=read-only
2638       else
2639         gcc_cv_ld_ro_rw_mix=read-write
2640       fi
2641     fi
2642   fi
2643 changequote(,)dnl
2644   rm -f conftest.* conftest[123].*
2645 changequote([,])dnl
2646 fi
2647 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2648         AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2649   [Define if your linker links a mix of read-only
2650    and read-write sections into a read-write section.])
2651 fi
2652 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2653
2654 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
2655 gcc_cv_ld_eh_frame_hdr=no
2656 if test $in_tree_ld = yes ; then
2657   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 \
2658      && test $in_tree_ld_is_elf = yes; then
2659     gcc_cv_ld_eh_frame_hdr=yes
2660   fi
2661 elif test x$gcc_cv_ld != x; then
2662         # Check if linker supports --eh-frame-hdr option
2663         if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
2664                 gcc_cv_ld_eh_frame_hdr=yes
2665         fi
2666 fi
2667 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
2668         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
2669 [Define if your linker supports --eh-frame-hdr option.])
2670 fi
2671 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
2672
2673 AC_MSG_CHECKING(linker position independent executable support)
2674 gcc_cv_ld_pie=no
2675 if test $in_tree_ld = yes ; then
2676   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 \
2677      && test $in_tree_ld_is_elf = yes; then
2678     gcc_cv_ld_pie=yes
2679   fi
2680 elif test x$gcc_cv_ld != x; then
2681         # Check if linker supports -pie option
2682         if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
2683                 gcc_cv_ld_pie=yes
2684         fi
2685 fi
2686 if test x"$gcc_cv_ld_pie" = xyes; then
2687         AC_DEFINE(HAVE_LD_PIE, 1,
2688 [Define if your linker supports -pie option.])
2689 fi
2690 AC_MSG_RESULT($gcc_cv_ld_pie)
2691
2692 # Miscellaneous target-specific checks.
2693 case "$target" in
2694   mips*-*-*)
2695     AC_MSG_CHECKING(whether libgloss uses STARTUP directives consistently)
2696     gcc_cv_mips_libgloss_startup=no
2697     gcc_cv_libgloss_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/libgloss
2698     if test "x$exec_prefix" = xNONE; then
2699       if test "x$prefix" = xNONE; then
2700         test_prefix=/usr/local
2701       else
2702         test_prefix=$prefix
2703       fi
2704     else
2705       test_prefix=$exec_prefix
2706     fi
2707     for f in $gcc_cv_libgloss_srcdir/mips/idt.ld $test_prefix/$target_alias/lib/idt.ld
2708     do
2709       if grep '^STARTUP' $f > /dev/null 2>&1; then
2710         gcc_cv_mips_libgloss_startup=yes
2711         break
2712       fi
2713     done
2714     if test x"$gcc_cv_mips_libgloss_startup" = xyes; then
2715       AC_DEFINE(HAVE_MIPS_LIBGLOSS_STARTUP_DIRECTIVES, 1,
2716         [Define if your MIPS libgloss linker scripts consistently include STARTUP directives.])
2717     fi
2718     AC_MSG_RESULT($gcc_cv_mips_libgloss_startup)
2719
2720     AC_MSG_CHECKING(whether the assembler has explicit relocation support)
2721     if test x$gcc_cv_mips_explicit_relocs = x; then
2722       gcc_cv_mips_explicit_relocs=no
2723       if test $in_tree_gas = yes; then
2724         gcc_GAS_VERSION_GTE_IFELSE(2,14,0,[
2725           gcc_cv_mips_explicit_relocs=yes
2726         ])
2727       elif test x$gcc_cv_as != x; then
2728         echo '  lw $4,%gp_rel(foo)($4)' > conftest.s
2729         if $gcc_cv_as conftest.s -o conftest.o > /dev/null 2>&1; then
2730           gcc_cv_mips_explicit_relocs=yes
2731         fi
2732         rm -f conftest.s conftest.o
2733       fi
2734     fi
2735     if test $gcc_cv_mips_explicit_relocs = yes; then
2736       test x$target_cpu_default != x || target_cpu_default=0
2737       target_cpu_default="(${target_cpu_default}|MASK_EXPLICIT_RELOCS)"
2738     fi
2739     AC_MSG_RESULT($gcc_cv_mips_explicit_relocs)
2740     ;;
2741 esac
2742
2743 if test x$with_sysroot = x && test x$host = x$target \
2744    && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" ; then
2745   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include")
2746 fi
2747
2748 # Figure out what language subdirectories are present.
2749 # Look if the user specified --enable-languages="..."; if not, use
2750 # the environment variable $LANGUAGES if defined. $LANGUAGES might
2751 # go away some day.
2752 # NB:  embedded tabs in this IF block -- do not untabify
2753 if test x"${enable_languages+set}" != xset; then
2754         if test x"${LANGUAGES+set}" = xset; then
2755                 enable_languages="${LANGUAGES}"
2756                 AC_MSG_WARN([setting LANGUAGES is deprecated, use --enable-languages instead])
2757
2758         else
2759                 enable_languages=all
2760         fi
2761 else
2762         if test x"${enable_languages}" = x \
2763         || test x"${enable_languages}" = xyes;
2764         then
2765                 AC_MSG_ERROR([--enable-languages needs at least one language argument])
2766         fi
2767 fi
2768 enable_languages=`echo "${enable_languages}" | sed -e 's/[[     ,]][[   ,]]*/,/g' -e 's/,$//'`
2769
2770 # First scan to see if an enabled language requires some other language.
2771 # We assume that a given config-lang.in will list all the language
2772 # front ends it requires, even if some are required indirectly.
2773 for lang in ${srcdir}/*/config-lang.in ..
2774 do
2775    case $lang in
2776     ..)
2777        ;;
2778     # The odd quoting in the next line works around
2779     # an apparent bug in bash 1.12 on linux.
2780 changequote(,)dnl
2781     ${srcdir}/[*]/config-lang.in)
2782        ;;
2783     *)
2784        lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^      ]*\).*$,\1,p' $lang`
2785        this_lang_requires=`sed -n -e 's,^lang_requires=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^lang_requires=\([^    ]*\).*$,\1,p' $lang`
2786        for other in $this_lang_requires
2787        do
2788           case ,${enable_languages}, in
2789            *,$other,*)
2790               ;;
2791            *,all,*)
2792               ;;
2793            *,$lang_alias,*)
2794               enable_languages="$enable_languages,$other"
2795               ;;
2796           esac
2797        done
2798        ;;
2799 changequote([,])dnl
2800    esac
2801 done
2802
2803 expected_languages=`echo ,${enable_languages}, | sed -e 's:,: :g' -e 's:  *: :g' -e 's:  *: :g' -e 's:^ ::' -e 's: $::'`
2804 found_languages=
2805 subdirs=
2806 for lang in ${srcdir}/*/config-lang.in ..
2807 do
2808         case $lang in
2809         ..) ;;
2810         # The odd quoting in the next line works around
2811         # an apparent bug in bash 1.12 on linux.
2812 changequote(,)dnl
2813         ${srcdir}/[*]/config-lang.in) ;;
2814         *)
2815           lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
2816           this_lang_libs=`sed -n -e 's,^target_libs=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^target_libs=\([^         ]*\).*$,\1,p' $lang`
2817           build_by_default=`sed -n -e 's,^build_by_default=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^build_by_default=\([^     ]*\).*$,\1,p' $lang`
2818           if test "x$lang_alias" = x
2819           then
2820                 echo "$lang doesn't set \$language." 1>&2
2821                 exit 1
2822           fi
2823           case ${build_by_default},${enable_languages}, in
2824           *,$lang_alias,*) add_this_lang=yes ;;
2825           no,*) add_this_lang=no ;;
2826           *,all,*) add_this_lang=yes ;;
2827           *) add_this_lang=no ;;
2828           esac
2829           found_languages="${found_languages} ${lang_alias}"
2830           if test x"${add_this_lang}" = xyes; then
2831                 case $lang in
2832                     ${srcdir}/ada/config-lang.in)
2833                         if test x$have_gnat = xyes ; then
2834                                 subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2835                         fi
2836                         ;;
2837                     *)
2838                         subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2839                         ;;
2840                 esac
2841           fi
2842           ;;
2843 changequote([,])dnl
2844         esac
2845 done
2846
2847 missing_languages=
2848 for expected_language in ${expected_languages} ..
2849 do
2850     if test "${expected_language}" != ..; then
2851         missing_language="${expected_language}"
2852         if test "${expected_language}" = "c" \
2853            || test "${expected_language}" = "all"; then
2854                 missing_language=
2855         fi
2856         for found_language in ${found_languages} ..
2857         do
2858             if test "${found_language}" != ..; then
2859                 if test "${expected_language}" = "${found_language}"; then
2860                     missing_language=
2861                 fi
2862             fi
2863         done
2864         if test "x${missing_language}" != x; then
2865            missing_languages="${missing_languages} ${missing_language}"
2866         fi
2867     fi
2868 done
2869
2870 if test "x$missing_languages" != x; then
2871   AC_MSG_ERROR([
2872 The following requested languages were not found:${missing_languages}
2873 The following languages were available: c${found_languages}])
2874 fi
2875
2876 # Make gthr-default.h if we have a thread file.
2877 gthread_flags=
2878 if test $thread_file != single; then
2879     rm -f gthr-default.h
2880     echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h
2881     gthread_flags=-DHAVE_GTHR_DEFAULT
2882 fi
2883 AC_SUBST(gthread_flags)
2884
2885 # Find out what GC implementation we want, or may, use.
2886 AC_ARG_WITH(gc,
2887 [  --with-gc={simple,page} choose the garbage collection mechanism to use
2888                           with the compiler],
2889 [case "$withval" in
2890   simple | page)
2891     GGC=ggc-$withval
2892     ;;
2893   *)
2894     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
2895     ;;
2896 esac],
2897 [GGC=ggc-page])
2898 AC_SUBST(GGC)
2899 echo "Using $GGC for garbage collection."
2900
2901 # Use the system's zlib library.
2902 zlibdir=-L../zlib
2903 zlibinc="-I\$(srcdir)/../zlib"
2904 AC_ARG_WITH(system-zlib,
2905 [  --with-system-zlib      use installed libz],
2906 zlibdir=
2907 zlibinc=
2908 )
2909 AC_SUBST(zlibdir)
2910 AC_SUBST(zlibinc)
2911
2912 dnl Very limited version of automake's enable-maintainer-mode
2913
2914 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
2915   dnl maintainer-mode is disabled by default
2916   AC_ARG_ENABLE(maintainer-mode,
2917 [  --enable-maintainer-mode
2918                           enable make rules and dependencies not useful
2919                           (and sometimes confusing) to the casual installer],
2920       maintainer_mode=$enableval,
2921       maintainer_mode=no)
2922
2923 AC_MSG_RESULT($maintainer_mode)
2924
2925 if test "$maintainer_mode" = "yes"; then
2926   MAINT=''
2927 else
2928   MAINT='#'
2929 fi
2930 AC_SUBST(MAINT)dnl
2931
2932 # Make empty files to contain the specs and options for each language.
2933 # Then add #include lines to for a compiler that has specs and/or options.
2934
2935 lang_opt_files=
2936 lang_specs_files=
2937 lang_options_files=
2938 lang_tree_files=
2939 for subdir in . $subdirs
2940 do
2941         if test -f $srcdir/$subdir/lang.opt; then
2942             lang_opt_files="$lang_opt_files $srcdir/$subdir/lang.opt"
2943         fi
2944         if test -f $srcdir/$subdir/lang-specs.h; then
2945             lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
2946         fi
2947         if test -f $srcdir/$subdir/lang-options.h; then
2948             lang_options_files="$lang_options_files $srcdir/$subdir/lang-options.h"
2949         fi
2950         if test -f $srcdir/$subdir/$subdir-tree.def; then
2951             lang_tree_files="$lang_tree_files $srcdir/$subdir/$subdir-tree.def"
2952         fi
2953 done
2954
2955 # These (without "all_") are set in each config-lang.in.
2956 # `language' must be a single word so is spelled singularly.
2957 all_languages=
2958 all_boot_languages=
2959 all_compilers=
2960 all_stagestuff=
2961 all_outputs='Makefile fixinc/Makefile gccbug mklibgcc mkheaders'
2962 # List of language makefile fragments.
2963 all_lang_makefiles=
2964 # Files for gengtype
2965 all_gtfiles="$target_gtfiles"
2966 # Files for gengtype with language
2967 all_gtfiles_files_langs=
2968 all_gtfiles_files_files=
2969
2970 # Add the language fragments.
2971 # Languages are added via two mechanisms.  Some information must be
2972 # recorded in makefile variables, these are defined in config-lang.in.
2973 # We accumulate them and plug them into the main Makefile.
2974 # The other mechanism is a set of hooks for each of the main targets
2975 # like `clean', `install', etc.
2976
2977 language_fragments="Make-lang"
2978 language_hooks="Make-hooks"
2979
2980 for s in .. $subdirs
2981 do
2982         if test $s != ".."
2983         then
2984                 language=
2985                 boot_language=
2986                 compilers=
2987                 stagestuff=
2988                 outputs=
2989                 gtfiles=
2990                 . ${srcdir}/$s/config-lang.in
2991                 if test "x$language" = x
2992                 then
2993                         echo "${srcdir}/$s/config-lang.in doesn't set \$language." 1>&2
2994                         exit 1
2995                 fi
2996                 all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Make-lang.in"
2997                 if test -f ${srcdir}/$s/Makefile.in
2998                 then all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Makefile.in"
2999                 fi
3000                 all_languages="$all_languages $language"
3001                 if test "x$boot_language" = xyes
3002                 then
3003                         all_boot_languages="$all_boot_languages $language"
3004                 fi
3005                 all_compilers="$all_compilers $compilers"
3006                 all_stagestuff="$all_stagestuff $stagestuff"
3007                 all_outputs="$all_outputs $outputs"
3008                 all_gtfiles="$all_gtfiles $gtfiles"
3009                 for f in .. $gtfiles
3010                 do
3011                      if test $f != ".."
3012                      then
3013                          all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
3014                          all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
3015                      fi
3016                 done
3017         fi
3018 done
3019
3020 # Pick up gtfiles for c
3021 gtfiles=
3022 s="c"
3023 . ${srcdir}/c-config-lang.in
3024 all_gtfiles="$all_gtfiles $gtfiles"
3025 for f in .. $gtfiles
3026 do
3027      if test $f != ".."
3028      then
3029         all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
3030         all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
3031      fi
3032 done
3033
3034 check_languages=
3035 for language in .. $all_languages
3036 do
3037         if test $language != ".."
3038         then
3039                 check_languages="$check_languages check-$language"
3040         fi
3041 done
3042
3043 # Since we can't use `::' targets, we link each language in
3044 # with a set of hooks, reached indirectly via lang.${target}.
3045
3046 rm -f Make-hooks
3047 touch Make-hooks
3048 target_list="all.build all.cross start.encap rest.encap tags \
3049         info dvi generated-manpages \
3050         install-normal install-common install-info install-man \
3051         uninstall \
3052         mostlyclean clean distclean extraclean maintainer-clean \
3053         stage1 stage2 stage3 stage4 stageprofile stagefeedback"
3054 for t in $target_list
3055 do
3056         x=
3057         for lang in .. $all_languages
3058         do
3059                 if test $lang != ".."; then
3060                         x="$x $lang.$t"
3061                 fi
3062         done
3063         echo "lang.$t: $x" >> Make-hooks
3064 done
3065
3066 # Create .gdbinit.
3067
3068 echo "dir ." > .gdbinit
3069 echo "dir ${srcdir}" >> .gdbinit
3070 if test x$gdb_needs_out_file_path = xyes
3071 then
3072         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
3073 fi
3074 if test "x$subdirs" != x; then
3075         for s in $subdirs
3076         do
3077                 echo "dir ${srcdir}/$s" >> .gdbinit
3078         done
3079 fi
3080 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
3081
3082 # If $(exec_prefix) exists and is not the same as $(prefix), then compute an
3083 # absolute path for gcc_tooldir based on inserting the number of up-directory
3084 # movements required to get from $(exec_prefix) to $(prefix) into the basic
3085 # $(libsubdir)/@(unlibsubdir) based path.
3086 # Don't set gcc_tooldir to tooldir since that's only passed in by the toplevel
3087 # make and thus we'd get different behavior depending on where we built the
3088 # sources.
3089 if test x$exec_prefix = xNONE -o x$exec_prefix = x$prefix; then
3090     gcc_tooldir='$(libsubdir)/$(unlibsubdir)/../$(target_alias)'
3091 else
3092 changequote(<<, >>)dnl
3093 # An explanation of the sed strings:
3094 #  -e 's|^\$(prefix)||'   matches and eliminates 'prefix' from 'exec_prefix'
3095 #  -e 's|/$||'            match a trailing forward slash and eliminates it
3096 #  -e 's|^[^/]|/|'        forces the string to start with a forward slash (*)
3097 #  -e 's|/[^/]*|../|g'    replaces each occurrence of /<directory> with ../
3098 #
3099 # (*) Note this pattern overwrites the first character of the string
3100 # with a forward slash if one is not already present.  This is not a
3101 # problem because the exact names of the sub-directories concerned is
3102 # unimportant, just the number of them matters.
3103 #
3104 # The practical upshot of these patterns is like this:
3105 #
3106 #  prefix     exec_prefix        result
3107 #  ------     -----------        ------
3108 #   /foo        /foo/bar          ../
3109 #   /foo/       /foo/bar          ../
3110 #   /foo        /foo/bar/         ../
3111 #   /foo/       /foo/bar/         ../
3112 #   /foo        /foo/bar/ugg      ../../
3113 #
3114     dollar='$$'
3115     gcc_tooldir="\$(libsubdir)/\$(unlibsubdir)/\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/\$(dollar)||' -e 's|^[^/]|/|' -e 's|/[^/]*|../|g'\`\$(target_alias)"
3116 changequote([, ])dnl
3117 fi
3118 AC_SUBST(gcc_tooldir)
3119 AC_SUBST(dollar)
3120
3121 # Find a directory in which to install a shared libgcc.
3122
3123 AC_ARG_ENABLE(version-specific-runtime-libs,
3124 [  --enable-version-specific-runtime-libs
3125                           specify that runtime libraries should be
3126                           installed in a compiler-specific directory])
3127
3128 AC_ARG_WITH(slibdir,
3129 [  --with-slibdir=DIR      shared libraries in DIR [LIBDIR]],
3130 slibdir="$with_slibdir",
3131 if test "${enable_version_specific_runtime_libs+set}" = set; then
3132   slibdir='$(libsubdir)'
3133 elif test "$host" != "$target"; then
3134   slibdir='$(build_tooldir)/lib'
3135 else
3136   slibdir='$(libdir)'
3137 fi)
3138 AC_SUBST(slibdir)
3139
3140 objdir=`${PWDCMD-pwd}`
3141 AC_SUBST(objdir)
3142
3143 # Process the language and host/target makefile fragments.
3144 ${CONFIG_SHELL-/bin/sh} $srcdir/configure.frag $srcdir "$subdirs" "$dep_host_xmake_file" "$dep_tmake_file"
3145
3146 # Substitute configuration variables
3147 AC_SUBST(subdirs)
3148 AC_SUBST(srcdir)
3149 AC_SUBST(all_boot_languages)
3150 AC_SUBST(all_compilers)
3151 AC_SUBST(all_gtfiles)
3152 AC_SUBST(all_gtfiles_files_langs)
3153 AC_SUBST(all_gtfiles_files_files)
3154 AC_SUBST(all_lang_makefiles)
3155 AC_SUBST(all_languages)
3156 AC_SUBST(all_stagestuff)
3157 AC_SUBST(build_exeext)
3158 AC_SUBST(build_install_headers_dir)
3159 AC_SUBST(build_xm_file_list)
3160 AC_SUBST(build_xm_file)
3161 AC_SUBST(build_xm_defines)
3162 AC_SUBST(check_languages)
3163 AC_SUBST(cc_set_by_configure)
3164 AC_SUBST(quoted_cc_set_by_configure)
3165 AC_SUBST(cpp_install_dir)
3166 AC_SUBST(dep_host_xmake_file)
3167 AC_SUBST(dep_tmake_file)
3168 AC_SUBST(extra_headers_list)
3169 AC_SUBST(extra_objs)
3170 AC_SUBST(extra_parts)
3171 AC_SUBST(extra_passes)
3172 AC_SUBST(extra_programs)
3173 AC_SUBST(float_h_file)
3174 AC_SUBST(gcc_config_arguments)
3175 AC_SUBST(gcc_gxx_include_dir)
3176 AC_SUBST(libstdcxx_incdir)
3177 AC_SUBST(gcc_version)
3178 AC_SUBST(gcc_version_full)
3179 AC_SUBST(gcc_version_trigger)
3180 AC_SUBST(host_exeext)
3181 AC_SUBST(host_extra_gcc_objs)
3182 AC_SUBST(host_xm_file_list)
3183 AC_SUBST(host_xm_file)
3184 AC_SUBST(host_xm_defines)
3185 AC_SUBST(out_host_hook_obj)
3186 AC_SUBST(install)
3187 AC_SUBST(lang_opt_files)
3188 AC_SUBST(lang_options_files)
3189 AC_SUBST(lang_specs_files)
3190 AC_SUBST(lang_tree_files)
3191 AC_SUBST(local_prefix)
3192 AC_SUBST(md_file)
3193 AC_SUBST(objc_boehm_gc)
3194 AC_SUBST(out_file)
3195 AC_SUBST(out_object_file)
3196 AC_SUBST(stage_prefix_set_by_configure)
3197 AC_SUBST(quoted_stage_prefix_set_by_configure)
3198 AC_SUBST(symbolic_link)
3199 AC_SUBST(thread_file)
3200 AC_SUBST(tm_file_list)
3201 AC_SUBST(tm_file)
3202 AC_SUBST(tm_defines)
3203 AC_SUBST(tm_p_file_list)
3204 AC_SUBST(tm_p_file)
3205 AC_SUBST(xm_file)
3206 AC_SUBST(xm_defines)
3207 AC_SUBST(target_alias)
3208 AC_SUBST(c_target_objs)
3209 AC_SUBST(cxx_target_objs)
3210 AC_SUBST(target_cpu_default)
3211
3212 AC_SUBST_FILE(target_overrides)
3213 AC_SUBST_FILE(host_overrides)
3214 AC_SUBST_FILE(language_fragments)
3215 AC_SUBST_FILE(language_hooks)
3216
3217 # Echo that links are built
3218 if test x$host = x$target
3219 then
3220         str1="native "
3221 else
3222         str1="cross-"
3223         str2=" from $host"
3224 fi
3225
3226 if test x$host != x$build
3227 then
3228         str3=" on a $build system"
3229 fi
3230
3231 if test "x$str2" != x || test "x$str3" != x
3232 then
3233         str4=
3234 fi
3235
3236 echo "Links are now set up to build a ${str1}compiler for ${target}$str4" 1>&2
3237
3238 if test "x$str2" != x || test "x$str3" != x
3239 then
3240         echo " ${str2}${str3}." 1>&2
3241 fi
3242
3243 # Configure the subdirectories
3244 # AC_CONFIG_SUBDIRS($subdirs)
3245
3246 # Create the Makefile
3247 # and configure language subdirectories
3248 AC_OUTPUT($all_outputs,
3249 [
3250 case x$CONFIG_HEADERS in
3251 xauto-host.h:config.in)
3252 echo > cstamp-h ;;
3253 esac
3254 # If the host supports symlinks, point stage[1234] at ../stage[1234] so
3255 # bootstrapping and the installation procedure can still use
3256 # CC="stage1/xgcc -Bstage1/".  If the host doesn't support symlinks,
3257 # FLAGS_TO_PASS has been modified to solve the problem there.
3258 # This is virtually a duplicate of what happens in configure.lang; we do
3259 # an extra check to make sure this only happens if ln -s can be used.
3260 if test "$symbolic_link" = "ln -s"; then
3261  for d in .. ${subdirs} fixinc ; do
3262    if test $d != ..; then
3263         STARTDIR=`${PWDCMD-pwd}`
3264         cd $d
3265         for t in stage1 stage2 stage3 stage4 stageprofile stagefeedback include
3266         do
3267                 rm -f $t
3268                 $symbolic_link ../$t $t 2>/dev/null
3269         done
3270         cd $STARTDIR
3271    fi
3272  done
3273 else true ; fi
3274 ],
3275 [subdirs='$subdirs'
3276 symbolic_link='$symbolic_link'
3277 ])