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