gcc/configure.ac

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