gcc/configure.ac

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