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