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