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