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