gcc/configure.ac

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