gcc/configure.ac

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