gcc/configure.ac

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