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     gcc_GAS_CHECK_FEATURE([LEON instructions],
3618       gcc_cv_as_sparc_leon,,
3619       [-Aleon],
3620       [.text
3621        .register %g2, #scratch
3622        .register %g3, #scratch
3623        .align 4
3624        smac %g2, %g3, %g1
3625        umac %g2, %g3, %g1
3626        cas [[%g2]], %g3, %g1],,
3627       [AC_DEFINE(HAVE_AS_LEON, 1,
3628                 [Define if your assembler supports LEON instructions.])])
3629     ;;
3630
3631 changequote(,)dnl
3632   i[34567]86-*-* | x86_64-*-*)
3633 changequote([,])dnl
3634     case $target_os in
3635       cygwin*)
3636         # Full C++ conformance when using a shared libstdc++-v3 requires some
3637         # support from the Cygwin DLL, which in more recent versions exports
3638         # wrappers to aid in interposing and redirecting operators new, delete,
3639         # etc., as per n2800 #17.6.4.6 [replacement.functions].  Check if we
3640         # are configuring for a version of Cygwin that exports the wrappers.
3641         if test x$host = x$target && test x$host_cpu = xi686; then
3642           AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3643         else
3644           # Can't check presence of libc functions during cross-compile, so
3645           # we just have to assume we're building for an up-to-date target.
3646           gcc_ac_cygwin_dll_wrappers=yes
3647         fi
3648         AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3649           [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3650           [Define if you want to generate code by default that assumes that the
3651            Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3652     esac
3653     case $target_os in
3654       cygwin* | pe | mingw32* | interix*)
3655         # Recent binutils allows the three-operand form of ".comm" on PE.  This
3656         # definition is used unconditionally to initialise the default state of
3657         # the target option variable that governs usage of the feature.
3658         gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3659          [2,19,52],,[.comm foo,1,32])
3660         AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3661           [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3662           [Define if your assembler supports specifying the alignment
3663            of objects allocated using the GAS .comm command.])
3664         # Used for DWARF 2 in PE
3665         gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3666           gcc_cv_as_ix86_pe_secrel32,
3667           [2,15,91],,
3668 [.text
3669 foo:    nop
3670 .data
3671         .secrel32 foo],
3672           [if test x$gcc_cv_ld != x \
3673            && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3674              gcc_cv_as_ix86_pe_secrel32=yes
3675            fi
3676            rm -f conftest],
3677           [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3678             [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3679         # Test if the assembler supports the extended form of the .section
3680         # directive that specifies section alignment.  LTO support uses this,
3681         # but normally only after installation, so we warn but don't fail the
3682         # configure if LTO is enabled but the assembler does not support it.
3683         gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3684           [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3685         if test x$gcc_cv_as_section_has_align != xyes; then
3686           case ",$enable_languages," in
3687             *,lto,*)
3688               AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3689               ;;
3690           esac
3691         fi
3692         # Test if the assembler supports the section flag 'e' for specifying
3693         # an excluded section.
3694         gcc_GAS_CHECK_FEATURE([.section with e], gcc_cv_as_section_has_e,
3695           [2,22,51],,
3696 [.section foo1,"e"
3697 .byte 0,0,0,0])
3698         AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3699           [`if test $gcc_cv_as_section_has_e = yes; then echo 1; else echo 0; fi`],
3700           [Define if your assembler supports specifying the section flag e.])
3701         ;;
3702     esac
3703
3704     gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3705        gcc_cv_as_ix86_filds,,,
3706        [filds mem; fists mem],,
3707        [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3708          [Define if your assembler uses filds and fists mnemonics.])])
3709
3710     gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3711        gcc_cv_as_ix86_fildq,,,
3712        [fildq mem; fistpq mem],,
3713        [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3714          [Define if your assembler uses fildq and fistq mnemonics.])])
3715
3716     gcc_GAS_CHECK_FEATURE([cmov syntax],
3717       gcc_cv_as_ix86_cmov_sun_syntax,,,
3718       [cmovl.l %edx, %eax],,
3719       [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3720         [Define if your assembler supports the Sun syntax for cmov.])])
3721
3722     gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3723       gcc_cv_as_ix86_ffreep,,,
3724       [ffreep %st(1)],,
3725       [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3726         [Define if your assembler supports the ffreep mnemonic.])])
3727
3728     gcc_GAS_CHECK_FEATURE([.quad directive],
3729       gcc_cv_as_ix86_quad,,,
3730       [.quad 0],,
3731       [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
3732         [Define if your assembler supports the .quad directive.])])
3733
3734     gcc_GAS_CHECK_FEATURE([sahf mnemonic],
3735       gcc_cv_as_ix86_sahf,,,
3736       [.code64
3737        sahf],,
3738       [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
3739         [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
3740
3741     gcc_GAS_CHECK_FEATURE([interunit movq mnemonic],
3742       gcc_cv_as_ix86_interunit_movq,,,
3743       [.code64
3744        movq %mm0, %rax
3745        movq %rax, %xmm0],,
3746       [AC_DEFINE(HAVE_AS_IX86_INTERUNIT_MOVQ, 1,
3747         [Define if your assembler supports interunit movq mnemonic.])])
3748
3749     gcc_GAS_CHECK_FEATURE([hle prefixes],
3750       gcc_cv_as_ix86_hle,,,
3751       [lock xacquire cmpxchg %esi, (%ecx)],,
3752       [AC_DEFINE(HAVE_AS_IX86_HLE, 1,
3753         [Define if your assembler supports HLE prefixes.])])
3754
3755     gcc_GAS_CHECK_FEATURE([swap suffix],
3756       gcc_cv_as_ix86_swap,,,
3757       [movl.s %esp, %ebp],,
3758       [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
3759         [Define if your assembler supports the swap suffix.])])
3760
3761     gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
3762       gcc_cv_as_ix86_diff_sect_delta,,,
3763       [.section .rodata
3764 .L1:
3765         .long .L2-.L1
3766         .long .L3-.L1
3767         .text
3768 .L3:    nop
3769 .L2:    nop],,
3770       [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
3771         [Define if your assembler supports the subtraction of symbols in different sections.])])
3772
3773     # These two are used unconditionally by i386.[ch]; it is to be defined
3774     # to 1 if the feature is present, 0 otherwise.
3775     gcc_GAS_CHECK_FEATURE([GOTOFF in data],
3776         gcc_cv_as_ix86_gotoff_in_data, [2,11,0],,
3777 [       .text
3778 .L0:
3779         nop
3780         .data
3781         .long .L0@GOTOFF])
3782     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
3783       [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
3784       [Define true if the assembler supports '.long foo@GOTOFF'.])
3785
3786     gcc_GAS_CHECK_FEATURE([rep and lock prefix],
3787         gcc_cv_as_ix86_rep_lock_prefix,,,
3788         [rep movsl
3789          rep ret
3790          rep nop
3791          rep bsf %ecx, %eax
3792          rep bsr %ecx, %eax
3793          lock addl %edi, (%eax,%esi)
3794          lock orl $0, (%esp)],,
3795         [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
3796           [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
3797
3798     gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
3799         gcc_cv_as_ix86_tlsgdplt,,,
3800         [call    tls_gd@tlsgdplt],
3801         [if test x$gcc_cv_ld != x \
3802          && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3803            gcc_cv_as_ix86_tlsgdplt=yes
3804          fi
3805          rm -f conftest],
3806       [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
3807         [Define if your assembler and linker support @tlsgdplt.])])
3808
3809     gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
3810         gcc_cv_as_ix86_tlsldmplt,,,
3811         [tls_ld:
3812          call    tls_ld@tlsldmplt],
3813         [if test x$gcc_cv_ld != x \
3814          && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3815            gcc_cv_as_ix86_tlsldmplt=yes
3816          fi
3817          rm -f conftest],
3818       [AC_DEFINE(HAVE_AS_IX86_TLSLDMPLT, 1,
3819         [Define if your assembler and linker support @tlsldmplt.])])
3820
3821     ;;
3822
3823   ia64*-*-*)
3824     gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
3825         gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
3826 [       .text
3827         addl r15 = @ltoffx(x#), gp
3828         ;;
3829         ld8.mov r16 = [[r15]], x#],,
3830     [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
3831           [Define if your assembler supports ltoffx and ldxmov relocations.])])
3832
3833     ;;
3834
3835   powerpc*-*-*)
3836     case $target in
3837       *-*-aix*) conftest_s='    .machine "pwr5"
3838         .csect .text[[PR]]
3839         mfcr 3,128';;
3840       *-*-darwin*)
3841         gcc_GAS_CHECK_FEATURE([.machine directive support],
3842           gcc_cv_as_machine_directive,,,
3843           [     .machine ppc7400])
3844         if test x$gcc_cv_as_machine_directive != xyes; then
3845           echo "*** This target requires an assembler supporting \".machine\"" >&2
3846           echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
3847           test x$build = x$target && exit 1
3848         fi
3849         conftest_s='    .text
3850         mfcr r3,128';;
3851       *) conftest_s='   .machine power4
3852         .text
3853         mfcr 3,128';;
3854     esac
3855
3856     gcc_GAS_CHECK_FEATURE([mfcr field support],
3857       gcc_cv_as_powerpc_mfcrf, [2,14,0],,
3858       [$conftest_s],,
3859       [AC_DEFINE(HAVE_AS_MFCRF, 1,
3860           [Define if your assembler supports mfcr field.])])
3861
3862     case $target in
3863       *-*-aix*) conftest_s='    .machine "pwr5"
3864         .csect .text[[PR]]
3865         popcntb 3,3';;
3866       *) conftest_s='   .machine power5
3867         .text
3868         popcntb 3,3';;
3869     esac
3870
3871     gcc_GAS_CHECK_FEATURE([popcntb support],
3872       gcc_cv_as_powerpc_popcntb, [2,17,0],,
3873       [$conftest_s],,
3874       [AC_DEFINE(HAVE_AS_POPCNTB, 1,
3875           [Define if your assembler supports popcntb field.])])
3876
3877     case $target in
3878       *-*-aix*) conftest_s='    .machine "pwr5x"
3879         .csect .text[[PR]]
3880         frin 1,1';;
3881       *) conftest_s='   .machine power5
3882         .text
3883         frin 1,1';;
3884     esac
3885
3886     gcc_GAS_CHECK_FEATURE([fp round support],
3887       gcc_cv_as_powerpc_fprnd, [2,17,0],,
3888       [$conftest_s],,
3889       [AC_DEFINE(HAVE_AS_FPRND, 1,
3890           [Define if your assembler supports fprnd.])])
3891
3892     case $target in
3893       *-*-aix*) conftest_s='    .machine "pwr6"
3894         .csect .text[[PR]]
3895         mffgpr 1,3';;
3896       *) conftest_s='   .machine power6
3897         .text
3898         mffgpr 1,3';;
3899     esac
3900
3901     gcc_GAS_CHECK_FEATURE([move fp gpr support],
3902       gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
3903       [$conftest_s],,
3904       [AC_DEFINE(HAVE_AS_MFPGPR, 1,
3905           [Define if your assembler supports mffgpr and mftgpr.])])
3906
3907     case $target in
3908       *-*-aix*) conftest_s='    .csect .text[[PR]]
3909 LCF..0:
3910         addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
3911       *-*-darwin*)
3912         conftest_s='    .text
3913 LCF0:
3914         addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
3915       *) conftest_s='   .text
3916 .LCF0:
3917         addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
3918     esac
3919
3920     gcc_GAS_CHECK_FEATURE([rel16 relocs],
3921       gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
3922       [$conftest_s],,
3923       [AC_DEFINE(HAVE_AS_REL16, 1,
3924           [Define if your assembler supports R_PPC_REL16 relocs.])])
3925
3926     case $target in
3927       *-*-aix*) conftest_s='    .machine "pwr6"
3928         .csect .text[[PR]]
3929         cmpb 3,4,5';;
3930       *) conftest_s='   .machine power6
3931         .text
3932         cmpb 3,4,5';;
3933     esac
3934
3935     gcc_GAS_CHECK_FEATURE([compare bytes support],
3936       gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
3937       [$conftest_s],,
3938       [AC_DEFINE(HAVE_AS_CMPB, 1,
3939           [Define if your assembler supports cmpb.])])
3940
3941     case $target in
3942       *-*-aix*) conftest_s='    .machine "pwr6"
3943         .csect .text[[PR]]
3944         dadd 1,2,3';;
3945       *) conftest_s='   .machine power6
3946         .text
3947         dadd 1,2,3';;
3948     esac
3949
3950     gcc_GAS_CHECK_FEATURE([decimal float support],
3951       gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
3952       [$conftest_s],,
3953       [AC_DEFINE(HAVE_AS_DFP, 1,
3954           [Define if your assembler supports DFP instructions.])])
3955
3956     case $target in
3957       *-*-aix*) conftest_s='    .machine "pwr7"
3958         .csect .text[[PR]]
3959         lxvd2x 1,2,3';;
3960       *) conftest_s='   .machine power7
3961         .text
3962         lxvd2x 1,2,3';;
3963     esac
3964
3965     gcc_GAS_CHECK_FEATURE([vector-scalar support],
3966       gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
3967       [$conftest_s],,
3968       [AC_DEFINE(HAVE_AS_VSX, 1,
3969           [Define if your assembler supports VSX instructions.])])
3970
3971     case $target in
3972       *-*-aix*) conftest_s='    .machine "pwr7"
3973         .csect .text[[PR]]
3974         popcntd 3,3';;
3975       *) conftest_s='   .machine power7
3976         .text
3977         popcntd 3,3';;
3978     esac
3979
3980     gcc_GAS_CHECK_FEATURE([popcntd support],
3981       gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
3982       [$conftest_s],,
3983       [AC_DEFINE(HAVE_AS_POPCNTD, 1,
3984           [Define if your assembler supports POPCNTD instructions.])])
3985
3986     case $target in
3987       *-*-aix*) conftest_s='    .machine "pwr8"
3988         .csect .text[[PR]]';;
3989       *) conftest_s='   .machine power8
3990         .text';;
3991     esac
3992
3993     gcc_GAS_CHECK_FEATURE([power8 support],
3994       gcc_cv_as_powerpc_power8, [2,19,2], -a32,
3995       [$conftest_s],,
3996       [AC_DEFINE(HAVE_AS_POWER8, 1,
3997           [Define if your assembler supports POWER8 instructions.])])
3998
3999     case $target in
4000       *-*-aix*) conftest_s='    .csect .text[[PR]]
4001         lwsync';;
4002       *) conftest_s='   .text
4003         lwsync';;
4004     esac
4005
4006     gcc_GAS_CHECK_FEATURE([lwsync support],
4007       gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
4008       [$conftest_s],,
4009       [AC_DEFINE(HAVE_AS_LWSYNC, 1,
4010           [Define if your assembler supports LWSYNC instructions.])])
4011
4012     case $target in
4013       *-*-aix*) conftest_s='    .machine "476"
4014         .csect .text[[PR]]
4015         dci 0';;
4016       *) conftest_s='   .machine "476"
4017         .text
4018         dci 0';;
4019     esac
4020
4021     gcc_GAS_CHECK_FEATURE([data cache invalidate support],
4022       gcc_cv_as_powerpc_dci, [9,99,0], -a32,
4023       [$conftest_s],,
4024       [AC_DEFINE(HAVE_AS_DCI, 1,
4025           [Define if your assembler supports the DCI/ICI instructions.])])
4026
4027     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4028       gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
4029       [.gnu_attribute 4,1],,
4030       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4031           [Define if your assembler supports .gnu_attribute.])])
4032
4033     gcc_GAS_CHECK_FEATURE([tls marker support],
4034       gcc_cv_as_powerpc_tls_markers, [2,20,0],,
4035       [ bl __tls_get_addr(x@tlsgd)],,
4036       [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
4037           [Define if your assembler supports arg info for __tls_get_addr.])])
4038
4039     case $target in
4040       *-*-aix*)
4041         gcc_GAS_CHECK_FEATURE([.ref support],
4042           gcc_cv_as_aix_ref, [2,21,0],,
4043           [     .csect stuff[[rw]]
4044              stuff:
4045                 .long 1
4046                 .extern sym
4047                 .ref sym
4048           ],,
4049           [AC_DEFINE(HAVE_AS_REF, 1,
4050             [Define if your assembler supports .ref])])
4051         ;;
4052     esac
4053     ;;
4054
4055   mips*-*-*)
4056     gcc_GAS_CHECK_FEATURE([explicit relocation support],
4057       gcc_cv_as_mips_explicit_relocs, [2,14,0],,
4058 [       lw $4,%gp_rel(foo)($4)],,
4059       [if test x$target_cpu_default = x
4060        then target_cpu_default=MASK_EXPLICIT_RELOCS
4061        else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
4062        fi])
4063     gcc_GAS_CHECK_FEATURE([-mno-shared support],
4064       gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
4065       [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
4066                  [Define if the assembler understands -mno-shared.])])
4067
4068     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4069       gcc_cv_as_mips_gnu_attribute, [2,18,0],,
4070       [.gnu_attribute 4,1],,
4071       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4072           [Define if your assembler supports .gnu_attribute.])])
4073
4074     gcc_GAS_CHECK_FEATURE([.micromips support],
4075       gcc_cv_as_micromips_support,,[--fatal-warnings],
4076       [.set micromips],,
4077       [AC_DEFINE(HAVE_GAS_MICROMIPS, 1,
4078           [Define if your assembler supports the .set micromips directive])])
4079
4080     gcc_GAS_CHECK_FEATURE([.dtprelword support],
4081       gcc_cv_as_mips_dtprelword, [2,18,0],,
4082       [.section .tdata,"awT",@progbits
4083 x:
4084         .word 2
4085         .text
4086         .dtprelword x+0x8000],,
4087       [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
4088           [Define if your assembler supports .dtprelword.])])
4089
4090     gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
4091       gcc_cv_as_mips_dspr1_mult,,,
4092 [       .set    mips32r2
4093         .set    nodspr2
4094         .set    dsp
4095         madd    $ac3,$4,$5
4096         maddu   $ac3,$4,$5
4097         msub    $ac3,$4,$5
4098         msubu   $ac3,$4,$5
4099         mult    $ac3,$4,$5
4100         multu   $ac3,$4,$5],,
4101       [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
4102           [Define if your assembler supports DSPR1 mult.])])
4103
4104     AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
4105     gcc_cv_as_ld_jalr_reloc=no
4106     if test $gcc_cv_as_mips_explicit_relocs = yes; then
4107       if test $in_tree_ld = yes ; then
4108         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 \
4109            && test $in_tree_ld_is_elf = yes; then
4110           gcc_cv_as_ld_jalr_reloc=yes
4111         fi
4112       elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
4113         echo '  .ent x' > conftest.s
4114         echo 'x:        ld $2,%got_disp(y)($3)' >> conftest.s
4115         echo '  ld $25,%call16(y)($28)' >> conftest.s
4116         echo '  .reloc  1f,R_MIPS_JALR,y' >> conftest.s
4117         echo '1:        jalr $25' >> conftest.s
4118         echo '  .reloc  1f,R_MIPS_JALR,x' >> conftest.s
4119         echo '1:        jalr $25' >> conftest.s
4120         echo '  .end x' >> conftest.s
4121         if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
4122            && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
4123           if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
4124              && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
4125             gcc_cv_as_ld_jalr_reloc=yes
4126           fi
4127         fi
4128         rm -f conftest.*
4129       fi
4130     fi
4131     if test $gcc_cv_as_ld_jalr_reloc = yes; then
4132       if test x$target_cpu_default = x; then
4133         target_cpu_default=MASK_RELAX_PIC_CALLS
4134       else
4135         target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
4136       fi
4137     fi
4138     AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
4139
4140     AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
4141       [gcc_cv_ld_mips_personality_relaxation],
4142       [gcc_cv_ld_mips_personality_relaxation=no
4143        if test $in_tree_ld = yes ; then
4144          if test "$gcc_cv_gld_major_version" -eq 2 \
4145                  -a "$gcc_cv_gld_minor_version" -ge 21 \
4146                  -o "$gcc_cv_gld_major_version" -gt 2; then
4147            gcc_cv_ld_mips_personality_relaxation=yes
4148          fi
4149        elif test x$gcc_cv_as != x \
4150                  -a x$gcc_cv_ld != x \
4151                  -a x$gcc_cv_readelf != x ; then
4152          cat > conftest.s <<EOF
4153         .cfi_startproc
4154         .cfi_personality 0x80,indirect_ptr
4155         .ent test
4156 test:
4157         nop
4158         .end test
4159         .cfi_endproc
4160
4161         .section .data,"aw",@progbits
4162 indirect_ptr:
4163         .dc.a personality
4164 EOF
4165          if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
4166             && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
4167            if $gcc_cv_readelf -d conftest 2>&1 \
4168               | grep TEXTREL > /dev/null 2>&1; then
4169              :
4170            elif $gcc_cv_readelf --relocs conftest 2>&1 \
4171                 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
4172              :
4173            else
4174              gcc_cv_ld_mips_personality_relaxation=yes
4175            fi
4176          fi
4177        fi
4178        rm -f conftest.s conftest.o conftest])
4179     if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
4180             AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
4181       [Define if your linker can relax absolute .eh_frame personality
4182 pointers into PC-relative form.])
4183     fi
4184
4185     gcc_GAS_CHECK_FEATURE([-mnan= support],
4186       gcc_cv_as_mips_nan,,
4187       [-mnan=2008],,,
4188       [AC_DEFINE(HAVE_AS_NAN, 1,
4189                  [Define if the assembler understands -mnan=.])])
4190     if test x$gcc_cv_as_mips_nan = xno \
4191        && test x$with_nan != x; then
4192       AC_MSG_ERROR(
4193         [Requesting --with-nan= requires assembler support for -mnan=])
4194     fi
4195     ;;
4196 esac
4197
4198 # Mips and HP-UX need the GNU assembler.
4199 # Linux on IA64 might be able to use the Intel assembler.
4200
4201 case "$target" in
4202   mips*-*-* | *-*-hpux* )
4203     if test x$gas_flag = xyes \
4204        || test x"$host" != x"$build" \
4205        || test ! -x "$gcc_cv_as" \
4206        || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
4207       :
4208     else
4209       echo "*** This configuration requires the GNU assembler" >&2
4210       exit 1
4211     fi
4212     ;;
4213 esac
4214
4215 # ??? Not all targets support dwarf2 debug_line, even within a version
4216 # of gas.  Moreover, we need to emit a valid instruction to trigger any
4217 # info to the output file.  So, as supported targets are added to gas 2.11,
4218 # add some instruction here to (also) show we expect this might work.
4219 # ??? Once 2.11 is released, probably need to add first known working
4220 # version to the per-target configury.
4221 case "$cpu_type" in
4222   aarch64 | alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze \
4223   | mips | pa | rs6000 | score | sparc | spu | tilegx | tilepro | xstormy16 \
4224   | xtensa)
4225     insn="nop"
4226     ;;
4227   ia64 | s390)
4228     insn="nop 0"
4229     ;;
4230   mmix)
4231     insn="swym 0"
4232     ;;
4233 esac
4234 if test x"$insn" != x; then
4235  conftest_s="\
4236         .file 1 \"conftest.s\"
4237         .loc 1 3 0
4238         $insn"
4239  gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
4240   gcc_cv_as_dwarf2_debug_line,
4241   [elf,2,11,0],, [$conftest_s],
4242   [if test x$gcc_cv_objdump != x \
4243    && $gcc_cv_objdump -h conftest.o 2> /dev/null \
4244       | grep debug_line > /dev/null 2>&1; then
4245      gcc_cv_as_dwarf2_debug_line=yes
4246    fi])
4247
4248 # The .debug_line file table must be in the exact order that
4249 # we specified the files, since these indices are also used
4250 # by DW_AT_decl_file.  Approximate this test by testing if
4251 # the assembler bitches if the same index is assigned twice.
4252  gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
4253   gcc_cv_as_dwarf2_file_buggy,,,
4254 [       .file 1 "foo.s"
4255         .file 1 "bar.s"])
4256
4257  if test $gcc_cv_as_dwarf2_debug_line = yes \
4258  && test $gcc_cv_as_dwarf2_file_buggy = no; then
4259         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
4260   [Define if your assembler supports dwarf2 .file/.loc directives,
4261    and preserves file table indices exactly as given.])
4262  fi
4263
4264  gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
4265   gcc_cv_as_gdwarf2_flag,
4266   [elf,2,11,0], [--gdwarf2], [$insn],,
4267   [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
4268 [Define if your assembler supports the --gdwarf2 option.])])
4269
4270  gcc_GAS_CHECK_FEATURE([--gstabs option],
4271   gcc_cv_as_gstabs_flag,
4272   [elf,2,11,0], [--gstabs], [$insn],
4273   [# The native Solaris 9/Intel assembler doesn't understand --gstabs
4274    # and warns about it, but still exits successfully.  So check for
4275    # this.
4276    if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
4277    then :
4278    else gcc_cv_as_gstabs_flag=yes
4279    fi],
4280   [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
4281 [Define if your assembler supports the --gstabs option.])])
4282
4283  gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
4284   gcc_cv_as_debug_prefix_map_flag,
4285   [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
4286   [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
4287 [Define if your assembler supports the --debug-prefix-map option.])])
4288 fi
4289
4290 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
4291  ,,
4292 [.lcomm bar,4,16],,
4293 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
4294   [Define if your assembler supports .lcomm with an alignment field.])])
4295
4296 AC_ARG_ENABLE(gnu-unique-object,
4297  [AS_HELP_STRING([--enable-gnu-unique-object],
4298    [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
4299  [case $enable_gnu_unique_object in
4300     yes | no) ;;
4301     *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
4302 Valid choices are 'yes' and 'no'.]) ;;
4303   esac],
4304  [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
4305    [elf,2,19,52],,
4306    [.type foo, '$target_type_format_char'gnu_unique_object],,
4307 # We need to unquote above to to use the definition from config.gcc.
4308 # Also check for ld.so support, i.e. glibc 2.11 or higher.
4309    [[if test x$host = x$build -a x$host = x$target &&
4310        ldd --version 2>/dev/null &&
4311        glibcver=`ldd --version 2>/dev/null | sed 's/.* //;q'`; then
4312       glibcmajor=`expr "$glibcver" : "\([0-9]*\)"`
4313       glibcminor=`expr "$glibcver" : "[2-9]*\.\([0-9]*\)"`
4314       glibcnum=`expr $glibcmajor \* 1000 + $glibcminor`
4315       if test "$glibcnum" -ge 2011 ; then
4316         enable_gnu_unique_object=yes
4317       fi
4318     fi]])])
4319 if test x$enable_gnu_unique_object = xyes; then
4320   AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
4321    [Define if your assembler supports @gnu_unique_object.])
4322 fi
4323
4324 AC_CACHE_CHECK([assembler for tolerance to line number 0],
4325  [gcc_cv_as_line_zero],
4326  [gcc_cv_as_line_zero=no
4327   if test $in_tree_gas = yes; then
4328     gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
4329   elif test "x$gcc_cv_as" != x; then
4330     { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
4331     if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
4332        test "x`cat conftest.out`" = x
4333     then
4334       gcc_cv_as_line_zero=yes
4335     else
4336       echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
4337       cat conftest.s >&AS_MESSAGE_LOG_FD
4338       echo "configure: error output was" >&AS_MESSAGE_LOG_FD
4339       cat conftest.out >&AS_MESSAGE_LOG_FD
4340     fi
4341     rm -f conftest.o conftest.s conftest.out
4342   fi])
4343 if test "x$gcc_cv_as_line_zero" = xyes; then
4344   AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
4345 [Define if the assembler won't complain about a line such as # 0 "" 2.])
4346 fi
4347
4348 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
4349 gcc_cv_ld_eh_frame_hdr=no
4350 if test $in_tree_ld = yes ; then
4351   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 \
4352      && test $in_tree_ld_is_elf = yes; then
4353     gcc_cv_ld_eh_frame_hdr=yes
4354   fi
4355 elif test x$gcc_cv_ld != x; then
4356   if echo "$ld_ver" | grep GNU > /dev/null; then
4357     # Check if linker supports --eh-frame-hdr option
4358     if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
4359       gcc_cv_ld_eh_frame_hdr=yes
4360     fi
4361   else
4362     case "$target" in
4363       *-*-solaris2*)
4364         # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
4365         if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
4366           gcc_cv_ld_eh_frame_hdr=yes
4367         fi
4368         ;;
4369     esac
4370   fi
4371 fi
4372 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
4373 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
4374         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
4375 [Define if your linker supports .eh_frame_hdr.])
4376 fi
4377 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
4378
4379 AC_MSG_CHECKING(linker CIEv3 in .eh_frame support)
4380 gcc_cv_ld_eh_frame_ciev3=no
4381 if test $in_tree_ld = yes ; then
4382   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 \
4383      && test $in_tree_ld_is_elf = yes; then
4384     gcc_cv_ld_eh_frame_ciev3=yes
4385   fi
4386 elif test x$gcc_cv_ld != x; then
4387   if echo "$ld_ver" | grep GNU > /dev/null; then
4388     gcc_cv_ld_eh_frame_ciev3=yes
4389     if test 0"$ld_date" -lt 20040513; then
4390       if test -n "$ld_date"; then
4391         # If there was date string, but was earlier than 2004-05-13, fail
4392         gcc_cv_ld_eh_frame_ciev3=no
4393       elif test "$ld_vers_major" -lt 2; then
4394         gcc_cv_ld_eh_frame_ciev3=no
4395       elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
4396         gcc_cv_ld_eh_frame_ciev3=no
4397       fi
4398     fi
4399   else
4400     case "$target" in
4401       *-*-solaris2*)
4402         # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1.
4403         if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then
4404           gcc_cv_ld_eh_frame_ciev3=yes
4405         fi
4406         ;;
4407     esac
4408   fi
4409 fi
4410 AC_DEFINE_UNQUOTED(HAVE_LD_EH_FRAME_CIEV3,
4411   [`if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi`],
4412   [Define 0/1 if your linker supports CIE v3 in .eh_frame.])
4413 AC_MSG_RESULT($gcc_cv_ld_eh_frame_ciev3)
4414
4415 AC_MSG_CHECKING(linker position independent executable support)
4416 gcc_cv_ld_pie=no
4417 if test $in_tree_ld = yes ; then
4418   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 \
4419      && test $in_tree_ld_is_elf = yes; then
4420     gcc_cv_ld_pie=yes
4421   fi
4422 elif test x$gcc_cv_ld != x; then
4423         # Check if linker supports -pie option
4424         if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
4425                 gcc_cv_ld_pie=yes
4426         fi
4427 fi
4428 if test x"$gcc_cv_ld_pie" = xyes; then
4429         AC_DEFINE(HAVE_LD_PIE, 1,
4430 [Define if your linker supports -pie option.])
4431 fi
4432 AC_MSG_RESULT($gcc_cv_ld_pie)
4433
4434 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
4435 gcc_cv_ld_eh_gc_sections=no
4436 if test $in_tree_ld = yes ; then
4437   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 \
4438      && test $in_tree_ld_is_elf = yes; then
4439     gcc_cv_ld_eh_gc_sections=yes
4440   fi
4441 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
4442   cat > conftest.s <<EOF
4443         .section        .text
4444 .globl _start
4445         .type _start, @function
4446 _start:
4447         .long foo
4448         .size _start, .-_start
4449         .section        .text.foo,"ax",@progbits
4450         .type foo, @function
4451 foo:
4452         .long 0
4453         .size foo, .-foo
4454         .section        .gcc_except_table.foo,"a",@progbits
4455 .L0:
4456         .long 0
4457         .section        .eh_frame,"a",@progbits
4458         .long .L0
4459 EOF
4460   if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4461     if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4462          | grep "gc-sections option ignored" > /dev/null; then
4463       gcc_cv_ld_eh_gc_sections=no
4464     elif $gcc_cv_objdump -h conftest 2> /dev/null \
4465          | grep gcc_except_table > /dev/null; then
4466       gcc_cv_ld_eh_gc_sections=yes
4467       # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
4468       if test x$gcc_cv_as_comdat_group != xyes; then
4469         gcc_cv_ld_eh_gc_sections=no
4470         cat > conftest.s <<EOF
4471         .section        .text
4472 .globl _start
4473         .type _start, @function
4474 _start:
4475         .long foo
4476         .size _start, .-_start
4477         .section        .gnu.linkonce.t.foo,"ax",@progbits
4478         .type foo, @function
4479 foo:
4480         .long 0
4481         .size foo, .-foo
4482         .section        .gcc_except_table.foo,"a",@progbits
4483 .L0:
4484         .long 0
4485         .section        .eh_frame,"a",@progbits
4486         .long .L0
4487 EOF
4488         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4489           if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4490                | grep "gc-sections option ignored" > /dev/null; then
4491             gcc_cv_ld_eh_gc_sections=no
4492           elif $gcc_cv_objdump -h conftest 2> /dev/null \
4493                | grep gcc_except_table > /dev/null; then
4494             gcc_cv_ld_eh_gc_sections=yes
4495           fi
4496         fi
4497       fi
4498     fi
4499   fi
4500   rm -f conftest.s conftest.o conftest
4501 fi
4502 case "$target" in
4503   hppa*-*-linux*)
4504     # ??? This apparently exposes a binutils bug with PC-relative relocations.
4505     gcc_cv_ld_eh_gc_sections=no
4506     ;;
4507 esac
4508 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
4509         AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
4510   [Define if your linker supports garbage collection of
4511    sections in presence of EH frames.])
4512 fi
4513 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
4514
4515 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
4516 gcc_cv_ld_eh_gc_sections_bug=no
4517 if test $in_tree_ld = yes ; then
4518   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -lt 19 -o "$gcc_cv_gld_major_version" -lt 2 \
4519      && test $in_tree_ld_is_elf = yes; then
4520     gcc_cv_ld_eh_gc_sections_bug=yes
4521   fi
4522 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
4523   gcc_cv_ld_eh_gc_sections_bug=yes
4524   cat > conftest.s <<EOF
4525         .section        .text
4526 .globl _start
4527         .type _start, @function
4528 _start:
4529         .long foo
4530         .size _start, .-_start
4531         .section        .text.startup.foo,"ax",@progbits
4532         .type foo, @function
4533 foo:
4534         .long 0
4535         .size foo, .-foo
4536         .section        .gcc_except_table.foo,"a",@progbits
4537 .L0:
4538         .long 0
4539         .section        .eh_frame,"a",@progbits
4540         .long .L0
4541 EOF
4542   if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4543     if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4544          | grep "gc-sections option ignored" > /dev/null; then
4545       :
4546     elif $gcc_cv_objdump -h conftest 2> /dev/null \
4547          | grep gcc_except_table > /dev/null; then
4548       gcc_cv_ld_eh_gc_sections_bug=no
4549     fi
4550   fi
4551   rm -f conftest.s conftest.o conftest
4552 fi
4553 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
4554         AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
4555   [Define if your linker has buggy garbage collection of
4556    sections support when .text.startup.foo like sections are used.])
4557 fi
4558 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
4559
4560 # --------
4561 # UNSORTED
4562 # --------
4563
4564 AC_CACHE_CHECK(linker --as-needed support,
4565 gcc_cv_ld_as_needed,
4566 [gcc_cv_ld_as_needed=no
4567 gcc_cv_ld_as_needed_option='--as-needed'
4568 gcc_cv_ld_no_as_needed_option='--no-as-needed'
4569 if test $in_tree_ld = yes ; then
4570   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 \
4571      && test $in_tree_ld_is_elf = yes; then
4572     gcc_cv_ld_as_needed=yes
4573   fi
4574 elif test x$gcc_cv_ld != x; then
4575         # Check if linker supports --as-needed and --no-as-needed options
4576         if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
4577                 gcc_cv_ld_as_needed=yes
4578         else
4579           case "$target" in
4580             # Solaris 2 ld always supports -z ignore/-z record.
4581             *-*-solaris2*)
4582               gcc_cv_ld_as_needed=yes
4583               gcc_cv_ld_as_needed_option="-z ignore"
4584               gcc_cv_ld_no_as_needed_option="-z record"
4585               ;;
4586           esac
4587         fi
4588 fi
4589 # --as-needed/-z ignore can only be used if libgcc_s.so.1 uses
4590 # dl_iterate_phdr, i.e. since Solaris 11.
4591 case "$target" in
4592   *-*-solaris2.1[[1-9]]*)
4593     case "$target" in
4594     i?86-*-* | x86_64-*-*)
4595       if echo "$ld_ver" | grep GNU > /dev/null; then
4596         # Doesn't work with gld on Solaris/x86 due to PR ld/12320.
4597         gcc_cv_ld_as_needed=no
4598       fi
4599       ;;
4600     esac
4601     ;;
4602   *-*-solaris2*)
4603     gcc_cv_ld_as_needed=no
4604     ;;
4605 esac
4606 ])
4607 if test x"$gcc_cv_ld_as_needed" = xyes; then
4608         AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
4609 [Define if your linker supports --as-needed/--no-as-needed or equivalent options.])
4610         AC_DEFINE_UNQUOTED(LD_AS_NEEDED_OPTION, "$gcc_cv_ld_as_needed_option",
4611 [Define to the linker option to ignore unused dependencies.])
4612         AC_DEFINE_UNQUOTED(LD_NO_AS_NEEDED_OPTION, "$gcc_cv_ld_no_as_needed_option",
4613 [Define to the linker option to keep unused dependencies.])
4614 fi
4615
4616 case "$target:$tm_file" in
4617   powerpc64-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
4618   case "$target" in
4619      *le-*-linux*)
4620      emul_name="-melf64lppc"
4621       ;;
4622      *-*-linux*)
4623      emul_name="-melf64ppc"
4624       ;;
4625      *-*-freebsd*)
4626      emul_name="-melf64ppc_fbsd"
4627       ;;
4628   esac
4629     AC_CACHE_CHECK(linker support for omitting dot symbols,
4630     gcc_cv_ld_no_dot_syms,
4631     [gcc_cv_ld_no_dot_syms=no
4632     if test x"$ld_is_gold" = xyes; then
4633       gcc_cv_ld_no_dot_syms=yes
4634     elif test $in_tree_ld = yes ; then
4635       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
4636         gcc_cv_ld_no_dot_syms=yes
4637       fi
4638     elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4639       cat > conftest1.s <<EOF
4640         .text
4641         bl .foo
4642 EOF
4643       cat > conftest2.s <<EOF
4644         .section ".opd","aw"
4645         .align 3
4646         .globl foo
4647         .type foo,@function
4648 foo:
4649         .quad .LEfoo,.TOC.@tocbase,0
4650         .text
4651 .LEfoo:
4652         blr
4653         .size foo,.-.LEfoo
4654 EOF
4655       if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4656          && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4657          && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
4658         gcc_cv_ld_no_dot_syms=yes
4659       fi
4660       rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
4661     fi
4662     ])
4663     if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
4664       AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
4665     [Define if your PowerPC64 linker only needs function descriptor syms.])
4666     fi
4667
4668     AC_CACHE_CHECK(linker large toc support,
4669     gcc_cv_ld_large_toc,
4670     [gcc_cv_ld_large_toc=no
4671     if test x"$ld_is_gold" = xyes; then
4672       gcc_cv_ld_large_toc=yes
4673     elif test $in_tree_ld = yes ; then
4674       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
4675         gcc_cv_ld_large_toc=yes
4676       fi
4677     elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4678       cat > conftest.s <<EOF
4679         .section ".tbss","awT",@nobits
4680         .align 3
4681 ie0:    .space 8
4682         .global _start
4683         .text
4684 _start:
4685         addis 9,13,ie0@got@tprel@ha
4686         ld 9,ie0@got@tprel@l(9)
4687 EOF
4688       if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
4689          && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
4690         gcc_cv_ld_large_toc=yes
4691       fi
4692       rm -f conftest conftest.o conftest.s
4693     fi
4694     ])
4695     if test x"$gcc_cv_ld_large_toc" = xyes; then
4696       AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4697     [Define if your PowerPC64 linker supports a large TOC.])
4698     fi
4699     ;;
4700 esac
4701
4702 case "$target" in
4703   *-*-aix*)
4704     AC_CACHE_CHECK(linker large toc support,
4705     gcc_cv_ld_large_toc,
4706     [gcc_cv_ld_large_toc=no
4707     if test x$gcc_cv_as != x ; then
4708       cat > conftest.s <<EOF
4709         .toc
4710 LC..1:
4711         .tc a[[TC]],a[[RW]]
4712         .extern a[[RW]]
4713         .csect .text[[PR]]
4714 .largetoctest:
4715         addis 9,LC..1@u(2)
4716         ld 3,LC..1@l(9)
4717 EOF
4718       if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1; then
4719         gcc_cv_ld_large_toc=yes
4720       fi
4721       rm -f conftest conftest.o conftest.s
4722     fi
4723     ])
4724     if test x"$gcc_cv_ld_large_toc" = xyes; then
4725       AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4726     [Define if your PowerPC64 linker supports a large TOC.])
4727     fi
4728     ;;
4729 esac
4730
4731 AC_CACHE_CHECK(linker --build-id support,
4732   gcc_cv_ld_buildid,
4733   [gcc_cv_ld_buildid=no
4734   if test $in_tree_ld = yes ; then
4735     if test "$gcc_cv_gld_major_version" -eq 2 -a \
4736        "$gcc_cv_gld_minor_version" -ge 18 -o \
4737        "$gcc_cv_gld_major_version" -gt 2 \
4738        && test $in_tree_ld_is_elf = yes; then
4739       gcc_cv_ld_buildid=yes
4740     fi
4741   elif test x$gcc_cv_ld != x; then
4742     if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
4743       gcc_cv_ld_buildid=yes
4744     fi
4745   fi])
4746 if test x"$gcc_cv_ld_buildid" = xyes; then
4747   AC_DEFINE(HAVE_LD_BUILDID, 1,
4748   [Define if your linker supports --build-id.])
4749 fi
4750
4751 AC_ARG_ENABLE(linker-build-id,
4752 [AS_HELP_STRING([--enable-linker-build-id],
4753                 [compiler will always pass --build-id to linker])],
4754 [],
4755 enable_linker_build_id=no)
4756
4757 if test x"$enable_linker_build_id" = xyes; then
4758   if test x"$gcc_cv_ld_buildid" = xyes; then
4759     AC_DEFINE(ENABLE_LD_BUILDID, 1,
4760     [Define if gcc should always pass --build-id to linker.])
4761   else
4762     AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
4763   fi
4764 fi
4765
4766 # In binutils 2.21, GNU ld gained support for new emulations fully
4767 # supporting the Solaris 2 ABI.  Detect their presence in the linker used.
4768 AC_CACHE_CHECK(linker *_sol2 emulation support,
4769   gcc_cv_ld_sol2_emulation,
4770   [gcc_cv_ld_sol2_emulation=no
4771   if test $in_tree_ld = yes ; then
4772     if test "$gcc_cv_gld_major_version" -eq 2 -a \
4773        "$gcc_cv_gld_minor_version" -ge 21 -o \
4774        "$gcc_cv_gld_major_version" -gt 2 \
4775        && test $in_tree_ld_is_elf = yes; then
4776       gcc_cv_ld_sol2_emulation=yes
4777     fi
4778   elif test x$gcc_cv_ld != x; then
4779     if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
4780        grep _sol2 > /dev/null; then
4781       gcc_cv_ld_sol2_emulation=yes
4782     fi
4783   fi])
4784 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
4785   AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
4786   [Define if your linker supports the *_sol2 emulations.])
4787 fi
4788
4789 AC_CACHE_CHECK(linker --sysroot support,
4790   gcc_cv_ld_sysroot,
4791   [gcc_cv_ld_sysroot=no
4792   if test $in_tree_ld = yes ; then
4793       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
4794         gcc_cv_ld_sysroot=yes
4795       fi
4796   elif test x$gcc_cv_ld != x; then
4797     if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
4798       gcc_cv_ld_sysroot=yes
4799     fi
4800   fi])
4801 if test x"$gcc_cv_ld_sysroot" = xyes; then
4802   AC_DEFINE(HAVE_LD_SYSROOT, 1,
4803   [Define if your linker supports --sysroot.])
4804 fi
4805
4806 if test x$with_sysroot = x && test x$host = x$target \
4807    && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4808    && test "$prefix" != "NONE"; then
4809   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4810 [Define to PREFIX/include if cpp should also search that directory.])
4811 fi
4812
4813 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4814   if test "x$with_headers" != x; then
4815     target_header_dir=$with_headers
4816   elif test "x$with_sysroot" = x; then
4817     target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include"
4818   elif test "x$with_build_sysroot" != "x"; then
4819     target_header_dir="${with_build_sysroot}${native_system_header_dir}"
4820   elif test "x$with_sysroot" = xyes; then
4821     target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
4822   else
4823     target_header_dir="${with_sysroot}${native_system_header_dir}"
4824   fi
4825 else
4826   target_header_dir=${native_system_header_dir}
4827 fi
4828
4829 # Test for stack protector support in target C library.
4830 AC_CACHE_CHECK(__stack_chk_fail in target C library,
4831       gcc_cv_libc_provides_ssp,
4832       [gcc_cv_libc_provides_ssp=no
4833     case "$target" in
4834        *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
4835       [# glibc 2.4 and later provides __stack_chk_fail and
4836       # either __stack_chk_guard, or TLS access to stack guard canary.
4837       if test -f $target_header_dir/features.h \
4838          && $EGREP '^[  ]*#[    ]*define[       ]+__GNU_LIBRARY__[      ]+([1-9][0-9]|[6-9])' \
4839             $target_header_dir/features.h > /dev/null; then
4840         if $EGREP '^[   ]*#[    ]*define[       ]+__GLIBC__[    ]+([1-9][0-9]|[3-9])' \
4841            $target_header_dir/features.h > /dev/null; then
4842           gcc_cv_libc_provides_ssp=yes
4843         elif $EGREP '^[         ]*#[    ]*define[       ]+__GLIBC__[    ]+2' \
4844              $target_header_dir/features.h > /dev/null \
4845              && $EGREP '^[      ]*#[    ]*define[       ]+__GLIBC_MINOR__[      ]+([1-9][0-9]|[4-9])' \
4846              $target_header_dir/features.h > /dev/null; then
4847           gcc_cv_libc_provides_ssp=yes
4848         elif $EGREP '^[         ]*#[    ]*define[       ]+__UCLIBC__[   ]+1' \
4849              $target_header_dir/features.h > /dev/null && \
4850              test -f $target_header_dir/bits/uClibc_config.h && \
4851              $EGREP '^[         ]*#[    ]*define[       ]+__UCLIBC_HAS_SSP__[   ]+1' \
4852              $target_header_dir/bits/uClibc_config.h > /dev/null; then
4853           gcc_cv_libc_provides_ssp=yes
4854         fi
4855       # all versions of Bionic support stack protector
4856       elif test -f $target_header_dir/sys/cdefs.h \
4857         && $EGREP '^[  ]*#[    ]*define[       ]+__BIONIC__[   ]+1' \
4858            $target_header_dir/sys/cdefs.h > /dev/null; then
4859          gcc_cv_libc_provides_ssp=yes
4860       fi]
4861         ;;
4862        *-*-gnu*)
4863          # Avoid complicated tests (see
4864          # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
4865          # simply assert that glibc does provide this, which is true for all
4866          # realistically usable GNU/Hurd configurations.
4867          gcc_cv_libc_provides_ssp=yes;;
4868        *-*-darwin* | *-*-freebsd*)
4869          AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
4870            [echo "no __stack_chk_fail on this target"])
4871         ;;
4872   *) gcc_cv_libc_provides_ssp=no ;;
4873     esac])
4874
4875 if test x$gcc_cv_libc_provides_ssp = xyes; then
4876   AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
4877             [Define if your target C library provides stack protector support])
4878 fi
4879
4880 # Test for <sys/sdt.h> on the target.
4881 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
4882 AC_MSG_CHECKING(sys/sdt.h in the target C library)
4883 have_sys_sdt_h=no
4884 if test -f $target_header_dir/sys/sdt.h; then
4885   have_sys_sdt_h=yes
4886   AC_DEFINE(HAVE_SYS_SDT_H, 1,
4887             [Define if your target C library provides sys/sdt.h])
4888 fi
4889 AC_MSG_RESULT($have_sys_sdt_h)
4890
4891 # Check if TFmode long double should be used by default or not.
4892 # Some glibc targets used DFmode long double, but with glibc 2.4
4893 # and later they can use TFmode.
4894 case "$target" in
4895   powerpc*-*-linux* | \
4896   sparc*-*-linux* | \
4897   s390*-*-linux* | \
4898   alpha*-*-linux*)
4899     AC_ARG_WITH(long-double-128,
4900       [AS_HELP_STRING([--with-long-double-128],
4901                       [use 128-bit long double by default])],
4902       gcc_cv_target_ldbl128="$with_long_double_128",
4903       [[gcc_cv_target_ldbl128=no
4904       grep '^[  ]*#[    ]*define[       ][      ]*__LONG_DOUBLE_MATH_OPTIONAL' \
4905         $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
4906       && gcc_cv_target_ldbl128=yes
4907       ]])
4908     ;;
4909 esac
4910 if test x$gcc_cv_target_ldbl128 = xyes; then
4911   AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
4912             [Define if TFmode long double should be the default])
4913 fi
4914
4915 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
4916 gcc_cv_target_dl_iterate_phdr=unknown
4917 case "$target" in
4918   # Restrict to Solaris 11+.  While most of the Solaris 11 linker changes
4919   # were backported to Solaris 10 Update 10, dl_iterate_phdr only lives in
4920   # libdl there, both complicating its use and breaking compatibility
4921   # between Solaris 10 updates.
4922   *-*-solaris2.1[[1-9]]*)
4923     # <link.h> needs both a dl_iterate_phdr declaration and support for
4924     # compilation with largefile support.
4925     if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
4926       && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
4927       gcc_cv_target_dl_iterate_phdr=yes
4928     else
4929       gcc_cv_target_dl_iterate_phdr=no
4930     fi
4931     ;;
4932 esac
4933 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
4934 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
4935    AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
4936 [Define if your target C library provides the `dl_iterate_phdr' function.])
4937 fi
4938 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
4939
4940 # We no longer support different GC mechanisms.  Emit an error if
4941 # the user configures with --with-gc.
4942 AC_ARG_WITH(gc,
4943 [AS_HELP_STRING([--with-gc={page,zone}],
4944                 [this option is not supported anymore.  It used to choose
4945                  the garbage collection mechanism to use with the compiler])],
4946 [AC_MSG_ERROR([Configure option --with-gc is only supported up to GCC 4.7.x])],
4947 [])
4948
4949 # Libraries to use on the host.  This will normally be set by the top
4950 # level Makefile.  Here we simply capture the value for our Makefile.
4951 if test -z "${HOST_LIBS+set}"; then
4952   HOST_LIBS=
4953 fi
4954 AC_SUBST(HOST_LIBS)
4955
4956 # Use the system's zlib library.
4957 zlibdir=-L../zlib
4958 zlibinc="-I\$(srcdir)/../zlib"
4959 AC_ARG_WITH(system-zlib,
4960 [AS_HELP_STRING([--with-system-zlib], [use installed libz])],
4961 zlibdir=
4962 zlibinc=
4963 )
4964 AC_SUBST(zlibdir)
4965 AC_SUBST(zlibinc)
4966
4967 dnl Very limited version of automake's enable-maintainer-mode
4968
4969 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
4970   dnl maintainer-mode is disabled by default
4971   AC_ARG_ENABLE(maintainer-mode,
4972 [AS_HELP_STRING([--enable-maintainer-mode],
4973                 [enable make rules and dependencies not useful
4974                  (and sometimes confusing) to the casual installer])],
4975       maintainer_mode=$enableval,
4976       maintainer_mode=no)
4977
4978 AC_MSG_RESULT($maintainer_mode)
4979
4980 if test "$maintainer_mode" = "yes"; then
4981   MAINT=''
4982 else
4983   MAINT='#'
4984 fi
4985 AC_SUBST(MAINT)dnl
4986
4987 dnl Whether to prevent multiple front-ends from linking at the same time
4988
4989 AC_MSG_CHECKING([whether to avoid linking multiple front-ends at once])
4990   AC_ARG_ENABLE(link-mutex,
4991 [AS_HELP_STRING([--enable-link-mutex],
4992                 [avoid linking multiple front-ends at once to avoid thrashing
4993                  on the build machine])],
4994       do_link_mutex=$enableval,
4995       do_link_mutex=no)
4996 AC_MSG_RESULT($do_link_mutex)
4997
4998 if test "$do_link_mutex" = "yes"; then
4999    DO_LINK_MUTEX=true
5000 else
5001    DO_LINK_MUTEX=false
5002 fi
5003 AC_SUBST(DO_LINK_MUTEX)
5004
5005 # --------------
5006 # Language hooks
5007 # --------------
5008
5009 # Make empty files to contain the specs and options for each language.
5010 # Then add #include lines to for a compiler that has specs and/or options.
5011
5012 subdirs=
5013 lang_opt_files=
5014 lang_specs_files=
5015 lang_tree_files=
5016 # These (without "all_") are set in each config-lang.in.
5017 # `language' must be a single word so is spelled singularly.
5018 all_languages=
5019 all_compilers=
5020 all_outputs='Makefile'
5021 # List of language makefile fragments.
5022 all_lang_makefrags=
5023 # Additional files for gengtype
5024 all_gtfiles="$target_gtfiles"
5025
5026 # These are the languages that are set in --enable-languages,
5027 # and are available in the GCC tree.
5028 all_selected_languages=
5029
5030 # Add the language fragments.
5031 # Languages are added via two mechanisms.  Some information must be
5032 # recorded in makefile variables, these are defined in config-lang.in.
5033 # We accumulate them and plug them into the main Makefile.
5034 # The other mechanism is a set of hooks for each of the main targets
5035 # like `clean', `install', etc.
5036
5037 language_hooks="Make-hooks"
5038
5039 for lang in ${srcdir}/*/config-lang.in
5040 do
5041 changequote(,)dnl
5042         test "$lang" = "${srcdir}/*/config-lang.in" && continue
5043
5044         lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
5045         if test "x$lang_alias" = x
5046         then
5047               echo "$lang doesn't set \$language." 1>&2
5048               exit 1
5049         fi
5050         subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
5051         subdirs="$subdirs $subdir"
5052
5053         # $gcc_subdir is where the gcc integration files are to be found
5054         # for a language, both for internal compiler purposes (compiler
5055         # sources implementing front-end to GCC tree converters), and for
5056         # build infrastructure purposes (Make-lang.in, etc.)
5057         #
5058         # This will be <subdir> (relative to $srcdir) if a line like
5059         # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
5060         # is found in <langdir>/config-lang.in, and will remain <langdir>
5061         # otherwise.
5062         #
5063         # Except for the language alias (fetched above), the regular
5064         # "config-lang.in" contents are always retrieved from $gcc_subdir,
5065         # so a <langdir>/config-lang.in setting gcc_subdir typically sets
5066         # only this and the language alias.
5067
5068         gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^   ]*\).*$,\1,p' $lang`
5069         if [ "$gcc_subdir" = "" ]; then
5070            gcc_subdir="$subdir"
5071         fi
5072
5073         case ",$enable_languages," in
5074         *,$lang_alias,*)
5075             all_selected_languages="$all_selected_languages $lang_alias"
5076             if test -f $srcdir/$gcc_subdir/lang-specs.h; then
5077                 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
5078             fi
5079             ;;
5080         esac
5081 changequote([,])dnl
5082
5083         language=
5084         boot_language=
5085         compilers=
5086         outputs=
5087         gtfiles=
5088         subdir_requires=
5089         . ${srcdir}/$gcc_subdir/config-lang.in
5090         if test "x$language" = x
5091         then
5092                 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
5093                 exit 1
5094         fi
5095
5096         ok=:
5097         case ",$enable_languages," in
5098                 *,$lang_alias,*) ;;
5099                 *)
5100                         for i in $subdir_requires; do
5101                                 test -f "${srcdir}/$i/config-lang.in" && continue
5102                                 ok=false
5103                                 break
5104                         done
5105                 ;;
5106         esac
5107         $ok || continue
5108
5109         all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
5110         if test -f $srcdir/$gcc_subdir/lang.opt; then
5111             lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
5112             all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
5113         fi
5114         if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
5115             lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
5116         fi
5117         all_languages="$all_languages $language"
5118         all_compilers="$all_compilers $compilers"
5119         all_outputs="$all_outputs $outputs"
5120         all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
5121         case ",$enable_languages," in
5122                 *,lto,*)
5123                     AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
5124                     enable_lto=yes
5125                     AC_SUBST(enable_lto)
5126                     ;;
5127                 *) ;;
5128         esac
5129 done
5130
5131 check_languages=
5132 for language in $all_selected_languages
5133 do
5134         check_languages="$check_languages check-$language"
5135 done
5136
5137 # We link each language in with a set of hooks, reached indirectly via
5138 # lang.${target}.  Only do so for selected languages.
5139
5140 rm -f Make-hooks
5141 touch Make-hooks
5142 target_list="all.cross start.encap rest.encap tags \
5143         install-common install-man install-info install-pdf install-html dvi \
5144         pdf html uninstall info man srcextra srcman srcinfo \
5145         mostlyclean clean distclean maintainer-clean install-plugin"
5146
5147 for t in $target_list
5148 do
5149         x=
5150         for lang in $all_selected_languages
5151         do
5152                 x="$x $lang.$t"
5153         done
5154         echo "lang.$t: $x" >> Make-hooks
5155 done
5156
5157 # --------
5158 # Option include files
5159 # --------
5160
5161 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
5162 option_includes="option-includes.mk"
5163 AC_SUBST_FILE(option_includes)
5164
5165 # --------
5166 # UNSORTED
5167 # --------
5168
5169 # Create .gdbinit.
5170
5171 echo "dir ." > .gdbinit
5172 echo "dir ${srcdir}" >> .gdbinit
5173 if test x$gdb_needs_out_file_path = xyes
5174 then
5175         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
5176 fi
5177 if test "x$subdirs" != x; then
5178         for s in $subdirs
5179         do
5180                 echo "dir ${srcdir}/$s" >> .gdbinit
5181         done
5182 fi
5183 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
5184 echo "python import sys; sys.path.append('${srcdir}'); import gdbhooks" >> .gdbinit
5185
5186 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
5187 AC_SUBST(gcc_tooldir)
5188 AC_SUBST(dollar)
5189
5190 # Find a directory in which to install a shared libgcc.
5191
5192 AC_ARG_ENABLE(version-specific-runtime-libs,
5193 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
5194                 [specify that runtime libraries should be
5195                  installed in a compiler-specific directory])])
5196
5197 # Substitute configuration variables
5198 AC_SUBST(subdirs)
5199 AC_SUBST(srcdir)
5200 AC_SUBST(all_compilers)
5201 AC_SUBST(all_gtfiles)
5202 AC_SUBST(all_lang_makefrags)
5203 AC_SUBST(all_languages)
5204 AC_SUBST(all_selected_languages)
5205 AC_SUBST(build_exeext)
5206 AC_SUBST(build_install_headers_dir)
5207 AC_SUBST(build_xm_file_list)
5208 AC_SUBST(build_xm_include_list)
5209 AC_SUBST(build_xm_defines)
5210 AC_SUBST(build_file_translate)
5211 AC_SUBST(check_languages)
5212 AC_SUBST(cpp_install_dir)
5213 AC_SUBST(xmake_file)
5214 AC_SUBST(tmake_file)
5215 AC_SUBST(TM_ENDIAN_CONFIG)
5216 AC_SUBST(TM_MULTILIB_CONFIG)
5217 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
5218 AC_SUBST(extra_gcc_objs)
5219 AC_SUBST(user_headers_inc_next_pre)
5220 AC_SUBST(user_headers_inc_next_post)
5221 AC_SUBST(extra_headers_list)
5222 AC_SUBST(extra_objs)
5223 AC_SUBST(extra_programs)
5224 AC_SUBST(float_h_file)
5225 AC_SUBST(gcc_config_arguments)
5226 AC_SUBST(gcc_gxx_include_dir)
5227 AC_SUBST(gcc_gxx_include_dir_add_sysroot)
5228 AC_SUBST(host_exeext)
5229 AC_SUBST(host_xm_file_list)
5230 AC_SUBST(host_xm_include_list)
5231 AC_SUBST(host_xm_defines)
5232 AC_SUBST(out_host_hook_obj)
5233 AC_SUBST(install)
5234 AC_SUBST(lang_opt_files)
5235 AC_SUBST(lang_specs_files)
5236 AC_SUBST(lang_tree_files)
5237 AC_SUBST(local_prefix)
5238 AC_SUBST(md_file)
5239 AC_SUBST(objc_boehm_gc)
5240 AC_SUBST(out_file)
5241 AC_SUBST(out_object_file)
5242 AC_SUBST(common_out_file)
5243 AC_SUBST(common_out_object_file)
5244 AC_SUBST(tm_file_list)
5245 AC_SUBST(tm_include_list)
5246 AC_SUBST(tm_defines)
5247 AC_SUBST(tm_p_file_list)
5248 AC_SUBST(tm_p_include_list)
5249 AC_SUBST(xm_file_list)
5250 AC_SUBST(xm_include_list)
5251 AC_SUBST(xm_defines)
5252 AC_SUBST(use_gcc_stdint)
5253 AC_SUBST(c_target_objs)
5254 AC_SUBST(cxx_target_objs)
5255 AC_SUBST(fortran_target_objs)
5256 AC_SUBST(target_cpu_default)
5257
5258 AC_SUBST_FILE(language_hooks)
5259
5260 # Echo link setup.
5261 if test x${build} = x${host} ; then
5262   if test x${host} = x${target} ; then
5263     echo "Links are now set up to build a native compiler for ${target}." 1>&2
5264   else
5265     echo "Links are now set up to build a cross-compiler" 1>&2
5266     echo " from ${host} to ${target}." 1>&2
5267   fi
5268 else
5269   if test x${host} = x${target} ; then
5270     echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
5271     echo " for ${target}." 1>&2
5272   else
5273     echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
5274     echo " from ${host} to ${target}." 1>&2
5275   fi
5276 fi
5277
5278 AC_ARG_VAR(GMPLIBS,[How to link GMP])
5279 AC_ARG_VAR(GMPINC,[How to find GMP include files])
5280
5281 AC_ARG_VAR(ISLLIBS,[How to link ISL])
5282 AC_ARG_VAR(ISLINC,[How to find ISL include files])
5283
5284 AC_ARG_VAR(CLOOGLIBS,[How to link CLOOG])
5285 AC_ARG_VAR(CLOOGINC,[How to find CLOOG include files])
5286 if test "x${CLOOGLIBS}" != "x" ; then
5287    AC_DEFINE(HAVE_cloog, 1, [Define if cloog is in use.])
5288 fi
5289
5290 # Check for plugin support
5291 AC_ARG_ENABLE(plugin,
5292 [AS_HELP_STRING([--enable-plugin], [enable plugin support])],
5293 enable_plugin=$enableval,
5294 enable_plugin=yes; default_plugin=yes)
5295
5296 pluginlibs=
5297
5298 case "${host}" in
5299   *-*-darwin*)
5300     if test x$build = x$host; then
5301       export_sym_check="nm${exeext} -g"
5302     elif test x$host = x$target; then
5303       export_sym_check="$gcc_cv_nm -g"
5304     else
5305       export_sym_check=
5306     fi
5307   ;;
5308   *)
5309     if test x$build = x$host; then
5310       export_sym_check="objdump${exeext} -T"
5311     elif test x$host = x$target; then
5312       export_sym_check="$gcc_cv_objdump -T"
5313     else
5314       export_sym_check=
5315     fi
5316   ;;
5317 esac
5318
5319 if test x"$enable_plugin" = x"yes"; then
5320
5321   AC_MSG_CHECKING([for exported symbols])
5322   if test "x$export_sym_check" != x; then
5323     echo "int main() {return 0;} int foobar() {return 0;}" > conftest.c
5324     ${CC} ${CFLAGS} ${LDFLAGS} conftest.c -o conftest > /dev/null 2>&1
5325     if $export_sym_check conftest | grep foobar > /dev/null; then
5326       : # No need to use a flag
5327       AC_MSG_RESULT([yes])
5328     else
5329       AC_MSG_RESULT([yes])
5330       AC_MSG_CHECKING([for -rdynamic])
5331       ${CC} ${CFLAGS} ${LDFLAGS} -rdynamic conftest.c -o conftest > /dev/null 2>&1
5332       if $export_sym_check conftest | grep foobar > /dev/null; then
5333         plugin_rdynamic=yes
5334         pluginlibs="-rdynamic"
5335       else
5336         plugin_rdynamic=no
5337         enable_plugin=no
5338       fi
5339       AC_MSG_RESULT([$plugin_rdynamic])
5340     fi
5341   else
5342     AC_MSG_RESULT([unable to check])
5343   fi
5344
5345   # Check -ldl
5346   saved_LIBS="$LIBS"
5347   AC_SEARCH_LIBS([dlopen], [dl])
5348   if test x"$ac_cv_search_dlopen" = x"-ldl"; then
5349     pluginlibs="$pluginlibs -ldl"
5350   fi
5351   LIBS="$saved_LIBS"
5352
5353   # Check that we can build shared objects with -fPIC -shared
5354   saved_LDFLAGS="$LDFLAGS"
5355   saved_CFLAGS="$CFLAGS"
5356   case "${host}" in
5357     *-*-darwin*)
5358       CFLAGS=`echo $CFLAGS | sed s/-mdynamic-no-pic//g`
5359       CFLAGS="$CFLAGS -fPIC"
5360       LDFLAGS="$LDFLAGS -shared -undefined dynamic_lookup"
5361     ;;
5362     *)
5363       CFLAGS="$CFLAGS -fPIC"
5364       LDFLAGS="$LDFLAGS -fPIC -shared"
5365     ;;
5366   esac
5367   AC_MSG_CHECKING([for -fPIC -shared])
5368   AC_TRY_LINK(
5369     [extern int X;],[return X == 0;],
5370     [AC_MSG_RESULT([yes]); have_pic_shared=yes],
5371     [AC_MSG_RESULT([no]); have_pic_shared=no])
5372   if test x"$have_pic_shared" != x"yes" -o x"$ac_cv_search_dlopen" = x"no"; then
5373     pluginlibs=
5374     enable_plugin=no
5375   fi
5376   LDFLAGS="$saved_LDFLAGS"
5377   CFLAGS="$saved_CFLAGS"
5378
5379   # If plugin support had been requested but not available, fail.
5380   if test x"$enable_plugin" = x"no" ; then
5381     if test x"$default_plugin" != x"yes"; then
5382       AC_MSG_ERROR([
5383 Building GCC with plugin support requires a host that supports
5384 -fPIC, -shared, -ldl and -rdynamic.])
5385     fi
5386   fi
5387 fi
5388
5389 AC_SUBST(pluginlibs)
5390 AC_SUBST(enable_plugin)
5391 if test x"$enable_plugin" = x"yes"; then
5392   AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
5393 fi
5394
5395
5396 AC_ARG_ENABLE(libquadmath-support,
5397 [AS_HELP_STRING([--disable-libquadmath-support],
5398   [disable libquadmath support for Fortran])],
5399 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
5400 ENABLE_LIBQUADMATH_SUPPORT=yes)
5401 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
5402   AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
5403             [Define to 1 to enable libquadmath support])
5404 fi
5405
5406
5407 # Specify what hash style to use by default.
5408 AC_ARG_WITH([linker-hash-style],
5409 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
5410                 [specify the linker hash style])],
5411 [case x"$withval" in
5412    xsysv)
5413      LINKER_HASH_STYLE=sysv
5414      ;;
5415    xgnu)
5416      LINKER_HASH_STYLE=gnu
5417      ;;
5418    xboth)
5419      LINKER_HASH_STYLE=both
5420      ;;
5421    *)
5422      AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
5423      ;;
5424  esac],
5425 [LINKER_HASH_STYLE=''])
5426 if test x"${LINKER_HASH_STYLE}" != x; then
5427   AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
5428                                          [The linker hash style])
5429 fi
5430
5431 # Configure the subdirectories
5432 # AC_CONFIG_SUBDIRS($subdirs)
5433
5434 # Create the Makefile
5435 # and configure language subdirectories
5436 AC_CONFIG_FILES($all_outputs)
5437
5438 AC_CONFIG_COMMANDS([default],
5439 [
5440 case ${CONFIG_HEADERS} in
5441   *auto-host.h:config.in*)
5442   echo > cstamp-h ;;
5443 esac
5444 # Make sure all the subdirs exist.
5445 for d in $subdirs doc build common c-family
5446 do
5447     test -d $d || mkdir $d
5448 done
5449 ],
5450 [subdirs='$subdirs'])
5451 AC_OUTPUT
5452