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