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