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