gcc/configure.ac

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