gcc/configure.ac

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