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