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