gcc/configure.ac

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