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, 2012 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         [if test x$gcc_cv_ld != x \
3679          && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3680            gcc_cv_as_ix86_tlsgdplt=yes
3681          fi
3682          rm -f conftest],
3683       [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
3684         [Define if your assembler and linker support @tlsgdplt.])])
3685
3686     gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
3687         gcc_cv_as_ix86_tlsldmplt,,,
3688         [call    tls_ld@tlsldmplt],
3689         [if test x$gcc_cv_ld != x \
3690          && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3691            gcc_cv_as_ix86_tlsldmplt=yes
3692          fi
3693          rm -f conftest],
3694       [AC_DEFINE(HAVE_AS_IX86_TLSLDMPLT, 1,
3695         [Define if your assembler and linker support @tlsldmplt.])])
3696
3697     ;;
3698
3699   ia64*-*-*)
3700     gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
3701         gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
3702 [       .text
3703         addl r15 = @ltoffx(x#), gp
3704         ;;
3705         ld8.mov r16 = [[r15]], x#],,
3706     [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
3707           [Define if your assembler supports ltoffx and ldxmov relocations.])])
3708
3709     ;;
3710
3711   powerpc*-*-*)
3712     case $target in
3713       *-*-aix*) conftest_s='    .machine "pwr5"
3714         .csect .text[[PR]]
3715         mfcr 3,128';;
3716       *-*-darwin*)
3717         gcc_GAS_CHECK_FEATURE([.machine directive support],
3718           gcc_cv_as_machine_directive,,,
3719           [     .machine ppc7400])
3720         if test x$gcc_cv_as_machine_directive != xyes; then
3721           echo "*** This target requires an assembler supporting \".machine\"" >&2
3722           echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
3723           test x$build = x$target && exit 1
3724         fi
3725         conftest_s='    .text
3726         mfcr r3,128';;
3727       *) conftest_s='   .machine power4
3728         .text
3729         mfcr 3,128';;
3730     esac
3731
3732     gcc_GAS_CHECK_FEATURE([mfcr field support],
3733       gcc_cv_as_powerpc_mfcrf, [2,14,0],,
3734       [$conftest_s],,
3735       [AC_DEFINE(HAVE_AS_MFCRF, 1,
3736           [Define if your assembler supports mfcr field.])])
3737
3738     case $target in
3739       *-*-aix*) conftest_s='    .machine "pwr5"
3740         .csect .text[[PR]]
3741         popcntb 3,3';;
3742       *) conftest_s='   .machine power5
3743         .text
3744         popcntb 3,3';;
3745     esac
3746
3747     gcc_GAS_CHECK_FEATURE([popcntb support],
3748       gcc_cv_as_powerpc_popcntb, [2,17,0],,
3749       [$conftest_s],,
3750       [AC_DEFINE(HAVE_AS_POPCNTB, 1,
3751           [Define if your assembler supports popcntb field.])])
3752
3753     case $target in
3754       *-*-aix*) conftest_s='    .machine "pwr5x"
3755         .csect .text[[PR]]
3756         frin 1,1';;
3757       *) conftest_s='   .machine power5
3758         .text
3759         frin 1,1';;
3760     esac
3761
3762     gcc_GAS_CHECK_FEATURE([fp round support],
3763       gcc_cv_as_powerpc_fprnd, [2,17,0],,
3764       [$conftest_s],,
3765       [AC_DEFINE(HAVE_AS_FPRND, 1,
3766           [Define if your assembler supports fprnd.])])
3767
3768     case $target in
3769       *-*-aix*) conftest_s='    .machine "pwr6"
3770         .csect .text[[PR]]
3771         mffgpr 1,3';;
3772       *) conftest_s='   .machine power6
3773         .text
3774         mffgpr 1,3';;
3775     esac
3776
3777     gcc_GAS_CHECK_FEATURE([move fp gpr support],
3778       gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
3779       [$conftest_s],,
3780       [AC_DEFINE(HAVE_AS_MFPGPR, 1,
3781           [Define if your assembler supports mffgpr and mftgpr.])])
3782
3783     case $target in
3784       *-*-aix*) conftest_s='    .csect .text[[PR]]
3785 LCF..0:
3786         addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
3787       *-*-darwin*)
3788         conftest_s='    .text
3789 LCF0:
3790         addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
3791       *) conftest_s='   .text
3792 .LCF0:
3793         addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
3794     esac
3795
3796     gcc_GAS_CHECK_FEATURE([rel16 relocs],
3797       gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
3798       [$conftest_s],,
3799       [AC_DEFINE(HAVE_AS_REL16, 1,
3800           [Define if your assembler supports R_PPC_REL16 relocs.])])
3801
3802     case $target in
3803       *-*-aix*) conftest_s='    .machine "pwr6"
3804         .csect .text[[PR]]
3805         cmpb 3,4,5';;
3806       *) conftest_s='   .machine power6
3807         .text
3808         cmpb 3,4,5';;
3809     esac
3810
3811     gcc_GAS_CHECK_FEATURE([compare bytes support],
3812       gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
3813       [$conftest_s],,
3814       [AC_DEFINE(HAVE_AS_CMPB, 1,
3815           [Define if your assembler supports cmpb.])])
3816
3817     case $target in
3818       *-*-aix*) conftest_s='    .machine "pwr6"
3819         .csect .text[[PR]]
3820         dadd 1,2,3';;
3821       *) conftest_s='   .machine power6
3822         .text
3823         dadd 1,2,3';;
3824     esac
3825
3826     gcc_GAS_CHECK_FEATURE([decimal float support],
3827       gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
3828       [$conftest_s],,
3829       [AC_DEFINE(HAVE_AS_DFP, 1,
3830           [Define if your assembler supports DFP instructions.])])
3831
3832     case $target in
3833       *-*-aix*) conftest_s='    .machine "pwr7"
3834         .csect .text[[PR]]
3835         lxvd2x 1,2,3';;
3836       *) conftest_s='   .machine power7
3837         .text
3838         lxvd2x 1,2,3';;
3839     esac
3840
3841     gcc_GAS_CHECK_FEATURE([vector-scalar support],
3842       gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
3843       [$conftest_s],,
3844       [AC_DEFINE(HAVE_AS_VSX, 1,
3845           [Define if your assembler supports VSX instructions.])])
3846
3847     case $target in
3848       *-*-aix*) conftest_s='    .machine "pwr7"
3849         .csect .text[[PR]]
3850         popcntd 3,3';;
3851       *) conftest_s='   .machine power7
3852         .text
3853         popcntd 3,3';;
3854     esac
3855
3856     gcc_GAS_CHECK_FEATURE([popcntd support],
3857       gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
3858       [$conftest_s],,
3859       [AC_DEFINE(HAVE_AS_POPCNTD, 1,
3860           [Define if your assembler supports POPCNTD instructions.])])
3861
3862     case $target in
3863       *-*-aix*) conftest_s='    .csect .text[[PR]]
3864         lwsync';;
3865       *) conftest_s='   .text
3866         lwsync';;
3867     esac
3868
3869     gcc_GAS_CHECK_FEATURE([lwsync support],
3870       gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
3871       [$conftest_s],,
3872       [AC_DEFINE(HAVE_AS_LWSYNC, 1,
3873           [Define if your assembler supports LWSYNC instructions.])])
3874
3875     case $target in
3876       *-*-aix*) conftest_s='    .machine "476"
3877         .csect .text[[PR]]
3878         dci 0';;
3879       *) conftest_s='   .machine "476"
3880         .text
3881         dci 0';;
3882     esac
3883
3884     gcc_GAS_CHECK_FEATURE([data cache invalidate support],
3885       gcc_cv_as_powerpc_dci, [9,99,0], -a32,
3886       [$conftest_s],,
3887       [AC_DEFINE(HAVE_AS_DCI, 1,
3888           [Define if your assembler supports the DCI/ICI instructions.])])
3889
3890     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3891       gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
3892       [.gnu_attribute 4,1],,
3893       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3894           [Define if your assembler supports .gnu_attribute.])])
3895
3896     gcc_GAS_CHECK_FEATURE([tls marker support],
3897       gcc_cv_as_powerpc_tls_markers, [2,20,0],,
3898       [ bl __tls_get_addr(x@tlsgd)],,
3899       [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
3900           [Define if your assembler supports arg info for __tls_get_addr.])])
3901
3902     case $target in
3903       *-*-aix*)
3904         gcc_GAS_CHECK_FEATURE([.ref support],
3905           gcc_cv_as_aix_ref, [2.21.0],,
3906           [     .csect stuff[[rw]]
3907              stuff:
3908                 .long 1
3909                 .extern sym
3910                 .ref sym
3911           ],,
3912           [AC_DEFINE(HAVE_AS_REF, 1,
3913             [Define if your assembler supports .ref])])
3914         ;;
3915     esac
3916     ;;
3917
3918   mips*-*-*)
3919     gcc_GAS_CHECK_FEATURE([explicit relocation support],
3920       gcc_cv_as_mips_explicit_relocs, [2,14,0],,
3921 [       lw $4,%gp_rel(foo)($4)],,
3922       [if test x$target_cpu_default = x
3923        then target_cpu_default=MASK_EXPLICIT_RELOCS
3924        else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
3925        fi])
3926     gcc_GAS_CHECK_FEATURE([-mno-shared support],
3927       gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
3928       [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
3929                  [Define if the assembler understands -mno-shared.])])
3930
3931     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3932       gcc_cv_as_mips_gnu_attribute, [2,18,0],,
3933       [.gnu_attribute 4,1],,
3934       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3935           [Define if your assembler supports .gnu_attribute.])])
3936
3937     gcc_GAS_CHECK_FEATURE([.dtprelword support],
3938       gcc_cv_as_mips_dtprelword, [2,18,0],,
3939       [.section .tdata,"awT",@progbits
3940 x:
3941         .word 2
3942         .text
3943         .dtprelword x+0x8000],,
3944       [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
3945           [Define if your assembler supports .dtprelword.])])
3946
3947     gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
3948       gcc_cv_as_mips_dspr1_mult,,,
3949 [       .set    mips32r2
3950         .set    nodspr2
3951         .set    dsp
3952         madd    $ac3,$4,$5
3953         maddu   $ac3,$4,$5
3954         msub    $ac3,$4,$5
3955         msubu   $ac3,$4,$5
3956         mult    $ac3,$4,$5
3957         multu   $ac3,$4,$5],,
3958       [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
3959           [Define if your assembler supports DSPR1 mult.])])
3960
3961     AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
3962     gcc_cv_as_ld_jalr_reloc=no
3963     if test $gcc_cv_as_mips_explicit_relocs = yes; then
3964       if test $in_tree_ld = yes ; then
3965         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 \
3966            && test $in_tree_ld_is_elf = yes; then
3967           gcc_cv_as_ld_jalr_reloc=yes
3968         fi
3969       elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
3970         echo '  .ent x' > conftest.s
3971         echo 'x:        ld $2,%got_disp(y)($3)' >> conftest.s
3972         echo '  ld $25,%call16(y)($28)' >> conftest.s
3973         echo '  .reloc  1f,R_MIPS_JALR,y' >> conftest.s
3974         echo '1:        jalr $25' >> conftest.s
3975         echo '  .reloc  1f,R_MIPS_JALR,x' >> conftest.s
3976         echo '1:        jalr $25' >> conftest.s
3977         echo '  .end x' >> conftest.s
3978         if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
3979            && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
3980           if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
3981              && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
3982             gcc_cv_as_ld_jalr_reloc=yes
3983           fi
3984         fi
3985         rm -f conftest.*
3986       fi
3987     fi
3988     if test $gcc_cv_as_ld_jalr_reloc = yes; then
3989       if test x$target_cpu_default = x; then
3990         target_cpu_default=MASK_RELAX_PIC_CALLS
3991       else
3992         target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
3993       fi
3994     fi
3995     AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
3996
3997     AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
3998       [gcc_cv_ld_mips_personality_relaxation],
3999       [gcc_cv_ld_mips_personality_relaxation=no
4000        if test $in_tree_ld = yes ; then
4001          if test "$gcc_cv_gld_major_version" -eq 2 \
4002                  -a "$gcc_cv_gld_minor_version" -ge 21 \
4003                  -o "$gcc_cv_gld_major_version" -gt 2; then
4004            gcc_cv_ld_mips_personality_relaxation=yes
4005          fi
4006        elif test x$gcc_cv_as != x \
4007                  -a x$gcc_cv_ld != x \
4008                  -a x$gcc_cv_readelf != x ; then
4009          cat > conftest.s <<EOF
4010         .cfi_startproc
4011         .cfi_personality 0x80,indirect_ptr
4012         .ent test
4013 test:
4014         nop
4015         .end test
4016         .cfi_endproc
4017
4018         .section .data,"aw",@progbits
4019 indirect_ptr:
4020         .dc.a personality
4021 EOF
4022          if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
4023             && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
4024            if $gcc_cv_readelf -d conftest 2>&1 \
4025               | grep TEXTREL > /dev/null 2>&1; then
4026              :
4027            elif $gcc_cv_readelf --relocs conftest 2>&1 \
4028                 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
4029              :
4030            else
4031              gcc_cv_ld_mips_personality_relaxation=yes
4032            fi
4033          fi
4034        fi
4035        rm -f conftest.s conftest.o conftest])
4036     if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
4037             AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
4038       [Define if your linker can relax absolute .eh_frame personality
4039 pointers into PC-relative form.])
4040     fi
4041     ;;
4042 esac
4043
4044 # Mips and HP-UX need the GNU assembler.
4045 # Linux on IA64 might be able to use the Intel assembler.
4046
4047 case "$target" in
4048   mips*-*-* | *-*-hpux* )
4049     if test x$gas_flag = xyes \
4050        || test x"$host" != x"$build" \
4051        || test ! -x "$gcc_cv_as" \
4052        || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
4053       :
4054     else
4055       echo "*** This configuration requires the GNU assembler" >&2
4056       exit 1
4057     fi
4058     ;;
4059 esac
4060
4061 # ??? Not all targets support dwarf2 debug_line, even within a version
4062 # of gas.  Moreover, we need to emit a valid instruction to trigger any
4063 # info to the output file.  So, as supported targets are added to gas 2.11,
4064 # add some instruction here to (also) show we expect this might work.
4065 # ??? Once 2.11 is released, probably need to add first known working
4066 # version to the per-target configury.
4067 case "$cpu_type" in
4068   alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze | mips \
4069   | pa | rs6000 | score | sparc | spu | xstormy16 | xtensa)
4070     insn="nop"
4071     ;;
4072   ia64 | s390)
4073     insn="nop 0"
4074     ;;
4075   mmix)
4076     insn="swym 0"
4077     ;;
4078 esac
4079 if test x"$insn" != x; then
4080  conftest_s="\
4081         .file 1 \"conftest.s\"
4082         .loc 1 3 0
4083         $insn"
4084  gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
4085   gcc_cv_as_dwarf2_debug_line,
4086   [elf,2,11,0],, [$conftest_s],
4087   [if test x$gcc_cv_objdump != x \
4088    && $gcc_cv_objdump -h conftest.o 2> /dev/null \
4089       | grep debug_line > /dev/null 2>&1; then
4090      gcc_cv_as_dwarf2_debug_line=yes
4091    fi])
4092
4093 # The .debug_line file table must be in the exact order that
4094 # we specified the files, since these indices are also used
4095 # by DW_AT_decl_file.  Approximate this test by testing if
4096 # the assembler bitches if the same index is assigned twice.
4097  gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
4098   gcc_cv_as_dwarf2_file_buggy,,,
4099 [       .file 1 "foo.s"
4100         .file 1 "bar.s"])
4101
4102  if test $gcc_cv_as_dwarf2_debug_line = yes \
4103  && test $gcc_cv_as_dwarf2_file_buggy = no; then
4104         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
4105   [Define if your assembler supports dwarf2 .file/.loc directives,
4106    and preserves file table indices exactly as given.])
4107  fi
4108
4109  gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
4110   gcc_cv_as_gdwarf2_flag,
4111   [elf,2,11,0], [--gdwarf2], [$insn],,
4112   [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
4113 [Define if your assembler supports the --gdwarf2 option.])])
4114
4115  gcc_GAS_CHECK_FEATURE([--gstabs option],
4116   gcc_cv_as_gstabs_flag,
4117   [elf,2,11,0], [--gstabs], [$insn],
4118   [# The native Solaris 9/Intel assembler doesn't understand --gstabs
4119    # and warns about it, but still exits successfully.  So check for
4120    # this.
4121    if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
4122    then :
4123    else gcc_cv_as_gstabs_flag=yes
4124    fi],
4125   [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
4126 [Define if your assembler supports the --gstabs option.])])
4127
4128  gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
4129   gcc_cv_as_debug_prefix_map_flag,
4130   [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
4131   [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
4132 [Define if your assembler supports the --debug-prefix-map option.])])
4133 fi
4134
4135 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
4136  ,,
4137 [.lcomm bar,4,16],,
4138 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
4139   [Define if your assembler supports .lcomm with an alignment field.])])
4140
4141 AC_ARG_ENABLE(gnu-unique-object,
4142  [AS_HELP_STRING([--enable-gnu-unique-object],
4143    [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
4144  [case $enable_gnu_unique_object in
4145     yes | no) ;;
4146     *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
4147 Valid choices are 'yes' and 'no'.]) ;;
4148   esac],
4149  [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
4150    [elf,2,19,52],,
4151    [.type foo, @gnu_unique_object],,
4152 # Also check for ld.so support, i.e. glibc 2.11 or higher.
4153    [[if test x$host = x$build -a x$host = x$target &&
4154        ldd --version 2>/dev/null &&
4155        glibcver=`ldd --version 2>/dev/null | sed 's/.* //;q'`; then
4156       glibcmajor=`expr "$glibcver" : "\([0-9]*\)"`
4157       glibcminor=`expr "$glibcver" : "[2-9]*\.\([0-9]*\)"`
4158       glibcnum=`expr $glibcmajor \* 1000 + $glibcminor`
4159       if test "$glibcnum" -ge 2011 ; then
4160         enable_gnu_unique_object=yes
4161       fi
4162     fi]])])
4163 if test x$enable_gnu_unique_object = xyes; then
4164   AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
4165    [Define if your assembler supports @gnu_unique_object.])
4166 fi
4167
4168 AC_CACHE_CHECK([assembler for tolerance to line number 0],
4169  [gcc_cv_as_line_zero],
4170  [gcc_cv_as_line_zero=no
4171   if test $in_tree_gas = yes; then
4172     gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
4173   elif test "x$gcc_cv_as" != x; then
4174     { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
4175     if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
4176        test "x`cat conftest.out`" = x
4177     then
4178       gcc_cv_as_line_zero=yes
4179     else
4180       echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
4181       cat conftest.s >&AS_MESSAGE_LOG_FD
4182       echo "configure: error output was" >&AS_MESSAGE_LOG_FD
4183       cat conftest.out >&AS_MESSAGE_LOG_FD
4184     fi
4185     rm -f conftest.o conftest.s conftest.out
4186   fi])
4187 if test "x$gcc_cv_as_line_zero" = xyes; then
4188   AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
4189 [Define if the assembler won't complain about a line such as # 0 "" 2.])
4190 fi
4191
4192 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
4193 gcc_cv_ld_eh_frame_hdr=no
4194 if test $in_tree_ld = yes ; then
4195   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 \
4196      && test $in_tree_ld_is_elf = yes; then
4197     gcc_cv_ld_eh_frame_hdr=yes
4198   fi
4199 elif test x$gcc_cv_ld != x; then
4200   if echo "$ld_ver" | grep GNU > /dev/null; then
4201     # Check if linker supports --eh-frame-hdr option
4202     if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
4203       gcc_cv_ld_eh_frame_hdr=yes
4204     fi
4205   else
4206     case "$target" in
4207       *-*-solaris2*)
4208         # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
4209         if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
4210           gcc_cv_ld_eh_frame_hdr=yes
4211         fi
4212         ;;
4213     esac
4214   fi
4215 fi
4216 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
4217 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
4218         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
4219 [Define if your linker supports .eh_frame_hdr.])
4220 fi
4221 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
4222
4223 AC_MSG_CHECKING(linker position independent executable support)
4224 gcc_cv_ld_pie=no
4225 if test $in_tree_ld = yes ; then
4226   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 \
4227      && test $in_tree_ld_is_elf = yes; then
4228     gcc_cv_ld_pie=yes
4229   fi
4230 elif test x$gcc_cv_ld != x; then
4231         # Check if linker supports -pie option
4232         if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
4233                 gcc_cv_ld_pie=yes
4234         fi
4235 fi
4236 if test x"$gcc_cv_ld_pie" = xyes; then
4237         AC_DEFINE(HAVE_LD_PIE, 1,
4238 [Define if your linker supports -pie option.])
4239 fi
4240 AC_MSG_RESULT($gcc_cv_ld_pie)
4241
4242 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
4243 gcc_cv_ld_eh_gc_sections=no
4244 if test $in_tree_ld = yes ; then
4245   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 \
4246      && test $in_tree_ld_is_elf = yes; then
4247     gcc_cv_ld_eh_gc_sections=yes
4248   fi
4249 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
4250   cat > conftest.s <<EOF
4251         .section        .text
4252 .globl _start
4253         .type _start, @function
4254 _start:
4255         .long foo
4256         .size _start, .-_start
4257         .section        .text.foo,"ax",@progbits
4258         .type foo, @function
4259 foo:
4260         .long 0
4261         .size foo, .-foo
4262         .section        .gcc_except_table.foo,"a",@progbits
4263 .L0:
4264         .long 0
4265         .section        .eh_frame,"a",@progbits
4266         .long .L0
4267 EOF
4268   if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4269     if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4270          | grep "gc-sections option ignored" > /dev/null; then
4271       gcc_cv_ld_eh_gc_sections=no
4272     elif $gcc_cv_objdump -h conftest 2> /dev/null \
4273          | grep gcc_except_table > /dev/null; then
4274       gcc_cv_ld_eh_gc_sections=yes
4275       # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
4276       if test x$gcc_cv_as_comdat_group != xyes; then
4277         gcc_cv_ld_eh_gc_sections=no
4278         cat > conftest.s <<EOF
4279         .section        .text
4280 .globl _start
4281         .type _start, @function
4282 _start:
4283         .long foo
4284         .size _start, .-_start
4285         .section        .gnu.linkonce.t.foo,"ax",@progbits
4286         .type foo, @function
4287 foo:
4288         .long 0
4289         .size foo, .-foo
4290         .section        .gcc_except_table.foo,"a",@progbits
4291 .L0:
4292         .long 0
4293         .section        .eh_frame,"a",@progbits
4294         .long .L0
4295 EOF
4296         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4297           if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4298                | grep "gc-sections option ignored" > /dev/null; then
4299             gcc_cv_ld_eh_gc_sections=no
4300           elif $gcc_cv_objdump -h conftest 2> /dev/null \
4301                | grep gcc_except_table > /dev/null; then
4302             gcc_cv_ld_eh_gc_sections=yes
4303           fi
4304         fi
4305       fi
4306     fi
4307   fi
4308   rm -f conftest.s conftest.o conftest
4309 fi
4310 case "$target" in
4311   hppa*-*-linux*)
4312     # ??? This apparently exposes a binutils bug with PC-relative relocations.
4313     gcc_cv_ld_eh_gc_sections=no
4314     ;;
4315 esac
4316 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
4317         AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
4318   [Define if your linker supports garbage collection of
4319    sections in presence of EH frames.])
4320 fi
4321 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
4322
4323 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
4324 gcc_cv_ld_eh_gc_sections_bug=no
4325 if test $in_tree_ld = yes ; then
4326   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 \
4327      && test $in_tree_ld_is_elf = yes; then
4328     gcc_cv_ld_eh_gc_sections_bug=yes
4329   fi
4330 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
4331   gcc_cv_ld_eh_gc_sections_bug=yes
4332   cat > conftest.s <<EOF
4333         .section        .text
4334 .globl _start
4335         .type _start, @function
4336 _start:
4337         .long foo
4338         .size _start, .-_start
4339         .section        .text.startup.foo,"ax",@progbits
4340         .type foo, @function
4341 foo:
4342         .long 0
4343         .size foo, .-foo
4344         .section        .gcc_except_table.foo,"a",@progbits
4345 .L0:
4346         .long 0
4347         .section        .eh_frame,"a",@progbits
4348         .long .L0
4349 EOF
4350   if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4351     if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4352          | grep "gc-sections option ignored" > /dev/null; then
4353       :
4354     elif $gcc_cv_objdump -h conftest 2> /dev/null \
4355          | grep gcc_except_table > /dev/null; then
4356       gcc_cv_ld_eh_gc_sections_bug=no
4357     fi
4358   fi
4359   rm -f conftest.s conftest.o conftest
4360 fi
4361 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
4362         AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
4363   [Define if your linker has buggy garbage collection of
4364    sections support when .text.startup.foo like sections are used.])
4365 fi
4366 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
4367
4368 # --------
4369 # UNSORTED
4370 # --------
4371
4372 AC_CACHE_CHECK(linker --as-needed support,
4373 gcc_cv_ld_as_needed,
4374 [gcc_cv_ld_as_needed=no
4375 if test $in_tree_ld = yes ; then
4376   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 \
4377      && test $in_tree_ld_is_elf = yes; then
4378     gcc_cv_ld_as_needed=yes
4379   fi
4380 elif test x$gcc_cv_ld != x; then
4381         # Check if linker supports --as-needed and --no-as-needed options
4382         if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
4383                 gcc_cv_ld_as_needed=yes
4384         fi
4385 fi
4386 ])
4387 if test x"$gcc_cv_ld_as_needed" = xyes; then
4388         AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
4389 [Define if your linker supports --as-needed and --no-as-needed options.])
4390 fi
4391
4392 case "$target:$tm_file" in
4393   powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
4394     AC_CACHE_CHECK(linker support for omitting dot symbols,
4395     gcc_cv_ld_no_dot_syms,
4396     [gcc_cv_ld_no_dot_syms=no
4397     if test $in_tree_ld = yes ; then
4398       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
4399         gcc_cv_ld_no_dot_syms=yes
4400       fi
4401     elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4402       cat > conftest1.s <<EOF
4403         .text
4404         bl .foo
4405 EOF
4406       cat > conftest2.s <<EOF
4407         .section ".opd","aw"
4408         .align 3
4409         .globl foo
4410         .type foo,@function
4411 foo:
4412         .quad .LEfoo,.TOC.@tocbase,0
4413         .text
4414 .LEfoo:
4415         blr
4416         .size foo,.-.LEfoo
4417 EOF
4418       if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4419          && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4420          && $gcc_cv_ld -melf64ppc -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
4421         gcc_cv_ld_no_dot_syms=yes
4422       fi
4423       rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
4424     fi
4425     ])
4426     if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
4427       AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
4428     [Define if your PowerPC64 linker only needs function descriptor syms.])
4429     fi
4430
4431     AC_CACHE_CHECK(linker large toc support,
4432     gcc_cv_ld_large_toc,
4433     [gcc_cv_ld_large_toc=no
4434     if test $in_tree_ld = yes ; then
4435       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
4436         gcc_cv_ld_large_toc=yes
4437       fi
4438     elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4439       cat > conftest.s <<EOF
4440         .section ".tbss","awT",@nobits
4441         .align 3
4442 ie0:    .space 8
4443         .global _start
4444         .text
4445 _start:
4446         addis 9,13,ie0@got@tprel@ha
4447         ld 9,ie0@got@tprel@l(9)
4448 EOF
4449       if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
4450          && $gcc_cv_ld -melf64ppc --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
4451         gcc_cv_ld_large_toc=yes
4452       fi
4453       rm -f conftest conftest.o conftest.s
4454     fi
4455     ])
4456     if test x"$gcc_cv_ld_large_toc" = xyes; then
4457       AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4458     [Define if your PowerPC64 linker supports a large TOC.])
4459     fi
4460     ;;
4461 esac
4462
4463 AC_CACHE_CHECK(linker --build-id support,
4464   gcc_cv_ld_buildid,
4465   [gcc_cv_ld_buildid=no
4466   if test $in_tree_ld = yes ; then
4467     if test "$gcc_cv_gld_major_version" -eq 2 -a \
4468        "$gcc_cv_gld_minor_version" -ge 18 -o \
4469        "$gcc_cv_gld_major_version" -gt 2 \
4470        && test $in_tree_ld_is_elf = yes; then
4471       gcc_cv_ld_buildid=yes
4472     fi
4473   elif test x$gcc_cv_ld != x; then
4474     if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
4475       gcc_cv_ld_buildid=yes
4476     fi
4477   fi])
4478 if test x"$gcc_cv_ld_buildid" = xyes; then
4479   AC_DEFINE(HAVE_LD_BUILDID, 1,
4480   [Define if your linker supports --build-id.])
4481 fi
4482
4483 AC_ARG_ENABLE(linker-build-id,
4484 [AS_HELP_STRING([--enable-linker-build-id],
4485                 [compiler will always pass --build-id to linker])],
4486 [],
4487 enable_linker_build_id=no)
4488
4489 if test x"$enable_linker_build_id" = xyes; then
4490   if test x"$gcc_cv_ld_buildid" = xyes; then
4491     AC_DEFINE(ENABLE_LD_BUILDID, 1,
4492     [Define if gcc should always pass --build-id to linker.])
4493   else
4494     AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
4495   fi
4496 fi
4497
4498 # In binutils 2.21, GNU ld gained support for new emulations fully
4499 # supporting the Solaris 2 ABI.  Detect their presence in the linker used.
4500 AC_CACHE_CHECK(linker *_sol2 emulation support,
4501   gcc_cv_ld_sol2_emulation,
4502   [gcc_cv_ld_sol2_emulation=no
4503   if test $in_tree_ld = yes ; then
4504     if test "$gcc_cv_gld_major_version" -eq 2 -a \
4505        "$gcc_cv_gld_minor_version" -ge 21 -o \
4506        "$gcc_cv_gld_major_version" -gt 2 \
4507        && test $in_tree_ld_is_elf = yes; then
4508       gcc_cv_ld_sol2_emulation=yes
4509     fi
4510   elif test x$gcc_cv_ld != x; then
4511     if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
4512        grep _sol2 > /dev/null; then
4513       gcc_cv_ld_sol2_emulation=yes
4514     fi
4515   fi])
4516 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
4517   AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
4518   [Define if your linker supports the *_sol2 emulations.])
4519 fi
4520
4521 AC_CACHE_CHECK(linker --sysroot support,
4522   gcc_cv_ld_sysroot,
4523   [gcc_cv_ld_sysroot=no
4524   if test $in_tree_ld = yes ; then
4525       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
4526         gcc_cv_ld_sysroot=yes
4527       fi
4528   elif test x$gcc_cv_ld != x; then
4529     if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
4530       gcc_cv_ld_sysroot=yes
4531     fi
4532   fi])
4533 if test x"$gcc_cv_ld_sysroot" = xyes; then
4534   AC_DEFINE(HAVE_LD_SYSROOT, 1,
4535   [Define if your linker supports --sysroot.])
4536 fi
4537
4538 if test x$with_sysroot = x && test x$host = x$target \
4539    && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4540    && test "$prefix" != "NONE"; then
4541   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4542 [Define to PREFIX/include if cpp should also search that directory.])
4543 fi
4544
4545 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4546   if test "x$with_headers" != x; then
4547     target_header_dir=$with_headers
4548   elif test "x$with_sysroot" = x; then
4549     target_header_dir="${exec_prefix}/${target_noncanonical}/sys-include"
4550   elif test "x$with_build_sysroot" != "x"; then
4551     target_header_dir="${with_build_sysroot}${native_system_header_dir}"
4552   elif test "x$with_sysroot" = xyes; then
4553     target_header_dir="${exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
4554   else
4555     target_header_dir="${with_sysroot}${native_system_header_dir}"
4556   fi
4557 else
4558   target_header_dir=${native_system_header_dir}
4559 fi
4560
4561 # Test for stack protector support in target C library.
4562 AC_CACHE_CHECK(__stack_chk_fail in target C library,
4563       gcc_cv_libc_provides_ssp,
4564       [gcc_cv_libc_provides_ssp=no
4565     case "$target" in
4566        *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
4567       [# glibc 2.4 and later provides __stack_chk_fail and
4568       # either __stack_chk_guard, or TLS access to stack guard canary.
4569       if test -f $target_header_dir/features.h \
4570          && $EGREP '^[  ]*#[    ]*define[       ]+__GNU_LIBRARY__[      ]+([1-9][0-9]|[6-9])' \
4571             $target_header_dir/features.h > /dev/null; then
4572         if $EGREP '^[   ]*#[    ]*define[       ]+__GLIBC__[    ]+([1-9][0-9]|[3-9])' \
4573            $target_header_dir/features.h > /dev/null; then
4574           gcc_cv_libc_provides_ssp=yes
4575         elif $EGREP '^[         ]*#[    ]*define[       ]+__GLIBC__[    ]+2' \
4576              $target_header_dir/features.h > /dev/null \
4577              && $EGREP '^[      ]*#[    ]*define[       ]+__GLIBC_MINOR__[      ]+([1-9][0-9]|[4-9])' \
4578              $target_header_dir/features.h > /dev/null; then
4579           gcc_cv_libc_provides_ssp=yes
4580         elif $EGREP '^[         ]*#[    ]*define[       ]+__UCLIBC__[   ]+1' \
4581              $target_header_dir/features.h > /dev/null && \
4582              test -f $target_header_dir/bits/uClibc_config.h && \
4583              $EGREP '^[         ]*#[    ]*define[       ]+__UCLIBC_HAS_SSP__[   ]+1' \
4584              $target_header_dir/bits/uClibc_config.h > /dev/null; then
4585           gcc_cv_libc_provides_ssp=yes
4586         fi
4587       fi]
4588         ;;
4589        *-*-gnu*)
4590          # Avoid complicated tests (see
4591          # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
4592          # simply assert that glibc does provide this, which is true for all
4593          # realistically usable GNU/Hurd configurations.
4594          gcc_cv_libc_provides_ssp=yes;;
4595        *-*-darwin* | *-*-freebsd*)
4596          AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
4597            [echo "no __stack_chk_fail on this target"])
4598         ;;
4599   *) gcc_cv_libc_provides_ssp=no ;;
4600     esac])
4601
4602 if test x$gcc_cv_libc_provides_ssp = xyes; then
4603   AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
4604             [Define if your target C library provides stack protector support])
4605 fi
4606
4607 # Test for <sys/sdt.h> on the target.
4608 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
4609 AC_MSG_CHECKING(sys/sdt.h in the target C library)
4610 have_sys_sdt_h=no
4611 if test -f $target_header_dir/sys/sdt.h; then
4612   have_sys_sdt_h=yes
4613   AC_DEFINE(HAVE_SYS_SDT_H, 1,
4614             [Define if your target C library provides sys/sdt.h])
4615 fi
4616 AC_MSG_RESULT($have_sys_sdt_h)
4617
4618 # Check if TFmode long double should be used by default or not.
4619 # Some glibc targets used DFmode long double, but with glibc 2.4
4620 # and later they can use TFmode.
4621 case "$target" in
4622   powerpc*-*-linux* | \
4623   sparc*-*-linux* | \
4624   s390*-*-linux* | \
4625   alpha*-*-linux*)
4626     AC_ARG_WITH(long-double-128,
4627       [AS_HELP_STRING([--with-long-double-128],
4628                       [use 128-bit long double by default])],
4629       gcc_cv_target_ldbl128="$with_long_double_128",
4630       [[gcc_cv_target_ldbl128=no
4631       grep '^[  ]*#[    ]*define[       ][      ]*__LONG_DOUBLE_MATH_OPTIONAL' \
4632         $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
4633       && gcc_cv_target_ldbl128=yes
4634       ]])
4635     ;;
4636 esac
4637 if test x$gcc_cv_target_ldbl128 = xyes; then
4638   AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
4639             [Define if TFmode long double should be the default])
4640 fi
4641
4642 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
4643 gcc_cv_target_dl_iterate_phdr=unknown
4644 case "$target" in
4645   *-*-solaris2*)
4646     # <link.h> needs both a dl_iterate_phdr declaration and support for
4647     # compilation with largefile support.
4648     if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
4649       && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
4650       gcc_cv_target_dl_iterate_phdr=yes
4651     else
4652       gcc_cv_target_dl_iterate_phdr=no
4653     fi
4654     ;;
4655 esac
4656 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
4657 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
4658    AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
4659 [Define if your target C library provides the `dl_iterate_phdr' function.])
4660 fi
4661 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
4662
4663 # Find out what GC implementation we want, or may, use.
4664 AC_ARG_WITH(gc,
4665 [AS_HELP_STRING([--with-gc={page,zone}],
4666                 [choose the garbage collection mechanism to use
4667                  with the compiler])],
4668 [case "$withval" in
4669   page)
4670     GGC=ggc-$withval
4671     ;;
4672   zone)
4673     GGC=ggc-$withval
4674     AC_DEFINE(GGC_ZONE, 1, [Define if the zone collector is in use])
4675     ;;
4676   *)
4677     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
4678     ;;
4679 esac],
4680 [GGC=ggc-page])
4681 AC_SUBST(GGC)
4682 echo "Using $GGC for garbage collection."
4683
4684 # Libraries to use on the host.  This will normally be set by the top
4685 # level Makefile.  Here we simply capture the value for our Makefile.
4686 if test -z "${HOST_LIBS+set}"; then
4687   HOST_LIBS=
4688 fi
4689 AC_SUBST(HOST_LIBS)
4690
4691 # Use the system's zlib library.
4692 zlibdir=-L../zlib
4693 zlibinc="-I\$(srcdir)/../zlib"
4694 AC_ARG_WITH(system-zlib,
4695 [AS_HELP_STRING([--with-system-zlib], [use installed libz])],
4696 zlibdir=
4697 zlibinc=
4698 )
4699 AC_SUBST(zlibdir)
4700 AC_SUBST(zlibinc)
4701
4702 dnl Very limited version of automake's enable-maintainer-mode
4703
4704 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
4705   dnl maintainer-mode is disabled by default
4706   AC_ARG_ENABLE(maintainer-mode,
4707 [AS_HELP_STRING([--enable-maintainer-mode],
4708                 [enable make rules and dependencies not useful
4709                  (and sometimes confusing) to the casual installer])],
4710       maintainer_mode=$enableval,
4711       maintainer_mode=no)
4712
4713 AC_MSG_RESULT($maintainer_mode)
4714
4715 if test "$maintainer_mode" = "yes"; then
4716   MAINT=''
4717 else
4718   MAINT='#'
4719 fi
4720 AC_SUBST(MAINT)dnl
4721
4722 # --------------
4723 # Language hooks
4724 # --------------
4725
4726 # Make empty files to contain the specs and options for each language.
4727 # Then add #include lines to for a compiler that has specs and/or options.
4728
4729 subdirs=
4730 lang_opt_files=
4731 lang_specs_files=
4732 lang_tree_files=
4733 # These (without "all_") are set in each config-lang.in.
4734 # `language' must be a single word so is spelled singularly.
4735 all_languages=
4736 all_compilers=
4737 all_outputs='Makefile'
4738 # List of language makefile fragments.
4739 all_lang_makefrags=
4740 # Additional files for gengtype
4741 all_gtfiles="$target_gtfiles"
4742
4743 # These are the languages that are set in --enable-languages,
4744 # and are available in the GCC tree.
4745 all_selected_languages=
4746
4747 # Add the language fragments.
4748 # Languages are added via two mechanisms.  Some information must be
4749 # recorded in makefile variables, these are defined in config-lang.in.
4750 # We accumulate them and plug them into the main Makefile.
4751 # The other mechanism is a set of hooks for each of the main targets
4752 # like `clean', `install', etc.
4753
4754 language_hooks="Make-hooks"
4755
4756 for lang in ${srcdir}/*/config-lang.in
4757 do
4758 changequote(,)dnl
4759         test "$lang" = "${srcdir}/*/config-lang.in" && continue
4760
4761         lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
4762         if test "x$lang_alias" = x
4763         then
4764               echo "$lang doesn't set \$language." 1>&2
4765               exit 1
4766         fi
4767         subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
4768         subdirs="$subdirs $subdir"
4769
4770         # $gcc_subdir is where the gcc integration files are to be found
4771         # for a language, both for internal compiler purposes (compiler
4772         # sources implementing front-end to GCC tree converters), and for
4773         # build infrastructure purposes (Make-lang.in, etc.)
4774         #
4775         # This will be <subdir> (relative to $srcdir) if a line like
4776         # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
4777         # is found in <langdir>/config-lang.in, and will remain <langdir>
4778         # otherwise.
4779         #
4780         # Except for the language alias (fetched above), the regular
4781         # "config-lang.in" contents are always retrieved from $gcc_subdir,
4782         # so a <langdir>/config-lang.in setting gcc_subdir typically sets
4783         # only this and the language alias.
4784
4785         gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^   ]*\).*$,\1,p' $lang`
4786         if [ "$gcc_subdir" = "" ]; then
4787            gcc_subdir="$subdir"
4788         fi
4789
4790         case ",$enable_languages," in
4791         *,$lang_alias,*)
4792             all_selected_languages="$all_selected_languages $lang_alias"
4793             if test -f $srcdir/$gcc_subdir/lang-specs.h; then
4794                 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
4795             fi
4796             ;;
4797         esac
4798 changequote([,])dnl
4799
4800         language=
4801         boot_language=
4802         compilers=
4803         outputs=
4804         gtfiles=
4805         subdir_requires=
4806         . ${srcdir}/$gcc_subdir/config-lang.in
4807         if test "x$language" = x
4808         then
4809                 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
4810                 exit 1
4811         fi
4812
4813         ok=:
4814         case ",$enable_languages," in
4815                 *,$lang_alias,*) ;;
4816                 *)
4817                         for i in $subdir_requires; do
4818                                 test -f "${srcdir}/$i/config-lang.in" && continue
4819                                 ok=false
4820                                 break
4821                         done
4822                 ;;
4823         esac
4824         $ok || continue
4825
4826         all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
4827         if test -f $srcdir/$gcc_subdir/lang.opt; then
4828             lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
4829             all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
4830         fi
4831         if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
4832             lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
4833         fi
4834         all_languages="$all_languages $language"
4835         all_compilers="$all_compilers $compilers"
4836         all_outputs="$all_outputs $outputs"
4837         all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
4838         case ",$enable_languages," in
4839                 *,lto,*)
4840                     AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
4841                     enable_lto=yes
4842                     AC_SUBST(enable_lto)
4843                     ;;
4844                 *) ;;
4845         esac
4846 done
4847
4848 # Pick up gtfiles for c
4849 gtfiles=
4850 . ${srcdir}/c-config-lang.in
4851 all_gtfiles="$all_gtfiles [[c]] $gtfiles"
4852
4853 check_languages=
4854 for language in $all_selected_languages
4855 do
4856         check_languages="$check_languages check-$language"
4857 done
4858
4859 # We link each language in with a set of hooks, reached indirectly via
4860 # lang.${target}.  Only do so for selected languages.
4861
4862 rm -f Make-hooks
4863 touch Make-hooks
4864 target_list="all.cross start.encap rest.encap tags \
4865         install-common install-man install-info install-pdf install-html dvi \
4866         pdf html uninstall info man srcextra srcman srcinfo \
4867         mostlyclean clean distclean maintainer-clean install-plugin"
4868
4869 for t in $target_list
4870 do
4871         x=
4872         for lang in $all_selected_languages
4873         do
4874                 x="$x $lang.$t"
4875         done
4876         echo "lang.$t: $x" >> Make-hooks
4877 done
4878
4879 # --------
4880 # Option include files
4881 # --------
4882
4883 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
4884 option_includes="option-includes.mk"
4885 AC_SUBST_FILE(option_includes)
4886
4887 # --------
4888 # UNSORTED
4889 # --------
4890
4891 # Create .gdbinit.
4892
4893 echo "dir ." > .gdbinit
4894 echo "dir ${srcdir}" >> .gdbinit
4895 if test x$gdb_needs_out_file_path = xyes
4896 then
4897         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
4898 fi
4899 if test "x$subdirs" != x; then
4900         for s in $subdirs
4901         do
4902                 echo "dir ${srcdir}/$s" >> .gdbinit
4903         done
4904 fi
4905 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
4906
4907 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
4908 AC_SUBST(gcc_tooldir)
4909 AC_SUBST(dollar)
4910
4911 # Find a directory in which to install a shared libgcc.
4912
4913 AC_ARG_ENABLE(version-specific-runtime-libs,
4914 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
4915                 [specify that runtime libraries should be
4916                  installed in a compiler-specific directory])])
4917
4918 # Substitute configuration variables
4919 AC_SUBST(subdirs)
4920 AC_SUBST(srcdir)
4921 AC_SUBST(all_compilers)
4922 AC_SUBST(all_gtfiles)
4923 AC_SUBST(all_lang_makefrags)
4924 AC_SUBST(all_languages)
4925 AC_SUBST(all_selected_languages)
4926 AC_SUBST(build_exeext)
4927 AC_SUBST(build_install_headers_dir)
4928 AC_SUBST(build_xm_file_list)
4929 AC_SUBST(build_xm_include_list)
4930 AC_SUBST(build_xm_defines)
4931 AC_SUBST(build_file_translate)
4932 AC_SUBST(check_languages)
4933 AC_SUBST(cpp_install_dir)
4934 AC_SUBST(xmake_file)
4935 AC_SUBST(tmake_file)
4936 AC_SUBST(TM_ENDIAN_CONFIG)
4937 AC_SUBST(TM_MULTILIB_CONFIG)
4938 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
4939 AC_SUBST(extra_gcc_objs)
4940 AC_SUBST(user_headers_inc_next_pre)
4941 AC_SUBST(user_headers_inc_next_post)
4942 AC_SUBST(extra_headers_list)
4943 AC_SUBST(extra_objs)
4944 AC_SUBST(extra_passes)
4945 AC_SUBST(extra_programs)
4946 AC_SUBST(float_h_file)
4947 AC_SUBST(gcc_config_arguments)
4948 AC_SUBST(gcc_gxx_include_dir)
4949 AC_SUBST(gcc_gxx_include_dir_add_sysroot)
4950 AC_SUBST(host_exeext)
4951 AC_SUBST(host_xm_file_list)
4952 AC_SUBST(host_xm_include_list)
4953 AC_SUBST(host_xm_defines)
4954 AC_SUBST(out_host_hook_obj)
4955 AC_SUBST(install)
4956 AC_SUBST(lang_opt_files)
4957 AC_SUBST(lang_specs_files)
4958 AC_SUBST(lang_tree_files)
4959 AC_SUBST(local_prefix)
4960 AC_SUBST(md_file)
4961 AC_SUBST(objc_boehm_gc)
4962 AC_SUBST(out_file)
4963 AC_SUBST(out_object_file)
4964 AC_SUBST(common_out_file)
4965 AC_SUBST(common_out_object_file)
4966 AC_SUBST(tm_file_list)
4967 AC_SUBST(tm_include_list)
4968 AC_SUBST(tm_defines)
4969 AC_SUBST(tm_p_file_list)
4970 AC_SUBST(tm_p_include_list)
4971 AC_SUBST(xm_file_list)
4972 AC_SUBST(xm_include_list)
4973 AC_SUBST(xm_defines)
4974 AC_SUBST(use_gcc_stdint)
4975 AC_SUBST(c_target_objs)
4976 AC_SUBST(cxx_target_objs)
4977 AC_SUBST(fortran_target_objs)
4978 AC_SUBST(target_cpu_default)
4979
4980 AC_SUBST_FILE(language_hooks)
4981
4982 # Echo link setup.
4983 if test x${build} = x${host} ; then
4984   if test x${host} = x${target} ; then
4985     echo "Links are now set up to build a native compiler for ${target}." 1>&2
4986   else
4987     echo "Links are now set up to build a cross-compiler" 1>&2
4988     echo " from ${host} to ${target}." 1>&2
4989   fi
4990 else
4991   if test x${host} = x${target} ; then
4992     echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
4993     echo " for ${target}." 1>&2
4994   else
4995     echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
4996     echo " from ${host} to ${target}." 1>&2
4997   fi
4998 fi
4999
5000 AC_ARG_VAR(GMPLIBS,[How to link GMP])
5001 AC_ARG_VAR(GMPINC,[How to find GMP include files])
5002
5003 AC_ARG_VAR(PPLLIBS,[How to link PPL])
5004 AC_ARG_VAR(PPLINC,[How to find PPL include files])
5005
5006 AC_ARG_VAR(CLOOGLIBS,[How to link CLOOG])
5007 AC_ARG_VAR(CLOOGINC,[How to find CLOOG include files])
5008 if test "x${CLOOGLIBS}" != "x" ; then
5009    AC_DEFINE(HAVE_cloog, 1, [Define if cloog is in use.])
5010 fi
5011
5012 # Check for plugin support
5013 AC_ARG_ENABLE(plugin,
5014 [AS_HELP_STRING([--enable-plugin], [enable plugin support])],
5015 enable_plugin=$enableval,
5016 enable_plugin=yes; default_plugin=yes)
5017
5018 pluginlibs=
5019
5020 case "${host}" in
5021   *-*-darwin*)
5022     if test x$build = x$host; then
5023       export_sym_check="nm${exeext} -g"
5024     elif test x$host = x$target; then
5025       export_sym_check="$gcc_cv_nm -g"
5026     else
5027       export_sym_check=
5028     fi
5029   ;;
5030   *)
5031     if test x$build = x$host; then
5032       export_sym_check="objdump${exeext} -T"
5033     elif test x$host = x$target; then
5034       export_sym_check="$gcc_cv_objdump -T"
5035     else
5036       export_sym_check=
5037     fi
5038   ;;
5039 esac
5040
5041 if test x"$enable_plugin" = x"yes"; then
5042
5043   AC_MSG_CHECKING([for exported symbols])
5044   if test "x$export_sym_check" != x; then
5045     echo "int main() {return 0;} int foobar() {return 0;}" > conftest.c
5046     ${CC} ${CFLAGS} ${LDFLAGS} conftest.c -o conftest > /dev/null 2>&1
5047     if $export_sym_check conftest | grep foobar > /dev/null; then
5048       : # No need to use a flag
5049       AC_MSG_RESULT([yes])
5050     else
5051       AC_MSG_RESULT([yes])
5052       AC_MSG_CHECKING([for -rdynamic])
5053       ${CC} ${CFLAGS} ${LDFLAGS} -rdynamic conftest.c -o conftest > /dev/null 2>&1
5054       if $export_sym_check conftest | grep foobar > /dev/null; then
5055         plugin_rdynamic=yes
5056         pluginlibs="-rdynamic"
5057       else
5058         plugin_rdynamic=no
5059         enable_plugin=no
5060       fi
5061       AC_MSG_RESULT([$plugin_rdynamic])
5062     fi
5063   else
5064     AC_MSG_RESULT([unable to check])
5065   fi
5066
5067   # Check -ldl
5068   saved_LIBS="$LIBS"
5069   AC_SEARCH_LIBS([dlopen], [dl])
5070   if test x"$ac_cv_search_dlopen" = x"-ldl"; then
5071     pluginlibs="$pluginlibs -ldl"
5072   fi
5073   LIBS="$saved_LIBS"
5074
5075   # Check that we can build shared objects with -fPIC -shared
5076   saved_LDFLAGS="$LDFLAGS"
5077   saved_CFLAGS="$CFLAGS"
5078   case "${host}" in
5079     *-*-darwin*)
5080       CFLAGS=`echo $CFLAGS | sed s/-mdynamic-no-pic//g`
5081       CFLAGS="$CFLAGS -fPIC"
5082       LDFLAGS="$LDFLAGS -shared -undefined dynamic_lookup"
5083     ;;
5084     *)
5085       CFLAGS="$CFLAGS -fPIC"
5086       LDFLAGS="$LDFLAGS -fPIC -shared"
5087     ;;
5088   esac
5089   AC_MSG_CHECKING([for -fPIC -shared])
5090   AC_TRY_LINK(
5091     [extern int X;],[return X == 0;],
5092     [AC_MSG_RESULT([yes]); have_pic_shared=yes],
5093     [AC_MSG_RESULT([no]); have_pic_shared=no])
5094   if test x"$have_pic_shared" != x"yes" -o x"$ac_cv_search_dlopen" = x"no"; then
5095     pluginlibs=
5096     enable_plugin=no
5097   fi
5098   LDFLAGS="$saved_LDFLAGS"
5099   CFLAGS="$saved_CFLAGS"
5100
5101   # If plugin support had been requested but not available, fail.
5102   if test x"$enable_plugin" = x"no" ; then
5103     if test x"$default_plugin" != x"yes"; then
5104       AC_MSG_ERROR([
5105 Building GCC with plugin support requires a host that supports
5106 -fPIC, -shared, -ldl and -rdynamic.])
5107     fi
5108   fi
5109 fi
5110
5111 AC_SUBST(pluginlibs)
5112 AC_SUBST(enable_plugin)
5113 if test x"$enable_plugin" = x"yes"; then
5114   AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
5115 fi
5116
5117
5118 AC_ARG_ENABLE(libquadmath-support,
5119 [AS_HELP_STRING([--disable-libquadmath-support],
5120   [disable libquadmath support for Fortran])],
5121 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
5122 ENABLE_LIBQUADMATH_SUPPORT=yes)
5123 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
5124   AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
5125             [Define to 1 to enable libquadmath support])
5126 fi
5127
5128
5129 # Specify what hash style to use by default.
5130 AC_ARG_WITH([linker-hash-style],
5131 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
5132                 [specify the linker hash style])],
5133 [case x"$withval" in
5134    xsysv)
5135      LINKER_HASH_STYLE=sysv
5136      ;;
5137    xgnu)
5138      LINKER_HASH_STYLE=gnu
5139      ;;
5140    xboth)
5141      LINKER_HASH_STYLE=both
5142      ;;
5143    *)
5144      AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
5145      ;;
5146  esac],
5147 [LINKER_HASH_STYLE=''])
5148 if test x"${LINKER_HASH_STYLE}" != x; then
5149   AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
5150                                          [The linker hash style])
5151 fi
5152
5153 # Configure the subdirectories
5154 # AC_CONFIG_SUBDIRS($subdirs)
5155
5156 # Create the Makefile
5157 # and configure language subdirectories
5158 AC_CONFIG_FILES($all_outputs)
5159
5160 AC_CONFIG_COMMANDS([default],
5161 [
5162 case ${CONFIG_HEADERS} in
5163   *auto-host.h:config.in*)
5164   echo > cstamp-h ;;
5165 esac
5166 # Make sure all the subdirs exist.
5167 for d in $subdirs doc build common c-family
5168 do
5169     test -d $d || mkdir $d
5170 done
5171 ],
5172 [subdirs='$subdirs'])
5173 AC_OUTPUT
5174