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