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