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