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