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