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