gcc/configure.ac

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