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