gcc/configure.ac

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