gcc/configure.ac

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