gcc/configure.ac

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