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 for f in $extra_options; do
1386   extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1387 done
1388 AC_SUBST(extra_opt_files)
1389
1390 # auto-host.h is the file containing items generated by autoconf and is
1391 # the first file included by config.h.
1392 # If host=build, it is correct to have bconfig include auto-host.h
1393 # as well.  If host!=build, we are in error and need to do more
1394 # work to find out the build config parameters.
1395 if test x$host = x$build
1396 then
1397         build_auto=auto-host.h
1398 else
1399         # We create a subdir, then run autoconf in the subdir.
1400         # To prevent recursion we set host and build for the new
1401         # invocation of configure to the build for this invocation
1402         # of configure.
1403         tempdir=build.$$
1404         rm -rf $tempdir
1405         mkdir $tempdir
1406         cd $tempdir
1407         case ${srcdir} in
1408         /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1409         *) realsrcdir=../${srcdir};;
1410         esac
1411         saved_CFLAGS="${CFLAGS}"
1412         CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1413         LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1414         ${realsrcdir}/configure \
1415                 --enable-languages=${enable_languages-all} \
1416                 --target=$target_alias --host=$build_alias --build=$build_alias
1417         CFLAGS="${saved_CFLAGS}"
1418
1419         # We just finished tests for the build machine, so rename
1420         # the file auto-build.h in the gcc directory.
1421         mv auto-host.h ../auto-build.h
1422         cd ..
1423         rm -rf $tempdir
1424         build_auto=auto-build.h
1425 fi
1426 AC_SUBST(build_subdir)
1427
1428 tm_file="${tm_file} defaults.h"
1429 tm_p_file="${tm_p_file} tm-preds.h"
1430 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1431 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1432 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1433 # put this back in temporarily.
1434 xm_file="auto-host.h ansidecl.h ${xm_file}"
1435
1436 # --------
1437 # UNSORTED
1438 # --------
1439
1440 changequote(,)dnl
1441 # Compile in configure arguments.
1442 if test -f configargs.h ; then
1443         # Being re-configured.
1444         gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1445         gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1446 else
1447         gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1448 fi
1449
1450 # Double all backslashes and backslash all quotes to turn
1451 # gcc_config_arguments into a C string.
1452 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1453 $gcc_config_arguments
1454 EOF
1455 gcc_config_arguments_str=`cat conftest.out`
1456 rm -f conftest.out
1457
1458 cat > configargs.h <<EOF
1459 /* Generated automatically. */
1460 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1461 static const char thread_model[] = "$thread_file";
1462
1463 static const struct {
1464   const char *name, *value;
1465 } configure_default_options[] = $configure_default_options;
1466 EOF
1467 changequote([,])dnl
1468
1469 changequote(,)dnl
1470 gcc_BASEVER=`cat $srcdir/BASE-VER`
1471 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
1472 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
1473 if test -f $srcdir/REVISION ; then
1474         gcc_REVISION=`cat $srcdir/REVISION`
1475 else
1476         gcc_REVISION=""
1477 fi
1478 cat > plugin-version.h <<EOF
1479 #include "configargs.h"
1480
1481 static char basever[] = "$gcc_BASEVER";
1482 static char datestamp[] = "$gcc_DATESTAMP";
1483 static char devphase[] = "$gcc_DEVPHASE";
1484 static char revision[] = "$gcc_REVISION";
1485
1486 /* FIXME plugins: We should make the version information more precise.
1487    One way to do is to add a checksum. */
1488
1489 static struct plugin_gcc_version gcc_version = {basever, datestamp,
1490                                                 devphase, revision,
1491                                                 configuration_arguments};
1492 EOF
1493 changequote([,])dnl
1494
1495 # Internationalization
1496 ZW_GNU_GETTEXT_SISTER_DIR
1497
1498 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1499 # -liconv on the link line twice.
1500 case "$LIBINTL" in *$LIBICONV*)
1501         LIBICONV= ;;
1502 esac
1503
1504 AC_ARG_ENABLE(secureplt,
1505 [  --enable-secureplt      enable -msecure-plt by default for PowerPC],
1506 [], [])
1507
1508 AC_ARG_ENABLE(leading-mingw64-underscores,
1509   AS_HELP_STRING([--enable-leading-mingw64-underscores],
1510                  [Enable leading underscores on 64 bit mingw targets]),
1511   [],[])
1512 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
1513   [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
1514     [Define if we should use leading underscore on 64 bit mingw targets])])
1515
1516 AC_ARG_ENABLE(cld,
1517 [  --enable-cld            enable -mcld by default for 32bit x86], [],
1518 [enable_cld=no])
1519
1520 AC_ARG_ENABLE(frame-pointer,
1521 [  --enable-frame-pointer  enable -fno-omit-frame-pointer by default for 32bit x86], [],
1522 [
1523 case $target_os in
1524 linux* | darwin[[8912]]*)
1525   # Enable -fomit-frame-pointer by default for Linux and Darwin with
1526   # DWARF2.
1527   enable_frame_pointer=no
1528   ;;
1529 *)
1530   enable_frame_pointer=yes
1531   ;;
1532 esac
1533 ])
1534
1535 # Windows32 Registry support for specifying GCC installation paths.
1536 AC_ARG_ENABLE(win32-registry,
1537 [  --disable-win32-registry
1538                           disable lookup of installation paths in the
1539                           Registry on Windows hosts
1540   --enable-win32-registry enable registry lookup (default)
1541   --enable-win32-registry=KEY
1542                           use KEY instead of GCC version as the last portion
1543                           of the registry key],,)
1544
1545 case $host_os in
1546   win32 | pe | cygwin* | mingw32* | uwin*)
1547     if test "x$enable_win32_registry" != xno; then
1548       AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1549     fi
1550
1551     if test "x$enable_win32_registry" != xno; then
1552       AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1553   [Define to 1 if installation paths should be looked up in the Windows
1554    Registry. Ignored on non-Windows hosts.])
1555
1556       if test "x$enable_win32_registry" != xyes \
1557          && test "x$enable_win32_registry" != x; then
1558         AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1559   [Define to be the last component of the Windows registry key under which
1560    to look for installation paths.  The full key used will be
1561    HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1562    The default is the GCC version number.])
1563       fi
1564     fi
1565   ;;
1566 esac
1567
1568 # Get an absolute path to the GCC top-level source directory
1569 holddir=`${PWDCMD-pwd}`
1570 cd $srcdir
1571 topdir=`${PWDCMD-pwd}`
1572 cd $holddir
1573
1574 # Conditionalize the makefile for this host machine.
1575 xmake_file=
1576 for f in ${host_xmake_file}
1577 do
1578         if test -f ${srcdir}/config/$f
1579         then
1580                 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1581         fi
1582 done
1583
1584 # Conditionalize the makefile for this target machine.
1585 tmake_file_=
1586 for f in ${tmake_file}
1587 do
1588         if test -f ${srcdir}/config/$f
1589         then
1590                 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1591         fi
1592 done
1593 tmake_file="${tmake_file_}"
1594
1595 out_object_file=`basename $out_file .c`.o
1596
1597 tm_file_list="options.h"
1598 tm_include_list="options.h insn-constants.h"
1599 for f in $tm_file; do
1600   case $f in
1601     ./* )
1602        f=`echo $f | sed 's/^..//'`
1603        tm_file_list="${tm_file_list} $f"
1604        tm_include_list="${tm_include_list} $f"
1605        ;;
1606     defaults.h )
1607        tm_file_list="${tm_file_list} \$(srcdir)/$f"
1608        tm_include_list="${tm_include_list} $f"
1609        ;;
1610     * )
1611        tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1612        tm_include_list="${tm_include_list} config/$f"
1613        ;;
1614   esac
1615 done
1616
1617 tm_p_file_list=
1618 tm_p_include_list=
1619 for f in $tm_p_file; do
1620   case $f in
1621     tm-preds.h )
1622        tm_p_file_list="${tm_p_file_list} $f"
1623        tm_p_include_list="${tm_p_include_list} $f"
1624        ;;
1625     * )
1626        tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1627        tm_p_include_list="${tm_p_include_list} config/$f"
1628   esac
1629 done
1630
1631 xm_file_list=
1632 xm_include_list=
1633 for f in $xm_file; do
1634   case $f in
1635     ansidecl.h )
1636        xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1637        xm_include_list="${xm_include_list} $f"
1638        ;;
1639     auto-host.h )
1640        xm_file_list="${xm_file_list} $f"
1641        xm_include_list="${xm_include_list} $f"
1642        ;;
1643     * )
1644        xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1645        xm_include_list="${xm_include_list} config/$f"
1646        ;;
1647   esac
1648 done
1649
1650 host_xm_file_list=
1651 host_xm_include_list=
1652 for f in $host_xm_file; do
1653   case $f in
1654     ansidecl.h )
1655        host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1656        host_xm_include_list="${host_xm_include_list} $f"
1657        ;;
1658     auto-host.h )
1659        host_xm_file_list="${host_xm_file_list} $f"
1660        host_xm_include_list="${host_xm_include_list} $f"
1661        ;;
1662     * )
1663        host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1664        host_xm_include_list="${host_xm_include_list} config/$f"
1665        ;;
1666   esac
1667 done
1668
1669 build_xm_file_list=
1670 for f in $build_xm_file; do
1671   case $f in
1672     ansidecl.h )
1673        build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1674        build_xm_include_list="${build_xm_include_list} $f"
1675        ;;
1676     auto-build.h | auto-host.h )
1677        build_xm_file_list="${build_xm_file_list} $f"
1678        build_xm_include_list="${build_xm_include_list} $f"
1679        ;;
1680     * )
1681        build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1682        build_xm_include_list="${build_xm_include_list} config/$f"
1683        ;;
1684   esac
1685 done
1686
1687 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1688 # cross-compiler which does not use the native headers and libraries.
1689 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1690 CROSS=                                          AC_SUBST(CROSS)
1691 ALL=all.internal                                AC_SUBST(ALL)
1692 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1693
1694 if test "x$with_build_sysroot" != x; then
1695   build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1696 else
1697   # This value is used, even on a native system, because
1698   # CROSS_SYSTEM_HEADER_DIR is just
1699   # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1700   build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1701 fi
1702
1703 if test x$host != x$target
1704 then
1705         CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1706         ALL=all.cross
1707         SYSTEM_HEADER_DIR=$build_system_header_dir
1708         case "$host","$target" in
1709         # Darwin crosses can use the host system's libraries and headers,
1710         # because of the fat library support.  Of course, it must be the
1711         # same version of Darwin on both sides.  Allow the user to
1712         # just say --target=foo-darwin without a version number to mean
1713         # "the version on this system".
1714             *-*-darwin*,*-*-darwin*)
1715                 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1716                 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1717                 if test $hostos = $targetos -o $targetos = darwin ; then
1718                     CROSS=
1719                     SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1720                     with_headers=yes
1721                 fi
1722                 ;;
1723
1724             i?86-*-*,x86_64-*-* \
1725             | powerpc*-*-*,powerpc64*-*-*)
1726                 CROSS="$CROSS -DNATIVE_CROSS" ;;
1727         esac
1728
1729         case $target in
1730                 *-*-mingw*)
1731                         if test "x$with_headers" = x; then
1732                                 with_headers=yes
1733                         fi
1734                         ;;
1735                 *)
1736                         ;;
1737         esac
1738 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1739         SYSTEM_HEADER_DIR=$build_system_header_dir
1740 fi
1741
1742 # If this is a cross-compiler that does not
1743 # have its own set of headers then define
1744 # inhibit_libc
1745
1746 # If this is using newlib, without having the headers available now,
1747 # then define inhibit_libc in LIBGCC2_CFLAGS.
1748 # This prevents libgcc2 from containing any code which requires libc
1749 # support.
1750 : ${inhibit_libc=false}
1751 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1752        test x$with_newlib = xyes ; } &&
1753      { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1754        inhibit_libc=true
1755 fi
1756 AC_SUBST(inhibit_libc)
1757
1758 # When building gcc with a cross-compiler, we need to adjust things so
1759 # that the generator programs are still built with the native compiler.
1760 # Also, we cannot run fixincludes.
1761
1762 # These are the normal (build=host) settings:
1763 CC_FOR_BUILD='$(CC)'            AC_SUBST(CC_FOR_BUILD)
1764 BUILD_CFLAGS='$(ALL_CFLAGS)'    AC_SUBST(BUILD_CFLAGS)
1765 BUILD_LDFLAGS='$(LDFLAGS)'      AC_SUBST(BUILD_LDFLAGS)
1766 STMP_FIXINC=stmp-fixinc         AC_SUBST(STMP_FIXINC)
1767
1768 # And these apply if build != host, or we are generating coverage data
1769 if test x$build != x$host || test "x$coverage_flags" != x
1770 then
1771     BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1772     BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
1773 fi
1774
1775 # Expand extra_headers to include complete path.
1776 # This substitutes for lots of t-* files.
1777 extra_headers_list=
1778 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1779 for file in ${extra_headers} ; do
1780   extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1781 done
1782
1783 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
1784 if test x"$use_gcc_tgmath" = xyes
1785 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
1786 fi
1787
1788 # Define collect2 in Makefile.
1789 case $host_can_use_collect2 in
1790   no) collect2= ;;
1791   *) collect2='collect2$(exeext)' ;;
1792 esac
1793 AC_SUBST([collect2])
1794
1795 # Add a definition of USE_COLLECT2 if system wants one.
1796 case $use_collect2 in
1797   no) use_collect2= ;;
1798   "") ;;
1799   *)
1800     host_xm_defines="${host_xm_defines} USE_COLLECT2"
1801     xm_defines="${xm_defines} USE_COLLECT2"
1802     case $host_can_use_collect2 in
1803       no)
1804         AC_MSG_ERROR([collect2 is required but cannot be built on this system])
1805         ;;
1806     esac
1807     ;;
1808 esac
1809
1810 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
1811 [Define to the name of the LTO plugin DSO that must be
1812   passed to the linker's -plugin=LIB option.])
1813
1814 # ---------------------------
1815 # Assembler & linker features
1816 # ---------------------------
1817
1818 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
1819 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
1820 # However when ld-new is first executed from the build tree, libtool will
1821 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
1822 # to the build tree.  While doing this we need to use the previous-stage
1823 # linker, or we have an infinite loop.  The presence of a shell script as
1824 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
1825 # the gcc/collect-ld script.  So we need to know how libtool works, or
1826 # exec-tool will fail.
1827
1828 m4_defun([_LT_CONFIG_COMMANDS], [])
1829 AC_PROG_LIBTOOL
1830 AC_SUBST(objdir)
1831 AC_SUBST(enable_fast_install)
1832
1833 # Identify the assembler which will work hand-in-glove with the newly
1834 # built GCC, so that we can examine its features.  This is the assembler
1835 # which will be driven by the driver program.
1836 #
1837 # If build != host, and we aren't building gas in-tree, we identify a
1838 # build->target assembler and hope that it will have the same features
1839 # as the host->target assembler we'll be using.
1840 gcc_cv_gas_major_version=
1841 gcc_cv_gas_minor_version=
1842 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1843
1844 m4_pattern_allow([AS_FOR_TARGET])dnl
1845 AS_VAR_SET_IF(gcc_cv_as,, [
1846 if test -x "$DEFAULT_ASSEMBLER"; then
1847         gcc_cv_as="$DEFAULT_ASSEMBLER"
1848 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
1849      && test -f ../gas/Makefile \
1850      && test x$build = x$host; then
1851         gcc_cv_as=../gas/as-new$build_exeext
1852 elif test -x as$build_exeext; then
1853         # Build using assembler in the current directory.
1854         gcc_cv_as=./as$build_exeext
1855 elif test -x $AS_FOR_TARGET; then
1856         gcc_cv_as="$AS_FOR_TARGET"
1857 else
1858         AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
1859 fi])
1860
1861 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
1862 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
1863 case "$ORIGINAL_AS_FOR_TARGET" in
1864   ./as | ./as$build_exeext) ;;
1865   *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
1866 esac
1867
1868 AC_MSG_CHECKING(what assembler to use)
1869 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
1870   # Single tree build which includes gas.  We want to prefer it
1871   # over whatever linker top-level may have detected, since
1872   # we'll use what we're building after installation anyway.
1873   AC_MSG_RESULT(newly built gas)
1874   in_tree_gas=yes
1875   _gcc_COMPUTE_GAS_VERSION
1876   in_tree_gas_is_elf=no
1877   if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
1878      || (grep 'obj_format = multi' ../gas/Makefile \
1879          && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
1880   then
1881     in_tree_gas_is_elf=yes
1882   fi
1883 else
1884   AC_MSG_RESULT($gcc_cv_as)
1885   in_tree_gas=no
1886 fi
1887
1888 # Identify the linker which will work hand-in-glove with the newly
1889 # built GCC, so that we can examine its features.  This is the linker
1890 # which will be driven by the driver program.
1891 #
1892 # If build != host, and we aren't building gas in-tree, we identify a
1893 # build->target linker and hope that it will have the same features
1894 # as the host->target linker we'll be using.
1895 gcc_cv_gld_major_version=
1896 gcc_cv_gld_minor_version=
1897 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1898 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1899
1900 AS_VAR_SET_IF(gcc_cv_ld,, [
1901 if test -x "$DEFAULT_LINKER"; then
1902         gcc_cv_ld="$DEFAULT_LINKER"
1903 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
1904      && test -f ../ld/Makefile \
1905      && test x$build = x$host; then
1906         gcc_cv_ld=../ld/ld-new$build_exeext
1907 elif test -x collect-ld$build_exeext; then
1908         # Build using linker in the current directory.
1909         gcc_cv_ld=./collect-ld$build_exeext
1910 elif test -x $LD_FOR_TARGET; then
1911         gcc_cv_ld="$LD_FOR_TARGET"
1912 else
1913         AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
1914 fi])
1915
1916 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
1917 PLUGIN_LD=`basename $gcc_cv_ld`
1918 AC_ARG_WITH(plugin-ld,
1919 [  --with-plugin-ld=[[ARG]]  specify the plugin linker],
1920 [if test x"$withval" != x; then
1921    ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
1922    PLUGIN_LD="$withval"
1923  fi])
1924 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
1925 AC_DEFINE_UNQUOTED(PLUGIN_LD, "$PLUGIN_LD", [Specify plugin linker])
1926
1927 # Check to see if we are using gold instead of ld
1928 AC_MSG_CHECKING(whether we are using gold)
1929 ld_is_gold=no
1930 if test x$gcc_cv_ld != x; then
1931   if $gcc_cv_ld --version 2>/dev/null | sed 1q \
1932      | grep "GNU gold" > /dev/null; then
1933     ld_is_gold=yes
1934   fi
1935 fi
1936 AC_MSG_RESULT($ld_is_gold)
1937
1938 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
1939 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
1940 case "$ORIGINAL_LD_FOR_TARGET" in
1941   ./collect-ld | ./collect-ld$build_exeext) ;;
1942   *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
1943 esac
1944
1945 AC_MSG_CHECKING(what linker to use)
1946 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext; then
1947         # Single tree build which includes ld.  We want to prefer it
1948         # over whatever linker top-level may have detected, since
1949         # we'll use what we're building after installation anyway.
1950         AC_MSG_RESULT(newly built ld)
1951         in_tree_ld=yes
1952         in_tree_ld_is_elf=no
1953         if (grep 'EMUL = .*elf' ../ld/Makefile \
1954             || grep 'EMUL = .*linux' ../ld/Makefile \
1955             || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
1956           in_tree_ld_is_elf=yes
1957         fi
1958         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
1959         do
1960 changequote(,)dnl
1961                 gcc_cv_gld_version=`sed -n -e 's/^[     ]*\(VERSION=[0-9]*\.[0-9]*.*\)/\1/p' < $f`
1962                 if test x$gcc_cv_gld_version != x; then
1963                         break
1964                 fi
1965         done
1966         gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
1967         gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1968 changequote([,])dnl
1969 else
1970         AC_MSG_RESULT($gcc_cv_ld)
1971         in_tree_ld=no
1972 fi
1973
1974 # Figure out what nm we will be using.
1975 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
1976 AS_VAR_SET_IF(gcc_cv_nm,, [
1977 if test -f $gcc_cv_binutils_srcdir/configure.in \
1978      && test -f ../binutils/Makefile \
1979      && test x$build = x$host; then
1980         gcc_cv_nm=../binutils/nm-new$build_exeext
1981 elif test -x nm$build_exeext; then
1982         gcc_cv_nm=./nm$build_exeext
1983 elif test -x $NM_FOR_TARGET; then
1984         gcc_cv_nm="$NM_FOR_TARGET"
1985 else
1986         AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
1987 fi])
1988
1989 AC_MSG_CHECKING(what nm to use)
1990 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
1991         # Single tree build which includes binutils.
1992         AC_MSG_RESULT(newly built nm)
1993         in_tree_nm=yes
1994 else
1995         AC_MSG_RESULT($gcc_cv_nm)
1996         in_tree_nm=no
1997 fi
1998
1999 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2000 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2001 case "$ORIGINAL_NM_FOR_TARGET" in
2002   ./nm | ./nm$build_exeext) ;;
2003   *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2004 esac
2005
2006
2007 # Figure out what objdump we will be using.
2008 AS_VAR_SET_IF(gcc_cv_objdump,, [
2009 if test -f $gcc_cv_binutils_srcdir/configure.in \
2010      && test -f ../binutils/Makefile \
2011      && test x$build = x$host; then
2012         # Single tree build which includes binutils.
2013         gcc_cv_objdump=../binutils/objdump$build_exeext
2014 elif test -x objdump$build_exeext; then
2015         gcc_cv_objdump=./objdump$build_exeext
2016 elif test -x $OBJDUMP_FOR_TARGET; then
2017         gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2018 else
2019         AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2020 fi])
2021
2022 AC_MSG_CHECKING(what objdump to use)
2023 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2024         # Single tree build which includes binutils.
2025         AC_MSG_RESULT(newly built objdump)
2026 elif test x$gcc_cv_objdump = x; then
2027         AC_MSG_RESULT(not found)
2028 else
2029         AC_MSG_RESULT($gcc_cv_objdump)
2030 fi
2031
2032 # Figure out what readelf we will be using.
2033 AS_VAR_SET_IF(gcc_cv_readelf,, [
2034 if test -f $gcc_cv_binutils_srcdir/configure.in \
2035      && test -f ../binutils/Makefile \
2036      && test x$build = x$host; then
2037         # Single tree build which includes binutils.
2038         gcc_cv_readelf=../binutils/readelf$build_exeext
2039 elif test -x readelf$build_exeext; then
2040         gcc_cv_readelf=./readelf$build_exeext
2041 else
2042         AC_PATH_PROG(gcc_cv_readelf, readelf)
2043 fi])
2044
2045 AC_MSG_CHECKING(what readelf to use)
2046 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2047         # Single tree build which includes binutils.
2048         AC_MSG_RESULT(newly built readelf)
2049 elif test x$gcc_cv_readelf = x; then
2050         AC_MSG_RESULT(not found)
2051 else
2052         AC_MSG_RESULT($gcc_cv_readelf)
2053 fi
2054
2055 # Figure out what assembler alignment features are present.
2056 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2057  [2,6,0],,
2058 [.balign 4
2059 .p2align 2],,
2060 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2061   [Define if your assembler supports .balign and .p2align.])])
2062
2063 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2064  [2,8,0],,
2065  [.p2align 4,,7],,
2066 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2067   [Define if your assembler supports specifying the maximum number
2068    of bytes to skip when using the GAS .p2align command.])])
2069
2070 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2071  [2,8,0],,
2072  [.literal16],,
2073 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2074   [Define if your assembler supports .literal16.])])
2075
2076 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2077  [elf,2,9,0],,
2078  [conftest_label1: .word 0
2079 .subsection -1
2080 conftest_label2: .word 0
2081 .previous],
2082  [if test x$gcc_cv_nm != x; then
2083     $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2084     $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2085     if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2086     then :
2087     else gcc_cv_as_subsection_m1=yes
2088     fi
2089     rm -f conftest.nm1 conftest.nm2
2090   fi],
2091  [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2092   [Define if your assembler supports .subsection and .subsection -1 starts
2093    emitting at the beginning of your section.])])
2094
2095 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2096  [2,2,0],,
2097  [      .weak foobar],,
2098 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2099
2100 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2101  [2,17,0],,
2102  [      .weakref foobar, barfnot],,
2103 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2104
2105 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2106  [2,15,91],,
2107  [      .SPACE $TEXT$
2108         .NSUBSPA $CODE$,COMDAT],,
2109 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2110
2111 # .hidden needs to be supported in both the assembler and the linker,
2112 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2113 # This is irritatingly difficult to feature test for; we have to check the
2114 # date string after the version number.  If we've got an in-tree
2115 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2116 # to be safe.
2117 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2118 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2119  [elf,2,13,0],,
2120 [       .hidden foobar
2121 foobar:],[
2122 # Solaris 9/x86 as incorrectly emits an alias for a hidden symbol with
2123 # STV_HIDDEN, so disable .hidden support if so.
2124 case "${target}" in
2125   i?86-*-solaris2*)
2126     if test x$gcc_cv_as != x && test x$gcc_cv_objdump != x; then
2127       cat > conftest.s <<EOF
2128 .globl hidden
2129         .hidden hidden
2130 hidden:
2131 .globl default
2132         .set    default,hidden
2133 EOF
2134       if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
2135         && $gcc_cv_objdump -t conftest.o 2>/dev/null | \
2136         grep '\.hidden default' > /dev/null; then
2137         gcc_cv_as_hidden=no
2138       else
2139         gcc_cv_as_hidden=yes
2140       fi
2141     else
2142       # Assume bug is present if objdump is missing.
2143       gcc_cv_as_hidden=no
2144     fi
2145     ;;
2146   *)
2147     gcc_cv_as_hidden=yes
2148     ;;
2149 esac])
2150
2151 # gnu_indirect_function type is an extension proposed at
2152 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2153 # selection of function implementation
2154 AC_ARG_ENABLE(gnu-indirect-function,
2155  [AS_HELP_STRING([--enable-gnu-indirect-function],
2156                  [enable the use of the @gnu_indirect_function to glibc systems])],
2157  [case $enable_gnu_indirect_function in
2158     yes | no) ;;
2159     *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2160 Valid choices are 'yes' and 'no'.]) ;;
2161   esac],
2162  [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2163 if test x$enable_gnu_indirect_function = xyes; then
2164   AC_DEFINE(HAVE_GNU_INDIRECT_FUNCTION, 1,
2165    [Define if your system supports gnu indirect functions.])
2166 fi
2167
2168 changequote(,)dnl
2169 if test $in_tree_ld != yes ; then
2170   ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2171   if test x"$ld_is_gold" = xyes; then
2172     gcc_cv_ld_hidden=yes
2173   elif echo "$ld_ver" | grep GNU > /dev/null; then
2174     ld_vers=`echo $ld_ver | sed -n \
2175         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2176     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'`
2177     ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2178     ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2179     ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2180   else
2181     case "${target}" in
2182       *-*-solaris2*)
2183         #
2184         # Solaris 2 ld -V output looks like this for a regular version:
2185         #
2186         # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1699
2187         #
2188         # but test versions add stuff at the end:
2189         #
2190         # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1701:onnv-ab196087-6931056-03/25/10
2191         #
2192         ld_ver=`$gcc_cv_ld -V 2>&1`
2193         if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2194           ld_vers=`echo $ld_ver | sed -n \
2195             -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2196           ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2197           ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2198         fi
2199         ;;
2200     esac
2201   fi
2202 fi
2203 changequote([,])dnl
2204
2205 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2206 [[if test $in_tree_ld = yes ; then
2207   gcc_cv_ld_hidden=no
2208   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 \
2209      && test $in_tree_ld_is_elf = yes; then
2210      gcc_cv_ld_hidden=yes
2211   fi
2212 else
2213   gcc_cv_ld_hidden=yes
2214   if echo "$ld_ver" | grep GNU > /dev/null; then
2215     if test 0"$ld_date" -lt 20020404; then
2216       if test -n "$ld_date"; then
2217         # If there was date string, but was earlier than 2002-04-04, fail
2218         gcc_cv_ld_hidden=no
2219       elif test -z "$ld_vers"; then
2220         # If there was no date string nor ld version number, something is wrong
2221         gcc_cv_ld_hidden=no
2222       else
2223         test -z "$ld_vers_patch" && ld_vers_patch=0
2224         if test "$ld_vers_major" -lt 2; then
2225           gcc_cv_ld_hidden=no
2226         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2227           gcc_cv_ld_hidden="no"
2228         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2229           gcc_cv_ld_hidden=no
2230         fi
2231       fi
2232     fi
2233   else
2234     case "${target}" in
2235       hppa64*-*-hpux* | ia64*-*-hpux*)
2236         gcc_cv_ld_hidden=yes
2237         ;;
2238       *-*-solaris2.8*)
2239         # .hidden support was backported to Solaris 8, starting with ld
2240         # version 1.276.
2241         if test "$ld_vers_minor" -ge 276; then
2242           gcc_cv_ld_hidden=yes
2243         else
2244           gcc_cv_ld_hidden=no
2245         fi
2246         ;;
2247       *-*-solaris2.9* | *-*-solaris2.1[0-9]*)
2248         # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2249         # .symbolic was only added in Solaris 9 12/02.
2250         gcc_cv_ld_hidden=yes
2251         ;;
2252       *)
2253         gcc_cv_ld_hidden=no
2254         ;;
2255     esac
2256   fi
2257 fi]])
2258 libgcc_visibility=no
2259 AC_SUBST(libgcc_visibility)
2260 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2261 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2262   libgcc_visibility=yes
2263   AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2264   [Define if your assembler and linker support .hidden.])
2265 fi
2266
2267 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2268 gcc_cv_ld_ro_rw_mix=unknown
2269 if test $in_tree_ld = yes ; then
2270   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 \
2271      && test $in_tree_ld_is_elf = yes; then
2272     gcc_cv_ld_ro_rw_mix=read-write
2273   fi
2274 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2275   echo '.section myfoosect, "a"' > conftest1.s
2276   echo '.section myfoosect, "aw"' > conftest2.s
2277   echo '.byte 1' >> conftest2.s
2278   echo '.section myfoosect, "a"' > conftest3.s
2279   echo '.byte 0' >> conftest3.s
2280   if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2281      && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2282      && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2283      && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2284         conftest2.o conftest3.o > /dev/null 2>&1; then
2285     gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2286                          | sed -e '/myfoosect/!d' -e N`
2287     if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2288       if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2289         gcc_cv_ld_ro_rw_mix=read-only
2290       else
2291         gcc_cv_ld_ro_rw_mix=read-write
2292       fi
2293     fi
2294   fi
2295 changequote(,)dnl
2296   rm -f conftest.* conftest[123].*
2297 changequote([,])dnl
2298 fi
2299 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2300         AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2301   [Define if your linker links a mix of read-only
2302    and read-write sections into a read-write section.])
2303 fi
2304 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2305
2306 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2307 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2308   [elf,2,11,0],,
2309 [       .data
2310         .uleb128 L2 - L1
2311 L1:
2312         .uleb128 1280
2313         .sleb128 -1010
2314 L2:],
2315 [[# GAS versions before 2.11 do not support uleb128,
2316   # despite appearing to.
2317   # ??? There exists an elf-specific test that will crash
2318   # the assembler.  Perhaps it's better to figure out whether
2319   # arbitrary sections are supported and try the test.
2320   as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2321   if echo "$as_ver" | grep GNU > /dev/null; then
2322     as_vers=`echo $as_ver | sed -n \
2323         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2324     as_major=`expr "$as_vers" : '\([0-9]*\)'`
2325     as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2326     if test $as_major -eq 2 && test $as_minor -lt 11
2327     then :
2328     else gcc_cv_as_leb128=yes
2329     fi
2330   fi]],
2331   [AC_DEFINE(HAVE_AS_LEB128, 1,
2332     [Define if your assembler supports .sleb128 and .uleb128.])])
2333
2334 # Check if we have assembler support for unwind directives.
2335 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2336   ,,
2337 [       .text
2338         .cfi_startproc
2339         .cfi_offset 0, 0
2340         .cfi_same_value 1
2341         .cfi_def_cfa 1, 2
2342         .cfi_escape 1, 2, 3, 4, 5
2343         .cfi_endproc],
2344 [case "$target" in
2345   *-*-solaris*)
2346     # If the linker used on Solaris (like Sun ld) isn't capable of merging
2347     # read-only and read-write sections, we need to make sure that the
2348     # assembler used emits read-write .eh_frame sections.
2349     if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2350       if test "x$gcc_cv_objdump" != x; then
2351         if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2352                 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2353           gcc_cv_as_cfi_directive=no
2354         else
2355           case "$target" in
2356             i?86-*-solaris2.1[[0-9]]*)
2357               # On Solaris/x86, make sure that GCC and gas agree on using
2358               # read-only .eh_frame sections for 64-bit.
2359               if $gcc_cv_as --64 -o conftest.o conftest.s > /dev/null 2>&1 && \
2360                 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2361                         sed -e /.eh_frame/!d -e N | \
2362                         grep READONLY > /dev/null; then
2363                 gcc_cv_as_cfi_directive=yes
2364               else
2365                 gcc_cv_as_cfi_directive=no
2366               fi
2367               ;;
2368             *)
2369               gcc_cv_as_cfi_directive=yes
2370               ;;
2371           esac
2372         fi
2373       else
2374         # no objdump, err on the side of caution
2375         gcc_cv_as_cfi_directive=no
2376       fi
2377     else
2378       gcc_cv_as_cfi_directive=yes
2379     fi
2380     ;;
2381   *-*-*)
2382     gcc_cv_as_cfi_directive=yes
2383     ;;
2384 esac])
2385 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
2386 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2387   ,,
2388 [       .text
2389         .cfi_startproc
2390         .cfi_adjust_cfa_offset 64
2391         .skip 75040, 0
2392         .cfi_adjust_cfa_offset 128
2393         .cfi_endproc],
2394 [[
2395 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
2396     | grep 'DW_CFA_advance_loc[24]:[    ][      ]*75040[        ]' >/dev/null; then
2397    gcc_cv_as_cfi_advance_working=yes
2398 fi
2399 ]])
2400 else
2401   # no objdump, err on the side of caution
2402   gcc_cv_as_cfi_advance_working=no
2403 fi
2404 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
2405 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2406   [`if test $gcc_cv_as_cfi_directive = yes \
2407        && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2408   [Define 0/1 if your assembler supports CFI directives.])
2409
2410 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
2411 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2412   gcc_cv_as_cfi_personality_directive, ,,
2413 [       .text
2414         .cfi_startproc
2415         .cfi_personality 0, symbol
2416         .cfi_endproc])
2417 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2418   [`if test $gcc_cv_as_cfi_personality_directive = yes;
2419     then echo 1; else echo 0; fi`],
2420   [Define 0/1 if your assembler supports .cfi_personality.])
2421
2422 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2423   gcc_cv_as_cfi_sections_directive, ,,
2424 [       .text
2425         .cfi_sections .debug_frame, .eh_frame
2426         .cfi_startproc
2427         .cfi_endproc],
2428 [case $target_os in
2429   win32 | pe | cygwin* | mingw32* | uwin*)
2430     # Need to check that we generated the correct relocation for the
2431     # .debug_frame section.  This was fixed for binutils 2.21.
2432     gcc_cv_as_cfi_sections_directive=no
2433     if test "x$gcc_cv_objdump" != x; then
2434      if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
2435         grep secrel > /dev/null; then
2436       gcc_cv_as_cfi_sections_directive=yes
2437      fi
2438     fi
2439     ;;
2440   *)
2441     gcc_cv_as_cfi_sections_directive=yes
2442     ;;
2443 esac])
2444 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
2445 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2446   [`if test $gcc_cv_as_cfi_sections_directive = yes;
2447     then echo 1; else echo 0; fi`],
2448   [Define 0/1 if your assembler supports .cfi_sections.])
2449
2450 # GAS versions up to and including 2.11.0 may mis-optimize
2451 # .eh_frame data.
2452 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2453   [elf,2,12,0],,
2454 [       .text
2455 .LFB1:
2456         .4byte  0
2457 .L1:
2458         .4byte  0
2459 .LFE1:
2460         .section        .eh_frame,"aw",@progbits
2461 __FRAME_BEGIN__:
2462         .4byte  .LECIE1-.LSCIE1
2463 .LSCIE1:
2464         .4byte  0x0
2465         .byte   0x1
2466         .ascii "z\0"
2467         .byte   0x1
2468         .byte   0x78
2469         .byte   0x1a
2470         .byte   0x0
2471         .byte   0x4
2472         .4byte  1
2473         .p2align 1
2474 .LECIE1:
2475 .LSFDE1:
2476         .4byte  .LEFDE1-.LASFDE1
2477 .LASFDE1:
2478         .4byte  .LASFDE1-__FRAME_BEGIN__
2479         .4byte  .LFB1
2480         .4byte  .LFE1-.LFB1
2481         .byte   0x4
2482         .4byte  .LFE1-.LFB1
2483         .byte   0x4
2484         .4byte  .L1-.LFB1
2485 .LEFDE1:],
2486 [  dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2487 cat > conftest.lit <<EOF
2488  0000 10000000 00000000 017a0001 781a0004  .........z..x...
2489  0010 01000000 12000000 18000000 00000000  ................
2490  0020 08000000 04080000 0044               .........D      @&t@
2491 EOF
2492 cat > conftest.big <<EOF
2493  0000 00000010 00000000 017a0001 781a0004  .........z..x...
2494  0010 00000001 00000012 00000018 00000000  ................
2495  0020 00000008 04000000 0844               .........D      @&t@
2496 EOF
2497   # If the assembler didn't choke, and we can objdump,
2498   # and we got the correct data, then succeed.
2499   # The text in the here-document typically retains its unix-style line
2500   # endings, while the output of objdump will use host line endings.
2501   # Therefore, use diff -b for the comparisons.
2502   if test x$gcc_cv_objdump != x \
2503   && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2504      | tail -3 > conftest.got \
2505   && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2506     || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2507   then
2508     gcc_cv_as_eh_frame=yes
2509   elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2510     gcc_cv_as_eh_frame=buggy
2511   else
2512     # Uh oh, what do we do now?
2513     gcc_cv_as_eh_frame=no
2514   fi])
2515
2516 if test $gcc_cv_as_eh_frame = buggy; then
2517   AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2518   [Define if your assembler mis-optimizes .eh_frame data.])
2519 fi
2520
2521 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2522  [elf,2,12,0], [--fatal-warnings],
2523  [.section .rodata.str, "aMS", @progbits, 1])
2524 if test $gcc_cv_as_shf_merge = no; then
2525   gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2526     [elf,2,12,0], [--fatal-warnings],
2527     [.section .rodata.str, "aMS", %progbits, 1])
2528 fi
2529 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2530   [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2531 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2532
2533 gcc_GAS_CHECK_FEATURE(COMDAT group support, gcc_cv_as_comdat_group,
2534  [elf,2,16,0], [--fatal-warnings],
2535  [.section .text,"axG",@progbits,.foo,comdat])
2536 if test $gcc_cv_as_comdat_group = yes; then
2537   gcc_cv_as_comdat_group_percent=no
2538 else
2539  gcc_GAS_CHECK_FEATURE(COMDAT group support, gcc_cv_as_comdat_group_percent,
2540    [elf,2,16,0], [--fatal-warnings],
2541    [.section .text,"axG",%progbits,.foo,comdat])
2542 fi
2543 if test x"$ld_is_gold" = xyes; then
2544   comdat_group=yes
2545 elif test $in_tree_ld = yes ; then
2546   comdat_group=no
2547   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 \
2548      && test $in_tree_ld_is_elf = yes; then
2549      comdat_group=yes
2550   fi
2551 elif echo "$ld_ver" | grep GNU > /dev/null; then
2552   comdat_group=yes
2553   if test 0"$ld_date" -lt 20050308; then
2554     if test -n "$ld_date"; then
2555       # If there was date string, but was earlier than 2005-03-08, fail
2556       comdat_group=no
2557     elif test "$ld_vers_major" -lt 2; then
2558       comdat_group=no
2559     elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2560       comdat_group=no
2561     fi
2562   fi
2563 else
2564 changequote(,)dnl
2565   case "${target}" in
2566     *-*-solaris2.1[1-9]*)
2567       # Sun ld has COMDAT group support since Solaris 9, but it doesn't
2568       # interoperate with GNU as until Solaris 11 build 130, i.e. ld
2569       # version 1.688.
2570       #
2571       # FIXME: Maybe need to refine later when COMDAT group support with
2572       # Sun as is implemented.
2573       if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 1688; then
2574         comdat_group=yes
2575       else
2576         comdat_group=no
2577       fi
2578       ;;
2579     *)
2580       # Assume linkers other than GNU ld don't support COMDAT group.
2581       comdat_group=no
2582       ;;
2583   esac
2584 changequote([,])dnl
2585 fi
2586 # Allow overriding the automatic COMDAT group tests above.
2587 AC_ARG_ENABLE(comdat,
2588   [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
2589   [comdat_group="$enable_comdat"])
2590 if test $comdat_group = no; then
2591   gcc_cv_as_comdat_group=no
2592   gcc_cv_as_comdat_group_percent=no
2593 fi
2594 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2595   [`if test $gcc_cv_as_comdat_group = yes || test $gcc_cv_as_comdat_group_percent = yes; then echo 1; else echo 0; fi`],
2596 [Define 0/1 if your assembler and linker support COMDAT groups.])
2597
2598 gcc_GAS_CHECK_FEATURE([line table discriminator support],
2599  gcc_cv_as_discriminator,
2600  [2,19,51],,
2601 [       .text
2602         .file 1 "conf.c"
2603         .loc 1 1 0 discriminator 1],,
2604 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
2605   [Define if your assembler supports the .loc discriminator sub-directive.])])
2606
2607 # Thread-local storage - the check is heavily parameterized.
2608 conftest_s=
2609 tls_first_major=
2610 tls_first_minor=
2611 tls_as_opt=
2612 case "$target" in
2613 changequote(,)dnl
2614   alpha*-*-*)
2615     conftest_s='
2616         .section ".tdata","awT",@progbits
2617 foo:    .long   25
2618         .text
2619         ldq     $27,__tls_get_addr($29)         !literal!1
2620         lda     $16,foo($29)                    !tlsgd!1
2621         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
2622         ldq     $27,__tls_get_addr($29)         !literal!2
2623         lda     $16,foo($29)                    !tlsldm!2
2624         jsr     $26,($27),__tls_get_addr        !lituse_tlsldm!2
2625         ldq     $1,foo($29)                     !gotdtprel
2626         ldah    $2,foo($29)                     !dtprelhi
2627         lda     $3,foo($2)                      !dtprello
2628         lda     $4,foo($29)                     !dtprel
2629         ldq     $1,foo($29)                     !gottprel
2630         ldah    $2,foo($29)                     !tprelhi
2631         lda     $3,foo($2)                      !tprello
2632         lda     $4,foo($29)                     !tprel'
2633         tls_first_major=2
2634         tls_first_minor=13
2635         tls_as_opt=--fatal-warnings
2636         ;;
2637   cris-*-*|crisv32-*-*)
2638     conftest_s='
2639         .section ".tdata","awT",@progbits
2640 x:      .long   25
2641         .text
2642         move.d x:IE,$r10
2643         nop'
2644         tls_first_major=2
2645         tls_first_minor=20
2646         tls_as_opt=--fatal-warnings
2647         ;;
2648   frv*-*-*)
2649     conftest_s='
2650         .section ".tdata","awT",@progbits
2651 x:      .long   25
2652         .text
2653         call    #gettlsoff(x)'
2654         tls_first_major=2
2655         tls_first_minor=14
2656         ;;
2657   hppa*-*-linux*)
2658     conftest_s='
2659 t1:     .reg    %r20
2660 t2:     .reg    %r21
2661 gp:     .reg    %r19
2662         .section ".tdata","awT",@progbits
2663 foo:    .long   25
2664         .text
2665         .align  4
2666         addil LT%foo-$tls_gdidx$,gp
2667         ldo RT%foo-$tls_gdidx$(%r1),%arg0
2668         b __tls_get_addr
2669         nop
2670         addil LT%foo-$tls_ldidx$,gp
2671         b __tls_get_addr
2672         ldo RT%foo-$tls_ldidx$(%r1),%arg0
2673         addil LR%foo-$tls_dtpoff$,%ret0
2674         ldo RR%foo-$tls_dtpoff$(%r1),%t1
2675         mfctl %cr27,%t1
2676         addil LT%foo-$tls_ieoff$,gp
2677         ldw RT%foo-$tls_ieoff$(%r1),%t2
2678         add %t1,%t2,%t3
2679         mfctl %cr27,%t1
2680         addil LR%foo-$tls_leoff$,%t1
2681         ldo RR%foo-$tls_leoff$(%r1),%t2'
2682         tls_first_major=2
2683         tls_first_minor=15
2684         tls_as_opt=--fatal-warnings
2685         ;;
2686   arm*-*-*)
2687     conftest_s='
2688         .section ".tdata","awT",%progbits
2689 foo:    .long   25
2690         .text
2691 .word foo(gottpoff)
2692 .word foo(tpoff)
2693 .word foo(tlsgd)
2694 .word foo(tlsldm)
2695 .word foo(tlsldo)'
2696         tls_first_major=2
2697         tls_first_minor=17
2698         ;;
2699   i[34567]86-*-*)
2700     case "$target" in
2701       i[34567]86-*-solaris2.*)
2702         on_solaris=yes
2703         tga_func=___tls_get_addr
2704         ;;
2705       *)
2706         on_solaris=no
2707         ;;
2708     esac
2709     if test x$on_solaris = xyes && test x$gas_flag = xno; then
2710       conftest_s='
2711         .section .tdata,"awt",@progbits'
2712       tls_first_major=0
2713       tls_first_minor=0
2714 changequote([,])dnl
2715       AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
2716 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
2717 changequote(,)dnl
2718     else
2719       conftest_s='
2720         .section ".tdata","awT",@progbits'
2721       tls_first_major=2
2722       tls_first_minor=14
2723       tls_as_opt="--fatal-warnings"
2724     fi
2725     conftest_s="$conftest_s
2726 foo:    .long   25
2727         .text
2728         movl    %gs:0, %eax
2729         leal    foo@tlsgd(,%ebx,1), %eax
2730         leal    foo@tlsldm(%ebx), %eax
2731         leal    foo@dtpoff(%eax), %edx
2732         movl    foo@gottpoff(%ebx), %eax
2733         subl    foo@gottpoff(%ebx), %eax
2734         addl    foo@gotntpoff(%ebx), %eax
2735         movl    foo@indntpoff, %eax
2736         movl    \$foo@tpoff, %eax
2737         subl    \$foo@tpoff, %eax
2738         leal    foo@ntpoff(%ecx), %eax"
2739     ;;
2740   x86_64-*-*)
2741     conftest_s='
2742         .section ".tdata","awT",@progbits
2743 foo:    .long   25
2744         .text
2745         movq    %fs:0, %rax
2746         leaq    foo@TLSGD(%rip), %rdi
2747         leaq    foo@TLSLD(%rip), %rdi
2748         leaq    foo@DTPOFF(%rax), %rdx
2749         movq    foo@GOTTPOFF(%rip), %rax
2750         movq    $foo@TPOFF, %rax'
2751         tls_first_major=2
2752         tls_first_minor=14
2753         tls_as_opt=--fatal-warnings
2754         ;;
2755   ia64-*-*)
2756     conftest_s='
2757         .section ".tdata","awT",@progbits
2758 foo:    data8   25
2759         .text
2760         addl    r16 = @ltoff(@dtpmod(foo#)), gp
2761         addl    r17 = @ltoff(@dtprel(foo#)), gp
2762         addl    r18 = @ltoff(@tprel(foo#)), gp
2763         addl    r19 = @dtprel(foo#), gp
2764         adds    r21 = @dtprel(foo#), r13
2765         movl    r23 = @dtprel(foo#)
2766         addl    r20 = @tprel(foo#), gp
2767         adds    r22 = @tprel(foo#), r13
2768         movl    r24 = @tprel(foo#)'
2769         tls_first_major=2
2770         tls_first_minor=13
2771         tls_as_opt=--fatal-warnings
2772         ;;
2773   mips*-*-*)
2774     conftest_s='
2775         .section .tdata,"awT",@progbits
2776 x:
2777         .word 2
2778         .text
2779         addiu $4, $28, %tlsgd(x)
2780         addiu $4, $28, %tlsldm(x)
2781         lui $4, %dtprel_hi(x)
2782         addiu $4, $4, %dtprel_lo(x)
2783         lw $4, %gottprel(x)($28)
2784         lui $4, %tprel_hi(x)
2785         addiu $4, $4, %tprel_lo(x)'
2786         tls_first_major=2
2787         tls_first_minor=16
2788         tls_as_opt='-32 --fatal-warnings'
2789         ;;
2790   m68k-*-*)
2791     conftest_s='
2792         .section .tdata,"awT",@progbits
2793 x:
2794         .word 2
2795         .text
2796 foo:
2797         move.l x@TLSGD(%a5),%a0
2798         move.l x@TLSLDM(%a5),%a0
2799         move.l x@TLSLDO(%a5),%a0
2800         move.l x@TLSIE(%a5),%a0
2801         move.l x@TLSLE(%a5),%a0'
2802         tls_first_major=2
2803         tls_first_minor=19
2804         tls_as_opt='--fatal-warnings'
2805         ;;
2806   powerpc-*-*)
2807     conftest_s='
2808         .section ".tdata","awT",@progbits
2809         .align 2
2810 ld0:    .space 4
2811 ld1:    .space 4
2812 x1:     .space 4
2813 x2:     .space 4
2814 x3:     .space 4
2815         .text
2816         addi 3,31,ld0@got@tlsgd
2817         bl __tls_get_addr
2818         addi 3,31,x1@got@tlsld
2819         bl __tls_get_addr
2820         addi 9,3,x1@dtprel
2821         addis 9,3,x2@dtprel@ha
2822         addi 9,9,x2@dtprel@l
2823         lwz 9,x3@got@tprel(31)
2824         add 9,9,x@tls
2825         addi 9,2,x1@tprel
2826         addis 9,2,x2@tprel@ha
2827         addi 9,9,x2@tprel@l'
2828         tls_first_major=2
2829         tls_first_minor=14
2830         tls_as_opt="-a32 --fatal-warnings"
2831         ;;
2832   powerpc64-*-*)
2833     conftest_s='
2834         .section ".tdata","awT",@progbits
2835         .align 3
2836 ld0:    .space 8
2837 ld1:    .space 8
2838 x1:     .space 8
2839 x2:     .space 8
2840 x3:     .space 8
2841         .text
2842         addi 3,2,ld0@got@tlsgd
2843         bl .__tls_get_addr
2844         nop
2845         addi 3,2,ld1@toc
2846         bl .__tls_get_addr
2847         nop
2848         addi 3,2,x1@got@tlsld
2849         bl .__tls_get_addr
2850         nop
2851         addi 9,3,x1@dtprel
2852         bl .__tls_get_addr
2853         nop
2854         addis 9,3,x2@dtprel@ha
2855         addi 9,9,x2@dtprel@l
2856         bl .__tls_get_addr
2857         nop
2858         ld 9,x3@got@dtprel(2)
2859         add 9,9,3
2860         bl .__tls_get_addr
2861         nop'
2862         tls_first_major=2
2863         tls_first_minor=14
2864         tls_as_opt="-a64 --fatal-warnings"
2865         ;;
2866   s390-*-*)
2867     conftest_s='
2868         .section ".tdata","awT",@progbits
2869 foo:    .long   25
2870         .text
2871         .long   foo@TLSGD
2872         .long   foo@TLSLDM
2873         .long   foo@DTPOFF
2874         .long   foo@NTPOFF
2875         .long   foo@GOTNTPOFF
2876         .long   foo@INDNTPOFF
2877         l       %r1,foo@GOTNTPOFF(%r12)
2878         l       %r1,0(%r1):tls_load:foo
2879         bas     %r14,0(%r1,%r13):tls_gdcall:foo
2880         bas     %r14,0(%r1,%r13):tls_ldcall:foo'
2881         tls_first_major=2
2882         tls_first_minor=14
2883         tls_as_opt="-m31 --fatal-warnings"
2884         ;;
2885   s390x-*-*)
2886     conftest_s='
2887         .section ".tdata","awT",@progbits
2888 foo:    .long   25
2889         .text
2890         .quad   foo@TLSGD
2891         .quad   foo@TLSLDM
2892         .quad   foo@DTPOFF
2893         .quad   foo@NTPOFF
2894         .quad   foo@GOTNTPOFF
2895         lg      %r1,foo@GOTNTPOFF(%r12)
2896         larl    %r1,foo@INDNTPOFF
2897         brasl   %r14,__tls_get_offset@PLT:tls_gdcall:foo
2898         brasl   %r14,__tls_get_offset@PLT:tls_ldcall:foo'
2899         tls_first_major=2
2900         tls_first_minor=14
2901         tls_as_opt="-m64 -Aesame --fatal-warnings"
2902         ;;
2903   sh-*-* | sh[34]-*-*)
2904     conftest_s='
2905         .section ".tdata","awT",@progbits
2906 foo:    .long   25
2907         .text
2908         .long   foo@TLSGD
2909         .long   foo@TLSLDM
2910         .long   foo@DTPOFF
2911         .long   foo@GOTTPOFF
2912         .long   foo@TPOFF'
2913         tls_first_major=2
2914         tls_first_minor=13
2915         tls_as_opt=--fatal-warnings
2916         ;;
2917   sparc*-*-*)
2918     case "$target" in
2919       sparc*-sun-solaris2.*)
2920         on_solaris=yes
2921         tga_func=__tls_get_addr
2922         ;;
2923       *)
2924         on_solaris=no
2925         ;;
2926     esac
2927     if test x$on_solaris = xyes && test x$gas_flag = xno; then
2928       conftest_s='
2929         .section ".tdata",#alloc,#write,#tls'
2930         tls_first_major=0
2931         tls_first_minor=0
2932     else
2933       conftest_s='
2934         .section ".tdata","awT",@progbits'
2935         tls_first_major=2
2936         tls_first_minor=14
2937         tls_as_opt="-32 --fatal-warnings"
2938     fi
2939     conftest_s="$conftest_s
2940 foo:    .long   25
2941         .text
2942         sethi   %tgd_hi22(foo), %o0
2943         add     %o0, %tgd_lo10(foo), %o1
2944         add     %l7, %o1, %o0, %tgd_add(foo)
2945         call    __tls_get_addr, %tgd_call(foo)
2946         sethi   %tldm_hi22(foo), %l1
2947         add     %l1, %tldm_lo10(foo), %l2
2948         add     %l7, %l2, %o0, %tldm_add(foo)
2949         call    __tls_get_addr, %tldm_call(foo)
2950         sethi   %tldo_hix22(foo), %l3
2951         xor     %l3, %tldo_lox10(foo), %l4
2952         add     %o0, %l4, %l5, %tldo_add(foo)
2953         sethi   %tie_hi22(foo), %o3
2954         add     %o3, %tie_lo10(foo), %o3
2955         ld      [%l7 + %o3], %o2, %tie_ld(foo)
2956         add     %g7, %o2, %o4, %tie_add(foo)
2957         sethi   %tle_hix22(foo), %l1
2958         xor     %l1, %tle_lox10(foo), %o5
2959         ld      [%g7 + %o5], %o1"
2960         ;;
2961   xtensa*-*-*)
2962     conftest_s='
2963         .section ".tdata","awT",@progbits
2964 foo:    .long   25
2965         .text
2966         movi    a8, foo@TLSFUNC
2967         movi    a10, foo@TLSARG
2968         callx8.tls a8, foo@TLSCALL'
2969         tls_first_major=2
2970         tls_first_minor=19
2971         ;;
2972 changequote([,])dnl
2973 esac
2974 set_have_as_tls=no
2975 if test "x$enable_tls" = xno ; then
2976   : # TLS explicitly disabled.
2977 elif test "x$enable_tls" = xyes ; then
2978   set_have_as_tls=yes # TLS explicitly enabled.
2979 elif test -z "$tls_first_major"; then
2980   : # If we don't have a check, assume no support.
2981 else
2982   gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
2983   [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
2984   [set_have_as_tls=yes])
2985 fi
2986 case "$target" in
2987   *-*-irix6*)
2988     # IRIX 6.5 rld and libc.so lack TLS support, so even if gas and gld
2989     # with TLS support are in use, native TLS cannot work.
2990     set_have_as_tls=no
2991     ;;
2992   *-*-osf*)
2993     # Tru64 UNIX loader and libc.so lack TLS support, so even if gas and
2994     # gld with TLS support are in use, native TLS cannot work.
2995     set_have_as_tls=no
2996     ;;
2997   # TLS was introduced in the Solaris 9 FCS release and backported to
2998   # Solaris 8 patches.  Support for GNU-style TLS on x86 was only
2999   # introduced in Solaris 9 4/04, replacing the earlier Sun style that Sun
3000   # ld and GCC don't support any longer.
3001   *-*-solaris2.*)
3002     AC_MSG_CHECKING(linker and ld.so.1 TLS support)
3003     ld_tls_support=no
3004     # Check ld and ld.so.1 TLS support.
3005     if echo "$ld_ver" | grep GNU > /dev/null; then
3006       # Assume all interesting versions of GNU ld have TLS support.
3007       # FIXME: still need ld.so.1 support, i.e. ld version checks below.
3008       ld_tls_support=yes
3009     else
3010       case "$target" in
3011         # Solaris 8/x86 ld has GNU style TLS support since version 1.280.
3012         i?86-*-solaris2.8)
3013           min_tls_ld_vers_minor=280
3014           ;;
3015         # Solaris 8/SPARC ld has TLS support since version 1.272.
3016         sparc*-*-solaris2.8)
3017           min_tls_ld_vers_minor=272
3018           ;;
3019         # Solaris 9/x86 ld has GNU style TLS support since version 1.374.
3020         i?86-*-solaris2.9)
3021           min_tls_ld_vers_minor=374
3022           ;;
3023         # Solaris 9/SPARC and Solaris 10+ ld have TLS support since FCS.
3024         sparc*-*-solaris2.9 | *-*-solaris2.1[[0-9]]*)
3025           min_tls_ld_vers_minor=343
3026           ;;
3027       esac
3028       if test "$ld_vers_major" -gt 1 || \
3029         test "$ld_vers_minor" -ge "$min_tls_ld_vers_minor"; then
3030         ld_tls_support=yes
3031       else
3032         set_have_as_tls=no
3033       fi
3034     fi
3035     AC_MSG_RESULT($ld_tls_support)
3036
3037     save_LIBS="$LIBS"
3038     save_LDFLAGS="$LDFLAGS"
3039     LIBS=
3040     LDFLAGS=
3041
3042     AC_MSG_CHECKING(alternate thread library)
3043     case "$target" in
3044       # TLS support was backported to Solaris 8 patches, but only lives in
3045       # the alternate thread library which became the default in Solaris 9.
3046       # We want to always use that, irrespective of TLS support.
3047       *-*-solaris2.8)
3048         # Take multilib subdir into account.  There's no spec to handle
3049         # this.  The 64 symlink exists since Solaris 8.
3050         lwp_dir=/usr/lib/lwp
3051         lwp_spec="-L$lwp_dir%{m64:/64} -R$lwp_dir%{m64:/64}"
3052         LDFLAGS="-L$lwp_dir -R$lwp_dir"
3053         ;;
3054       *-*-solaris2*)
3055         lwp_dir="none"
3056         lwp_spec=""
3057         ;;
3058     esac
3059     # Always define LIB_THREAD_LDFLAGS_SPEC, even without TLS support.
3060     AC_DEFINE_UNQUOTED(LIB_THREAD_LDFLAGS_SPEC, "$lwp_spec",
3061         [Define to the linker flags to use for -pthread.])
3062     AC_MSG_RESULT($lwp_dir)
3063
3064     AC_MSG_CHECKING(library containing $tga_func)
3065     # Before Solaris 10, __tls_get_addr (SPARC/x64) resp. ___tls_get_addr
3066     # (32-bit x86) only lived in libthread, so check for that.  Keep
3067     # set_have_as_tls if found, disable if not.
3068     AC_SEARCH_LIBS([$tga_func], [thread],, [set_have_as_tls=no])
3069     # Clear LIBS if we cannot support TLS.
3070     if test $set_have_as_tls = no; then
3071       LIBS=
3072     fi
3073     # Always define LIB_TLS_SPEC, even without TLS support.
3074     AC_DEFINE_UNQUOTED(LIB_TLS_SPEC, "$LIBS",
3075         [Define to the library containing __tls_get_addr/___tls_get_addr.])
3076     AC_MSG_RESULT($LIBS)
3077
3078     LIBS="$save_LIBS"
3079     LDFLAGS="$save_LDFLAGS"
3080     ;;
3081 esac
3082 if test $set_have_as_tls = yes ; then
3083   AC_DEFINE(HAVE_AS_TLS, 1,
3084             [Define if your assembler and linker support thread-local storage.])
3085 fi
3086
3087 # Target-specific assembler checks.
3088
3089 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3090 gcc_cv_ld_static_dynamic=no
3091 if test $in_tree_ld = yes ; then
3092   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
3093     gcc_cv_ld_static_dynamic=yes
3094   fi
3095 elif test x$gcc_cv_ld != x; then
3096         # Check if linker supports -Bstatic/-Bdynamic option
3097         if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
3098           && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
3099                 gcc_cv_ld_static_dynamic=yes
3100         fi
3101 fi
3102 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3103         AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3104 [Define if your linker supports -Bstatic/-Bdynamic option.])
3105 fi
3106 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3107
3108 if test x"$demangler_in_ld" = xyes; then
3109   AC_MSG_CHECKING(linker --demangle support)
3110   gcc_cv_ld_demangle=no
3111   if test $in_tree_ld = yes; then
3112     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 \
3113       gcc_cv_ld_demangle=yes
3114     fi
3115   elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3116     # Check if the GNU linker supports --demangle option
3117     if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3118       gcc_cv_ld_demangle=yes
3119     fi
3120   fi
3121   if test x"$gcc_cv_ld_demangle" = xyes; then
3122     AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3123 [Define if your linker supports --demangle option.])
3124   fi
3125   AC_MSG_RESULT($gcc_cv_ld_demangle)
3126 fi
3127
3128 case "$target" in
3129   # All TARGET_ABI_OSF targets.
3130   alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
3131     gcc_GAS_CHECK_FEATURE([explicit relocation support],
3132         gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3133 [       .set nomacro
3134         .text
3135         extbl   $3, $2, $3      !lituse_bytoff!1
3136         ldq     $2, a($29)      !literal!1
3137         ldq     $4, b($29)      !literal!2
3138         ldq_u   $3, 0($2)       !lituse_base!1
3139         ldq     $27, f($29)     !literal!5
3140         jsr     $26, ($27), f   !lituse_jsr!5
3141         ldah    $29, 0($26)     !gpdisp!3
3142         lda     $0, c($29)      !gprel
3143         ldah    $1, d($29)      !gprelhigh
3144         lda     $1, d($1)       !gprellow
3145         lda     $29, 0($29)     !gpdisp!3],,
3146     [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3147   [Define if your assembler supports explicit relocations.])])
3148     gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3149         gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3150 [       .set nomacro
3151         .text
3152         ldq     $27, a($29)     !literal!1
3153         jsr     $26, ($27), a   !lituse_jsrdirect!1],,
3154     [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3155   [Define if your assembler supports the lituse_jsrdirect relocation.])])
3156     ;;
3157
3158   cris-*-*)
3159     gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3160       gcc_cv_as_cris_no_mul_bug,[2,15,91],
3161       [-no-mul-bug-abort], [.text],,
3162       [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3163                 [Define if your assembler supports the -no-mul-bug-abort option.])])
3164     ;;
3165
3166   sparc*-*-*)
3167     gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3168       [.register %g2, #scratch],,
3169       [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3170                 [Define if your assembler supports .register.])])
3171
3172     gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3173       [-relax], [.text],,
3174       [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3175                 [Define if your assembler supports -relax option.])])
3176
3177     gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3178       gcc_cv_as_sparc_gotdata_op,,
3179       [-K PIC],
3180 [.text
3181 foo:
3182         nop
3183 bar:
3184         sethi %gdop_hix22(foo), %g1
3185         xor    %g1, %gdop_lox10(foo), %g1
3186         ld    [[%l7 + %g1]], %g2, %gdop(foo)],
3187       [if test x$gcc_cv_ld != x \
3188        && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3189          if $gcc_cv_ld -v | grep GNU >/dev/null 2>&1; then
3190            if test x$gcc_cv_objdump != x; then
3191              if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3192                 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3193                gcc_cv_as_sparc_gotdata_op=no
3194              else
3195                gcc_cv_as_sparc_gotdata_op=yes
3196              fi
3197            fi
3198          else
3199            gcc_cv_as_sparc_gotdata_op=yes
3200          fi
3201        fi
3202        rm -f conftest],
3203       [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3204                 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3205
3206     gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3207       gcc_cv_as_sparc_ua_pcrel,,
3208       [-K PIC],
3209 [.text
3210 foo:
3211         nop
3212 .data
3213 .align 4
3214 .byte 0
3215 .uaword %r_disp32(foo)],
3216       [if test x$gcc_cv_ld != x \
3217        && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3218          gcc_cv_as_sparc_ua_pcrel=yes
3219        fi
3220        rm -f conftest],
3221       [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3222                 [Define if your assembler and linker support unaligned PC relative relocs.])
3223
3224       gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3225         gcc_cv_as_sparc_ua_pcrel_hidden,,
3226         [-K PIC],
3227 [.data
3228 .align 4
3229 .byte 0x31
3230 .uaword %r_disp32(foo)
3231 .byte 0x32, 0x33, 0x34
3232 .global foo
3233 .hidden foo
3234 foo:
3235 .skip 4],
3236         [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3237          && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3238          && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3239             | grep ' 31000000 07323334' > /dev/null 2>&1; then
3240             if $gcc_cv_objdump -R conftest 2> /dev/null \
3241                | grep 'DISP32' > /dev/null 2>&1; then
3242                 :
3243             else
3244                 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3245             fi
3246          fi
3247          rm -f conftest],
3248          [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3249                    [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3250     ]) # unaligned pcrel relocs
3251
3252     gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3253       gcc_cv_as_sparc_offsetable_lo10,,
3254       [-xarch=v9],
3255 [.text
3256         or %g1, %lo(ab) + 12, %g1
3257         or %g1, %lo(ab + 12), %g1],
3258       [if test x$gcc_cv_objdump != x \
3259        && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3260           | grep ' 82106000 82106000' > /dev/null 2>&1; then
3261          gcc_cv_as_sparc_offsetable_lo10=yes
3262        fi],
3263        [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3264                  [Define if your assembler supports offsetable %lo().])])
3265     ;;
3266
3267 changequote(,)dnl
3268   i[34567]86-*-* | x86_64-*-*)
3269 changequote([,])dnl
3270     case $target_os in
3271       cygwin*)
3272         # Full C++ conformance when using a shared libstdc++-v3 requires some
3273         # support from the Cygwin DLL, which in more recent versions exports
3274         # wrappers to aid in interposing and redirecting operators new, delete,
3275         # etc., as per n2800 #17.6.4.6 [replacement.functions].  Check if we
3276         # are configuring for a version of Cygwin that exports the wrappers.
3277         if test x$host = x$target; then
3278           AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3279         else
3280           # Can't check presence of libc functions during cross-compile, so
3281           # we just have to assume we're building for an up-to-date target.
3282           gcc_ac_cygwin_dll_wrappers=yes
3283         fi
3284         AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3285           [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3286           [Define if you want to generate code by default that assumes that the
3287            Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3288     esac
3289     case $target_os in
3290       cygwin* | pe | mingw32*)
3291         # Recent binutils allows the three-operand form of ".comm" on PE.  This
3292         # definition is used unconditionally to initialise the default state of
3293         # the target option variable that governs usage of the feature.
3294         gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3295          [2,19,52],,[.comm foo,1,32])
3296         AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3297           [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3298           [Define if your assembler supports specifying the alignment
3299            of objects allocated using the GAS .comm command.])
3300         # Used for DWARF 2 in PE
3301         gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3302           gcc_cv_as_ix86_pe_secrel32,
3303           [2,15,91],,
3304 [.text
3305 foo:    nop
3306 .data
3307         .secrel32 foo],
3308           [if test x$gcc_cv_ld != x \
3309            && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3310              gcc_cv_as_ix86_pe_secrel32=yes
3311            fi
3312            rm -f conftest],
3313           [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3314             [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3315         # Test if the assembler supports the extended form of the .section
3316         # directive that specifies section alignment.  LTO support uses this,
3317         # but normally only after installation, so we warn but don't fail the
3318         # configure if LTO is enabled but the assembler does not support it.
3319         gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3320           [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3321         if test x$gcc_cv_as_section_has_align != xyes; then
3322           case ",$enable_languages," in
3323             *,lto,*)
3324               AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3325               ;;
3326           esac
3327         fi
3328         ;;
3329     esac
3330
3331     gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3332        gcc_cv_as_ix86_filds,,,
3333        [filds mem; fists mem],,
3334        [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3335          [Define if your assembler uses filds and fists mnemonics.])])
3336
3337     gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3338        gcc_cv_as_ix86_fildq,,,
3339        [fildq mem; fistpq mem],,
3340        [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3341          [Define if your assembler uses fildq and fistq mnemonics.])])
3342
3343     gcc_GAS_CHECK_FEATURE([cmov syntax],
3344       gcc_cv_as_ix86_cmov_sun_syntax,,,
3345       [cmovl.l %edx, %eax],,
3346       [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3347         [Define if your assembler supports the Sun syntax for cmov.])])
3348
3349     gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3350       gcc_cv_as_ix86_ffreep,,,
3351       [ffreep %st(1)],,
3352       [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3353         [Define if your assembler supports the ffreep mnemonic.])])
3354
3355     gcc_GAS_CHECK_FEATURE([.quad directive],
3356       gcc_cv_as_ix86_quad,,,
3357       [.quad 0],,
3358       [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
3359         [Define if your assembler supports the .quad directive.])])
3360
3361     gcc_GAS_CHECK_FEATURE([sahf mnemonic],
3362       gcc_cv_as_ix86_sahf,,,
3363       [.code64
3364        sahf],,
3365       [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
3366         [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
3367
3368     gcc_GAS_CHECK_FEATURE([swap suffix],
3369       gcc_cv_as_ix86_swap,,,
3370       [movl.s %esp, %ebp],,
3371       [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
3372         [Define if your assembler supports the swap suffix.])])
3373
3374     gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
3375       gcc_cv_as_ix86_diff_sect_delta,,,
3376       [.section .rodata
3377 .L1:
3378         .long .L2-.L1
3379         .long .L3-.L1
3380         .text
3381 .L3:    nop
3382 .L2:    nop],,
3383       [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
3384         [Define if your assembler supports the subtraction of symbols in different sections.])])
3385
3386     # These two are used unconditionally by i386.[ch]; it is to be defined
3387     # to 1 if the feature is present, 0 otherwise.
3388     gcc_GAS_CHECK_FEATURE([GOTOFF in data],
3389         gcc_cv_as_ix86_gotoff_in_data, [2,11,0],,
3390 [       .text
3391 .L0:
3392         nop
3393         .data
3394         .long .L0@GOTOFF])
3395     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
3396       [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
3397       [Define true if the assembler supports '.long foo@GOTOFF'.])
3398
3399     gcc_GAS_CHECK_FEATURE([rep and lock prefix],
3400         gcc_cv_as_ix86_rep_lock_prefix,,,
3401         [rep movsl
3402          lock addl %edi, (%eax,%esi)
3403          lock orl $0, (%esp)],,
3404         [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
3405           [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
3406
3407     ;;
3408
3409   ia64*-*-*)
3410     gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
3411         gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
3412 [       .text
3413         addl r15 = @ltoffx(x#), gp
3414         ;;
3415         ld8.mov r16 = [[r15]], x#],,
3416     [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
3417           [Define if your assembler supports ltoffx and ldxmov relocations.])])
3418
3419     ;;
3420
3421   powerpc*-*-*)
3422     case $target in
3423       *-*-aix*) conftest_s='    .machine "pwr5"
3424         .csect .text[[PR]]
3425         mfcr 3,128';;
3426       *-*-darwin*)
3427         gcc_GAS_CHECK_FEATURE([.machine directive support],
3428           gcc_cv_as_machine_directive,,,
3429           [     .machine ppc7400])
3430         if test x$gcc_cv_as_machine_directive != xyes; then
3431           echo "*** This target requires an assembler supporting \".machine\"" >&2
3432           echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
3433           test x$build = x$target && exit 1
3434         fi
3435         conftest_s='    .text
3436         mfcr r3,128';;
3437       *) conftest_s='   .machine power4
3438         .text
3439         mfcr 3,128';;
3440     esac
3441
3442     gcc_GAS_CHECK_FEATURE([mfcr field support],
3443       gcc_cv_as_powerpc_mfcrf, [2,14,0],,
3444       [$conftest_s],,
3445       [AC_DEFINE(HAVE_AS_MFCRF, 1,
3446           [Define if your assembler supports mfcr field.])])
3447
3448     case $target in
3449       *-*-aix*) conftest_s='    .machine "pwr5"
3450         .csect .text[[PR]]
3451         popcntb 3,3';;
3452       *) conftest_s='   .machine power5
3453         .text
3454         popcntb 3,3';;
3455     esac
3456
3457     gcc_GAS_CHECK_FEATURE([popcntb support],
3458       gcc_cv_as_powerpc_popcntb, [2,17,0],,
3459       [$conftest_s],,
3460       [AC_DEFINE(HAVE_AS_POPCNTB, 1,
3461           [Define if your assembler supports popcntb field.])])
3462
3463     case $target in
3464       *-*-aix*) conftest_s='    .machine "pwr5x"
3465         .csect .text[[PR]]
3466         frin 1,1';;
3467       *) conftest_s='   .machine power5
3468         .text
3469         frin 1,1';;
3470     esac
3471
3472     gcc_GAS_CHECK_FEATURE([fp round support],
3473       gcc_cv_as_powerpc_fprnd, [2,17,0],,
3474       [$conftest_s],,
3475       [AC_DEFINE(HAVE_AS_FPRND, 1,
3476           [Define if your assembler supports fprnd.])])
3477
3478     case $target in
3479       *-*-aix*) conftest_s='    .machine "pwr6"
3480         .csect .text[[PR]]
3481         mffgpr 1,3';;
3482       *) conftest_s='   .machine power6
3483         .text
3484         mffgpr 1,3';;
3485     esac
3486
3487     gcc_GAS_CHECK_FEATURE([move fp gpr support],
3488       gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
3489       [$conftest_s],,
3490       [AC_DEFINE(HAVE_AS_MFPGPR, 1,
3491           [Define if your assembler supports mffgpr and mftgpr.])])
3492
3493     case $target in
3494       *-*-aix*) conftest_s='    .csect .text[[PR]]
3495 LCF..0:
3496         addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
3497       *-*-darwin*)
3498         conftest_s='    .text
3499 LCF0:
3500         addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
3501       *) conftest_s='   .text
3502 .LCF0:
3503         addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
3504     esac
3505
3506     gcc_GAS_CHECK_FEATURE([rel16 relocs],
3507       gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
3508       [$conftest_s],,
3509       [AC_DEFINE(HAVE_AS_REL16, 1,
3510           [Define if your assembler supports R_PPC_REL16 relocs.])])
3511
3512     case $target in
3513       *-*-aix*) conftest_s='    .machine "pwr6"
3514         .csect .text[[PR]]
3515         cmpb 3,4,5';;
3516       *) conftest_s='   .machine power6
3517         .text
3518         cmpb 3,4,5';;
3519     esac
3520
3521     gcc_GAS_CHECK_FEATURE([compare bytes support],
3522       gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
3523       [$conftest_s],,
3524       [AC_DEFINE(HAVE_AS_CMPB, 1,
3525           [Define if your assembler supports cmpb.])])
3526
3527     case $target in
3528       *-*-aix*) conftest_s='    .machine "pwr6"
3529         .csect .text[[PR]]
3530         dadd 1,2,3';;
3531       *) conftest_s='   .machine power6
3532         .text
3533         dadd 1,2,3';;
3534     esac
3535
3536     gcc_GAS_CHECK_FEATURE([decimal float support],
3537       gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
3538       [$conftest_s],,
3539       [AC_DEFINE(HAVE_AS_DFP, 1,
3540           [Define if your assembler supports DFP instructions.])])
3541
3542     case $target in
3543       *-*-aix*) conftest_s='    .machine "pwr7"
3544         .csect .text[[PR]]
3545         lxvd2x 1,2,3';;
3546       *) conftest_s='   .machine power7
3547         .text
3548         lxvd2x 1,2,3';;
3549     esac
3550
3551     gcc_GAS_CHECK_FEATURE([vector-scalar support],
3552       gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
3553       [$conftest_s],,
3554       [AC_DEFINE(HAVE_AS_VSX, 1,
3555           [Define if your assembler supports VSX instructions.])])
3556
3557     case $target in
3558       *-*-aix*) conftest_s='    .machine "pwr7"
3559         .csect .text[[PR]]
3560         popcntd 3,3';;
3561       *) conftest_s='   .machine power7
3562         .text
3563         popcntd 3,3';;
3564     esac
3565
3566     gcc_GAS_CHECK_FEATURE([popcntd support],
3567       gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
3568       [$conftest_s],,
3569       [AC_DEFINE(HAVE_AS_POPCNTD, 1,
3570           [Define if your assembler supports POPCNTD instructions.])])
3571
3572     case $target in
3573       *-*-aix*) conftest_s='    .csect .text[[PR]]
3574         lwsync';;
3575       *) conftest_s='   .text
3576         lwsync';;
3577     esac
3578
3579     gcc_GAS_CHECK_FEATURE([lwsync support],
3580       gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
3581       [$conftest_s],,
3582       [AC_DEFINE(HAVE_AS_LWSYNC, 1,
3583           [Define if your assembler supports LWSYNC instructions.])])
3584
3585     case $target in
3586       *-*-aix*) conftest_s='    .machine "476"
3587         .csect .text[[PR]]
3588         dci 0';;
3589       *) conftest_s='   .machine "476"
3590         .text
3591         dci 0';;
3592     esac
3593
3594     gcc_GAS_CHECK_FEATURE([data cache invalidate support],
3595       gcc_cv_as_powerpc_dci, [9,99,0], -a32,
3596       [$conftest_s],,
3597       [AC_DEFINE(HAVE_AS_DCI, 1,
3598           [Define if your assembler supports the DCI/ICI instructions.])])
3599
3600     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3601       gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
3602       [.gnu_attribute 4,1],,
3603       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3604           [Define if your assembler supports .gnu_attribute.])])
3605
3606     gcc_GAS_CHECK_FEATURE([tls marker support],
3607       gcc_cv_as_powerpc_tls_markers, [2,20,0],,
3608       [ bl __tls_get_addr(x@tlsgd)],,
3609       [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
3610           [Define if your assembler supports arg info for __tls_get_addr.])])
3611
3612     case $target in
3613       *-*-aix*)
3614         gcc_GAS_CHECK_FEATURE([.ref support],
3615           gcc_cv_as_aix_ref, [2.21.0],,
3616           [     .csect stuff[[rw]]
3617              stuff:
3618                 .long 1
3619                 .extern sym
3620                 .ref sym
3621           ],,
3622           [AC_DEFINE(HAVE_AS_REF, 1,
3623             [Define if your assembler supports .ref])])
3624         ;;
3625     esac
3626     ;;
3627
3628   mips*-*-*)
3629     gcc_GAS_CHECK_FEATURE([explicit relocation support],
3630       gcc_cv_as_mips_explicit_relocs, [2,14,0],,
3631 [       lw $4,%gp_rel(foo)($4)],,
3632       [if test x$target_cpu_default = x
3633        then target_cpu_default=MASK_EXPLICIT_RELOCS
3634        else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
3635        fi])
3636     gcc_GAS_CHECK_FEATURE([-mno-shared support],
3637       gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
3638       [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
3639                  [Define if the assembler understands -mno-shared.])])
3640
3641     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3642       gcc_cv_as_mips_gnu_attribute, [2,18,0],,
3643       [.gnu_attribute 4,1],,
3644       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3645           [Define if your assembler supports .gnu_attribute.])])
3646
3647     gcc_GAS_CHECK_FEATURE([.dtprelword support],
3648       gcc_cv_as_mips_dtprelword, [2,18,0],,
3649       [.section .tdata,"awT",@progbits
3650 x:
3651         .word 2
3652         .text
3653         .dtprelword x+0x8000],,
3654       [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
3655           [Define if your assembler supports .dtprelword.])])
3656
3657     gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
3658       gcc_cv_as_mips_dspr1_mult,,,
3659 [       .set    mips32r2
3660         .set    nodspr2
3661         .set    dsp
3662         madd    $ac3,$4,$5
3663         maddu   $ac3,$4,$5
3664         msub    $ac3,$4,$5
3665         msubu   $ac3,$4,$5
3666         mult    $ac3,$4,$5
3667         multu   $ac3,$4,$5],,
3668       [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
3669           [Define if your assembler supports DSPR1 mult.])])
3670
3671     AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
3672     gcc_cv_as_ld_jalr_reloc=no
3673     if test $gcc_cv_as_mips_explicit_relocs = yes; then
3674       if test $in_tree_ld = yes ; then
3675         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 \
3676            && test $in_tree_ld_is_elf = yes; then
3677           gcc_cv_as_ld_jalr_reloc=yes
3678         fi
3679       elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
3680         echo '  .ent x' > conftest.s
3681         echo 'x:        ld $2,%got_disp(y)($3)' >> conftest.s
3682         echo '  ld $25,%call16(y)($28)' >> conftest.s
3683         echo '  .reloc  1f,R_MIPS_JALR,y' >> conftest.s
3684         echo '1:        jalr $25' >> conftest.s
3685         echo '  .reloc  1f,R_MIPS_JALR,x' >> conftest.s
3686         echo '1:        jalr $25' >> conftest.s
3687         echo '  .end x' >> conftest.s
3688         if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
3689            && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
3690           if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
3691              && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
3692             gcc_cv_as_ld_jalr_reloc=yes
3693           fi
3694         fi
3695         rm -f conftest.*
3696       fi
3697     fi
3698     if test $gcc_cv_as_ld_jalr_reloc = yes; then
3699       if test x$target_cpu_default = x; then
3700         target_cpu_default=MASK_RELAX_PIC_CALLS
3701       else
3702         target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
3703       fi
3704     fi
3705     AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
3706
3707     AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
3708       [gcc_cv_ld_mips_personality_relaxation],
3709       [gcc_cv_ld_mips_personality_relaxation=no
3710        if test $in_tree_ld = yes ; then
3711          if test "$gcc_cv_gld_major_version" -eq 2 \
3712                  -a "$gcc_cv_gld_minor_version" -ge 21 \
3713                  -o "$gcc_cv_gld_major_version" -gt 2; then
3714            gcc_cv_ld_mips_personality_relaxation=yes
3715          fi
3716        elif test x$gcc_cv_as != x \
3717                  -a x$gcc_cv_ld != x \
3718                  -a x$gcc_cv_readelf != x ; then
3719          cat > conftest.s <<EOF
3720         .cfi_startproc
3721         .cfi_personality 0x80,indirect_ptr
3722         .ent test
3723 test:
3724         nop
3725         .end test
3726         .cfi_endproc
3727
3728         .section .data,"aw",@progbits
3729 indirect_ptr:
3730         .dc.a personality
3731 EOF
3732          if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
3733             && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
3734            if $gcc_cv_readelf -d conftest 2>&1 \
3735               | grep TEXTREL > /dev/null 2>&1; then
3736              :
3737            elif $gcc_cv_readelf --relocs conftest 2>&1 \
3738                 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
3739              :
3740            else
3741              gcc_cv_ld_mips_personality_relaxation=yes
3742            fi
3743          fi
3744        fi
3745        rm -f conftest.s conftest.o conftest])
3746     if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
3747             AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
3748       [Define if your linker can relax absolute .eh_frame personality
3749 pointers into PC-relative form.])
3750     fi
3751     ;;
3752 esac
3753
3754 # Mips and HP-UX need the GNU assembler.
3755 # Linux on IA64 might be able to use the Intel assembler.
3756
3757 case "$target" in
3758   mips*-*-* | *-*-hpux* )
3759     if test x$gas_flag = xyes \
3760        || test x"$host" != x"$build" \
3761        || test ! -x "$gcc_cv_as" \
3762        || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
3763       :
3764     else
3765       echo "*** This configuration requires the GNU assembler" >&2
3766       exit 1
3767     fi
3768     ;;
3769 esac
3770
3771 # ??? Not all targets support dwarf2 debug_line, even within a version
3772 # of gas.  Moreover, we need to emit a valid instruction to trigger any
3773 # info to the output file.  So, as supported targets are added to gas 2.11,
3774 # add some instruction here to (also) show we expect this might work.
3775 # ??? Once 2.11 is released, probably need to add first known working
3776 # version to the per-target configury.
3777 case "$cpu_type" in
3778   alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze | mips \
3779   | pa | rs6000 | score | sparc | spu | xstormy16 | xtensa)
3780     insn="nop"
3781     ;;
3782   ia64 | s390)
3783     insn="nop 0"
3784     ;;
3785   mmix)
3786     insn="swym 0"
3787     ;;
3788 esac
3789 if test x"$insn" != x; then
3790  conftest_s="\
3791         .file 1 \"conftest.s\"
3792         .loc 1 3 0
3793         $insn"
3794  gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
3795   gcc_cv_as_dwarf2_debug_line,
3796   [elf,2,11,0],, [$conftest_s],
3797   [if test x$gcc_cv_objdump != x \
3798    && $gcc_cv_objdump -h conftest.o 2> /dev/null \
3799       | grep debug_line > /dev/null 2>&1; then
3800      gcc_cv_as_dwarf2_debug_line=yes
3801    fi])
3802
3803 # The .debug_line file table must be in the exact order that
3804 # we specified the files, since these indices are also used
3805 # by DW_AT_decl_file.  Approximate this test by testing if
3806 # the assembler bitches if the same index is assigned twice.
3807  gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
3808   gcc_cv_as_dwarf2_file_buggy,,,
3809 [       .file 1 "foo.s"
3810         .file 1 "bar.s"])
3811
3812  if test $gcc_cv_as_dwarf2_debug_line = yes \
3813  && test $gcc_cv_as_dwarf2_file_buggy = no; then
3814         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
3815   [Define if your assembler supports dwarf2 .file/.loc directives,
3816    and preserves file table indices exactly as given.])
3817  fi
3818
3819  gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
3820   gcc_cv_as_gdwarf2_flag,
3821   [elf,2,11,0], [--gdwarf2], [$insn],,
3822   [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
3823 [Define if your assembler supports the --gdwarf2 option.])])
3824
3825  gcc_GAS_CHECK_FEATURE([--gstabs option],
3826   gcc_cv_as_gstabs_flag,
3827   [elf,2,11,0], [--gstabs], [$insn],
3828   [# The native Solaris 9/Intel assembler doesn't understand --gstabs
3829    # and warns about it, but still exits successfully.  So check for
3830    # this.
3831    if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
3832    then :
3833    else gcc_cv_as_gstabs_flag=yes
3834    fi],
3835   [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
3836 [Define if your assembler supports the --gstabs option.])])
3837
3838  gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
3839   gcc_cv_as_debug_prefix_map_flag,
3840   [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
3841   [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
3842 [Define if your assembler supports the --debug-prefix-map option.])])
3843 fi
3844
3845 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
3846  ,,
3847 [.lcomm bar,4,16],,
3848 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
3849   [Define if your assembler supports .lcomm with an alignment field.])])
3850
3851 AC_ARG_ENABLE(gnu-unique-object,
3852  [  --enable-gnu-unique-object  enable the use of the @gnu_unique_object ELF extension on
3853                                 glibc systems],
3854  [case $enable_gnu_unique_object in
3855     yes | no) ;;
3856     *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
3857 Valid choices are 'yes' and 'no'.]) ;;
3858   esac],
3859  [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
3860    [elf,2,19,52],,
3861    [.type foo, @gnu_unique_object],,
3862 # Also check for ld.so support, i.e. glibc 2.11 or higher.
3863    [[if test x$host = x$build -a x$host = x$target &&
3864        glibcver=`ldd --version 2>/dev/null | sed 's/.* //;q'`; then
3865       glibcmajor=`expr "$glibcver" : "\([0-9]*\)"`
3866       glibcminor=`expr "$glibcver" : "[2-9]*\.\([0-9]*\)"`
3867       glibcnum=`expr $glibcmajor \* 1000 + $glibcminor`
3868       if test "$glibcnum" -ge 2011 ; then
3869         enable_gnu_unique_object=yes
3870       fi
3871     fi]])])
3872 if test x$enable_gnu_unique_object = xyes; then
3873   AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
3874    [Define if your assembler supports @gnu_unique_object.])
3875 fi
3876
3877 AC_CACHE_CHECK([assembler for tolerance to line number 0],
3878  [gcc_cv_as_line_zero],
3879  [gcc_cv_as_line_zero=no
3880   if test $in_tree_gas = yes; then
3881     gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
3882   elif test "x$gcc_cv_as" != x; then
3883     { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
3884     if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
3885        test "x`cat conftest.out`" = x
3886     then
3887       gcc_cv_as_line_zero=yes
3888     else
3889       echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
3890       cat conftest.s >&AS_MESSAGE_LOG_FD
3891       echo "configure: error output was" >&AS_MESSAGE_LOG_FD
3892       cat conftest.out >&AS_MESSAGE_LOG_FD
3893     fi
3894     rm -f conftest.o conftest.s conftest.out
3895   fi])
3896 if test "x$gcc_cv_as_line_zero" = xyes; then
3897   AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
3898 [Define if the assembler won't complain about a line such as # 0 "" 2.])
3899 fi
3900
3901 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
3902 gcc_cv_ld_eh_frame_hdr=no
3903 if test $in_tree_ld = yes ; then
3904   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 \
3905      && test $in_tree_ld_is_elf = yes; then
3906     gcc_cv_ld_eh_frame_hdr=yes
3907   fi
3908 elif test x$gcc_cv_ld != x; then
3909         # Check if linker supports --eh-frame-hdr option
3910         if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
3911                 gcc_cv_ld_eh_frame_hdr=yes
3912         fi
3913 fi
3914 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
3915 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
3916         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
3917 [Define if your linker supports --eh-frame-hdr option.])
3918 fi
3919 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
3920
3921 AC_MSG_CHECKING(linker position independent executable support)
3922 gcc_cv_ld_pie=no
3923 if test $in_tree_ld = yes ; then
3924   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 \
3925      && test $in_tree_ld_is_elf = yes; then
3926     gcc_cv_ld_pie=yes
3927   fi
3928 elif test x$gcc_cv_ld != x; then
3929         # Check if linker supports -pie option
3930         if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
3931                 gcc_cv_ld_pie=yes
3932         fi
3933 fi
3934 if test x"$gcc_cv_ld_pie" = xyes; then
3935         AC_DEFINE(HAVE_LD_PIE, 1,
3936 [Define if your linker supports -pie option.])
3937 fi
3938 AC_MSG_RESULT($gcc_cv_ld_pie)
3939
3940 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
3941 gcc_cv_ld_eh_gc_sections=no
3942 if test $in_tree_ld = yes ; then
3943   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 \
3944      && test $in_tree_ld_is_elf = yes; then
3945     gcc_cv_ld_eh_gc_sections=yes
3946   fi
3947 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
3948   cat > conftest.s <<EOF
3949         .section        .text
3950 .globl _start
3951         .type _start, @function
3952 _start:
3953         .long foo
3954         .size _start, .-_start
3955         .section        .text.foo,"ax",@progbits
3956         .type foo, @function
3957 foo:
3958         .long 0
3959         .size foo, .-foo
3960         .section        .gcc_except_table.foo,"a",@progbits
3961 .L0:
3962         .long 0
3963         .section        .eh_frame,"a",@progbits
3964         .long .L0
3965 EOF
3966   if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
3967     if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
3968          | grep "gc-sections option ignored" > /dev/null; then
3969       gcc_cv_ld_eh_gc_sections=no
3970     elif $gcc_cv_objdump -h conftest 2> /dev/null \
3971          | grep gcc_except_table > /dev/null; then
3972       gcc_cv_ld_eh_gc_sections=yes
3973       # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
3974       if test x$gcc_cv_as_comdat_group != xyes; then
3975         gcc_cv_ld_eh_gc_sections=no
3976         cat > conftest.s <<EOF
3977         .section        .text
3978 .globl _start
3979         .type _start, @function
3980 _start:
3981         .long foo
3982         .size _start, .-_start
3983         .section        .gnu.linkonce.t.foo,"ax",@progbits
3984         .type foo, @function
3985 foo:
3986         .long 0
3987         .size foo, .-foo
3988         .section        .gcc_except_table.foo,"a",@progbits
3989 .L0:
3990         .long 0
3991         .section        .eh_frame,"a",@progbits
3992         .long .L0
3993 EOF
3994         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
3995           if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
3996                | grep "gc-sections option ignored" > /dev/null; then
3997             gcc_cv_ld_eh_gc_sections=no
3998           elif $gcc_cv_objdump -h conftest 2> /dev/null \
3999                | grep gcc_except_table > /dev/null; then
4000             gcc_cv_ld_eh_gc_sections=yes
4001           fi
4002         fi
4003       fi
4004     fi
4005   fi
4006   rm -f conftest.s conftest.o conftest
4007 fi
4008 case "$target" in
4009   hppa*-*-linux*)
4010     # ??? This apparently exposes a binutils bug with PC-relative relocations.
4011     gcc_cv_ld_eh_gc_sections=no
4012     ;;
4013 esac
4014 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
4015         AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
4016   [Define if your linker supports garbage collection of
4017    sections in presence of EH frames.])
4018 fi
4019 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
4020
4021 # --------
4022 # UNSORTED
4023 # --------
4024
4025 AC_CACHE_CHECK(linker --as-needed support,
4026 gcc_cv_ld_as_needed,
4027 [gcc_cv_ld_as_needed=no
4028 if test $in_tree_ld = yes ; then
4029   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 \
4030      && test $in_tree_ld_is_elf = yes; then
4031     gcc_cv_ld_as_needed=yes
4032   fi
4033 elif test x$gcc_cv_ld != x; then
4034         # Check if linker supports --as-needed and --no-as-needed options
4035         if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
4036                 gcc_cv_ld_as_needed=yes
4037         fi
4038 fi
4039 ])
4040 if test x"$gcc_cv_ld_as_needed" = xyes; then
4041         AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
4042 [Define if your linker supports --as-needed and --no-as-needed options.])
4043 fi
4044
4045 case "$target:$tm_file" in
4046   powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
4047     AC_CACHE_CHECK(linker support for omitting dot symbols,
4048     gcc_cv_ld_no_dot_syms,
4049     [gcc_cv_ld_no_dot_syms=no
4050     if test $in_tree_ld = yes ; then
4051       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
4052         gcc_cv_ld_no_dot_syms=yes
4053       fi
4054     elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4055       cat > conftest1.s <<EOF
4056         .text
4057         bl .foo
4058 EOF
4059       cat > conftest2.s <<EOF
4060         .section ".opd","aw"
4061         .align 3
4062         .globl foo
4063         .type foo,@function
4064 foo:
4065         .quad .LEfoo,.TOC.@tocbase,0
4066         .text
4067 .LEfoo:
4068         blr
4069         .size foo,.-.LEfoo
4070 EOF
4071       if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4072          && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4073          && $gcc_cv_ld -melf64ppc -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
4074         gcc_cv_ld_no_dot_syms=yes
4075       fi
4076       rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
4077     fi
4078     ])
4079     if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
4080       AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
4081     [Define if your PowerPC64 linker only needs function descriptor syms.])
4082     fi
4083
4084     AC_CACHE_CHECK(linker large toc support,
4085     gcc_cv_ld_large_toc,
4086     [gcc_cv_ld_large_toc=no
4087     if test $in_tree_ld = yes ; then
4088       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
4089         gcc_cv_ld_large_toc=yes
4090       fi
4091     elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4092       cat > conftest.s <<EOF
4093         .section ".tbss","awT",@nobits
4094         .align 3
4095 ie0:    .space 8
4096         .global _start
4097         .text
4098 _start:
4099         addis 9,13,ie0@got@tprel@ha
4100         ld 9,ie0@got@tprel@l(9)
4101 EOF
4102       if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
4103          && $gcc_cv_ld -melf64ppc --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
4104         gcc_cv_ld_large_toc=yes
4105       fi
4106       rm -f conftest conftest.o conftest.s
4107     fi
4108     ])
4109     if test x"$gcc_cv_ld_large_toc" = xyes; then
4110       AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4111     [Define if your PowerPC64 linker supports a large TOC.])
4112     fi
4113     ;;
4114 esac
4115
4116 AC_CACHE_CHECK(linker --build-id support,
4117   gcc_cv_ld_buildid,
4118   [gcc_cv_ld_buildid=no
4119   if test $in_tree_ld = yes ; then
4120     if test "$gcc_cv_gld_major_version" -eq 2 -a \
4121        "$gcc_cv_gld_minor_version" -ge 18 -o \
4122        "$gcc_cv_gld_major_version" -gt 2 \
4123        && test $in_tree_ld_is_elf = yes; then
4124       gcc_cv_ld_buildid=yes
4125     fi
4126   elif test x$gcc_cv_ld != x; then
4127     if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
4128       gcc_cv_ld_buildid=yes
4129     fi
4130   fi])
4131 if test x"$gcc_cv_ld_buildid" = xyes; then
4132   AC_DEFINE(HAVE_LD_BUILDID, 1,
4133   [Define if your linker supports --build-id.])
4134 fi
4135
4136 AC_ARG_ENABLE(linker-build-id,
4137 [  --enable-linker-build-id
4138                           compiler will always pass --build-id to linker],
4139 [],
4140 enable_linker_build_id=no)
4141
4142 if test x"$enable_linker_build_id" = xyes; then
4143   if test x"$gcc_cv_ld_buildid" = xyes; then
4144     AC_DEFINE(ENABLE_LD_BUILDID, 1,
4145     [Define if gcc should always pass --build-id to linker.])
4146   else
4147     AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
4148   fi
4149 fi
4150
4151 # In binutils 2.21, GNU ld gained support for new emulations fully
4152 # supporting the Solaris 2 ABI.  Detect their presence in the linker used.
4153 AC_CACHE_CHECK(linker *_sol2 emulation support,
4154   gcc_cv_ld_sol2_emulation,
4155   [gcc_cv_ld_sol2_emulation=no
4156   if test $in_tree_ld = yes ; then
4157     if test "$gcc_cv_gld_major_version" -eq 2 -a \
4158        "$gcc_cv_gld_minor_version" -ge 21 -o \
4159        "$gcc_cv_gld_major_version" -gt 2 \
4160        && test $in_tree_ld_is_elf = yes; then
4161       gcc_cv_ld_sol2_emulation=yes
4162     fi
4163   elif test x$gcc_cv_ld != x; then
4164     if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
4165        grep _sol2 > /dev/null; then
4166       gcc_cv_ld_sol2_emulation=yes
4167     fi
4168   fi])
4169 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
4170   AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
4171   [Define if your linker supports the *_sol2 emulations.])
4172 fi
4173
4174 AC_CACHE_CHECK(linker --sysroot support,
4175   gcc_cv_ld_sysroot,
4176   [gcc_cv_ld_sysroot=no
4177   if test $in_tree_ld = yes ; then
4178       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
4179         gcc_cv_ld_sysroot=yes
4180       fi
4181   elif test x$gcc_cv_ld != x; then
4182     if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
4183       gcc_cv_ld_sysroot=yes
4184     fi
4185   fi])
4186 if test x"$gcc_cv_ld_sysroot" = xyes; then
4187   AC_DEFINE(HAVE_LD_SYSROOT, 1,
4188   [Define if your linker supports --sysroot.])
4189 fi
4190
4191 if test x$with_sysroot = x && test x$host = x$target \
4192    && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4193    && test "$prefix" != "NONE"; then
4194   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4195 [Define to PREFIX/include if cpp should also search that directory.])
4196 fi
4197
4198 # Test for stack protector support in target C library.
4199 AC_CACHE_CHECK(__stack_chk_fail in target C library,
4200       gcc_cv_libc_provides_ssp,
4201       [gcc_cv_libc_provides_ssp=no
4202     case "$target" in
4203        *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
4204       if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4205         if test "x$with_headers" != x; then
4206           glibc_header_dir=$with_headers
4207         elif test "x$with_sysroot" = x; then
4208           glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-include"
4209         elif test "x$with_build_sysroot" != "x"; then
4210           glibc_header_dir="${with_build_sysroot}/usr/include"
4211         elif test "x$with_sysroot" = xyes; then
4212           glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-root/usr/include"
4213         else
4214           glibc_header_dir="${with_sysroot}/usr/include"
4215         fi
4216       else
4217         glibc_header_dir=/usr/include
4218       fi
4219       [# glibc 2.4 and later provides __stack_chk_fail and
4220       # either __stack_chk_guard, or TLS access to stack guard canary.
4221       if test -f $glibc_header_dir/features.h \
4222          && $EGREP '^[  ]*#[    ]*define[       ]+__GNU_LIBRARY__[      ]+([1-9][0-9]|[6-9])' \
4223             $glibc_header_dir/features.h > /dev/null; then
4224         if $EGREP '^[   ]*#[    ]*define[       ]+__GLIBC__[    ]+([1-9][0-9]|[3-9])' \
4225            $glibc_header_dir/features.h > /dev/null; then
4226           gcc_cv_libc_provides_ssp=yes
4227         elif $EGREP '^[         ]*#[    ]*define[       ]+__GLIBC__[    ]+2' \
4228              $glibc_header_dir/features.h > /dev/null \
4229              && $EGREP '^[      ]*#[    ]*define[       ]+__GLIBC_MINOR__[      ]+([1-9][0-9]|[4-9])' \
4230              $glibc_header_dir/features.h > /dev/null; then
4231           gcc_cv_libc_provides_ssp=yes
4232         elif $EGREP '^[         ]*#[    ]*define[       ]+__UCLIBC__[   ]+1' \
4233              $glibc_header_dir/features.h > /dev/null && \
4234              test -f $glibc_header_dir/bits/uClibc_config.h && \
4235              $EGREP '^[         ]*#[    ]*define[       ]+__UCLIBC_HAS_SSP__[   ]+1' \
4236              $glibc_header_dir/bits/uClibc_config.h > /dev/null; then
4237           gcc_cv_libc_provides_ssp=yes
4238         fi
4239       fi]
4240         ;;
4241        *-*-gnu*)
4242          # Avoid complicated tests (see
4243          # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
4244          # simply assert that glibc does provide this, which is true for all
4245          # realistically usable GNU/Hurd configurations.
4246          gcc_cv_libc_provides_ssp=yes;;
4247        *-*-darwin* | *-*-freebsd*)
4248          AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
4249            [echo "no __stack_chk_fail on this target"])
4250         ;;
4251   *) gcc_cv_libc_provides_ssp=no ;;
4252     esac])
4253
4254 if test x$gcc_cv_libc_provides_ssp = xyes; then
4255   AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
4256             [Define if your target C library provides stack protector support])
4257 fi
4258
4259 # Check if TFmode long double should be used by default or not.
4260 # Some glibc targets used DFmode long double, but with glibc 2.4
4261 # and later they can use TFmode.
4262 case "$target" in
4263   powerpc*-*-linux* | \
4264   powerpc*-*-gnu* | \
4265   sparc*-*-linux* | \
4266   s390*-*-linux* | \
4267   alpha*-*-linux*)
4268     AC_ARG_WITH(long-double-128,
4269 [  --with-long-double-128  Use 128-bit long double by default.],
4270       gcc_cv_target_ldbl128="$with_long_double_128",
4271       [[gcc_cv_target_ldbl128=no
4272       if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4273         if test "x$with_sysroot" = x; then
4274           glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-include"
4275         elif test "x$with_build_sysroot" != "x"; then
4276           glibc_header_dir="${with_build_sysroot}/usr/include"
4277         elif test "x$with_sysroot" = xyes; then
4278           glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-root/usr/include"
4279         else
4280           glibc_header_dir="${with_sysroot}/usr/include"
4281         fi
4282       else
4283         glibc_header_dir=/usr/include
4284       fi
4285       grep '^[  ]*#[    ]*define[       ][      ]*__LONG_DOUBLE_MATH_OPTIONAL' \
4286         $glibc_header_dir/bits/wordsize.h > /dev/null 2>&1 \
4287       && gcc_cv_target_ldbl128=yes
4288       ]])
4289     ;;
4290 esac
4291 if test x$gcc_cv_target_ldbl128 = xyes; then
4292   AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
4293             [Define if TFmode long double should be the default])
4294 fi
4295
4296 # Find out what GC implementation we want, or may, use.
4297 AC_ARG_WITH(gc,
4298 [  --with-gc={page,zone}   choose the garbage collection mechanism to use
4299                           with the compiler],
4300 [case "$withval" in
4301   page)
4302     GGC=ggc-$withval
4303     ;;
4304   zone)
4305     GGC=ggc-$withval
4306     AC_DEFINE(GGC_ZONE, 1, [Define if the zone collector is in use])
4307     ;;
4308   *)
4309     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
4310     ;;
4311 esac],
4312 [GGC=ggc-page])
4313 AC_SUBST(GGC)
4314 echo "Using $GGC for garbage collection."
4315
4316 # Libraries to use on the host.  This will normally be set by the top
4317 # level Makefile.  Here we simply capture the value for our Makefile.
4318 if test -z "${HOST_LIBS+set}"; then
4319   HOST_LIBS=
4320 fi
4321 AC_SUBST(HOST_LIBS)
4322
4323 # Use the system's zlib library.
4324 zlibdir=-L../zlib
4325 zlibinc="-I\$(srcdir)/../zlib"
4326 AC_ARG_WITH(system-zlib,
4327 [  --with-system-zlib      use installed libz],
4328 zlibdir=
4329 zlibinc=
4330 )
4331 AC_SUBST(zlibdir)
4332 AC_SUBST(zlibinc)
4333
4334 dnl Very limited version of automake's enable-maintainer-mode
4335
4336 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
4337   dnl maintainer-mode is disabled by default
4338   AC_ARG_ENABLE(maintainer-mode,
4339 [  --enable-maintainer-mode
4340                           enable make rules and dependencies not useful
4341                           (and sometimes confusing) to the casual installer],
4342       maintainer_mode=$enableval,
4343       maintainer_mode=no)
4344
4345 AC_MSG_RESULT($maintainer_mode)
4346
4347 if test "$maintainer_mode" = "yes"; then
4348   MAINT=''
4349 else
4350   MAINT='#'
4351 fi
4352 AC_SUBST(MAINT)dnl
4353
4354 # --------------
4355 # Language hooks
4356 # --------------
4357
4358 # Make empty files to contain the specs and options for each language.
4359 # Then add #include lines to for a compiler that has specs and/or options.
4360
4361 subdirs=
4362 lang_opt_files=
4363 lang_specs_files=
4364 lang_tree_files=
4365 # These (without "all_") are set in each config-lang.in.
4366 # `language' must be a single word so is spelled singularly.
4367 all_languages=
4368 all_compilers=
4369 all_outputs='Makefile'
4370 # List of language makefile fragments.
4371 all_lang_makefrags=
4372 # Additional files for gengtype
4373 all_gtfiles="$target_gtfiles"
4374
4375 # These are the languages that are set in --enable-languages,
4376 # and are available in the GCC tree.
4377 all_selected_languages=
4378
4379 # Add the language fragments.
4380 # Languages are added via two mechanisms.  Some information must be
4381 # recorded in makefile variables, these are defined in config-lang.in.
4382 # We accumulate them and plug them into the main Makefile.
4383 # The other mechanism is a set of hooks for each of the main targets
4384 # like `clean', `install', etc.
4385
4386 language_hooks="Make-hooks"
4387
4388 for lang in ${srcdir}/*/config-lang.in
4389 do
4390 changequote(,)dnl
4391         test "$lang" = "${srcdir}/*/config-lang.in" && continue
4392
4393         lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
4394         if test "x$lang_alias" = x
4395         then
4396               echo "$lang doesn't set \$language." 1>&2
4397               exit 1
4398         fi
4399         subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
4400         subdirs="$subdirs $subdir"
4401
4402         # $gcc_subdir is where the gcc integration files are to be found
4403         # for a language, both for internal compiler purposes (compiler
4404         # sources implementing front-end to GCC tree converters), and for
4405         # build infrastructure purposes (Make-lang.in, etc.)
4406         #
4407         # This will be <subdir> (relative to $srcdir) if a line like
4408         # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
4409         # is found in <langdir>/config-lang.in, and will remain <langdir>
4410         # otherwise.
4411         #
4412         # Except for the language alias (fetched above), the regular
4413         # "config-lang.in" contents are always retrieved from $gcc_subdir,
4414         # so a <langdir>/config-lang.in setting gcc_subdir typically sets
4415         # only this and the language alias.
4416
4417         gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^   ]*\).*$,\1,p' $lang`
4418         if [ "$gcc_subdir" = "" ]; then
4419            gcc_subdir="$subdir"
4420         fi
4421
4422         case ",$enable_languages," in
4423         *,$lang_alias,*)
4424             all_selected_languages="$all_selected_languages $lang_alias"
4425             if test -f $srcdir/$gcc_subdir/lang-specs.h; then
4426                 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
4427             fi
4428             ;;
4429         esac
4430 changequote([,])dnl
4431
4432         language=
4433         boot_language=
4434         compilers=
4435         outputs=
4436         gtfiles=
4437         subdir_requires=
4438         . ${srcdir}/$gcc_subdir/config-lang.in
4439         if test "x$language" = x
4440         then
4441                 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
4442                 exit 1
4443         fi
4444
4445         ok=:
4446         case ",$enable_languages," in
4447                 *,$lang_alias,*) ;;
4448                 *)
4449                         for i in $subdir_requires; do
4450                                 test -f "${srcdir}/$i/config-lang.in" && continue
4451                                 ok=false
4452                                 break
4453                         done
4454                 ;;
4455         esac
4456         $ok || continue
4457
4458         all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
4459         if test -f $srcdir/$gcc_subdir/lang.opt; then
4460             lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
4461         fi
4462         if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
4463             lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
4464         fi
4465         all_languages="$all_languages $language"
4466         all_compilers="$all_compilers $compilers"
4467         all_outputs="$all_outputs $outputs"
4468         all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
4469         case ",$enable_languages," in
4470                 *,lto,*)
4471                     AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
4472                     enable_lto=yes
4473                     AC_SUBST(enable_lto)
4474                     ;;
4475                 *) ;;
4476         esac
4477 done
4478
4479 # Pick up gtfiles for c
4480 gtfiles=
4481 . ${srcdir}/c-config-lang.in
4482 all_gtfiles="$all_gtfiles [[c]] $gtfiles"
4483
4484 check_languages=
4485 for language in $all_selected_languages
4486 do
4487         check_languages="$check_languages check-$language"
4488 done
4489
4490 # We link each language in with a set of hooks, reached indirectly via
4491 # lang.${target}.  Only do so for selected languages.
4492
4493 rm -f Make-hooks
4494 touch Make-hooks
4495 target_list="all.cross start.encap rest.encap tags \
4496         install-common install-man install-info install-pdf install-html dvi \
4497         pdf html uninstall info man srcextra srcman srcinfo \
4498         mostlyclean clean distclean maintainer-clean install-plugin"
4499
4500 for t in $target_list
4501 do
4502         x=
4503         for lang in $all_selected_languages
4504         do
4505                 x="$x $lang.$t"
4506         done
4507         echo "lang.$t: $x" >> Make-hooks
4508 done
4509
4510 # --------
4511 # UNSORTED
4512 # --------
4513
4514 # Create .gdbinit.
4515
4516 echo "dir ." > .gdbinit
4517 echo "dir ${srcdir}" >> .gdbinit
4518 if test x$gdb_needs_out_file_path = xyes
4519 then
4520         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
4521 fi
4522 if test "x$subdirs" != x; then
4523         for s in $subdirs
4524         do
4525                 echo "dir ${srcdir}/$s" >> .gdbinit
4526         done
4527 fi
4528 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
4529
4530 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
4531 AC_SUBST(gcc_tooldir)
4532 AC_SUBST(dollar)
4533
4534 # Find a directory in which to install a shared libgcc.
4535
4536 AC_ARG_ENABLE(version-specific-runtime-libs,
4537 [  --enable-version-specific-runtime-libs
4538                           specify that runtime libraries should be
4539                           installed in a compiler-specific directory])
4540
4541 AC_ARG_WITH(slibdir,
4542 [  --with-slibdir=DIR      shared libraries in DIR [[LIBDIR]]],
4543 slibdir="$with_slibdir",
4544 if test "${enable_version_specific_runtime_libs+set}" = set; then
4545   slibdir='$(libsubdir)'
4546 elif test "$host" != "$target"; then
4547   slibdir='$(build_tooldir)/lib'
4548 else
4549   slibdir='$(libdir)'
4550 fi)
4551 AC_SUBST(slibdir)
4552
4553 # Substitute configuration variables
4554 AC_SUBST(subdirs)
4555 AC_SUBST(srcdir)
4556 AC_SUBST(all_compilers)
4557 AC_SUBST(all_gtfiles)
4558 AC_SUBST(all_lang_makefrags)
4559 AC_SUBST(all_languages)
4560 AC_SUBST(all_selected_languages)
4561 AC_SUBST(build_exeext)
4562 AC_SUBST(build_install_headers_dir)
4563 AC_SUBST(build_xm_file_list)
4564 AC_SUBST(build_xm_include_list)
4565 AC_SUBST(build_xm_defines)
4566 AC_SUBST(build_file_translate)
4567 AC_SUBST(check_languages)
4568 AC_SUBST(cpp_install_dir)
4569 AC_SUBST(xmake_file)
4570 AC_SUBST(tmake_file)
4571 AC_SUBST(TM_ENDIAN_CONFIG)
4572 AC_SUBST(TM_MULTILIB_CONFIG)
4573 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
4574 AC_SUBST(extra_gcc_objs)
4575 AC_SUBST(user_headers_inc_next_pre)
4576 AC_SUBST(user_headers_inc_next_post)
4577 AC_SUBST(extra_headers_list)
4578 AC_SUBST(extra_objs)
4579 AC_SUBST(extra_parts)
4580 AC_SUBST(extra_passes)
4581 AC_SUBST(extra_programs)
4582 AC_SUBST(float_h_file)
4583 AC_SUBST(gcc_config_arguments)
4584 AC_SUBST(gcc_gxx_include_dir)
4585 AC_SUBST(host_exeext)
4586 AC_SUBST(host_xm_file_list)
4587 AC_SUBST(host_xm_include_list)
4588 AC_SUBST(host_xm_defines)
4589 AC_SUBST(out_host_hook_obj)
4590 AC_SUBST(install)
4591 AC_SUBST(lang_opt_files)
4592 AC_SUBST(lang_specs_files)
4593 AC_SUBST(lang_tree_files)
4594 AC_SUBST(local_prefix)
4595 AC_SUBST(md_file)
4596 AC_SUBST(objc_boehm_gc)
4597 AC_SUBST(out_file)
4598 AC_SUBST(out_object_file)
4599 AC_SUBST(thread_file)
4600 AC_SUBST(tm_file_list)
4601 AC_SUBST(tm_include_list)
4602 AC_SUBST(tm_defines)
4603 AC_SUBST(tm_p_file_list)
4604 AC_SUBST(tm_p_include_list)
4605 AC_SUBST(xm_file_list)
4606 AC_SUBST(xm_include_list)
4607 AC_SUBST(xm_defines)
4608 AC_SUBST(use_gcc_stdint)
4609 AC_SUBST(c_target_objs)
4610 AC_SUBST(cxx_target_objs)
4611 AC_SUBST(fortran_target_objs)
4612 AC_SUBST(target_cpu_default)
4613
4614 AC_SUBST_FILE(language_hooks)
4615
4616 # Echo link setup.
4617 if test x${build} = x${host} ; then
4618   if test x${host} = x${target} ; then
4619     echo "Links are now set up to build a native compiler for ${target}." 1>&2
4620   else
4621     echo "Links are now set up to build a cross-compiler" 1>&2
4622     echo " from ${host} to ${target}." 1>&2
4623   fi
4624 else
4625   if test x${host} = x${target} ; then
4626     echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
4627     echo " for ${target}." 1>&2
4628   else
4629     echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
4630     echo " from ${host} to ${target}." 1>&2
4631   fi
4632 fi
4633
4634 AC_ARG_VAR(GMPLIBS,[How to link GMP])
4635 AC_ARG_VAR(GMPINC,[How to find GMP include files])
4636
4637 AC_ARG_VAR(PPLLIBS,[How to link PPL])
4638 AC_ARG_VAR(PPLINC,[How to find PPL include files])
4639
4640 AC_ARG_VAR(CLOOGLIBS,[How to link CLOOG])
4641 AC_ARG_VAR(CLOOGINC,[How to find CLOOG include files])
4642 if test "x${CLOOGLIBS}" != "x" ; then
4643    AC_DEFINE(HAVE_cloog, 1, [Define if cloog is in use.])
4644 fi
4645
4646 # Check for plugin support
4647 AC_ARG_ENABLE(plugin,
4648 [  --enable-plugin         enable plugin support],
4649 enable_plugin=$enableval,
4650 enable_plugin=yes; default_plugin=yes)
4651
4652 pluginlibs=
4653
4654 case "${host}" in
4655   *-*-darwin*)
4656     if test x$build = x$host; then
4657       export_sym_check="nm${exeext} -g"
4658     elif test x$host = x$target; then
4659       export_sym_check="$gcc_cv_nm -g"
4660     else
4661       export_sym_check=
4662     fi
4663   ;;
4664   *)
4665     if test x$build = x$host; then
4666       export_sym_check="objdump${exeext} -T"
4667     elif test x$host = x$target; then
4668       export_sym_check="$gcc_cv_objdump -T"
4669     else
4670       export_sym_check=
4671     fi
4672   ;;
4673 esac
4674
4675 if test x"$enable_plugin" = x"yes"; then
4676
4677   AC_MSG_CHECKING([for exported symbols])
4678   if test "x$export_sym_check" != x; then
4679     echo "int main() {return 0;} int foobar() {return 0;}" > conftest.c
4680     ${CC} ${CFLAGS} ${LDFLAGS} conftest.c -o conftest > /dev/null 2>&1
4681     if $export_sym_check conftest | grep foobar > /dev/null; then
4682       : # No need to use a flag
4683       AC_MSG_RESULT([yes])
4684     else
4685       AC_MSG_RESULT([yes])
4686       AC_MSG_CHECKING([for -rdynamic])
4687       ${CC} ${CFLAGS} ${LDFLAGS} -rdynamic conftest.c -o conftest > /dev/null 2>&1
4688       if $export_sym_check conftest | grep foobar > /dev/null; then
4689         plugin_rdynamic=yes
4690         pluginlibs="-rdynamic"
4691       else
4692         plugin_rdynamic=no
4693         enable_plugin=no
4694       fi
4695       AC_MSG_RESULT([$plugin_rdynamic])
4696     fi
4697   else
4698     AC_MSG_RESULT([unable to check])
4699   fi
4700
4701   # Check -ldl
4702   saved_LIBS="$LIBS"
4703   AC_SEARCH_LIBS([dlopen], [dl])
4704   if test x"$ac_cv_search_dlopen" = x"-ldl"; then
4705     pluginlibs="$pluginlibs -ldl"
4706   fi
4707   LIBS="$saved_LIBS"
4708
4709   # Check that we can build shared objects with -fPIC -shared
4710   saved_LDFLAGS="$LDFLAGS"
4711   saved_CFLAGS="$CFLAGS"
4712   case "${host}" in
4713     *-*-darwin*)
4714       CFLAGS=`echo $CFLAGS | sed s/-mdynamic-no-pic//g`
4715       CFLAGS="$CFLAGS -fPIC"
4716       LDFLAGS="$LDFLAGS -shared -undefined dynamic_lookup"
4717     ;;
4718     *)
4719       CFLAGS="$CFLAGS -fPIC"
4720       LDFLAGS="$LDFLAGS -fPIC -shared"
4721     ;;
4722   esac
4723   AC_MSG_CHECKING([for -fPIC -shared])
4724   AC_TRY_LINK(
4725     [extern int X;],[return X == 0;],
4726     [AC_MSG_RESULT([yes]); have_pic_shared=yes],
4727     [AC_MSG_RESULT([no]); have_pic_shared=no])
4728   if test x"$have_pic_shared" != x"yes" -o x"$ac_cv_search_dlopen" = x"no"; then
4729     pluginlibs=
4730     enable_plugin=no
4731   fi
4732   LDFLAGS="$saved_LDFLAGS"
4733   CFLAGS="$saved_CFLAGS"
4734
4735   # If plugin support had been requested but not available, fail.
4736   if test x"$enable_plugin" = x"no" ; then
4737     if test x"$default_plugin" != x"yes"; then
4738       AC_MSG_ERROR([
4739 Building GCC with plugin support requires a host that supports
4740 -fPIC, -shared, -ldl and -rdynamic.])
4741     fi
4742   fi
4743 fi
4744
4745 AC_SUBST(pluginlibs)
4746 AC_SUBST(enable_plugin)
4747 if test x"$enable_plugin" = x"yes"; then
4748   AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
4749 fi
4750
4751 # Configure the subdirectories
4752 # AC_CONFIG_SUBDIRS($subdirs)
4753
4754 # Create the Makefile
4755 # and configure language subdirectories
4756 AC_CONFIG_FILES($all_outputs)
4757
4758 AC_CONFIG_COMMANDS([default],
4759 [
4760 case ${CONFIG_HEADERS} in
4761   *auto-host.h:config.in*)
4762   echo > cstamp-h ;;
4763 esac
4764 # Make sure all the subdirs exist.
4765 for d in $subdirs doc build c-family
4766 do
4767     test -d $d || mkdir $d
4768 done
4769 ],
4770 [subdirs='$subdirs'])
4771 AC_OUTPUT