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