gcc/configure.ac

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