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