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