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