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