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,
   5 # 2007, 2008, 2009, 2010, 2011 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.64)
  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 [AS_HELP_STRING([--with-local-prefix=DIR],
 109                 [specifies directory to put local include])],
 110 [case "${withval}" in
 111 yes)    AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
 112 no)     ;;
 113 *)      local_prefix=$with_local_prefix ;;
 114 esac])
 115
 116 # Default local prefix if it is empty
 117 if test x$local_prefix = x; then
 118         local_prefix=/usr/local
 119 fi
 120
 121 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
 122 # passed in by the toplevel make and thus we'd get different behavior
 123 # depending on where we built the sources.
 124 gcc_gxx_include_dir=
 125 # Specify the g++ header file directory
 126 AC_ARG_WITH(gxx-include-dir,
 127 [AS_HELP_STRING([--with-gxx-include-dir=DIR],
 128                 [specifies directory to put g++ header files])],
 129 [case "${withval}" in
 130 yes)    AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
 131 no)     ;;
 132 *)      gcc_gxx_include_dir=$with_gxx_include_dir ;;
 133 esac])
 134
 135 # This logic must match libstdc++-v3/acinclude.m4:GLIBCXX_EXPORT_INSTALL_INFO.
 136 if test x${gcc_gxx_include_dir} = x; then
 137   if test x${enable_version_specific_runtime_libs} = xyes; then
 138     gcc_gxx_include_dir='${libsubdir}/include/c++'
 139   else
 140     libstdcxx_incdir='include/c++/$(version)'
 141     if test x$host != x$target; then
 142        libstdcxx_incdir="$target_alias/$libstdcxx_incdir"
 143     fi
 144     gcc_gxx_include_dir="\$(libsubdir)/\$(libsubdir_to_prefix)$libstdcxx_incdir"
 145   fi
 146 fi
 147
 148 AC_ARG_WITH(cpp_install_dir,
 149 [AC_HELP_STRING([--with-cpp-install-dir=DIR],
 150                 [install the user visible C preprocessor in DIR
 151                  (relative to PREFIX) as well as PREFIX/bin])],
 152 [if test x$withval = xyes; then
 153   AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
 154 elif test x$withval != xno; then
 155   cpp_install_dir=$withval
 156 fi])
 157
 158 # We would like to our source tree to be readonly.  However when releases or
 159 # pre-releases are generated, the flex/bison generated files as well as the
 160 # various formats of manuals need to be included along with the rest of the
 161 # sources.  Therefore we have --enable-generated-files-in-srcdir to do
 162 # just that.
 163
 164 AC_MSG_CHECKING([whether to place generated files in the source directory])
 165   dnl generated-files-in-srcdir is disabled by default
 166   AC_ARG_ENABLE(generated-files-in-srcdir,
 167     [AS_HELP_STRING([--enable-generated-files-in-srcdir],
 168                     [put copies of generated files in source dir
 169                      intended for creating source tarballs for users
 170                      without texinfo bison or flex])],
 171       generated_files_in_srcdir=$enableval,
 172       generated_files_in_srcdir=no)
 173
 174 AC_MSG_RESULT($generated_files_in_srcdir)
 175
 176 if test "$generated_files_in_srcdir" = "yes"; then
 177   GENINSRC=''
 178 else
 179   GENINSRC='#'
 180 fi
 181 AC_SUBST(GENINSRC)
 182
 183 # -------------------
 184 # Find default linker
 185 # -------------------
 186
 187 # With GNU ld
 188 AC_ARG_WITH(gnu-ld,
 189 [AS_HELP_STRING([--with-gnu-ld], [arrange to work with GNU ld])],
 190 gnu_ld_flag="$with_gnu_ld",
 191 gnu_ld_flag=no)
 192
 193 # With pre-defined ld
 194 AC_ARG_WITH(ld,
 195 [AS_HELP_STRING([--with-ld], [arrange to use the specified ld (full pathname)])],
 196 DEFAULT_LINKER="$with_ld")
 197 if test x"${DEFAULT_LINKER+set}" = x"set"; then
 198   if test ! -x "$DEFAULT_LINKER"; then
 199     AC_MSG_ERROR([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
 200   elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
 201     gnu_ld_flag=yes
 202   fi
 203   AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
 204         [Define to enable the use of a default linker.])
 205 fi
 206
 207 gnu_ld=`if test x"$gnu_ld_flag" = x"yes"; then echo 1; else echo 0; fi`
 208 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld, [Define if using GNU ld.])
 209
 210 AC_MSG_CHECKING([whether a default linker was specified])
 211 if test x"${DEFAULT_LINKER+set}" = x"set"; then
 212   if test x"$gnu_ld_flag" = x"no"; then
 213     AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
 214   else
 215     AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
 216   fi
 217 else
 218   AC_MSG_RESULT(no)
 219 fi
 220
 221 # With demangler in GNU ld
 222 AC_ARG_WITH(demangler-in-ld,
 223 [AS_HELP_STRING([--with-demangler-in-ld], [try to use demangler in GNU ld])],
 224 demangler_in_ld="$with_demangler_in_ld",
 225 demangler_in_ld=yes)
 226
 227 # ----------------------
 228 # Find default assembler
 229 # ----------------------
 230
 231 # With GNU as
 232 AC_ARG_WITH(gnu-as,
 233 [AS_HELP_STRING([--with-gnu-as], [arrange to work with GNU as])],
 234 gas_flag="$with_gnu_as",
 235 gas_flag=no)
 236
 237 AC_ARG_WITH(as,
 238 [AS_HELP_STRING([--with-as], [arrange to use the specified as (full pathname)])],
 239 DEFAULT_ASSEMBLER="$with_as")
 240 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
 241   if test ! -x "$DEFAULT_ASSEMBLER"; then
 242     AC_MSG_ERROR([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
 243   elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
 244     gas_flag=yes
 245   fi
 246   AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
 247         [Define to enable the use of a default assembler.])
 248 fi
 249
 250 gnu_as=`if test x"$gas_flag" = x"yes"; then echo 1; else echo 0; fi`
 251 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as, [Define if using GNU as.])
 252
 253 AC_MSG_CHECKING([whether a default assembler was specified])
 254 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
 255   if test x"$gas_flag" = x"no"; then
 256     AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
 257   else
 258     AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
 259   fi
 260 else
 261   AC_MSG_RESULT(no)
 262 fi
 263
 264 # ---------------
 265 # Find C compiler
 266 # ---------------
 267
 268 # If a non-executable a.out is present (e.g. created by GNU as above even if
 269 # invoked with -v only), the IRIX 6 native ld just overwrites the existing
 270 # file, even when creating an executable, so an execution test fails.
 271 # Remove possible default executable files to avoid this.
 272 #
 273 # FIXME: This really belongs into AC_PROG_CC and can be removed once
 274 # Autoconf includes it.
 275 rm -f a.out a.exe b.out
 276
 277 # Find the native compiler
 278 AC_PROG_CC
 279 AM_PROG_CC_C_O
 280 AC_PROG_CXX
 281 ACX_PROG_GNAT([-I"$srcdir"/ada])
 282
 283 # autoconf is lame and doesn't give us any substitution variable for this.
 284 if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = no"; then
 285   NO_MINUS_C_MINUS_O=yes
 286 else
 287   OUTPUT_OPTION='-o $@'
 288 fi
 289 AC_SUBST(NO_MINUS_C_MINUS_O)
 290 AC_SUBST(OUTPUT_OPTION)
 291
 292 # Remove the -O2: for historical reasons, unless bootstrapping we prefer
 293 # optimizations to be activated explicitly by the toplevel.
 294 case "$CC" in
 295   */prev-gcc/xgcc*) ;;
 296   *) CFLAGS=`echo $CFLAGS | sed "s/-O[[s0-9]]* *//" ` ;;
 297 esac
 298 AC_SUBST(CFLAGS)
 299
 300 # Determine PICFLAG for target gnatlib.
 301 GCC_PICFLAG_FOR_TARGET
 302 AC_SUBST(PICFLAG_FOR_TARGET)
 303
 304 # -------------------------
 305 # Check C compiler features
 306 # -------------------------
 307
 308 AC_USE_SYSTEM_EXTENSIONS
 309 AC_PROG_CPP
 310 AC_C_INLINE
 311
 312 AC_SYS_LARGEFILE
 313
 314 # sizeof(char) is 1 by definition.
 315 AC_CHECK_SIZEOF(void *)
 316 AC_CHECK_SIZEOF(short)
 317 AC_CHECK_SIZEOF(int)
 318 AC_CHECK_SIZEOF(long)
 319 AC_CHECK_TYPES([long long], [AC_CHECK_SIZEOF(long long)])
 320 AC_CHECK_TYPES([__int64], [AC_CHECK_SIZEOF(__int64)])
 321 GCC_STDINT_TYPES
 322
 323 # ---------------------
 324 # Warnings and checking
 325 # ---------------------
 326
 327 # Check $CC warning features (if it's GCC).
 328 # We want to use -pedantic, but we don't want warnings about
 329 # * 'long long'
 330 # * variadic macros
 331 # * overlong strings
 332 # So, we only use -pedantic if we can disable those warnings.
 333
 334 ACX_PROG_CC_WARNING_OPTS(
 335         m4_quote(m4_do([-W -Wall -Wwrite-strings -Wcast-qual])), [loose_warn])
 336 ACX_PROG_CC_WARNING_OPTS(
 337         m4_quote(m4_do([-Wstrict-prototypes -Wmissing-prototypes])),
 338         [c_loose_warn])
 339 ACX_PROG_CC_WARNING_OPTS(
 340         m4_quote(m4_do([-Wmissing-format-attribute])), [strict_warn])
 341 ACX_PROG_CC_WARNING_OPTS(
 342         m4_quote(m4_do([-Wold-style-definition -Wc++-compat])), [c_strict_warn])
 343 ACX_PROG_CC_WARNING_ALMOST_PEDANTIC(
 344         m4_quote(m4_do([-Wno-long-long -Wno-variadic-macros ],
 345                        [-Wno-overlength-strings])), [strict_warn])
 346 ACX_PROG_CC_WARNINGS_ARE_ERRORS([manual], [strict_warn])
 347
 348 # The above macros do nothing if the compiler is not GCC.  However, the
 349 # Makefile has more goo to add other flags, so these variables are used
 350 # to enable warnings only for GCC.
 351 warn_cflags=
 352 warn_cxxflags=
 353 if test "x$GCC" = "xyes"; then
 354   warn_cflags='$(GCC_WARN_CFLAGS)'
 355   warn_cxxflags='$(GCC_WARN_CXXFLAGS)'
 356 fi
 357 AC_SUBST(warn_cflags)
 358 AC_SUBST(warn_cxxflags)
 359
 360 # Enable expensive internal checks
 361 is_release=
 362 if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then
 363   is_release=yes
 364 fi
 365
 366 AC_ARG_ENABLE(checking,
 367 [AS_HELP_STRING([[--enable-checking[=LIST]]],
 368                 [enable expensive run-time checks.  With LIST,
 369                  enable only specific categories of checks.
 370                  Categories are: yes,no,all,none,release.
 371                  Flags are: assert,df,fold,gc,gcac,gimple,misc,
 372                  rtlflag,rtl,runtime,tree,valgrind,types])],
 373 [ac_checking_flags="${enableval}"],[
 374 # Determine the default checks.
 375 if test x$is_release = x ; then
 376   ac_checking_flags=yes
 377 else
 378   ac_checking_flags=release
 379 fi])
 380 IFS="${IFS=     }"; ac_save_IFS="$IFS"; IFS="$IFS,"
 381 for check in release $ac_checking_flags
 382 do
 383         case $check in
 384         # these set all the flags to specific states
 385         yes)            ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking= ;
 386                         ac_fold_checking= ; ac_gc_checking=1 ;
 387                         ac_gc_always_collect= ; ac_gimple_checking=1 ; ac_rtl_checking= ;
 388                         ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
 389                         ac_tree_checking=1 ; ac_valgrind_checking= ;
 390                         ac_types_checking=1 ;;
 391         no|none)        ac_assert_checking= ; ac_checking= ; ac_df_checking= ;
 392                         ac_fold_checking= ; ac_gc_checking= ;
 393                         ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
 394                         ac_rtlflag_checking= ; ac_runtime_checking= ;
 395                         ac_tree_checking= ; ac_valgrind_checking= ;
 396                         ac_types_checking= ;;
 397         all)            ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking=1 ;
 398                         ac_fold_checking=1 ; ac_gc_checking=1 ;
 399                         ac_gc_always_collect=1 ; ac_gimple_checking=1 ; ac_rtl_checking=1 ;
 400                         ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
 401                         ac_tree_checking=1 ; ac_valgrind_checking= ;
 402                         ac_types_checking=1 ;;
 403         release)        ac_assert_checking=1 ; ac_checking= ; ac_df_checking= ;
 404                         ac_fold_checking= ; ac_gc_checking= ;
 405                         ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
 406                         ac_rtlflag_checking= ; ac_runtime_checking=1 ;
 407                         ac_tree_checking= ; ac_valgrind_checking= ;
 408                         ac_types_checking= ;;
 409         # these enable particular checks
 410         assert)         ac_assert_checking=1 ;;
 411         df)             ac_df_checking=1 ;;
 412         fold)           ac_fold_checking=1 ;;
 413         gc)             ac_gc_checking=1 ;;
 414         gcac)           ac_gc_always_collect=1 ;;
 415         gimple)         ac_gimple_checking=1 ;;
 416         misc)           ac_checking=1 ;;
 417         rtl)            ac_rtl_checking=1 ;;
 418         rtlflag)        ac_rtlflag_checking=1 ;;
 419         runtime)        ac_runtime_checking=1 ;;
 420         tree)           ac_tree_checking=1 ;;
 421         types)          ac_types_checking=1 ;;
 422         valgrind)       ac_valgrind_checking=1 ;;
 423         *)      AC_MSG_ERROR(unknown check category $check) ;;
 424         esac
 425 done
 426 IFS="$ac_save_IFS"
 427
 428 nocommon_flag=""
 429 if test x$ac_checking != x ; then
 430   AC_DEFINE(ENABLE_CHECKING, 1,
 431 [Define if you want more run-time sanity checks.  This one gets a grab
 432    bag of miscellaneous but relatively cheap checks.])
 433   nocommon_flag=-fno-common
 434 fi
 435 AC_SUBST(nocommon_flag)
 436 if test x$ac_df_checking != x ; then
 437   AC_DEFINE(ENABLE_DF_CHECKING, 1,
 438 [Define if you want more run-time sanity checks for dataflow.])
 439 fi
 440 if test x$ac_assert_checking != x ; then
 441   AC_DEFINE(ENABLE_ASSERT_CHECKING, 1,
 442 [Define if you want assertions enabled.  This is a cheap check.])
 443 fi
 444 if test x$ac_gimple_checking != x ; then
 445   AC_DEFINE(ENABLE_GIMPLE_CHECKING, 1,
 446 [Define if you want operations on GIMPLE (the basic data structure of
 447 the high-level optimizers) to be checked for dynamic type safety at
 448 runtime.  This is moderately expensive.])
 449 fi
 450 GCC_TARGET_TEMPLATE(ENABLE_RUNTIME_CHECKING)
 451 if test x$ac_runtime_checking != x ; then
 452   AC_DEFINE(ENABLE_RUNTIME_CHECKING, 1,
 453 [Define if you want runtime assertions enabled.  This is a cheap check.])
 454 fi
 455 if test x$ac_tree_checking != x ; then
 456   AC_DEFINE(ENABLE_TREE_CHECKING, 1,
 457 [Define if you want all operations on trees (the basic data
 458    structure of the front ends) to be checked for dynamic type safety
 459    at runtime.  This is moderately expensive.  The tree browser debugging
 460    routines will also be enabled by this option.
 461    ])
 462   TREEBROWSER=tree-browser.o
 463 fi
 464 if test x$ac_types_checking != x ; then
 465   AC_DEFINE(ENABLE_TYPES_CHECKING, 1,
 466 [Define if you want all gimple types to be verified after gimplifiation.
 467    This is cheap.
 468    ])
 469 fi
 470 AC_SUBST(TREEBROWSER)
 471 if test x$ac_rtl_checking != x ; then
 472   AC_DEFINE(ENABLE_RTL_CHECKING, 1,
 473 [Define if you want all operations on RTL (the basic data structure
 474    of the optimizer and back end) to be checked for dynamic type safety
 475    at runtime.  This is quite expensive.])
 476 fi
 477 if test x$ac_rtlflag_checking != x ; then
 478   AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
 479 [Define if you want RTL flag accesses to be checked against the RTL
 480    codes that are supported for each access macro.  This is relatively
 481    cheap.])
 482 fi
 483 if test x$ac_gc_checking != x ; then
 484   AC_DEFINE(ENABLE_GC_CHECKING, 1,
 485 [Define if you want the garbage collector to do object poisoning and
 486    other memory allocation checks.  This is quite expensive.])
 487 fi
 488 if test x$ac_gc_always_collect != x ; then
 489   AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
 490 [Define if you want the garbage collector to operate in maximally
 491    paranoid mode, validating the entire heap and collecting garbage at
 492    every opportunity.  This is extremely expensive.])
 493 fi
 494 if test x$ac_fold_checking != x ; then
 495   AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
 496 [Define if you want fold checked that it never destructs its argument.
 497    This is quite expensive.])
 498 fi
 499 valgrind_path_defines=
 500 valgrind_command=
 501
 502 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
 503 dnl # an if statement.  This was the source of very frustrating bugs
 504 dnl # in converting to autoconf 2.5x!
 505 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
 506
 507 if test x$ac_valgrind_checking != x ; then
 508   # It is certainly possible that there's valgrind but no valgrind.h.
 509   # GCC relies on making annotations so we must have both.
 510   AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
 511   AC_PREPROC_IFELSE([AC_LANG_SOURCE(
 512     [[#include <valgrind/memcheck.h>
 513 #ifndef VALGRIND_DISCARD
 514 #error VALGRIND_DISCARD not defined
 515 #endif]])],
 516   [gcc_cv_header_valgrind_memcheck_h=yes],
 517   [gcc_cv_header_valgrind_memcheck_h=no])
 518   AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
 519   AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
 520   AC_PREPROC_IFELSE([AC_LANG_SOURCE(
 521     [[#include <memcheck.h>
 522 #ifndef VALGRIND_DISCARD
 523 #error VALGRIND_DISCARD not defined
 524 #endif]])],
 525   [gcc_cv_header_memcheck_h=yes],
 526   [gcc_cv_header_memcheck_h=no])
 527   AC_MSG_RESULT($gcc_cv_header_memcheck_h)
 528   AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
 529         [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
 530   if test "x$valgrind_path" = "x" \
 531     || (test $have_valgrind_h = no \
 532         && test $gcc_cv_header_memcheck_h = no \
 533         && test $gcc_cv_header_valgrind_memcheck_h = no); then
 534         AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
 535   fi
 536   valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
 537   valgrind_command="$valgrind_path -q"
 538   AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
 539 [Define if you want to run subprograms and generated programs
 540    through valgrind (a memory checker).  This is extremely expensive.])
 541   if test $gcc_cv_header_valgrind_memcheck_h = yes; then
 542     AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
 543         [Define if valgrind's valgrind/memcheck.h header is installed.])
 544   fi
 545   if test $gcc_cv_header_memcheck_h = yes; then
 546     AC_DEFINE(HAVE_MEMCHECK_H, 1,
 547         [Define if valgrind's memcheck.h header is installed.])
 548   fi
 549 fi
 550 AC_SUBST(valgrind_path_defines)
 551 AC_SUBST(valgrind_command)
 552
 553 # Enable code coverage collection
 554 AC_ARG_ENABLE(coverage,
 555 [AS_HELP_STRING([[--enable-coverage[=LEVEL]]],
 556                 [enable compiler's code coverage collection.
 557                  Use to measure compiler performance and locate
 558                  unused parts of the compiler. With LEVEL, specify
 559                  optimization. Values are opt, noopt,
 560                  default is noopt])],
 561 [case "${enableval}" in
 562   yes|noopt)
 563     coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
 564     ;;
 565   opt)
 566     coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
 567     ;;
 568   no)
 569     # a.k.a. --disable-coverage
 570     coverage_flags=""
 571     ;;
 572   *)
 573     AC_MSG_ERROR(unknown coverage setting $enableval)
 574     ;;
 575 esac],
 576 [coverage_flags=""])
 577 AC_SUBST(coverage_flags)
 578
 579 AC_ARG_ENABLE(gather-detailed-mem-stats,
 580 [AS_HELP_STRING([--enable-gather-detailed-mem-stats],
 581                 [enable detailed memory allocation stats gathering])], [],
 582 [enable_gather_detailed_mem_stats=no])
 583 if test x$enable_gather_detailed_mem_stats = xyes ; then
 584   AC_DEFINE(GATHER_STATISTICS, 1,
 585         [Define to enable detailed memory allocation stats gathering.])
 586 fi
 587
 588 # -------------------------------
 589 # Miscenalleous configure options
 590 # -------------------------------
 591
 592 # See if we are building gcc with C++.
 593 AC_ARG_ENABLE(build-with-cxx,
 594 [AS_HELP_STRING([--enable-build-with-cxx],
 595                 [build with C++ compiler instead of C compiler])],
 596 ENABLE_BUILD_WITH_CXX=$enableval,
 597 ENABLE_BUILD_WITH_CXX=no)
 598 AC_SUBST(ENABLE_BUILD_WITH_CXX)
 599 if test "$ENABLE_BUILD_WITH_CXX" = "yes"; then
 600   AC_DEFINE(ENABLE_BUILD_WITH_CXX, 1,
 601             [Define if building with C++.])
 602 fi
 603
 604 # With stabs
 605 AC_ARG_WITH(stabs,
 606 [AS_HELP_STRING([--with-stabs],
 607                 [arrange to use stabs instead of host debug format])],
 608 stabs="$with_stabs",
 609 stabs=no)
 610
 611 # Determine whether or not multilibs are enabled.
 612 AC_ARG_ENABLE(multilib,
 613 [AS_HELP_STRING([--enable-multilib],
 614                 [enable library support for multiple ABIs])],
 615 [], [enable_multilib=yes])
 616 AC_SUBST(enable_multilib)
 617
 618 # Enable __cxa_atexit for C++.
 619 AC_ARG_ENABLE(__cxa_atexit,
 620 [AS_HELP_STRING([--enable-__cxa_atexit], [enable __cxa_atexit for C++])],
 621 [], [])
 622
 623 # Enable C extension for decimal float if target supports it.
 624 GCC_AC_ENABLE_DECIMAL_FLOAT([$target])
 625
 626 dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi`
 627 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp,
 628 [Define to 1 to enable decimal float extension to C.])
 629
 630 # Use default_decimal_float for dependency.
 631 enable_decimal_float=$default_decimal_float
 632
 633 bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi`
 634 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid,
 635 [Define to 1 to specify that we are using the BID decimal floating
 636 point format instead of DPD])
 637
 638 # Enable C extension for fixed-point arithmetic.
 639 AC_ARG_ENABLE(fixed-point,
 640 [AS_HELP_STRING([--enable-fixed-point],
 641                 [enable fixed-point arithmetic extension to C])],
 642 [],
 643 [
 644   case $target in
 645     arm*)
 646       enable_fixed_point=yes
 647       ;;
 648
 649     mips*-*-*)
 650       case $host in
 651         mips*-sgi-irix*)
 652           AC_MSG_WARN([fixed-point is not supported on IRIX, ignored])
 653           enable_fixed_point=no
 654           ;;
 655         *)
 656           enable_fixed_point=yes
 657           ;;
 658       esac
 659       ;;
 660     *)
 661       AC_MSG_WARN([fixed-point is not supported for this target, ignored])
 662       enable_fixed_point=no
 663       ;;
 664   esac
 665 ])
 666 AC_SUBST(enable_fixed_point)
 667
 668 fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi`
 669 AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint,
 670 [Define to 1 to enable fixed-point arithmetic extension to C.])
 671
 672 # Enable threads
 673 # Pass with no value to take the default
 674 # Pass with a value to specify a thread package
 675 AC_ARG_ENABLE(threads,
 676 [AS_HELP_STRING([[--enable-threads[=LIB]]],
 677                 [enable thread usage for target GCC,
 678                  using LIB thread package])],,
 679 [enable_threads=''])
 680
 681 AC_ARG_ENABLE(tls,
 682 [AS_HELP_STRING([--enable-tls],
 683                 [enable or disable generation of tls code
 684                  overriding the assembler check for tls support])],
 685 [
 686   case $enable_tls in
 687     yes | no) ;;
 688     *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
 689 Valid choices are 'yes' and 'no'.]) ;;
 690   esac
 691 ], [enable_tls=''])
 692
 693 AC_ARG_ENABLE(objc-gc,
 694 [AS_HELP_STRING([--enable-objc-gc],
 695                 [enable the use of Boehm's garbage collector with
 696                  the GNU Objective-C runtime])],
 697 if test x$enable_objc_gc = xno; then
 698         objc_boehm_gc=''
 699 else
 700         objc_boehm_gc=1
 701 fi,
 702 objc_boehm_gc='')
 703
 704 AC_ARG_WITH(dwarf2,
 705 [AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2])],
 706 dwarf2="$with_dwarf2",
 707 dwarf2=no)
 708
 709 AC_ARG_ENABLE(shared,
 710 [AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])],
 711 [
 712   case $enable_shared in
 713   yes | no) ;;
 714   *)
 715     enable_shared=no
 716     IFS="${IFS=         }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
 717     for pkg in $enableval; do
 718       if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
 719         enable_shared=yes
 720       fi
 721     done
 722     IFS="$ac_save_ifs"
 723     ;;
 724   esac
 725 ], [enable_shared=yes])
 726 AC_SUBST(enable_shared)
 727
 728 AC_ARG_WITH([native-system-header-dir],
 729   [  --with-native-system-header-dir=dir
 730                           use dir as the directory to look for standard
 731                           system header files in.  Defaults to /usr/include.],
 732 [
 733  case ${with_native_system_header_dir} in
 734  yes|no) AC_MSG_ERROR([bad value ${withval} given for --with-native-system-header-dir]) ;;
 735  /* | [[A-Za-z]]:[[\\/]]*) ;;
 736  *) AC_MSG_ERROR([--with-native-system-header-dir argument ${withval} must be an absolute directory]) ;;
 737  esac
 738  configured_native_system_header_dir="${withval}"
 739 ], [configured_native_system_header_dir=])
 740
 741 AC_ARG_WITH(build-sysroot,
 742   [AS_HELP_STRING([--with-build-sysroot=sysroot],
 743                   [use sysroot as the system root during the build])],
 744   [if test x"$withval" != x ; then
 745      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
 746    fi],
 747   [SYSROOT_CFLAGS_FOR_TARGET=])
 748 AC_SUBST(SYSROOT_CFLAGS_FOR_TARGET)
 749
 750 AC_ARG_WITH(sysroot,
 751 [AS_HELP_STRING([[--with-sysroot[=DIR]]],
 752                 [search for usr/lib, usr/include, et al, within DIR])],
 753 [
 754  case ${with_sysroot} in
 755  yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
 756  *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
 757  esac
 758
 759  TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
 760  CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
 761
 762  if test "x$prefix" = xNONE; then
 763   test_prefix=/usr/local
 764  else
 765   test_prefix=$prefix
 766  fi
 767  if test "x$exec_prefix" = xNONE; then
 768   test_exec_prefix=$test_prefix
 769  else
 770   test_exec_prefix=$exec_prefix
 771  fi
 772  case ${TARGET_SYSTEM_ROOT} in
 773  "${test_prefix}"|"${test_prefix}/"*|\
 774  "${test_exec_prefix}"|"${test_exec_prefix}/"*|\
 775  '${prefix}'|'${prefix}/'*|\
 776  '${exec_prefix}'|'${exec_prefix}/'*)
 777    t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
 778    TARGET_SYSTEM_ROOT_DEFINE="$t"
 779    ;;
 780  esac
 781 ], [
 782  TARGET_SYSTEM_ROOT=
 783  TARGET_SYSTEM_ROOT_DEFINE=
 784  CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
 785 ])
 786 AC_SUBST(TARGET_SYSTEM_ROOT)
 787 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
 788 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
 789
 790 AC_ARG_WITH(specs,
 791   [AS_HELP_STRING([--with-specs=SPECS],
 792                   [add SPECS to driver command-line processing])],
 793   [CONFIGURE_SPECS=$withval],
 794   [CONFIGURE_SPECS=]
 795 )
 796 AC_SUBST(CONFIGURE_SPECS)
 797
 798 ACX_PKGVERSION([GCC])
 799 ACX_BUGURL([http://gcc.gnu.org/bugs.html])
 800
 801 # Sanity check enable_languages in case someone does not run the toplevel
 802 # configure # script.
 803 AC_ARG_ENABLE(languages,
 804 [AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])],
 805 [case ,${enable_languages}, in
 806        ,,|,yes,)
 807                 # go safe -- we cannot be much sure without the toplevel
 808                 # configure's
 809                 # analysis of which target libs are present and usable
 810                 enable_languages=c
 811                 ;;
 812          *,all,*)
 813                 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
 814                 ;;
 815         *,c,*)
 816                 ;;
 817         *)
 818                 enable_languages=c,${enable_languages}
 819                 ;;
 820 esac],
 821 [enable_languages=c])
 822
 823 AC_ARG_WITH(multilib-list,
 824 [AS_HELP_STRING([--with-multilib-list], [select multilibs (SH and x86-64 only)])],
 825 :,
 826 with_multilib_list=default)
 827
 828 # -------------------------
 829 # Checks for other programs
 830 # -------------------------
 831
 832 AC_PROG_MAKE_SET
 833
 834 # Find some useful tools
 835 AC_PROG_AWK
 836 # We need awk to create options.c and options.h.
 837 # Bail out if it's missing.
 838 case ${AWK} in
 839   "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
 840 esac
 841
 842 gcc_AC_PROG_LN_S
 843 ACX_PROG_LN($LN_S)
 844 AC_PROG_RANLIB
 845 case "${host}" in
 846 *-*-darwin*)
 847   # By default, the Darwin ranlib will not treat common symbols as
 848   # definitions when  building the archive table of contents.  Other
 849   # ranlibs do that; pass an option to the Darwin ranlib that makes
 850   # it behave similarly.
 851   ranlib_flags="-c"
 852   ;;
 853 *)
 854   ranlib_flags=""
 855 esac
 856 AC_SUBST(ranlib_flags)
 857
 858 gcc_AC_PROG_INSTALL
 859
 860 # See if cmp has --ignore-initial.
 861 gcc_AC_PROG_CMP_IGNORE_INITIAL
 862
 863 # See if we have the mktemp command.
 864 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
 865
 866 # See if makeinfo has been installed and is modern enough
 867 # that we can use it.
 868 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
 869   [GNU texinfo.* \([0-9][0-9.]*\)],
 870   [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
 871 if test $gcc_cv_prog_makeinfo_modern = no; then
 872   AC_MSG_WARN([
 873 *** Makeinfo is missing or too old.
 874 *** Info documentation will not be built.])
 875   BUILD_INFO=
 876 else
 877   BUILD_INFO=info
 878 fi
 879 AC_SUBST(BUILD_INFO)
 880
 881 # Is pod2man recent enough to regenerate manpages?
 882 AC_MSG_CHECKING([for recent Pod::Man])
 883 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
 884   AC_MSG_RESULT(yes)
 885   GENERATED_MANPAGES=generated-manpages
 886 else
 887   AC_MSG_RESULT(no)
 888   GENERATED_MANPAGES=
 889 fi
 890 AC_SUBST(GENERATED_MANPAGES)
 891
 892 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
 893
 894 # How about lex?
 895 dnl Don't use AC_PROG_LEX; we insist on flex.
 896 dnl LEXLIB is not useful in gcc.
 897 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
 898
 899 # Bison?
 900 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
 901
 902 # Binutils are not build modules, unlike bison/flex/makeinfo.  So we
 903 # check for build == host before using them.
 904
 905 # NM
 906 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
 907   && test -d ../binutils ; then
 908   NM='${objdir}/../binutils/nm-new'
 909 else
 910   AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
 911 fi
 912
 913 # AR
 914 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
 915   && test -d ../binutils ; then
 916   AR='${objdir}/../binutils/ar'
 917 else
 918   AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
 919 fi
 920
 921
 922 # --------------------
 923 # Checks for C headers
 924 # --------------------
 925
 926 # Need to reject headers which give warnings, so that the -Werror bootstrap
 927 # works later. *sigh*  This needs to come before all header checks.
 928 AC_PROG_CPP_WERROR
 929
 930 AC_HEADER_STDC
 931 AC_HEADER_TIME
 932 ACX_HEADER_STRING
 933 AC_HEADER_SYS_WAIT
 934 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
 935                  fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
 936                  sys/resource.h sys/param.h sys/times.h sys/stat.h \
 937                  direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
 938
 939 # Check for thread headers.
 940 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
 941 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
 942
 943 # These tests can't be done till we know if we have limits.h.
 944 gcc_AC_C_CHAR_BIT
 945 AC_C_BIGENDIAN
 946
 947 # ----------------------
 948 # Checks for C++ headers
 949 # ----------------------
 950
 951 dnl Autoconf will give an error in the configure script if there is no
 952 dnl C++ preprocessor.  Hack to prevent that.
 953 m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl
 954 AC_PROG_CXXCPP
 955 m4_popdef([AC_MSG_ERROR])[]dnl
 956
 957 AC_LANG_PUSH(C++)
 958
 959 AC_CHECK_HEADERS(unordered_map)
 960 AC_CHECK_HEADERS(tr1/unordered_map)
 961 AC_CHECK_HEADERS(ext/hash_map)
 962
 963 AC_LANG_POP(C++)
 964
 965 # --------
 966 # UNSORTED
 967 # --------
 968
 969
 970 # These libraries may be used by collect2.
 971 # We may need a special search path to get them linked.
 972 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
 973 [save_LIBS="$LIBS"
 974 for libs in '' -lld -lmld \
 975                 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
 976                 '-L/usr/lib/cmplrs/cc3.11 -lmld'
 977 do
 978         LIBS="$libs"
 979         AC_TRY_LINK_FUNC(ldopen,
 980                 [gcc_cv_collect2_libs="$libs"; break])
 981 done
 982 LIBS="$save_LIBS"
 983 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
 984 case $gcc_cv_collect2_libs in
 985         "none required")        ;;
 986         *)      COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
 987 esac
 988 AC_SUBST(COLLECT2_LIBS)
 989
 990 # When building Ada code on Alpha, we need exc_resume which is usually in
 991 # -lexc.  So test for it.
 992 save_LIBS="$LIBS"
 993 LIBS=
 994 AC_SEARCH_LIBS(exc_resume, exc)
 995 GNAT_LIBEXC="$LIBS"
 996 LIBS="$save_LIBS"
 997 AC_SUBST(GNAT_LIBEXC)
 998
 999 # To support -mcpu=native on Solaris/SPARC, we need libkstat.
1000 save_LIBS="$LIBS"
1001 LIBS=
1002 AC_SEARCH_LIBS(kstat_open, kstat)
1003 EXTRA_GCC_LIBS="$LIBS"
1004 LIBS="$save_LIBS"
1005 AC_SUBST(EXTRA_GCC_LIBS)
1006
1007 # Some systems put ldexp and frexp in libm instead of libc; assume
1008 # they're both in the same place.  jcf-dump needs them.
1009 save_LIBS="$LIBS"
1010 LIBS=
1011 AC_SEARCH_LIBS(ldexp, m)
1012 LDEXP_LIB="$LIBS"
1013 LIBS="$save_LIBS"
1014 AC_SUBST(LDEXP_LIB)
1015
1016 # Use <inttypes.h> only if it exists,
1017 # doesn't clash with <sys/types.h>, and declares intmax_t.
1018 AC_MSG_CHECKING(for inttypes.h)
1019 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
1020 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1021 [[#include <sys/types.h>
1022 #include <inttypes.h>]],
1023   [[intmax_t i = -1;]])],
1024   [gcc_cv_header_inttypes_h=yes],
1025   [gcc_cv_header_inttypes_h=no])])
1026 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
1027 if test $gcc_cv_header_inttypes_h = yes; then
1028   AC_DEFINE(HAVE_INTTYPES_H, 1,
1029         [Define if you have a working <inttypes.h> header file.])
1030 fi
1031
1032 dnl Disabled until we have a complete test for buggy enum bitfields.
1033 dnl gcc_AC_C_ENUM_BF_UNSIGNED
1034
1035 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
1036   ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
1037   fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
1038   fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
1039   putchar_unlocked putc_unlocked)
1040 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoll atoq \
1041         sysconf strsignal getrusage nl_langinfo \
1042         gettimeofday mbstowcs wcswidth mmap setlocale \
1043         gcc_UNLOCKED_FUNCS madvise)
1044
1045 if test x$ac_cv_func_mbstowcs = xyes; then
1046   AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
1047 [    AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
1048 int main()
1049 {
1050   mbstowcs(0, "", 0);
1051   return 0;
1052 }]])],
1053     [gcc_cv_func_mbstowcs_works=yes],
1054     [gcc_cv_func_mbstowcs_works=no],
1055     [gcc_cv_func_mbstowcs_works=yes])])
1056   if test x$gcc_cv_func_mbstowcs_works = xyes; then
1057     AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
1058   [Define this macro if mbstowcs does not crash when its
1059    first argument is NULL.])
1060   fi
1061 fi
1062
1063 AC_CHECK_TYPE(ssize_t, int)
1064 AC_CHECK_TYPE(caddr_t, char *)
1065
1066 gcc_AC_FUNC_MMAP_BLACKLIST
1067
1068 case "${host}" in
1069 *-*-*vms*)
1070   # Under VMS, vfork works very differently than on Unix. The standard test
1071   # won't work, and it isn't easily adaptable. It makes more sense to
1072   # just force it.
1073   ac_cv_func_vfork_works=yes
1074   ;;
1075 esac
1076 AC_FUNC_FORK
1077
1078 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which exposes a different
1079 # iconv() prototype.
1080 AS_IF([test "$ENABLE_BUILD_WITH_CXX" = "yes"],
1081   [AC_LANG_PUSH([C++])
1082    AM_ICONV
1083    AC_LANG_POP([C++])],
1084   [AM_ICONV])
1085
1086 # Until we have in-tree GNU iconv:
1087 LIBICONV_DEP=
1088 AC_SUBST(LIBICONV_DEP)
1089
1090 AM_LC_MESSAGES
1091
1092 AM_LANGINFO_CODESET
1093
1094 # We will need to find libiberty.h and ansidecl.h
1095 saved_CFLAGS="$CFLAGS"
1096 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include"
1097 saved_CXXFLAGS="$CXXFLAGS"
1098 CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include"
1099 gcc_AC_CHECK_DECLS(getenv atol asprintf sbrk abort atof getcwd getwd \
1100         strsignal strstr strverscmp \
1101         errno snprintf vsnprintf vasprintf malloc realloc calloc \
1102         free basename getopt clock getpagesize gcc_UNLOCKED_FUNCS, , ,[
1103 #include "ansidecl.h"
1104 #include "system.h"])
1105
1106 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1107 #include "ansidecl.h"
1108 #include "system.h"
1109 #ifdef HAVE_SYS_RESOURCE_H
1110 #include <sys/resource.h>
1111 #endif
1112 ])
1113
1114 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1115 #include "ansidecl.h"
1116 #include "system.h"
1117 #ifdef HAVE_SYS_RESOURCE_H
1118 #include <sys/resource.h>
1119 #endif
1120 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1121 [Define to `long' if <sys/resource.h> doesn't define.])])
1122
1123 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1124 # FREAD and FWRITE macros.  Fortunately, for GCC's single usage of ldgetname
1125 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1126 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1127 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1128 #include "ansidecl.h"
1129 #include "system.h"
1130 #ifdef HAVE_LDFCN_H
1131 #undef FREAD
1132 #undef FWRITE
1133 #include <ldfcn.h>
1134 #endif
1135 ])
1136
1137 gcc_AC_CHECK_DECLS(times, , ,[
1138 #include "ansidecl.h"
1139 #include "system.h"
1140 #ifdef HAVE_SYS_TIMES_H
1141 #include <sys/times.h>
1142 #endif
1143 ])
1144
1145 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1146 #include "ansidecl.h"
1147 #include "system.h"
1148 #include <signal.h>
1149 ])
1150
1151 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which hides the madvise()
1152 # prototype.
1153 AS_IF([test "$ENABLE_BUILD_WITH_CXX" = "yes"],
1154   [AC_LANG_PUSH([C++])
1155    gcc_AC_CHECK_DECLS(madvise, , ,[
1156      #include "ansidecl.h"
1157      #include "system.h"
1158    ])
1159    AC_LANG_POP([C++])],
1160   [gcc_AC_CHECK_DECLS(madvise, , ,[
1161      #include "ansidecl.h"
1162      #include "system.h"
1163    ])
1164 ])
1165
1166 # More time-related stuff.
1167 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1168 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1169 #include "ansidecl.h"
1170 #include "system.h"
1171 #ifdef HAVE_SYS_TIMES_H
1172 #include <sys/times.h>
1173 #endif
1174 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1175 if test $ac_cv_struct_tms = yes; then
1176   AC_DEFINE(HAVE_STRUCT_TMS, 1,
1177   [Define if <sys/times.h> defines struct tms.])
1178 fi
1179
1180 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1181 # revisit after autoconf 2.50.
1182 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1183 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1184 #include "ansidecl.h"
1185 #include "system.h"
1186 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1187 if test $gcc_cv_type_clock_t = yes; then
1188   AC_DEFINE(HAVE_CLOCK_T, 1,
1189   [Define if <time.h> defines clock_t.])
1190 fi
1191
1192 # Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1193 CFLAGS="$saved_CFLAGS"
1194 CXXFLAGS="$saved_CXXFLAGS"
1195
1196 gcc_AC_INITFINI_ARRAY
1197
1198 # mkdir takes a single argument on some systems.
1199 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1200
1201 # File extensions
1202 manext='.1'
1203 objext='.o'
1204 AC_SUBST(manext)
1205 AC_SUBST(objext)
1206
1207 # With Setjmp/Longjmp based exception handling.
1208 AC_ARG_ENABLE(sjlj-exceptions,
1209 [AS_HELP_STRING([--enable-sjlj-exceptions],
1210                 [arrange to use setjmp/longjmp exception handling])],
1211 [case $target in
1212   *-*-hpux10*)
1213     if test $enableval != yes; then
1214       AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1215       enableval=yes
1216     fi
1217     ;;
1218 esac
1219 force_sjlj_exceptions=yes],
1220 [case $target in
1221   *-*-hpux10*)
1222     force_sjlj_exceptions=yes
1223     enableval=yes
1224     ;;
1225   *)
1226     force_sjlj_exceptions=no
1227     ;;
1228 esac])
1229 if test $force_sjlj_exceptions = yes; then
1230   sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1231   AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1232     [Define 0/1 to force the choice for exception handling model.])
1233 fi
1234
1235 # --------------------------------------------------------
1236 # Build, host, and target specific configuration fragments
1237 # --------------------------------------------------------
1238
1239 # Collect build-machine-specific information.
1240 . ${srcdir}/config.build
1241
1242 # Collect host-machine-specific information.
1243 . ${srcdir}/config.host
1244
1245 target_gtfiles=
1246
1247 # Collect target-machine-specific information.
1248 . ${srcdir}/config.gcc
1249
1250 extra_objs="${host_extra_objs} ${extra_objs}"
1251 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1252
1253 # Default the target-machine variables that were not explicitly set.
1254 if test x"$tm_file" = x
1255 then tm_file=$cpu_type/$cpu_type.h; fi
1256
1257 if test x"$extra_headers" = x
1258 then extra_headers=; fi
1259
1260 if test x$md_file = x
1261 then md_file=$cpu_type/$cpu_type.md; fi
1262
1263 if test x$out_file = x
1264 then out_file=$cpu_type/$cpu_type.c; fi
1265
1266 if test x"$tmake_file" = x
1267 then tmake_file=$cpu_type/t-$cpu_type
1268 fi
1269
1270 if test x"$dwarf2" = xyes
1271 then tm_file="$tm_file tm-dwarf2.h"
1272 fi
1273
1274 # Say what files are being used for the output code and MD file.
1275 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1276 echo "Using \`$srcdir/config/$md_file' as machine description file."
1277
1278 # If any of the xm_file variables contain nonexistent files, warn
1279 # about them and drop them.
1280
1281 bx=
1282 for x in $build_xm_file; do
1283   if    test -f $srcdir/config/$x
1284   then      bx="$bx $x"
1285   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1286   fi
1287 done
1288 build_xm_file="$bx"
1289
1290 hx=
1291 for x in $host_xm_file; do
1292   if    test -f $srcdir/config/$x
1293   then      hx="$hx $x"
1294   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1295   fi
1296 done
1297 host_xm_file="$hx"
1298
1299 tx=
1300 for x in $xm_file; do
1301   if    test -f $srcdir/config/$x
1302   then      tx="$tx $x"
1303   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1304   fi
1305 done
1306 xm_file="$tx"
1307
1308 count=a
1309 for f in $tm_file; do
1310         count=${count}x
1311 done
1312 if test $count = ax; then
1313         echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1314 else
1315         echo "Using the following target machine macro files:"
1316         for f in $tm_file; do
1317                 echo "  $srcdir/config/$f"
1318         done
1319 fi
1320
1321 if test x$need_64bit_hwint = xyes; then
1322         AC_DEFINE(NEED_64BIT_HOST_WIDE_INT, 1,
1323 [Define to 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h).])
1324 fi
1325
1326 if test x$use_long_long_for_widest_fast_int = xyes; then
1327         AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1328 [Define to 1 if the 'long long' (or '__int64') is wider than 'long' but still
1329 efficiently supported by the host hardware.])
1330 fi
1331
1332 count=a
1333 for f in $host_xm_file; do
1334         count=${count}x
1335 done
1336 if test $count = a; then
1337         :
1338 elif test $count = ax; then
1339         echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1340 else
1341         echo "Using the following host machine macro files:"
1342         for f in $host_xm_file; do
1343                 echo "  $srcdir/config/$f"
1344         done
1345 fi
1346 echo "Using ${out_host_hook_obj} for host machine hooks."
1347
1348 if test "$host_xm_file" != "$build_xm_file"; then
1349         count=a
1350         for f in $build_xm_file; do
1351                 count=${count}x
1352         done
1353         if test $count = a; then
1354                 :
1355         elif test $count = ax; then
1356                 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1357         else
1358                 echo "Using the following build machine macro files:"
1359                 for f in $build_xm_file; do
1360                         echo "  $srcdir/config/$f"
1361                 done
1362         fi
1363 fi
1364
1365 if test -n "$configured_native_system_header_dir"; then
1366   native_system_header_dir=$configured_native_system_header_dir
1367 fi
1368 NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir"
1369 AC_SUBST(NATIVE_SYSTEM_HEADER_DIR)
1370
1371 case ${host} in
1372   powerpc*-*-darwin*)
1373     AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1374       gcc_cv_mcontext_underscores,
1375       AC_COMPILE_IFELSE([
1376 #include <sys/cdefs.h>
1377 #include <sys/signal.h>
1378 #include <ucontext.h>
1379 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1380 ],
1381         gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1382       if test $gcc_cv_mcontext_underscores = yes; then
1383         AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1384           [mcontext_t fields start with __])
1385       fi
1386     ;;
1387 esac
1388
1389 # ---------
1390 # Threading
1391 # ---------
1392
1393 # Check if a valid thread package
1394 case ${enable_threads} in
1395   "" | no)
1396     # No threads
1397     target_thread_file='single'
1398     ;;
1399   yes)
1400     # default
1401     target_thread_file='single'
1402     ;;
1403   aix | dce | lynx | mipssde | posix | rtems | \
1404   single | tpf | vxworks | win32)
1405     target_thread_file=${enable_threads}
1406     ;;
1407   *)
1408     echo "${enable_threads} is an unknown thread package" 1>&2
1409     exit 1
1410     ;;
1411 esac
1412
1413 if test x${thread_file} = x; then
1414   # No thread file set by target-specific clauses in config.gcc,
1415   # so use file chosen by default logic above
1416   thread_file=${target_thread_file}
1417 fi
1418
1419 # Make gthr-default.h if we have a thread file.
1420 gthread_flags=
1421 if test $thread_file != single; then
1422   echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h-t
1423   if diff gthr-default.h-t gthr-default.h 2>/dev/null; then
1424     rm -f gthr-default.h-t
1425   else
1426     mv -f gthr-default.h-t gthr-default.h
1427   fi
1428   gthread_flags=-DHAVE_GTHR_DEFAULT
1429 fi
1430 AC_SUBST(gthread_flags)
1431
1432 # --------
1433 # UNSORTED
1434 # --------
1435
1436 use_cxa_atexit=no
1437 if test x$enable___cxa_atexit = xyes || \
1438    test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1439   if test x$host = x$target; then
1440     case $host in
1441       # mingw32 doesn't have __cxa_atexit but uses atexit registration
1442       # keyed to flag_use_cxa_atexit
1443       *-*-mingw32*)
1444         use_cxa_atexit=yes
1445         ;;
1446       *)
1447         AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1448           [echo "__cxa_atexit can't be enabled on this target"])
1449         ;;
1450     esac
1451   else
1452     # We can't check for __cxa_atexit when building a cross, so assume
1453     # it is available
1454     use_cxa_atexit=yes
1455   fi
1456   if test x$use_cxa_atexit = xyes; then
1457     AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1458       [Define if you want to use __cxa_atexit, rather than atexit, to
1459       register C++ destructors for local statics and global objects.
1460       This is essential for fully standards-compliant handling of
1461       destructors, but requires __cxa_atexit in libc.])
1462   fi
1463 fi
1464
1465 # Look for a file containing extra machine modes.
1466 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1467   extra_modes_file='$(srcdir)'/config/${extra_modes}
1468   AC_SUBST(extra_modes_file)
1469   AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1470   [Define to the name of a file containing a list of extra machine modes
1471    for this architecture.])
1472 fi
1473
1474 # Convert extra_options into a form suitable for Makefile use.
1475 extra_opt_files=
1476 all_opt_files=
1477 for f in $extra_options; do
1478   extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1479   all_opt_files="$all_opt_files $srcdir/config/$f"
1480 done
1481 AC_SUBST(extra_opt_files)
1482
1483 # auto-host.h is the file containing items generated by autoconf and is
1484 # the first file included by config.h.
1485 # If host=build, it is correct to have bconfig include auto-host.h
1486 # as well.  If host!=build, we are in error and need to do more
1487 # work to find out the build config parameters.
1488 if test x$host = x$build
1489 then
1490         build_auto=auto-host.h
1491 else
1492         # We create a subdir, then run autoconf in the subdir.
1493         # To prevent recursion we set host and build for the new
1494         # invocation of configure to the build for this invocation
1495         # of configure.
1496         tempdir=build.$$
1497         rm -rf $tempdir
1498         mkdir $tempdir
1499         cd $tempdir
1500         case ${srcdir} in
1501         /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1502         *) realsrcdir=../${srcdir};;
1503         esac
1504         saved_CFLAGS="${CFLAGS}"
1505         CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1506         LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1507         ${realsrcdir}/configure \
1508                 --enable-languages=${enable_languages-all} \
1509                 --target=$target_alias --host=$build_alias --build=$build_alias
1510         CFLAGS="${saved_CFLAGS}"
1511
1512         # We just finished tests for the build machine, so rename
1513         # the file auto-build.h in the gcc directory.
1514         mv auto-host.h ../auto-build.h
1515         cd ..
1516         rm -rf $tempdir
1517         build_auto=auto-build.h
1518 fi
1519 AC_SUBST(build_subdir)
1520
1521 tm_file="${tm_file} defaults.h"
1522 tm_p_file="${tm_p_file} tm-preds.h"
1523 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1524 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1525 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1526 # put this back in temporarily.
1527 xm_file="auto-host.h ansidecl.h ${xm_file}"
1528
1529 # --------
1530 # UNSORTED
1531 # --------
1532
1533 changequote(,)dnl
1534 # Compile in configure arguments.
1535 if test -f configargs.h ; then
1536         # Being re-configured.
1537         gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1538         gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1539 else
1540         gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1541 fi
1542
1543 # Double all backslashes and backslash all quotes to turn
1544 # gcc_config_arguments into a C string.
1545 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1546 $gcc_config_arguments
1547 EOF
1548 gcc_config_arguments_str=`cat conftest.out`
1549 rm -f conftest.out
1550
1551 cat > configargs.h <<EOF
1552 /* Generated automatically. */
1553 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1554 static const char thread_model[] = "$thread_file";
1555
1556 static const struct {
1557   const char *name, *value;
1558 } configure_default_options[] = $configure_default_options;
1559 EOF
1560 changequote([,])dnl
1561
1562 changequote(,)dnl
1563 gcc_BASEVER=`cat $srcdir/BASE-VER`
1564 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
1565 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
1566 if test -f $srcdir/REVISION ; then
1567         gcc_REVISION=`cat $srcdir/REVISION`
1568 else
1569         gcc_REVISION=""
1570 fi
1571 cat > plugin-version.h <<EOF
1572 #include "configargs.h"
1573
1574 #define GCCPLUGIN_VERSION_MAJOR   `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'`
1575 #define GCCPLUGIN_VERSION_MINOR   `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'`
1576 #define GCCPLUGIN_VERSION_PATCHLEVEL   `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'`
1577 #define GCCPLUGIN_VERSION  (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR)
1578
1579 static char basever[] = "$gcc_BASEVER";
1580 static char datestamp[] = "$gcc_DATESTAMP";
1581 static char devphase[] = "$gcc_DEVPHASE";
1582 static char revision[] = "$gcc_REVISION";
1583
1584 /* FIXME plugins: We should make the version information more precise.
1585    One way to do is to add a checksum. */
1586
1587 static struct plugin_gcc_version gcc_version = {basever, datestamp,
1588                                                 devphase, revision,
1589                                                 configuration_arguments};
1590 EOF
1591 changequote([,])dnl
1592
1593 # Internationalization
1594 ZW_GNU_GETTEXT_SISTER_DIR
1595
1596 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1597 # -liconv on the link line twice.
1598 case "$LIBINTL" in *$LIBICONV*)
1599         LIBICONV= ;;
1600 esac
1601
1602 AC_ARG_ENABLE(secureplt,
1603 [AS_HELP_STRING([--enable-secureplt],
1604                 [enable -msecure-plt by default for PowerPC])],
1605 [], [])
1606
1607 AC_ARG_ENABLE(leading-mingw64-underscores,
1608   AS_HELP_STRING([--enable-leading-mingw64-underscores],
1609                  [enable leading underscores on 64 bit mingw targets]),
1610   [],[])
1611 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
1612   [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
1613     [Define if we should use leading underscore on 64 bit mingw targets])])
1614
1615 AC_ARG_ENABLE(cld,
1616 [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [],
1617 [enable_cld=no])
1618
1619 AC_ARG_ENABLE(frame-pointer,
1620 [AS_HELP_STRING([--enable-frame-pointer],
1621                 [enable -fno-omit-frame-pointer by default for 32bit x86])], [],
1622 [
1623 case $target_os in
1624 linux* | darwin[[8912]]*)
1625   # Enable -fomit-frame-pointer by default for Linux and Darwin with
1626   # DWARF2.
1627   enable_frame_pointer=no
1628   ;;
1629 *)
1630   enable_frame_pointer=yes
1631   ;;
1632 esac
1633 ])
1634
1635 # Windows32 Registry support for specifying GCC installation paths.
1636 AC_ARG_ENABLE(win32-registry,
1637 [AS_HELP_STRING([--disable-win32-registry],
1638                 [disable lookup of installation paths in the
1639                  Registry on Windows hosts])
1640 AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)])
1641 AS_HELP_STRING([--enable-win32-registry=KEY],
1642                [use KEY instead of GCC version as the last portion
1643                 of the registry key])],,)
1644
1645 case $host_os in
1646   win32 | pe | cygwin* | mingw32* | uwin*)
1647     if test "x$enable_win32_registry" != xno; then
1648       AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1649     fi
1650
1651     if test "x$enable_win32_registry" != xno; then
1652       AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1653   [Define to 1 if installation paths should be looked up in the Windows
1654    Registry. Ignored on non-Windows hosts.])
1655
1656       if test "x$enable_win32_registry" != xyes \
1657          && test "x$enable_win32_registry" != x; then
1658         AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1659   [Define to be the last component of the Windows registry key under which
1660    to look for installation paths.  The full key used will be
1661    HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1662    The default is the GCC version number.])
1663       fi
1664     fi
1665   ;;
1666 esac
1667
1668 # Get an absolute path to the GCC top-level source directory
1669 holddir=`${PWDCMD-pwd}`
1670 cd $srcdir
1671 topdir=`${PWDCMD-pwd}`
1672 cd $holddir
1673
1674 # Conditionalize the makefile for this host machine.
1675 xmake_file=
1676 for f in ${host_xmake_file}
1677 do
1678         if test -f ${srcdir}/config/$f
1679         then
1680                 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1681         fi
1682 done
1683
1684 # Conditionalize the makefile for this target machine.
1685 tmake_file_=
1686 for f in ${tmake_file}
1687 do
1688         if test -f ${srcdir}/config/$f
1689         then
1690                 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1691         fi
1692 done
1693 tmake_file="${tmake_file_}"
1694
1695 out_object_file=`basename $out_file .c`.o
1696 common_out_object_file=`basename $common_out_file .c`.o
1697
1698 tm_file_list="options.h"
1699 tm_include_list="options.h insn-constants.h"
1700 for f in $tm_file; do
1701   case $f in
1702     ./* )
1703        f=`echo $f | sed 's/^..//'`
1704        tm_file_list="${tm_file_list} $f"
1705        tm_include_list="${tm_include_list} $f"
1706        ;;
1707     defaults.h )
1708        tm_file_list="${tm_file_list} \$(srcdir)/$f"
1709        tm_include_list="${tm_include_list} $f"
1710        ;;
1711     * )
1712        tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1713        tm_include_list="${tm_include_list} config/$f"
1714        ;;
1715   esac
1716 done
1717
1718 tm_p_file_list=
1719 tm_p_include_list=
1720 for f in $tm_p_file; do
1721   case $f in
1722     tm-preds.h )
1723        tm_p_file_list="${tm_p_file_list} $f"
1724        tm_p_include_list="${tm_p_include_list} $f"
1725        ;;
1726     * )
1727        tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1728        tm_p_include_list="${tm_p_include_list} config/$f"
1729   esac
1730 done
1731
1732 xm_file_list=
1733 xm_include_list=
1734 for f in $xm_file; do
1735   case $f in
1736     ansidecl.h )
1737        xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1738        xm_include_list="${xm_include_list} $f"
1739        ;;
1740     auto-host.h )
1741        xm_file_list="${xm_file_list} $f"
1742        xm_include_list="${xm_include_list} $f"
1743        ;;
1744     * )
1745        xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1746        xm_include_list="${xm_include_list} config/$f"
1747        ;;
1748   esac
1749 done
1750
1751 host_xm_file_list=
1752 host_xm_include_list=
1753 for f in $host_xm_file; do
1754   case $f in
1755     ansidecl.h )
1756        host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1757        host_xm_include_list="${host_xm_include_list} $f"
1758        ;;
1759     auto-host.h )
1760        host_xm_file_list="${host_xm_file_list} $f"
1761        host_xm_include_list="${host_xm_include_list} $f"
1762        ;;
1763     * )
1764        host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1765        host_xm_include_list="${host_xm_include_list} config/$f"
1766        ;;
1767   esac
1768 done
1769
1770 build_xm_file_list=
1771 for f in $build_xm_file; do
1772   case $f in
1773     ansidecl.h )
1774        build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1775        build_xm_include_list="${build_xm_include_list} $f"
1776        ;;
1777     auto-build.h | auto-host.h )
1778        build_xm_file_list="${build_xm_file_list} $f"
1779        build_xm_include_list="${build_xm_include_list} $f"
1780        ;;
1781     * )
1782        build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1783        build_xm_include_list="${build_xm_include_list} config/$f"
1784        ;;
1785   esac
1786 done
1787
1788 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1789 # cross-compiler which does not use the native headers and libraries.
1790 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1791 CROSS=                                          AC_SUBST(CROSS)
1792 ALL=all.internal                                AC_SUBST(ALL)
1793 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1794
1795 if test "x$with_build_sysroot" != x; then
1796   build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1797 else
1798   # This value is used, even on a native system, because
1799   # CROSS_SYSTEM_HEADER_DIR is just
1800   # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1801   build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1802 fi
1803
1804 if test x$host != x$target
1805 then
1806         CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1807         ALL=all.cross
1808         SYSTEM_HEADER_DIR=$build_system_header_dir
1809         case "$host","$target" in
1810         # Darwin crosses can use the host system's libraries and headers,
1811         # because of the fat library support.  Of course, it must be the
1812         # same version of Darwin on both sides.  Allow the user to
1813         # just say --target=foo-darwin without a version number to mean
1814         # "the version on this system".
1815             *-*-darwin*,*-*-darwin*)
1816                 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1817                 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1818                 if test $hostos = $targetos -o $targetos = darwin ; then
1819                     CROSS=
1820                     SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1821                     with_headers=yes
1822                 fi
1823                 ;;
1824
1825             i?86-*-*,x86_64-*-* \
1826             | powerpc*-*-*,powerpc64*-*-*)
1827                 CROSS="$CROSS -DNATIVE_CROSS" ;;
1828         esac
1829
1830         case $target in
1831                 *-*-mingw*)
1832                         if test "x$with_headers" = x; then
1833                                 with_headers=yes
1834                         fi
1835                         ;;
1836                 *)
1837                         ;;
1838         esac
1839 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1840         SYSTEM_HEADER_DIR=$build_system_header_dir
1841 fi
1842
1843 # If this is a cross-compiler that does not
1844 # have its own set of headers then define
1845 # inhibit_libc
1846
1847 # If this is using newlib, without having the headers available now,
1848 # then define inhibit_libc in LIBGCC2_CFLAGS.
1849 # This prevents libgcc2 from containing any code which requires libc
1850 # support.
1851 : ${inhibit_libc=false}
1852 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1853        test x$with_newlib = xyes ; } &&
1854      { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1855        inhibit_libc=true
1856 fi
1857 AC_SUBST(inhibit_libc)
1858
1859 # When building gcc with a cross-compiler, we need to adjust things so
1860 # that the generator programs are still built with the native compiler.
1861 # Also, we cannot run fixincludes.
1862
1863 # These are the normal (build=host) settings:
1864 CC_FOR_BUILD='$(CC)'            AC_SUBST(CC_FOR_BUILD)
1865 BUILD_CFLAGS='$(ALL_CFLAGS)'    AC_SUBST(BUILD_CFLAGS)
1866 BUILD_LDFLAGS='$(LDFLAGS)'      AC_SUBST(BUILD_LDFLAGS)
1867 STMP_FIXINC=stmp-fixinc         AC_SUBST(STMP_FIXINC)
1868
1869 # And these apply if build != host, or we are generating coverage data
1870 if test x$build != x$host || test "x$coverage_flags" != x
1871 then
1872     BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1873     BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
1874 fi
1875
1876 # Expand extra_headers to include complete path.
1877 # This substitutes for lots of t-* files.
1878 extra_headers_list=
1879 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1880 for file in ${extra_headers} ; do
1881   extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1882 done
1883
1884 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
1885 if test x"$use_gcc_tgmath" = xyes
1886 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
1887 fi
1888
1889 # Define collect2 in Makefile.
1890 case $host_can_use_collect2 in
1891   no) collect2= ;;
1892   *) collect2='collect2$(exeext)' ;;
1893 esac
1894 AC_SUBST([collect2])
1895
1896 # Add a definition of USE_COLLECT2 if system wants one.
1897 case $use_collect2 in
1898   no) use_collect2= ;;
1899   "") ;;
1900   *)
1901     host_xm_defines="${host_xm_defines} USE_COLLECT2"
1902     xm_defines="${xm_defines} USE_COLLECT2"
1903     case $host_can_use_collect2 in
1904       no)
1905         AC_MSG_ERROR([collect2 is required but cannot be built on this system])
1906         ;;
1907     esac
1908     ;;
1909 esac
1910
1911 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
1912 [Define to the name of the LTO plugin DSO that must be
1913   passed to the linker's -plugin=LIB option.])
1914
1915 # ---------------------------
1916 # Assembler & linker features
1917 # ---------------------------
1918
1919 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
1920 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
1921 # However when ld-new is first executed from the build tree, libtool will
1922 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
1923 # to the build tree.  While doing this we need to use the previous-stage
1924 # linker, or we have an infinite loop.  The presence of a shell script as
1925 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
1926 # the gcc/collect-ld script.  So we need to know how libtool works, or
1927 # exec-tool will fail.
1928
1929 m4_defun([_LT_CONFIG_COMMANDS], [])
1930 AC_PROG_LIBTOOL
1931 AC_SUBST(objdir)
1932 AC_SUBST(enable_fast_install)
1933
1934 # Identify the assembler which will work hand-in-glove with the newly
1935 # built GCC, so that we can examine its features.  This is the assembler
1936 # which will be driven by the driver program.
1937 #
1938 # If build != host, and we aren't building gas in-tree, we identify a
1939 # build->target assembler and hope that it will have the same features
1940 # as the host->target assembler we'll be using.
1941 gcc_cv_gas_major_version=
1942 gcc_cv_gas_minor_version=
1943 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1944
1945 m4_pattern_allow([AS_FOR_TARGET])dnl
1946 AS_VAR_SET_IF(gcc_cv_as,, [
1947 if test -x "$DEFAULT_ASSEMBLER"; then
1948         gcc_cv_as="$DEFAULT_ASSEMBLER"
1949 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
1950      && test -f ../gas/Makefile \
1951      && test x$build = x$host; then
1952         gcc_cv_as=../gas/as-new$build_exeext
1953 elif test -x as$build_exeext; then
1954         # Build using assembler in the current directory.
1955         gcc_cv_as=./as$build_exeext
1956 elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then
1957         gcc_cv_as="$AS_FOR_TARGET"
1958 else
1959         AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
1960 fi])
1961
1962 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
1963 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
1964 case "$ORIGINAL_AS_FOR_TARGET" in
1965   ./as | ./as$build_exeext) ;;
1966   *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
1967 esac
1968
1969 AC_MSG_CHECKING(what assembler to use)
1970 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
1971   # Single tree build which includes gas.  We want to prefer it
1972   # over whatever linker top-level may have detected, since
1973   # we'll use what we're building after installation anyway.
1974   AC_MSG_RESULT(newly built gas)
1975   in_tree_gas=yes
1976   _gcc_COMPUTE_GAS_VERSION
1977   in_tree_gas_is_elf=no
1978   if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
1979      || (grep 'obj_format = multi' ../gas/Makefile \
1980          && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
1981   then
1982     in_tree_gas_is_elf=yes
1983   fi
1984 else
1985   AC_MSG_RESULT($gcc_cv_as)
1986   in_tree_gas=no
1987 fi
1988
1989 # Identify the linker which will work hand-in-glove with the newly
1990 # built GCC, so that we can examine its features.  This is the linker
1991 # which will be driven by the driver program.
1992 #
1993 # If build != host, and we aren't building gas in-tree, we identify a
1994 # build->target linker and hope that it will have the same features
1995 # as the host->target linker we'll be using.
1996 gcc_cv_gld_major_version=
1997 gcc_cv_gld_minor_version=
1998 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1999 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
2000
2001 AS_VAR_SET_IF(gcc_cv_ld,, [
2002 if test -x "$DEFAULT_LINKER"; then
2003         gcc_cv_ld="$DEFAULT_LINKER"
2004 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
2005      && test -f ../ld/Makefile \
2006      && test x$build = x$host; then
2007         gcc_cv_ld=../ld/ld-new$build_exeext
2008 elif test -x collect-ld$build_exeext; then
2009         # Build using linker in the current directory.
2010         gcc_cv_ld=./collect-ld$build_exeext
2011 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
2012         gcc_cv_ld="$LD_FOR_TARGET"
2013 else
2014         AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
2015 fi])
2016
2017 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
2018 PLUGIN_LD=`basename $gcc_cv_ld`
2019 AC_ARG_WITH(plugin-ld,
2020 [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])],
2021 [if test x"$withval" != x; then
2022    ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
2023    PLUGIN_LD="$withval"
2024  fi])
2025 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
2026 AC_DEFINE_UNQUOTED(PLUGIN_LD, "$PLUGIN_LD", [Specify plugin linker])
2027
2028 # Check to see if we are using gold instead of ld
2029 AC_MSG_CHECKING(whether we are using gold)
2030 ld_is_gold=no
2031 if test x$gcc_cv_ld != x; then
2032   if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2033      | grep "GNU gold" > /dev/null; then
2034     ld_is_gold=yes
2035   fi
2036 fi
2037 AC_MSG_RESULT($ld_is_gold)
2038
2039 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
2040 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
2041 case "$ORIGINAL_LD_FOR_TARGET" in
2042   ./collect-ld | ./collect-ld$build_exeext) ;;
2043   *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
2044 esac
2045
2046 AC_MSG_CHECKING(what linker to use)
2047 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \
2048    || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then
2049         # Single tree build which includes ld.  We want to prefer it
2050         # over whatever linker top-level may have detected, since
2051         # we'll use what we're building after installation anyway.
2052         AC_MSG_RESULT(newly built ld)
2053         in_tree_ld=yes
2054         in_tree_ld_is_elf=no
2055         if (grep 'EMUL = .*elf' ../ld/Makefile \
2056             || grep 'EMUL = .*linux' ../ld/Makefile \
2057             || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
2058           in_tree_ld_is_elf=yes
2059         elif test "$ld_is_gold" = yes; then
2060           in_tree_ld_is_elf=yes
2061         fi
2062         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
2063         do
2064 changequote(,)dnl
2065                 gcc_cv_gld_version=`sed -n -e 's/^[     ]*\(VERSION=[0-9]*\.[0-9]*.*\)/\1/p' < $f`
2066                 if test x$gcc_cv_gld_version != x; then
2067                         break
2068                 fi
2069         done
2070         gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2071         gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2072 changequote([,])dnl
2073 else
2074         AC_MSG_RESULT($gcc_cv_ld)
2075         in_tree_ld=no
2076 fi
2077
2078 # Figure out what nm we will be using.
2079 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2080 AS_VAR_SET_IF(gcc_cv_nm,, [
2081 if test -f $gcc_cv_binutils_srcdir/configure.in \
2082      && test -f ../binutils/Makefile \
2083      && test x$build = x$host; then
2084         gcc_cv_nm=../binutils/nm-new$build_exeext
2085 elif test -x nm$build_exeext; then
2086         gcc_cv_nm=./nm$build_exeext
2087 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
2088         gcc_cv_nm="$NM_FOR_TARGET"
2089 else
2090         AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2091 fi])
2092
2093 AC_MSG_CHECKING(what nm to use)
2094 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2095         # Single tree build which includes binutils.
2096         AC_MSG_RESULT(newly built nm)
2097         in_tree_nm=yes
2098 else
2099         AC_MSG_RESULT($gcc_cv_nm)
2100         in_tree_nm=no
2101 fi
2102
2103 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2104 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2105 case "$ORIGINAL_NM_FOR_TARGET" in
2106   ./nm | ./nm$build_exeext) ;;
2107   *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2108 esac
2109
2110
2111 # Figure out what objdump we will be using.
2112 AS_VAR_SET_IF(gcc_cv_objdump,, [
2113 if test -f $gcc_cv_binutils_srcdir/configure.in \
2114      && test -f ../binutils/Makefile \
2115      && test x$build = x$host; then
2116         # Single tree build which includes binutils.
2117         gcc_cv_objdump=../binutils/objdump$build_exeext
2118 elif test -x objdump$build_exeext; then
2119         gcc_cv_objdump=./objdump$build_exeext
2120 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2121         gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2122 else
2123         AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2124 fi])
2125
2126 AC_MSG_CHECKING(what objdump to use)
2127 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2128         # Single tree build which includes binutils.
2129         AC_MSG_RESULT(newly built objdump)
2130 elif test x$gcc_cv_objdump = x; then
2131         AC_MSG_RESULT(not found)
2132 else
2133         AC_MSG_RESULT($gcc_cv_objdump)
2134 fi
2135
2136 # Figure out what readelf we will be using.
2137 AS_VAR_SET_IF(gcc_cv_readelf,, [
2138 if test -f $gcc_cv_binutils_srcdir/configure.in \
2139      && test -f ../binutils/Makefile \
2140      && test x$build = x$host; then
2141         # Single tree build which includes binutils.
2142         gcc_cv_readelf=../binutils/readelf$build_exeext
2143 elif test -x readelf$build_exeext; then
2144         gcc_cv_readelf=./readelf$build_exeext
2145 else
2146         AC_PATH_PROG(gcc_cv_readelf, readelf)
2147 fi])
2148
2149 AC_MSG_CHECKING(what readelf to use)
2150 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2151         # Single tree build which includes binutils.
2152         AC_MSG_RESULT(newly built readelf)
2153 elif test x$gcc_cv_readelf = x; then
2154         AC_MSG_RESULT(not found)
2155 else
2156         AC_MSG_RESULT($gcc_cv_readelf)
2157 fi
2158
2159 # Figure out what assembler alignment features are present.
2160 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2161  [2,6,0],,
2162 [.balign 4
2163 .p2align 2],,
2164 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2165   [Define if your assembler supports .balign and .p2align.])])
2166
2167 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2168  [2,8,0],,
2169  [.p2align 4,,7],,
2170 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2171   [Define if your assembler supports specifying the maximum number
2172    of bytes to skip when using the GAS .p2align command.])])
2173
2174 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2175  [2,8,0],,
2176  [.literal16],,
2177 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2178   [Define if your assembler supports .literal16.])])
2179
2180 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2181  [elf,2,9,0],,
2182  [conftest_label1: .word 0
2183 .subsection -1
2184 conftest_label2: .word 0
2185 .previous],
2186  [if test x$gcc_cv_nm != x; then
2187     $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2188     $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2189     if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2190     then :
2191     else gcc_cv_as_subsection_m1=yes
2192     fi
2193     rm -f conftest.nm1 conftest.nm2
2194   fi],
2195  [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2196   [Define if your assembler supports .subsection and .subsection -1 starts
2197    emitting at the beginning of your section.])])
2198
2199 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2200  [2,2,0],,
2201  [      .weak foobar],,
2202 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2203
2204 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2205  [2,17,0],,
2206  [      .weakref foobar, barfnot],,
2207 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2208
2209 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2210  [2,15,91],,
2211  [      .SPACE $TEXT$
2212         .NSUBSPA $CODE$,COMDAT],,
2213 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2214
2215 # .hidden needs to be supported in both the assembler and the linker,
2216 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2217 # This is irritatingly difficult to feature test for; we have to check the
2218 # date string after the version number.  If we've got an in-tree
2219 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2220 # to be safe.
2221 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2222 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2223  [elf,2,13,0],,
2224 [       .hidden foobar
2225 foobar:],[
2226 # Solaris 9/x86 as incorrectly emits an alias for a hidden symbol with
2227 # STV_HIDDEN, so disable .hidden support if so.
2228 case "${target}" in
2229   i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2230     if test x$gcc_cv_as != x && test x$gcc_cv_objdump != x; then
2231       cat > conftest.s <<EOF
2232 .globl hidden
2233         .hidden hidden
2234 hidden:
2235 .globl default
2236         .set    default,hidden
2237 EOF
2238       if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
2239         && $gcc_cv_objdump -t conftest.o 2>/dev/null | \
2240         grep '\.hidden default' > /dev/null; then
2241         gcc_cv_as_hidden=no
2242       else
2243         gcc_cv_as_hidden=yes
2244       fi
2245     else
2246       # Assume bug is present if objdump is missing.
2247       gcc_cv_as_hidden=no
2248     fi
2249     ;;
2250   *)
2251     gcc_cv_as_hidden=yes
2252     ;;
2253 esac])
2254 case "${target}" in
2255   *-*-darwin*)
2256     # Darwin as has some visibility support, though with a different syntax.
2257     gcc_cv_as_hidden=yes
2258     ;;
2259 esac
2260
2261 # gnu_indirect_function type is an extension proposed at
2262 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2263 # selection of function implementation
2264 AC_ARG_ENABLE(gnu-indirect-function,
2265  [AS_HELP_STRING([--enable-gnu-indirect-function],
2266                  [enable the use of the @gnu_indirect_function to glibc systems])],
2267  [case $enable_gnu_indirect_function in
2268     yes | no) ;;
2269     *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2270 Valid choices are 'yes' and 'no'.]) ;;
2271   esac],
2272  [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2273 if test x$enable_gnu_indirect_function = xyes; then
2274   AC_DEFINE(HAVE_GNU_INDIRECT_FUNCTION, 1,
2275    [Define if your system supports gnu indirect functions.])
2276 fi
2277
2278 changequote(,)dnl
2279 if test $in_tree_ld != yes ; then
2280   ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2281   if echo "$ld_ver" | grep GNU > /dev/null; then
2282     if test x"$ld_is_gold" = xyes; then
2283       # GNU gold --version looks like this:
2284       #
2285       # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
2286       #
2287       # We extract the binutils version which is more familiar and specific
2288       # than the gold version.
2289       ld_vers=`echo $ld_ver | sed -n \
2290           -e 's,^[^)]*[  ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
2291     else
2292       # GNU ld --version looks like this:
2293       #
2294       # GNU ld (GNU Binutils) 2.21.51.20110225
2295       ld_vers=`echo $ld_ver | sed -n \
2296           -e 's,^.*[     ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2297     fi
2298     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'`
2299     ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2300     ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2301     ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2302   else
2303     case "${target}" in
2304       *-*-solaris2*)
2305         #
2306         # Solaris 2 ld -V output looks like this for a regular version:
2307         #
2308         # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1699
2309         #
2310         # but test versions add stuff at the end:
2311         #
2312         # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1701:onnv-ab196087-6931056-03/25/10
2313         #
2314         ld_ver=`$gcc_cv_ld -V 2>&1`
2315         if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2316           ld_vers=`echo $ld_ver | sed -n \
2317             -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2318           ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2319           ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2320         fi
2321         ;;
2322     esac
2323   fi
2324 fi
2325 changequote([,])dnl
2326
2327 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2328 [[if test $in_tree_ld = yes ; then
2329   gcc_cv_ld_hidden=no
2330   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 \
2331      && test $in_tree_ld_is_elf = yes; then
2332      gcc_cv_ld_hidden=yes
2333   fi
2334 else
2335   gcc_cv_ld_hidden=yes
2336   if test x"$ld_is_gold" = xyes; then
2337     :
2338   elif echo "$ld_ver" | grep GNU > /dev/null; then
2339     if test 0"$ld_date" -lt 20020404; then
2340       if test -n "$ld_date"; then
2341         # If there was date string, but was earlier than 2002-04-04, fail
2342         gcc_cv_ld_hidden=no
2343       elif test -z "$ld_vers"; then
2344         # If there was no date string nor ld version number, something is wrong
2345         gcc_cv_ld_hidden=no
2346       else
2347         test -z "$ld_vers_patch" && ld_vers_patch=0
2348         if test "$ld_vers_major" -lt 2; then
2349           gcc_cv_ld_hidden=no
2350         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2351           gcc_cv_ld_hidden="no"
2352         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2353           gcc_cv_ld_hidden=no
2354         fi
2355       fi
2356     fi
2357   else
2358     case "${target}" in
2359       *-*-darwin*)
2360         # Darwin ld has some visibility support.
2361         gcc_cv_ld_hidden=yes
2362         ;;
2363       hppa64*-*-hpux* | ia64*-*-hpux*)
2364         gcc_cv_ld_hidden=yes
2365         ;;
2366       *-*-solaris2.8*)
2367         # .hidden support was backported to Solaris 8, starting with ld
2368         # version 1.276.
2369         if test "$ld_vers_minor" -ge 276; then
2370           gcc_cv_ld_hidden=yes
2371         else
2372           gcc_cv_ld_hidden=no
2373         fi
2374         ;;
2375       *-*-solaris2.9* | *-*-solaris2.1[0-9]*)
2376         # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2377         # .symbolic was only added in Solaris 9 12/02.
2378         gcc_cv_ld_hidden=yes
2379         ;;
2380       *)
2381         gcc_cv_ld_hidden=no
2382         ;;
2383     esac
2384   fi
2385 fi]])
2386 libgcc_visibility=no
2387 AC_SUBST(libgcc_visibility)
2388 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2389 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2390   libgcc_visibility=yes
2391   AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2392   [Define if your assembler and linker support .hidden.])
2393 fi
2394
2395 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2396 gcc_cv_ld_ro_rw_mix=unknown
2397 if test $in_tree_ld = yes ; then
2398   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 \
2399      && test $in_tree_ld_is_elf = yes; then
2400     gcc_cv_ld_ro_rw_mix=read-write
2401   fi
2402 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2403   echo '.section myfoosect, "a"' > conftest1.s
2404   echo '.section myfoosect, "aw"' > conftest2.s
2405   echo '.byte 1' >> conftest2.s
2406   echo '.section myfoosect, "a"' > conftest3.s
2407   echo '.byte 0' >> conftest3.s
2408   if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2409      && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2410      && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2411      && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2412         conftest2.o conftest3.o > /dev/null 2>&1; then
2413     gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2414                          | sed -e '/myfoosect/!d' -e N`
2415     if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2416       if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2417         gcc_cv_ld_ro_rw_mix=read-only
2418       else
2419         gcc_cv_ld_ro_rw_mix=read-write
2420       fi
2421     fi
2422   fi
2423 changequote(,)dnl
2424   rm -f conftest.* conftest[123].*
2425 changequote([,])dnl
2426 fi
2427 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2428         AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2429   [Define if your linker links a mix of read-only
2430    and read-write sections into a read-write section.])
2431 fi
2432 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2433
2434 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2435 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2436   [elf,2,11,0],,
2437 [       .data
2438         .uleb128 L2 - L1
2439 L1:
2440         .uleb128 1280
2441         .sleb128 -1010
2442 L2:],
2443 [[# GAS versions before 2.11 do not support uleb128,
2444   # despite appearing to.
2445   # ??? There exists an elf-specific test that will crash
2446   # the assembler.  Perhaps it's better to figure out whether
2447   # arbitrary sections are supported and try the test.
2448   as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2449   if echo "$as_ver" | grep GNU > /dev/null; then
2450     as_vers=`echo $as_ver | sed -n \
2451         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2452     as_major=`expr "$as_vers" : '\([0-9]*\)'`
2453     as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2454     if test $as_major -eq 2 && test $as_minor -lt 11
2455     then :
2456     else gcc_cv_as_leb128=yes
2457     fi
2458   fi]],
2459   [AC_DEFINE(HAVE_AS_LEB128, 1,
2460     [Define if your assembler supports .sleb128 and .uleb128.])])
2461
2462 # Check if we have assembler support for unwind directives.
2463 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2464   ,,
2465 [       .text
2466         .cfi_startproc
2467         .cfi_offset 0, 0
2468         .cfi_same_value 1
2469         .cfi_def_cfa 1, 2
2470         .cfi_escape 1, 2, 3, 4, 5
2471         .cfi_endproc],
2472 [case "$target" in
2473   *-*-solaris*)
2474     # If the linker used on Solaris (like Sun ld) isn't capable of merging
2475     # read-only and read-write sections, we need to make sure that the
2476     # assembler used emits read-write .eh_frame sections.
2477     if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2478       if test "x$gcc_cv_objdump" != x; then
2479         if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2480                 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2481           gcc_cv_as_cfi_directive=no
2482         else
2483           case "$target" in
2484             i?86-*-solaris2.1[[0-9]]* | x86_64-*-solaris2.1[[0-9]]*)
2485               # On Solaris/x86, make sure that GCC and gas agree on using
2486               # read-only .eh_frame sections for 64-bit.
2487               if $gcc_cv_as --64 -o conftest.o conftest.s > /dev/null 2>&1 && \
2488                 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2489                         sed -e /.eh_frame/!d -e N | \
2490                         grep READONLY > /dev/null; then
2491                 gcc_cv_as_cfi_directive=yes
2492               else
2493                 gcc_cv_as_cfi_directive=no
2494               fi
2495               ;;
2496             *)
2497               gcc_cv_as_cfi_directive=yes
2498               ;;
2499           esac
2500         fi
2501       else
2502         # no objdump, err on the side of caution
2503         gcc_cv_as_cfi_directive=no
2504       fi
2505     else
2506       gcc_cv_as_cfi_directive=yes
2507     fi
2508     ;;
2509   *-*-*)
2510     gcc_cv_as_cfi_directive=yes
2511     ;;
2512 esac])
2513 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
2514 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2515   ,,
2516 [       .text
2517         .cfi_startproc
2518         .cfi_adjust_cfa_offset 64
2519         .skip 75040, 0
2520         .cfi_adjust_cfa_offset 128
2521         .cfi_endproc],
2522 [[
2523 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
2524     | grep 'DW_CFA_advance_loc[24]:[    ][      ]*75040[        ]' >/dev/null; then
2525    gcc_cv_as_cfi_advance_working=yes
2526 fi
2527 ]])
2528 else
2529   # no objdump, err on the side of caution
2530   gcc_cv_as_cfi_advance_working=no
2531 fi
2532 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
2533 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2534   [`if test $gcc_cv_as_cfi_directive = yes \
2535        && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2536   [Define 0/1 if your assembler supports CFI directives.])
2537
2538 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
2539 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2540   gcc_cv_as_cfi_personality_directive, ,,
2541 [       .text
2542         .cfi_startproc
2543         .cfi_personality 0, symbol
2544         .cfi_endproc])
2545 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2546   [`if test $gcc_cv_as_cfi_personality_directive = yes;
2547     then echo 1; else echo 0; fi`],
2548   [Define 0/1 if your assembler supports .cfi_personality.])
2549
2550 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2551   gcc_cv_as_cfi_sections_directive, ,,
2552 [       .text
2553         .cfi_sections .debug_frame, .eh_frame
2554         .cfi_startproc
2555         .cfi_endproc],
2556 [case $target_os in
2557   win32 | pe | cygwin* | mingw32* | uwin*)
2558     # Need to check that we generated the correct relocation for the
2559     # .debug_frame section.  This was fixed for binutils 2.21.
2560     gcc_cv_as_cfi_sections_directive=no
2561     if test "x$gcc_cv_objdump" != x; then
2562      if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
2563         grep secrel > /dev/null; then
2564       gcc_cv_as_cfi_sections_directive=yes
2565      fi
2566     fi
2567     ;;
2568   *)
2569     gcc_cv_as_cfi_sections_directive=yes
2570     ;;
2571 esac])
2572 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
2573 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2574   [`if test $gcc_cv_as_cfi_sections_directive = yes;
2575     then echo 1; else echo 0; fi`],
2576   [Define 0/1 if your assembler supports .cfi_sections.])
2577
2578 # GAS versions up to and including 2.11.0 may mis-optimize
2579 # .eh_frame data.
2580 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2581   [elf,2,12,0],,
2582 [       .text
2583 .LFB1:
2584         .4byte  0
2585 .L1:
2586         .4byte  0
2587 .LFE1:
2588         .section        .eh_frame,"aw",@progbits
2589 __FRAME_BEGIN__:
2590         .4byte  .LECIE1-.LSCIE1
2591 .LSCIE1:
2592         .4byte  0x0
2593         .byte   0x1
2594         .ascii "z\0"
2595         .byte   0x1
2596         .byte   0x78
2597         .byte   0x1a
2598         .byte   0x0
2599         .byte   0x4
2600         .4byte  1
2601         .p2align 1
2602 .LECIE1:
2603 .LSFDE1:
2604         .4byte  .LEFDE1-.LASFDE1
2605 .LASFDE1:
2606         .4byte  .LASFDE1-__FRAME_BEGIN__
2607         .4byte  .LFB1
2608         .4byte  .LFE1-.LFB1
2609         .byte   0x4
2610         .4byte  .LFE1-.LFB1
2611         .byte   0x4
2612         .4byte  .L1-.LFB1
2613 .LEFDE1:],
2614 [  dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2615 cat > conftest.lit <<EOF
2616  0000 10000000 00000000 017a0001 781a0004  .........z..x...
2617  0010 01000000 12000000 18000000 00000000  ................
2618  0020 08000000 04080000 0044               .........D      @&t@
2619 EOF
2620 cat > conftest.big <<EOF
2621  0000 00000010 00000000 017a0001 781a0004  .........z..x...
2622  0010 00000001 00000012 00000018 00000000  ................
2623  0020 00000008 04000000 0844               .........D      @&t@
2624 EOF
2625   # If the assembler didn't choke, and we can objdump,
2626   # and we got the correct data, then succeed.
2627   # The text in the here-document typically retains its unix-style line
2628   # endings, while the output of objdump will use host line endings.
2629   # Therefore, use diff -b for the comparisons.
2630   if test x$gcc_cv_objdump != x \
2631   && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2632      | tail -3 > conftest.got \
2633   && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2634     || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2635   then
2636     gcc_cv_as_eh_frame=yes
2637   elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2638     gcc_cv_as_eh_frame=buggy
2639   else
2640     # Uh oh, what do we do now?
2641     gcc_cv_as_eh_frame=no
2642   fi])
2643
2644 if test $gcc_cv_as_eh_frame = buggy; then
2645   AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2646   [Define if your assembler mis-optimizes .eh_frame data.])
2647 fi
2648
2649 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2650  [elf,2,12,0], [--fatal-warnings],
2651  [.section .rodata.str, "aMS", @progbits, 1])
2652 if test $gcc_cv_as_shf_merge = no; then
2653   gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2654     [elf,2,12,0], [--fatal-warnings],
2655     [.section .rodata.str, "aMS", %progbits, 1])
2656 fi
2657 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2658   [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2659 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2660
2661 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)],
2662  gcc_cv_as_comdat_group,
2663  [elf,2,16,0], [--fatal-warnings],
2664  [.section .text,"axG",@progbits,.foo,comdat])
2665 if test $gcc_cv_as_comdat_group = yes; then
2666   gcc_cv_as_comdat_group_percent=no
2667   gcc_cv_as_comdat_group_group=no
2668 else
2669  gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
2670    gcc_cv_as_comdat_group_percent,
2671    [elf,2,16,0], [--fatal-warnings],
2672    [.section .text,"axG",%progbits,.foo,comdat])
2673  if test $gcc_cv_as_comdat_group_percent = yes; then
2674    gcc_cv_as_comdat_group_group=no
2675  else
2676    case "${target}" in
2677      # Sun as uses a completely different syntax.
2678      *-*-solaris2*)
2679        case "${target}" in
2680          sparc*-*-solaris2*)
2681            conftest_s='
2682                .group foo,".text%foo",#comdat
2683                .section ".text%foo", #alloc,#execinstr,#progbits
2684                .globl foo
2685              foo:
2686              '
2687            ;;
2688          i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2689            conftest_s='
2690                .group foo,.text%foo,#comdat
2691                .section .text%foo, "ax", @progbits
2692                .globl  foo
2693              foo:
2694              '
2695            ;;
2696        esac
2697        gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
2698          gcc_cv_as_comdat_group_group,
2699          ,, [$conftest_s])
2700        ;;
2701    esac
2702  fi
2703 fi
2704 if test x"$ld_is_gold" = xyes; then
2705   comdat_group=yes
2706 elif test $in_tree_ld = yes ; then
2707   comdat_group=no
2708   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 \
2709      && test $in_tree_ld_is_elf = yes; then
2710      comdat_group=yes
2711   fi
2712 elif echo "$ld_ver" | grep GNU > /dev/null; then
2713   comdat_group=yes
2714   if test 0"$ld_date" -lt 20050308; then
2715     if test -n "$ld_date"; then
2716       # If there was date string, but was earlier than 2005-03-08, fail
2717       comdat_group=no
2718     elif test "$ld_vers_major" -lt 2; then
2719       comdat_group=no
2720     elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2721       comdat_group=no
2722     fi
2723   fi
2724 else
2725 changequote(,)dnl
2726   case "${target}" in
2727     *-*-solaris2.1[1-9]*)
2728       comdat_group=no
2729       # Sun ld has COMDAT group support since Solaris 9, but it doesn't
2730       # interoperate with GNU as until Solaris 11 build 130, i.e. ld
2731       # version 1.688.
2732       #
2733       # If using Sun as for COMDAT group as emitted by GCC, one needs at
2734       # least ld version 1.2267.
2735       if test "$ld_vers_major" -gt 1; then
2736         comdat_group=yes
2737       elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
2738         comdat_group=yes
2739       elif test "$ld_vers_minor" -ge 2267; then
2740         comdat_group=yes
2741       fi
2742       ;;
2743     *)
2744       # Assume linkers other than GNU ld don't support COMDAT group.
2745       comdat_group=no
2746       ;;
2747   esac
2748 changequote([,])dnl
2749 fi
2750 # Allow overriding the automatic COMDAT group tests above.
2751 AC_ARG_ENABLE(comdat,
2752   [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
2753   [comdat_group="$enable_comdat"])
2754 if test $comdat_group = no; then
2755   gcc_cv_as_comdat_group=no
2756   gcc_cv_as_comdat_group_percent=no
2757   gcc_cv_as_comdat_group_group=no
2758 fi
2759 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2760   [`if test $gcc_cv_as_comdat_group = yes \
2761     || test $gcc_cv_as_comdat_group_percent = yes \
2762     || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`],
2763 [Define 0/1 if your assembler and linker support COMDAT groups.])
2764
2765 gcc_GAS_CHECK_FEATURE([line table discriminator support],
2766  gcc_cv_as_discriminator,
2767  [2,19,51],,
2768 [       .text
2769         .file 1 "conf.c"
2770         .loc 1 1 0 discriminator 1],,
2771 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
2772   [Define if your assembler supports the .loc discriminator sub-directive.])])
2773
2774 # Thread-local storage - the check is heavily parameterized.
2775 conftest_s=
2776 tls_first_major=
2777 tls_first_minor=
2778 tls_as_opt=
2779 case "$target" in
2780 changequote(,)dnl
2781   alpha*-*-*)
2782     conftest_s='
2783         .section ".tdata","awT",@progbits
2784 foo:    .long   25
2785         .text
2786         ldq     $27,__tls_get_addr($29)         !literal!1
2787         lda     $16,foo($29)                    !tlsgd!1
2788         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
2789         ldq     $27,__tls_get_addr($29)         !literal!2
2790         lda     $16,foo($29)                    !tlsldm!2
2791         jsr     $26,($27),__tls_get_addr        !lituse_tlsldm!2
2792         ldq     $1,foo($29)                     !gotdtprel
2793         ldah    $2,foo($29)                     !dtprelhi
2794         lda     $3,foo($2)                      !dtprello
2795         lda     $4,foo($29)                     !dtprel
2796         ldq     $1,foo($29)                     !gottprel
2797         ldah    $2,foo($29)                     !tprelhi
2798         lda     $3,foo($2)                      !tprello
2799         lda     $4,foo($29)                     !tprel'
2800         tls_first_major=2
2801         tls_first_minor=13
2802         tls_as_opt=--fatal-warnings
2803         ;;
2804   cris-*-*|crisv32-*-*)
2805     conftest_s='
2806         .section ".tdata","awT",@progbits
2807 x:      .long   25
2808         .text
2809         move.d x:IE,$r10
2810         nop'
2811         tls_first_major=2
2812         tls_first_minor=20
2813         tls_as_opt=--fatal-warnings
2814         ;;
2815   frv*-*-*)
2816     conftest_s='
2817         .section ".tdata","awT",@progbits
2818 x:      .long   25
2819         .text
2820         call    #gettlsoff(x)'
2821         tls_first_major=2
2822         tls_first_minor=14
2823         ;;
2824   hppa*-*-linux*)
2825     conftest_s='
2826 t1:     .reg    %r20
2827 t2:     .reg    %r21
2828 gp:     .reg    %r19
2829         .section ".tdata","awT",@progbits
2830 foo:    .long   25
2831         .text
2832         .align  4
2833         addil LT%foo-$tls_gdidx$,gp
2834         ldo RT%foo-$tls_gdidx$(%r1),%arg0
2835         b __tls_get_addr
2836         nop
2837         addil LT%foo-$tls_ldidx$,gp
2838         b __tls_get_addr
2839         ldo RT%foo-$tls_ldidx$(%r1),%arg0
2840         addil LR%foo-$tls_dtpoff$,%ret0
2841         ldo RR%foo-$tls_dtpoff$(%r1),%t1
2842         mfctl %cr27,%t1
2843         addil LT%foo-$tls_ieoff$,gp
2844         ldw RT%foo-$tls_ieoff$(%r1),%t2
2845         add %t1,%t2,%t3
2846         mfctl %cr27,%t1
2847         addil LR%foo-$tls_leoff$,%t1
2848         ldo RR%foo-$tls_leoff$(%r1),%t2'
2849         tls_first_major=2
2850         tls_first_minor=15
2851         tls_as_opt=--fatal-warnings
2852         ;;
2853   arm*-*-*)
2854     conftest_s='
2855         .section ".tdata","awT",%progbits
2856 foo:    .long   25
2857         .text
2858 .word foo(gottpoff)
2859 .word foo(tpoff)
2860 .word foo(tlsgd)
2861 .word foo(tlsldm)
2862 .word foo(tlsldo)'
2863         tls_first_major=2
2864         tls_first_minor=17
2865         ;;
2866   i[34567]86-*-* | x86_64-*-solaris2.1[0-9]*)
2867     case "$target" in
2868       i[34567]86-*-solaris2.*)
2869         on_solaris=yes
2870         tga_func=___tls_get_addr
2871         ;;
2872       x86_64-*-solaris2.1[0-9]*)
2873         on_solaris=yes
2874         tga_func=__tls_get_addr
2875         ;;
2876       *)
2877         on_solaris=no
2878         ;;
2879     esac
2880     if test x$on_solaris = xyes && test x$gas_flag = xno; then
2881       conftest_s='
2882         .section .tdata,"awt",@progbits'
2883       tls_first_major=0
2884       tls_first_minor=0
2885 changequote([,])dnl
2886       AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
2887 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
2888 changequote(,)dnl
2889     else
2890       conftest_s='
2891         .section ".tdata","awT",@progbits'
2892       tls_first_major=2
2893       tls_first_minor=14
2894       tls_as_opt="--fatal-warnings"
2895     fi
2896     conftest_s="$conftest_s
2897 foo:    .long   25
2898         .text
2899         movl    %gs:0, %eax
2900         leal    foo@tlsgd(,%ebx,1), %eax
2901         leal    foo@tlsldm(%ebx), %eax
2902         leal    foo@dtpoff(%eax), %edx
2903         movl    foo@gottpoff(%ebx), %eax
2904         subl    foo@gottpoff(%ebx), %eax
2905         addl    foo@gotntpoff(%ebx), %eax
2906         movl    foo@indntpoff, %eax
2907         movl    \$foo@tpoff, %eax
2908         subl    \$foo@tpoff, %eax
2909         leal    foo@ntpoff(%ecx), %eax"
2910     ;;
2911   x86_64-*-*)
2912     conftest_s='
2913         .section ".tdata","awT",@progbits
2914 foo:    .long   25
2915         .text
2916         movq    %fs:0, %rax
2917         leaq    foo@TLSGD(%rip), %rdi
2918         leaq    foo@TLSLD(%rip), %rdi
2919         leaq    foo@DTPOFF(%rax), %rdx
2920         movq    foo@GOTTPOFF(%rip), %rax
2921         movq    $foo@TPOFF, %rax'
2922         tls_first_major=2
2923         tls_first_minor=14
2924         tls_as_opt=--fatal-warnings
2925         ;;
2926   ia64-*-*)
2927     conftest_s='
2928         .section ".tdata","awT",@progbits
2929 foo:    data8   25
2930         .text
2931         addl    r16 = @ltoff(@dtpmod(foo#)), gp
2932         addl    r17 = @ltoff(@dtprel(foo#)), gp
2933         addl    r18 = @ltoff(@tprel(foo#)), gp
2934         addl    r19 = @dtprel(foo#), gp
2935         adds    r21 = @dtprel(foo#), r13
2936         movl    r23 = @dtprel(foo#)
2937         addl    r20 = @tprel(foo#), gp
2938         adds    r22 = @tprel(foo#), r13
2939         movl    r24 = @tprel(foo#)'
2940         tls_first_major=2
2941         tls_first_minor=13
2942         tls_as_opt=--fatal-warnings
2943         ;;
2944   mips*-*-*)
2945     conftest_s='
2946         .section .tdata,"awT",@progbits
2947 x:
2948         .word 2
2949         .text
2950         addiu $4, $28, %tlsgd(x)
2951         addiu $4, $28, %tlsldm(x)
2952         lui $4, %dtprel_hi(x)
2953         addiu $4, $4, %dtprel_lo(x)
2954         lw $4, %gottprel(x)($28)
2955         lui $4, %tprel_hi(x)
2956         addiu $4, $4, %tprel_lo(x)'
2957         tls_first_major=2
2958         tls_first_minor=16
2959         tls_as_opt='-32 --fatal-warnings'
2960         ;;
2961   m68k-*-*)
2962     conftest_s='
2963         .section .tdata,"awT",@progbits
2964 x:
2965         .word 2
2966         .text
2967 foo:
2968         move.l x@TLSGD(%a5),%a0
2969         move.l x@TLSLDM(%a5),%a0
2970         move.l x@TLSLDO(%a5),%a0
2971         move.l x@TLSIE(%a5),%a0
2972         move.l x@TLSLE(%a5),%a0'
2973         tls_first_major=2
2974         tls_first_minor=19
2975         tls_as_opt='--fatal-warnings'
2976         ;;
2977   powerpc-*-*)
2978     conftest_s='
2979         .section ".tdata","awT",@progbits
2980         .align 2
2981 ld0:    .space 4
2982 ld1:    .space 4
2983 x1:     .space 4
2984 x2:     .space 4
2985 x3:     .space 4
2986         .text
2987         addi 3,31,ld0@got@tlsgd
2988         bl __tls_get_addr
2989         addi 3,31,x1@got@tlsld
2990         bl __tls_get_addr
2991         addi 9,3,x1@dtprel
2992         addis 9,3,x2@dtprel@ha
2993         addi 9,9,x2@dtprel@l
2994         lwz 9,x3@got@tprel(31)
2995         add 9,9,x@tls
2996         addi 9,2,x1@tprel
2997         addis 9,2,x2@tprel@ha
2998         addi 9,9,x2@tprel@l'
2999         tls_first_major=2
3000         tls_first_minor=14
3001         tls_as_opt="-a32 --fatal-warnings"
3002         ;;
3003   powerpc64-*-*)
3004     conftest_s='
3005         .section ".tdata","awT",@progbits
3006         .align 3
3007 ld0:    .space 8
3008 ld1:    .space 8
3009 x1:     .space 8
3010 x2:     .space 8
3011 x3:     .space 8
3012         .text
3013         addi 3,2,ld0@got@tlsgd
3014         bl .__tls_get_addr
3015         nop
3016         addi 3,2,ld1@toc
3017         bl .__tls_get_addr
3018         nop
3019         addi 3,2,x1@got@tlsld
3020         bl .__tls_get_addr
3021         nop
3022         addi 9,3,x1@dtprel
3023         bl .__tls_get_addr
3024         nop
3025         addis 9,3,x2@dtprel@ha
3026         addi 9,9,x2@dtprel@l
3027         bl .__tls_get_addr
3028         nop
3029         ld 9,x3@got@dtprel(2)
3030         add 9,9,3
3031         bl .__tls_get_addr
3032         nop'
3033         tls_first_major=2
3034         tls_first_minor=14
3035         tls_as_opt="-a64 --fatal-warnings"
3036         ;;
3037   s390-*-*)
3038     conftest_s='
3039         .section ".tdata","awT",@progbits
3040 foo:    .long   25
3041         .text
3042         .long   foo@TLSGD
3043         .long   foo@TLSLDM
3044         .long   foo@DTPOFF
3045         .long   foo@NTPOFF
3046         .long   foo@GOTNTPOFF
3047         .long   foo@INDNTPOFF
3048         l       %r1,foo@GOTNTPOFF(%r12)
3049         l       %r1,0(%r1):tls_load:foo
3050         bas     %r14,0(%r1,%r13):tls_gdcall:foo
3051         bas     %r14,0(%r1,%r13):tls_ldcall:foo'
3052         tls_first_major=2
3053         tls_first_minor=14
3054         tls_as_opt="-m31 --fatal-warnings"
3055         ;;
3056   s390x-*-*)
3057     conftest_s='
3058         .section ".tdata","awT",@progbits
3059 foo:    .long   25
3060         .text
3061         .quad   foo@TLSGD
3062         .quad   foo@TLSLDM
3063         .quad   foo@DTPOFF
3064         .quad   foo@NTPOFF
3065         .quad   foo@GOTNTPOFF
3066         lg      %r1,foo@GOTNTPOFF(%r12)
3067         larl    %r1,foo@INDNTPOFF
3068         brasl   %r14,__tls_get_offset@PLT:tls_gdcall:foo
3069         brasl   %r14,__tls_get_offset@PLT:tls_ldcall:foo'
3070         tls_first_major=2
3071         tls_first_minor=14
3072         tls_as_opt="-m64 -Aesame --fatal-warnings"
3073         ;;
3074   sh-*-* | sh[34]-*-*)
3075     conftest_s='
3076         .section ".tdata","awT",@progbits
3077 foo:    .long   25
3078         .text
3079         .long   foo@TLSGD
3080         .long   foo@TLSLDM
3081         .long   foo@DTPOFF
3082         .long   foo@GOTTPOFF
3083         .long   foo@TPOFF'
3084         tls_first_major=2
3085         tls_first_minor=13
3086         tls_as_opt=--fatal-warnings
3087         ;;
3088   sparc*-*-*)
3089     case "$target" in
3090       sparc*-sun-solaris2.*)
3091         on_solaris=yes
3092         tga_func=__tls_get_addr
3093         ;;
3094       *)
3095         on_solaris=no
3096         ;;
3097     esac
3098     if test x$on_solaris = xyes && test x$gas_flag = xno; then
3099       conftest_s='
3100         .section ".tdata",#alloc,#write,#tls'
3101         tls_first_major=0
3102         tls_first_minor=0
3103     else
3104       conftest_s='
3105         .section ".tdata","awT",@progbits'
3106         tls_first_major=2
3107         tls_first_minor=14
3108         tls_as_opt="-32 --fatal-warnings"
3109     fi
3110     conftest_s="$conftest_s
3111 foo:    .long   25
3112         .text
3113         sethi   %tgd_hi22(foo), %o0
3114         add     %o0, %tgd_lo10(foo), %o1
3115         add     %l7, %o1, %o0, %tgd_add(foo)
3116         call    __tls_get_addr, %tgd_call(foo)
3117         sethi   %tldm_hi22(foo), %l1
3118         add     %l1, %tldm_lo10(foo), %l2
3119         add     %l7, %l2, %o0, %tldm_add(foo)
3120         call    __tls_get_addr, %tldm_call(foo)
3121         sethi   %tldo_hix22(foo), %l3
3122         xor     %l3, %tldo_lox10(foo), %l4
3123         add     %o0, %l4, %l5, %tldo_add(foo)
3124         sethi   %tie_hi22(foo), %o3
3125         add     %o3, %tie_lo10(foo), %o3
3126         ld      [%l7 + %o3], %o2, %tie_ld(foo)
3127         add     %g7, %o2, %o4, %tie_add(foo)
3128         sethi   %tle_hix22(foo), %l1
3129         xor     %l1, %tle_lox10(foo), %o5
3130         ld      [%g7 + %o5], %o1"
3131         ;;
3132   xtensa*-*-*)
3133     conftest_s='
3134         .section ".tdata","awT",@progbits
3135 foo:    .long   25
3136         .text
3137         movi    a8, foo@TLSFUNC
3138         movi    a10, foo@TLSARG
3139         callx8.tls a8, foo@TLSCALL'
3140         tls_first_major=2
3141         tls_first_minor=19
3142         ;;
3143 changequote([,])dnl
3144 esac
3145 set_have_as_tls=no
3146 if test "x$enable_tls" = xno ; then
3147   : # TLS explicitly disabled.
3148 elif test "x$enable_tls" = xyes ; then
3149   set_have_as_tls=yes # TLS explicitly enabled.
3150 elif test -z "$tls_first_major"; then
3151   : # If we don't have a check, assume no support.
3152 else
3153   gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
3154   [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
3155   [set_have_as_tls=yes])
3156 fi
3157 case "$target" in
3158   *-*-irix6*)
3159     # IRIX 6.5 rld and libc.so lack TLS support, so even if gas and gld
3160     # with TLS support are in use, native TLS cannot work.
3161     set_have_as_tls=no
3162     ;;
3163   *-*-osf*)
3164     # Tru64 UNIX loader and libc.so lack TLS support, so even if gas and
3165     # gld with TLS support are in use, native TLS cannot work.
3166     set_have_as_tls=no
3167     ;;
3168   # TLS was introduced in the Solaris 9 FCS release and backported to
3169   # Solaris 8 patches.  Support for GNU-style TLS on x86 was only
3170   # introduced in Solaris 9 4/04, replacing the earlier Sun style that Sun
3171   # ld and GCC don't support any longer.
3172   *-*-solaris2.*)
3173     AC_MSG_CHECKING(linker and ld.so.1 TLS support)
3174     ld_tls_support=no
3175     # Check ld and ld.so.1 TLS support.
3176     if echo "$ld_ver" | grep GNU > /dev/null; then
3177       # Assume all interesting versions of GNU ld have TLS support.
3178       # FIXME: still need ld.so.1 support, i.e. ld version checks below.
3179       ld_tls_support=yes
3180     else
3181       case "$target" in
3182         # Solaris 8/x86 ld has GNU style TLS support since version 1.280.
3183         i?86-*-solaris2.8)
3184           min_tls_ld_vers_minor=280
3185           ;;
3186         # Solaris 8/SPARC ld has TLS support since version 1.272.
3187         sparc*-*-solaris2.8)
3188           min_tls_ld_vers_minor=272
3189           ;;
3190         # Solaris 9/x86 ld has GNU style TLS support since version 1.374.
3191         i?86-*-solaris2.9)
3192           min_tls_ld_vers_minor=374
3193           ;;
3194         # Solaris 9/SPARC and Solaris 10+ ld have TLS support since FCS.
3195         sparc*-*-solaris2.9 | *-*-solaris2.1[[0-9]]*)
3196           min_tls_ld_vers_minor=343
3197           ;;
3198       esac
3199       if test "$ld_vers_major" -gt 1 || \
3200         test "$ld_vers_minor" -ge "$min_tls_ld_vers_minor"; then
3201         ld_tls_support=yes
3202       else
3203         set_have_as_tls=no
3204       fi
3205     fi
3206     AC_MSG_RESULT($ld_tls_support)
3207
3208     save_LIBS="$LIBS"
3209     save_LDFLAGS="$LDFLAGS"
3210     LIBS=
3211     LDFLAGS=
3212
3213     AC_MSG_CHECKING(alternate thread library)
3214     case "$target" in
3215       # TLS support was backported to Solaris 8 patches, but only lives in
3216       # the alternate thread library which became the default in Solaris 9.
3217       # We want to always use that, irrespective of TLS support.
3218       *-*-solaris2.8)
3219         # Take multilib subdir into account.  There's no spec to handle
3220         # this.  The 64 symlink exists since Solaris 8.
3221         lwp_dir=/usr/lib/lwp
3222         lwp_spec="-L$lwp_dir%{m64:/64} -R$lwp_dir%{m64:/64}"
3223         LDFLAGS="-L$lwp_dir -R$lwp_dir"
3224         ;;
3225       *-*-solaris2*)
3226         lwp_dir="none"
3227         lwp_spec=""
3228         ;;
3229     esac
3230     # Always define LIB_THREAD_LDFLAGS_SPEC, even without TLS support.
3231     AC_DEFINE_UNQUOTED(LIB_THREAD_LDFLAGS_SPEC, "$lwp_spec",
3232         [Define to the linker flags to use for -pthread.])
3233     AC_MSG_RESULT($lwp_dir)
3234
3235     AC_MSG_CHECKING(library containing $tga_func)
3236     # Before Solaris 10, __tls_get_addr (SPARC/x64) resp. ___tls_get_addr
3237     # (32-bit x86) only lived in libthread, so check for that.  Keep
3238     # set_have_as_tls if found, disable if not.
3239     AC_SEARCH_LIBS([$tga_func], [thread],, [set_have_as_tls=no])
3240     # Clear LIBS if we cannot support TLS.
3241     if test $set_have_as_tls = no; then
3242       LIBS=
3243     fi
3244     # Always define LIB_TLS_SPEC, even without TLS support.
3245     AC_DEFINE_UNQUOTED(LIB_TLS_SPEC, "$LIBS",
3246         [Define to the library containing __tls_get_addr/___tls_get_addr.])
3247     AC_MSG_RESULT($LIBS)
3248
3249     LIBS="$save_LIBS"
3250     LDFLAGS="$save_LDFLAGS"
3251     ;;
3252 esac
3253 if test $set_have_as_tls = yes ; then
3254   AC_DEFINE(HAVE_AS_TLS, 1,
3255             [Define if your assembler and linker support thread-local storage.])
3256 fi
3257
3258 # Target-specific assembler checks.
3259
3260 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3261 gcc_cv_ld_static_dynamic=no
3262 gcc_cv_ld_static_option='-Bstatic'
3263 gcc_cv_ld_dynamic_option='-Bdynamic'
3264 if test $in_tree_ld = yes ; then
3265   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; then
3266     gcc_cv_ld_static_dynamic=yes
3267   fi
3268 elif test x$gcc_cv_ld != x; then
3269   # Check if linker supports -Bstatic/-Bdynamic option
3270   if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
3271      && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
3272       gcc_cv_ld_static_dynamic=yes
3273   else
3274     case "$target" in
3275       # Tru64 UNIX support -noso/-so_archive instead of -Bstatic/-Bdynamic.
3276       alpha*-dec-osf*)
3277         gcc_cv_ld_static_dynamic=yes
3278         gcc_cv_ld_static_option="-noso"
3279         gcc_cv_ld_dynamic_option="-so_archive"
3280         ;;
3281       # HP-UX ld uses -a flags to select between shared and archive.
3282       *-*-hpux*)
3283         if test x"$gnu_ld" = xno; then
3284           gcc_cv_ld_static_dynamic=yes
3285           gcc_cv_ld_static_option="-aarchive_shared"
3286           gcc_cv_ld_dynamic_option="-adefault"
3287         fi
3288         ;;
3289       # IRIX 6 ld supports -Bstatic/-Bdynamic.
3290       mips-sgi-irix6*)
3291         gcc_cv_ld_static_dynamic=yes
3292         ;;
3293       # Solaris 2 ld always supports -Bstatic/-Bdynamic.
3294       *-*-solaris2*)
3295         gcc_cv_ld_static_dynamic=yes
3296         ;;
3297     esac
3298   fi
3299 fi
3300 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3301         AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3302 [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.])
3303         AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option",
3304 [Define to the linker option to disable use of shared objects.])
3305         AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option",
3306 [Define to the linker option to enable use of shared objects.])
3307 fi
3308 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3309
3310 if test x"$demangler_in_ld" = xyes; then
3311   AC_MSG_CHECKING(linker --demangle support)
3312   gcc_cv_ld_demangle=no
3313   if test $in_tree_ld = yes; then
3314     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 \
3315       gcc_cv_ld_demangle=yes
3316     fi
3317   elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3318     # Check if the GNU linker supports --demangle option
3319     if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3320       gcc_cv_ld_demangle=yes
3321     fi
3322   fi
3323   if test x"$gcc_cv_ld_demangle" = xyes; then
3324     AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3325 [Define if your linker supports --demangle option.])
3326   fi
3327   AC_MSG_RESULT($gcc_cv_ld_demangle)
3328 fi
3329
3330 AC_MSG_CHECKING(linker plugin support)
3331 gcc_cv_lto_plugin=0
3332 if test -f liblto_plugin.la; then
3333   save_ld_ver="$ld_ver"
3334   save_ld_vers_major="$ld_vers_major"
3335   save_ld_vers_minor="$ld_vers_minor"
3336   save_ld_is_gold="$ld_is_gold"
3337
3338   ld_is_gold=no
3339
3340   if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
3341     ld_ver="GNU ld"
3342     # FIXME: ld_is_gold?
3343     ld_vers_major="$gcc_cv_gld_major_version"
3344     ld_vers_minor="$gcc_cv_gld_minor_version"
3345   else
3346     # Determine plugin linker version.
3347     # FIXME: Partial duplicate from above, generalize.
3348 changequote(,)dnl
3349     ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q`
3350     if echo "$ld_ver" | grep GNU > /dev/null; then
3351       if echo "$ld_ver" | grep "GNU gold" > /dev/null; then
3352         ld_is_gold=yes
3353         ld_vers=`echo $ld_ver | sed -n \
3354             -e 's,^[^)]*[        ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
3355       else
3356         ld_vers=`echo $ld_ver | sed -n \
3357             -e 's,^.*[   ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
3358       fi
3359       ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
3360       ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
3361     fi
3362 changequote([,])dnl
3363   fi
3364
3365   # Determine plugin support.
3366   if echo "$ld_ver" | grep GNU > /dev/null; then
3367     # Require GNU ld or gold 2.21+ for plugin support by default.
3368     if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then
3369       gcc_cv_lto_plugin=2
3370     # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20.
3371     elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then
3372       gcc_cv_lto_plugin=1
3373     fi
3374   fi
3375
3376   ld_ver="$save_ld_ver"
3377   ld_vers_major="$save_ld_vers_major"
3378   ld_vers_minor="$save_ld_vers_minor"
3379   ld_is_gold="$save_ld_is_gold"
3380 fi
3381 AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin,
3382   [Define to the level of your linker's plugin support.])
3383 AC_MSG_RESULT($gcc_cv_lto_plugin)
3384
3385 case "$target" in
3386   # All TARGET_ABI_OSF targets.
3387   alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
3388     gcc_GAS_CHECK_FEATURE([explicit relocation support],
3389         gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3390 [       .set nomacro
3391         .text
3392         extbl   $3, $2, $3      !lituse_bytoff!1
3393         ldq     $2, a($29)      !literal!1
3394         ldq     $4, b($29)      !literal!2
3395         ldq_u   $3, 0($2)       !lituse_base!1
3396         ldq     $27, f($29)     !literal!5
3397         jsr     $26, ($27), f   !lituse_jsr!5
3398         ldah    $29, 0($26)     !gpdisp!3
3399         lda     $0, c($29)      !gprel
3400         ldah    $1, d($29)      !gprelhigh
3401         lda     $1, d($1)       !gprellow
3402         lda     $29, 0($29)     !gpdisp!3],,
3403     [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3404   [Define if your assembler supports explicit relocations.])])
3405     gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3406         gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3407 [       .set nomacro
3408         .text
3409         ldq     $27, a($29)     !literal!1
3410         jsr     $26, ($27), a   !lituse_jsrdirect!1],,
3411     [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3412   [Define if your assembler supports the lituse_jsrdirect relocation.])])
3413     ;;
3414
3415   cris-*-*)
3416     gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3417       gcc_cv_as_cris_no_mul_bug,[2,15,91],
3418       [-no-mul-bug-abort], [.text],,
3419       [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3420                 [Define if your assembler supports the -no-mul-bug-abort option.])])
3421     ;;
3422
3423   sparc*-*-*)
3424     gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3425       [.register %g2, #scratch],,
3426       [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3427                 [Define if your assembler supports .register.])])
3428
3429     gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3430       [-relax], [.text],,
3431       [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3432                 [Define if your assembler supports -relax option.])])
3433
3434     gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3435       gcc_cv_as_sparc_gotdata_op,,
3436       [-K PIC],
3437 [.text
3438 .align 4
3439 foo:
3440         nop
3441 bar:
3442         sethi %gdop_hix22(foo), %g1
3443         xor    %g1, %gdop_lox10(foo), %g1
3444         ld    [[%l7 + %g1]], %g2, %gdop(foo)],
3445       [if test x$gcc_cv_ld != x \
3446        && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3447          if test x$gcc_cv_objdump != x; then
3448            if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3449               | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3450                gcc_cv_as_sparc_gotdata_op=no
3451            else
3452                gcc_cv_as_sparc_gotdata_op=yes
3453            fi
3454          fi
3455        fi
3456        rm -f conftest],
3457       [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3458                 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3459
3460     gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3461       gcc_cv_as_sparc_ua_pcrel,,
3462       [-K PIC],
3463 [.text
3464 foo:
3465         nop
3466 .data
3467 .align 4
3468 .byte 0
3469 .uaword %r_disp32(foo)],
3470       [if test x$gcc_cv_ld != x \
3471        && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3472          gcc_cv_as_sparc_ua_pcrel=yes
3473        fi
3474        rm -f conftest],
3475       [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3476                 [Define if your assembler and linker support unaligned PC relative relocs.])
3477
3478       gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3479         gcc_cv_as_sparc_ua_pcrel_hidden,,
3480         [-K PIC],
3481 [.data
3482 .align 4
3483 .byte 0x31
3484 .uaword %r_disp32(foo)
3485 .byte 0x32, 0x33, 0x34
3486 .global foo
3487 .hidden foo
3488 foo:
3489 .skip 4],
3490         [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3491          && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3492          && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3493             | grep ' 31000000 07323334' > /dev/null 2>&1; then
3494             if $gcc_cv_objdump -R conftest 2> /dev/null \
3495                | grep 'DISP32' > /dev/null 2>&1; then
3496                 :
3497             else
3498                 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3499             fi
3500          fi
3501          rm -f conftest],
3502          [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3503                    [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3504     ]) # unaligned pcrel relocs
3505
3506     gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3507       gcc_cv_as_sparc_offsetable_lo10,,
3508       [-xarch=v9],
3509 [.text
3510         or %g1, %lo(ab) + 12, %g1
3511         or %g1, %lo(ab + 12), %g1],
3512       [if test x$gcc_cv_objdump != x \
3513        && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3514           | grep ' 82106000 82106000' > /dev/null 2>&1; then
3515          gcc_cv_as_sparc_offsetable_lo10=yes
3516        fi],
3517        [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3518                  [Define if your assembler supports offsetable %lo().])])
3519
3520     gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions],
3521       gcc_cv_as_sparc_fmaf,,
3522       [-xarch=v9d],
3523       [.text
3524        .register %g2, #scratch
3525        .register %g3, #scratch
3526        .align 4
3527        fmaddd %f0, %f2, %f4, %f6
3528        addxccc %g1, %g2, %g3
3529        fsrl32 %f2, %f4, %f8
3530        fnaddd %f10, %f12, %f14],,
3531       [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1,
3532                 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])])
3533     ;;
3534
3535 changequote(,)dnl
3536   i[34567]86-*-* | x86_64-*-*)
3537 changequote([,])dnl
3538     case $target_os in
3539       cygwin*)
3540         # Full C++ conformance when using a shared libstdc++-v3 requires some
3541         # support from the Cygwin DLL, which in more recent versions exports
3542         # wrappers to aid in interposing and redirecting operators new, delete,
3543         # etc., as per n2800 #17.6.4.6 [replacement.functions].  Check if we
3544         # are configuring for a version of Cygwin that exports the wrappers.
3545         if test x$host = x$target; then
3546           AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3547         else
3548           # Can't check presence of libc functions during cross-compile, so
3549           # we just have to assume we're building for an up-to-date target.
3550           gcc_ac_cygwin_dll_wrappers=yes
3551         fi
3552         AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3553           [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3554           [Define if you want to generate code by default that assumes that the
3555            Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3556     esac
3557     case $target_os in
3558       cygwin* | pe | mingw32*)
3559         # Recent binutils allows the three-operand form of ".comm" on PE.  This
3560         # definition is used unconditionally to initialise the default state of
3561         # the target option variable that governs usage of the feature.
3562         gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3563          [2,19,52],,[.comm foo,1,32])
3564         AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3565           [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3566           [Define if your assembler supports specifying the alignment
3567            of objects allocated using the GAS .comm command.])
3568         # Used for DWARF 2 in PE
3569         gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3570           gcc_cv_as_ix86_pe_secrel32,
3571           [2,15,91],,
3572 [.text
3573 foo:    nop
3574 .data
3575         .secrel32 foo],
3576           [if test x$gcc_cv_ld != x \
3577            && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3578              gcc_cv_as_ix86_pe_secrel32=yes
3579            fi
3580            rm -f conftest],
3581           [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3582             [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3583         # Test if the assembler supports the extended form of the .section
3584         # directive that specifies section alignment.  LTO support uses this,
3585         # but normally only after installation, so we warn but don't fail the
3586         # configure if LTO is enabled but the assembler does not support it.
3587         gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3588           [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3589         if test x$gcc_cv_as_section_has_align != xyes; then
3590           case ",$enable_languages," in
3591             *,lto,*)
3592               AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3593               ;;
3594           esac
3595         fi
3596         # Test if the assembler supports the section flag 'e' for specifying
3597         # an excluded section.
3598         gcc_GAS_CHECK_FEATURE([.section with e], gcc_cv_as_section_has_e,
3599           [2,22,51],,
3600 [.section foo1,"e"
3601 .byte 0,0,0,0])
3602         AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3603           [`if test $gcc_cv_as_section_has_e = yes; then echo 1; else echo 0; fi`],
3604           [Define if your assembler supports specifying the section flag e.])
3605         ;;
3606     esac
3607
3608     gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3609        gcc_cv_as_ix86_filds,,,
3610        [filds mem; fists mem],,
3611        [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3612          [Define if your assembler uses filds and fists mnemonics.])])
3613
3614     gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3615        gcc_cv_as_ix86_fildq,,,
3616        [fildq mem; fistpq mem],,
3617        [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3618          [Define if your assembler uses fildq and fistq mnemonics.])])
3619
3620     gcc_GAS_CHECK_FEATURE([cmov syntax],
3621       gcc_cv_as_ix86_cmov_sun_syntax,,,
3622       [cmovl.l %edx, %eax],,
3623       [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3624         [Define if your assembler supports the Sun syntax for cmov.])])
3625
3626     gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3627       gcc_cv_as_ix86_ffreep,,,
3628       [ffreep %st(1)],,
3629       [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3630         [Define if your assembler supports the ffreep mnemonic.])])
3631
3632     gcc_GAS_CHECK_FEATURE([.quad directive],
3633       gcc_cv_as_ix86_quad,,,
3634       [.quad 0],,
3635       [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
3636         [Define if your assembler supports the .quad directive.])])
3637
3638     gcc_GAS_CHECK_FEATURE([sahf mnemonic],
3639       gcc_cv_as_ix86_sahf,,,
3640       [.code64
3641        sahf],,
3642       [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
3643         [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
3644
3645     gcc_GAS_CHECK_FEATURE([swap suffix],
3646       gcc_cv_as_ix86_swap,,,
3647       [movl.s %esp, %ebp],,
3648       [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
3649         [Define if your assembler supports the swap suffix.])])
3650
3651     gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
3652       gcc_cv_as_ix86_diff_sect_delta,,,
3653       [.section .rodata
3654 .L1:
3655         .long .L2-.L1
3656         .long .L3-.L1
3657         .text
3658 .L3:    nop
3659 .L2:    nop],,
3660       [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
3661         [Define if your assembler supports the subtraction of symbols in different sections.])])
3662
3663     # These two are used unconditionally by i386.[ch]; it is to be defined
3664     # to 1 if the feature is present, 0 otherwise.
3665     gcc_GAS_CHECK_FEATURE([GOTOFF in data],
3666         gcc_cv_as_ix86_gotoff_in_data, [2,11,0],,
3667 [       .text
3668 .L0:
3669         nop
3670         .data
3671         .long .L0@GOTOFF])
3672     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
3673       [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
3674       [Define true if the assembler supports '.long foo@GOTOFF'.])
3675
3676     gcc_GAS_CHECK_FEATURE([rep and lock prefix],
3677         gcc_cv_as_ix86_rep_lock_prefix,,,
3678         [rep movsl
3679          lock addl %edi, (%eax,%esi)
3680          lock orl $0, (%esp)],,
3681         [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
3682           [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
3683
3684     gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
3685         gcc_cv_as_ix86_tlsgdplt,,,
3686         [call    tls_gd@tlsgdplt],,
3687       [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
3688         [Define if your assembler supports @tlsgdplt.])])
3689
3690     gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
3691         gcc_cv_as_ix86_tlsldmplt,,,
3692         [call    tls_ld@tlsldmplt],,
3693       [AC_DEFINE(HAVE_AS_IX86_TLSLDMPLT, 1,
3694         [Define if your assembler supports @tlsldmplt.])])
3695
3696     ;;
3697
3698   ia64*-*-*)
3699     gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
3700         gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
3701 [       .text
3702         addl r15 = @ltoffx(x#), gp
3703         ;;
3704         ld8.mov r16 = [[r15]], x#],,
3705     [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
3706           [Define if your assembler supports ltoffx and ldxmov relocations.])])
3707
3708     ;;
3709
3710   powerpc*-*-*)
3711     case $target in
3712       *-*-aix*) conftest_s='    .machine "pwr5"
3713         .csect .text[[PR]]
3714         mfcr 3,128';;
3715       *-*-darwin*)
3716         gcc_GAS_CHECK_FEATURE([.machine directive support],
3717           gcc_cv_as_machine_directive,,,
3718           [     .machine ppc7400])
3719         if test x$gcc_cv_as_machine_directive != xyes; then
3720           echo "*** This target requires an assembler supporting \".machine\"" >&2
3721           echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
3722           test x$build = x$target && exit 1
3723         fi
3724         conftest_s='    .text
3725         mfcr r3,128';;
3726       *) conftest_s='   .machine power4
3727         .text
3728         mfcr 3,128';;
3729     esac
3730
3731     gcc_GAS_CHECK_FEATURE([mfcr field support],
3732       gcc_cv_as_powerpc_mfcrf, [2,14,0],,
3733       [$conftest_s],,
3734       [AC_DEFINE(HAVE_AS_MFCRF, 1,
3735           [Define if your assembler supports mfcr field.])])
3736
3737     case $target in
3738       *-*-aix*) conftest_s='    .machine "pwr5"
3739         .csect .text[[PR]]
3740         popcntb 3,3';;
3741       *) conftest_s='   .machine power5
3742         .text
3743         popcntb 3,3';;
3744     esac
3745
3746     gcc_GAS_CHECK_FEATURE([popcntb support],
3747       gcc_cv_as_powerpc_popcntb, [2,17,0],,
3748       [$conftest_s],,
3749       [AC_DEFINE(HAVE_AS_POPCNTB, 1,
3750           [Define if your assembler supports popcntb field.])])
3751
3752     case $target in
3753       *-*-aix*) conftest_s='    .machine "pwr5x"
3754         .csect .text[[PR]]
3755         frin 1,1';;
3756       *) conftest_s='   .machine power5
3757         .text
3758         frin 1,1';;
3759     esac
3760
3761     gcc_GAS_CHECK_FEATURE([fp round support],
3762       gcc_cv_as_powerpc_fprnd, [2,17,0],,
3763       [$conftest_s],,
3764       [AC_DEFINE(HAVE_AS_FPRND, 1,
3765           [Define if your assembler supports fprnd.])])
3766
3767     case $target in
3768       *-*-aix*) conftest_s='    .machine "pwr6"
3769         .csect .text[[PR]]
3770         mffgpr 1,3';;
3771       *) conftest_s='   .machine power6
3772         .text
3773         mffgpr 1,3';;
3774     esac
3775
3776     gcc_GAS_CHECK_FEATURE([move fp gpr support],
3777       gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
3778       [$conftest_s],,
3779       [AC_DEFINE(HAVE_AS_MFPGPR, 1,
3780           [Define if your assembler supports mffgpr and mftgpr.])])
3781
3782     case $target in
3783       *-*-aix*) conftest_s='    .csect .text[[PR]]
3784 LCF..0:
3785         addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
3786       *-*-darwin*)
3787         conftest_s='    .text
3788 LCF0:
3789         addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
3790       *) conftest_s='   .text
3791 .LCF0:
3792         addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
3793     esac
3794
3795     gcc_GAS_CHECK_FEATURE([rel16 relocs],
3796       gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
3797       [$conftest_s],,
3798       [AC_DEFINE(HAVE_AS_REL16, 1,
3799           [Define if your assembler supports R_PPC_REL16 relocs.])])
3800
3801     case $target in
3802       *-*-aix*) conftest_s='    .machine "pwr6"
3803         .csect .text[[PR]]
3804         cmpb 3,4,5';;
3805       *) conftest_s='   .machine power6
3806         .text
3807         cmpb 3,4,5';;
3808     esac
3809
3810     gcc_GAS_CHECK_FEATURE([compare bytes support],
3811       gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
3812       [$conftest_s],,
3813       [AC_DEFINE(HAVE_AS_CMPB, 1,
3814           [Define if your assembler supports cmpb.])])
3815
3816     case $target in
3817       *-*-aix*) conftest_s='    .machine "pwr6"
3818         .csect .text[[PR]]
3819         dadd 1,2,3';;
3820       *) conftest_s='   .machine power6
3821         .text
3822         dadd 1,2,3';;
3823     esac
3824
3825     gcc_GAS_CHECK_FEATURE([decimal float support],
3826       gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
3827       [$conftest_s],,
3828       [AC_DEFINE(HAVE_AS_DFP, 1,
3829           [Define if your assembler supports DFP instructions.])])
3830
3831     case $target in
3832       *-*-aix*) conftest_s='    .machine "pwr7"
3833         .csect .text[[PR]]
3834         lxvd2x 1,2,3';;
3835       *) conftest_s='   .machine power7
3836         .text
3837         lxvd2x 1,2,3';;
3838     esac
3839
3840     gcc_GAS_CHECK_FEATURE([vector-scalar support],
3841       gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
3842       [$conftest_s],,
3843       [AC_DEFINE(HAVE_AS_VSX, 1,
3844           [Define if your assembler supports VSX instructions.])])
3845
3846     case $target in
3847       *-*-aix*) conftest_s='    .machine "pwr7"
3848         .csect .text[[PR]]
3849         popcntd 3,3';;
3850       *) conftest_s='   .machine power7
3851         .text
3852         popcntd 3,3';;
3853     esac
3854
3855     gcc_GAS_CHECK_FEATURE([popcntd support],
3856       gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
3857       [$conftest_s],,
3858       [AC_DEFINE(HAVE_AS_POPCNTD, 1,
3859           [Define if your assembler supports POPCNTD instructions.])])
3860
3861     case $target in
3862       *-*-aix*) conftest_s='    .csect .text[[PR]]
3863         lwsync';;
3864       *) conftest_s='   .text
3865         lwsync';;
3866     esac
3867
3868     gcc_GAS_CHECK_FEATURE([lwsync support],
3869       gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
3870       [$conftest_s],,
3871       [AC_DEFINE(HAVE_AS_LWSYNC, 1,
3872           [Define if your assembler supports LWSYNC instructions.])])
3873
3874     case $target in
3875       *-*-aix*) conftest_s='    .machine "476"
3876         .csect .text[[PR]]
3877         dci 0';;
3878       *) conftest_s='   .machine "476"
3879         .text
3880         dci 0';;
3881     esac
3882
3883     gcc_GAS_CHECK_FEATURE([data cache invalidate support],
3884       gcc_cv_as_powerpc_dci, [9,99,0], -a32,
3885       [$conftest_s],,
3886       [AC_DEFINE(HAVE_AS_DCI, 1,
3887           [Define if your assembler supports the DCI/ICI instructions.])])
3888
3889     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3890       gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
3891       [.gnu_attribute 4,1],,
3892       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3893           [Define if your assembler supports .gnu_attribute.])])
3894
3895     gcc_GAS_CHECK_FEATURE([tls marker support],
3896       gcc_cv_as_powerpc_tls_markers, [2,20,0],,
3897       [ bl __tls_get_addr(x@tlsgd)],,
3898       [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
3899           [Define if your assembler supports arg info for __tls_get_addr.])])
3900
3901     case $target in
3902       *-*-aix*)
3903         gcc_GAS_CHECK_FEATURE([.ref support],
3904           gcc_cv_as_aix_ref, [2.21.0],,
3905           [     .csect stuff[[rw]]
3906              stuff:
3907                 .long 1
3908                 .extern sym
3909                 .ref sym
3910           ],,
3911           [AC_DEFINE(HAVE_AS_REF, 1,
3912             [Define if your assembler supports .ref])])
3913         ;;
3914     esac
3915     ;;
3916
3917   mips*-*-*)
3918     gcc_GAS_CHECK_FEATURE([explicit relocation support],
3919       gcc_cv_as_mips_explicit_relocs, [2,14,0],,
3920 [       lw $4,%gp_rel(foo)($4)],,
3921       [if test x$target_cpu_default = x
3922        then target_cpu_default=MASK_EXPLICIT_RELOCS
3923        else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
3924        fi])
3925     gcc_GAS_CHECK_FEATURE([-mno-shared support],
3926       gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
3927       [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
3928                  [Define if the assembler understands -mno-shared.])])
3929
3930     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3931       gcc_cv_as_mips_gnu_attribute, [2,18,0],,
3932       [.gnu_attribute 4,1],,
3933       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3934           [Define if your assembler supports .gnu_attribute.])])
3935
3936     gcc_GAS_CHECK_FEATURE([.dtprelword support],
3937       gcc_cv_as_mips_dtprelword, [2,18,0],,
3938       [.section .tdata,"awT",@progbits
3939 x:
3940         .word 2
3941         .text
3942         .dtprelword x+0x8000],,
3943       [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
3944           [Define if your assembler supports .dtprelword.])])
3945
3946     gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
3947       gcc_cv_as_mips_dspr1_mult,,,
3948 [       .set    mips32r2
3949         .set    nodspr2
3950         .set    dsp
3951         madd    $ac3,$4,$5
3952         maddu   $ac3,$4,$5
3953         msub    $ac3,$4,$5
3954         msubu   $ac3,$4,$5
3955         mult    $ac3,$4,$5
3956         multu   $ac3,$4,$5],,
3957       [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
3958           [Define if your assembler supports DSPR1 mult.])])
3959
3960     AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
3961     gcc_cv_as_ld_jalr_reloc=no
3962     if test $gcc_cv_as_mips_explicit_relocs = yes; then
3963       if test $in_tree_ld = yes ; then
3964         if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 20 -o "$gcc_cv_gld_major_version" -gt 2 \
3965            && test $in_tree_ld_is_elf = yes; then
3966           gcc_cv_as_ld_jalr_reloc=yes
3967         fi
3968       elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
3969         echo '  .ent x' > conftest.s
3970         echo 'x:        ld $2,%got_disp(y)($3)' >> conftest.s
3971         echo '  ld $25,%call16(y)($28)' >> conftest.s
3972         echo '  .reloc  1f,R_MIPS_JALR,y' >> conftest.s
3973         echo '1:        jalr $25' >> conftest.s
3974         echo '  .reloc  1f,R_MIPS_JALR,x' >> conftest.s
3975         echo '1:        jalr $25' >> conftest.s
3976         echo '  .end x' >> conftest.s
3977         if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
3978            && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
3979           if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
3980              && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
3981             gcc_cv_as_ld_jalr_reloc=yes
3982           fi
3983         fi
3984         rm -f conftest.*
3985       fi
3986     fi
3987     if test $gcc_cv_as_ld_jalr_reloc = yes; then
3988       if test x$target_cpu_default = x; then
3989         target_cpu_default=MASK_RELAX_PIC_CALLS
3990       else
3991         target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
3992       fi
3993     fi
3994     AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
3995
3996     AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
3997       [gcc_cv_ld_mips_personality_relaxation],
3998       [gcc_cv_ld_mips_personality_relaxation=no
3999        if test $in_tree_ld = yes ; then
4000          if test "$gcc_cv_gld_major_version" -eq 2 \
4001                  -a "$gcc_cv_gld_minor_version" -ge 21 \
4002                  -o "$gcc_cv_gld_major_version" -gt 2; then
4003            gcc_cv_ld_mips_personality_relaxation=yes
4004          fi
4005        elif test x$gcc_cv_as != x \
4006                  -a x$gcc_cv_ld != x \
4007                  -a x$gcc_cv_readelf != x ; then
4008          cat > conftest.s <<EOF
4009         .cfi_startproc
4010         .cfi_personality 0x80,indirect_ptr
4011         .ent test
4012 test:
4013         nop
4014         .end test
4015         .cfi_endproc
4016
4017         .section .data,"aw",@progbits
4018 indirect_ptr:
4019         .dc.a personality
4020 EOF
4021          if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
4022             && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
4023            if $gcc_cv_readelf -d conftest 2>&1 \
4024               | grep TEXTREL > /dev/null 2>&1; then
4025              :
4026            elif $gcc_cv_readelf --relocs conftest 2>&1 \
4027                 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
4028              :
4029            else
4030              gcc_cv_ld_mips_personality_relaxation=yes
4031            fi
4032          fi
4033        fi
4034        rm -f conftest.s conftest.o conftest])
4035     if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
4036             AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
4037       [Define if your linker can relax absolute .eh_frame personality
4038 pointers into PC-relative form.])
4039     fi
4040     ;;
4041 esac
4042
4043 # Mips and HP-UX need the GNU assembler.
4044 # Linux on IA64 might be able to use the Intel assembler.
4045
4046 case "$target" in
4047   mips*-*-* | *-*-hpux* )
4048     if test x$gas_flag = xyes \
4049        || test x"$host" != x"$build" \
4050        || test ! -x "$gcc_cv_as" \
4051        || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
4052       :
4053     else
4054       echo "*** This configuration requires the GNU assembler" >&2
4055       exit 1
4056     fi
4057     ;;
4058 esac
4059
4060 # ??? Not all targets support dwarf2 debug_line, even within a version
4061 # of gas.  Moreover, we need to emit a valid instruction to trigger any
4062 # info to the output file.  So, as supported targets are added to gas 2.11,
4063 # add some instruction here to (also) show we expect this might work.
4064 # ??? Once 2.11 is released, probably need to add first known working
4065 # version to the per-target configury.
4066 case "$cpu_type" in
4067   alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze | mips \
4068   | pa | rs6000 | score | sparc | spu | xstormy16 | xtensa)
4069     insn="nop"
4070     ;;
4071   ia64 | s390)
4072     insn="nop 0"
4073     ;;
4074   mmix)
4075     insn="swym 0"
4076     ;;
4077 esac
4078 if test x"$insn" != x; then
4079  conftest_s="\
4080         .file 1 \"conftest.s\"
4081         .loc 1 3 0
4082         $insn"
4083  gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
4084   gcc_cv_as_dwarf2_debug_line,
4085   [elf,2,11,0],, [$conftest_s],
4086   [if test x$gcc_cv_objdump != x \
4087    && $gcc_cv_objdump -h conftest.o 2> /dev/null \
4088       | grep debug_line > /dev/null 2>&1; then
4089      gcc_cv_as_dwarf2_debug_line=yes
4090    fi])
4091
4092 # The .debug_line file table must be in the exact order that
4093 # we specified the files, since these indices are also used
4094 # by DW_AT_decl_file.  Approximate this test by testing if
4095 # the assembler bitches if the same index is assigned twice.
4096  gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
4097   gcc_cv_as_dwarf2_file_buggy,,,
4098 [       .file 1 "foo.s"
4099         .file 1 "bar.s"])
4100
4101  if test $gcc_cv_as_dwarf2_debug_line = yes \
4102  && test $gcc_cv_as_dwarf2_file_buggy = no; then
4103         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
4104   [Define if your assembler supports dwarf2 .file/.loc directives,
4105    and preserves file table indices exactly as given.])
4106  fi
4107
4108  gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
4109   gcc_cv_as_gdwarf2_flag,
4110   [elf,2,11,0], [--gdwarf2], [$insn],,
4111   [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
4112 [Define if your assembler supports the --gdwarf2 option.])])
4113
4114  gcc_GAS_CHECK_FEATURE([--gstabs option],
4115   gcc_cv_as_gstabs_flag,
4116   [elf,2,11,0], [--gstabs], [$insn],
4117   [# The native Solaris 9/Intel assembler doesn't understand --gstabs
4118    # and warns about it, but still exits successfully.  So check for
4119    # this.
4120    if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
4121    then :
4122    else gcc_cv_as_gstabs_flag=yes
4123    fi],
4124   [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
4125 [Define if your assembler supports the --gstabs option.])])
4126
4127  gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
4128   gcc_cv_as_debug_prefix_map_flag,
4129   [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
4130   [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
4131 [Define if your assembler supports the --debug-prefix-map option.])])
4132 fi
4133
4134 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
4135  ,,
4136 [.lcomm bar,4,16],,
4137 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
4138   [Define if your assembler supports .lcomm with an alignment field.])])
4139
4140 AC_ARG_ENABLE(gnu-unique-object,
4141  [AS_HELP_STRING([--enable-gnu-unique-object],
4142    [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
4143  [case $enable_gnu_unique_object in
4144     yes | no) ;;
4145     *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
4146 Valid choices are 'yes' and 'no'.]) ;;
4147   esac],
4148  [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
4149    [elf,2,19,52],,
4150    [.type foo, @gnu_unique_object],,
4151 # Also check for ld.so support, i.e. glibc 2.11 or higher.
4152    [[if test x$host = x$build -a x$host = x$target &&
4153        ldd --version 2>/dev/null &&
4154        glibcver=`ldd --version 2>/dev/null | sed 's/.* //;q'`; then
4155       glibcmajor=`expr "$glibcver" : "\([0-9]*\)"`
4156       glibcminor=`expr "$glibcver" : "[2-9]*\.\([0-9]*\)"`
4157       glibcnum=`expr $glibcmajor \* 1000 + $glibcminor`
4158       if test "$glibcnum" -ge 2011 ; then
4159         enable_gnu_unique_object=yes
4160       fi
4161     fi]])])
4162 if test x$enable_gnu_unique_object = xyes; then
4163   AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
4164    [Define if your assembler supports @gnu_unique_object.])
4165 fi
4166
4167 AC_CACHE_CHECK([assembler for tolerance to line number 0],
4168  [gcc_cv_as_line_zero],
4169  [gcc_cv_as_line_zero=no
4170   if test $in_tree_gas = yes; then
4171     gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
4172   elif test "x$gcc_cv_as" != x; then
4173     { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
4174     if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
4175        test "x`cat conftest.out`" = x
4176     then
4177       gcc_cv_as_line_zero=yes
4178     else
4179       echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
4180       cat conftest.s >&AS_MESSAGE_LOG_FD
4181       echo "configure: error output was" >&AS_MESSAGE_LOG_FD
4182       cat conftest.out >&AS_MESSAGE_LOG_FD
4183     fi
4184     rm -f conftest.o conftest.s conftest.out
4185   fi])
4186 if test "x$gcc_cv_as_line_zero" = xyes; then
4187   AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
4188 [Define if the assembler won't complain about a line such as # 0 "" 2.])
4189 fi
4190
4191 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
4192 gcc_cv_ld_eh_frame_hdr=no
4193 if test $in_tree_ld = yes ; then
4194   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 \
4195      && test $in_tree_ld_is_elf = yes; then
4196     gcc_cv_ld_eh_frame_hdr=yes
4197   fi
4198 elif test x$gcc_cv_ld != x; then
4199   if echo "$ld_ver" | grep GNU > /dev/null; then
4200     # Check if linker supports --eh-frame-hdr option
4201     if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
4202       gcc_cv_ld_eh_frame_hdr=yes
4203     fi
4204   else
4205     case "$target" in
4206       *-*-solaris2*)
4207         # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
4208         if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
4209           gcc_cv_ld_eh_frame_hdr=yes
4210         fi
4211         ;;
4212     esac
4213   fi
4214 fi
4215 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
4216 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
4217         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
4218 [Define if your linker supports .eh_frame_hdr.])
4219 fi
4220 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
4221
4222 AC_MSG_CHECKING(linker position independent executable support)
4223 gcc_cv_ld_pie=no
4224 if test $in_tree_ld = yes ; then
4225   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 \
4226      && test $in_tree_ld_is_elf = yes; then
4227     gcc_cv_ld_pie=yes
4228   fi
4229 elif test x$gcc_cv_ld != x; then
4230         # Check if linker supports -pie option
4231         if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
4232                 gcc_cv_ld_pie=yes
4233         fi
4234 fi
4235 if test x"$gcc_cv_ld_pie" = xyes; then
4236         AC_DEFINE(HAVE_LD_PIE, 1,
4237 [Define if your linker supports -pie option.])
4238 fi
4239 AC_MSG_RESULT($gcc_cv_ld_pie)
4240
4241 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
4242 gcc_cv_ld_eh_gc_sections=no
4243 if test $in_tree_ld = yes ; then
4244   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 \
4245      && test $in_tree_ld_is_elf = yes; then
4246     gcc_cv_ld_eh_gc_sections=yes
4247   fi
4248 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
4249   cat > conftest.s <<EOF
4250         .section        .text
4251 .globl _start
4252         .type _start, @function
4253 _start:
4254         .long foo
4255         .size _start, .-_start
4256         .section        .text.foo,"ax",@progbits
4257         .type foo, @function
4258 foo:
4259         .long 0
4260         .size foo, .-foo
4261         .section        .gcc_except_table.foo,"a",@progbits
4262 .L0:
4263         .long 0
4264         .section        .eh_frame,"a",@progbits
4265         .long .L0
4266 EOF
4267   if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4268     if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4269          | grep "gc-sections option ignored" > /dev/null; then
4270       gcc_cv_ld_eh_gc_sections=no
4271     elif $gcc_cv_objdump -h conftest 2> /dev/null \
4272          | grep gcc_except_table > /dev/null; then
4273       gcc_cv_ld_eh_gc_sections=yes
4274       # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
4275       if test x$gcc_cv_as_comdat_group != xyes; then
4276         gcc_cv_ld_eh_gc_sections=no
4277         cat > conftest.s <<EOF
4278         .section        .text
4279 .globl _start
4280         .type _start, @function
4281 _start:
4282         .long foo
4283         .size _start, .-_start
4284         .section        .gnu.linkonce.t.foo,"ax",@progbits
4285         .type foo, @function
4286 foo:
4287         .long 0
4288         .size foo, .-foo
4289         .section        .gcc_except_table.foo,"a",@progbits
4290 .L0:
4291         .long 0
4292         .section        .eh_frame,"a",@progbits
4293         .long .L0
4294 EOF
4295         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4296           if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4297                | grep "gc-sections option ignored" > /dev/null; then
4298             gcc_cv_ld_eh_gc_sections=no
4299           elif $gcc_cv_objdump -h conftest 2> /dev/null \
4300                | grep gcc_except_table > /dev/null; then
4301             gcc_cv_ld_eh_gc_sections=yes
4302           fi
4303         fi
4304       fi
4305     fi
4306   fi
4307   rm -f conftest.s conftest.o conftest
4308 fi
4309 case "$target" in
4310   hppa*-*-linux*)
4311     # ??? This apparently exposes a binutils bug with PC-relative relocations.
4312     gcc_cv_ld_eh_gc_sections=no
4313     ;;
4314 esac
4315 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
4316         AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
4317   [Define if your linker supports garbage collection of
4318    sections in presence of EH frames.])
4319 fi
4320 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
4321
4322 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
4323 gcc_cv_ld_eh_gc_sections_bug=no
4324 if test $in_tree_ld = yes ; then
4325   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -lt 19 -o "$gcc_cv_gld_major_version" -lt 2 \
4326      && test $in_tree_ld_is_elf = yes; then
4327     gcc_cv_ld_eh_gc_sections_bug=yes
4328   fi
4329 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x -a x$gcc_cv_as_comdat_group = xyes; then
4330   gcc_cv_ld_eh_gc_sections_bug=yes
4331   cat > conftest.s <<EOF
4332         .section        .text
4333 .globl _start
4334         .type _start, @function
4335 _start:
4336         .long foo
4337         .size _start, .-_start
4338         .section        .text.startup.foo,"ax",@progbits
4339         .type foo, @function
4340 foo:
4341         .long 0
4342         .size foo, .-foo
4343         .section        .gcc_except_table.foo,"a",@progbits
4344 .L0:
4345         .long 0
4346         .section        .eh_frame,"a",@progbits
4347         .long .L0
4348 EOF
4349   if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4350     if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4351          | grep "gc-sections option ignored" > /dev/null; then
4352       :
4353     elif $gcc_cv_objdump -h conftest 2> /dev/null \
4354          | grep gcc_except_table > /dev/null; then
4355       gcc_cv_ld_eh_gc_sections_bug=no
4356     fi
4357   fi
4358   rm -f conftest.s conftest.o conftest
4359 fi
4360 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
4361         AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
4362   [Define if your linker has buggy garbage collection of
4363    sections support when .text.startup.foo like sections are used.])
4364 fi
4365 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
4366
4367 # --------
4368 # UNSORTED
4369 # --------
4370
4371 AC_CACHE_CHECK(linker --as-needed support,
4372 gcc_cv_ld_as_needed,
4373 [gcc_cv_ld_as_needed=no
4374 if test $in_tree_ld = yes ; then
4375   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 \
4376      && test $in_tree_ld_is_elf = yes; then
4377     gcc_cv_ld_as_needed=yes
4378   fi
4379 elif test x$gcc_cv_ld != x; then
4380         # Check if linker supports --as-needed and --no-as-needed options
4381         if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
4382                 gcc_cv_ld_as_needed=yes
4383         fi
4384 fi
4385 ])
4386 if test x"$gcc_cv_ld_as_needed" = xyes; then
4387         AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
4388 [Define if your linker supports --as-needed and --no-as-needed options.])
4389 fi
4390
4391 case "$target:$tm_file" in
4392   powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
4393     AC_CACHE_CHECK(linker support for omitting dot symbols,
4394     gcc_cv_ld_no_dot_syms,
4395     [gcc_cv_ld_no_dot_syms=no
4396     if test $in_tree_ld = yes ; then
4397       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
4398         gcc_cv_ld_no_dot_syms=yes
4399       fi
4400     elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4401       cat > conftest1.s <<EOF
4402         .text
4403         bl .foo
4404 EOF
4405       cat > conftest2.s <<EOF
4406         .section ".opd","aw"
4407         .align 3
4408         .globl foo
4409         .type foo,@function
4410 foo:
4411         .quad .LEfoo,.TOC.@tocbase,0
4412         .text
4413 .LEfoo:
4414         blr
4415         .size foo,.-.LEfoo
4416 EOF
4417       if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4418          && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4419          && $gcc_cv_ld -melf64ppc -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
4420         gcc_cv_ld_no_dot_syms=yes
4421       fi
4422       rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
4423     fi
4424     ])
4425     if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
4426       AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
4427     [Define if your PowerPC64 linker only needs function descriptor syms.])
4428     fi
4429
4430     AC_CACHE_CHECK(linker large toc support,
4431     gcc_cv_ld_large_toc,
4432     [gcc_cv_ld_large_toc=no
4433     if test $in_tree_ld = yes ; then
4434       if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 21 -o "$gcc_cv_gld_major_version" -gt 2; then
4435         gcc_cv_ld_large_toc=yes
4436       fi
4437     elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4438       cat > conftest.s <<EOF
4439         .section ".tbss","awT",@nobits
4440         .align 3
4441 ie0:    .space 8
4442         .global _start
4443         .text
4444 _start:
4445         addis 9,13,ie0@got@tprel@ha
4446         ld 9,ie0@got@tprel@l(9)
4447 EOF
4448       if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
4449          && $gcc_cv_ld -melf64ppc --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
4450         gcc_cv_ld_large_toc=yes
4451       fi
4452       rm -f conftest conftest.o conftest.s
4453     fi
4454     ])
4455     if test x"$gcc_cv_ld_large_toc" = xyes; then
4456       AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4457     [Define if your PowerPC64 linker supports a large TOC.])
4458     fi
4459     ;;
4460 esac
4461
4462 AC_CACHE_CHECK(linker --build-id support,
4463   gcc_cv_ld_buildid,
4464   [gcc_cv_ld_buildid=no
4465   if test $in_tree_ld = yes ; then
4466     if test "$gcc_cv_gld_major_version" -eq 2 -a \
4467        "$gcc_cv_gld_minor_version" -ge 18 -o \
4468        "$gcc_cv_gld_major_version" -gt 2 \
4469        && test $in_tree_ld_is_elf = yes; then
4470       gcc_cv_ld_buildid=yes
4471     fi
4472   elif test x$gcc_cv_ld != x; then
4473     if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
4474       gcc_cv_ld_buildid=yes
4475     fi
4476   fi])
4477 if test x"$gcc_cv_ld_buildid" = xyes; then
4478   AC_DEFINE(HAVE_LD_BUILDID, 1,
4479   [Define if your linker supports --build-id.])
4480 fi
4481
4482 AC_ARG_ENABLE(linker-build-id,
4483 [AS_HELP_STRING([--enable-linker-build-id],
4484                 [compiler will always pass --build-id to linker])],
4485 [],
4486 enable_linker_build_id=no)
4487
4488 if test x"$enable_linker_build_id" = xyes; then
4489   if test x"$gcc_cv_ld_buildid" = xyes; then
4490     AC_DEFINE(ENABLE_LD_BUILDID, 1,
4491     [Define if gcc should always pass --build-id to linker.])
4492   else
4493     AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
4494   fi
4495 fi
4496
4497 # In binutils 2.21, GNU ld gained support for new emulations fully
4498 # supporting the Solaris 2 ABI.  Detect their presence in the linker used.
4499 AC_CACHE_CHECK(linker *_sol2 emulation support,
4500   gcc_cv_ld_sol2_emulation,
4501   [gcc_cv_ld_sol2_emulation=no
4502   if test $in_tree_ld = yes ; then
4503     if test "$gcc_cv_gld_major_version" -eq 2 -a \
4504        "$gcc_cv_gld_minor_version" -ge 21 -o \
4505        "$gcc_cv_gld_major_version" -gt 2 \
4506        && test $in_tree_ld_is_elf = yes; then
4507       gcc_cv_ld_sol2_emulation=yes
4508     fi
4509   elif test x$gcc_cv_ld != x; then
4510     if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
4511        grep _sol2 > /dev/null; then
4512       gcc_cv_ld_sol2_emulation=yes
4513     fi
4514   fi])
4515 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
4516   AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
4517   [Define if your linker supports the *_sol2 emulations.])
4518 fi
4519
4520 AC_CACHE_CHECK(linker --sysroot support,
4521   gcc_cv_ld_sysroot,
4522   [gcc_cv_ld_sysroot=no
4523   if test $in_tree_ld = yes ; then
4524       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
4525         gcc_cv_ld_sysroot=yes
4526       fi
4527   elif test x$gcc_cv_ld != x; then
4528     if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
4529       gcc_cv_ld_sysroot=yes
4530     fi
4531   fi])
4532 if test x"$gcc_cv_ld_sysroot" = xyes; then
4533   AC_DEFINE(HAVE_LD_SYSROOT, 1,
4534   [Define if your linker supports --sysroot.])
4535 fi
4536
4537 if test x$with_sysroot = x && test x$host = x$target \
4538    && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4539    && test "$prefix" != "NONE"; then
4540   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4541 [Define to PREFIX/include if cpp should also search that directory.])
4542 fi
4543
4544 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4545   if test "x$with_headers" != x; then
4546     target_header_dir=$with_headers
4547   elif test "x$with_sysroot" = x; then
4548     target_header_dir="${exec_prefix}/${target_noncanonical}/sys-include"
4549   elif test "x$with_build_sysroot" != "x"; then
4550     target_header_dir="${with_build_sysroot}${native_system_header_dir}"
4551   elif test "x$with_sysroot" = xyes; then
4552     target_header_dir="${exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
4553   else
4554     target_header_dir="${with_sysroot}${native_system_header_dir}"
4555   fi
4556 else
4557   target_header_dir=${native_system_header_dir}
4558 fi
4559
4560 # Test for stack protector support in target C library.
4561 AC_CACHE_CHECK(__stack_chk_fail in target C library,
4562       gcc_cv_libc_provides_ssp,
4563       [gcc_cv_libc_provides_ssp=no
4564     case "$target" in
4565        *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
4566       [# glibc 2.4 and later provides __stack_chk_fail and
4567       # either __stack_chk_guard, or TLS access to stack guard canary.
4568       if test -f $target_header_dir/features.h \
4569          && $EGREP '^[  ]*#[    ]*define[       ]+__GNU_LIBRARY__[      ]+([1-9][0-9]|[6-9])' \
4570             $target_header_dir/features.h > /dev/null; then
4571         if $EGREP '^[   ]*#[    ]*define[       ]+__GLIBC__[    ]+([1-9][0-9]|[3-9])' \
4572            $target_header_dir/features.h > /dev/null; then
4573           gcc_cv_libc_provides_ssp=yes
4574         elif $EGREP '^[         ]*#[    ]*define[       ]+__GLIBC__[    ]+2' \
4575              $target_header_dir/features.h > /dev/null \
4576              && $EGREP '^[      ]*#[    ]*define[       ]+__GLIBC_MINOR__[      ]+([1-9][0-9]|[4-9])' \
4577              $target_header_dir/features.h > /dev/null; then
4578           gcc_cv_libc_provides_ssp=yes
4579         elif $EGREP '^[         ]*#[    ]*define[       ]+__UCLIBC__[   ]+1' \
4580              $target_header_dir/features.h > /dev/null && \
4581              test -f $target_header_dir/bits/uClibc_config.h && \
4582              $EGREP '^[         ]*#[    ]*define[       ]+__UCLIBC_HAS_SSP__[   ]+1' \
4583              $target_header_dir/bits/uClibc_config.h > /dev/null; then
4584           gcc_cv_libc_provides_ssp=yes
4585         fi
4586       fi]
4587         ;;
4588        *-*-gnu*)
4589          # Avoid complicated tests (see
4590          # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
4591          # simply assert that glibc does provide this, which is true for all
4592          # realistically usable GNU/Hurd configurations.
4593          gcc_cv_libc_provides_ssp=yes;;
4594        *-*-darwin* | *-*-freebsd*)
4595          AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
4596            [echo "no __stack_chk_fail on this target"])
4597         ;;
4598   *) gcc_cv_libc_provides_ssp=no ;;
4599     esac])
4600
4601 if test x$gcc_cv_libc_provides_ssp = xyes; then
4602   AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
4603             [Define if your target C library provides stack protector support])
4604 fi
4605
4606 # Test for <sys/sdt.h> on the target.
4607 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
4608 AC_MSG_CHECKING(sys/sdt.h in the target C library)
4609 have_sys_sdt_h=no
4610 if test -f $target_header_dir/sys/sdt.h; then
4611   have_sys_sdt_h=yes
4612   AC_DEFINE(HAVE_SYS_SDT_H, 1,
4613             [Define if your target C library provides sys/sdt.h])
4614 fi
4615 AC_MSG_RESULT($have_sys_sdt_h)
4616
4617 # Check if TFmode long double should be used by default or not.
4618 # Some glibc targets used DFmode long double, but with glibc 2.4
4619 # and later they can use TFmode.
4620 case "$target" in
4621   powerpc*-*-linux* | \
4622   sparc*-*-linux* | \
4623   s390*-*-linux* | \
4624   alpha*-*-linux*)
4625     AC_ARG_WITH(long-double-128,
4626       [AS_HELP_STRING([--with-long-double-128],
4627                       [use 128-bit long double by default])],
4628       gcc_cv_target_ldbl128="$with_long_double_128",
4629       [[gcc_cv_target_ldbl128=no
4630       grep '^[  ]*#[    ]*define[       ][      ]*__LONG_DOUBLE_MATH_OPTIONAL' \
4631         $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
4632       && gcc_cv_target_ldbl128=yes
4633       ]])
4634     ;;
4635 esac
4636 if test x$gcc_cv_target_ldbl128 = xyes; then
4637   AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
4638             [Define if TFmode long double should be the default])
4639 fi
4640
4641 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
4642 gcc_cv_target_dl_iterate_phdr=unknown
4643 case "$target" in
4644   *-*-solaris2*)
4645     # <link.h> needs both a dl_iterate_phdr declaration and support for
4646     # compilation with largefile support.
4647     if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
4648       && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
4649       gcc_cv_target_dl_iterate_phdr=yes
4650     else
4651       gcc_cv_target_dl_iterate_phdr=no
4652     fi
4653     ;;
4654 esac
4655 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
4656 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
4657    AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
4658 [Define if your target C library provides the `dl_iterate_phdr' function.])
4659 fi
4660 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
4661
4662 # Find out what GC implementation we want, or may, use.
4663 AC_ARG_WITH(gc,
4664 [AS_HELP_STRING([--with-gc={page,zone}],
4665                 [choose the garbage collection mechanism to use
4666                  with the compiler])],
4667 [case "$withval" in
4668   page)
4669     GGC=ggc-$withval
4670     ;;
4671   zone)
4672     GGC=ggc-$withval
4673     AC_DEFINE(GGC_ZONE, 1, [Define if the zone collector is in use])
4674     ;;
4675   *)
4676     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
4677     ;;
4678 esac],
4679 [GGC=ggc-page])
4680 AC_SUBST(GGC)
4681 echo "Using $GGC for garbage collection."
4682
4683 # Libraries to use on the host.  This will normally be set by the top
4684 # level Makefile.  Here we simply capture the value for our Makefile.
4685 if test -z "${HOST_LIBS+set}"; then
4686   HOST_LIBS=
4687 fi
4688 AC_SUBST(HOST_LIBS)
4689
4690 # Use the system's zlib library.
4691 zlibdir=-L../zlib
4692 zlibinc="-I\$(srcdir)/../zlib"
4693 AC_ARG_WITH(system-zlib,
4694 [AS_HELP_STRING([--with-system-zlib], [use installed libz])],
4695 zlibdir=
4696 zlibinc=
4697 )
4698 AC_SUBST(zlibdir)
4699 AC_SUBST(zlibinc)
4700
4701 dnl Very limited version of automake's enable-maintainer-mode
4702
4703 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
4704   dnl maintainer-mode is disabled by default
4705   AC_ARG_ENABLE(maintainer-mode,
4706 [AS_HELP_STRING([--enable-maintainer-mode],
4707                 [enable make rules and dependencies not useful
4708                  (and sometimes confusing) to the casual installer])],
4709       maintainer_mode=$enableval,
4710       maintainer_mode=no)
4711
4712 AC_MSG_RESULT($maintainer_mode)
4713
4714 if test "$maintainer_mode" = "yes"; then
4715   MAINT=''
4716 else
4717   MAINT='#'
4718 fi
4719 AC_SUBST(MAINT)dnl
4720
4721 # --------------
4722 # Language hooks
4723 # --------------
4724
4725 # Make empty files to contain the specs and options for each language.
4726 # Then add #include lines to for a compiler that has specs and/or options.
4727
4728 subdirs=
4729 lang_opt_files=
4730 lang_specs_files=
4731 lang_tree_files=
4732 # These (without "all_") are set in each config-lang.in.
4733 # `language' must be a single word so is spelled singularly.
4734 all_languages=
4735 all_compilers=
4736 all_outputs='Makefile'
4737 # List of language makefile fragments.
4738 all_lang_makefrags=
4739 # Additional files for gengtype
4740 all_gtfiles="$target_gtfiles"
4741
4742 # These are the languages that are set in --enable-languages,
4743 # and are available in the GCC tree.
4744 all_selected_languages=
4745
4746 # Add the language fragments.
4747 # Languages are added via two mechanisms.  Some information must be
4748 # recorded in makefile variables, these are defined in config-lang.in.
4749 # We accumulate them and plug them into the main Makefile.
4750 # The other mechanism is a set of hooks for each of the main targets
4751 # like `clean', `install', etc.
4752
4753 language_hooks="Make-hooks"
4754
4755 for lang in ${srcdir}/*/config-lang.in
4756 do
4757 changequote(,)dnl
4758         test "$lang" = "${srcdir}/*/config-lang.in" && continue
4759
4760         lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
4761         if test "x$lang_alias" = x
4762         then
4763               echo "$lang doesn't set \$language." 1>&2
4764               exit 1
4765         fi
4766         subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
4767         subdirs="$subdirs $subdir"
4768
4769         # $gcc_subdir is where the gcc integration files are to be found
4770         # for a language, both for internal compiler purposes (compiler
4771         # sources implementing front-end to GCC tree converters), and for
4772         # build infrastructure purposes (Make-lang.in, etc.)
4773         #
4774         # This will be <subdir> (relative to $srcdir) if a line like
4775         # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
4776         # is found in <langdir>/config-lang.in, and will remain <langdir>
4777         # otherwise.
4778         #
4779         # Except for the language alias (fetched above), the regular
4780         # "config-lang.in" contents are always retrieved from $gcc_subdir,
4781         # so a <langdir>/config-lang.in setting gcc_subdir typically sets
4782         # only this and the language alias.
4783
4784         gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^   ]*\).*$,\1,p' $lang`
4785         if [ "$gcc_subdir" = "" ]; then
4786            gcc_subdir="$subdir"
4787         fi
4788
4789         case ",$enable_languages," in
4790         *,$lang_alias,*)
4791             all_selected_languages="$all_selected_languages $lang_alias"
4792             if test -f $srcdir/$gcc_subdir/lang-specs.h; then
4793                 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
4794             fi
4795             ;;
4796         esac
4797 changequote([,])dnl
4798
4799         language=
4800         boot_language=
4801         compilers=
4802         outputs=
4803         gtfiles=
4804         subdir_requires=
4805         . ${srcdir}/$gcc_subdir/config-lang.in
4806         if test "x$language" = x
4807         then
4808                 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
4809                 exit 1
4810         fi
4811
4812         ok=:
4813         case ",$enable_languages," in
4814                 *,$lang_alias,*) ;;
4815                 *)
4816                         for i in $subdir_requires; do
4817                                 test -f "${srcdir}/$i/config-lang.in" && continue
4818                                 ok=false
4819                                 break
4820                         done
4821                 ;;
4822         esac
4823         $ok || continue
4824
4825         all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
4826         if test -f $srcdir/$gcc_subdir/lang.opt; then
4827             lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
4828             all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
4829         fi
4830         if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
4831             lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
4832         fi
4833         all_languages="$all_languages $language"
4834         all_compilers="$all_compilers $compilers"
4835         all_outputs="$all_outputs $outputs"
4836         all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
4837         case ",$enable_languages," in
4838                 *,lto,*)
4839                     AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
4840                     enable_lto=yes
4841                     AC_SUBST(enable_lto)
4842                     ;;
4843                 *) ;;
4844         esac
4845 done
4846
4847 # Pick up gtfiles for c
4848 gtfiles=
4849 . ${srcdir}/c-config-lang.in
4850 all_gtfiles="$all_gtfiles [[c]] $gtfiles"
4851
4852 check_languages=
4853 for language in $all_selected_languages
4854 do
4855         check_languages="$check_languages check-$language"
4856 done
4857
4858 # We link each language in with a set of hooks, reached indirectly via
4859 # lang.${target}.  Only do so for selected languages.
4860
4861 rm -f Make-hooks
4862 touch Make-hooks
4863 target_list="all.cross start.encap rest.encap tags \
4864         install-common install-man install-info install-pdf install-html dvi \
4865         pdf html uninstall info man srcextra srcman srcinfo \
4866         mostlyclean clean distclean maintainer-clean install-plugin"
4867
4868 for t in $target_list
4869 do
4870         x=
4871         for lang in $all_selected_languages
4872         do
4873                 x="$x $lang.$t"
4874         done
4875         echo "lang.$t: $x" >> Make-hooks
4876 done
4877
4878 # --------
4879 # Option include files
4880 # --------
4881
4882 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
4883 option_includes="option-includes.mk"
4884 AC_SUBST_FILE(option_includes)
4885
4886 # --------
4887 # UNSORTED
4888 # --------
4889
4890 # Create .gdbinit.
4891
4892 echo "dir ." > .gdbinit
4893 echo "dir ${srcdir}" >> .gdbinit
4894 if test x$gdb_needs_out_file_path = xyes
4895 then
4896         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
4897 fi
4898 if test "x$subdirs" != x; then
4899         for s in $subdirs
4900         do
4901                 echo "dir ${srcdir}/$s" >> .gdbinit
4902         done
4903 fi
4904 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
4905
4906 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
4907 AC_SUBST(gcc_tooldir)
4908 AC_SUBST(dollar)
4909
4910 # Find a directory in which to install a shared libgcc.
4911
4912 AC_ARG_ENABLE(version-specific-runtime-libs,
4913 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
4914                 [specify that runtime libraries should be
4915                  installed in a compiler-specific directory])])
4916
4917 # Substitute configuration variables
4918 AC_SUBST(subdirs)
4919 AC_SUBST(srcdir)
4920 AC_SUBST(all_compilers)
4921 AC_SUBST(all_gtfiles)
4922 AC_SUBST(all_lang_makefrags)
4923 AC_SUBST(all_languages)
4924 AC_SUBST(all_selected_languages)
4925 AC_SUBST(build_exeext)
4926 AC_SUBST(build_install_headers_dir)
4927 AC_SUBST(build_xm_file_list)
4928 AC_SUBST(build_xm_include_list)
4929 AC_SUBST(build_xm_defines)
4930 AC_SUBST(build_file_translate)
4931 AC_SUBST(check_languages)
4932 AC_SUBST(cpp_install_dir)
4933 AC_SUBST(xmake_file)
4934 AC_SUBST(tmake_file)
4935 AC_SUBST(TM_ENDIAN_CONFIG)
4936 AC_SUBST(TM_MULTILIB_CONFIG)
4937 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
4938 AC_SUBST(extra_gcc_objs)
4939 AC_SUBST(user_headers_inc_next_pre)
4940 AC_SUBST(user_headers_inc_next_post)
4941 AC_SUBST(extra_headers_list)
4942 AC_SUBST(extra_objs)
4943 AC_SUBST(extra_passes)
4944 AC_SUBST(extra_programs)
4945 AC_SUBST(float_h_file)
4946 AC_SUBST(gcc_config_arguments)
4947 AC_SUBST(gcc_gxx_include_dir)
4948 AC_SUBST(host_exeext)
4949 AC_SUBST(host_xm_file_list)
4950 AC_SUBST(host_xm_include_list)
4951 AC_SUBST(host_xm_defines)
4952 AC_SUBST(out_host_hook_obj)
4953 AC_SUBST(install)
4954 AC_SUBST(lang_opt_files)
4955 AC_SUBST(lang_specs_files)
4956 AC_SUBST(lang_tree_files)
4957 AC_SUBST(local_prefix)
4958 AC_SUBST(md_file)
4959 AC_SUBST(objc_boehm_gc)
4960 AC_SUBST(out_file)
4961 AC_SUBST(out_object_file)
4962 AC_SUBST(common_out_file)
4963 AC_SUBST(common_out_object_file)
4964 AC_SUBST(thread_file)
4965 AC_SUBST(tm_file_list)
4966 AC_SUBST(tm_include_list)
4967 AC_SUBST(tm_defines)
4968 AC_SUBST(tm_p_file_list)
4969 AC_SUBST(tm_p_include_list)
4970 AC_SUBST(xm_file_list)
4971 AC_SUBST(xm_include_list)
4972 AC_SUBST(xm_defines)
4973 AC_SUBST(use_gcc_stdint)
4974 AC_SUBST(c_target_objs)
4975 AC_SUBST(cxx_target_objs)
4976 AC_SUBST(fortran_target_objs)
4977 AC_SUBST(target_cpu_default)
4978
4979 AC_SUBST_FILE(language_hooks)
4980
4981 # Echo link setup.
4982 if test x${build} = x${host} ; then
4983   if test x${host} = x${target} ; then
4984     echo "Links are now set up to build a native compiler for ${target}." 1>&2
4985   else
4986     echo "Links are now set up to build a cross-compiler" 1>&2
4987     echo " from ${host} to ${target}." 1>&2
4988   fi
4989 else
4990   if test x${host} = x${target} ; then
4991     echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
4992     echo " for ${target}." 1>&2
4993   else
4994     echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
4995     echo " from ${host} to ${target}." 1>&2
4996   fi
4997 fi
4998
4999 AC_ARG_VAR(GMPLIBS,[How to link GMP])
5000 AC_ARG_VAR(GMPINC,[How to find GMP include files])
5001
5002 AC_ARG_VAR(PPLLIBS,[How to link PPL])
5003 AC_ARG_VAR(PPLINC,[How to find PPL include files])
5004
5005 AC_ARG_VAR(CLOOGLIBS,[How to link CLOOG])
5006 AC_ARG_VAR(CLOOGINC,[How to find CLOOG include files])
5007 if test "x${CLOOGLIBS}" != "x" ; then
5008    AC_DEFINE(HAVE_cloog, 1, [Define if cloog is in use.])
5009 fi
5010
5011 # Check for plugin support
5012 AC_ARG_ENABLE(plugin,
5013 [AS_HELP_STRING([--enable-plugin], [enable plugin support])],
5014 enable_plugin=$enableval,
5015 enable_plugin=yes; default_plugin=yes)
5016
5017 pluginlibs=
5018
5019 case "${host}" in
5020   *-*-darwin*)
5021     if test x$build = x$host; then
5022       export_sym_check="nm${exeext} -g"
5023     elif test x$host = x$target; then
5024       export_sym_check="$gcc_cv_nm -g"
5025     else
5026       export_sym_check=
5027     fi
5028   ;;
5029   *)
5030     if test x$build = x$host; then
5031       export_sym_check="objdump${exeext} -T"
5032     elif test x$host = x$target; then
5033       export_sym_check="$gcc_cv_objdump -T"
5034     else
5035       export_sym_check=
5036     fi
5037   ;;
5038 esac
5039
5040 if test x"$enable_plugin" = x"yes"; then
5041
5042   AC_MSG_CHECKING([for exported symbols])
5043   if test "x$export_sym_check" != x; then
5044     echo "int main() {return 0;} int foobar() {return 0;}" > conftest.c
5045     ${CC} ${CFLAGS} ${LDFLAGS} conftest.c -o conftest > /dev/null 2>&1
5046     if $export_sym_check conftest | grep foobar > /dev/null; then
5047       : # No need to use a flag
5048       AC_MSG_RESULT([yes])
5049     else
5050       AC_MSG_RESULT([yes])
5051       AC_MSG_CHECKING([for -rdynamic])
5052       ${CC} ${CFLAGS} ${LDFLAGS} -rdynamic conftest.c -o conftest > /dev/null 2>&1
5053       if $export_sym_check conftest | grep foobar > /dev/null; then
5054         plugin_rdynamic=yes
5055         pluginlibs="-rdynamic"
5056       else
5057         plugin_rdynamic=no
5058         enable_plugin=no
5059       fi
5060       AC_MSG_RESULT([$plugin_rdynamic])
5061     fi
5062   else
5063     AC_MSG_RESULT([unable to check])
5064   fi
5065
5066   # Check -ldl
5067   saved_LIBS="$LIBS"
5068   AC_SEARCH_LIBS([dlopen], [dl])
5069   if test x"$ac_cv_search_dlopen" = x"-ldl"; then
5070     pluginlibs="$pluginlibs -ldl"
5071   fi
5072   LIBS="$saved_LIBS"
5073
5074   # Check that we can build shared objects with -fPIC -shared
5075   saved_LDFLAGS="$LDFLAGS"
5076   saved_CFLAGS="$CFLAGS"
5077   case "${host}" in
5078     *-*-darwin*)
5079       CFLAGS=`echo $CFLAGS | sed s/-mdynamic-no-pic//g`
5080       CFLAGS="$CFLAGS -fPIC"
5081       LDFLAGS="$LDFLAGS -shared -undefined dynamic_lookup"
5082     ;;
5083     *)
5084       CFLAGS="$CFLAGS -fPIC"
5085       LDFLAGS="$LDFLAGS -fPIC -shared"
5086     ;;
5087   esac
5088   AC_MSG_CHECKING([for -fPIC -shared])
5089   AC_TRY_LINK(
5090     [extern int X;],[return X == 0;],
5091     [AC_MSG_RESULT([yes]); have_pic_shared=yes],
5092     [AC_MSG_RESULT([no]); have_pic_shared=no])
5093   if test x"$have_pic_shared" != x"yes" -o x"$ac_cv_search_dlopen" = x"no"; then
5094     pluginlibs=
5095     enable_plugin=no
5096   fi
5097   LDFLAGS="$saved_LDFLAGS"
5098   CFLAGS="$saved_CFLAGS"
5099
5100   # If plugin support had been requested but not available, fail.
5101   if test x"$enable_plugin" = x"no" ; then
5102     if test x"$default_plugin" != x"yes"; then
5103       AC_MSG_ERROR([
5104 Building GCC with plugin support requires a host that supports
5105 -fPIC, -shared, -ldl and -rdynamic.])
5106     fi
5107   fi
5108 fi
5109
5110 AC_SUBST(pluginlibs)
5111 AC_SUBST(enable_plugin)
5112 if test x"$enable_plugin" = x"yes"; then
5113   AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
5114 fi
5115
5116
5117 AC_ARG_ENABLE(libquadmath-support,
5118 [AS_HELP_STRING([--disable-libquadmath-support],
5119   [disable libquadmath support for Fortran])],
5120 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
5121 ENABLE_LIBQUADMATH_SUPPORT=yes)
5122 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
5123   AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
5124             [Define to 1 to enable libquadmath support])
5125 fi
5126
5127
5128 # Specify what hash style to use by default.
5129 AC_ARG_WITH([linker-hash-style],
5130 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
5131                 [specify the linker hash style])],
5132 [case x"$withval" in
5133    xsysv)
5134      LINKER_HASH_STYLE=sysv
5135      ;;
5136    xgnu)
5137      LINKER_HASH_STYLE=gnu
5138      ;;
5139    xboth)
5140      LINKER_HASH_STYLE=both
5141      ;;
5142    *)
5143      AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
5144      ;;
5145  esac],
5146 [LINKER_HASH_STYLE=''])
5147 if test x"${LINKER_HASH_STYLE}" != x; then
5148   AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
5149                                          [The linker hash style])
5150 fi
5151
5152 # Configure the subdirectories
5153 # AC_CONFIG_SUBDIRS($subdirs)
5154
5155 # Create the Makefile
5156 # and configure language subdirectories
5157 AC_CONFIG_FILES($all_outputs)
5158
5159 AC_CONFIG_COMMANDS([default],
5160 [
5161 case ${CONFIG_HEADERS} in
5162   *auto-host.h:config.in*)
5163   echo > cstamp-h ;;
5164 esac
5165 # Make sure all the subdirs exist.
5166 for d in $subdirs doc build common c-family
5167 do
5168     test -d $d || mkdir $d
5169 done
5170 ],
5171 [subdirs='$subdirs'])
5172 AC_OUTPUT
5173