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.9* | *-*-solaris2.1[0-9]*)
2239         # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2240         # .symbolic was only added in Solaris 9 12/02.
2241         gcc_cv_ld_hidden=yes
2242         ;;
2243       *)
2244         gcc_cv_ld_hidden=no
2245         ;;
2246     esac
2247   fi
2248 fi]])
2249 libgcc_visibility=no
2250 AC_SUBST(libgcc_visibility)
2251 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2252 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2253   libgcc_visibility=yes
2254   AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2255   [Define if your assembler and linker support .hidden.])
2256 fi
2257
2258 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2259 gcc_cv_ld_ro_rw_mix=unknown
2260 if test $in_tree_ld = yes ; then
2261   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 \
2262      && test $in_tree_ld_is_elf = yes; then
2263     gcc_cv_ld_ro_rw_mix=read-write
2264   fi
2265 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2266   echo '.section myfoosect, "a"' > conftest1.s
2267   echo '.section myfoosect, "aw"' > conftest2.s
2268   echo '.byte 1' >> conftest2.s
2269   echo '.section myfoosect, "a"' > conftest3.s
2270   echo '.byte 0' >> conftest3.s
2271   if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2272      && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2273      && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2274      && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2275         conftest2.o conftest3.o > /dev/null 2>&1; then
2276     gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2277                          | sed -e '/myfoosect/!d' -e N`
2278     if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2279       if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2280         gcc_cv_ld_ro_rw_mix=read-only
2281       else
2282         gcc_cv_ld_ro_rw_mix=read-write
2283       fi
2284     fi
2285   fi
2286 changequote(,)dnl
2287   rm -f conftest.* conftest[123].*
2288 changequote([,])dnl
2289 fi
2290 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2291         AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2292   [Define if your linker links a mix of read-only
2293    and read-write sections into a read-write section.])
2294 fi
2295 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2296
2297 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2298 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2299   [elf,2,11,0],,
2300 [       .data
2301         .uleb128 L2 - L1
2302 L1:
2303         .uleb128 1280
2304         .sleb128 -1010
2305 L2:],
2306 [[# GAS versions before 2.11 do not support uleb128,
2307   # despite appearing to.
2308   # ??? There exists an elf-specific test that will crash
2309   # the assembler.  Perhaps it's better to figure out whether
2310   # arbitrary sections are supported and try the test.
2311   as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2312   if echo "$as_ver" | grep GNU > /dev/null; then
2313     as_vers=`echo $as_ver | sed -n \
2314         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2315     as_major=`expr "$as_vers" : '\([0-9]*\)'`
2316     as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2317     if test $as_major -eq 2 && test $as_minor -lt 11
2318     then :
2319     else gcc_cv_as_leb128=yes
2320     fi
2321   fi]],
2322   [AC_DEFINE(HAVE_AS_LEB128, 1,
2323     [Define if your assembler supports .sleb128 and .uleb128.])])
2324
2325 # Check if we have assembler support for unwind directives.
2326 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2327   ,,
2328 [       .text
2329         .cfi_startproc
2330         .cfi_offset 0, 0
2331         .cfi_same_value 1
2332         .cfi_def_cfa 1, 2
2333         .cfi_escape 1, 2, 3, 4, 5
2334         .cfi_endproc],
2335 [case "$target" in
2336   *-*-solaris*)
2337     # If the linker used on Solaris (like Sun ld) isn't capable of merging
2338     # read-only and read-write sections, we need to make sure that the
2339     # assembler used emits read-write .eh_frame sections.
2340     if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2341       if test "x$gcc_cv_objdump" != x; then
2342         if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2343                 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2344           gcc_cv_as_cfi_directive=no
2345         else
2346           case "$target" in
2347             i?86-*-solaris2.1[[0-9]]*)
2348               # On Solaris/x86, make sure that GCC and gas agree on using
2349               # read-only .eh_frame sections for 64-bit.
2350               if $gcc_cv_as --64 -o conftest.o conftest.s > /dev/null 2>&1 && \
2351                 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2352                         sed -e /.eh_frame/!d -e N | \
2353                         grep READONLY > /dev/null; then
2354                 gcc_cv_as_cfi_directive=yes
2355               else
2356                 gcc_cv_as_cfi_directive=no
2357               fi
2358               ;;
2359             *)
2360               gcc_cv_as_cfi_directive=yes
2361               ;;
2362           esac
2363         fi
2364       else
2365         # no objdump, err on the side of caution
2366         gcc_cv_as_cfi_directive=no
2367       fi
2368     else
2369       gcc_cv_as_cfi_directive=yes
2370     fi
2371     ;;
2372   *-*-*)
2373     gcc_cv_as_cfi_directive=yes
2374     ;;
2375 esac])
2376 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
2377 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2378   ,,
2379 [       .text
2380         .cfi_startproc
2381         .cfi_adjust_cfa_offset 64
2382         .skip 75040, 0
2383         .cfi_adjust_cfa_offset 128
2384         .cfi_endproc],
2385 [[
2386 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
2387     | grep 'DW_CFA_advance_loc[24]:[    ][      ]*75040[        ]' >/dev/null; then
2388    gcc_cv_as_cfi_advance_working=yes
2389 fi
2390 ]])
2391 else
2392   # no objdump, err on the side of caution
2393   gcc_cv_as_cfi_advance_working=no
2394 fi
2395 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
2396 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2397   [`if test $gcc_cv_as_cfi_directive = yes \
2398        && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2399   [Define 0/1 if your assembler supports CFI directives.])
2400
2401 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
2402 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2403   gcc_cv_as_cfi_personality_directive, ,,
2404 [       .text
2405         .cfi_startproc
2406         .cfi_personality 0, symbol
2407         .cfi_endproc])
2408 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2409   [`if test $gcc_cv_as_cfi_personality_directive = yes;
2410     then echo 1; else echo 0; fi`],
2411   [Define 0/1 if your assembler supports .cfi_personality.])
2412
2413 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2414   gcc_cv_as_cfi_sections_directive, ,,
2415 [       .text
2416         .cfi_sections .debug_frame, .eh_frame
2417         .cfi_startproc
2418         .cfi_endproc],
2419 [case $target_os in
2420   win32 | pe | cygwin* | mingw32* | uwin*)
2421     # Need to check that we generated the correct relocation for the
2422     # .debug_frame section.  This was fixed for binutils 2.21.
2423     gcc_cv_as_cfi_sections_directive=no
2424     if test "x$gcc_cv_objdump" != x; then
2425      if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
2426         grep secrel > /dev/null; then
2427       gcc_cv_as_cfi_sections_directive=yes
2428      fi
2429     fi
2430     ;;
2431   *)
2432     gcc_cv_as_cfi_sections_directive=yes
2433     ;;
2434 esac])
2435 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
2436 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2437   [`if test $gcc_cv_as_cfi_sections_directive = yes;
2438     then echo 1; else echo 0; fi`],
2439   [Define 0/1 if your assembler supports .cfi_sections.])
2440
2441 # GAS versions up to and including 2.11.0 may mis-optimize
2442 # .eh_frame data.
2443 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2444   [elf,2,12,0],,
2445 [       .text
2446 .LFB1:
2447         .4byte  0
2448 .L1:
2449         .4byte  0
2450 .LFE1:
2451         .section        .eh_frame,"aw",@progbits
2452 __FRAME_BEGIN__:
2453         .4byte  .LECIE1-.LSCIE1
2454 .LSCIE1:
2455         .4byte  0x0
2456         .byte   0x1
2457         .ascii "z\0"
2458         .byte   0x1
2459         .byte   0x78
2460         .byte   0x1a
2461         .byte   0x0
2462         .byte   0x4
2463         .4byte  1
2464         .p2align 1
2465 .LECIE1:
2466 .LSFDE1:
2467         .4byte  .LEFDE1-.LASFDE1
2468 .LASFDE1:
2469         .4byte  .LASFDE1-__FRAME_BEGIN__
2470         .4byte  .LFB1
2471         .4byte  .LFE1-.LFB1
2472         .byte   0x4
2473         .4byte  .LFE1-.LFB1
2474         .byte   0x4
2475         .4byte  .L1-.LFB1
2476 .LEFDE1:],
2477 [  dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2478 cat > conftest.lit <<EOF
2479  0000 10000000 00000000 017a0001 781a0004  .........z..x...
2480  0010 01000000 12000000 18000000 00000000  ................
2481  0020 08000000 04080000 0044               .........D      @&t@
2482 EOF
2483 cat > conftest.big <<EOF
2484  0000 00000010 00000000 017a0001 781a0004  .........z..x...
2485  0010 00000001 00000012 00000018 00000000  ................
2486  0020 00000008 04000000 0844               .........D      @&t@
2487 EOF
2488   # If the assembler didn't choke, and we can objdump,
2489   # and we got the correct data, then succeed.
2490   # The text in the here-document typically retains its unix-style line
2491   # endings, while the output of objdump will use host line endings.
2492   # Therefore, use diff -b for the comparisons.
2493   if test x$gcc_cv_objdump != x \
2494   && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2495      | tail -3 > conftest.got \
2496   && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2497     || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2498   then
2499     gcc_cv_as_eh_frame=yes
2500   elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2501     gcc_cv_as_eh_frame=buggy
2502   else
2503     # Uh oh, what do we do now?
2504     gcc_cv_as_eh_frame=no
2505   fi])
2506
2507 if test $gcc_cv_as_eh_frame = buggy; then
2508   AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2509   [Define if your assembler mis-optimizes .eh_frame data.])
2510 fi
2511
2512 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2513  [elf,2,12,0], [--fatal-warnings],
2514  [.section .rodata.str, "aMS", @progbits, 1])
2515 if test $gcc_cv_as_shf_merge = no; then
2516   gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2517     [elf,2,12,0], [--fatal-warnings],
2518     [.section .rodata.str, "aMS", %progbits, 1])
2519 fi
2520 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2521   [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2522 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2523
2524 gcc_GAS_CHECK_FEATURE(COMDAT group support, gcc_cv_as_comdat_group,
2525  [elf,2,16,0], [--fatal-warnings],
2526  [.section .text,"axG",@progbits,.foo,comdat])
2527 if test $gcc_cv_as_comdat_group = yes; then
2528   gcc_cv_as_comdat_group_percent=no
2529 else
2530  gcc_GAS_CHECK_FEATURE(COMDAT group support, gcc_cv_as_comdat_group_percent,
2531    [elf,2,16,0], [--fatal-warnings],
2532    [.section .text,"axG",%progbits,.foo,comdat])
2533 fi
2534 if test x"$ld_is_gold" = xyes; then
2535   comdat_group=yes
2536 elif test $in_tree_ld = yes ; then
2537   comdat_group=no
2538   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 \
2539      && test $in_tree_ld_is_elf = yes; then
2540      comdat_group=yes
2541   fi
2542 elif echo "$ld_ver" | grep GNU > /dev/null; then
2543   comdat_group=yes
2544   if test 0"$ld_date" -lt 20050308; then
2545     if test -n "$ld_date"; then
2546       # If there was date string, but was earlier than 2005-03-08, fail
2547       comdat_group=no
2548     elif test "$ld_vers_major" -lt 2; then
2549       comdat_group=no
2550     elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2551       comdat_group=no
2552     fi
2553   fi
2554 else
2555 changequote(,)dnl
2556   case "${target}" in
2557     *-*-solaris2.1[1-9]*)
2558       # Sun ld has COMDAT group support since Solaris 9, but it doesn't
2559       # interoperate with GNU as until Solaris 11 build 130, i.e. ld
2560       # version 1.688.
2561       #
2562       # FIXME: Maybe need to refine later when COMDAT group support with
2563       # Sun as is implemented.
2564       if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 1688; then
2565         comdat_group=yes
2566       else
2567         comdat_group=no
2568       fi
2569       ;;
2570     *)
2571       # Assume linkers other than GNU ld don't support COMDAT group.
2572       comdat_group=no
2573       ;;
2574   esac
2575 changequote([,])dnl
2576 fi
2577 # Allow overriding the automatic COMDAT group tests above.
2578 AC_ARG_ENABLE(comdat,
2579   [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
2580   [comdat_group="$enable_comdat"])
2581 if test $comdat_group = no; then
2582   gcc_cv_as_comdat_group=no
2583   gcc_cv_as_comdat_group_percent=no
2584 fi
2585 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2586   [`if test $gcc_cv_as_comdat_group = yes || test $gcc_cv_as_comdat_group_percent = yes; then echo 1; else echo 0; fi`],
2587 [Define 0/1 if your assembler and linker support COMDAT groups.])
2588
2589 gcc_GAS_CHECK_FEATURE([line table discriminator support],
2590  gcc_cv_as_discriminator,
2591  [2,19,51],,
2592 [       .text
2593         .file 1 "conf.c"
2594         .loc 1 1 0 discriminator 1],,
2595 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
2596   [Define if your assembler supports the .loc discriminator sub-directive.])])
2597
2598 # Thread-local storage - the check is heavily parameterized.
2599 conftest_s=
2600 tls_first_major=
2601 tls_first_minor=
2602 tls_as_opt=
2603 case "$target" in
2604 changequote(,)dnl
2605   alpha*-*-*)
2606     conftest_s='
2607         .section ".tdata","awT",@progbits
2608 foo:    .long   25
2609         .text
2610         ldq     $27,__tls_get_addr($29)         !literal!1
2611         lda     $16,foo($29)                    !tlsgd!1
2612         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
2613         ldq     $27,__tls_get_addr($29)         !literal!2
2614         lda     $16,foo($29)                    !tlsldm!2
2615         jsr     $26,($27),__tls_get_addr        !lituse_tlsldm!2
2616         ldq     $1,foo($29)                     !gotdtprel
2617         ldah    $2,foo($29)                     !dtprelhi
2618         lda     $3,foo($2)                      !dtprello
2619         lda     $4,foo($29)                     !dtprel
2620         ldq     $1,foo($29)                     !gottprel
2621         ldah    $2,foo($29)                     !tprelhi
2622         lda     $3,foo($2)                      !tprello
2623         lda     $4,foo($29)                     !tprel'
2624         tls_first_major=2
2625         tls_first_minor=13
2626         tls_as_opt=--fatal-warnings
2627         ;;
2628   cris-*-*|crisv32-*-*)
2629     conftest_s='
2630         .section ".tdata","awT",@progbits
2631 x:      .long   25
2632         .text
2633         move.d x:IE,$r10
2634         nop'
2635         tls_first_major=2
2636         tls_first_minor=20
2637         tls_as_opt=--fatal-warnings
2638         ;;
2639   frv*-*-*)
2640     conftest_s='
2641         .section ".tdata","awT",@progbits
2642 x:      .long   25
2643         .text
2644         call    #gettlsoff(x)'
2645         tls_first_major=2
2646         tls_first_minor=14
2647         ;;
2648   hppa*-*-linux*)
2649     conftest_s='
2650 t1:     .reg    %r20
2651 t2:     .reg    %r21
2652 gp:     .reg    %r19
2653         .section ".tdata","awT",@progbits
2654 foo:    .long   25
2655         .text
2656         .align  4
2657         addil LT%foo-$tls_gdidx$,gp
2658         ldo RT%foo-$tls_gdidx$(%r1),%arg0
2659         b __tls_get_addr
2660         nop
2661         addil LT%foo-$tls_ldidx$,gp
2662         b __tls_get_addr
2663         ldo RT%foo-$tls_ldidx$(%r1),%arg0
2664         addil LR%foo-$tls_dtpoff$,%ret0
2665         ldo RR%foo-$tls_dtpoff$(%r1),%t1
2666         mfctl %cr27,%t1
2667         addil LT%foo-$tls_ieoff$,gp
2668         ldw RT%foo-$tls_ieoff$(%r1),%t2
2669         add %t1,%t2,%t3
2670         mfctl %cr27,%t1
2671         addil LR%foo-$tls_leoff$,%t1
2672         ldo RR%foo-$tls_leoff$(%r1),%t2'
2673         tls_first_major=2
2674         tls_first_minor=15
2675         tls_as_opt=--fatal-warnings
2676         ;;
2677   arm*-*-*)
2678     conftest_s='
2679         .section ".tdata","awT",%progbits
2680 foo:    .long   25
2681         .text
2682 .word foo(gottpoff)
2683 .word foo(tpoff)
2684 .word foo(tlsgd)
2685 .word foo(tlsldm)
2686 .word foo(tlsldo)'
2687         tls_first_major=2
2688         tls_first_minor=17
2689         ;;
2690   i[34567]86-*-*)
2691     case "$target" in
2692       i[34567]86-*-solaris2.*)
2693         on_solaris=yes
2694         tga_func=___tls_get_addr
2695         ;;
2696       *)
2697         on_solaris=no
2698         ;;
2699     esac
2700     if test x$on_solaris = xyes && test x$gas_flag = xno; then
2701       conftest_s='
2702         .section .tdata,"awt",@progbits'
2703       tls_first_major=0
2704       tls_first_minor=0
2705 changequote([,])dnl
2706       AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
2707 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
2708 changequote(,)dnl
2709     else
2710       conftest_s='
2711         .section ".tdata","awT",@progbits'
2712       tls_first_major=2
2713       tls_first_minor=14
2714       tls_as_opt="--fatal-warnings"
2715     fi
2716     conftest_s="$conftest_s
2717 foo:    .long   25
2718         .text
2719         movl    %gs:0, %eax
2720         leal    foo@tlsgd(,%ebx,1), %eax
2721         leal    foo@tlsldm(%ebx), %eax
2722         leal    foo@dtpoff(%eax), %edx
2723         movl    foo@gottpoff(%ebx), %eax
2724         subl    foo@gottpoff(%ebx), %eax
2725         addl    foo@gotntpoff(%ebx), %eax
2726         movl    foo@indntpoff, %eax
2727         movl    \$foo@tpoff, %eax
2728         subl    \$foo@tpoff, %eax
2729         leal    foo@ntpoff(%ecx), %eax"
2730     ;;
2731   x86_64-*-*)
2732     conftest_s='
2733         .section ".tdata","awT",@progbits
2734 foo:    .long   25
2735         .text
2736         movq    %fs:0, %rax
2737         leaq    foo@TLSGD(%rip), %rdi
2738         leaq    foo@TLSLD(%rip), %rdi
2739         leaq    foo@DTPOFF(%rax), %rdx
2740         movq    foo@GOTTPOFF(%rip), %rax
2741         movq    $foo@TPOFF, %rax'
2742         tls_first_major=2
2743         tls_first_minor=14
2744         tls_as_opt=--fatal-warnings
2745         ;;
2746   ia64-*-*)
2747     conftest_s='
2748         .section ".tdata","awT",@progbits
2749 foo:    data8   25
2750         .text
2751         addl    r16 = @ltoff(@dtpmod(foo#)), gp
2752         addl    r17 = @ltoff(@dtprel(foo#)), gp
2753         addl    r18 = @ltoff(@tprel(foo#)), gp
2754         addl    r19 = @dtprel(foo#), gp
2755         adds    r21 = @dtprel(foo#), r13
2756         movl    r23 = @dtprel(foo#)
2757         addl    r20 = @tprel(foo#), gp
2758         adds    r22 = @tprel(foo#), r13
2759         movl    r24 = @tprel(foo#)'
2760         tls_first_major=2
2761         tls_first_minor=13
2762         tls_as_opt=--fatal-warnings
2763         ;;
2764   mips*-*-*)
2765     conftest_s='
2766         .section .tdata,"awT",@progbits
2767 x:
2768         .word 2
2769         .text
2770         addiu $4, $28, %tlsgd(x)
2771         addiu $4, $28, %tlsldm(x)
2772         lui $4, %dtprel_hi(x)
2773         addiu $4, $4, %dtprel_lo(x)
2774         lw $4, %gottprel(x)($28)
2775         lui $4, %tprel_hi(x)
2776         addiu $4, $4, %tprel_lo(x)'
2777         tls_first_major=2
2778         tls_first_minor=16
2779         tls_as_opt='-32 --fatal-warnings'
2780         ;;
2781   m68k-*-*)
2782     conftest_s='
2783         .section .tdata,"awT",@progbits
2784 x:
2785         .word 2
2786         .text
2787 foo:
2788         move.l x@TLSGD(%a5),%a0
2789         move.l x@TLSLDM(%a5),%a0
2790         move.l x@TLSLDO(%a5),%a0
2791         move.l x@TLSIE(%a5),%a0
2792         move.l x@TLSLE(%a5),%a0'
2793         tls_first_major=2
2794         tls_first_minor=19
2795         tls_as_opt='--fatal-warnings'
2796         ;;
2797   powerpc-*-*)
2798     conftest_s='
2799         .section ".tdata","awT",@progbits
2800         .align 2
2801 ld0:    .space 4
2802 ld1:    .space 4
2803 x1:     .space 4
2804 x2:     .space 4
2805 x3:     .space 4
2806         .text
2807         addi 3,31,ld0@got@tlsgd
2808         bl __tls_get_addr
2809         addi 3,31,x1@got@tlsld
2810         bl __tls_get_addr
2811         addi 9,3,x1@dtprel
2812         addis 9,3,x2@dtprel@ha
2813         addi 9,9,x2@dtprel@l
2814         lwz 9,x3@got@tprel(31)
2815         add 9,9,x@tls
2816         addi 9,2,x1@tprel
2817         addis 9,2,x2@tprel@ha
2818         addi 9,9,x2@tprel@l'
2819         tls_first_major=2
2820         tls_first_minor=14
2821         tls_as_opt="-a32 --fatal-warnings"
2822         ;;
2823   powerpc64-*-*)
2824     conftest_s='
2825         .section ".tdata","awT",@progbits
2826         .align 3
2827 ld0:    .space 8
2828 ld1:    .space 8
2829 x1:     .space 8
2830 x2:     .space 8
2831 x3:     .space 8
2832         .text
2833         addi 3,2,ld0@got@tlsgd
2834         bl .__tls_get_addr
2835         nop
2836         addi 3,2,ld1@toc
2837         bl .__tls_get_addr
2838         nop
2839         addi 3,2,x1@got@tlsld
2840         bl .__tls_get_addr
2841         nop
2842         addi 9,3,x1@dtprel
2843         bl .__tls_get_addr
2844         nop
2845         addis 9,3,x2@dtprel@ha
2846         addi 9,9,x2@dtprel@l
2847         bl .__tls_get_addr
2848         nop
2849         ld 9,x3@got@dtprel(2)
2850         add 9,9,3
2851         bl .__tls_get_addr
2852         nop'
2853         tls_first_major=2
2854         tls_first_minor=14
2855         tls_as_opt="-a64 --fatal-warnings"
2856         ;;
2857   s390-*-*)
2858     conftest_s='
2859         .section ".tdata","awT",@progbits
2860 foo:    .long   25
2861         .text
2862         .long   foo@TLSGD
2863         .long   foo@TLSLDM
2864         .long   foo@DTPOFF
2865         .long   foo@NTPOFF
2866         .long   foo@GOTNTPOFF
2867         .long   foo@INDNTPOFF
2868         l       %r1,foo@GOTNTPOFF(%r12)
2869         l       %r1,0(%r1):tls_load:foo
2870         bas     %r14,0(%r1,%r13):tls_gdcall:foo
2871         bas     %r14,0(%r1,%r13):tls_ldcall:foo'
2872         tls_first_major=2
2873         tls_first_minor=14
2874         tls_as_opt="-m31 --fatal-warnings"
2875         ;;
2876   s390x-*-*)
2877     conftest_s='
2878         .section ".tdata","awT",@progbits
2879 foo:    .long   25
2880         .text
2881         .quad   foo@TLSGD
2882         .quad   foo@TLSLDM
2883         .quad   foo@DTPOFF
2884         .quad   foo@NTPOFF
2885         .quad   foo@GOTNTPOFF
2886         lg      %r1,foo@GOTNTPOFF(%r12)
2887         larl    %r1,foo@INDNTPOFF
2888         brasl   %r14,__tls_get_offset@PLT:tls_gdcall:foo
2889         brasl   %r14,__tls_get_offset@PLT:tls_ldcall:foo'
2890         tls_first_major=2
2891         tls_first_minor=14
2892         tls_as_opt="-m64 -Aesame --fatal-warnings"
2893         ;;
2894   sh-*-* | sh[34]-*-*)
2895     conftest_s='
2896         .section ".tdata","awT",@progbits
2897 foo:    .long   25
2898         .text
2899         .long   foo@TLSGD
2900         .long   foo@TLSLDM
2901         .long   foo@DTPOFF
2902         .long   foo@GOTTPOFF
2903         .long   foo@TPOFF'
2904         tls_first_major=2
2905         tls_first_minor=13
2906         tls_as_opt=--fatal-warnings
2907         ;;
2908   sparc*-*-*)
2909     case "$target" in
2910       sparc*-sun-solaris2.*)
2911         on_solaris=yes
2912         tga_func=__tls_get_addr
2913         ;;
2914       *)
2915         on_solaris=no
2916         ;;
2917     esac
2918     if test x$on_solaris = xyes && test x$gas_flag = xno; then
2919       conftest_s='
2920         .section ".tdata",#alloc,#write,#tls'
2921         tls_first_major=0
2922         tls_first_minor=0
2923     else
2924       conftest_s='
2925         .section ".tdata","awT",@progbits'
2926         tls_first_major=2
2927         tls_first_minor=14
2928         tls_as_opt="-32 --fatal-warnings"
2929     fi
2930     conftest_s="$conftest_s
2931 foo:    .long   25
2932         .text
2933         sethi   %tgd_hi22(foo), %o0
2934         add     %o0, %tgd_lo10(foo), %o1
2935         add     %l7, %o1, %o0, %tgd_add(foo)
2936         call    __tls_get_addr, %tgd_call(foo)
2937         sethi   %tldm_hi22(foo), %l1
2938         add     %l1, %tldm_lo10(foo), %l2
2939         add     %l7, %l2, %o0, %tldm_add(foo)
2940         call    __tls_get_addr, %tldm_call(foo)
2941         sethi   %tldo_hix22(foo), %l3
2942         xor     %l3, %tldo_lox10(foo), %l4
2943         add     %o0, %l4, %l5, %tldo_add(foo)
2944         sethi   %tie_hi22(foo), %o3
2945         add     %o3, %tie_lo10(foo), %o3
2946         ld      [%l7 + %o3], %o2, %tie_ld(foo)
2947         add     %g7, %o2, %o4, %tie_add(foo)
2948         sethi   %tle_hix22(foo), %l1
2949         xor     %l1, %tle_lox10(foo), %o5
2950         ld      [%g7 + %o5], %o1"
2951         ;;
2952   xtensa*-*-*)
2953     conftest_s='
2954         .section ".tdata","awT",@progbits
2955 foo:    .long   25
2956         .text
2957         movi    a8, foo@TLSFUNC
2958         movi    a10, foo@TLSARG
2959         callx8.tls a8, foo@TLSCALL'
2960         tls_first_major=2
2961         tls_first_minor=19
2962         ;;
2963 changequote([,])dnl
2964 esac
2965 set_have_as_tls=no
2966 if test "x$enable_tls" = xno ; then
2967   : # TLS explicitly disabled.
2968 elif test "x$enable_tls" = xyes ; then
2969   set_have_as_tls=yes # TLS explicitly enabled.
2970 elif test -z "$tls_first_major"; then
2971   : # If we don't have a check, assume no support.
2972 else
2973   gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
2974   [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
2975   [set_have_as_tls=yes])
2976 fi
2977 case "$target" in
2978   # TLS was introduced in the Solaris 9 FCS release and backported to
2979   # Solaris 8 patches.  Support for GNU-style TLS on x86 was only
2980   # introduced in Solaris 9 4/04, replacing the earlier Sun style that Sun
2981   # ld and GCC don't support any longer.
2982   *-*-solaris2.*)
2983     AC_MSG_CHECKING(linker and ld.so.1 TLS support)
2984     ld_tls_support=no
2985     # Check ld and ld.so.1 TLS support.
2986     if echo "$ld_ver" | grep GNU > /dev/null; then
2987       # Assume all interesting versions of GNU ld have TLS support.
2988       # FIXME: still need ld.so.1 support, i.e. ld version checks below.
2989       ld_tls_support=yes
2990     else
2991       case "$target" in
2992         # Solaris 8/x86 ld has GNU style TLS support since version 1.280.
2993         i?86-*-solaris2.8)
2994           min_tls_ld_vers_minor=280
2995           ;;
2996         # Solaris 8/SPARC ld has TLS support since version 1.272.
2997         sparc*-*-solaris2.8)
2998           min_tls_ld_vers_minor=272
2999           ;;
3000         # Solaris 9/x86 ld has GNU style TLS support since version 1.374.
3001         i?86-*-solaris2.9)
3002           min_tls_ld_vers_minor=374
3003           ;;
3004         # Solaris 9/SPARC and Solaris 10+ ld have TLS support since FCS.
3005         sparc*-*-solaris2.9 | *-*-solaris2.1[[0-9]]*)
3006           min_tls_ld_vers_minor=343
3007           ;;
3008       esac
3009       if test "$ls_vers_major" -gt 1 || \
3010         test "$ld_vers_minor" -ge "$min_tls_ld_vers_minor"; then
3011         ld_tls_support=yes
3012       else
3013         set_have_as_tls=no
3014       fi
3015     fi
3016     AC_MSG_RESULT($ld_tls_support)
3017
3018     save_LIBS="$LIBS"
3019     save_LDFLAGS="$LDFLAGS"
3020     LIBS=
3021     LDFLAGS=
3022
3023     AC_MSG_CHECKING(alternate thread library)
3024     case "$target" in
3025       # TLS support was backported to Solaris 8 patches, but only lives in
3026       # the alternate thread library which became the default in Solaris 9.
3027       # We want to always use that, irrespective of TLS support.
3028       *-*-solaris2.8)
3029         # Take multilib subdir into account.  There's no spec to handle
3030         # this.  The 64 symlink exists since Solaris 8.
3031         lwp_dir=/usr/lib/lwp
3032         lwp_spec="-L$lwp_dir%{m64:/64} -R$lwp_dir%{m64:/64}"
3033         LDFLAGS="-L$lwp_dir -R$lwp_dir"
3034         ;;
3035       *-*-solaris2*)
3036         lwp_dir="none"
3037         lwp_spec=""
3038         ;;
3039     esac
3040     # Always define LIB_THREAD_LDFLAGS_SPEC, even without TLS support.
3041     AC_DEFINE_UNQUOTED(LIB_THREAD_LDFLAGS_SPEC, "$lwp_spec",
3042         [Define to the linker flags to use for -pthread.])
3043     AC_MSG_RESULT($lwp_dir)
3044
3045     AC_MSG_CHECKING(library containing $tga_func)
3046     # Before Solaris 10, __tls_get_addr (SPARC/x64) resp. ___tls_get_addr
3047     # (32-bit x86) only lived in libthread, so check for that.  Keep
3048     # set_have_as_tls if found, disable if not.
3049     AC_SEARCH_LIBS([$tga_func], [thread],, [set_have_as_tls=no])
3050     # Clear LIBS if we cannot support TLS.
3051     if test $set_have_as_tls = no; then
3052       LIBS=
3053     fi
3054     # Always define LIB_TLS_SPEC, even without TLS support.
3055     AC_DEFINE_UNQUOTED(LIB_TLS_SPEC, "$LIBS",
3056         [Define to the library containing __tls_get_addr/___tls_get_addr.])
3057     AC_MSG_RESULT($LIBS)
3058
3059     LIBS="$save_LIBS"
3060     LDFLAGS="$save_LDFLAGS"
3061     ;;
3062 esac
3063 if test $set_have_as_tls = yes ; then
3064   AC_DEFINE(HAVE_AS_TLS, 1,
3065             [Define if your assembler and linker support thread-local storage.])
3066 fi
3067
3068 # Target-specific assembler checks.
3069
3070 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3071 gcc_cv_ld_static_dynamic=no
3072 if test $in_tree_ld = yes ; then
3073   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
3074     gcc_cv_ld_static_dynamic=yes
3075   fi
3076 elif test x$gcc_cv_ld != x; then
3077         # Check if linker supports -Bstatic/-Bdynamic option
3078         if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
3079           && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
3080                 gcc_cv_ld_static_dynamic=yes
3081         fi
3082 fi
3083 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3084         AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3085 [Define if your linker supports -Bstatic/-Bdynamic option.])
3086 fi
3087 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3088
3089 if test x"$demangler_in_ld" = xyes; then
3090   AC_MSG_CHECKING(linker --demangle support)
3091   gcc_cv_ld_demangle=no
3092   if test $in_tree_ld = yes; then
3093     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 \
3094       gcc_cv_ld_demangle=yes
3095     fi
3096   elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3097     # Check if the GNU linker supports --demangle option
3098     if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3099       gcc_cv_ld_demangle=yes
3100     fi
3101   fi
3102   if test x"$gcc_cv_ld_demangle" = xyes; then
3103     AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3104 [Define if your linker supports --demangle option.])
3105   fi
3106   AC_MSG_RESULT($gcc_cv_ld_demangle)
3107 fi
3108
3109 case "$target" in
3110   # All TARGET_ABI_OSF targets.
3111   alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
3112     gcc_GAS_CHECK_FEATURE([explicit relocation support],
3113         gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3114 [       .set nomacro
3115         .text
3116         extbl   $3, $2, $3      !lituse_bytoff!1
3117         ldq     $2, a($29)      !literal!1
3118         ldq     $4, b($29)      !literal!2
3119         ldq_u   $3, 0($2)       !lituse_base!1
3120         ldq     $27, f($29)     !literal!5
3121         jsr     $26, ($27), f   !lituse_jsr!5
3122         ldah    $29, 0($26)     !gpdisp!3
3123         lda     $0, c($29)      !gprel
3124         ldah    $1, d($29)      !gprelhigh
3125         lda     $1, d($1)       !gprellow
3126         lda     $29, 0($29)     !gpdisp!3],,
3127     [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3128   [Define if your assembler supports explicit relocations.])])
3129     gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3130         gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3131 [       .set nomacro
3132         .text
3133         ldq     $27, a($29)     !literal!1
3134         jsr     $26, ($27), a   !lituse_jsrdirect!1],,
3135     [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3136   [Define if your assembler supports the lituse_jsrdirect relocation.])])
3137     ;;
3138
3139   cris-*-*)
3140     gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3141       gcc_cv_as_cris_no_mul_bug,[2,15,91],
3142       [-no-mul-bug-abort], [.text],,
3143       [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3144                 [Define if your assembler supports the -no-mul-bug-abort option.])])
3145     ;;
3146
3147   sparc*-*-*)
3148     gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3149       [.register %g2, #scratch],,
3150       [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3151                 [Define if your assembler supports .register.])])
3152
3153     gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3154       [-relax], [.text],,
3155       [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3156                 [Define if your assembler supports -relax option.])])
3157
3158     gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3159       gcc_cv_as_sparc_gotdata_op,,
3160       [-K PIC],
3161 [.text
3162 foo:
3163         nop
3164 bar:
3165         sethi %gdop_hix22(foo), %g1
3166         xor    %g1, %gdop_lox10(foo), %g1
3167         ld    [[%l7 + %g1]], %g2, %gdop(foo)],
3168       [if test x$gcc_cv_ld != x \
3169        && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3170          if $gcc_cv_ld -v | grep GNU >/dev/null 2>&1; then
3171            if test x$gcc_cv_objdump != x; then
3172              if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3173                 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3174                gcc_cv_as_sparc_gotdata_op=no
3175              else
3176                gcc_cv_as_sparc_gotdata_op=yes
3177              fi
3178            fi
3179          else
3180            gcc_cv_as_sparc_gotdata_op=yes
3181          fi
3182        fi
3183        rm -f conftest],
3184       [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3185                 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3186
3187     gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3188       gcc_cv_as_sparc_ua_pcrel,,
3189       [-K PIC],
3190 [.text
3191 foo:
3192         nop
3193 .data
3194 .align 4
3195 .byte 0
3196 .uaword %r_disp32(foo)],
3197       [if test x$gcc_cv_ld != x \
3198        && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3199          gcc_cv_as_sparc_ua_pcrel=yes
3200        fi
3201        rm -f conftest],
3202       [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3203                 [Define if your assembler and linker support unaligned PC relative relocs.])
3204
3205       gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3206         gcc_cv_as_sparc_ua_pcrel_hidden,,
3207         [-K PIC],
3208 [.data
3209 .align 4
3210 .byte 0x31
3211 .uaword %r_disp32(foo)
3212 .byte 0x32, 0x33, 0x34
3213 .global foo
3214 .hidden foo
3215 foo:
3216 .skip 4],
3217         [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3218          && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3219          && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3220             | grep ' 31000000 07323334' > /dev/null 2>&1; then
3221             if $gcc_cv_objdump -R conftest 2> /dev/null \
3222                | grep 'DISP32' > /dev/null 2>&1; then
3223                 :
3224             else
3225                 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3226             fi
3227          fi
3228          rm -f conftest],
3229          [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3230                    [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3231     ]) # unaligned pcrel relocs
3232
3233     gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3234       gcc_cv_as_sparc_offsetable_lo10,,
3235       [-xarch=v9],
3236 [.text
3237         or %g1, %lo(ab) + 12, %g1
3238         or %g1, %lo(ab + 12), %g1],
3239       [if test x$gcc_cv_objdump != x \
3240        && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3241           | grep ' 82106000 82106000' > /dev/null 2>&1; then
3242          gcc_cv_as_sparc_offsetable_lo10=yes
3243        fi],
3244        [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3245                  [Define if your assembler supports offsetable %lo().])])
3246     ;;
3247
3248 changequote(,)dnl
3249   i[34567]86-*-* | x86_64-*-*)
3250 changequote([,])dnl
3251     case $target_os in
3252       cygwin*)
3253         # Full C++ conformance when using a shared libstdc++-v3 requires some
3254         # support from the Cygwin DLL, which in more recent versions exports
3255         # wrappers to aid in interposing and redirecting operators new, delete,
3256         # etc., as per n2800 #17.6.4.6 [replacement.functions].  Check if we
3257         # are configuring for a version of Cygwin that exports the wrappers.
3258         if test x$host = x$target; then
3259           AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3260         else
3261           # Can't check presence of libc functions during cross-compile, so
3262           # we just have to assume we're building for an up-to-date target.
3263           gcc_ac_cygwin_dll_wrappers=yes
3264         fi
3265         AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3266           [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3267           [Define if you want to generate code by default that assumes that the
3268            Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3269     esac
3270     case $target_os in
3271       cygwin* | pe | mingw32*)
3272         # Recent binutils allows the three-operand form of ".comm" on PE.  This
3273         # definition is used unconditionally to initialise the default state of
3274         # the target option variable that governs usage of the feature.
3275         gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3276          [2,19,52],,[.comm foo,1,32])
3277         AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3278           [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3279           [Define if your assembler supports specifying the alignment
3280            of objects allocated using the GAS .comm command.])
3281         # Used for DWARF 2 in PE
3282         gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3283           gcc_cv_as_ix86_pe_secrel32,
3284           [2,15,91],,
3285 [.text
3286 foo:    nop
3287 .data
3288         .secrel32 foo],
3289           [if test x$gcc_cv_ld != x \
3290            && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3291              gcc_cv_as_ix86_pe_secrel32=yes
3292            fi
3293            rm -f conftest],
3294           [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3295             [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3296         # Test if the assembler supports the extended form of the .section
3297         # directive that specifies section alignment.  LTO support uses this,
3298         # but normally only after installation, so we warn but don't fail the
3299         # configure if LTO is enabled but the assembler does not support it.
3300         gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3301           [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3302         if test x$gcc_cv_as_section_has_align != xyes; then
3303           case ",$enable_languages," in
3304             *,lto,*)
3305               AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3306               ;;
3307           esac
3308         fi
3309         ;;
3310     esac
3311
3312     gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3313        gcc_cv_as_ix86_filds,,,
3314        [filds mem; fists mem],,
3315        [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3316          [Define if your assembler uses filds and fists mnemonics.])])
3317
3318     gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3319        gcc_cv_as_ix86_fildq,,,
3320        [fildq mem; fistpq mem],,
3321        [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3322          [Define if your assembler uses fildq and fistq mnemonics.])])
3323
3324     gcc_GAS_CHECK_FEATURE([cmov syntax],
3325       gcc_cv_as_ix86_cmov_sun_syntax,,,
3326       [cmovl.l %edx, %eax],,
3327       [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3328         [Define if your assembler supports the Sun syntax for cmov.])])
3329
3330     gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3331       gcc_cv_as_ix86_ffreep,,,
3332       [ffreep %st(1)],,
3333       [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3334         [Define if your assembler supports the ffreep mnemonic.])])
3335
3336     gcc_GAS_CHECK_FEATURE([.quad directive],
3337       gcc_cv_as_ix86_quad,,,
3338       [.quad 0],,
3339       [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
3340         [Define if your assembler supports the .quad directive.])])
3341
3342     gcc_GAS_CHECK_FEATURE([sahf mnemonic],
3343       gcc_cv_as_ix86_sahf,,,
3344       [.code64
3345        sahf],,
3346       [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
3347         [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
3348
3349     gcc_GAS_CHECK_FEATURE([swap suffix],
3350       gcc_cv_as_ix86_swap,,,
3351       [movl.s %esp, %ebp],,
3352       [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
3353         [Define if your assembler supports the swap suffix.])])
3354
3355     gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
3356       gcc_cv_as_ix86_diff_sect_delta,,,
3357       [.section .rodata
3358 .L1:
3359         .long .L2-.L1
3360         .long .L3-.L1
3361         .text
3362 .L3:    nop
3363 .L2:    nop],,
3364       [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
3365         [Define if your assembler supports the subtraction of symbols in different sections.])])
3366
3367     # These two are used unconditionally by i386.[ch]; it is to be defined
3368     # to 1 if the feature is present, 0 otherwise.
3369     gcc_GAS_CHECK_FEATURE([GOTOFF in data],
3370         gcc_cv_as_ix86_gotoff_in_data, [2,11,0],,
3371 [       .text
3372 .L0:
3373         nop
3374         .data
3375         .long .L0@GOTOFF])
3376     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
3377       [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
3378       [Define true if the assembler supports '.long foo@GOTOFF'.])
3379
3380     gcc_GAS_CHECK_FEATURE([rep and lock prefix],
3381         gcc_cv_as_ix86_rep_lock_prefix,,,
3382         [rep movsl
3383          lock addl %edi, (%eax,%esi)
3384          lock orl $0, (%esp)],,
3385         [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
3386           [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
3387
3388     ;;
3389
3390   ia64*-*-*)
3391     gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
3392         gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
3393 [       .text
3394         addl r15 = @ltoffx(x#), gp
3395         ;;
3396         ld8.mov r16 = [[r15]], x#],,
3397     [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
3398           [Define if your assembler supports ltoffx and ldxmov relocations.])])
3399
3400     ;;
3401
3402   powerpc*-*-*)
3403     case $target in
3404       *-*-aix*) conftest_s='    .machine "pwr5"
3405         .csect .text[[PR]]
3406         mfcr 3,128';;
3407       *-*-darwin*)
3408         gcc_GAS_CHECK_FEATURE([.machine directive support],
3409           gcc_cv_as_machine_directive,,,
3410           [     .machine ppc7400])
3411         if test x$gcc_cv_as_machine_directive != xyes; then
3412           echo "*** This target requires an assembler supporting \".machine\"" >&2
3413           echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
3414           test x$build = x$target && exit 1
3415         fi
3416         conftest_s='    .text
3417         mfcr r3,128';;
3418       *) conftest_s='   .machine power4
3419         .text
3420         mfcr 3,128';;
3421     esac
3422
3423     gcc_GAS_CHECK_FEATURE([mfcr field support],
3424       gcc_cv_as_powerpc_mfcrf, [2,14,0],,
3425       [$conftest_s],,
3426       [AC_DEFINE(HAVE_AS_MFCRF, 1,
3427           [Define if your assembler supports mfcr field.])])
3428
3429     case $target in
3430       *-*-aix*) conftest_s='    .machine "pwr5"
3431         .csect .text[[PR]]
3432         popcntb 3,3';;
3433       *) conftest_s='   .machine power5
3434         .text
3435         popcntb 3,3';;
3436     esac
3437
3438     gcc_GAS_CHECK_FEATURE([popcntb support],
3439       gcc_cv_as_powerpc_popcntb, [2,17,0],,
3440       [$conftest_s],,
3441       [AC_DEFINE(HAVE_AS_POPCNTB, 1,
3442           [Define if your assembler supports popcntb field.])])
3443
3444     case $target in
3445       *-*-aix*) conftest_s='    .machine "pwr5x"
3446         .csect .text[[PR]]
3447         frin 1,1';;
3448       *) conftest_s='   .machine power5
3449         .text
3450         frin 1,1';;
3451     esac
3452
3453     gcc_GAS_CHECK_FEATURE([fp round support],
3454       gcc_cv_as_powerpc_fprnd, [2,17,0],,
3455       [$conftest_s],,
3456       [AC_DEFINE(HAVE_AS_FPRND, 1,
3457           [Define if your assembler supports fprnd.])])
3458
3459     case $target in
3460       *-*-aix*) conftest_s='    .machine "pwr6"
3461         .csect .text[[PR]]
3462         mffgpr 1,3';;
3463       *) conftest_s='   .machine power6
3464         .text
3465         mffgpr 1,3';;
3466     esac
3467
3468     gcc_GAS_CHECK_FEATURE([move fp gpr support],
3469       gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
3470       [$conftest_s],,
3471       [AC_DEFINE(HAVE_AS_MFPGPR, 1,
3472           [Define if your assembler supports mffgpr and mftgpr.])])
3473
3474     case $target in
3475       *-*-aix*) conftest_s='    .csect .text[[PR]]
3476 LCF..0:
3477         addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
3478       *-*-darwin*)
3479         conftest_s='    .text
3480 LCF0:
3481         addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
3482       *) conftest_s='   .text
3483 .LCF0:
3484         addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
3485     esac
3486
3487     gcc_GAS_CHECK_FEATURE([rel16 relocs],
3488       gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
3489       [$conftest_s],,
3490       [AC_DEFINE(HAVE_AS_REL16, 1,
3491           [Define if your assembler supports R_PPC_REL16 relocs.])])
3492
3493     case $target in
3494       *-*-aix*) conftest_s='    .machine "pwr6"
3495         .csect .text[[PR]]
3496         cmpb 3,4,5';;
3497       *) conftest_s='   .machine power6
3498         .text
3499         cmpb 3,4,5';;
3500     esac
3501
3502     gcc_GAS_CHECK_FEATURE([compare bytes support],
3503       gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
3504       [$conftest_s],,
3505       [AC_DEFINE(HAVE_AS_CMPB, 1,
3506           [Define if your assembler supports cmpb.])])
3507
3508     case $target in
3509       *-*-aix*) conftest_s='    .machine "pwr6"
3510         .csect .text[[PR]]
3511         dadd 1,2,3';;
3512       *) conftest_s='   .machine power6
3513         .text
3514         dadd 1,2,3';;
3515     esac
3516
3517     gcc_GAS_CHECK_FEATURE([decimal float support],
3518       gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
3519       [$conftest_s],,
3520       [AC_DEFINE(HAVE_AS_DFP, 1,
3521           [Define if your assembler supports DFP instructions.])])
3522
3523     case $target in
3524       *-*-aix*) conftest_s='    .machine "pwr7"
3525         .csect .text[[PR]]
3526         lxvd2x 1,2,3';;
3527       *) conftest_s='   .machine power7
3528         .text
3529         lxvd2x 1,2,3';;
3530     esac
3531
3532     gcc_GAS_CHECK_FEATURE([vector-scalar support],
3533       gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
3534       [$conftest_s],,
3535       [AC_DEFINE(HAVE_AS_VSX, 1,
3536           [Define if your assembler supports VSX instructions.])])
3537
3538     case $target in
3539       *-*-aix*) conftest_s='    .machine "pwr7"
3540         .csect .text[[PR]]
3541         popcntd 3,3';;
3542       *) conftest_s='   .machine power7
3543         .text
3544         popcntd 3,3';;
3545     esac
3546
3547     gcc_GAS_CHECK_FEATURE([popcntd support],
3548       gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
3549       [$conftest_s],,
3550       [AC_DEFINE(HAVE_AS_POPCNTD, 1,
3551           [Define if your assembler supports POPCNTD instructions.])])
3552
3553     case $target in
3554       *-*-aix*) conftest_s='    .csect .text[[PR]]
3555         lwsync';;
3556       *) conftest_s='   .text
3557         lwsync';;
3558     esac
3559
3560     gcc_GAS_CHECK_FEATURE([lwsync support],
3561       gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
3562       [$conftest_s],,
3563       [AC_DEFINE(HAVE_AS_LWSYNC, 1,
3564           [Define if your assembler supports LWSYNC instructions.])])
3565
3566     case $target in
3567       *-*-aix*) conftest_s='    .machine "476"
3568         .csect .text[[PR]]
3569         dci 0';;
3570       *) conftest_s='   .machine "476"
3571         .text
3572         dci 0';;
3573     esac
3574
3575     gcc_GAS_CHECK_FEATURE([data cache invalidate support],
3576       gcc_cv_as_powerpc_dci, [9,99,0], -a32,
3577       [$conftest_s],,
3578       [AC_DEFINE(HAVE_AS_DCI, 1,
3579           [Define if your assembler supports the DCI/ICI instructions.])])
3580
3581     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3582       gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
3583       [.gnu_attribute 4,1],,
3584       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3585           [Define if your assembler supports .gnu_attribute.])])
3586
3587     gcc_GAS_CHECK_FEATURE([tls marker support],
3588       gcc_cv_as_powerpc_tls_markers, [2,20,0],,
3589       [ bl __tls_get_addr(x@tlsgd)],,
3590       [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
3591           [Define if your assembler supports arg info for __tls_get_addr.])])
3592
3593     case $target in
3594       *-*-aix*)
3595         gcc_GAS_CHECK_FEATURE([.ref support],
3596           gcc_cv_as_aix_ref, [2.21.0],,
3597           [     .csect stuff[[rw]]
3598              stuff:
3599                 .long 1
3600                 .extern sym
3601                 .ref sym
3602           ],,
3603           [AC_DEFINE(HAVE_AS_REF, 1,
3604             [Define if your assembler supports .ref])])
3605         ;;
3606     esac
3607     ;;
3608
3609   mips*-*-*)
3610     gcc_GAS_CHECK_FEATURE([explicit relocation support],
3611       gcc_cv_as_mips_explicit_relocs, [2,14,0],,
3612 [       lw $4,%gp_rel(foo)($4)],,
3613       [if test x$target_cpu_default = x
3614        then target_cpu_default=MASK_EXPLICIT_RELOCS
3615        else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
3616        fi])
3617     gcc_GAS_CHECK_FEATURE([-mno-shared support],
3618       gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
3619       [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
3620                  [Define if the assembler understands -mno-shared.])])
3621
3622     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3623       gcc_cv_as_mips_gnu_attribute, [2,18,0],,
3624       [.gnu_attribute 4,1],,
3625       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3626           [Define if your assembler supports .gnu_attribute.])])
3627
3628     gcc_GAS_CHECK_FEATURE([.dtprelword support],
3629       gcc_cv_as_mips_dtprelword, [2,18,0],,
3630       [.section .tdata,"awT",@progbits
3631 x:
3632         .word 2
3633         .text
3634         .dtprelword x+0x8000],,
3635       [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
3636           [Define if your assembler supports .dtprelword.])])
3637
3638     AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
3639     gcc_cv_as_ld_jalr_reloc=no
3640     if test $gcc_cv_as_mips_explicit_relocs = yes; then
3641       if test $in_tree_ld = yes ; then
3642         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 \
3643            && test $in_tree_ld_is_elf = yes; then
3644           gcc_cv_as_ld_jalr_reloc=yes
3645         fi
3646       elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
3647         echo '  .ent x' > conftest.s
3648         echo 'x:        ld $2,%got_disp(y)($3)' >> conftest.s
3649         echo '  ld $25,%call16(y)($28)' >> conftest.s
3650         echo '  .reloc  1f,R_MIPS_JALR,y' >> conftest.s
3651         echo '1:        jalr $25' >> conftest.s
3652         echo '  .reloc  1f,R_MIPS_JALR,x' >> conftest.s
3653         echo '1:        jalr $25' >> conftest.s
3654         echo '  .end x' >> conftest.s
3655         if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
3656            && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
3657           if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
3658              && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
3659             gcc_cv_as_ld_jalr_reloc=yes
3660           fi
3661         fi
3662         rm -f conftest.*
3663       fi
3664     fi
3665     if test $gcc_cv_as_ld_jalr_reloc = yes; then
3666       if test x$target_cpu_default = x; then
3667         target_cpu_default=MASK_RELAX_PIC_CALLS
3668       else
3669         target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
3670       fi
3671     fi
3672     AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
3673
3674     AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
3675       [gcc_cv_ld_mips_personality_relaxation],
3676       [gcc_cv_ld_mips_personality_relaxation=no
3677        if test $in_tree_ld = yes ; then
3678          if test "$gcc_cv_gld_major_version" -eq 2 \
3679                  -a "$gcc_cv_gld_minor_version" -ge 21 \
3680                  -o "$gcc_cv_gld_major_version" -gt 2; then
3681            gcc_cv_ld_mips_personality_relaxation=yes
3682          fi
3683        elif test x$gcc_cv_as != x \
3684                  -a x$gcc_cv_ld != x \
3685                  -a x$gcc_cv_readelf != x ; then
3686          cat > conftest.s <<EOF
3687         .cfi_startproc
3688         .cfi_personality 0x80,indirect_ptr
3689         .ent test
3690 test:
3691         nop
3692         .end test
3693         .cfi_endproc
3694
3695         .section .data,"aw",@progbits
3696 indirect_ptr:
3697         .dc.a personality
3698 EOF
3699          if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
3700             && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
3701            if $gcc_cv_readelf -d conftest 2>&1 \
3702               | grep TEXTREL > /dev/null 2>&1; then
3703              :
3704            elif $gcc_cv_readelf --relocs conftest 2>&1 \
3705                 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
3706              :
3707            else
3708              gcc_cv_ld_mips_personality_relaxation=yes
3709            fi
3710          fi
3711        fi
3712        rm -f conftest.s conftest.o conftest])
3713     if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
3714             AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
3715       [Define if your linker can relax absolute .eh_frame personality
3716 pointers into PC-relative form.])
3717     fi
3718     ;;
3719 esac
3720
3721 # Mips and HP-UX need the GNU assembler.
3722 # Linux on IA64 might be able to use the Intel assembler.
3723
3724 case "$target" in
3725   mips*-*-* | *-*-hpux* )
3726     if test x$gas_flag = xyes \
3727        || test x"$host" != x"$build" \
3728        || test ! -x "$gcc_cv_as" \
3729        || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
3730       :
3731     else
3732       echo "*** This configuration requires the GNU assembler" >&2
3733       exit 1
3734     fi
3735     ;;
3736 esac
3737
3738 # ??? Not all targets support dwarf2 debug_line, even within a version
3739 # of gas.  Moreover, we need to emit a valid instruction to trigger any
3740 # info to the output file.  So, as supported targets are added to gas 2.11,
3741 # add some instruction here to (also) show we expect this might work.
3742 # ??? Once 2.11 is released, probably need to add first known working
3743 # version to the per-target configury.
3744 case "$target" in
3745   i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* \
3746   | x86_64*-*-* | hppa*-*-* | arm*-*-* \
3747   | xstormy16*-*-* | cris-*-* | crisv32-*-* | xtensa*-*-* | bfin-*-* | score*-*-* \
3748   | spu-*-* | fido*-*-* | m32c-*-* | microblaze-*-*)
3749     insn="nop"
3750     ;;
3751   ia64*-*-* | s390*-*-*)
3752     insn="nop 0"
3753     ;;
3754   mmix-*-*)
3755     insn="swym 0"
3756     ;;
3757 esac
3758 if test x"$insn" != x; then
3759  conftest_s="\
3760         .file 1 \"conftest.s\"
3761         .loc 1 3 0
3762         $insn"
3763  gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
3764   gcc_cv_as_dwarf2_debug_line,
3765   [elf,2,11,0],, [$conftest_s],
3766   [if test x$gcc_cv_objdump != x \
3767    && $gcc_cv_objdump -h conftest.o 2> /dev/null \
3768       | grep debug_line > /dev/null 2>&1; then
3769      gcc_cv_as_dwarf2_debug_line=yes
3770    fi])
3771
3772 # The .debug_line file table must be in the exact order that
3773 # we specified the files, since these indices are also used
3774 # by DW_AT_decl_file.  Approximate this test by testing if
3775 # the assembler bitches if the same index is assigned twice.
3776  gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
3777   gcc_cv_as_dwarf2_file_buggy,,,
3778 [       .file 1 "foo.s"
3779         .file 1 "bar.s"])
3780
3781  if test $gcc_cv_as_dwarf2_debug_line = yes \
3782  && test $gcc_cv_as_dwarf2_file_buggy = no; then
3783         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
3784   [Define if your assembler supports dwarf2 .file/.loc directives,
3785    and preserves file table indices exactly as given.])
3786  fi
3787
3788  gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
3789   gcc_cv_as_gdwarf2_flag,
3790   [elf,2,11,0], [--gdwarf2], [$insn],,
3791   [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
3792 [Define if your assembler supports the --gdwarf2 option.])])
3793
3794  gcc_GAS_CHECK_FEATURE([--gstabs option],
3795   gcc_cv_as_gstabs_flag,
3796   [elf,2,11,0], [--gstabs], [$insn],
3797   [# The native Solaris 9/Intel assembler doesn't understand --gstabs
3798    # and warns about it, but still exits successfully.  So check for
3799    # this.
3800    if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
3801    then :
3802    else gcc_cv_as_gstabs_flag=yes
3803    fi],
3804   [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
3805 [Define if your assembler supports the --gstabs option.])])
3806
3807  gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
3808   gcc_cv_as_debug_prefix_map_flag,
3809   [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
3810   [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
3811 [Define if your assembler supports the --debug-prefix-map option.])])
3812 fi
3813
3814 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
3815  ,,
3816 [.lcomm bar,4,16],,
3817 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
3818   [Define if your assembler supports .lcomm with an alignment field.])])
3819
3820 AC_ARG_ENABLE(gnu-unique-object,
3821  [  --enable-gnu-unique-object  enable the use of the @gnu_unique_object ELF extension on
3822                                 glibc systems],
3823  [case $enable_gnu_unique_object in
3824     yes | no) ;;
3825     *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
3826 Valid choices are 'yes' and 'no'.]) ;;
3827   esac],
3828  [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
3829    [elf,2,19,52],,
3830    [.type foo, @gnu_unique_object],,
3831 # Also check for ld.so support, i.e. glibc 2.11 or higher.
3832    [[if test x$host = x$build -a x$host = x$target &&
3833        glibcver=`ldd --version 2>/dev/null | sed 's/.* //;q'`; then
3834       glibcmajor=`expr "$glibcver" : "\([0-9]*\)"`
3835       glibcminor=`expr "$glibcver" : "[2-9]*\.\([0-9]*\)"`
3836       glibcnum=`expr $glibcmajor \* 1000 + $glibcminor`
3837       if test "$glibcnum" -ge 2011 ; then
3838         enable_gnu_unique_object=yes
3839       fi
3840     fi]])])
3841 if test x$enable_gnu_unique_object = xyes; then
3842   AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
3843    [Define if your assembler supports @gnu_unique_object.])
3844 fi
3845
3846 AC_CACHE_CHECK([assembler for tolerance to line number 0],
3847  [gcc_cv_as_line_zero],
3848  [gcc_cv_as_line_zero=no
3849   if test $in_tree_gas = yes; then
3850     gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
3851   elif test "x$gcc_cv_as" != x; then
3852     { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
3853     if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
3854        test "x`cat conftest.out`" = x
3855     then
3856       gcc_cv_as_line_zero=yes
3857     else
3858       echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
3859       cat conftest.s >&AS_MESSAGE_LOG_FD
3860       echo "configure: error output was" >&AS_MESSAGE_LOG_FD
3861       cat conftest.out >&AS_MESSAGE_LOG_FD
3862     fi
3863     rm -f conftest.o conftest.s conftest.out
3864   fi])
3865 if test "x$gcc_cv_as_line_zero" = xyes; then
3866   AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
3867 [Define if the assembler won't complain about a line such as # 0 "" 2.])
3868 fi
3869
3870 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
3871 gcc_cv_ld_eh_frame_hdr=no
3872 if test $in_tree_ld = yes ; then
3873   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 \
3874      && test $in_tree_ld_is_elf = yes; then
3875     gcc_cv_ld_eh_frame_hdr=yes
3876   fi
3877 elif test x$gcc_cv_ld != x; then
3878         # Check if linker supports --eh-frame-hdr option
3879         if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
3880                 gcc_cv_ld_eh_frame_hdr=yes
3881         fi
3882 fi
3883 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
3884 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
3885         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
3886 [Define if your linker supports --eh-frame-hdr option.])
3887 fi
3888 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
3889
3890 AC_MSG_CHECKING(linker position independent executable support)
3891 gcc_cv_ld_pie=no
3892 if test $in_tree_ld = yes ; then
3893   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 \
3894      && test $in_tree_ld_is_elf = yes; then
3895     gcc_cv_ld_pie=yes
3896   fi
3897 elif test x$gcc_cv_ld != x; then
3898         # Check if linker supports -pie option
3899         if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
3900                 gcc_cv_ld_pie=yes
3901         fi
3902 fi
3903 if test x"$gcc_cv_ld_pie" = xyes; then
3904         AC_DEFINE(HAVE_LD_PIE, 1,
3905 [Define if your linker supports -pie option.])
3906 fi
3907 AC_MSG_RESULT($gcc_cv_ld_pie)
3908
3909 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
3910 gcc_cv_ld_eh_gc_sections=no
3911 if test $in_tree_ld = yes ; then
3912   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 \
3913      && test $in_tree_ld_is_elf = yes; then
3914     gcc_cv_ld_eh_gc_sections=yes
3915   fi
3916 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
3917   cat > conftest.s <<EOF
3918         .section        .text
3919 .globl _start
3920         .type _start, @function
3921 _start:
3922         .long foo
3923         .size _start, .-_start
3924         .section        .text.foo,"ax",@progbits
3925         .type foo, @function
3926 foo:
3927         .long 0
3928         .size foo, .-foo
3929         .section        .gcc_except_table.foo,"a",@progbits
3930 .L0:
3931         .long 0
3932         .section        .eh_frame,"a",@progbits
3933         .long .L0
3934 EOF
3935   if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
3936     if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
3937          | grep "gc-sections option ignored" > /dev/null; then
3938       gcc_cv_ld_eh_gc_sections=no
3939     elif $gcc_cv_objdump -h conftest 2> /dev/null \
3940          | grep gcc_except_table > /dev/null; then
3941       gcc_cv_ld_eh_gc_sections=yes
3942       # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
3943       if test x$gcc_cv_as_comdat_group != xyes; then
3944         gcc_cv_ld_eh_gc_sections=no
3945         cat > conftest.s <<EOF
3946         .section        .text
3947 .globl _start
3948         .type _start, @function
3949 _start:
3950         .long foo
3951         .size _start, .-_start
3952         .section        .gnu.linkonce.t.foo,"ax",@progbits
3953         .type foo, @function
3954 foo:
3955         .long 0
3956         .size foo, .-foo
3957         .section        .gcc_except_table.foo,"a",@progbits
3958 .L0:
3959         .long 0
3960         .section        .eh_frame,"a",@progbits
3961         .long .L0
3962 EOF
3963         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
3964           if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
3965                | grep "gc-sections option ignored" > /dev/null; then
3966             gcc_cv_ld_eh_gc_sections=no
3967           elif $gcc_cv_objdump -h conftest 2> /dev/null \
3968                | grep gcc_except_table > /dev/null; then
3969             gcc_cv_ld_eh_gc_sections=yes
3970           fi
3971         fi
3972       fi
3973     fi
3974   fi
3975   rm -f conftest.s conftest.o conftest
3976 fi
3977 case "$target" in
3978   hppa*-*-linux*)
3979     # ??? This apparently exposes a binutils bug with PC-relative relocations.
3980     gcc_cv_ld_eh_gc_sections=no
3981     ;;
3982 esac
3983 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
3984         AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
3985   [Define if your linker supports garbage collection of
3986    sections in presence of EH frames.])
3987 fi
3988 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
3989
3990 # --------
3991 # UNSORTED
3992 # --------
3993
3994 AC_CACHE_CHECK(linker --as-needed support,
3995 gcc_cv_ld_as_needed,
3996 [gcc_cv_ld_as_needed=no
3997 if test $in_tree_ld = yes ; then
3998   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 \
3999      && test $in_tree_ld_is_elf = yes; then
4000     gcc_cv_ld_as_needed=yes
4001   fi
4002 elif test x$gcc_cv_ld != x; then
4003         # Check if linker supports --as-needed and --no-as-needed options
4004         if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
4005                 gcc_cv_ld_as_needed=yes
4006         fi
4007 fi
4008 ])
4009 if test x"$gcc_cv_ld_as_needed" = xyes; then
4010         AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
4011 [Define if your linker supports --as-needed and --no-as-needed options.])
4012 fi
4013
4014 case "$target:$tm_file" in
4015   powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
4016     AC_CACHE_CHECK(linker support for omitting dot symbols,
4017     gcc_cv_ld_no_dot_syms,
4018     [gcc_cv_ld_no_dot_syms=no
4019     if test $in_tree_ld = yes ; then
4020       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
4021         gcc_cv_ld_no_dot_syms=yes
4022       fi
4023     elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4024       cat > conftest1.s <<EOF
4025         .text
4026         bl .foo
4027 EOF
4028       cat > conftest2.s <<EOF
4029         .section ".opd","aw"
4030         .align 3
4031         .globl foo
4032         .type foo,@function
4033 foo:
4034         .quad .LEfoo,.TOC.@tocbase,0
4035         .text
4036 .LEfoo:
4037         blr
4038         .size foo,.-.LEfoo
4039 EOF
4040       if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4041          && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4042          && $gcc_cv_ld -melf64ppc -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
4043         gcc_cv_ld_no_dot_syms=yes
4044       fi
4045       rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
4046     fi
4047     ])
4048     if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
4049       AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
4050     [Define if your PowerPC64 linker only needs function descriptor syms.])
4051     fi
4052
4053     AC_CACHE_CHECK(linker large toc support,
4054     gcc_cv_ld_large_toc,
4055     [gcc_cv_ld_large_toc=no
4056     if test $in_tree_ld = yes ; then
4057       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
4058         gcc_cv_ld_large_toc=yes
4059       fi
4060     elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4061       cat > conftest.s <<EOF
4062         .section ".tbss","awT",@nobits
4063         .align 3
4064 ie0:    .space 8
4065         .global _start
4066         .text
4067 _start:
4068         addis 9,13,ie0@got@tprel@ha
4069         ld 9,ie0@got@tprel@l(9)
4070 EOF
4071       if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
4072          && $gcc_cv_ld -melf64ppc --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
4073         gcc_cv_ld_large_toc=yes
4074       fi
4075       rm -f conftest conftest.o conftest.s
4076     fi
4077     ])
4078     if test x"$gcc_cv_ld_large_toc" = xyes; then
4079       AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4080     [Define if your PowerPC64 linker supports a large TOC.])
4081     fi
4082     ;;
4083 esac
4084
4085 AC_CACHE_CHECK(linker --build-id support,
4086   gcc_cv_ld_buildid,
4087   [gcc_cv_ld_buildid=no
4088   if test $in_tree_ld = yes ; then
4089     if test "$gcc_cv_gld_major_version" -eq 2 -a \
4090        "$gcc_cv_gld_minor_version" -ge 18 -o \
4091        "$gcc_cv_gld_major_version" -gt 2 \
4092        && test $in_tree_ld_is_elf = yes; then
4093       gcc_cv_ld_buildid=yes
4094     fi
4095   elif test x$gcc_cv_ld != x; then
4096     if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
4097       gcc_cv_ld_buildid=yes
4098     fi
4099   fi])
4100 if test x"$gcc_cv_ld_buildid" = xyes; then
4101   AC_DEFINE(HAVE_LD_BUILDID, 1,
4102   [Define if your linker supports --build-id.])
4103 fi
4104
4105 AC_ARG_ENABLE(linker-build-id,
4106 [  --enable-linker-build-id
4107                           compiler will always pass --build-id to linker],
4108 [],
4109 enable_linker_build_id=no)
4110
4111 if test x"$enable_linker_build_id" = xyes; then
4112   if test x"$gcc_cv_ld_buildid" = xyes; then
4113     AC_DEFINE(ENABLE_LD_BUILDID, 1,
4114     [Define if gcc should always pass --build-id to linker.])
4115   else
4116     AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
4117   fi
4118 fi
4119
4120 # In binutils 2.21, GNU ld gained support for new emulations fully
4121 # supporting the Solaris 2 ABI.  Detect their presence in the linker used.
4122 AC_CACHE_CHECK(linker *_sol2 emulation support,
4123   gcc_cv_ld_sol2_emulation,
4124   [gcc_cv_ld_sol2_emulation=no
4125   if test $in_tree_ld = yes ; then
4126     if test "$gcc_cv_gld_major_version" -eq 2 -a \
4127        "$gcc_cv_gld_minor_version" -ge 21 -o \
4128        "$gcc_cv_gld_major_version" -gt 2 \
4129        && test $in_tree_ld_is_elf = yes; then
4130       gcc_cv_ld_sol2_emulation=yes
4131     fi
4132   elif test x$gcc_cv_ld != x; then
4133     if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
4134        grep _sol2 > /dev/null; then
4135       gcc_cv_ld_sol2_emulation=yes
4136     fi
4137   fi])
4138 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
4139   AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
4140   [Define if your linker supports the *_sol2 emulations.])
4141 fi
4142
4143 AC_CACHE_CHECK(linker --sysroot support,
4144   gcc_cv_ld_sysroot,
4145   [gcc_cv_ld_sysroot=no
4146   if test $in_tree_ld = yes ; then
4147       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
4148         gcc_cv_ld_sysroot=yes
4149       fi
4150   elif test x$gcc_cv_ld != x; then
4151     if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
4152       gcc_cv_ld_sysroot=yes
4153     fi
4154   fi])
4155 if test x"$gcc_cv_ld_sysroot" = xyes; then
4156   AC_DEFINE(HAVE_LD_SYSROOT, 1,
4157   [Define if your linker supports --sysroot.])
4158 fi
4159
4160 if test x$with_sysroot = x && test x$host = x$target \
4161    && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4162    && test "$prefix" != "NONE"; then
4163   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4164 [Define to PREFIX/include if cpp should also search that directory.])
4165 fi
4166
4167 # Test for stack protector support in target C library.
4168 AC_CACHE_CHECK(__stack_chk_fail in target C library,
4169       gcc_cv_libc_provides_ssp,
4170       [gcc_cv_libc_provides_ssp=no
4171     case "$target" in
4172        *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
4173       if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4174         if test "x$with_headers" != x; then
4175           glibc_header_dir=$with_headers
4176         elif test "x$with_sysroot" = x; then
4177           glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-include"
4178         elif test "x$with_build_sysroot" != "x"; then
4179           glibc_header_dir="${with_build_sysroot}/usr/include"
4180         elif test "x$with_sysroot" = xyes; then
4181           glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-root/usr/include"
4182         else
4183           glibc_header_dir="${with_sysroot}/usr/include"
4184         fi
4185       else
4186         glibc_header_dir=/usr/include
4187       fi
4188       [# glibc 2.4 and later provides __stack_chk_fail and
4189       # either __stack_chk_guard, or TLS access to stack guard canary.
4190       if test -f $glibc_header_dir/features.h \
4191          && $EGREP '^[  ]*#[    ]*define[       ]+__GNU_LIBRARY__[      ]+([1-9][0-9]|[6-9])' \
4192             $glibc_header_dir/features.h > /dev/null; then
4193         if $EGREP '^[   ]*#[    ]*define[       ]+__GLIBC__[    ]+([1-9][0-9]|[3-9])' \
4194            $glibc_header_dir/features.h > /dev/null; then
4195           gcc_cv_libc_provides_ssp=yes
4196         elif $EGREP '^[         ]*#[    ]*define[       ]+__GLIBC__[    ]+2' \
4197              $glibc_header_dir/features.h > /dev/null \
4198              && $EGREP '^[      ]*#[    ]*define[       ]+__GLIBC_MINOR__[      ]+([1-9][0-9]|[4-9])' \
4199              $glibc_header_dir/features.h > /dev/null; then
4200           gcc_cv_libc_provides_ssp=yes
4201         elif $EGREP '^[         ]*#[    ]*define[       ]+__UCLIBC__[   ]+1' \
4202              $glibc_header_dir/features.h > /dev/null && \
4203              test -f $glibc_header_dir/bits/uClibc_config.h && \
4204              $EGREP '^[         ]*#[    ]*define[       ]+__UCLIBC_HAS_SSP__[   ]+1' \
4205              $glibc_header_dir/bits/uClibc_config.h > /dev/null; then
4206           gcc_cv_libc_provides_ssp=yes
4207         fi
4208       fi]
4209         ;;
4210        *-*-gnu*)
4211          # Avoid complicated tests (see
4212          # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
4213          # simply assert that glibc does provide this, which is true for all
4214          # realistically usable GNU/Hurd configurations.
4215          gcc_cv_libc_provides_ssp=yes;;
4216        *-*-darwin* | *-*-freebsd*)
4217          AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
4218            [echo "no __stack_chk_fail on this target"])
4219         ;;
4220   *) gcc_cv_libc_provides_ssp=no ;;
4221     esac])
4222
4223 if test x$gcc_cv_libc_provides_ssp = xyes; then
4224   AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
4225             [Define if your target C library provides stack protector support])
4226 fi
4227
4228 # Check if TFmode long double should be used by default or not.
4229 # Some glibc targets used DFmode long double, but with glibc 2.4
4230 # and later they can use TFmode.
4231 case "$target" in
4232   powerpc*-*-linux* | \
4233   powerpc*-*-gnu* | \
4234   sparc*-*-linux* | \
4235   s390*-*-linux* | \
4236   alpha*-*-linux*)
4237     AC_ARG_WITH(long-double-128,
4238 [  --with-long-double-128  Use 128-bit long double by default.],
4239       gcc_cv_target_ldbl128="$with_long_double_128",
4240       [[gcc_cv_target_ldbl128=no
4241       if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4242         if test "x$with_sysroot" = x; then
4243           glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-include"
4244         elif test "x$with_build_sysroot" != "x"; then
4245           glibc_header_dir="${with_build_sysroot}/usr/include"
4246         elif test "x$with_sysroot" = xyes; then
4247           glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-root/usr/include"
4248         else
4249           glibc_header_dir="${with_sysroot}/usr/include"
4250         fi
4251       else
4252         glibc_header_dir=/usr/include
4253       fi
4254       grep '^[  ]*#[    ]*define[       ][      ]*__LONG_DOUBLE_MATH_OPTIONAL' \
4255         $glibc_header_dir/bits/wordsize.h > /dev/null 2>&1 \
4256       && gcc_cv_target_ldbl128=yes
4257       ]])
4258     ;;
4259 esac
4260 if test x$gcc_cv_target_ldbl128 = xyes; then
4261   AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
4262             [Define if TFmode long double should be the default])
4263 fi
4264
4265 # Find out what GC implementation we want, or may, use.
4266 AC_ARG_WITH(gc,
4267 [  --with-gc={page,zone}   choose the garbage collection mechanism to use
4268                           with the compiler],
4269 [case "$withval" in
4270   page)
4271     GGC=ggc-$withval
4272     ;;
4273   zone)
4274     GGC=ggc-$withval
4275     AC_DEFINE(GGC_ZONE, 1, [Define if the zone collector is in use])
4276     ;;
4277   *)
4278     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
4279     ;;
4280 esac],
4281 [GGC=ggc-page])
4282 AC_SUBST(GGC)
4283 echo "Using $GGC for garbage collection."
4284
4285 # Libraries to use on the host.  This will normally be set by the top
4286 # level Makefile.  Here we simply capture the value for our Makefile.
4287 if test -z "${HOST_LIBS+set}"; then
4288   HOST_LIBS=
4289 fi
4290 AC_SUBST(HOST_LIBS)
4291
4292 # Use the system's zlib library.
4293 zlibdir=-L../zlib
4294 zlibinc="-I\$(srcdir)/../zlib"
4295 AC_ARG_WITH(system-zlib,
4296 [  --with-system-zlib      use installed libz],
4297 zlibdir=
4298 zlibinc=
4299 )
4300 AC_SUBST(zlibdir)
4301 AC_SUBST(zlibinc)
4302
4303 dnl Very limited version of automake's enable-maintainer-mode
4304
4305 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
4306   dnl maintainer-mode is disabled by default
4307   AC_ARG_ENABLE(maintainer-mode,
4308 [  --enable-maintainer-mode
4309                           enable make rules and dependencies not useful
4310                           (and sometimes confusing) to the casual installer],
4311       maintainer_mode=$enableval,
4312       maintainer_mode=no)
4313
4314 AC_MSG_RESULT($maintainer_mode)
4315
4316 if test "$maintainer_mode" = "yes"; then
4317   MAINT=''
4318 else
4319   MAINT='#'
4320 fi
4321 AC_SUBST(MAINT)dnl
4322
4323 # --------------
4324 # Language hooks
4325 # --------------
4326
4327 # Make empty files to contain the specs and options for each language.
4328 # Then add #include lines to for a compiler that has specs and/or options.
4329
4330 subdirs=
4331 lang_opt_files=
4332 lang_specs_files=
4333 lang_tree_files=
4334 # These (without "all_") are set in each config-lang.in.
4335 # `language' must be a single word so is spelled singularly.
4336 all_languages=
4337 all_compilers=
4338 all_outputs='Makefile gccbug'
4339 # List of language makefile fragments.
4340 all_lang_makefrags=
4341 # Additional files for gengtype
4342 all_gtfiles="$target_gtfiles"
4343
4344 # These are the languages that are set in --enable-languages,
4345 # and are available in the GCC tree.
4346 all_selected_languages=
4347
4348 # Add the language fragments.
4349 # Languages are added via two mechanisms.  Some information must be
4350 # recorded in makefile variables, these are defined in config-lang.in.
4351 # We accumulate them and plug them into the main Makefile.
4352 # The other mechanism is a set of hooks for each of the main targets
4353 # like `clean', `install', etc.
4354
4355 language_hooks="Make-hooks"
4356
4357 for lang in ${srcdir}/*/config-lang.in
4358 do
4359 changequote(,)dnl
4360         test "$lang" = "${srcdir}/*/config-lang.in" && continue
4361
4362         lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
4363         if test "x$lang_alias" = x
4364         then
4365               echo "$lang doesn't set \$language." 1>&2
4366               exit 1
4367         fi
4368         subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
4369         subdirs="$subdirs $subdir"
4370
4371         # $gcc_subdir is where the gcc integration files are to be found
4372         # for a language, both for internal compiler purposes (compiler
4373         # sources implementing front-end to GCC tree converters), and for
4374         # build infrastructure purposes (Make-lang.in, etc.)
4375         #
4376         # This will be <subdir> (relative to $srcdir) if a line like
4377         # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
4378         # is found in <langdir>/config-lang.in, and will remain <langdir>
4379         # otherwise.
4380         #
4381         # Except for the language alias (fetched above), the regular
4382         # "config-lang.in" contents are always retrieved from $gcc_subdir,
4383         # so a <langdir>/config-lang.in setting gcc_subdir typically sets
4384         # only this and the language alias.
4385
4386         gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^   ]*\).*$,\1,p' $lang`
4387         if [ "$gcc_subdir" = "" ]; then
4388            gcc_subdir="$subdir"
4389         fi
4390
4391         case ",$enable_languages," in
4392         *,$lang_alias,*)
4393             all_selected_languages="$all_selected_languages $lang_alias"
4394             if test -f $srcdir/$gcc_subdir/lang-specs.h; then
4395                 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
4396             fi
4397             ;;
4398         esac
4399 changequote([,])dnl
4400
4401         language=
4402         boot_language=
4403         compilers=
4404         outputs=
4405         gtfiles=
4406         subdir_requires=
4407         . ${srcdir}/$gcc_subdir/config-lang.in
4408         if test "x$language" = x
4409         then
4410                 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
4411                 exit 1
4412         fi
4413
4414         ok=:
4415         case ",$enable_languages," in
4416                 *,$lang_alias,*) ;;
4417                 *)
4418                         for i in $subdir_requires; do
4419                                 test -f "${srcdir}/$i/config-lang.in" && continue
4420                                 ok=false
4421                                 break
4422                         done
4423                 ;;
4424         esac
4425         $ok || continue
4426
4427         all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
4428         if test -f $srcdir/$gcc_subdir/lang.opt; then
4429             lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
4430         fi
4431         if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
4432             lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
4433         fi
4434         all_languages="$all_languages $language"
4435         all_compilers="$all_compilers $compilers"
4436         all_outputs="$all_outputs $outputs"
4437         all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
4438         case ",$enable_languages," in
4439                 *,lto,*)
4440                     AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
4441                     enable_lto=yes
4442                     AC_SUBST(enable_lto)
4443                     # LTO needs to speak the platform's object file format, and has a
4444                     # number of implementations of the required binary file access APIs.
4445                     # ELF is the most common, and default.  We only link libelf if ELF
4446                     # is indeed the selected format.
4447                     LTO_BINARY_READER=${lto_binary_reader}
4448                     LTO_USE_LIBELF=-lelf
4449                     if test "x$lto_binary_reader" != "xlto-elf" ; then
4450                       LTO_USE_LIBELF=
4451                     fi
4452                     AC_SUBST(LTO_BINARY_READER)
4453                     AC_SUBST(LTO_USE_LIBELF)
4454                     ;;
4455                 *) ;;
4456         esac
4457 done
4458
4459 # Pick up gtfiles for c
4460 gtfiles=
4461 . ${srcdir}/c-config-lang.in
4462 all_gtfiles="$all_gtfiles [[c]] $gtfiles"
4463
4464 check_languages=
4465 for language in $all_selected_languages
4466 do
4467         check_languages="$check_languages check-$language"
4468 done
4469
4470 # We link each language in with a set of hooks, reached indirectly via
4471 # lang.${target}.  Only do so for selected languages.
4472
4473 rm -f Make-hooks
4474 touch Make-hooks
4475 target_list="all.cross start.encap rest.encap tags \
4476         install-common install-man install-info install-pdf install-html dvi \
4477         pdf html uninstall info man srcextra srcman srcinfo \
4478         mostlyclean clean distclean maintainer-clean install-plugin"
4479
4480 for t in $target_list
4481 do
4482         x=
4483         for lang in $all_selected_languages
4484         do
4485                 x="$x $lang.$t"
4486         done
4487         echo "lang.$t: $x" >> Make-hooks
4488 done
4489
4490 # --------
4491 # UNSORTED
4492 # --------
4493
4494 # Create .gdbinit.
4495
4496 echo "dir ." > .gdbinit
4497 echo "dir ${srcdir}" >> .gdbinit
4498 if test x$gdb_needs_out_file_path = xyes
4499 then
4500         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
4501 fi
4502 if test "x$subdirs" != x; then
4503         for s in $subdirs
4504         do
4505                 echo "dir ${srcdir}/$s" >> .gdbinit
4506         done
4507 fi
4508 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
4509
4510 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
4511 AC_SUBST(gcc_tooldir)
4512 AC_SUBST(dollar)
4513
4514 # Find a directory in which to install a shared libgcc.
4515
4516 AC_ARG_ENABLE(version-specific-runtime-libs,
4517 [  --enable-version-specific-runtime-libs
4518                           specify that runtime libraries should be
4519                           installed in a compiler-specific directory])
4520
4521 AC_ARG_WITH(slibdir,
4522 [  --with-slibdir=DIR      shared libraries in DIR [[LIBDIR]]],
4523 slibdir="$with_slibdir",
4524 if test "${enable_version_specific_runtime_libs+set}" = set; then
4525   slibdir='$(libsubdir)'
4526 elif test "$host" != "$target"; then
4527   slibdir='$(build_tooldir)/lib'
4528 else
4529   slibdir='$(libdir)'
4530 fi)
4531 AC_SUBST(slibdir)
4532
4533 # Substitute configuration variables
4534 AC_SUBST(subdirs)
4535 AC_SUBST(srcdir)
4536 AC_SUBST(all_compilers)
4537 AC_SUBST(all_gtfiles)
4538 AC_SUBST(all_lang_makefrags)
4539 AC_SUBST(all_languages)
4540 AC_SUBST(all_selected_languages)
4541 AC_SUBST(build_exeext)
4542 AC_SUBST(build_install_headers_dir)
4543 AC_SUBST(build_xm_file_list)
4544 AC_SUBST(build_xm_include_list)
4545 AC_SUBST(build_xm_defines)
4546 AC_SUBST(build_file_translate)
4547 AC_SUBST(check_languages)
4548 AC_SUBST(cpp_install_dir)
4549 AC_SUBST(xmake_file)
4550 AC_SUBST(tmake_file)
4551 AC_SUBST(TM_ENDIAN_CONFIG)
4552 AC_SUBST(TM_MULTILIB_CONFIG)
4553 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
4554 AC_SUBST(extra_gcc_objs)
4555 AC_SUBST(user_headers_inc_next_pre)
4556 AC_SUBST(user_headers_inc_next_post)
4557 AC_SUBST(extra_headers_list)
4558 AC_SUBST(extra_objs)
4559 AC_SUBST(extra_parts)
4560 AC_SUBST(extra_passes)
4561 AC_SUBST(extra_programs)
4562 AC_SUBST(float_h_file)
4563 AC_SUBST(gcc_config_arguments)
4564 AC_SUBST(gcc_gxx_include_dir)
4565 AC_SUBST(host_exeext)
4566 AC_SUBST(host_xm_file_list)
4567 AC_SUBST(host_xm_include_list)
4568 AC_SUBST(host_xm_defines)
4569 AC_SUBST(out_host_hook_obj)
4570 AC_SUBST(install)
4571 AC_SUBST(lang_opt_files)
4572 AC_SUBST(lang_specs_files)
4573 AC_SUBST(lang_tree_files)
4574 AC_SUBST(local_prefix)
4575 AC_SUBST(md_file)
4576 AC_SUBST(objc_boehm_gc)
4577 AC_SUBST(out_file)
4578 AC_SUBST(out_object_file)
4579 AC_SUBST(thread_file)
4580 AC_SUBST(tm_file_list)
4581 AC_SUBST(tm_include_list)
4582 AC_SUBST(tm_defines)
4583 AC_SUBST(tm_p_file_list)
4584 AC_SUBST(tm_p_include_list)
4585 AC_SUBST(xm_file_list)
4586 AC_SUBST(xm_include_list)
4587 AC_SUBST(xm_defines)
4588 AC_SUBST(use_gcc_stdint)
4589 AC_SUBST(c_target_objs)
4590 AC_SUBST(cxx_target_objs)
4591 AC_SUBST(fortran_target_objs)
4592 AC_SUBST(target_cpu_default)
4593
4594 AC_SUBST_FILE(language_hooks)
4595
4596 # Echo link setup.
4597 if test x${build} = x${host} ; then
4598   if test x${host} = x${target} ; then
4599     echo "Links are now set up to build a native compiler for ${target}." 1>&2
4600   else
4601     echo "Links are now set up to build a cross-compiler" 1>&2
4602     echo " from ${host} to ${target}." 1>&2
4603   fi
4604 else
4605   if test x${host} = x${target} ; then
4606     echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
4607     echo " for ${target}." 1>&2
4608   else
4609     echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
4610     echo " from ${host} to ${target}." 1>&2
4611   fi
4612 fi
4613
4614 AC_ARG_VAR(GMPLIBS,[How to link GMP])
4615 AC_ARG_VAR(GMPINC,[How to find GMP include files])
4616
4617 AC_ARG_VAR(PPLLIBS,[How to link PPL])
4618 AC_ARG_VAR(PPLINC,[How to find PPL include files])
4619
4620 AC_ARG_VAR(CLOOGLIBS,[How to link CLOOG])
4621 AC_ARG_VAR(CLOOGINC,[How to find CLOOG include files])
4622 if test "x${CLOOGLIBS}" != "x" ; then
4623    AC_DEFINE(HAVE_cloog, 1, [Define if cloog is in use.])
4624 fi
4625
4626 AC_ARG_VAR(LIBELFLIBS,[How to link libelf])
4627 AC_ARG_VAR(LIBELFINC,[How to find libelf include files])
4628 if test "x${LIBELFLIBS}" != "x" ; then
4629    AC_DEFINE(HAVE_libelf, 1, [Define if libelf is in use.])
4630 fi
4631
4632 # Check for plugin support
4633 AC_ARG_ENABLE(plugin,
4634 [  --enable-plugin         enable plugin support],
4635 enable_plugin=$enableval,
4636 enable_plugin=yes; default_plugin=yes)
4637
4638 pluginlibs=
4639
4640 case "${host}" in
4641   *-*-darwin*)
4642     if test x$build = x$host; then
4643       export_sym_check="nm${exeext} -g"
4644     elif test x$host = x$target; then
4645       export_sym_check="$gcc_cv_nm -g"
4646     else
4647       export_sym_check=
4648     fi
4649   ;;
4650   *)
4651     if test x$build = x$host; then
4652       export_sym_check="objdump${exeext} -T"
4653     elif test x$host = x$target; then
4654       export_sym_check="$gcc_cv_objdump -T"
4655     else
4656       export_sym_check=
4657     fi
4658   ;;
4659 esac
4660
4661 if test x"$enable_plugin" = x"yes"; then
4662
4663   AC_MSG_CHECKING([for exported symbols])
4664   if test "x$export_sym_check" != x; then
4665     echo "int main() {return 0;} int foobar() {return 0;}" > conftest.c
4666     ${CC} ${CFLAGS} ${LDFLAGS} conftest.c -o conftest > /dev/null 2>&1
4667     if $export_sym_check conftest | grep foobar > /dev/null; then
4668       : # No need to use a flag
4669       AC_MSG_RESULT([yes])
4670     else
4671       AC_MSG_RESULT([yes])
4672       AC_MSG_CHECKING([for -rdynamic])
4673       ${CC} ${CFLAGS} ${LDFLAGS} -rdynamic conftest.c -o conftest > /dev/null 2>&1
4674       if $export_sym_check conftest | grep foobar > /dev/null; then
4675         plugin_rdynamic=yes
4676         pluginlibs="-rdynamic"
4677       else
4678         plugin_rdynamic=no
4679         enable_plugin=no
4680       fi
4681       AC_MSG_RESULT([$plugin_rdynamic])
4682     fi
4683   else
4684     AC_MSG_RESULT([unable to check])
4685   fi
4686
4687   # Check -ldl
4688   saved_LIBS="$LIBS"
4689   AC_SEARCH_LIBS([dlopen], [dl])
4690   if test x"$ac_cv_search_dlopen" = x"-ldl"; then
4691     pluginlibs="$pluginlibs -ldl"
4692   fi
4693   LIBS="$saved_LIBS"
4694
4695   # Check that we can build shared objects with -fPIC -shared
4696   saved_LDFLAGS="$LDFLAGS"
4697   case "${host}" in
4698     *-*-darwin*)
4699       LDFLAGS="$LDFLAGS -fPIC -shared -undefined dynamic_lookup"
4700     ;;
4701     *)
4702       LDFLAGS="$LDFLAGS -fPIC -shared"
4703     ;;
4704   esac
4705   AC_MSG_CHECKING([for -fPIC -shared])
4706   AC_TRY_LINK(
4707     [extern int X;],[return X == 0;],
4708     [AC_MSG_RESULT([yes]); have_pic_shared=yes],
4709     [AC_MSG_RESULT([no]); have_pic_shared=no])
4710   if test x"$have_pic_shared" != x"yes" -o x"$ac_cv_search_dlopen" = x"no"; then
4711     pluginlibs=
4712     enable_plugin=no
4713   fi
4714   LDFLAGS="$saved_LDFLAGS"
4715
4716   # If plugin support had been requested but not available, fail.
4717   if test x"$enable_plugin" = x"no" ; then
4718     if test x"$default_plugin" != x"yes"; then
4719       AC_MSG_ERROR([
4720 Building GCC with plugin support requires a host that supports
4721 -fPIC, -shared, -ldl and -rdynamic.])
4722     fi
4723   fi
4724 fi
4725
4726 AC_SUBST(pluginlibs)
4727 AC_SUBST(enable_plugin)
4728 if test x"$enable_plugin" = x"yes"; then
4729   AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
4730 fi
4731
4732 # Configure the subdirectories
4733 # AC_CONFIG_SUBDIRS($subdirs)
4734
4735 # Create the Makefile
4736 # and configure language subdirectories
4737 AC_CONFIG_FILES($all_outputs)
4738
4739 AC_CONFIG_COMMANDS([default],
4740 [
4741 case ${CONFIG_HEADERS} in
4742   *auto-host.h:config.in*)
4743   echo > cstamp-h ;;
4744 esac
4745 # Make sure all the subdirs exist.
4746 for d in $subdirs doc build c-family
4747 do
4748     test -d $d || mkdir $d
4749 done
4750 ],
4751 [subdirs='$subdirs'])
4752 AC_OUTPUT