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