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