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