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
   5 # 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 2, 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 COPYING.  If not, write to the Free
  21 #Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  22 #02111-1307, USA.
  23
  24 # --------------------------------
  25 # Initialization and sanity checks
  26 # --------------------------------
  27
  28 AC_PREREQ(2.59)
  29 AC_INIT
  30 AC_CONFIG_SRCDIR(tree.c)
  31 AC_CONFIG_HEADER(auto-host.h:config.in)
  32
  33 # Determine the host, build, and target systems
  34 AC_CANONICAL_BUILD
  35 AC_CANONICAL_HOST
  36 AC_CANONICAL_TARGET
  37
  38 # Determine the noncanonical target name, for directory use.
  39 _GCC_TOPLEV_NONCANONICAL_TARGET
  40
  41 # Determine the target- and build-specific subdirectories
  42 GCC_TOPLEV_SUBDIRS
  43
  44 # Set program_transform_name
  45 AC_ARG_PROGRAM
  46
  47 # Check for bogus environment variables.
  48 # Test if LIBRARY_PATH contains the notation for the current directory
  49 # since this would lead to problems installing/building glibc.
  50 # LIBRARY_PATH contains the current directory if one of the following
  51 # is true:
  52 # - one of the terminals (":" and ";") is the first or last sign
  53 # - two terminals occur directly after each other
  54 # - the path contains an element with a dot in it
  55 AC_MSG_CHECKING(LIBRARY_PATH variable)
  56 changequote(,)dnl
  57 case ${LIBRARY_PATH} in
  58   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
  59     library_path_setting="contains current directory"
  60     ;;
  61   *)
  62     library_path_setting="ok"
  63     ;;
  64 esac
  65 changequote([,])dnl
  66 AC_MSG_RESULT($library_path_setting)
  67 if test "$library_path_setting" != "ok"; then
  68 AC_MSG_ERROR([
  69 *** LIBRARY_PATH shouldn't contain the current directory when
  70 *** building gcc. Please change the environment variable
  71 *** and run configure again.])
  72 fi
  73
  74 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
  75 # since this would lead to problems installing/building glibc.
  76 # GCC_EXEC_PREFIX contains the current directory if one of the following
  77 # is true:
  78 # - one of the terminals (":" and ";") is the first or last sign
  79 # - two terminals occur directly after each other
  80 # - the path contains an element with a dot in it
  81 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
  82 changequote(,)dnl
  83 case ${GCC_EXEC_PREFIX} in
  84   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
  85     gcc_exec_prefix_setting="contains current directory"
  86     ;;
  87   *)
  88     gcc_exec_prefix_setting="ok"
  89     ;;
  90 esac
  91 changequote([,])dnl
  92 AC_MSG_RESULT($gcc_exec_prefix_setting)
  93 if test "$gcc_exec_prefix_setting" != "ok"; then
  94 AC_MSG_ERROR([
  95 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
  96 *** building gcc. Please change the environment variable
  97 *** and run configure again.])
  98 fi
  99
 100 # -----------
 101 # Directories
 102 # -----------
 103
 104 # Specify the local prefix
 105 local_prefix=
 106 AC_ARG_WITH(local-prefix,
 107 [  --with-local-prefix=DIR specifies directory to put local include],
 108 [case "${withval}" in
 109 yes)    AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
 110 no)     ;;
 111 *)      local_prefix=$with_local_prefix ;;
 112 esac])
 113
 114 # Default local prefix if it is empty
 115 if test x$local_prefix = x; then
 116         local_prefix=/usr/local
 117 fi
 118
 119 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
 120 # passed in by the toplevel make and thus we'd get different behavior
 121 # depending on where we built the sources.
 122 gcc_gxx_include_dir=
 123 # Specify the g++ header file directory
 124 AC_ARG_WITH(gxx-include-dir,
 125 [  --with-gxx-include-dir=DIR
 126                           specifies directory to put g++ header files],
 127 [case "${withval}" in
 128 yes)    AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
 129 no)     ;;
 130 *)      gcc_gxx_include_dir=$with_gxx_include_dir ;;
 131 esac])
 132
 133 if test x${gcc_gxx_include_dir} = x; then
 134   if test x${enable_version_specific_runtime_libs} = xyes; then
 135     gcc_gxx_include_dir='${libsubdir}/include/c++'
 136   else
 137     topsrcdir=${srcdir}/.. . ${srcdir}/../config.if
 138 changequote(<<, >>)dnl
 139     gcc_gxx_include_dir="\$(libsubdir)/\$(unlibsubdir)/..\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/[^/]*|/..|g'\`/include/"${libstdcxx_incdir}
 140 changequote([, ])dnl
 141   fi
 142 fi
 143
 144 AC_ARG_WITH(cpp_install_dir,
 145 [  --with-cpp-install-dir=DIR
 146                           install the user visible C preprocessor in DIR
 147                           (relative to PREFIX) as well as PREFIX/bin],
 148 [if test x$withval = xyes; then
 149   AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
 150 elif test x$withval != xno; then
 151   cpp_install_dir=$withval
 152 fi])
 153
 154 # We would like to our source tree to be readonly.  However when releases or
 155 # pre-releases are generated, the flex/bison generated files as well as the
 156 # various formats of manuals need to be included along with the rest of the
 157 # sources.  Therefore we have --enable-generated-files-in-srcdir to do
 158 # just that.
 159
 160 AC_MSG_CHECKING([whether to place generated files in the source directory])
 161   dnl generated-files-in-srcdir is disabled by default
 162   AC_ARG_ENABLE(generated-files-in-srcdir,
 163 [  --enable-generated-files-in-srcdir
 164                           put copies of generated files in source dir
 165                           intended for creating source tarballs for users
 166                           without texinfo bison or flex.],
 167       generated_files_in_srcdir=$enableval,
 168       generated_files_in_srcdir=no)
 169
 170 AC_MSG_RESULT($generated_files_in_srcdir)
 171
 172 if test "$generated_files_in_srcdir" = "yes"; then
 173   GENINSRC=''
 174 else
 175   GENINSRC='#'
 176 fi
 177 AC_SUBST(GENINSRC)
 178
 179 # -------------------
 180 # Find default linker
 181 # -------------------
 182
 183 # With GNU ld
 184 AC_ARG_WITH(gnu-ld,
 185 [  --with-gnu-ld           arrange to work with GNU ld.],
 186 gnu_ld_flag="$with_gnu_ld",
 187 gnu_ld_flag=no)
 188
 189 # With pre-defined ld
 190 AC_ARG_WITH(ld,
 191 [  --with-ld               arrange to use the specified ld (full pathname)],
 192 DEFAULT_LINKER="$with_ld")
 193 if test x"${DEFAULT_LINKER+set}" = x"set"; then
 194   if test ! -x "$DEFAULT_LINKER"; then
 195     AC_MSG_ERROR([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
 196   elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
 197     gnu_ld_flag=yes
 198   fi
 199   AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
 200         [Define to enable the use of a default linker.])
 201 fi
 202
 203 AC_MSG_CHECKING([whether a default linker was specified])
 204 if test x"${DEFAULT_LINKER+set}" = x"set"; then
 205   if test x"$gnu_ld_flag" = x"no"; then
 206     AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
 207   else
 208     AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
 209   fi
 210 else
 211   AC_MSG_RESULT(no)
 212 fi
 213
 214 # With demangler in GNU ld
 215 AC_ARG_WITH(demangler-in-ld,
 216 [  --with-demangler-in-ld  try to use demangler in GNU ld.],
 217 demangler_in_ld="$with_demangler_in_ld",
 218 demangler_in_ld=no)
 219
 220 # ----------------------
 221 # Find default assembler
 222 # ----------------------
 223
 224 # With GNU as
 225 AC_ARG_WITH(gnu-as,
 226 [  --with-gnu-as           arrange to work with GNU as],
 227 gas_flag="$with_gnu_as",
 228 gas_flag=no)
 229
 230 AC_ARG_WITH(as,
 231 [  --with-as               arrange to use the specified as (full pathname)],
 232 DEFAULT_ASSEMBLER="$with_as")
 233 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
 234   if test ! -x "$DEFAULT_ASSEMBLER"; then
 235     AC_MSG_ERROR([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
 236   elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
 237     gas_flag=yes
 238   fi
 239   AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
 240         [Define to enable the use of a default assembler.])
 241 fi
 242
 243 AC_MSG_CHECKING([whether a default assembler was specified])
 244 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
 245   if test x"$gas_flag" = x"no"; then
 246     AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
 247   else
 248     AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
 249   fi
 250 else
 251   AC_MSG_RESULT(no)
 252 fi
 253
 254 # ---------------
 255 # Find C compiler
 256 # ---------------
 257
 258 # If a non-executable a.out is present (e.g. created by GNU as above even if
 259 # invoked with -v only), the IRIX 6 native ld just overwrites the existing
 260 # file, even when creating an executable, so an execution test fails.
 261 # Remove possible default executable files to avoid this.
 262 #
 263 # FIXME: This really belongs into AC_PROG_CC and can be removed once
 264 # Autoconf includes it.
 265 rm -f a.out a.exe b.out
 266
 267 # Find the native compiler
 268 AC_PROG_CC
 269 AC_PROG_CC_C_O
 270 # autoconf is lame and doesn't give us any substitution variable for this.
 271 if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = no"; then
 272   NO_MINUS_C_MINUS_O=yes
 273 else
 274   OUTPUT_OPTION='-o $@'
 275 fi
 276 AC_SUBST(NO_MINUS_C_MINUS_O)
 277 AC_SUBST(OUTPUT_OPTION)
 278
 279 # -------------------------
 280 # Check C compiler features
 281 # -------------------------
 282
 283 AC_PROG_CPP
 284 AC_C_INLINE
 285
 286 gcc_AC_C_LONG_LONG
 287
 288 # sizeof(char) is 1 by definition.
 289 AC_COMPILE_CHECK_SIZEOF(void *)
 290 AC_COMPILE_CHECK_SIZEOF(short)
 291 AC_COMPILE_CHECK_SIZEOF(int)
 292 AC_COMPILE_CHECK_SIZEOF(long)
 293 if test $ac_cv_c_long_long = yes; then
 294   AC_COMPILE_CHECK_SIZEOF(long long)
 295 fi
 296 if test $ac_cv_c___int64 = yes; then
 297   AC_COMPILE_CHECK_SIZEOF(__int64)
 298 fi
 299
 300 # ---------------------
 301 # Warnings and checking
 302 # ---------------------
 303
 304 # Check $CC warning features (if it's GCC).
 305 # We want to use -pedantic, but we don't want warnings about
 306 # * 'long long'
 307 # * variadic macros
 308 # So, we only use -pedantic if we can disable those warnings.
 309
 310 AC_CACHE_CHECK(
 311   [whether ${CC} accepts -Wno-long-long],
 312   [ac_cv_prog_cc_w_no_long_long],
 313   [save_CFLAGS="$CFLAGS"
 314   CFLAGS="-Wno-long-long"
 315   AC_COMPILE_IFELSE([AC_LANG_SOURCE([[]])],
 316                     [ac_cv_prog_cc_w_no_long_long=yes],
 317                     [ac_cv_prog_cc_w_no_long_long=no])
 318   CFLAGS="$save_CFLAGS"
 319   ])
 320
 321 AC_CACHE_CHECK(
 322   [whether ${CC} accepts -Wno-variadic-macros],
 323   [ac_cv_prog_cc_w_no_variadic_macros],
 324   [save_CFLAGS="$CFLAGS"
 325   CFLAGS="-Wno-variadic-macros"
 326   AC_COMPILE_IFELSE([AC_LANG_SOURCE([[]])],
 327                     [ac_cv_prog_cc_w_no_variadic_macros=yes],
 328                     [ac_cv_prog_cc_w_no_variadic_macros=no])
 329   CFLAGS="$save_CFLAGS"
 330   ])
 331
 332 strict1_warn=
 333 if test $ac_cv_prog_cc_w_no_long_long = yes \
 334    && test $ac_cv_prog_cc_w_no_variadic_macros = yes ; then
 335   strict1_warn="-pedantic -Wno-long-long -Wno-variadic-macros"
 336 fi
 337 AC_SUBST(strict1_warn)
 338
 339 # Add -Wold-style-definition if it's accepted
 340 AC_CACHE_CHECK(
 341   [whether ${CC} accepts -Wold-style-definition],
 342   [ac_cv_prog_cc_w_old_style_definition],
 343   [save_CFLAGS="$CFLAGS"
 344   CFLAGS="-Wold-style-definition"
 345   AC_COMPILE_IFELSE([AC_LANG_SOURCE([[]])],
 346                     [ac_cv_prog_cc_w_old_style_definition=yes],
 347                     [ac_cv_prog_cc_w_old_style_definition=no])
 348   CFLAGS="$save_CFLAGS"
 349   ])
 350 if test $ac_cv_prog_cc_w_old_style_definition = yes ; then
 351   strict1_warn="${strict1_warn} -Wold-style-definition"
 352 fi
 353
 354 # Enable -Werror, period.
 355 AC_ARG_ENABLE(werror_always,
 356 [  --enable-werror-always         enable -Werror always], [],
 357 [enable_werror_always=no])
 358 if test x${enable_werror_always} = xyes ; then
 359   strict1_warn="${strict1_warn} -Werror"
 360   WERROR=-Werror
 361 fi
 362
 363 # If the native compiler is GCC, we can enable warnings even in stage1.
 364 # That's useful for people building cross-compilers, or just running a
 365 # quick `make'.
 366 warn_cflags=
 367 if test "x$GCC" = "xyes"; then
 368   warn_cflags='$(GCC_WARN_CFLAGS)'
 369 fi
 370 AC_SUBST(warn_cflags)
 371
 372 # Enable -Werror in bootstrap stage2 and later.
 373 # Change the default to "no" on release branches.
 374 AC_ARG_ENABLE(werror,
 375 [  --enable-werror         enable -Werror in bootstrap stage2 and later], [],
 376 [enable_werror=yes])
 377 if test x$enable_werror = xyes ; then
 378   WERROR=-Werror
 379 fi
 380 AC_SUBST(WERROR)
 381
 382 # Enable expensive internal checks
 383 AC_ARG_ENABLE(checking,
 384 [  --enable-checking[=LIST]
 385                           enable expensive run-time checks.  With LIST,
 386                           enable only specific categories of checks.
 387                           Categories are: misc,tree,rtl,rtlflag,gc,gcac,fold;
 388                           default is misc,tree,gc,rtlflag],
 389 [ac_checking=
 390 ac_tree_checking=
 391 ac_rtl_checking=
 392 ac_rtlflag_checking=
 393 ac_gc_checking=
 394 ac_gc_always_collect=
 395 ac_fold_checking=
 396 case "${enableval}" in
 397 yes)    ac_checking=1 ; ac_tree_checking=1 ; ac_gc_checking=1 ;
 398         ac_rtlflag_checking=1 ;;
 399 no)     ;;
 400 *)      IFS="${IFS=     }"; ac_save_IFS="$IFS"; IFS="$IFS,"
 401         set fnord $enableval; shift
 402         IFS="$ac_save_IFS"
 403         for check
 404         do
 405                 case $check in
 406                 misc)   ac_checking=1 ;;
 407                 tree)   ac_tree_checking=1 ;;
 408                 rtlflag)        ac_rtlflag_checking=1 ;;
 409                 rtl)    ac_rtl_checking=1 ;;
 410                 gc)     ac_gc_checking=1 ;;
 411                 gcac)   ac_gc_always_collect=1 ;;
 412                 fold)   ac_fold_checking=1 ;;
 413                 valgrind)       ac_checking_valgrind=1 ;;
 414                 *)      AC_MSG_ERROR(unknown check category $check) ;;
 415                 esac
 416         done
 417         ;;
 418 esac
 419 ],
 420 # Enable some checks by default for development versions of GCC
 421 [ac_checking=1; ac_tree_checking=1; ac_gc_checking=1; ac_rtlflag_checking=1;])
 422 nocommon_flag=""
 423 if test x$ac_checking != x ; then
 424   AC_DEFINE(ENABLE_CHECKING, 1,
 425 [Define if you want more run-time sanity checks.  This one gets a grab
 426    bag of miscellaneous but relatively cheap checks.])
 427   nocommon_flag=-fno-common
 428 fi
 429 AC_SUBST(nocommon_flag)
 430 if test x$ac_tree_checking != x ; then
 431   AC_DEFINE(ENABLE_TREE_CHECKING, 1,
 432 [Define if you want all operations on trees (the basic data
 433    structure of the front ends) to be checked for dynamic type safety
 434    at runtime.  This is moderately expensive.  The tree browser debugging
 435    routines will also be enabled by this option.
 436    ])
 437   TREEBROWSER=tree-browser.o
 438 fi
 439 AC_SUBST(TREEBROWSER)
 440 if test x$ac_rtl_checking != x ; then
 441   AC_DEFINE(ENABLE_RTL_CHECKING, 1,
 442 [Define if you want all operations on RTL (the basic data structure
 443    of the optimizer and back end) to be checked for dynamic type safety
 444    at runtime.  This is quite expensive.])
 445 fi
 446 if test x$ac_rtlflag_checking != x ; then
 447   AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
 448 [Define if you want RTL flag accesses to be checked against the RTL
 449    codes that are supported for each access macro.  This is relatively
 450    cheap.])
 451 fi
 452 if test x$ac_gc_checking != x ; then
 453   AC_DEFINE(ENABLE_GC_CHECKING, 1,
 454 [Define if you want the garbage collector to do object poisoning and
 455    other memory allocation checks.  This is quite expensive.])
 456 fi
 457 if test x$ac_gc_always_collect != x ; then
 458   AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
 459 [Define if you want the garbage collector to operate in maximally
 460    paranoid mode, validating the entire heap and collecting garbage at
 461    every opportunity.  This is extremely expensive.])
 462 fi
 463 if test x$ac_fold_checking != x ; then
 464   AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
 465 [Define if you want fold checked that it never destructs its argument.
 466    This is quite expensive.])
 467 fi
 468 valgrind_path_defines=
 469 valgrind_command=
 470
 471 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
 472 dnl # an if statement.  This was the source of very frustrating bugs
 473 dnl # in converting to autoconf 2.5x!
 474 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
 475
 476 if test x$ac_checking_valgrind != x ; then
 477   # It is certainly possible that there's valgrind but no valgrind.h.
 478   # GCC relies on making annotations so we must have both.
 479   AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
 480   AC_TRY_CPP(
 481     [#include <valgrind/memcheck.h>
 482 #ifndef VALGRIND_DISCARD
 483 #error VALGRIND_DISCARD not defined
 484 #endif],
 485   [gcc_cv_header_valgrind_memcheck_h=yes],
 486   [gcc_cv_header_valgrind_memcheck_h=no])
 487   AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
 488   AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
 489   AC_TRY_CPP(
 490     [#include <memcheck.h>
 491 #ifndef VALGRIND_DISCARD
 492 #error VALGRIND_DISCARD not defined
 493 #endif],
 494   [gcc_cv_header_memcheck_h=yes],
 495   gcc_cv_header_memcheck_h=no)
 496   AC_MSG_RESULT($gcc_cv_header_memcheck_h)
 497   AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
 498         [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
 499   if test "x$valgrind_path" = "x" \
 500     || (test $have_valgrind_h = no \
 501         && test $gcc_cv_header_memcheck_h = no \
 502         && test $gcc_cv_header_valgrind_memcheck_h = no); then
 503         AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
 504   fi
 505   valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
 506   valgrind_command="$valgrind_path -q"
 507   AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
 508 [Define if you want to run subprograms and generated programs
 509    through valgrind (a memory checker).  This is extremely expensive.])
 510   if test $gcc_cv_header_valgrind_memcheck_h = yes; then
 511     AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
 512         [Define if valgrind's valgrind/memcheck.h header is installed.])
 513   fi
 514   if test $gcc_cv_header_memcheck_h = yes; then
 515     AC_DEFINE(HAVE_MEMCHECK_H, 1,
 516         [Define if valgrind's memcheck.h header is installed.])
 517   fi
 518 fi
 519 AC_SUBST(valgrind_path_defines)
 520 AC_SUBST(valgrind_command)
 521
 522 AC_ARG_ENABLE(mapped-location,
 523 [  --enable-mapped-location   location_t is fileline integer cookie],,
 524 enable_mapped_location=no)
 525
 526 if test "$enable_mapped_location" = yes ; then
 527   AC_DEFINE(USE_MAPPED_LOCATION, 1,
 528 [Define if location_t is fileline integer cookie.])
 529 fi
 530
 531 # Enable code coverage collection
 532 AC_ARG_ENABLE(coverage,
 533 [  --enable-coverage[=LEVEL]
 534                           enable compiler\'s code coverage collection.
 535                           Use to measure compiler performance and locate
 536                           unused parts of the compiler. With LEVEL, specify
 537                           optimization. Values are opt, noopt,
 538                           default is noopt],
 539 [case "${enableval}" in
 540   yes|noopt)
 541     coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
 542     ;;
 543   opt)
 544     coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
 545     ;;
 546   no)
 547     # a.k.a. --disable-coverage
 548     coverage_flags=""
 549     ;;
 550   *)
 551     AC_MSG_ERROR(unknown coverage setting $enableval)
 552     ;;
 553 esac],
 554 [coverage_flags=""])
 555 AC_SUBST(coverage_flags)
 556
 557 AC_ARG_ENABLE(gather-detailed-mem-stats,
 558 [  --enable-gather-detailed-mem-stats         enable detailed memory allocation stats gathering], [],
 559 [enable_gather_detailed_mem_stats=no])
 560 if test x$enable_gather_detailed_mem_stats = xyes ; then
 561   AC_DEFINE(GATHER_STATISTICS, 1,
 562         [Define to enable detailed memory allocation stats gathering.])
 563 fi
 564
 565 # -------------------------------
 566 # Miscenalleous configure options
 567 # -------------------------------
 568
 569 # With stabs
 570 AC_ARG_WITH(stabs,
 571 [  --with-stabs            arrange to use stabs instead of host debug format],
 572 stabs="$with_stabs",
 573 stabs=no)
 574
 575 # Determine whether or not multilibs are enabled.
 576 AC_ARG_ENABLE(multilib,
 577 [  --enable-multilib       enable library support for multiple ABIs],
 578 [], [enable_multilib=yes])
 579 AC_SUBST(enable_multilib)
 580
 581 # Enable __cxa_atexit for C++.
 582 AC_ARG_ENABLE(__cxa_atexit,
 583 [  --enable-__cxa_atexit   enable __cxa_atexit for C++],
 584 [], [])
 585
 586 # Enable threads
 587 # Pass with no value to take the default
 588 # Pass with a value to specify a thread package
 589 AC_ARG_ENABLE(threads,
 590 [  --enable-threads        enable thread usage for target GCC
 591   --enable-threads=LIB    use LIB thread package for target GCC],,
 592 [enable_threads=''])
 593
 594 AC_ARG_ENABLE(objc-gc,
 595 [  --enable-objc-gc       enable the use of Boehm's garbage collector with
 596                           the GNU Objective-C runtime],
 597 if test x$enable_objc_gc = xno; then
 598         objc_boehm_gc=''
 599 else
 600         objc_boehm_gc=1
 601 fi,
 602 objc_boehm_gc='')
 603
 604 AC_ARG_WITH(dwarf2,
 605 [  --with-dwarf2           force the default debug format to be DWARF 2],
 606 dwarf2="$with_dwarf2",
 607 dwarf2=no)
 608
 609 AC_ARG_ENABLE(shared,
 610 [  --disable-shared        don't provide a shared libgcc],
 611 [
 612   case $enable_shared in
 613   yes | no) ;;
 614   *)
 615     enable_shared=no
 616     IFS="${IFS=         }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
 617     for pkg in $enableval; do
 618       if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
 619         enable_shared=yes
 620       fi
 621     done
 622     IFS="$ac_save_ifs"
 623     ;;
 624   esac
 625 ], [enable_shared=yes])
 626 AC_SUBST(enable_shared)
 627
 628 AC_ARG_WITH(sysroot,
 629 [  --with-sysroot[=DIR] Search for usr/lib, usr/include, et al, within DIR.],
 630 [
 631  case ${with_sysroot} in
 632  yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
 633  *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
 634  esac
 635
 636  TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
 637  CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR)'
 638
 639  if test "x$exec_prefix" = xNONE; then
 640   if test "x$prefix" = xNONE; then
 641    test_prefix=/usr/local
 642   else
 643    test_prefix=$prefix
 644   fi
 645  else
 646   test_prefix=$exec_prefix
 647  fi
 648  case ${TARGET_SYSTEM_ROOT} in
 649  "${test_prefix}"|"${test_prefix}/"*|\
 650  '${exec_prefix}'|'${exec_prefix}/'*)
 651    t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
 652    TARGET_SYSTEM_ROOT_DEFINE="$t"
 653    ;;
 654  esac
 655 ], [
 656  TARGET_SYSTEM_ROOT=
 657  TARGET_SYSTEM_ROOT_DEFINE=
 658  CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
 659 ])
 660 AC_SUBST(TARGET_SYSTEM_ROOT)
 661 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
 662 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
 663
 664 # Build with intermodule optimisations
 665 AC_ARG_ENABLE(intermodule,
 666 [  --enable-intermodule    build the compiler in one step],
 667 [case ${enable_intermodule} in
 668   yes) onestep="-onestep";;
 669   *) onestep="";;
 670 esac],
 671 [onestep=""])
 672 AC_SUBST(onestep)
 673
 674 # Sanity check enable_languages in case someone does not run the toplevel
 675 # configure # script.
 676 AC_ARG_ENABLE(languages,
 677 [  --enable-languages=LIST specify which front-ends to build],
 678 [case ,${enable_languages}, in
 679        ,,|,yes,)
 680                 # go safe -- we cannot be much sure without the toplevel
 681                 # configure's
 682                 # analysis of which target libs are present and usable
 683                 enable_languages=c
 684                 ;;
 685          *,all,*)
 686                 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
 687                 ;;
 688         *,c,*)
 689                 ;;
 690         *)
 691                 enable_languages=c,${enable_languages}
 692                 ;;
 693 esac],
 694 [enable_languages=c])
 695
 696 subdirs=
 697 for lang in ${srcdir}/*/config-lang.in
 698 do
 699         case $lang in
 700         # The odd quoting in the next line works around
 701         # an apparent bug in bash 1.12 on linux.
 702 changequote(,)dnl
 703         ${srcdir}/[*]/config-lang.in) ;;
 704         *)
 705           lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
 706           if test "x$lang_alias" = x
 707           then
 708                 echo "$lang doesn't set \$language." 1>&2
 709                 exit 1
 710           fi
 711           case ",$enable_languages," in
 712           *,$lang_alias,*)
 713             subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`" ;;
 714           esac
 715           ;;
 716 changequote([,])dnl
 717         esac
 718 done
 719
 720
 721 # -------------------------
 722 # Checks for other programs
 723 # -------------------------
 724
 725 AC_PROG_MAKE_SET
 726
 727 # Find some useful tools
 728 AC_PROG_AWK
 729 # We need awk to create options.c and options.h.
 730 # Bail out if it's missing.
 731 case ${AWK} in
 732   "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
 733 esac
 734
 735 gcc_AC_PROG_LN_S
 736 ACX_PROG_LN($LN_S)
 737 AC_PROG_RANLIB
 738 case "${host}" in
 739 *-*-darwin*)
 740   # By default, the Darwin ranlib will not treat common symbols as
 741   # definitions when  building the archive table of contents.  Other
 742   # ranlibs do that; pass an option to the Darwin ranlib that makes
 743   # it behave similarly.
 744   ranlib_flags="-c"
 745   ;;
 746 *)
 747   ranlib_flags=""
 748 esac
 749 AC_SUBST(ranlib_flags)
 750
 751 gcc_AC_PROG_INSTALL
 752
 753 # See if cmp has --ignore-initial.
 754 gcc_AC_PROG_CMP_IGNORE_INITIAL
 755
 756 # See if we have the mktemp command.
 757 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
 758
 759 # Do we have a single-tree copy of texinfo?
 760 if test -f $srcdir/../texinfo/Makefile.in; then
 761   MAKEINFO='$(objdir)/../texinfo/makeinfo/makeinfo'
 762   gcc_cv_prog_makeinfo_modern=yes
 763   AC_MSG_RESULT([Using makeinfo from the unified source tree.])
 764 else
 765   # See if makeinfo has been installed and is modern enough
 766   # that we can use it.
 767   gcc_AC_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
 768   [GNU texinfo.* \([0-9][0-9.]*\)],
 769   [4.[2-9]*])
 770 fi
 771
 772 if test $gcc_cv_prog_makeinfo_modern = no; then
 773   AC_MSG_WARN([
 774 *** Makeinfo is missing or too old.
 775 *** Info documentation will not be built.])
 776   BUILD_INFO=
 777 else
 778   BUILD_INFO=info               AC_SUBST(BUILD_INFO)
 779 fi
 780
 781 # Is pod2man recent enough to regenerate manpages?
 782 AC_MSG_CHECKING([for recent Pod::Man])
 783 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
 784   AC_MSG_RESULT(yes)
 785   GENERATED_MANPAGES=generated-manpages         AC_SUBST(GENERATED_MANPAGES)
 786 else
 787   AC_MSG_RESULT(no)
 788   GENERATED_MANPAGES=
 789 fi
 790
 791 # How about lex?
 792 dnl Don't use AC_PROG_LEX; we insist on flex.
 793 dnl LEXLIB is not useful in gcc.
 794 if test x${build} = x${host} && test -f $srcdir/../flex/skel.c; then
 795   FLEX='$(objdir)/../flex/flex'
 796 else
 797   AC_CHECK_PROG(FLEX, flex, flex, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing flex)
 798 fi
 799
 800 # Bison?
 801 # The -L switch is so bison can find its skeleton file.
 802 if test x${build} = x${host} && test -f $srcdir/../bison/bison.simple; then
 803   BISON='$(objdir)/../bison/bison -L $(srcdir)/../bison/'
 804 else
 805   AC_CHECK_PROG(BISON, bison, bison, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing bison)
 806 fi
 807
 808 # --------------------
 809 # Checks for C headers
 810 # --------------------
 811
 812 AC_MSG_CHECKING(for GNU C library)
 813 AC_CACHE_VAL(gcc_cv_glibc,
 814 [AC_TRY_COMPILE(
 815   [#include <features.h>],[
 816 #if ! (defined __GLIBC__ || defined __GNU_LIBRARY__)
 817 #error Not a GNU C library system
 818 #endif],
 819   [gcc_cv_glibc=yes],
 820   gcc_cv_glibc=no)])
 821 AC_MSG_RESULT($gcc_cv_glibc)
 822 if test $gcc_cv_glibc = yes; then
 823   AC_DEFINE(_GNU_SOURCE, 1, [Always define this when using the GNU C Library])
 824 fi
 825
 826 # Need to reject headers which give warnings, so that the -Werror bootstrap
 827 # works later. *sigh*  This needs to come before all header checks.
 828 AC_PROG_CPP_WERROR
 829
 830 AC_HEADER_STDC
 831 AC_HEADER_TIME
 832 ACX_HEADER_STRING
 833 AC_HEADER_SYS_WAIT
 834 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h \
 835                  fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
 836                  sys/resource.h sys/param.h sys/times.h sys/stat.h \
 837                  direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
 838
 839 # Check for thread headers.
 840 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
 841 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
 842
 843 # These tests can't be done till we know if we have limits.h.
 844 gcc_AC_C_CHAR_BIT
 845 AC_C_BIGENDIAN_CROSS
 846
 847 # --------
 848 # UNSORTED
 849 # --------
 850
 851 # Stage specific cflags for build.
 852 stage1_cflags=
 853 case $build in
 854 vax-*-*)
 855   if test x$GCC = xyes
 856   then
 857     stage1_cflags="-Wa,-J"
 858   else
 859     stage1_cflags="-J"
 860   fi
 861   ;;
 862 powerpc-*-darwin*)
 863   # The spiffy cpp-precomp chokes on some legitimate constructs in GCC
 864   # sources; use -no-cpp-precomp to get to GNU cpp.
 865   # Apple's GCC has bugs in designated initializer handling, so disable
 866   # that too.
 867   stage1_cflags="-no-cpp-precomp -DHAVE_DESIGNATED_INITIALIZERS=0"
 868   ;;
 869 esac
 870 AC_SUBST(stage1_cflags)
 871
 872 # These libraries may be used by collect2.
 873 # We may need a special search path to get them linked.
 874 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
 875 [save_LIBS="$LIBS"
 876 for libs in '' -lld -lmld \
 877                 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
 878                 '-L/usr/lib/cmplrs/cc3.11 -lmld'
 879 do
 880         LIBS="$libs"
 881         AC_TRY_LINK_FUNC(ldopen,
 882                 [gcc_cv_collect2_libs="$libs"; break])
 883 done
 884 LIBS="$save_LIBS"
 885 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
 886 case $gcc_cv_collect2_libs in
 887         "none required")        ;;
 888         *)      COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
 889 esac
 890 AC_SUBST(COLLECT2_LIBS)
 891
 892 # When building Ada code on Alpha, we need exc_resume which is usually in
 893 # -lexc.  So test for it.
 894 save_LIBS="$LIBS"
 895 LIBS=
 896 AC_SEARCH_LIBS(exc_resume, exc)
 897 GNAT_LIBEXC="$LIBS"
 898 LIBS="$save_LIBS"
 899 AC_SUBST(GNAT_LIBEXC)
 900
 901 # Some systems put ldexp and frexp in libm instead of libc; assume
 902 # they're both in the same place.  jcf-dump needs them.
 903 save_LIBS="$LIBS"
 904 LIBS=
 905 AC_SEARCH_LIBS(ldexp, m)
 906 LDEXP_LIB="$LIBS"
 907 LIBS="$save_LIBS"
 908 AC_SUBST(LDEXP_LIB)
 909
 910 # Use <inttypes.h> only if it exists,
 911 # doesn't clash with <sys/types.h>, and declares intmax_t.
 912 AC_MSG_CHECKING(for inttypes.h)
 913 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
 914 [AC_TRY_COMPILE(
 915   [#include <sys/types.h>
 916 #include <inttypes.h>],
 917   [intmax_t i = -1;],
 918   [gcc_cv_header_inttypes_h=yes],
 919   gcc_cv_header_inttypes_h=no)])
 920 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
 921 if test $gcc_cv_header_inttypes_h = yes; then
 922   AC_DEFINE(HAVE_INTTYPES_H, 1,
 923         [Define if you have a working <inttypes.h> header file.])
 924 fi
 925
 926 dnl Disabled until we have a complete test for buggy enum bitfields.
 927 dnl gcc_AC_C_ENUM_BF_UNSIGNED
 928
 929 AC_CHECK_FUNCS(times clock dup2 kill getrlimit setrlimit atoll atoq \
 930         sysconf strsignal putc_unlocked fputc_unlocked fputs_unlocked \
 931         fwrite_unlocked fprintf_unlocked getrusage nl_langinfo \
 932         scandir alphasort gettimeofday mbstowcs wcswidth mmap mincore \
 933         setlocale)
 934
 935 if test x$ac_cv_func_mbstowcs = xyes; then
 936   AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
 937 [    AC_TRY_RUN([#include <stdlib.h>
 938 int main()
 939 {
 940   mbstowcs(0, "", 0);
 941   return 0;
 942 }],
 943     gcc_cv_func_mbstowcs_works=yes,
 944     gcc_cv_func_mbstowcs_works=no,
 945     gcc_cv_func_mbstowcs_works=yes)])
 946   if test x$gcc_cv_func_mbstowcs_works = xyes; then
 947     AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
 948   [Define this macro if mbstowcs does not crash when its
 949    first argument is NULL.])
 950   fi
 951 fi
 952
 953 AC_CHECK_TYPE(ssize_t, int)
 954
 955 # Try to determine the array type of the second argument of getgroups
 956 # for the target system (int or gid_t).
 957 AC_TYPE_GETGROUPS
 958 if test "${target}" = "${build}"; then
 959   TARGET_GETGROUPS_T=$ac_cv_type_getgroups
 960 else
 961   case "${target}" in
 962         # This condition may need some tweaking.  It should include all
 963         # targets where the array type of the second argument of getgroups
 964         # is int and the type of gid_t is not equivalent to int.
 965         *-*-sunos* | *-*-ultrix*)
 966                 TARGET_GETGROUPS_T=int
 967                 ;;
 968         *)
 969                 TARGET_GETGROUPS_T=gid_t
 970                 ;;
 971   esac
 972 fi
 973 AC_SUBST(TARGET_GETGROUPS_T)
 974
 975 gcc_AC_FUNC_PRINTF_PTR
 976 gcc_AC_FUNC_MMAP_BLACKLIST
 977
 978 case "${host}" in
 979 *-*-*vms*)
 980   # Under VMS, vfork works very differently than on Unix. The standard test
 981   # won't work, and it isn't easily adaptable. It makes more sense to
 982   # just force it.
 983   ac_cv_func_vfork_works=yes
 984   ;;
 985 esac
 986 AC_FUNC_VFORK
 987
 988 AM_ICONV
 989 # Until we have in-tree GNU iconv:
 990 LIBICONV_DEP=
 991 AC_SUBST(LIBICONV_DEP)
 992
 993 AM_LC_MESSAGES
 994
 995 # We will need to find libiberty.h and ansidecl.h
 996 saved_CFLAGS="$CFLAGS"
 997 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include"
 998 gcc_AC_CHECK_DECLS(getenv atol sbrk abort atof getcwd getwd \
 999         strsignal putc_unlocked fputs_unlocked fwrite_unlocked \
1000         fprintf_unlocked strstr errno snprintf vasprintf \
1001         malloc realloc calloc free basename getopt clock getpagesize, , ,[
1002 #include "ansidecl.h"
1003 #include "system.h"])
1004
1005 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1006 #include "ansidecl.h"
1007 #include "system.h"
1008 #ifdef HAVE_SYS_RESOURCE_H
1009 #include <sys/resource.h>
1010 #endif
1011 ])
1012
1013 AC_TRY_COMPILE([
1014 #include "ansidecl.h"
1015 #include "system.h"
1016 #ifdef HAVE_SYS_RESOURCE_H
1017 #include <sys/resource.h>
1018 #endif
1019 ],[rlim_t l = 0;],,[AC_DEFINE([rlim_t],[long],
1020 [Define to \`long' if <sys/resource.h> doesn't define.])])
1021
1022 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1023 #include "ansidecl.h"
1024 #include "system.h"
1025 #ifdef HAVE_LDFCN_H
1026 #include <ldfcn.h>
1027 #endif
1028 ])
1029
1030 gcc_AC_CHECK_DECLS(times, , ,[
1031 #include "ansidecl.h"
1032 #include "system.h"
1033 #ifdef HAVE_SYS_TIMES_H
1034 #include <sys/times.h>
1035 #endif
1036 ])
1037
1038 # More time-related stuff.
1039 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1040 AC_TRY_COMPILE([
1041 #include "ansidecl.h"
1042 #include "system.h"
1043 #ifdef HAVE_SYS_TIMES_H
1044 #include <sys/times.h>
1045 #endif
1046 ], [struct tms tms;], ac_cv_struct_tms=yes, ac_cv_struct_tms=no)])
1047 if test $ac_cv_struct_tms = yes; then
1048   AC_DEFINE(HAVE_STRUCT_TMS, 1,
1049   [Define if <sys/times.h> defines struct tms.])
1050 fi
1051
1052 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1053 # revisit after autoconf 2.50.
1054 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1055 AC_TRY_COMPILE([
1056 #include "ansidecl.h"
1057 #include "system.h"
1058 ], [clock_t x;], gcc_cv_type_clock_t=yes, gcc_cv_type_clock_t=no)])
1059 if test $gcc_cv_type_clock_t = yes; then
1060   AC_DEFINE(HAVE_CLOCK_T, 1,
1061   [Define if <time.h> defines clock_t.])
1062 fi
1063
1064 # Restore CFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1065 CFLAGS="$saved_CFLAGS"
1066
1067 gcc_AC_INITFINI_ARRAY
1068
1069 # mkdir takes a single argument on some systems.
1070 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1071
1072 # File extensions
1073 manext='.1'
1074 objext='.o'
1075 AC_SUBST(manext)
1076 AC_SUBST(objext)
1077
1078 # With Setjmp/Longjmp based exception handling.
1079 AC_ARG_ENABLE(sjlj-exceptions,
1080 [  --enable-sjlj-exceptions
1081                           arrange to use setjmp/longjmp exception handling],
1082 [sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1083 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1084   [Define 0/1 to force the choice for exception handling model.])])
1085
1086 if test x$host = x$target; then
1087    AC_CHECK_LIB(unwind, main, use_libunwind_default=yes, use_libunwind_default=no)
1088 else
1089    use_libunwind_default=no
1090 fi
1091 # Use libunwind based exception handling.
1092 AC_ARG_ENABLE(libunwind-exceptions,
1093 [  --enable-libunwind-exceptions  force use libunwind for exceptions],
1094 use_libunwind_exceptions=$enableval,
1095 use_libunwind_exceptions=$use_libunwind_default)
1096 if test x"$use_libunwind_exceptions" = xyes; then
1097    AC_DEFINE(USE_LIBUNWIND_EXCEPTIONS, 1,
1098         [Define if gcc should use -lunwind.])
1099 fi
1100
1101 # --------------------------------------------------------
1102 # Build, host, and target specific configuration fragments
1103 # --------------------------------------------------------
1104
1105 # Collect build-machine-specific information.
1106 . ${srcdir}/config.build
1107
1108 # Collect host-machine-specific information.
1109 . ${srcdir}/config.host
1110
1111 target_gtfiles=
1112
1113 # Collect target-machine-specific information.
1114 . ${srcdir}/config.gcc
1115
1116 extra_objs="${host_extra_objs} ${extra_objs}"
1117 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1118
1119 # Default the target-machine variables that were not explicitly set.
1120 if test x"$tm_file" = x
1121 then tm_file=$cpu_type/$cpu_type.h; fi
1122
1123 if test x"$extra_headers" = x
1124 then extra_headers=; fi
1125
1126 if test x$md_file = x
1127 then md_file=$cpu_type/$cpu_type.md; fi
1128
1129 if test x$out_file = x
1130 then out_file=$cpu_type/$cpu_type.c; fi
1131
1132 if test x"$tmake_file" = x
1133 then tmake_file=$cpu_type/t-$cpu_type
1134 fi
1135
1136 if test x"$dwarf2" = xyes
1137 then tm_file="$tm_file tm-dwarf2.h"
1138 fi
1139
1140 # Say what files are being used for the output code and MD file.
1141 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1142 echo "Using \`$srcdir/config/$md_file' as machine description file."
1143
1144 # If any of the xm_file variables contain nonexistent files, warn
1145 # about them and drop them.
1146
1147 bx=
1148 for x in $build_xm_file; do
1149   if    test -f $srcdir/config/$x
1150   then      bx="$bx $x"
1151   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1152   fi
1153 done
1154 build_xm_file="$bx"
1155
1156 hx=
1157 for x in $host_xm_file; do
1158   if    test -f $srcdir/config/$x
1159   then      hx="$hx $x"
1160   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1161   fi
1162 done
1163 host_xm_file="$hx"
1164
1165 tx=
1166 for x in $xm_file; do
1167   if    test -f $srcdir/config/$x
1168   then      tx="$tx $x"
1169   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1170   fi
1171 done
1172 xm_file="$tx"
1173
1174 count=a
1175 for f in $tm_file; do
1176         count=${count}x
1177 done
1178 if test $count = ax; then
1179         echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1180 else
1181         echo "Using the following target machine macro files:"
1182         for f in $tm_file; do
1183                 echo "  $srcdir/config/$f"
1184         done
1185 fi
1186
1187 if test x$need_64bit_hwint = xyes; then
1188         AC_DEFINE(NEED_64BIT_HOST_WIDE_INT, 1,
1189 [Define to 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h).])
1190 fi
1191
1192 count=a
1193 for f in $host_xm_file; do
1194         count=${count}x
1195 done
1196 if test $count = a; then
1197         :
1198 elif test $count = ax; then
1199         echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1200 else
1201         echo "Using the following host machine macro files:"
1202         for f in $host_xm_file; do
1203                 echo "  $srcdir/config/$f"
1204         done
1205 fi
1206 echo "Using ${out_host_hook_obj} for host machine hooks."
1207
1208 if test "$host_xm_file" != "$build_xm_file"; then
1209         count=a
1210         for f in $build_xm_file; do
1211                 count=${count}x
1212         done
1213         if test $count = a; then
1214                 :
1215         elif test $count = ax; then
1216                 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1217         else
1218                 echo "Using the following build machine macro files:"
1219                 for f in $build_xm_file; do
1220                         echo "  $srcdir/config/$f"
1221                 done
1222         fi
1223 fi
1224
1225 # ---------
1226 # Threading
1227 # ---------
1228
1229 # Check if a valid thread package
1230 case ${enable_threads} in
1231   "" | no)
1232     # No threads
1233     target_thread_file='single'
1234     ;;
1235   yes)
1236     # default
1237     target_thread_file='single'
1238     ;;
1239   aix | dce | gnat | irix | posix | rtems | \
1240   single | solaris | vxworks | win32 )
1241     target_thread_file=${enable_threads}
1242     ;;
1243   *)
1244     echo "${enable_threads} is an unknown thread package" 1>&2
1245     exit 1
1246     ;;
1247 esac
1248
1249 if test x${thread_file} = x; then
1250   # No thread file set by target-specific clauses in config.gcc,
1251   # so use file chosen by default logic above
1252   thread_file=${target_thread_file}
1253 fi
1254
1255 # Make gthr-default.h if we have a thread file.
1256 gthread_flags=
1257 if test $thread_file != single; then
1258   rm -f gthr-default.h
1259   echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h
1260   gthread_flags=-DHAVE_GTHR_DEFAULT
1261 fi
1262 AC_SUBST(gthread_flags)
1263
1264 # --------
1265 # UNSORTED
1266 # --------
1267
1268 if test x$enable___cxa_atexit = xyes || \
1269    test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1270    AC_CHECK_FUNC(__cxa_atexit,
1271         [AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 1,
1272         [Define if you want to use __cxa_atexit, rather than atexit, to
1273         register C++ destructors for local statics and global objects.
1274         This is essential for fully standards-compliant handling of
1275         destructors, but requires __cxa_atexit in libc.])],
1276         echo "__cxa_atexit can't be enabled on this target")
1277 fi
1278
1279 # Look for a file containing extra machine modes.
1280 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1281   extra_modes_file='$(srcdir)'/config/${extra_modes}
1282   AC_SUBST(extra_modes_file)
1283   AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1284   [Define to the name of a file containing a list of extra machine modes
1285    for this architecture.])
1286 fi
1287
1288 # auto-host.h is the file containing items generated by autoconf and is
1289 # the first file included by config.h.
1290 # If host=build, it is correct to have bconfig include auto-host.h
1291 # as well.  If host!=build, we are in error and need to do more
1292 # work to find out the build config parameters.
1293 if test x$host = x$build
1294 then
1295         build_auto=auto-host.h
1296         FORBUILD=..
1297 else
1298         # We create a subdir, then run autoconf in the subdir.
1299         # To prevent recursion we set host and build for the new
1300         # invocation of configure to the build for this invocation
1301         # of configure.
1302         tempdir=build.$$
1303         rm -rf $tempdir
1304         mkdir $tempdir
1305         cd $tempdir
1306         case ${srcdir} in
1307         /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1308         *) realsrcdir=../${srcdir};;
1309         esac
1310         saved_CFLAGS="${CFLAGS}"
1311         CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1312         ${realsrcdir}/configure \
1313                 --enable-languages=${enable_languages-all} \
1314                 --target=$target_alias --host=$build_alias --build=$build_alias
1315         CFLAGS="${saved_CFLAGS}"
1316
1317         # We just finished tests for the build machine, so rename
1318         # the file auto-build.h in the gcc directory.
1319         mv auto-host.h ../auto-build.h
1320         cd ..
1321         rm -rf $tempdir
1322         build_auto=auto-build.h
1323         FORBUILD=../${build_subdir}
1324 fi
1325 AC_SUBST(FORBUILD)
1326
1327 tm_file="${tm_file} defaults.h"
1328 tm_p_file="${tm_p_file} tm-preds.h"
1329 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1330 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1331 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1332 # put this back in temporarily.
1333 xm_file="ansidecl.h ${xm_file}"
1334
1335 # --------
1336 # UNSORTED
1337 # --------
1338
1339 # Get the version trigger filename from the toplevel
1340 if test "${with_gcc_version_trigger+set}" = set; then
1341         gcc_version_trigger=$with_gcc_version_trigger
1342 else
1343         gcc_version_trigger=${srcdir}/version.c
1344 fi
1345 changequote(,)dnl
1346 gcc_version_full=`grep version_string ${gcc_version_trigger} | sed -e 's/.*"\([^"]*\)".*/\1/'`
1347 gcc_version=`echo ${gcc_version_full} | sed -e 's/\([^ ]*\) .*/\1/'`
1348
1349 # Compile in configure arguments.
1350 if test -f configargs.h ; then
1351         # Being re-configured.
1352         gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1353         gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1354 else
1355         gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1356 fi
1357
1358 # Double all backslashes and backslash all quotes to turn
1359 # gcc_config_arguments into a C string.
1360 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1361 $gcc_config_arguments
1362 EOF
1363 gcc_config_arguments_str=`cat conftest.out`
1364 rm -f conftest.out
1365
1366 cat > configargs.h <<EOF
1367 /* Generated automatically. */
1368 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1369 static const char thread_model[] = "$thread_file";
1370
1371 static const struct {
1372   const char *name, *value;
1373 } configure_default_options[] = $configure_default_options;
1374 EOF
1375 changequote([,])dnl
1376
1377 # Internationalization
1378 PACKAGE=gcc
1379 VERSION="$gcc_version"
1380 AC_SUBST(PACKAGE)
1381 AC_SUBST(VERSION)
1382
1383 ZW_GNU_GETTEXT_SISTER_DIR
1384
1385 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1386 # -liconv on the link line twice.
1387 case "$LIBINTL" in *$LIBICONV*)
1388         LIBICONV= ;;
1389 esac
1390
1391 # Windows32 Registry support for specifying GCC installation paths.
1392 AC_ARG_ENABLE(win32-registry,
1393 [  --disable-win32-registry
1394                           disable lookup of installation paths in the
1395                           Registry on Windows hosts
1396   --enable-win32-registry enable registry lookup (default)
1397   --enable-win32-registry=KEY
1398                           use KEY instead of GCC version as the last portion
1399                           of the registry key],,)
1400 case $host_os in
1401         win32 | pe | cygwin* | mingw32* | uwin*)
1402 AC_MSG_CHECKING(whether windows registry support is requested)
1403 if test "x$enable_win32_registry" != xno; then
1404   AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1405 [Define to 1 if installation paths should be looked up in Windows32
1406    Registry. Ignored on non windows32 hosts.])
1407   AC_MSG_RESULT(yes)
1408   AC_SEARCH_LIBS(RegOpenKeyExA, advapi32)
1409 else
1410   AC_MSG_RESULT(no)
1411 fi
1412
1413 # Check if user specified a different registry key.
1414 case "x${enable_win32_registry}" in
1415 x | xyes)
1416   # default.
1417   gcc_cv_win32_registry_key="$VERSION"
1418   ;;
1419 xno)
1420   # no registry lookup.
1421   gcc_cv_win32_registry_key=''
1422   ;;
1423 *)
1424   # user-specified key.
1425   gcc_cv_win32_registry_key="$enable_win32_registry"
1426   ;;
1427 esac
1428
1429 if test "x$enable_win32_registry" != xno; then
1430   AC_MSG_CHECKING(registry key on windows hosts)
1431   AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$gcc_cv_win32_registry_key",
1432         [Define to be the last portion of registry key on windows hosts.])
1433   AC_MSG_RESULT($gcc_cv_win32_registry_key)
1434 fi
1435 ;;
1436 esac
1437
1438 # Get an absolute path to the GCC top-level source directory
1439 holddir=`${PWDCMD-pwd}`
1440 cd $srcdir
1441 topdir=`${PWDCMD-pwd}`
1442 cd $holddir
1443
1444 # Conditionalize the makefile for this host machine.
1445 xmake_file=
1446 for f in ${host_xmake_file}
1447 do
1448         if test -f ${srcdir}/config/$f
1449         then
1450                 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1451         fi
1452 done
1453
1454 # Conditionalize the makefile for this target machine.
1455 tmake_file_=
1456 for f in ${tmake_file}
1457 do
1458         if test -f ${srcdir}/config/$f
1459         then
1460                 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1461         fi
1462 done
1463 tmake_file="${tmake_file_}"
1464
1465 symbolic_link='ln -s'
1466
1467 # If the host doesn't support symlinks, modify CC in
1468 # FLAGS_TO_PASS so CC="stage1/xgcc -Bstage1/" works.
1469 # Otherwise, we can use "CC=$(CC)".
1470 rm -f symtest.tem
1471 if $symbolic_link $srcdir/gcc.c symtest.tem 2>/dev/null
1472 then
1473         cc_set_by_configure="\$(CC)"
1474         quoted_cc_set_by_configure="\$(CC)"
1475         stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1476         quoted_stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1477 else
1478         rm -f symtest.tem
1479         if cp -p $srcdir/gcc.c symtest.tem 2>/dev/null
1480         then
1481                 symbolic_link="cp -p"
1482         else
1483                 symbolic_link="cp"
1484         fi
1485         cc_set_by_configure="\`case '\$(CC)' in stage*) echo '\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\$(CC)';; esac\`"
1486         quoted_cc_set_by_configure="\\\`case '\\\$(CC)' in stage*) echo '\\\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(CC)';; esac\\\`"
1487         stage_prefix_set_by_configure="\`case '\$(STAGE_PREFIX)' in stage*) echo '\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\$(STAGE_PREFIX)';; esac\`"
1488         quoted_stage_prefix_set_by_configure="\\\`case '\\\$(STAGE_PREFIX)' in stage*) echo '\\\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(STAGE_PREFIX)';; esac\\\`"
1489 fi
1490 rm -f symtest.tem
1491
1492 out_object_file=`basename $out_file .c`.o
1493
1494 tm_file_list=
1495 tm_include_list=
1496 for f in $tm_file; do
1497   case $f in
1498     defaults.h )
1499        tm_file_list="${tm_file_list} \$(srcdir)/$f"
1500        tm_include_list="${tm_include_list} $f"
1501        ;;
1502     * )
1503        tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1504        tm_include_list="${tm_include_list} config/$f"
1505        ;;
1506   esac
1507 done
1508
1509 tm_p_file_list=
1510 tm_p_include_list=
1511 for f in $tm_p_file; do
1512   case $f in
1513     tm-preds.h )
1514        tm_p_file_list="${tm_p_file_list} $f"
1515        tm_p_include_list="${tm_p_include_list} $f"
1516        ;;
1517     * )
1518        tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1519        tm_p_include_list="${tm_p_include_list} config/$f"
1520   esac
1521 done
1522
1523 xm_file_list=
1524 xm_include_list=
1525 for f in $xm_file; do
1526   case $f in
1527     ansidecl.h )
1528        xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1529        xm_include_list="${xm_include_list} $f"
1530        ;;
1531     auto-host.h )
1532        xm_file_list="${xm_file_list} $f"
1533        xm_include_list="${xm_include_list} $f"
1534        ;;
1535     * )
1536        xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1537        xm_include_list="${xm_include_list} config/$f"
1538        ;;
1539   esac
1540 done
1541
1542 host_xm_file_list=
1543 host_xm_include_list=
1544 for f in $host_xm_file; do
1545   case $f in
1546     ansidecl.h )
1547        host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1548        host_xm_include_list="${host_xm_include_list} $f"
1549        ;;
1550     auto-host.h )
1551        host_xm_file_list="${host_xm_file_list} $f"
1552        host_xm_include_list="${host_xm_include_list} $f"
1553        ;;
1554     * )
1555        host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1556        host_xm_include_list="${host_xm_include_list} config/$f"
1557        ;;
1558   esac
1559 done
1560
1561 build_xm_file_list=
1562 for f in $build_xm_file; do
1563   case $f in
1564     ansidecl.h )
1565        build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1566        build_xm_include_list="${build_xm_include_list} $f"
1567        ;;
1568     auto-build.h | auto-host.h )
1569        build_xm_file_list="${build_xm_file_list} $f"
1570        build_xm_include_list="${build_xm_include_list} $f"
1571        ;;
1572     * )
1573        build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1574        build_xm_include_list="${build_xm_include_list} config/$f"
1575        ;;
1576   esac
1577 done
1578
1579 # Define macro CROSS_COMPILE in compilation if this is a cross-compiler.
1580 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1581 CROSS=                                          AC_SUBST(CROSS)
1582 ALL=all.internal                                AC_SUBST(ALL)
1583 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1584 if test x$host != x$target
1585 then
1586         CROSS="-DCROSS_COMPILE"
1587         ALL=all.cross
1588         SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1589         case "$host","$target" in
1590         # Darwin crosses can use the host system's libraries and headers,
1591         # because of the fat library support.  Of course, it must be the
1592         # same version of Darwin on both sides.  Allow the user to
1593         # just say --target=foo-darwin without a version number to mean
1594         # "the version on this system".
1595             *-*-darwin*,*-*-darwin*)
1596                 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1597                 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1598                 if test $hostos = $targetos -o $targetos = darwin ; then
1599                     CROSS=
1600                     SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1601                     with_headers=yes
1602                 fi
1603                 ;;
1604
1605             i?86-*-*,x86_64-*-* \
1606             | powerpc*-*-*,powerpc64*-*-*)
1607                 CROSS="$CROSS -DNATIVE_CROSS" ;;
1608         esac
1609 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1610         # This is just $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR)
1611         SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1612 fi
1613
1614 # If this is a cross-compiler that does not
1615 # have its own set of headers then define
1616 # inhibit_libc
1617
1618 # If this is using newlib, without having the headers available now,
1619 # then define inhibit_libc in LIBGCC2_CFLAGS.
1620 # This prevents libgcc2 from containing any code which requires libc
1621 # support.
1622 inhibit_libc=
1623 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1624        test x$with_newlib = xyes ; } &&
1625      { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1626        inhibit_libc=-Dinhibit_libc
1627 fi
1628 AC_SUBST(inhibit_libc)
1629
1630 # When building gcc with a cross-compiler, we need to adjust things so
1631 # that the generator programs are still built with the native compiler.
1632 # Also, we cannot run fixincludes or fix-header.
1633
1634 # These are the normal (build=host) settings:
1635 BUILD_PREFIX=                   AC_SUBST(BUILD_PREFIX)
1636 BUILD_PREFIX_1=ignore-          AC_SUBST(BUILD_PREFIX_1)
1637 CC_FOR_BUILD='$(CC)'            AC_SUBST(CC_FOR_BUILD)
1638 BUILD_CFLAGS='$(ALL_CFLAGS)'    AC_SUBST(BUILD_CFLAGS)
1639
1640 STMP_FIXINC=stmp-fixinc         AC_SUBST(STMP_FIXINC)
1641
1642 # Possibly disable fixproto, on a per-target basis.
1643 case ${use_fixproto} in
1644   no)
1645     STMP_FIXPROTO=
1646     ;;
1647   yes)
1648     STMP_FIXPROTO=stmp-fixproto
1649     ;;
1650 esac
1651 AC_SUBST(STMP_FIXPROTO)
1652
1653 # And these apply if build != host, or we are generating coverage data
1654 if test x$build != x$host || test "x$coverage_flags" != x
1655 then
1656     BUILD_PREFIX=build-
1657     BUILD_PREFIX_1=build-
1658     BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1659
1660     if test "x$TARGET_SYSTEM_ROOT" = x; then
1661         STMP_FIXINC=
1662         STMP_FIXPROTO=
1663     fi
1664 fi
1665
1666 # Expand extra_headers to include complete path.
1667 # This substitutes for lots of t-* files.
1668 extra_headers_list=
1669 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1670 for file in ${extra_headers} ; do
1671   extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1672 done
1673
1674 # Define collect2 in Makefile.
1675 case $host_can_use_collect2 in
1676   no) collect2= ;;
1677   *) collect2='collect2$(exeext)' ;;
1678 esac
1679 AC_SUBST([collect2])
1680
1681 # Add a definition of USE_COLLECT2 if system wants one.
1682 case $use_collect2 in
1683   no) use_collect2= ;;
1684   "") ;;
1685   *)
1686     host_xm_defines="${host_xm_defines} USE_COLLECT2"
1687     xm_defines="${xm_defines} USE_COLLECT2"
1688     case $host_can_use_collect2 in
1689       no)
1690         AC_MSG_ERROR([collect2 is required but cannot be built on this system])
1691         ;;
1692     esac
1693     ;;
1694 esac
1695
1696 # ---------------------------
1697 # Assembler & linker features
1698 # ---------------------------
1699
1700 # Identify the assembler which will work hand-in-glove with the newly
1701 # built GCC, so that we can examine its features.  This is the assembler
1702 # which will be driven by the driver program.
1703 #
1704 # If build != host, and we aren't building gas in-tree, we identify a
1705 # build->target assembler and hope that it will have the same features
1706 # as the host->target assembler we'll be using.
1707 AC_MSG_CHECKING(what assembler to use)
1708 in_tree_gas=no
1709 gcc_cv_as=
1710 gcc_cv_gas_major_version=
1711 gcc_cv_gas_minor_version=
1712 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1713 if test -x "$DEFAULT_ASSEMBLER"; then
1714         gcc_cv_as="$DEFAULT_ASSEMBLER"
1715 elif test -x as$host_exeext; then
1716         # Build using assembler in the current directory.
1717         gcc_cv_as=./as$host_exeext
1718 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
1719      && test -f ../gas/Makefile \
1720      && test x$build = x$host; then
1721   # Single tree build which includes gas.  We want to prefer it
1722   # over whatever linker top-level may have detected, since
1723   # we'll use what we're building after installation anyway.
1724   in_tree_gas=yes
1725   _gcc_COMPUTE_GAS_VERSION
1726   rm -f as$host_exeext
1727   $symbolic_link ../gas/as-new$host_exeext as$host_exeext 2>/dev/null
1728   in_tree_gas_is_elf=no
1729   if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
1730      || (grep 'obj_format = multi' ../gas/Makefile \
1731          && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
1732   then
1733     in_tree_gas_is_elf=yes
1734   fi
1735 m4_pattern_allow([AS_FOR_TARGET])dnl
1736 elif test -x "$AS_FOR_TARGET"; then
1737         gcc_cv_as="$AS_FOR_TARGET"
1738 elif test -x "$AS" && test x$host = x$target; then
1739         gcc_cv_as="$AS"
1740 fi
1741
1742 if test "x$gcc_cv_as" = x; then
1743         # Search the same directories that the installed compiler will
1744         # search.  Else we may find the wrong assembler and lose.  If we
1745         # do not find a suitable assembler binary, then try the user's
1746         # path.
1747         #
1748         # Also note we have to check MD_EXEC_PREFIX before checking the
1749         # user's path.  Unfortunately, there is no good way to get at the
1750         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1751         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1752         # to be fixed as part of the make/configure rewrite too.
1753
1754         if test "x$exec_prefix" = xNONE; then
1755                 if test "x$prefix" = xNONE; then
1756                         test_prefix=/usr/local
1757                 else
1758                         test_prefix=$prefix
1759                 fi
1760         else
1761                 test_prefix=$exec_prefix
1762         fi
1763
1764         # If the loop below does not find an assembler, then use whatever
1765         # one we can find in the users's path.
1766         # user's path.
1767         if test "x$program_prefix" != xNONE; then
1768                 gcc_cv_as=${program_prefix}as$host_exeext
1769         else
1770                 gcc_cv_as=`echo as | sed "${program_transform_name}"`$host_exeext
1771         fi
1772
1773         test_dirs="$test_prefix/libexec/gcc/$target_noncanonical/$gcc_version \
1774                    $test_prefix/libexec/gcc/$target_noncanonical \
1775                    /usr/lib/gcc/$target_noncanonical/$gcc_version \
1776                    /usr/lib/gcc/$target_noncanonical \
1777                    $test_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version \
1778                    $test_prefix/$target_noncanonical/bin"
1779
1780         if test x$host = x$target; then
1781             test_dirs="$test_dirs \
1782                    /usr/libexec \
1783                    /usr/ccs/gcc \
1784                    /usr/ccs/bin \
1785                    /udk/usr/ccs/bin \
1786                    /bsd43/usr/lib/cmplrs/cc \
1787                    /usr/cross64/usr/bin \
1788                    /usr/lib/cmplrs/cc \
1789                    /sysv/usr/lib/cmplrs/cc \
1790                    /svr4/usr/lib/cmplrs/cc \
1791                    /usr/bin"
1792         fi
1793
1794         for dir in $test_dirs; do
1795                 if test -x $dir/as$host_exeext; then
1796                         gcc_cv_as=$dir/as$host_exeext
1797                         break;
1798                 fi
1799         done
1800 fi
1801 case $in_tree_gas in
1802   yes)
1803     AC_MSG_RESULT("newly built gas")
1804     ;;
1805   no)
1806     AC_MSG_RESULT($gcc_cv_as)
1807     ;;
1808 esac
1809
1810 # Identify the linker which will work hand-in-glove with the newly
1811 # built GCC, so that we can examine its features.  This is the linker
1812 # which will be driven by the driver program.
1813 #
1814 # If build != host, and we aren't building gas in-tree, we identify a
1815 # build->target linker and hope that it will have the same features
1816 # as the host->target linker we'll be using.
1817 AC_MSG_CHECKING(what linker to use)
1818 in_tree_ld=no
1819 gcc_cv_ld=
1820 gcc_cv_gld_major_version=
1821 gcc_cv_gld_minor_version=
1822 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1823 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1824 if test -x "$DEFAULT_LINKER"; then
1825         gcc_cv_ld="$DEFAULT_LINKER"
1826 elif test -x collect-ld$host_exeext; then
1827         # Build using linker in the current directory.
1828         gcc_cv_ld=./collect-ld$host_exeext
1829 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
1830      && test -f ../ld/Makefile \
1831      && test x$build = x$host; then
1832         # Single tree build which includes ld.  We want to prefer it
1833         # over whatever linker top-level may have detected, since
1834         # we'll use what we're building after installation anyway.
1835         in_tree_ld=yes
1836         in_tree_ld_is_elf=no
1837         if (grep 'EMUL = .*elf' ../ld/Makefile \
1838             || grep 'EMUL = .*linux' ../ld/Makefile) > /dev/null; then
1839           in_tree_ld_is_elf=yes
1840         fi
1841         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
1842         do
1843 changequote(,)dnl
1844                 gcc_cv_gld_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
1845 changequote([,])dnl
1846                 if test x$gcc_cv_gld_version != x; then
1847                         break
1848                 fi
1849         done
1850 changequote(,)dnl
1851         gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
1852         gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1853 changequote([,])dnl
1854         rm -f collect-ld$host_exeext
1855         $symbolic_link ../ld/ld-new$host_exeext collect-ld$host_exeext \
1856                 2>/dev/null
1857 elif test -x "$LD_FOR_TARGET"; then
1858         gcc_cv_ld="$LD_FOR_TARGET"
1859 elif test -x "$LD" && test x$host = x$target; then
1860         gcc_cv_ld="$LD"
1861 fi
1862
1863 if test "x$gcc_cv_ld" = x; then
1864         # Search the same directories that the installed compiler will
1865         # search.  Else we may find the wrong linker and lose.  If we
1866         # do not find a suitable linker binary, then try the user's
1867         # path.
1868         #
1869         # Also note we have to check MD_EXEC_PREFIX before checking the
1870         # user's path.  Unfortunately, there is no good way to get at the
1871         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1872         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1873         # to be fixed as part of the make/configure rewrite too.
1874
1875         if test "x$exec_prefix" = xNONE; then
1876                 if test "x$prefix" = xNONE; then
1877                         test_prefix=/usr/local
1878                 else
1879                         test_prefix=$prefix
1880                 fi
1881         else
1882                 test_prefix=$exec_prefix
1883         fi
1884
1885         # If the loop below does not find an linker, then use whatever
1886         # one we can find in the users's path.
1887         # user's path.
1888         if test "x$program_prefix" != xNONE; then
1889                 gcc_cv_ld=${program_prefix}ld$host_exeext
1890         else
1891                 gcc_cv_ld=`echo ld | sed "${program_transform_name}"`$host_exeext
1892         fi
1893
1894         test_dirs="$test_prefix/libexec/gcc/$target_noncanonical/$gcc_version \
1895                    $test_prefix/libexec/gcc/$target_noncanonical \
1896                    /usr/lib/gcc/$target_noncanonical/$gcc_version \
1897                    /usr/lib/gcc/$target_noncanonical \
1898                    $test_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version \
1899                    $test_prefix/$target_noncanonical/bin"
1900
1901         if test x$host = x$target; then
1902             test_dirs="$test_dirs \
1903                    /usr/libexec \
1904                    /usr/ccs/gcc \
1905                    /usr/ccs/bin \
1906                    /udk/usr/ccs/bin \
1907                    /bsd43/usr/lib/cmplrs/cc \
1908                    /usr/cross64/usr/bin \
1909                    /usr/lib/cmplrs/cc \
1910                    /sysv/usr/lib/cmplrs/cc \
1911                    /svr4/usr/lib/cmplrs/cc \
1912                    /usr/bin"
1913         fi
1914
1915         for dir in $test_dirs; do
1916                 if test -x $dir/ld$host_exeext; then
1917                         gcc_cv_ld=$dir/ld$host_exeext
1918                         break;
1919                 fi
1920         done
1921 fi
1922 case $in_tree_ld in
1923   yes)
1924     AC_MSG_RESULT("newly built ld")
1925     ;;
1926   no)
1927     AC_MSG_RESULT($gcc_cv_ld)
1928     ;;
1929 esac
1930
1931 # Figure out what nm we will be using.
1932 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
1933 AC_MSG_CHECKING(what nm to use)
1934 in_tree_nm=no
1935 if test -x nm$host_exeext; then
1936         gcc_cv_nm=./nm$host_exeext
1937 elif test -f $gcc_cv_binutils_srcdir/configure.in \
1938      && test -f ../binutils/Makefile; then
1939         # Single tree build which includes binutils.
1940         in_tree_nm=yes
1941         gcc_cv_nm=./nm$host_exeext
1942         rm -f nm$host_exeext
1943         $symbolic_link ../binutils/nm-new$host_exeext nm$host_exeext 2>/dev/null
1944 elif test "x$program_prefix" != xNONE; then
1945         gcc_cv_nm=${program_prefix}nm$host_exeext
1946 else
1947         gcc_cv_nm=`echo nm | sed "${program_transform_name}"`$host_exeext
1948 fi
1949 case $in_tree_nm in
1950   yes) AC_MSG_RESULT("newly built nm") ;;
1951   no)  AC_MSG_RESULT($gcc_cv_nm) ;;
1952 esac
1953
1954 # Figure out what objdump we will be using.
1955 AC_MSG_CHECKING(what objdump to use)
1956 in_tree_objdump=no
1957 if test -x objdump$host_exeext; then
1958         gcc_cv_objdump=./objdump$host_exeext
1959 elif test -f $gcc_cv_binutils_srcdir/configure.in \
1960      && test -f ../binutils/Makefile; then
1961         # Single tree build which includes binutils.
1962         in_tree_objdump=yes
1963         gcc_cv_objdump=./objdump$host_exeext
1964         rm -f objdump$host_exeext
1965         $symbolic_link ../binutils/objdump$host_exeext \
1966                 objdump$host_exeext 2>/dev/null
1967 elif test "x$program_prefix" != xNONE; then
1968         gcc_cv_objdump=${program_prefix}objdump$host_exeext
1969 else
1970         gcc_cv_objdump=`echo objdump | \
1971                 sed "${program_transform_name}"`$host_exeext
1972 fi
1973 case $in_tree_objdump in
1974   yes) AC_MSG_RESULT("newly built objdump") ;;
1975   no)  AC_MSG_RESULT($gcc_cv_objdump) ;;
1976 esac
1977
1978 # Figure out what assembler alignment features are present.
1979 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
1980  [2,6,0],,
1981 [.balign 4
1982 .p2align 2],,
1983 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
1984   [Define if your assembler supports .balign and .p2align.])])
1985
1986 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
1987  [2,8,0],,
1988  [.p2align 4,,7],,
1989 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
1990   [Define if your assembler supports specifying the maximum number
1991    of bytes to skip when using the GAS .p2align command.])])
1992
1993 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
1994  [elf,2,9,0],,
1995  [conftest_label1: .word 0
1996 .subsection -1
1997 conftest_label2: .word 0
1998 .previous],
1999  [if test x$gcc_cv_nm != x; then
2000     $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2001     $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2002     if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2003     then :
2004     else gcc_cv_as_subsection_m1=yes
2005     fi
2006     rm -f conftest.nm1 conftest.nm2
2007   fi],
2008  [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2009   [Define if your assembler supports .subsection and .subsection -1 starts
2010    emitting at the beginning of your section.])])
2011
2012 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2013  [2,2,0],,
2014  [      .weak foobar],,
2015 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2016
2017 # .hidden needs to be supported in both the assembler and the linker,
2018 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2019 # This is irritatingly difficult to feature test for; we have to check the
2020 # date string after the version number.  If we've got an in-tree
2021 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2022 # to be safe.
2023 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2024 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2025  [elf,2,13,0],,
2026 [       .hidden foobar
2027 foobar:])
2028
2029 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2030 [if test $in_tree_ld = yes ; then
2031   gcc_cv_ld_hidden=no
2032   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 \
2033      && test $in_tree_ld_is_elf = yes; then
2034      gcc_cv_ld_hidden=yes
2035   fi
2036 else
2037   gcc_cv_ld_hidden=yes
2038   ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2039   if echo "$ld_ver" | grep GNU > /dev/null; then
2040 changequote(,)dnl
2041     ld_vers=`echo $ld_ver | sed -n \
2042         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
2043         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
2044         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
2045         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*\)[  ].*$,\1,p' \
2046         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)[     ].*$,\1,p' \
2047         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)[        ].*$,\1,p'`
2048     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'`
2049     if test 0"$ld_date" -lt 20020404; then
2050       if test -n "$ld_date"; then
2051         # If there was date string, but was earlier than 2002-04-04, fail
2052         gcc_cv_ld_hidden=no
2053       elif test -z "$ld_vers"; then
2054         # If there was no date string nor ld version number, something is wrong
2055         gcc_cv_ld_hidden=no
2056       else
2057         ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2058         ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2059         ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2060         test -z "$ld_vers_patch" && ld_vers_patch=0
2061         if test "$ld_vers_major" -lt 2; then
2062           gcc_cv_ld_hidden=no
2063         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2064           gcc_cv_ld_hidden="no"
2065         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2066           gcc_cv_ld_hidden=no
2067         fi
2068       fi
2069 changequote([,])dnl
2070     fi
2071   else
2072     case "${target}" in
2073       hppa64*-*-hpux* | ia64*-*-hpux*)
2074         gcc_cv_ld_hidden=yes
2075         ;;
2076       *)
2077         gcc_cv_ld_hidden=no
2078         ;;
2079     esac
2080   fi
2081 fi])
2082 libgcc_visibility=no
2083 AC_SUBST(libgcc_visibility)
2084 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2085   libgcc_visibility=yes
2086   AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2087   [Define if your assembler and linker support .hidden.])
2088 fi
2089
2090 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2091 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2092   [elf,2,11,0],,
2093 [       .data
2094         .uleb128 L2 - L1
2095 L1:
2096         .uleb128 1280
2097         .sleb128 -1010
2098 L2:],
2099  [# GAS versions before 2.11 do not support uleb128,
2100   # despite appearing to.
2101   # ??? There exists an elf-specific test that will crash
2102   # the assembler.  Perhaps it's better to figure out whether
2103   # arbitrary sections are supported and try the test.
2104   as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2105   if echo "$as_ver" | grep GNU > /dev/null; then
2106 changequote(,)dnl
2107     as_ver=`echo $as_ver | sed -e 's/GNU assembler \([0-9.][0-9.]*\).*/\1/'`
2108     as_major=`echo $as_ver | sed 's/\..*//'`
2109     as_minor=`echo $as_ver | sed 's/[^.]*\.\([0-9]*\).*/\1/'`
2110 changequote([,])dnl
2111     if test $as_major -eq 2 && test $as_minor -lt 11
2112     then :
2113     else gcc_cv_as_leb128=yes
2114     fi
2115   fi],
2116   [AC_DEFINE(HAVE_AS_LEB128, 1,
2117     [Define if your assembler supports .sleb128 and .uleb128.])])
2118
2119 # GAS versions up to and including 2.11.0 may mis-optimize
2120 # .eh_frame data.
2121 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2122   [elf,2,12,0],,
2123 [       .text
2124 .LFB1:
2125         .4byte  0
2126 .L1:
2127         .4byte  0
2128 .LFE1:
2129         .section        .eh_frame,"aw",@progbits
2130 __FRAME_BEGIN__:
2131         .4byte  .LECIE1-.LSCIE1
2132 .LSCIE1:
2133         .4byte  0x0
2134         .byte   0x1
2135         .ascii "z\0"
2136         .byte   0x1
2137         .byte   0x78
2138         .byte   0x1a
2139         .byte   0x0
2140         .byte   0x4
2141         .4byte  1
2142         .p2align 1
2143 .LECIE1:
2144 .LSFDE1:
2145         .4byte  .LEFDE1-.LASFDE1
2146 .LASFDE1:
2147         .4byte  .LASFDE1-__FRAME_BEGIN__
2148         .4byte  .LFB1
2149         .4byte  .LFE1-.LFB1
2150         .byte   0x4
2151         .4byte  .LFE1-.LFB1
2152         .byte   0x4
2153         .4byte  .L1-.LFB1
2154 .LEFDE1:],
2155 [  dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2156 cat > conftest.lit <<EOF
2157  0000 10000000 00000000 017a0001 781a0004  .........z..x...
2158  0010 01000000 12000000 18000000 00000000  ................
2159  0020 08000000 04080000 0044               .........D      @&t@
2160 EOF
2161 cat > conftest.big <<EOF
2162  0000 00000010 00000000 017a0001 781a0004  .........z..x...
2163  0010 00000001 00000012 00000018 00000000  ................
2164  0020 00000008 04000000 0844               .........D      @&t@
2165 EOF
2166   # If the assembler didn't choke, and we can objdump,
2167   # and we got the correct data, then succeed.
2168   if test x$gcc_cv_objdump != x \
2169   && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2170      | tail -3 > conftest.got \
2171   && { cmp conftest.lit conftest.got > /dev/null 2>&1 \
2172     || cmp conftest.big conftest.got > /dev/null 2>&1; }
2173   then
2174     gcc_cv_as_eh_frame=yes
2175   elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2176     gcc_cv_as_eh_frame=buggy
2177   else
2178     # Uh oh, what do we do now?
2179     gcc_cv_as_eh_frame=no
2180   fi])
2181
2182 if test $gcc_cv_as_eh_frame = buggy; then
2183   AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2184   [Define if your assembler mis-optimizes .eh_frame data.])
2185 fi
2186
2187 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2188  [elf,2,12,0], [--fatal-warnings],
2189  [.section .rodata.str, "aMS", @progbits, 1])
2190 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2191   [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2192 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2193
2194 # Thread-local storage - the check is heavily parametrized.
2195 conftest_s=
2196 tls_first_major=
2197 tls_first_minor=
2198 tls_as_opt=
2199 case "$target" in
2200 changequote(,)dnl
2201   alpha*-*-*)
2202     conftest_s='
2203         .section ".tdata","awT",@progbits
2204 foo:    .long   25
2205         .text
2206         ldq     $27,__tls_get_addr($29)         !literal!1
2207         lda     $16,foo($29)                    !tlsgd!1
2208         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
2209         ldq     $27,__tls_get_addr($29)         !literal!2
2210         lda     $16,foo($29)                    !tlsldm!2
2211         jsr     $26,($27),__tls_get_addr        !lituse_tlsldm!2
2212         ldq     $1,foo($29)                     !gotdtprel
2213         ldah    $2,foo($29)                     !dtprelhi
2214         lda     $3,foo($2)                      !dtprello
2215         lda     $4,foo($29)                     !dtprel
2216         ldq     $1,foo($29)                     !gottprel
2217         ldah    $2,foo($29)                     !tprelhi
2218         lda     $3,foo($2)                      !tprello
2219         lda     $4,foo($29)                     !tprel'
2220         tls_first_major=2
2221         tls_first_minor=13
2222         tls_as_opt=--fatal-warnings
2223         ;;
2224   i[34567]86-*-*)
2225     conftest_s='
2226         .section ".tdata","awT",@progbits
2227 foo:    .long   25
2228         .text
2229         movl    %gs:0, %eax
2230         leal    foo@TLSGD(,%ebx,1), %eax
2231         leal    foo@TLSLDM(%ebx), %eax
2232         leal    foo@DTPOFF(%eax), %edx
2233         movl    foo@GOTTPOFF(%ebx), %eax
2234         subl    foo@GOTTPOFF(%ebx), %eax
2235         addl    foo@GOTNTPOFF(%ebx), %eax
2236         movl    foo@INDNTPOFF, %eax
2237         movl    $foo@TPOFF, %eax
2238         subl    $foo@TPOFF, %eax
2239         leal    foo@NTPOFF(%ecx), %eax'
2240         tls_first_major=2
2241         tls_first_minor=14
2242         tls_as_opt=--fatal-warnings
2243         ;;
2244   x86_64-*-*)
2245     conftest_s='
2246         .section ".tdata","awT",@progbits
2247 foo:    .long   25
2248         .text
2249         movq    %fs:0, %rax
2250         leaq    foo@TLSGD(%rip), %rdi
2251         leaq    foo@TLSLD(%rip), %rdi
2252         leaq    foo@DTPOFF(%rax), %rdx
2253         movq    foo@GOTTPOFF(%rip), %rax
2254         movq    $foo@TPOFF, %rax'
2255         tls_first_major=2
2256         tls_first_minor=14
2257         tls_as_opt=--fatal-warnings
2258         ;;
2259   ia64-*-*)
2260     conftest_s='
2261         .section ".tdata","awT",@progbits
2262 foo:    data8   25
2263         .text
2264         addl    r16 = @ltoff(@dtpmod(foo#)), gp
2265         addl    r17 = @ltoff(@dtprel(foo#)), gp
2266         addl    r18 = @ltoff(@tprel(foo#)), gp
2267         addl    r19 = @dtprel(foo#), gp
2268         adds    r21 = @dtprel(foo#), r13
2269         movl    r23 = @dtprel(foo#)
2270         addl    r20 = @tprel(foo#), gp
2271         adds    r22 = @tprel(foo#), r13
2272         movl    r24 = @tprel(foo#)'
2273         tls_first_major=2
2274         tls_first_minor=13
2275         tls_as_opt=--fatal-warnings
2276         ;;
2277   powerpc-*-*)
2278     conftest_s='
2279         .section ".tdata","awT",@progbits
2280         .align 2
2281 ld0:    .space 4
2282 ld1:    .space 4
2283 x1:     .space 4
2284 x2:     .space 4
2285 x3:     .space 4
2286         .text
2287         addi 3,31,ld0@got@tlsgd
2288         bl __tls_get_addr
2289         addi 3,31,x1@got@tlsld
2290         bl __tls_get_addr
2291         addi 9,3,x1@dtprel
2292         addis 9,3,x2@dtprel@ha
2293         addi 9,9,x2@dtprel@l
2294         lwz 9,x3@got@tprel(31)
2295         add 9,9,x@tls
2296         addi 9,2,x1@tprel
2297         addis 9,2,x2@tprel@ha
2298         addi 9,9,x2@tprel@l'
2299         tls_first_major=2
2300         tls_first_minor=14
2301         tls_as_opt="-a32 --fatal-warnings"
2302         ;;
2303   powerpc64-*-*)
2304     conftest_s='
2305         .section ".tdata","awT",@progbits
2306         .align 3
2307 ld0:    .space 8
2308 ld1:    .space 8
2309 x1:     .space 8
2310 x2:     .space 8
2311 x3:     .space 8
2312         .text
2313         addi 3,2,ld0@got@tlsgd
2314         bl .__tls_get_addr
2315         nop
2316         addi 3,2,ld1@toc
2317         bl .__tls_get_addr
2318         nop
2319         addi 3,2,x1@got@tlsld
2320         bl .__tls_get_addr
2321         nop
2322         addi 9,3,x1@dtprel
2323         bl .__tls_get_addr
2324         nop
2325         addis 9,3,x2@dtprel@ha
2326         addi 9,9,x2@dtprel@l
2327         bl .__tls_get_addr
2328         nop
2329         ld 9,x3@got@dtprel(2)
2330         add 9,9,3
2331         bl .__tls_get_addr
2332         nop'
2333         tls_first_major=2
2334         tls_first_minor=14
2335         tls_as_opt="-a64 --fatal-warnings"
2336         ;;
2337   s390-*-*)
2338     conftest_s='
2339         .section ".tdata","awT",@progbits
2340 foo:    .long   25
2341         .text
2342         .long   foo@TLSGD
2343         .long   foo@TLSLDM
2344         .long   foo@DTPOFF
2345         .long   foo@NTPOFF
2346         .long   foo@GOTNTPOFF
2347         .long   foo@INDNTPOFF
2348         l       %r1,foo@GOTNTPOFF(%r12)
2349         l       %r1,0(%r1):tls_load:foo
2350         bas     %r14,0(%r1,%r13):tls_gdcall:foo
2351         bas     %r14,0(%r1,%r13):tls_ldcall:foo'
2352         tls_first_major=2
2353         tls_first_minor=14
2354         tls_as_opt="-m31 --fatal-warnings"
2355         ;;
2356   s390x-*-*)
2357     conftest_s='
2358         .section ".tdata","awT",@progbits
2359 foo:    .long   25
2360         .text
2361         .quad   foo@TLSGD
2362         .quad   foo@TLSLDM
2363         .quad   foo@DTPOFF
2364         .quad   foo@NTPOFF
2365         .quad   foo@GOTNTPOFF
2366         lg      %r1,foo@GOTNTPOFF(%r12)
2367         larl    %r1,foo@INDNTPOFF
2368         brasl   %r14,__tls_get_offset@PLT:tls_gdcall:foo
2369         brasl   %r14,__tls_get_offset@PLT:tls_ldcall:foo'
2370         tls_first_major=2
2371         tls_first_minor=14
2372         tls_as_opt="-m64 -Aesame --fatal-warnings"
2373         ;;
2374   sh-*-* | sh[34]-*-*)
2375     conftest_s='
2376         .section ".tdata","awT",@progbits
2377 foo:    .long   25
2378         .text
2379         .long   foo@TLSGD
2380         .long   foo@TLSLDM
2381         .long   foo@DTPOFF
2382         .long   foo@GOTTPOFF
2383         .long   foo@TPOFF'
2384         tls_first_major=2
2385         tls_first_minor=13
2386         tls_as_opt=--fatal-warnings
2387         ;;
2388   sparc*-*-*)
2389     case "$target" in
2390       sparc*-sun-solaris2.*)
2391         on_solaris=yes
2392         ;;
2393       *)
2394         on_solaris=no
2395         ;;
2396     esac
2397     if test x$on_solaris = xyes && test x$gas_flag = xno; then
2398       conftest_s='
2399         .section ".tdata",#alloc,#write,#tls
2400 foo:    .long   25
2401         .text
2402         sethi   %tgd_hi22(foo), %o0
2403         add     %o0, %tgd_lo10(foo), %o1
2404         add     %l7, %o1, %o0, %tgd_add(foo)
2405         call    __tls_get_addr, %tgd_call(foo)
2406         sethi   %tldm_hi22(foo), %l1
2407         add     %l1, %tldm_lo10(foo), %l2
2408         add     %l7, %l2, %o0, %tldm_add(foo)
2409         call    __tls_get_addr, %tldm_call(foo)
2410         sethi   %tldo_hix22(foo), %l3
2411         xor     %l3, %tldo_lox10(foo), %l4
2412         add     %o0, %l4, %l5, %tldo_add(foo)
2413         sethi   %tie_hi22(foo), %o3
2414         add     %o3, %tie_lo10(foo), %o3
2415         ld      [%l7 + %o3], %o2, %tie_ld(foo)
2416         add     %g7, %o2, %o4, %tie_add(foo)
2417         sethi   %tle_hix22(foo), %l1
2418         xor     %l1, %tle_lox10(foo), %o5
2419         ld      [%g7 + %o5], %o1'
2420         tls_first_major=0
2421         tls_first_minor=0
2422     else
2423       conftest_s='
2424         .section ".tdata","awT",@progbits
2425 foo:    .long   25
2426         .text
2427         sethi   %tgd_hi22(foo), %o0
2428         add     %o0, %tgd_lo10(foo), %o1
2429         add     %l7, %o1, %o0, %tgd_add(foo)
2430         call    __tls_get_addr, %tgd_call(foo)
2431         sethi   %tldm_hi22(foo), %l1
2432         add     %l1, %tldm_lo10(foo), %l2
2433         add     %l7, %l2, %o0, %tldm_add(foo)
2434         call    __tls_get_addr, %tldm_call(foo)
2435         sethi   %tldo_hix22(foo), %l3
2436         xor     %l3, %tldo_lox10(foo), %l4
2437         add     %o0, %l4, %l5, %tldo_add(foo)
2438         sethi   %tie_hi22(foo), %o3
2439         add     %o3, %tie_lo10(foo), %o3
2440         ld      [%l7 + %o3], %o2, %tie_ld(foo)
2441         add     %g7, %o2, %o4, %tie_add(foo)
2442         sethi   %tle_hix22(foo), %l1
2443         xor     %l1, %tle_lox10(foo), %o5
2444         ld      [%g7 + %o5], %o1'
2445         tls_first_major=2
2446         tls_first_minor=14
2447         tls_as_opt="-32 --fatal-warnings"
2448       fi
2449         ;;
2450 changequote([,])dnl
2451 esac
2452 if test -z "$tls_first_major"; then
2453   : # If we don't have a check, assume no support.
2454 else
2455   gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
2456   [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
2457   [AC_DEFINE(HAVE_AS_TLS, 1,
2458             [Define if your assembler supports thread-local storage.])])
2459 fi
2460
2461 # Target-specific assembler checks.
2462
2463 if test x"$demangler_in_ld" = xyes; then
2464   AC_MSG_CHECKING(linker --demangle support)
2465   gcc_cv_ld_demangle=no
2466   if test $in_tree_ld = yes; then
2467     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 \
2468       gcc_cv_ld_demangle=yes
2469     fi
2470   elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
2471     # Check if the GNU linker supports --demangle option
2472     if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
2473       gcc_cv_ld_demangle=yes
2474     fi
2475   fi
2476   if test x"$gcc_cv_ld_demangle" = xyes; then
2477     AC_DEFINE(HAVE_LD_DEMANGLE, 1,
2478 [Define if your linker supports --demangle option.])
2479   fi
2480   AC_MSG_RESULT($gcc_cv_ld_demangle)
2481 fi
2482
2483 case "$target" in
2484   # All TARGET_ABI_OSF targets.
2485   alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
2486     gcc_GAS_CHECK_FEATURE([explicit relocation support],
2487         gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
2488 [       .set nomacro
2489         .text
2490         extbl   $3, $2, $3      !lituse_bytoff!1
2491         ldq     $2, a($29)      !literal!1
2492         ldq     $4, b($29)      !literal!2
2493         ldq_u   $3, 0($2)       !lituse_base!1
2494         ldq     $27, f($29)     !literal!5
2495         jsr     $26, ($27), f   !lituse_jsr!5
2496         ldah    $29, 0($26)     !gpdisp!3
2497         lda     $0, c($29)      !gprel
2498         ldah    $1, d($29)      !gprelhigh
2499         lda     $1, d($1)       !gprellow
2500         lda     $29, 0($29)     !gpdisp!3],,
2501     [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
2502   [Define if your assembler supports explicit relocations.])])
2503     ;;
2504
2505   cris-*-*)
2506     gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
2507       gcc_cv_as_cris_no_mul_bug,[2,15,91],
2508       [-no-mul-bug-abort], [.text],,
2509       [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
2510                 [Define if your assembler supports the -no-mul-bug-abort option.])])
2511     ;;
2512
2513   sparc*-*-*)
2514     gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
2515       [.register %g2, #scratch],,
2516       [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
2517                 [Define if your assembler supports .register.])])
2518
2519     gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
2520       [-relax], [.text],,
2521       [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
2522                 [Define if your assembler supports -relax option.])])
2523
2524     gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
2525       gcc_cv_as_sparc_ua_pcrel,,
2526       [-K PIC],
2527 [.text
2528 foo:
2529         nop
2530 .data
2531 .align 4
2532 .byte 0
2533 .uaword %r_disp32(foo)],
2534       [if test x$gcc_cv_ld != x \
2535        && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
2536          gcc_cv_as_sparc_ua_pcrel=yes
2537        fi
2538        rm -f conftest],
2539       [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
2540                 [Define if your assembler and linker support unaligned PC relative relocs.])
2541
2542       gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
2543         gcc_cv_as_sparc_ua_pcrel_hidden,,
2544         [-K PIC],
2545 [.data
2546 .align 4
2547 .byte 0x31
2548 .uaword %r_disp32(foo)
2549 .byte 0x32, 0x33, 0x34
2550 .global foo
2551 .hidden foo
2552 foo:
2553 .skip 4],
2554         [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
2555          && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
2556          && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
2557             | grep ' 31000000 07323334' > /dev/null 2>&1; then
2558             if $gcc_cv_objdump -R conftest 2> /dev/null \
2559                | grep 'DISP32' > /dev/null 2>&1; then
2560                 :
2561             else
2562                 gcc_cv_as_sparc_ua_pcrel_hidden=yes
2563             fi
2564          fi
2565          rm -f conftest],
2566          [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
2567                    [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
2568     ]) # unaligned pcrel relocs
2569
2570     gcc_GAS_CHECK_FEATURE([offsetable %lo()],
2571       gcc_cv_as_sparc_offsetable_lo10,,
2572       [-xarch=v9],
2573 [.text
2574         or %g1, %lo(ab) + 12, %g1
2575         or %g1, %lo(ab + 12), %g1],
2576       [if test x$gcc_cv_objdump != x \
2577        && %gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
2578           | grep ' 82106000 82106000' > /dev/null 2>&1; then
2579          gcc_cv_as_offsetable_lo10=yes
2580        fi],
2581        [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
2582                  [Define if your assembler supports offsetable %lo().])])
2583     ;;
2584
2585 changequote(,)dnl
2586   i[34567]86-*-* | x86_64-*-*)
2587 changequote([,])dnl
2588     case $target_os in
2589       cygwin* | pe | mingw32*)
2590         # Used for DWARF 2 in PE
2591         gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
2592           gcc_cv_as_ix86_pe_secrel32,
2593           [2,15,91],,
2594 [.text
2595 foo:    nop
2596 .data
2597         .secrel32 foo],
2598           [if test x$gcc_cv_ld != x \
2599            && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
2600              gcc_cv_as_ix86_pe_secrel32=yes
2601            fi
2602            rm -f conftest],
2603           [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
2604             [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
2605         ;;
2606     esac
2607
2608     gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
2609        gcc_cv_as_ix86_filds_fists,
2610       [2,9,0],, [filds mem; fists mem],,
2611       [AC_DEFINE(HAVE_GAS_FILDS_FISTS, 1,
2612         [Define if your assembler uses the new HImode fild and fist notation.])])
2613
2614     gcc_GAS_CHECK_FEATURE([cmov syntax],
2615       gcc_cv_as_ix86_cmov_sun_syntax,,,
2616       [cmovl.l %edx, %eax],,
2617       [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
2618         [Define if your assembler supports the Sun syntax for cmov.])])
2619
2620     # This one is used unconditionally by i386.[ch]; it is to be defined
2621     # to 1 if the feature is present, 0 otherwise.
2622     gcc_GAS_CHECK_FEATURE([GOTOFF in data],
2623         gcc_cv_as_ix86_gotoff_in_data, [2,11,0],,
2624 [       .text
2625 .L0:
2626         nop
2627         .data
2628         .long .L0@GOTOFF])
2629     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
2630       [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
2631       [Define true if the assembler supports '.long foo@GOTOFF'.])
2632     ;;
2633
2634   ia64*-*-*)
2635     gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
2636         gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
2637 [       .text
2638         addl r15 = @ltoffx(x#), gp
2639         ;;
2640         ld8.mov r16 = [[r15]], x#],,
2641     [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
2642           [Define if your assembler supports ltoffx and ldxmov relocations.])])
2643
2644     ;;
2645
2646   powerpc*-*-*)
2647     case $target in
2648       *-*-aix*) conftest_s='    .csect .text[[PR]]
2649         mfcr 3,128';;
2650       *-*-darwin*) conftest_s=' .text
2651         mfcr r3,128';;
2652       *)       conftest_s='     .text
2653         mfcr 3,128';;
2654     esac
2655
2656     gcc_GAS_CHECK_FEATURE([mfcr field support],
2657       gcc_cv_as_powerpc_mfcrf, [2,14,0],,
2658       [$conftest_s],,
2659       [AC_DEFINE(HAVE_AS_MFCRF, 1,
2660           [Define if your assembler supports mfcr field.])])
2661     ;;
2662
2663   mips*-*-*)
2664     gcc_GAS_CHECK_FEATURE([explicit relocation support],
2665       gcc_cv_as_mips_explicit_relocs, [2,14,0],,
2666 [       lw $4,%gp_rel(foo)($4)],,
2667       [if test x$target_cpu_default = x
2668        then target_cpu_default=MASK_EXPLICIT_RELOCS
2669        else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
2670        fi])
2671
2672     ;;
2673 esac
2674 # ??? Not all targets support dwarf2 debug_line, even within a version
2675 # of gas.  Moreover, we need to emit a valid instruction to trigger any
2676 # info to the output file.  So, as supported targets are added to gas 2.11,
2677 # add some instruction here to (also) show we expect this might work.
2678 # ??? Once 2.11 is released, probably need to add first known working
2679 # version to the per-target configury.
2680 case "$target" in
2681   i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* \
2682   | x86_64*-*-* | hppa*-*-* | arm*-*-* | strongarm*-*-* | xscale*-*-* \
2683   | xstormy16*-*-* | cris-*-* | xtensa-*-*)
2684     insn="nop"
2685     ;;
2686   ia64*-*-* | s390*-*-*)
2687     insn="nop 0"
2688     ;;
2689   mmix-*-*)
2690     insn="swym 0"
2691     ;;
2692 esac
2693 if test x"$insn" != x; then
2694  conftest_s="\
2695         .file 1 \"conftest.s\"
2696         .loc 1 3 0
2697         $insn"
2698  gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
2699   gcc_cv_as_dwarf2_debug_line,
2700   [elf,2,11,0],, [$conftest_s],
2701   [# ??? This fails with non-gnu grep.  Maybe use objdump?
2702    if grep debug_line conftest.o > /dev/null 2>&1; then
2703      gcc_cv_as_dwarf2_debug_line=yes
2704    fi])
2705
2706 # The .debug_line file table must be in the exact order that
2707 # we specified the files, since these indices are also used
2708 # by DW_AT_decl_file.  Approximate this test by testing if
2709 # the assembler bitches if the same index is assigned twice.
2710  gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
2711   gcc_cv_as_dwarf2_file_buggy,,,
2712 [       .file 1 "foo.s"
2713         .file 1 "bar.s"])
2714
2715  if test $gcc_cv_as_dwarf2_debug_line = yes \
2716  && test $gcc_cv_as_dwarf2_file_buggy = no; then
2717         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
2718   [Define if your assembler supports dwarf2 .file/.loc directives,
2719    and preserves file table indices exactly as given.])
2720  fi
2721
2722  gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
2723   gcc_cv_as_gdwarf2_flag,
2724   [elf,2,11,0], [--gdwarf2], [$insn],,
2725   [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
2726 [Define if your assembler supports the --gdwarf2 option.])])
2727
2728  gcc_GAS_CHECK_FEATURE([--gstabs option],
2729   gcc_cv_as_gstabs_flag,
2730   [elf,2,11,0], [--gstabs], [$insn],
2731   [# The native Solaris 9/Intel assembler doesn't understand --gstabs
2732    # and warns about it, but still exits successfully.  So check for
2733    # this.
2734    if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
2735    then :
2736    else gcc_cv_as_gstabs_flag=yes
2737    fi],
2738   [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
2739 [Define if your assembler supports the --gstabs option.])])
2740 fi
2741
2742 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2743 gcc_cv_ld_ro_rw_mix=unknown
2744 if test $in_tree_ld = yes ; then
2745   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 \
2746      && test $in_tree_ld_is_elf = yes; then
2747     gcc_cv_ld_ro_rw_mix=read-write
2748   fi
2749 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2750   echo '.section myfoosect, "a"' > conftest1.s
2751   echo '.section myfoosect, "aw"' > conftest2.s
2752   echo '.byte 1' >> conftest2.s
2753   echo '.section myfoosect, "a"' > conftest3.s
2754   echo '.byte 0' >> conftest3.s
2755   if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2756      && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2757      && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2758      && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2759         conftest2.o conftest3.o > /dev/null 2>&1; then
2760     gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2761                          | sed -e '/myfoosect/!d' -e N`
2762     if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2763       if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2764         gcc_cv_ld_ro_rw_mix=read-only
2765       else
2766         gcc_cv_ld_ro_rw_mix=read-write
2767       fi
2768     fi
2769   fi
2770 changequote(,)dnl
2771   rm -f conftest.* conftest[123].*
2772 changequote([,])dnl
2773 fi
2774 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2775         AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2776   [Define if your linker links a mix of read-only
2777    and read-write sections into a read-write section.])
2778 fi
2779 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2780
2781 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
2782 gcc_cv_ld_eh_frame_hdr=no
2783 if test $in_tree_ld = yes ; then
2784   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 \
2785      && test $in_tree_ld_is_elf = yes; then
2786     gcc_cv_ld_eh_frame_hdr=yes
2787   fi
2788 elif test x$gcc_cv_ld != x; then
2789         # Check if linker supports --eh-frame-hdr option
2790         if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
2791                 gcc_cv_ld_eh_frame_hdr=yes
2792         fi
2793 fi
2794 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
2795         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
2796 [Define if your linker supports --eh-frame-hdr option.])
2797 fi
2798 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
2799
2800 AC_MSG_CHECKING(linker position independent executable support)
2801 gcc_cv_ld_pie=no
2802 if test $in_tree_ld = yes ; then
2803   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 \
2804      && test $in_tree_ld_is_elf = yes; then
2805     gcc_cv_ld_pie=yes
2806   fi
2807 elif test x$gcc_cv_ld != x; then
2808         # Check if linker supports -pie option
2809         if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
2810                 gcc_cv_ld_pie=yes
2811         fi
2812 fi
2813 if test x"$gcc_cv_ld_pie" = xyes; then
2814         AC_DEFINE(HAVE_LD_PIE, 1,
2815 [Define if your linker supports -pie option.])
2816 fi
2817 AC_MSG_RESULT($gcc_cv_ld_pie)
2818
2819 # --------
2820 # UNSORTED
2821 # --------
2822
2823 AC_CACHE_CHECK(linker --as-needed support,
2824 gcc_cv_ld_as_needed,
2825 [gcc_cv_ld_as_needed=no
2826 if test $in_tree_ld = yes ; then
2827   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 \
2828      && test $in_tree_ld_is_elf = yes; then
2829     gcc_cv_ld_as_needed=yes
2830   fi
2831 elif test x$gcc_cv_ld != x; then
2832         # Check if linker supports --as-needed and --no-as-needed options
2833         if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
2834                 gcc_cv_ld_as_needed=yes
2835         fi
2836 fi
2837 ])
2838 if test x"$gcc_cv_ld_as_needed" = xyes; then
2839         AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
2840 [Define if your linker supports --as-needed and --no-as-needed options.])
2841 fi
2842
2843 if test x$with_sysroot = x && test x$host = x$target \
2844    && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" ; then
2845   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
2846 [Define to PREFIX/include if cpp should also search that directory.])
2847 fi
2848
2849 # Find out what GC implementation we want, or may, use.
2850 AC_ARG_WITH(gc,
2851 [  --with-gc={page,zone}   choose the garbage collection mechanism to use
2852                           with the compiler],
2853 [case "$withval" in
2854   page | zone)
2855     GGC=ggc-$withval
2856     ;;
2857   *)
2858     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
2859     ;;
2860 esac],
2861 [GGC=ggc-page])
2862 AC_SUBST(GGC)
2863 echo "Using $GGC for garbage collection."
2864
2865 # Use the system's zlib library.
2866 zlibdir=-L../zlib
2867 zlibinc="-I\$(srcdir)/../zlib"
2868 AC_ARG_WITH(system-zlib,
2869 [  --with-system-zlib      use installed libz],
2870 zlibdir=
2871 zlibinc=
2872 )
2873 AC_SUBST(zlibdir)
2874 AC_SUBST(zlibinc)
2875
2876 dnl Very limited version of automake's enable-maintainer-mode
2877
2878 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
2879   dnl maintainer-mode is disabled by default
2880   AC_ARG_ENABLE(maintainer-mode,
2881 [  --enable-maintainer-mode
2882                           enable make rules and dependencies not useful
2883                           (and sometimes confusing) to the casual installer],
2884       maintainer_mode=$enableval,
2885       maintainer_mode=no)
2886
2887 AC_MSG_RESULT($maintainer_mode)
2888
2889 if test "$maintainer_mode" = "yes"; then
2890   MAINT=''
2891 else
2892   MAINT='#'
2893 fi
2894 AC_SUBST(MAINT)dnl
2895
2896 AC_MSG_CHECKING([whether to use libbanshee for points-to alias analysis])
2897 AC_ARG_WITH(libbanshee,
2898 [  --with-libbanshee      enable libbanshee],
2899 libbanshee="$with_libbanshee",
2900 libbanshee=no)
2901
2902 if test x"$libbanshee" = xyes; then
2903         BANSHEELIB="../libbanshee/points-to/libandersen.a ../libbanshee/engine/libbansheeengine.a ../libbanshee/libcompat/libbansheecompat.a "
2904         BANSHEEINC="-I\$(srcdir)/../libbanshee/libcompat -I\$(srcdir)/../libbanshee -I\$(srcdir)/../libbanshee/points-to"
2905         ANDER="tree-alias-ander.o"
2906         AC_DEFINE(HAVE_BANSHEE, 1, [Define if BANSHEE is available])
2907 else
2908         BANSHEELIB=""
2909         BANSHEEINC=""
2910         ANDER=""
2911 fi
2912 AC_MSG_RESULT($with_libbanshee)
2913
2914 AC_SUBST(ANDER)
2915 AC_SUBST(BANSHEEINC)
2916 AC_SUBST(BANSHEELIB)
2917
2918 # --------------
2919 # Language hooks
2920 # --------------
2921
2922 # Make empty files to contain the specs and options for each language.
2923 # Then add #include lines to for a compiler that has specs and/or options.
2924
2925 lang_opt_files=
2926 lang_specs_files=
2927 lang_tree_files=
2928 for subdir in . $subdirs
2929 do
2930         if test -f $srcdir/$subdir/lang.opt; then
2931             lang_opt_files="$lang_opt_files $srcdir/$subdir/lang.opt"
2932         fi
2933         if test -f $srcdir/$subdir/lang-specs.h; then
2934             lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
2935         fi
2936         if test -f $srcdir/$subdir/$subdir-tree.def; then
2937             lang_tree_files="$lang_tree_files $srcdir/$subdir/$subdir-tree.def"
2938         fi
2939 done
2940
2941 # These (without "all_") are set in each config-lang.in.
2942 # `language' must be a single word so is spelled singularly.
2943 all_languages=
2944 all_boot_languages=
2945 all_compilers=
2946 all_stagestuff=
2947 all_outputs='Makefile fixinc/Makefile gccbug mklibgcc mkheaders libada-mk'
2948 # List of language makefile fragments.
2949 all_lang_makefrags=
2950 # List of language subdirectory makefiles.  Deprecated.
2951 all_lang_makefiles=
2952 # Files for gengtype
2953 all_gtfiles="$target_gtfiles"
2954 # Files for gengtype with language
2955 all_gtfiles_files_langs=
2956 all_gtfiles_files_files=
2957
2958 # Add the language fragments.
2959 # Languages are added via two mechanisms.  Some information must be
2960 # recorded in makefile variables, these are defined in config-lang.in.
2961 # We accumulate them and plug them into the main Makefile.
2962 # The other mechanism is a set of hooks for each of the main targets
2963 # like `clean', `install', etc.
2964
2965 language_hooks="Make-hooks"
2966
2967 for s in $subdirs
2968 do
2969                 language=
2970                 boot_language=
2971                 compilers=
2972                 stagestuff=
2973                 outputs=
2974                 gtfiles=
2975                 . ${srcdir}/$s/config-lang.in
2976                 if test "x$language" = x
2977                 then
2978                         echo "${srcdir}/$s/config-lang.in doesn't set \$language." 1>&2
2979                         exit 1
2980                 fi
2981                 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$s/Make-lang.in"
2982                 if test -f ${srcdir}/$s/Makefile.in
2983                 then all_lang_makefiles="$s/Makefile"
2984                 fi
2985                 all_languages="$all_languages $language"
2986                 if test "x$boot_language" = xyes
2987                 then
2988                         all_boot_languages="$all_boot_languages $language"
2989                 fi
2990                 all_compilers="$all_compilers $compilers"
2991                 all_stagestuff="$all_stagestuff $stagestuff"
2992                 all_outputs="$all_outputs $outputs"
2993                 all_gtfiles="$all_gtfiles $gtfiles"
2994                 for f in $gtfiles
2995                 do
2996                          all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2997                          all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2998                 done
2999 done
3000
3001 # Pick up gtfiles for c
3002 gtfiles=
3003 s="c"
3004 . ${srcdir}/c-config-lang.in
3005 all_gtfiles="$all_gtfiles $gtfiles"
3006 for f in $gtfiles
3007 do
3008         all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
3009         all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
3010 done
3011
3012 check_languages=
3013 for language in $all_languages
3014 do
3015                 check_languages="$check_languages check-$language"
3016 done
3017
3018 # We link each language in with a set of hooks, reached indirectly via
3019 # lang.${target}.
3020
3021 rm -f Make-hooks
3022 touch Make-hooks
3023 target_list="all.build all.cross start.encap rest.encap tags \
3024         install-normal install-common install-man \
3025         uninstall info man srcextra srcman srcinfo \
3026         mostlyclean clean distclean maintainer-clean \
3027         stage1 stage2 stage3 stage4 stageprofile stagefeedback"
3028 for t in $target_list
3029 do
3030         x=
3031         for lang in $all_languages
3032         do
3033                         x="$x $lang.$t"
3034         done
3035         echo "lang.$t: $x" >> Make-hooks
3036 done
3037
3038 # --------
3039 # UNSORTED
3040 # --------
3041
3042 # Create .gdbinit.
3043
3044 echo "dir ." > .gdbinit
3045 echo "dir ${srcdir}" >> .gdbinit
3046 if test x$gdb_needs_out_file_path = xyes
3047 then
3048         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
3049 fi
3050 if test "x$subdirs" != x; then
3051         for s in $subdirs
3052         do
3053                 echo "dir ${srcdir}/$s" >> .gdbinit
3054         done
3055 fi
3056 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
3057
3058 # If $(exec_prefix) exists and is not the same as $(prefix), then compute an
3059 # absolute path for gcc_tooldir based on inserting the number of up-directory
3060 # movements required to get from $(exec_prefix) to $(prefix) into the basic
3061 # $(libsubdir)/@(unlibsubdir) based path.
3062 # Don't set gcc_tooldir to tooldir since that's only passed in by the toplevel
3063 # make and thus we'd get different behavior depending on where we built the
3064 # sources.
3065 if test x$exec_prefix = xNONE -o x$exec_prefix = x$prefix; then
3066     gcc_tooldir='$(libsubdir)/$(unlibsubdir)/../$(target_noncanonical)'
3067 else
3068 changequote(<<, >>)dnl
3069 # An explanation of the sed strings:
3070 #  -e 's|^\$(prefix)||'   matches and eliminates 'prefix' from 'exec_prefix'
3071 #  -e 's|/$||'            match a trailing forward slash and eliminates it
3072 #  -e 's|^[^/]|/|'        forces the string to start with a forward slash (*)
3073 #  -e 's|/[^/]*|../|g'    replaces each occurrence of /<directory> with ../
3074 #
3075 # (*) Note this pattern overwrites the first character of the string
3076 # with a forward slash if one is not already present.  This is not a
3077 # problem because the exact names of the sub-directories concerned is
3078 # unimportant, just the number of them matters.
3079 #
3080 # The practical upshot of these patterns is like this:
3081 #
3082 #  prefix     exec_prefix        result
3083 #  ------     -----------        ------
3084 #   /foo        /foo/bar          ../
3085 #   /foo/       /foo/bar          ../
3086 #   /foo        /foo/bar/         ../
3087 #   /foo/       /foo/bar/         ../
3088 #   /foo        /foo/bar/ugg      ../../
3089 #
3090     dollar='$$'
3091     gcc_tooldir="\$(libsubdir)/\$(unlibsubdir)/\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/\$(dollar)||' -e 's|^[^/]|/|' -e 's|/[^/]*|../|g'\`\$(target_noncanonical)"
3092 changequote([, ])dnl
3093 fi
3094 AC_SUBST(gcc_tooldir)
3095 AC_SUBST(dollar)
3096
3097 # Find a directory in which to install a shared libgcc.
3098
3099 AC_ARG_ENABLE(version-specific-runtime-libs,
3100 [  --enable-version-specific-runtime-libs
3101                           specify that runtime libraries should be
3102                           installed in a compiler-specific directory])
3103
3104 AC_ARG_WITH(slibdir,
3105 [  --with-slibdir=DIR      shared libraries in DIR [LIBDIR]],
3106 slibdir="$with_slibdir",
3107 if test "${enable_version_specific_runtime_libs+set}" = set; then
3108   slibdir='$(libsubdir)'
3109 elif test "$host" != "$target"; then
3110   slibdir='$(build_tooldir)/lib'
3111 else
3112   slibdir='$(libdir)'
3113 fi)
3114 AC_SUBST(slibdir)
3115
3116 objdir=`${PWDCMD-pwd}`
3117 AC_SUBST(objdir)
3118
3119 # Substitute configuration variables
3120 AC_SUBST(subdirs)
3121 AC_SUBST(srcdir)
3122 AC_SUBST(all_boot_languages)
3123 AC_SUBST(all_compilers)
3124 AC_SUBST(all_gtfiles)
3125 AC_SUBST(all_gtfiles_files_langs)
3126 AC_SUBST(all_gtfiles_files_files)
3127 AC_SUBST(all_lang_makefrags)
3128 AC_SUBST(all_lang_makefiles)
3129 AC_SUBST(all_languages)
3130 AC_SUBST(all_stagestuff)
3131 AC_SUBST(build_exeext)
3132 AC_SUBST(build_install_headers_dir)
3133 AC_SUBST(build_xm_file_list)
3134 AC_SUBST(build_xm_include_list)
3135 AC_SUBST(build_xm_defines)
3136 AC_SUBST(check_languages)
3137 AC_SUBST(cc_set_by_configure)
3138 AC_SUBST(quoted_cc_set_by_configure)
3139 AC_SUBST(cpp_install_dir)
3140 AC_SUBST(xmake_file)
3141 AC_SUBST(tmake_file)
3142 AC_SUBST(extra_gcc_objs)
3143 AC_SUBST(extra_headers_list)
3144 AC_SUBST(extra_objs)
3145 AC_SUBST(extra_parts)
3146 AC_SUBST(extra_passes)
3147 AC_SUBST(extra_programs)
3148 AC_SUBST(float_h_file)
3149 AC_SUBST(gcc_config_arguments)
3150 AC_SUBST(gcc_gxx_include_dir)
3151 AC_SUBST(libstdcxx_incdir)
3152 AC_SUBST(gcc_version)
3153 AC_SUBST(gcc_version_full)
3154 AC_SUBST(gcc_version_trigger)
3155 AC_SUBST(host_exeext)
3156 AC_SUBST(host_xm_file_list)
3157 AC_SUBST(host_xm_include_list)
3158 AC_SUBST(host_xm_defines)
3159 AC_SUBST(out_host_hook_obj)
3160 AC_SUBST(install)
3161 AC_SUBST(lang_opt_files)
3162 AC_SUBST(lang_specs_files)
3163 AC_SUBST(lang_tree_files)
3164 AC_SUBST(local_prefix)
3165 AC_SUBST(md_file)
3166 AC_SUBST(objc_boehm_gc)
3167 AC_SUBST(out_file)
3168 AC_SUBST(out_object_file)
3169 AC_SUBST(stage_prefix_set_by_configure)
3170 AC_SUBST(quoted_stage_prefix_set_by_configure)
3171 AC_SUBST(symbolic_link)
3172 AC_SUBST(thread_file)
3173 AC_SUBST(tm_file_list)
3174 AC_SUBST(tm_include_list)
3175 AC_SUBST(tm_defines)
3176 AC_SUBST(tm_p_file_list)
3177 AC_SUBST(tm_p_include_list)
3178 AC_SUBST(xm_file_list)
3179 AC_SUBST(xm_include_list)
3180 AC_SUBST(xm_defines)
3181 AC_SUBST(target_noncanonical)
3182 AC_SUBST(c_target_objs)
3183 AC_SUBST(cxx_target_objs)
3184 AC_SUBST(target_cpu_default)
3185
3186 AC_SUBST_FILE(language_hooks)
3187
3188 # If it doesn't already exist, create document directory
3189 echo "checking for the document directory." 1>&2
3190 if test -d doc ; then
3191   true
3192 else
3193   mkdir doc
3194 fi
3195
3196 # Echo link setup.
3197 if test x${build} = x${host} ; then
3198   if test x${host} = x${target} ; then
3199     echo "Links are now set up to build a native compiler for ${target}." 1>&2
3200   else
3201     echo "Links are now set up to build a cross-compiler" 1>&2
3202     echo " from ${host} to ${target}." 1>&2
3203   fi
3204 else
3205   if test x${host} = x${target} ; then
3206     echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
3207     echo " for ${target}." 1>&2
3208   else
3209     echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
3210     echo " from ${host} to ${target}." 1>&2
3211   fi
3212 fi
3213
3214 AC_ARG_VAR(GMPLIBS,[How to link GMP])
3215 AC_ARG_VAR(GMPINC,[How to find GMP include files])
3216
3217 # Configure the subdirectories
3218 # AC_CONFIG_SUBDIRS($subdirs)
3219
3220 # Create the Makefile
3221 # and configure language subdirectories
3222 AC_CONFIG_FILES($all_outputs)
3223
3224 AC_CONFIG_COMMANDS([default],
3225 [
3226 case ${CONFIG_HEADERS} in
3227   *auto-host.h:config.in*)
3228   echo > cstamp-h ;;
3229 esac
3230 # Make sure all the subdirs exist.
3231 for d in $subdirs
3232 do
3233     test -d $d || mkdir $d
3234 done
3235 # If the host supports symlinks, point stage[1234] at ../stage[1234] so
3236 # bootstrapping and the installation procedure can still use
3237 # CC="stage1/xgcc -Bstage1/".  If the host doesn't support symlinks,
3238 # FLAGS_TO_PASS has been modified to solve the problem there.
3239 # This is virtually a duplicate of what happens in configure.lang; we do
3240 # an extra check to make sure this only happens if ln -s can be used.
3241 if test "$symbolic_link" = "ln -s"; then
3242  for d in ${subdirs} fixinc ; do
3243         STARTDIR=`${PWDCMD-pwd}`
3244         cd $d
3245         for t in stage1 stage2 stage3 stage4 stageprofile stagefeedback include
3246         do
3247                 rm -f $t
3248                 $symbolic_link ../$t $t 2>/dev/null
3249         done
3250         cd $STARTDIR
3251  done
3252 else true ; fi
3253 ],
3254 [subdirs='$subdirs'
3255 symbolic_link='$symbolic_link'
3256 ])
3257 AC_OUTPUT