gcc/configure.ac

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