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