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