gcc/configure.ac

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