gcc/configure.ac

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