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 # Clearing GMPINC is necessary to prevent host headers being 1520 # used by the build compiler. Defining GENERATOR_FILE stops 1521 # system.h from including gmp.h. 1522 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \ 1523 CXX="${CXX_FOR_BUILD}" CXXFLAGS="${CXXFLAGS_FOR_BUILD}" \ 1524 LD="${LD_FOR_BUILD}" LDFLAGS="${LDFLAGS_FOR_BUILD}" \ 1525 GMPINC="" CPPFLAGS="${CPPFLAGS} -DGENERATOR_FILE" \ 1526 ${realsrcdir}/configure \ 1527 --enable-languages=${enable_languages-all} \ 1528 --target=$target_alias --host=$build_alias --build=$build_alias 1529 1530 # We just finished tests for the build machine, so rename 1531 # the file auto-build.h in the gcc directory. 1532 mv auto-host.h ../auto-build.h 1533 cd .. 1534 rm -rf $tempdir 1535 build_auto=auto-build.h 1536fi 1537AC_SUBST(build_subdir) 1538 1539tm_file="${tm_file} defaults.h" 1540tm_p_file="${tm_p_file} tm-preds.h" 1541host_xm_file="auto-host.h ansidecl.h ${host_xm_file}" 1542build_xm_file="${build_auto} ansidecl.h ${build_xm_file}" 1543# We don't want ansidecl.h in target files, write code there in ISO/GNU C. 1544# put this back in temporarily. 1545xm_file="auto-host.h ansidecl.h ${xm_file}" 1546 1547# -------- 1548# UNSORTED 1549# -------- 1550 1551changequote(,)dnl 1552# Compile in configure arguments. 1553if test -f configargs.h ; then 1554 # Being re-configured. 1555 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'` 1556 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS" 1557else 1558 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS" 1559fi 1560 1561# Double all backslashes and backslash all quotes to turn 1562# gcc_config_arguments into a C string. 1563sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out 1564$gcc_config_arguments 1565EOF 1566gcc_config_arguments_str=`cat conftest.out` 1567rm -f conftest.out 1568 1569cat > configargs.h <<EOF 1570/* Generated automatically. */ 1571static const char configuration_arguments[] = "$gcc_config_arguments_str"; 1572static const char thread_model[] = "$thread_file"; 1573 1574static const struct { 1575 const char *name, *value; 1576} configure_default_options[] = $configure_default_options; 1577EOF 1578changequote([,])dnl 1579 1580changequote(,)dnl 1581gcc_BASEVER=`cat $srcdir/BASE-VER` 1582gcc_DEVPHASE=`cat $srcdir/DEV-PHASE` 1583gcc_DATESTAMP=`cat $srcdir/DATESTAMP` 1584if test -f $srcdir/REVISION ; then 1585 gcc_REVISION=`cat $srcdir/REVISION` 1586else 1587 gcc_REVISION="" 1588fi 1589cat > plugin-version.h <<EOF 1590#include "configargs.h" 1591 1592#define GCCPLUGIN_VERSION_MAJOR `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'` 1593#define GCCPLUGIN_VERSION_MINOR `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'` 1594#define GCCPLUGIN_VERSION_PATCHLEVEL `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'` 1595#define GCCPLUGIN_VERSION (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR) 1596 1597static char basever[] = "$gcc_BASEVER"; 1598static char datestamp[] = "$gcc_DATESTAMP"; 1599static char devphase[] = "$gcc_DEVPHASE"; 1600static char revision[] = "$gcc_REVISION"; 1601 1602/* FIXME plugins: We should make the version information more precise. 1603 One way to do is to add a checksum. */ 1604 1605static struct plugin_gcc_version gcc_version = {basever, datestamp, 1606 devphase, revision, 1607 configuration_arguments}; 1608EOF 1609changequote([,])dnl 1610 1611# Internationalization 1612ZW_GNU_GETTEXT_SISTER_DIR 1613 1614# If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get 1615# -liconv on the link line twice. 1616case "$LIBINTL" in *$LIBICONV*) 1617 LIBICONV= ;; 1618esac 1619 1620AC_ARG_ENABLE(secureplt, 1621[AS_HELP_STRING([--enable-secureplt], 1622 [enable -msecure-plt by default for PowerPC])], 1623[], []) 1624 1625AC_ARG_ENABLE(leading-mingw64-underscores, 1626 AS_HELP_STRING([--enable-leading-mingw64-underscores], 1627 [enable leading underscores on 64 bit mingw targets]), 1628 [],[]) 1629AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ], 1630 [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1, 1631 [Define if we should use leading underscore on 64 bit mingw targets])]) 1632 1633AC_ARG_ENABLE(cld, 1634[AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [], 1635[enable_cld=no]) 1636 1637AC_ARG_ENABLE(frame-pointer, 1638[AS_HELP_STRING([--enable-frame-pointer], 1639 [enable -fno-omit-frame-pointer by default for 32bit x86])], [], 1640[ 1641case $target_os in 1642linux* | darwin[[8912]]*) 1643 # Enable -fomit-frame-pointer by default for Linux and Darwin with 1644 # DWARF2. 1645 enable_frame_pointer=no 1646 ;; 1647*) 1648 enable_frame_pointer=yes 1649 ;; 1650esac 1651]) 1652 1653# Windows32 Registry support for specifying GCC installation paths. 1654AC_ARG_ENABLE(win32-registry, 1655[AS_HELP_STRING([--disable-win32-registry], 1656 [disable lookup of installation paths in the 1657 Registry on Windows hosts]) 1658AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)]) 1659AS_HELP_STRING([--enable-win32-registry=KEY], 1660 [use KEY instead of GCC version as the last portion 1661 of the registry key])],,) 1662 1663case $host_os in 1664 win32 | pe | cygwin* | mingw32* | uwin*) 1665 if test "x$enable_win32_registry" != xno; then 1666 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no]) 1667 fi 1668 1669 if test "x$enable_win32_registry" != xno; then 1670 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1, 1671 [Define to 1 if installation paths should be looked up in the Windows 1672 Registry. Ignored on non-Windows hosts.]) 1673 1674 if test "x$enable_win32_registry" != xyes \ 1675 && test "x$enable_win32_registry" != x; then 1676 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry", 1677 [Define to be the last component of the Windows registry key under which 1678 to look for installation paths. The full key used will be 1679 HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}. 1680 The default is the GCC version number.]) 1681 fi 1682 fi 1683 ;; 1684esac 1685 1686# Get an absolute path to the GCC top-level source directory 1687holddir=`${PWDCMD-pwd}` 1688cd $srcdir 1689topdir=`${PWDCMD-pwd}` 1690cd $holddir 1691 1692# Conditionalize the makefile for this host machine. 1693xmake_file= 1694for f in ${host_xmake_file} 1695do 1696 if test -f ${srcdir}/config/$f 1697 then 1698 xmake_file="${xmake_file} \$(srcdir)/config/$f" 1699 fi 1700done 1701 1702# Conditionalize the makefile for this target machine. 1703tmake_file_= 1704for f in ${tmake_file} 1705do 1706 if test -f ${srcdir}/config/$f 1707 then 1708 tmake_file_="${tmake_file_} \$(srcdir)/config/$f" 1709 fi 1710done 1711tmake_file="${tmake_file_}" 1712 1713out_object_file=`basename $out_file .c`.o 1714common_out_object_file=`basename $common_out_file .c`.o 1715 1716tm_file_list="options.h" 1717tm_include_list="options.h insn-constants.h" 1718for f in $tm_file; do 1719 case $f in 1720 ./* ) 1721 f=`echo $f | sed 's/^..//'` 1722 tm_file_list="${tm_file_list} $f" 1723 tm_include_list="${tm_include_list} $f" 1724 ;; 1725 defaults.h ) 1726 tm_file_list="${tm_file_list} \$(srcdir)/$f" 1727 tm_include_list="${tm_include_list} $f" 1728 ;; 1729 * ) 1730 tm_file_list="${tm_file_list} \$(srcdir)/config/$f" 1731 tm_include_list="${tm_include_list} config/$f" 1732 ;; 1733 esac 1734done 1735 1736tm_p_file_list= 1737tm_p_include_list= 1738for f in $tm_p_file; do 1739 case $f in 1740 tm-preds.h ) 1741 tm_p_file_list="${tm_p_file_list} $f" 1742 tm_p_include_list="${tm_p_include_list} $f" 1743 ;; 1744 * ) 1745 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f" 1746 tm_p_include_list="${tm_p_include_list} config/$f" 1747 esac 1748done 1749 1750xm_file_list= 1751xm_include_list= 1752for f in $xm_file; do 1753 case $f in 1754 ansidecl.h ) 1755 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f" 1756 xm_include_list="${xm_include_list} $f" 1757 ;; 1758 auto-host.h ) 1759 xm_file_list="${xm_file_list} $f" 1760 xm_include_list="${xm_include_list} $f" 1761 ;; 1762 * ) 1763 xm_file_list="${xm_file_list} \$(srcdir)/config/$f" 1764 xm_include_list="${xm_include_list} config/$f" 1765 ;; 1766 esac 1767done 1768 1769host_xm_file_list= 1770host_xm_include_list= 1771for f in $host_xm_file; do 1772 case $f in 1773 ansidecl.h ) 1774 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f" 1775 host_xm_include_list="${host_xm_include_list} $f" 1776 ;; 1777 auto-host.h ) 1778 host_xm_file_list="${host_xm_file_list} $f" 1779 host_xm_include_list="${host_xm_include_list} $f" 1780 ;; 1781 * ) 1782 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f" 1783 host_xm_include_list="${host_xm_include_list} config/$f" 1784 ;; 1785 esac 1786done 1787 1788build_xm_file_list= 1789for f in $build_xm_file; do 1790 case $f in 1791 ansidecl.h ) 1792 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f" 1793 build_xm_include_list="${build_xm_include_list} $f" 1794 ;; 1795 auto-build.h | auto-host.h ) 1796 build_xm_file_list="${build_xm_file_list} $f" 1797 build_xm_include_list="${build_xm_include_list} $f" 1798 ;; 1799 * ) 1800 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f" 1801 build_xm_include_list="${build_xm_include_list} config/$f" 1802 ;; 1803 esac 1804done 1805 1806# Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a 1807# cross-compiler which does not use the native headers and libraries. 1808# Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR. 1809CROSS= AC_SUBST(CROSS) 1810ALL=all.internal AC_SUBST(ALL) 1811SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR) 1812 1813if test "x$with_build_sysroot" != x; then 1814 build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)' 1815else 1816 # This value is used, even on a native system, because 1817 # CROSS_SYSTEM_HEADER_DIR is just 1818 # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR). 1819 build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)' 1820fi 1821 1822if test x$host != x$target 1823then 1824 CROSS="-DCROSS_DIRECTORY_STRUCTURE" 1825 ALL=all.cross 1826 SYSTEM_HEADER_DIR=$build_system_header_dir 1827 case "$host","$target" in 1828 # Darwin crosses can use the host system's libraries and headers, 1829 # because of the fat library support. Of course, it must be the 1830 # same version of Darwin on both sides. Allow the user to 1831 # just say --target=foo-darwin without a version number to mean 1832 # "the version on this system". 1833 *-*-darwin*,*-*-darwin*) 1834 hostos=`echo $host | sed 's/.*-darwin/darwin/'` 1835 targetos=`echo $target | sed 's/.*-darwin/darwin/'` 1836 if test $hostos = $targetos -o $targetos = darwin ; then 1837 CROSS= 1838 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' 1839 with_headers=yes 1840 fi 1841 ;; 1842 1843 i?86-*-*,x86_64-*-* \ 1844 | powerpc*-*-*,powerpc64*-*-*) 1845 CROSS="$CROSS -DNATIVE_CROSS" ;; 1846 esac 1847 1848 case $target in 1849 *-*-mingw*) 1850 if test "x$with_headers" = x; then 1851 with_headers=yes 1852 fi 1853 ;; 1854 *) 1855 ;; 1856 esac 1857elif test "x$TARGET_SYSTEM_ROOT" != x; then 1858 SYSTEM_HEADER_DIR=$build_system_header_dir 1859fi 1860 1861# If this is a cross-compiler that does not 1862# have its own set of headers then define 1863# inhibit_libc 1864 1865# If this is using newlib, without having the headers available now, 1866# then define inhibit_libc in LIBGCC2_CFLAGS. 1867# This prevents libgcc2 from containing any code which requires libc 1868# support. 1869: ${inhibit_libc=false} 1870if { { test x$host != x$target && test "x$with_sysroot" = x ; } || 1871 test x$with_newlib = xyes ; } && 1872 { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then 1873 inhibit_libc=true 1874fi 1875AC_SUBST(inhibit_libc) 1876 1877# When building gcc with a cross-compiler, we need to adjust things so 1878# that the generator programs are still built with the native compiler. 1879# Also, we cannot run fixincludes. 1880 1881# These are the normal (build=host) settings: 1882CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD) 1883CXX_FOR_BUILD='$(CXX)' AC_SUBST(CXX_FOR_BUILD) 1884BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS) 1885BUILD_CXXFLAGS='$(ALL_CXXFLAGS)' AC_SUBST(BUILD_CXXFLAGS) 1886BUILD_LDFLAGS='$(LDFLAGS)' AC_SUBST(BUILD_LDFLAGS) 1887STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC) 1888 1889# And these apply if build != host, or we are generating coverage data 1890if test x$build != x$host || test "x$coverage_flags" != x 1891then 1892 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)' 1893 BUILD_CXXFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CXXFLAGS_FOR_BUILD)' 1894 BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)' 1895fi 1896 1897# Expand extra_headers to include complete path. 1898# This substitutes for lots of t-* files. 1899extra_headers_list= 1900# Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers. 1901for file in ${extra_headers} ; do 1902 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}" 1903done 1904 1905# If use_gcc_tgmath is set, append ginclude/tgmath.h. 1906if test x"$use_gcc_tgmath" = xyes 1907then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h" 1908fi 1909 1910# Define collect2 in Makefile. 1911case $host_can_use_collect2 in 1912 no) collect2= ;; 1913 *) collect2='collect2$(exeext)' ;; 1914esac 1915AC_SUBST([collect2]) 1916 1917# Add a definition of USE_COLLECT2 if system wants one. 1918case $use_collect2 in 1919 no) use_collect2= ;; 1920 "") ;; 1921 *) 1922 host_xm_defines="${host_xm_defines} USE_COLLECT2" 1923 xm_defines="${xm_defines} USE_COLLECT2" 1924 case $host_can_use_collect2 in 1925 no) 1926 AC_MSG_ERROR([collect2 is required but cannot be built on this system]) 1927 ;; 1928 esac 1929 ;; 1930esac 1931 1932AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}", 1933[Define to the name of the LTO plugin DSO that must be 1934 passed to the linker's -plugin=LIB option.]) 1935 1936# --------------------------- 1937# Assembler & linker features 1938# --------------------------- 1939 1940# During stage 2, ld is actually gcc/collect-ld, which is a small script to 1941# discern between when to use prev-ld/ld-new and when to use ld/ld-new. 1942# However when ld-new is first executed from the build tree, libtool will 1943# relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers 1944# to the build tree. While doing this we need to use the previous-stage 1945# linker, or we have an infinite loop. The presence of a shell script as 1946# ld/ld-new, and the fact that the script *uses ld itself*, is what confuses 1947# the gcc/collect-ld script. So we need to know how libtool works, or 1948# exec-tool will fail. 1949 1950m4_defun([_LT_CONFIG_COMMANDS], []) 1951AC_PROG_LIBTOOL 1952AC_SUBST(objdir) 1953AC_SUBST(enable_fast_install) 1954 1955# Identify the assembler which will work hand-in-glove with the newly 1956# built GCC, so that we can examine its features. This is the assembler 1957# which will be driven by the driver program. 1958# 1959# If build != host, and we aren't building gas in-tree, we identify a 1960# build->target assembler and hope that it will have the same features 1961# as the host->target assembler we'll be using. 1962gcc_cv_gas_major_version= 1963gcc_cv_gas_minor_version= 1964gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas 1965 1966m4_pattern_allow([AS_FOR_TARGET])dnl 1967AS_VAR_SET_IF(gcc_cv_as,, [ 1968if test -x "$DEFAULT_ASSEMBLER"; then 1969 gcc_cv_as="$DEFAULT_ASSEMBLER" 1970elif test -f $gcc_cv_as_gas_srcdir/configure.in \ 1971 && test -f ../gas/Makefile \ 1972 && test x$build = x$host; then 1973 gcc_cv_as=../gas/as-new$build_exeext 1974elif test -x as$build_exeext; then 1975 # Build using assembler in the current directory. 1976 gcc_cv_as=./as$build_exeext 1977elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then 1978 gcc_cv_as="$AS_FOR_TARGET" 1979else 1980 AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET) 1981fi]) 1982 1983ORIGINAL_AS_FOR_TARGET=$gcc_cv_as 1984AC_SUBST(ORIGINAL_AS_FOR_TARGET) 1985case "$ORIGINAL_AS_FOR_TARGET" in 1986 ./as | ./as$build_exeext) ;; 1987 *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;; 1988esac 1989 1990AC_MSG_CHECKING(what assembler to use) 1991if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then 1992 # Single tree build which includes gas. We want to prefer it 1993 # over whatever linker top-level may have detected, since 1994 # we'll use what we're building after installation anyway. 1995 AC_MSG_RESULT(newly built gas) 1996 in_tree_gas=yes 1997 _gcc_COMPUTE_GAS_VERSION 1998 in_tree_gas_is_elf=no 1999 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \ 2000 || (grep 'obj_format = multi' ../gas/Makefile \ 2001 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null 2002 then 2003 in_tree_gas_is_elf=yes 2004 fi 2005else 2006 AC_MSG_RESULT($gcc_cv_as) 2007 in_tree_gas=no 2008fi 2009 2010# Identify the linker which will work hand-in-glove with the newly 2011# built GCC, so that we can examine its features. This is the linker 2012# which will be driven by the driver program. 2013# 2014# If build != host, and we aren't building gas in-tree, we identify a 2015# build->target linker and hope that it will have the same features 2016# as the host->target linker we'll be using. 2017gcc_cv_gld_major_version= 2018gcc_cv_gld_minor_version= 2019gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld 2020gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd 2021 2022AS_VAR_SET_IF(gcc_cv_ld,, [ 2023if test -x "$DEFAULT_LINKER"; then 2024 gcc_cv_ld="$DEFAULT_LINKER" 2025elif test -f $gcc_cv_ld_gld_srcdir/configure.in \ 2026 && test -f ../ld/Makefile \ 2027 && test x$build = x$host; then 2028 gcc_cv_ld=../ld/ld-new$build_exeext 2029elif test -x collect-ld$build_exeext; then 2030 # Build using linker in the current directory. 2031 gcc_cv_ld=./collect-ld$build_exeext 2032elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then 2033 gcc_cv_ld="$LD_FOR_TARGET" 2034else 2035 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET) 2036fi]) 2037 2038ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld 2039PLUGIN_LD_SUFFIX=`basename $gcc_cv_ld | sed -e "s,$target_alias-,,"` 2040# if the PLUGIN_LD is set ld-new, just have it as ld 2041# as that is the installed named. 2042if test x$PLUGIN_LD_SUFFIX = xld-new \ 2043 || test x$PLUGIN_LD_SUFFIX = xcollect-ld ; then 2044 PLUGIN_LD_SUFFIX=ld 2045fi 2046AC_ARG_WITH(plugin-ld, 2047[AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])], 2048[if test x"$withval" != x; then 2049 ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval" 2050 PLUGIN_LD_SUFFIX=`echo $withval | sed -e "s,$target_alias-,,"` 2051 fi]) 2052AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET) 2053AC_DEFINE_UNQUOTED(PLUGIN_LD_SUFFIX, "$PLUGIN_LD_SUFFIX", [Specify plugin linker]) 2054 2055# Check to see if we are using gold instead of ld 2056AC_MSG_CHECKING(whether we are using gold) 2057ld_is_gold=no 2058if test x$gcc_cv_ld != x; then 2059 if $gcc_cv_ld --version 2>/dev/null | sed 1q \ 2060 | grep "GNU gold" > /dev/null; then 2061 ld_is_gold=yes 2062 fi 2063fi 2064AC_MSG_RESULT($ld_is_gold) 2065 2066ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld 2067AC_SUBST(ORIGINAL_LD_FOR_TARGET) 2068case "$ORIGINAL_LD_FOR_TARGET" in 2069 ./collect-ld | ./collect-ld$build_exeext) ;; 2070 *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;; 2071esac 2072 2073AC_MSG_CHECKING(what linker to use) 2074if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \ 2075 || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then 2076 # Single tree build which includes ld. We want to prefer it 2077 # over whatever linker top-level may have detected, since 2078 # we'll use what we're building after installation anyway. 2079 AC_MSG_RESULT(newly built ld) 2080 in_tree_ld=yes 2081 in_tree_ld_is_elf=no 2082 if (grep 'EMUL = .*elf' ../ld/Makefile \ 2083 || grep 'EMUL = .*linux' ../ld/Makefile \ 2084 || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then 2085 in_tree_ld_is_elf=yes 2086 elif test "$ld_is_gold" = yes; then 2087 in_tree_ld_is_elf=yes 2088 fi 2089 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 2090 do 2091changequote(,)dnl 2092 gcc_cv_gld_version=`sed -n -e 's/^[ ]*VERSION=[^0-9A-Za-z_]*\([0-9]*\.[0-9]*.*\)/VERSION=\1/p' < $f` 2093 if test x$gcc_cv_gld_version != x; then 2094 break 2095 fi 2096 done 2097 case $gcc_cv_gld_version in 2098 VERSION=[0-9]*) ;; 2099changequote([,])dnl 2100 *) AC_MSG_ERROR([[cannot find version of in-tree linker]]) ;; 2101changequote(,)dnl 2102 esac 2103 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"` 2104 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"` 2105changequote([,])dnl 2106else 2107 AC_MSG_RESULT($gcc_cv_ld) 2108 in_tree_ld=no 2109fi 2110 2111# Figure out what nm we will be using. 2112gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils 2113AS_VAR_SET_IF(gcc_cv_nm,, [ 2114if test -f $gcc_cv_binutils_srcdir/configure.in \ 2115 && test -f ../binutils/Makefile \ 2116 && test x$build = x$host; then 2117 gcc_cv_nm=../binutils/nm-new$build_exeext 2118elif test -x nm$build_exeext; then 2119 gcc_cv_nm=./nm$build_exeext 2120elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then 2121 gcc_cv_nm="$NM_FOR_TARGET" 2122else 2123 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET) 2124fi]) 2125 2126AC_MSG_CHECKING(what nm to use) 2127if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then 2128 # Single tree build which includes binutils. 2129 AC_MSG_RESULT(newly built nm) 2130 in_tree_nm=yes 2131else 2132 AC_MSG_RESULT($gcc_cv_nm) 2133 in_tree_nm=no 2134fi 2135 2136ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm 2137AC_SUBST(ORIGINAL_NM_FOR_TARGET) 2138case "$ORIGINAL_NM_FOR_TARGET" in 2139 ./nm | ./nm$build_exeext) ;; 2140 *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;; 2141esac 2142 2143 2144# Figure out what objdump we will be using. 2145AS_VAR_SET_IF(gcc_cv_objdump,, [ 2146if test -f $gcc_cv_binutils_srcdir/configure.in \ 2147 && test -f ../binutils/Makefile \ 2148 && test x$build = x$host; then 2149 # Single tree build which includes binutils. 2150 gcc_cv_objdump=../binutils/objdump$build_exeext 2151elif test -x objdump$build_exeext; then 2152 gcc_cv_objdump=./objdump$build_exeext 2153elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then 2154 gcc_cv_objdump="$OBJDUMP_FOR_TARGET" 2155else 2156 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET) 2157fi]) 2158 2159AC_MSG_CHECKING(what objdump to use) 2160if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then 2161 # Single tree build which includes binutils. 2162 AC_MSG_RESULT(newly built objdump) 2163elif test x$gcc_cv_objdump = x; then 2164 AC_MSG_RESULT(not found) 2165else 2166 AC_MSG_RESULT($gcc_cv_objdump) 2167fi 2168 2169# Figure out what readelf we will be using. 2170AS_VAR_SET_IF(gcc_cv_readelf,, [ 2171if test -f $gcc_cv_binutils_srcdir/configure.in \ 2172 && test -f ../binutils/Makefile \ 2173 && test x$build = x$host; then 2174 # Single tree build which includes binutils. 2175 gcc_cv_readelf=../binutils/readelf$build_exeext 2176elif test -x readelf$build_exeext; then 2177 gcc_cv_readelf=./readelf$build_exeext 2178else 2179 AC_PATH_PROG(gcc_cv_readelf, readelf) 2180fi]) 2181 2182AC_MSG_CHECKING(what readelf to use) 2183if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then 2184 # Single tree build which includes binutils. 2185 AC_MSG_RESULT(newly built readelf) 2186elif test x$gcc_cv_readelf = x; then 2187 AC_MSG_RESULT(not found) 2188else 2189 AC_MSG_RESULT($gcc_cv_readelf) 2190fi 2191 2192# Figure out what assembler alignment features are present. 2193gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align, 2194 [2,6,0],, 2195[.balign 4 2196.p2align 2],, 2197[AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1, 2198 [Define if your assembler supports .balign and .p2align.])]) 2199 2200gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align, 2201 [2,8,0],, 2202 [.p2align 4,,7],, 2203[AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1, 2204 [Define if your assembler supports specifying the maximum number 2205 of bytes to skip when using the GAS .p2align command.])]) 2206 2207gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16, 2208 [2,8,0],, 2209 [.literal16],, 2210[AC_DEFINE(HAVE_GAS_LITERAL16, 1, 2211 [Define if your assembler supports .literal16.])]) 2212 2213gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1, 2214 [elf,2,9,0],, 2215 [conftest_label1: .word 0 2216.subsection -1 2217conftest_label2: .word 0 2218.previous], 2219 [if test x$gcc_cv_nm != x; then 2220 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1 2221 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2 2222 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1 2223 then : 2224 else gcc_cv_as_subsection_m1=yes 2225 fi 2226 rm -f conftest.nm1 conftest.nm2 2227 fi], 2228 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1, 2229 [Define if your assembler supports .subsection and .subsection -1 starts 2230 emitting at the beginning of your section.])]) 2231 2232gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak, 2233 [2,2,0],, 2234 [ .weak foobar],, 2235[AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])]) 2236 2237gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref, 2238 [2,17,0],, 2239 [ .weakref foobar, barfnot],, 2240[AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])]) 2241 2242gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat, 2243 [2,15,91],, 2244 [ .SPACE $TEXT$ 2245 .NSUBSPA $CODE$,COMDAT],, 2246[AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])]) 2247 2248# .hidden needs to be supported in both the assembler and the linker, 2249# because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN. 2250# This is irritatingly difficult to feature test for; we have to check the 2251# date string after the version number. If we've got an in-tree 2252# ld, we don't know its patchlevel version, so we set the baseline at 2.13 2253# to be safe. 2254# The gcc_GAS_CHECK_FEATURE call just sets a cache variable. 2255gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden, 2256 [elf,2,13,0],, 2257[ .hidden foobar 2258foobar:],[ 2259# Solaris 9/x86 as incorrectly emits an alias for a hidden symbol with 2260# STV_HIDDEN, so disable .hidden support if so. 2261case "${target}" in 2262 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*) 2263 if test x$gcc_cv_as != x && test x$gcc_cv_objdump != x; then 2264 cat > conftest.s <<EOF 2265.globl hidden 2266 .hidden hidden 2267hidden: 2268.globl default 2269 .set default,hidden 2270EOF 2271 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \ 2272 && $gcc_cv_objdump -t conftest.o 2>/dev/null | \ 2273 grep '\.hidden default' > /dev/null; then 2274 gcc_cv_as_hidden=no 2275 else 2276 gcc_cv_as_hidden=yes 2277 fi 2278 else 2279 # Assume bug is present if objdump is missing. 2280 gcc_cv_as_hidden=no 2281 fi 2282 ;; 2283 *) 2284 gcc_cv_as_hidden=yes 2285 ;; 2286esac]) 2287case "${target}" in 2288 *-*-darwin*) 2289 # Darwin as has some visibility support, though with a different syntax. 2290 gcc_cv_as_hidden=yes 2291 ;; 2292esac 2293 2294# gnu_indirect_function type is an extension proposed at 2295# http://groups.google/com/group/generic-abi/files. It allows dynamic runtime 2296# selection of function implementation 2297AC_ARG_ENABLE(gnu-indirect-function, 2298 [AS_HELP_STRING([--enable-gnu-indirect-function], 2299 [enable the use of the @gnu_indirect_function to glibc systems])], 2300 [case $enable_gnu_indirect_function in 2301 yes | no) ;; 2302 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function. 2303Valid choices are 'yes' and 'no'.]) ;; 2304 esac], 2305 [enable_gnu_indirect_function="$default_gnu_indirect_function"]) 2306if test x$enable_gnu_indirect_function = xyes; then 2307 AC_DEFINE(HAVE_GNU_INDIRECT_FUNCTION, 1, 2308 [Define if your system supports gnu indirect functions.]) 2309fi 2310 2311changequote(,)dnl 2312if test $in_tree_ld != yes ; then 2313 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q` 2314 if echo "$ld_ver" | grep GNU > /dev/null; then 2315 if test x"$ld_is_gold" = xyes; then 2316 # GNU gold --version looks like this: 2317 # 2318 # GNU gold (GNU Binutils 2.21.51.20110225) 1.11 2319 # 2320 # We extract the binutils version which is more familiar and specific 2321 # than the gold version. 2322 ld_vers=`echo $ld_ver | sed -n \ 2323 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'` 2324 else 2325 # GNU ld --version looks like this: 2326 # 2327 # GNU ld (GNU Binutils) 2.21.51.20110225 2328 ld_vers=`echo $ld_ver | sed -n \ 2329 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'` 2330 fi 2331 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'` 2332 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'` 2333 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'` 2334 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'` 2335 else 2336 case "${target}" in 2337 *-*-solaris2*) 2338 # See acinclude.m4 (gcc_SUN_LD_VERSION) for the version number 2339 # format. 2340 # 2341 # Don't reuse gcc_gv_sun_ld_vers_* in case a linker other than 2342 # /usr/ccs/bin/ld has been configured. 2343 ld_ver=`$gcc_cv_ld -V 2>&1` 2344 if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then 2345 ld_vers=`echo $ld_ver | sed -n \ 2346 -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'` 2347 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'` 2348 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'` 2349 fi 2350 ;; 2351 esac 2352 fi 2353fi 2354changequote([,])dnl 2355 2356AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden, 2357[[if test $in_tree_ld = yes ; then 2358 gcc_cv_ld_hidden=no 2359 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 \ 2360 && test $in_tree_ld_is_elf = yes; then 2361 gcc_cv_ld_hidden=yes 2362 fi 2363else 2364 gcc_cv_ld_hidden=yes 2365 if test x"$ld_is_gold" = xyes; then 2366 : 2367 elif echo "$ld_ver" | grep GNU > /dev/null; then 2368 case "${target}" in 2369 mmix-knuth-mmixware) 2370 # The linker emits by default mmo, not ELF, so "no" is appropriate. 2371 gcc_cv_ld_hidden=no 2372 ;; 2373 esac 2374 if test 0"$ld_date" -lt 20020404; then 2375 if test -n "$ld_date"; then 2376 # If there was date string, but was earlier than 2002-04-04, fail 2377 gcc_cv_ld_hidden=no 2378 elif test -z "$ld_vers"; then 2379 # If there was no date string nor ld version number, something is wrong 2380 gcc_cv_ld_hidden=no 2381 else 2382 test -z "$ld_vers_patch" && ld_vers_patch=0 2383 if test "$ld_vers_major" -lt 2; then 2384 gcc_cv_ld_hidden=no 2385 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then 2386 gcc_cv_ld_hidden="no" 2387 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then 2388 gcc_cv_ld_hidden=no 2389 fi 2390 fi 2391 fi 2392 else 2393 case "${target}" in 2394 *-*-darwin*) 2395 # Darwin ld has some visibility support. 2396 gcc_cv_ld_hidden=yes 2397 ;; 2398 hppa64*-*-hpux* | ia64*-*-hpux*) 2399 gcc_cv_ld_hidden=yes 2400 ;; 2401 *-*-solaris2.9* | *-*-solaris2.1[0-9]*) 2402 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but 2403 # .symbolic was only added in Solaris 9 12/02. 2404 gcc_cv_ld_hidden=yes 2405 ;; 2406 *) 2407 gcc_cv_ld_hidden=no 2408 ;; 2409 esac 2410 fi 2411fi]]) 2412libgcc_visibility=no 2413AC_SUBST(libgcc_visibility) 2414GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN]) 2415if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then 2416 libgcc_visibility=yes 2417 AC_DEFINE(HAVE_GAS_HIDDEN, 1, 2418 [Define if your assembler and linker support .hidden.]) 2419fi 2420 2421AC_MSG_CHECKING(linker read-only and read-write section mixing) 2422gcc_cv_ld_ro_rw_mix=unknown 2423if test $in_tree_ld = yes ; then 2424 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 \ 2425 && test $in_tree_ld_is_elf = yes; then 2426 gcc_cv_ld_ro_rw_mix=read-write 2427 fi 2428elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then 2429 echo '.section myfoosect, "a"' > conftest1.s 2430 echo '.section myfoosect, "aw"' > conftest2.s 2431 echo '.byte 1' >> conftest2.s 2432 echo '.section myfoosect, "a"' > conftest3.s 2433 echo '.byte 0' >> conftest3.s 2434 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \ 2435 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \ 2436 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \ 2437 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \ 2438 conftest2.o conftest3.o > /dev/null 2>&1; then 2439 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \ 2440 | sed -e '/myfoosect/!d' -e N` 2441 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then 2442 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then 2443 gcc_cv_ld_ro_rw_mix=read-only 2444 else 2445 gcc_cv_ld_ro_rw_mix=read-write 2446 fi 2447 fi 2448 fi 2449changequote(,)dnl 2450 rm -f conftest.* conftest[123].* 2451changequote([,])dnl 2452fi 2453if test x$gcc_cv_ld_ro_rw_mix = xread-write; then 2454 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1, 2455 [Define if your linker links a mix of read-only 2456 and read-write sections into a read-write section.]) 2457fi 2458AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix) 2459 2460gcc_AC_INITFINI_ARRAY 2461 2462# Check if we have .[us]leb128, and support symbol arithmetic with it. 2463gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128, 2464 [elf,2,11,0],, 2465[ .data 2466 .uleb128 L2 - L1 2467L1: 2468 .uleb128 1280 2469 .sleb128 -1010 2470L2:], 2471[[# GAS versions before 2.11 do not support uleb128, 2472 # despite appearing to. 2473 # ??? There exists an elf-specific test that will crash 2474 # the assembler. Perhaps it's better to figure out whether 2475 # arbitrary sections are supported and try the test. 2476 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q` 2477 if echo "$as_ver" | grep GNU > /dev/null; then 2478 as_vers=`echo $as_ver | sed -n \ 2479 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'` 2480 as_major=`expr "$as_vers" : '\([0-9]*\)'` 2481 as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'` 2482 if test $as_major -eq 2 && test $as_minor -lt 11 2483 then : 2484 else gcc_cv_as_leb128=yes 2485 fi 2486 fi]], 2487 [AC_DEFINE(HAVE_AS_LEB128, 1, 2488 [Define if your assembler supports .sleb128 and .uleb128.])]) 2489 2490# Check if we have assembler support for unwind directives. 2491gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive, 2492 ,, 2493[ .text 2494 .cfi_startproc 2495 .cfi_offset 0, 0 2496 .cfi_same_value 1 2497 .cfi_def_cfa 1, 2 2498 .cfi_escape 1, 2, 3, 4, 5 2499 .cfi_endproc], 2500[case "$target" in 2501 *-*-solaris*) 2502 # If the linker used on Solaris (like Sun ld) isn't capable of merging 2503 # read-only and read-write sections, we need to make sure that the 2504 # assembler used emits read-write .eh_frame sections. 2505 if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then 2506 if test "x$gcc_cv_objdump" != x; then 2507 if $gcc_cv_objdump -h conftest.o 2>/dev/null | \ 2508 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then 2509 gcc_cv_as_cfi_directive=no 2510 else 2511 case "$target" in 2512 i?86-*-solaris2.1[[0-9]]* | x86_64-*-solaris2.1[[0-9]]*) 2513 # On Solaris/x86, make sure that GCC and gas agree on using 2514 # read-only .eh_frame sections for 64-bit. 2515 if $gcc_cv_as --64 -o conftest.o conftest.s > /dev/null 2>&1 && \ 2516 $gcc_cv_objdump -h conftest.o 2>/dev/null | \ 2517 sed -e /.eh_frame/!d -e N | \ 2518 grep READONLY > /dev/null; then 2519 gcc_cv_as_cfi_directive=yes 2520 else 2521 gcc_cv_as_cfi_directive=no 2522 fi 2523 ;; 2524 *) 2525 gcc_cv_as_cfi_directive=yes 2526 ;; 2527 esac 2528 fi 2529 else 2530 # no objdump, err on the side of caution 2531 gcc_cv_as_cfi_directive=no 2532 fi 2533 else 2534 gcc_cv_as_cfi_directive=yes 2535 fi 2536 ;; 2537 *-*-*) 2538 gcc_cv_as_cfi_directive=yes 2539 ;; 2540esac]) 2541if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then 2542gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working, 2543 ,, 2544[ .text 2545 .cfi_startproc 2546 .cfi_adjust_cfa_offset 64 2547 .skip 75040, 0 2548 .cfi_adjust_cfa_offset 128 2549 .cfi_endproc], 2550[[ 2551if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \ 2552 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then 2553 gcc_cv_as_cfi_advance_working=yes 2554fi 2555]]) 2556else 2557 # no objdump, err on the side of caution 2558 gcc_cv_as_cfi_advance_working=no 2559fi 2560GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE) 2561AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE, 2562 [`if test $gcc_cv_as_cfi_directive = yes \ 2563 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`], 2564 [Define 0/1 if your assembler supports CFI directives.]) 2565 2566GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE) 2567gcc_GAS_CHECK_FEATURE([cfi personality directive], 2568 gcc_cv_as_cfi_personality_directive, ,, 2569[ .text 2570 .cfi_startproc 2571 .cfi_personality 0, symbol 2572 .cfi_endproc]) 2573AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE, 2574 [`if test $gcc_cv_as_cfi_personality_directive = yes; 2575 then echo 1; else echo 0; fi`], 2576 [Define 0/1 if your assembler supports .cfi_personality.]) 2577 2578gcc_GAS_CHECK_FEATURE([cfi sections directive], 2579 gcc_cv_as_cfi_sections_directive, ,, 2580[ .text 2581 .cfi_sections .debug_frame, .eh_frame 2582 .cfi_startproc 2583 .cfi_endproc], 2584[case $target_os in 2585 win32 | pe | cygwin* | mingw32* | uwin*) 2586 # Need to check that we generated the correct relocation for the 2587 # .debug_frame section. This was fixed for binutils 2.21. 2588 gcc_cv_as_cfi_sections_directive=no 2589 if test "x$gcc_cv_objdump" != x; then 2590 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \ 2591 grep secrel > /dev/null; then 2592 gcc_cv_as_cfi_sections_directive=yes 2593 fi 2594 fi 2595 ;; 2596 *) 2597 gcc_cv_as_cfi_sections_directive=yes 2598 ;; 2599esac]) 2600GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE) 2601AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE, 2602 [`if test $gcc_cv_as_cfi_sections_directive = yes; 2603 then echo 1; else echo 0; fi`], 2604 [Define 0/1 if your assembler supports .cfi_sections.]) 2605 2606# GAS versions up to and including 2.11.0 may mis-optimize 2607# .eh_frame data. 2608gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame, 2609 [elf,2,12,0],, 2610[ .text 2611.LFB1: 2612 .4byte 0 2613.L1: 2614 .4byte 0 2615.LFE1: 2616 .section .eh_frame,"aw",@progbits 2617__FRAME_BEGIN__: 2618 .4byte .LECIE1-.LSCIE1 2619.LSCIE1: 2620 .4byte 0x0 2621 .byte 0x1 2622 .ascii "z\0" 2623 .byte 0x1 2624 .byte 0x78 2625 .byte 0x1a 2626 .byte 0x0 2627 .byte 0x4 2628 .4byte 1 2629 .p2align 1 2630.LECIE1: 2631.LSFDE1: 2632 .4byte .LEFDE1-.LASFDE1 2633.LASFDE1: 2634 .4byte .LASFDE1-__FRAME_BEGIN__ 2635 .4byte .LFB1 2636 .4byte .LFE1-.LFB1 2637 .byte 0x4 2638 .4byte .LFE1-.LFB1 2639 .byte 0x4 2640 .4byte .L1-.LFB1 2641.LEFDE1:], 2642[ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@. 2643cat > conftest.lit <<EOF 2644 0000 10000000 00000000 017a0001 781a0004 .........z..x... 2645 0010 01000000 12000000 18000000 00000000 ................ 2646 0020 08000000 04080000 0044 .........D @&t@ 2647EOF 2648cat > conftest.big <<EOF 2649 0000 00000010 00000000 017a0001 781a0004 .........z..x... 2650 0010 00000001 00000012 00000018 00000000 ................ 2651 0020 00000008 04000000 0844 .........D @&t@ 2652EOF 2653 # If the assembler didn't choke, and we can objdump, 2654 # and we got the correct data, then succeed. 2655 # The text in the here-document typically retains its unix-style line 2656 # endings, while the output of objdump will use host line endings. 2657 # Therefore, use diff -b for the comparisons. 2658 if test x$gcc_cv_objdump != x \ 2659 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \ 2660 | tail -3 > conftest.got \ 2661 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \ 2662 || diff -b conftest.big conftest.got > /dev/null 2>&1; } 2663 then 2664 gcc_cv_as_eh_frame=yes 2665 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then 2666 gcc_cv_as_eh_frame=buggy 2667 else 2668 # Uh oh, what do we do now? 2669 gcc_cv_as_eh_frame=no 2670 fi]) 2671 2672if test $gcc_cv_as_eh_frame = buggy; then 2673 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1, 2674 [Define if your assembler mis-optimizes .eh_frame data.]) 2675fi 2676 2677gcc_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]) 2680if test $gcc_cv_as_shf_merge = no; then 2681 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge, 2682 [elf,2,12,0], [--fatal-warnings], 2683 [.section .rodata.str, "aMS", %progbits, 1]) 2684fi 2685AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE, 2686 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`], 2687[Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.]) 2688 2689gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)], 2690 gcc_cv_as_comdat_group, 2691 [elf,2,16,0], [--fatal-warnings], 2692 [.section .text,"axG",@progbits,.foo,comdat]) 2693if test $gcc_cv_as_comdat_group = yes; then 2694 gcc_cv_as_comdat_group_percent=no 2695 gcc_cv_as_comdat_group_group=no 2696else 2697 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)], 2698 gcc_cv_as_comdat_group_percent, 2699 [elf,2,16,0], [--fatal-warnings], 2700 [.section .text,"axG",%progbits,.foo,comdat]) 2701 if test $gcc_cv_as_comdat_group_percent = yes; then 2702 gcc_cv_as_comdat_group_group=no 2703 else 2704 if test -z "${gcc_cv_as_comdat_group_group+set}"; then 2705 gcc_cv_as_comdat_group_group=no 2706 fi 2707 case "${target}" in 2708 # Sun as uses a completely different syntax. 2709 *-*-solaris2*) 2710 case "${target}" in 2711 sparc*-*-solaris2*) 2712 conftest_s=' 2713 .group foo,".text%foo",#comdat 2714 .section ".text%foo", #alloc,#execinstr,#progbits 2715 .globl foo 2716 foo: 2717 ' 2718 ;; 2719 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*) 2720 conftest_s=' 2721 .group foo,.text%foo,#comdat 2722 .section .text%foo, "ax", @progbits 2723 .globl foo 2724 foo: 2725 ' 2726 ;; 2727 esac 2728 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)], 2729 gcc_cv_as_comdat_group_group, 2730 ,, [$conftest_s]) 2731 ;; 2732 esac 2733 fi 2734fi 2735if test x"$ld_is_gold" = xyes; then 2736 comdat_group=yes 2737elif test $in_tree_ld = yes ; then 2738 comdat_group=no 2739 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 \ 2740 && test $in_tree_ld_is_elf = yes; then 2741 comdat_group=yes 2742 fi 2743elif echo "$ld_ver" | grep GNU > /dev/null; then 2744 comdat_group=yes 2745 if test 0"$ld_date" -lt 20050308; then 2746 if test -n "$ld_date"; then 2747 # If there was date string, but was earlier than 2005-03-08, fail 2748 comdat_group=no 2749 elif test "$ld_vers_major" -lt 2; then 2750 comdat_group=no 2751 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then 2752 comdat_group=no 2753 fi 2754 fi 2755else 2756changequote(,)dnl 2757 case "${target}" in 2758 *-*-solaris2.1[1-9]*) 2759 comdat_group=no 2760 # Sun ld has COMDAT group support since Solaris 9, but it doesn't 2761 # interoperate with GNU as until Solaris 11 build 130, i.e. ld 2762 # version 1.688. 2763 # 2764 # If using Sun as for COMDAT group as emitted by GCC, one needs at 2765 # least ld version 1.2267. 2766 if test "$ld_vers_major" -gt 1; then 2767 comdat_group=yes 2768 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then 2769 comdat_group=yes 2770 elif test "$ld_vers_minor" -ge 2267; then 2771 comdat_group=yes 2772 fi 2773 ;; 2774 *) 2775 # Assume linkers other than GNU ld don't support COMDAT group. 2776 comdat_group=no 2777 ;; 2778 esac 2779changequote([,])dnl 2780fi 2781# Allow overriding the automatic COMDAT group tests above. 2782AC_ARG_ENABLE(comdat, 2783 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])], 2784 [comdat_group="$enable_comdat"]) 2785if test $comdat_group = no; then 2786 gcc_cv_as_comdat_group=no 2787 gcc_cv_as_comdat_group_percent=no 2788 gcc_cv_as_comdat_group_group=no 2789fi 2790AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP, 2791 [`if test $gcc_cv_as_comdat_group = yes \ 2792 || test $gcc_cv_as_comdat_group_percent = yes \ 2793 || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`], 2794[Define 0/1 if your assembler and linker support COMDAT groups.]) 2795 2796gcc_GAS_CHECK_FEATURE([line table discriminator support], 2797 gcc_cv_as_discriminator, 2798 [2,19,51],, 2799[ .text 2800 .file 1 "conf.c" 2801 .loc 1 1 0 discriminator 1],, 2802[AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1, 2803 [Define if your assembler supports the .loc discriminator sub-directive.])]) 2804 2805# Thread-local storage - the check is heavily parameterized. 2806conftest_s= 2807tls_first_major= 2808tls_first_minor= 2809tls_as_opt= 2810case "$target" in 2811changequote(,)dnl 2812 alpha*-*-*) 2813 conftest_s=' 2814 .section ".tdata","awT",@progbits 2815foo: .long 25 2816 .text 2817 ldq $27,__tls_get_addr($29) !literal!1 2818 lda $16,foo($29) !tlsgd!1 2819 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1 2820 ldq $27,__tls_get_addr($29) !literal!2 2821 lda $16,foo($29) !tlsldm!2 2822 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2 2823 ldq $1,foo($29) !gotdtprel 2824 ldah $2,foo($29) !dtprelhi 2825 lda $3,foo($2) !dtprello 2826 lda $4,foo($29) !dtprel 2827 ldq $1,foo($29) !gottprel 2828 ldah $2,foo($29) !tprelhi 2829 lda $3,foo($2) !tprello 2830 lda $4,foo($29) !tprel' 2831 tls_first_major=2 2832 tls_first_minor=13 2833 tls_as_opt=--fatal-warnings 2834 ;; 2835 cris-*-*|crisv32-*-*) 2836 conftest_s=' 2837 .section ".tdata","awT",@progbits 2838x: .long 25 2839 .text 2840 move.d x:IE,$r10 2841 nop' 2842 tls_first_major=2 2843 tls_first_minor=20 2844 tls_as_opt=--fatal-warnings 2845 ;; 2846 frv*-*-*) 2847 conftest_s=' 2848 .section ".tdata","awT",@progbits 2849x: .long 25 2850 .text 2851 call #gettlsoff(x)' 2852 tls_first_major=2 2853 tls_first_minor=14 2854 ;; 2855 hppa*-*-linux*) 2856 conftest_s=' 2857t1: .reg %r20 2858t2: .reg %r21 2859gp: .reg %r19 2860 .section ".tdata","awT",@progbits 2861foo: .long 25 2862 .text 2863 .align 4 2864 addil LT%foo-$tls_gdidx$,gp 2865 ldo RT%foo-$tls_gdidx$(%r1),%arg0 2866 b __tls_get_addr 2867 nop 2868 addil LT%foo-$tls_ldidx$,gp 2869 b __tls_get_addr 2870 ldo RT%foo-$tls_ldidx$(%r1),%arg0 2871 addil LR%foo-$tls_dtpoff$,%ret0 2872 ldo RR%foo-$tls_dtpoff$(%r1),%t1 2873 mfctl %cr27,%t1 2874 addil LT%foo-$tls_ieoff$,gp 2875 ldw RT%foo-$tls_ieoff$(%r1),%t2 2876 add %t1,%t2,%t3 2877 mfctl %cr27,%t1 2878 addil LR%foo-$tls_leoff$,%t1 2879 ldo RR%foo-$tls_leoff$(%r1),%t2' 2880 tls_first_major=2 2881 tls_first_minor=15 2882 tls_as_opt=--fatal-warnings 2883 ;; 2884 arm*-*-*) 2885 conftest_s=' 2886 .section ".tdata","awT",%progbits 2887foo: .long 25 2888 .text 2889.word foo(gottpoff) 2890.word foo(tpoff) 2891.word foo(tlsgd) 2892.word foo(tlsldm) 2893.word foo(tlsldo)' 2894 tls_first_major=2 2895 tls_first_minor=17 2896 ;; 2897 i[34567]86-*-* | x86_64-*-solaris2.1[0-9]*) 2898 case "$target" in 2899 i[34567]86-*-solaris2.*) 2900 on_solaris=yes 2901 tga_func=___tls_get_addr 2902 ;; 2903 x86_64-*-solaris2.1[0-9]*) 2904 on_solaris=yes 2905 tga_func=__tls_get_addr 2906 ;; 2907 *) 2908 on_solaris=no 2909 ;; 2910 esac 2911 if test x$on_solaris = xyes && test x$gas_flag = xno; then 2912 conftest_s=' 2913 .section .tdata,"awt",@progbits' 2914 tls_first_major=0 2915 tls_first_minor=0 2916changequote([,])dnl 2917 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't', 2918[Define to the flag used to mark TLS sections if the default (`T') doesn't work.]) 2919changequote(,)dnl 2920 else 2921 conftest_s=' 2922 .section ".tdata","awT",@progbits' 2923 tls_first_major=2 2924 tls_first_minor=14 2925 tls_as_opt="--fatal-warnings" 2926 fi 2927 conftest_s="$conftest_s 2928foo: .long 25 2929 .text 2930 movl %gs:0, %eax 2931 leal foo@tlsgd(,%ebx,1), %eax 2932 leal foo@tlsldm(%ebx), %eax 2933 leal foo@dtpoff(%eax), %edx 2934 movl foo@gottpoff(%ebx), %eax 2935 subl foo@gottpoff(%ebx), %eax 2936 addl foo@gotntpoff(%ebx), %eax 2937 movl foo@indntpoff, %eax 2938 movl \$foo@tpoff, %eax 2939 subl \$foo@tpoff, %eax 2940 leal foo@ntpoff(%ecx), %eax" 2941 ;; 2942 x86_64-*-*) 2943 conftest_s=' 2944 .section ".tdata","awT",@progbits 2945foo: .long 25 2946 .text 2947 movq %fs:0, %rax 2948 leaq foo@TLSGD(%rip), %rdi 2949 leaq foo@TLSLD(%rip), %rdi 2950 leaq foo@DTPOFF(%rax), %rdx 2951 movq foo@GOTTPOFF(%rip), %rax 2952 movq $foo@TPOFF, %rax' 2953 tls_first_major=2 2954 tls_first_minor=14 2955 tls_as_opt=--fatal-warnings 2956 ;; 2957 ia64-*-*) 2958 conftest_s=' 2959 .section ".tdata","awT",@progbits 2960foo: data8 25 2961 .text 2962 addl r16 = @ltoff(@dtpmod(foo#)), gp 2963 addl r17 = @ltoff(@dtprel(foo#)), gp 2964 addl r18 = @ltoff(@tprel(foo#)), gp 2965 addl r19 = @dtprel(foo#), gp 2966 adds r21 = @dtprel(foo#), r13 2967 movl r23 = @dtprel(foo#) 2968 addl r20 = @tprel(foo#), gp 2969 adds r22 = @tprel(foo#), r13 2970 movl r24 = @tprel(foo#)' 2971 tls_first_major=2 2972 tls_first_minor=13 2973 tls_as_opt=--fatal-warnings 2974 ;; 2975 microblaze*-*-*) 2976 conftest_s=' 2977 .section .tdata,"awT",@progbits 2978x: 2979 .word 2 2980 .text 2981 addik r5,r20,x@TLSGD 2982 addik r5,r20,x@TLSLDM' 2983 tls_first_major=2 2984 tls_first_minor=20 2985 tls_as_opt='--fatal-warnings' 2986 ;; 2987 mips*-*-*) 2988 conftest_s=' 2989 .section .tdata,"awT",@progbits 2990x: 2991 .word 2 2992 .text 2993 addiu $4, $28, %tlsgd(x) 2994 addiu $4, $28, %tlsldm(x) 2995 lui $4, %dtprel_hi(x) 2996 addiu $4, $4, %dtprel_lo(x) 2997 lw $4, %gottprel(x)($28) 2998 lui $4, %tprel_hi(x) 2999 addiu $4, $4, %tprel_lo(x)' 3000 tls_first_major=2 3001 tls_first_minor=16 3002 tls_as_opt='-32 --fatal-warnings' 3003 ;; 3004 m68k-*-*) 3005 conftest_s=' 3006 .section .tdata,"awT",@progbits 3007x: 3008 .word 2 3009 .text 3010foo: 3011 move.l x@TLSGD(%a5),%a0 3012 move.l x@TLSLDM(%a5),%a0 3013 move.l x@TLSLDO(%a5),%a0 3014 move.l x@TLSIE(%a5),%a0 3015 move.l x@TLSLE(%a5),%a0' 3016 tls_first_major=2 3017 tls_first_minor=19 3018 tls_as_opt='--fatal-warnings' 3019 ;; 3020 aarch64*-*-*) 3021 conftest_s=' 3022 .section ".tdata","awT",%progbits 3023foo: .long 25 3024 .text 3025 adrp x0, :tlsgd:x 3026 add x0, x0, #:tlsgd_lo12:x 3027 bl __tls_get_addr 3028 nop' 3029 tls_first_major=2 3030 tls_first_minor=20 3031 tls_as_opt='--fatal-warnings' 3032 ;; 3033 powerpc-ibm-aix*) 3034 conftest_s=' 3035 .extern __get_tpointer 3036 .toc 3037LC..1: 3038 .tc a[TC],a[TL]@le 3039 .csect .text[PR] 3040.tlstest: 3041 lwz 9,LC..1(2) 3042 bla __get_tpointer 3043 lwzx 3,9,3 3044 .globl a 3045 .csect a[TL],4 3046a: 3047 .space 4' 3048 tls_first_major=0 3049 tls_first_minor=0 3050 ;; 3051 powerpc64*-*-*) 3052 conftest_s=' 3053 .section ".tdata","awT",@progbits 3054 .align 3 3055ld0: .space 8 3056ld1: .space 8 3057x1: .space 8 3058x2: .space 8 3059x3: .space 8 3060 .text 3061 addi 3,2,ld0@got@tlsgd 3062 bl .__tls_get_addr 3063 nop 3064 addi 3,2,ld1@toc 3065 bl .__tls_get_addr 3066 nop 3067 addi 3,2,x1@got@tlsld 3068 bl .__tls_get_addr 3069 nop 3070 addi 9,3,x1@dtprel 3071 bl .__tls_get_addr 3072 nop 3073 addis 9,3,x2@dtprel@ha 3074 addi 9,9,x2@dtprel@l 3075 bl .__tls_get_addr 3076 nop 3077 ld 9,x3@got@dtprel(2) 3078 add 9,9,3 3079 bl .__tls_get_addr 3080 nop' 3081 tls_first_major=2 3082 tls_first_minor=14 3083 tls_as_opt="-a64 --fatal-warnings" 3084 ;; 3085 powerpc*-*-*) 3086 conftest_s=' 3087 .section ".tdata","awT",@progbits 3088 .align 2 3089ld0: .space 4 3090ld1: .space 4 3091x1: .space 4 3092x2: .space 4 3093x3: .space 4 3094 .text 3095 addi 3,31,ld0@got@tlsgd 3096 bl __tls_get_addr 3097 addi 3,31,x1@got@tlsld 3098 bl __tls_get_addr 3099 addi 9,3,x1@dtprel 3100 addis 9,3,x2@dtprel@ha 3101 addi 9,9,x2@dtprel@l 3102 lwz 9,x3@got@tprel(31) 3103 add 9,9,x@tls 3104 addi 9,2,x1@tprel 3105 addis 9,2,x2@tprel@ha 3106 addi 9,9,x2@tprel@l' 3107 tls_first_major=2 3108 tls_first_minor=14 3109 tls_as_opt="-a32 --fatal-warnings" 3110 ;; 3111 s390-*-*) 3112 conftest_s=' 3113 .section ".tdata","awT",@progbits 3114foo: .long 25 3115 .text 3116 .long foo@TLSGD 3117 .long foo@TLSLDM 3118 .long foo@DTPOFF 3119 .long foo@NTPOFF 3120 .long foo@GOTNTPOFF 3121 .long foo@INDNTPOFF 3122 l %r1,foo@GOTNTPOFF(%r12) 3123 l %r1,0(%r1):tls_load:foo 3124 bas %r14,0(%r1,%r13):tls_gdcall:foo 3125 bas %r14,0(%r1,%r13):tls_ldcall:foo' 3126 tls_first_major=2 3127 tls_first_minor=14 3128 tls_as_opt="-m31 --fatal-warnings" 3129 ;; 3130 s390x-*-*) 3131 conftest_s=' 3132 .section ".tdata","awT",@progbits 3133foo: .long 25 3134 .text 3135 .quad foo@TLSGD 3136 .quad foo@TLSLDM 3137 .quad foo@DTPOFF 3138 .quad foo@NTPOFF 3139 .quad foo@GOTNTPOFF 3140 lg %r1,foo@GOTNTPOFF(%r12) 3141 larl %r1,foo@INDNTPOFF 3142 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo 3143 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo' 3144 tls_first_major=2 3145 tls_first_minor=14 3146 tls_as_opt="-m64 -Aesame --fatal-warnings" 3147 ;; 3148 sh-*-* | sh[34]-*-*) 3149 conftest_s=' 3150 .section ".tdata","awT",@progbits 3151foo: .long 25 3152 .text 3153 .long foo@TLSGD 3154 .long foo@TLSLDM 3155 .long foo@DTPOFF 3156 .long foo@GOTTPOFF 3157 .long foo@TPOFF' 3158 tls_first_major=2 3159 tls_first_minor=13 3160 tls_as_opt=--fatal-warnings 3161 ;; 3162 sparc*-*-*) 3163 case "$target" in 3164 sparc*-sun-solaris2.*) 3165 on_solaris=yes 3166 tga_func=__tls_get_addr 3167 ;; 3168 *) 3169 on_solaris=no 3170 ;; 3171 esac 3172 if test x$on_solaris = xyes && test x$gas_flag = xno; then 3173 conftest_s=' 3174 .section ".tdata",#alloc,#write,#tls' 3175 tls_first_major=0 3176 tls_first_minor=0 3177 else 3178 conftest_s=' 3179 .section ".tdata","awT",@progbits' 3180 tls_first_major=2 3181 tls_first_minor=14 3182 tls_as_opt="-32 --fatal-warnings" 3183 fi 3184 conftest_s="$conftest_s 3185foo: .long 25 3186 .text 3187 sethi %tgd_hi22(foo), %o0 3188 add %o0, %tgd_lo10(foo), %o1 3189 add %l7, %o1, %o0, %tgd_add(foo) 3190 call __tls_get_addr, %tgd_call(foo) 3191 sethi %tldm_hi22(foo), %l1 3192 add %l1, %tldm_lo10(foo), %l2 3193 add %l7, %l2, %o0, %tldm_add(foo) 3194 call __tls_get_addr, %tldm_call(foo) 3195 sethi %tldo_hix22(foo), %l3 3196 xor %l3, %tldo_lox10(foo), %l4 3197 add %o0, %l4, %l5, %tldo_add(foo) 3198 sethi %tie_hi22(foo), %o3 3199 add %o3, %tie_lo10(foo), %o3 3200 ld [%l7 + %o3], %o2, %tie_ld(foo) 3201 add %g7, %o2, %o4, %tie_add(foo) 3202 sethi %tle_hix22(foo), %l1 3203 xor %l1, %tle_lox10(foo), %o5 3204 ld [%g7 + %o5], %o1" 3205 ;; 3206 tilepro*-*-*) 3207 conftest_s=' 3208 .section ".tdata","awT",@progbits 3209foo: .long 25 3210 .text 3211 addli r0, zero, tls_gd(foo) 3212 auli r0, zero, tls_gd_ha16(foo) 3213 addli r0, r0, tls_gd_lo16(foo) 3214 jal __tls_get_addr 3215 addli r0, zero, tls_ie(foo) 3216 auli r0, r0, tls_ie_ha16(foo) 3217 addli r0, r0, tls_ie_lo16(foo)' 3218 tls_first_major=2 3219 tls_first_minor=22 3220 tls_as_opt="--fatal-warnings" 3221 ;; 3222 tilegx*-*-*) 3223 conftest_s=' 3224 .section ".tdata","awT",@progbits 3225foo: .long 25 3226 .text 3227 shl16insli r0, zero, hw0_last_tls_gd(foo) 3228 shl16insli r0, zero, hw1_last_tls_gd(foo) 3229 shl16insli r0, r0, hw0_tls_gd(foo) 3230 jal __tls_get_addr 3231 shl16insli r0, zero, hw1_last_tls_ie(foo) 3232 shl16insli r0, r0, hw0_tls_ie(foo)' 3233 tls_first_major=2 3234 tls_first_minor=22 3235 tls_as_opt="--fatal-warnings" 3236 ;; 3237 xtensa*-*-*) 3238 conftest_s=' 3239 .section ".tdata","awT",@progbits 3240foo: .long 25 3241 .text 3242 movi a8, foo@TLSFUNC 3243 movi a10, foo@TLSARG 3244 callx8.tls a8, foo@TLSCALL' 3245 tls_first_major=2 3246 tls_first_minor=19 3247 ;; 3248changequote([,])dnl 3249esac 3250set_have_as_tls=no 3251if test "x$enable_tls" = xno ; then 3252 : # TLS explicitly disabled. 3253elif test "x$enable_tls" = xyes ; then 3254 set_have_as_tls=yes # TLS explicitly enabled. 3255elif test -z "$tls_first_major"; then 3256 : # If we don't have a check, assume no support. 3257else 3258 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls, 3259 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],, 3260 [set_have_as_tls=yes]) 3261fi 3262case "$target" in 3263 # TLS was introduced in the Solaris 9 FCS release. Support for GNU-style 3264 # TLS on x86 was only introduced in Solaris 9 4/04, replacing the earlier 3265 # Sun style that Sun ld and GCC don't support any longer. 3266 *-*-solaris2.*) 3267 AC_MSG_CHECKING(linker and ld.so.1 TLS support) 3268 ld_tls_support=no 3269 # Check ld and ld.so.1 TLS support. 3270 if echo "$ld_ver" | grep GNU > /dev/null; then 3271 # Assume all interesting versions of GNU ld have TLS support. 3272 # FIXME: still need ld.so.1 support, i.e. ld version checks below. 3273 ld_tls_support=yes 3274 else 3275 case "$target" in 3276 # Solaris 9/x86 ld has GNU style TLS support since version 1.374. 3277 i?86-*-solaris2.9) 3278 min_tls_ld_vers_minor=374 3279 ;; 3280 # Solaris 9/SPARC and Solaris 10+ ld have TLS support since FCS. 3281 sparc*-*-solaris2.9 | *-*-solaris2.1[[0-9]]*) 3282 min_tls_ld_vers_minor=343 3283 ;; 3284 esac 3285 if test "$ld_vers_major" -gt 1 || \ 3286 test "$ld_vers_minor" -ge "$min_tls_ld_vers_minor"; then 3287 ld_tls_support=yes 3288 else 3289 set_have_as_tls=no 3290 fi 3291 fi 3292 AC_MSG_RESULT($ld_tls_support) 3293 3294 save_LIBS="$LIBS" 3295 save_LDFLAGS="$LDFLAGS" 3296 LIBS= 3297 LDFLAGS= 3298 3299 AC_MSG_CHECKING(library containing $tga_func) 3300 # Before Solaris 10, __tls_get_addr (SPARC/x64) resp. ___tls_get_addr 3301 # (32-bit x86) only lived in libthread, so check for that. Keep 3302 # set_have_as_tls if found, disable if not. 3303 AC_SEARCH_LIBS([$tga_func], [thread],, [set_have_as_tls=no]) 3304 # Clear LIBS if we cannot support TLS. 3305 if test $set_have_as_tls = no; then 3306 LIBS= 3307 fi 3308 # Always define LIB_TLS_SPEC, even without TLS support. 3309 AC_DEFINE_UNQUOTED(LIB_TLS_SPEC, "$LIBS", 3310 [Define to the library containing __tls_get_addr/___tls_get_addr.]) 3311 AC_MSG_RESULT($LIBS) 3312 3313 LIBS="$save_LIBS" 3314 LDFLAGS="$save_LDFLAGS" 3315 ;; 3316esac 3317if test $set_have_as_tls = yes ; then 3318 AC_DEFINE(HAVE_AS_TLS, 1, 3319 [Define if your assembler and linker support thread-local storage.]) 3320fi 3321 3322# Target-specific assembler checks. 3323 3324AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option) 3325gcc_cv_ld_static_dynamic=no 3326gcc_cv_ld_static_option='-Bstatic' 3327gcc_cv_ld_dynamic_option='-Bdynamic' 3328if test $in_tree_ld = yes ; then 3329 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 3330 gcc_cv_ld_static_dynamic=yes 3331 fi 3332elif test x$gcc_cv_ld != x; then 3333 # Check if linker supports -Bstatic/-Bdynamic option 3334 if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \ 3335 && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then 3336 gcc_cv_ld_static_dynamic=yes 3337 else 3338 case "$target" in 3339 # AIX ld uses -b flags 3340 *-*-aix4.[[23]]* | *-*-aix[[5-9]]*) 3341 gcc_cv_ld_static_dynamic=yes 3342 gcc_cv_ld_static_option="-bstatic" 3343 gcc_cv_ld_dynamic_option="-bdynamic" 3344 ;; 3345 # HP-UX ld uses -a flags to select between shared and archive. 3346 *-*-hpux*) 3347 if test x"$gnu_ld" = xno; then 3348 gcc_cv_ld_static_dynamic=yes 3349 gcc_cv_ld_static_option="-aarchive_shared" 3350 gcc_cv_ld_dynamic_option="-adefault" 3351 fi 3352 ;; 3353 # Solaris 2 ld always supports -Bstatic/-Bdynamic. 3354 *-*-solaris2*) 3355 gcc_cv_ld_static_dynamic=yes 3356 ;; 3357 esac 3358 fi 3359fi 3360if test x"$gcc_cv_ld_static_dynamic" = xyes; then 3361 AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1, 3362[Define if your linker supports -Bstatic/-Bdynamic or equivalent options.]) 3363 AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option", 3364[Define to the linker option to disable use of shared objects.]) 3365 AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option", 3366[Define to the linker option to enable use of shared objects.]) 3367fi 3368AC_MSG_RESULT($gcc_cv_ld_static_dynamic) 3369 3370if test x"$demangler_in_ld" = xyes; then 3371 AC_MSG_CHECKING(linker --demangle support) 3372 gcc_cv_ld_demangle=no 3373 if test $in_tree_ld = yes; then 3374 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 \ 3375 gcc_cv_ld_demangle=yes 3376 fi 3377 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then 3378 # Check if the GNU linker supports --demangle option 3379 if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then 3380 gcc_cv_ld_demangle=yes 3381 fi 3382 fi 3383 if test x"$gcc_cv_ld_demangle" = xyes; then 3384 AC_DEFINE(HAVE_LD_DEMANGLE, 1, 3385[Define if your linker supports --demangle option.]) 3386 fi 3387 AC_MSG_RESULT($gcc_cv_ld_demangle) 3388fi 3389 3390AC_MSG_CHECKING(linker plugin support) 3391gcc_cv_lto_plugin=0 3392if test -f liblto_plugin.la; then 3393 save_ld_ver="$ld_ver" 3394 save_ld_vers_major="$ld_vers_major" 3395 save_ld_vers_minor="$ld_vers_minor" 3396 save_ld_is_gold="$ld_is_gold" 3397 3398 ld_is_gold=no 3399 3400 if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then 3401 ld_ver="GNU ld" 3402 # FIXME: ld_is_gold? 3403 ld_vers_major="$gcc_cv_gld_major_version" 3404 ld_vers_minor="$gcc_cv_gld_minor_version" 3405 else 3406 # Determine plugin linker version. 3407 # FIXME: Partial duplicate from above, generalize. 3408changequote(,)dnl 3409 ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q` 3410 if echo "$ld_ver" | grep GNU > /dev/null; then 3411 if echo "$ld_ver" | grep "GNU gold" > /dev/null; then 3412 ld_is_gold=yes 3413 ld_vers=`echo $ld_ver | sed -n \ 3414 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'` 3415 else 3416 ld_vers=`echo $ld_ver | sed -n \ 3417 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'` 3418 fi 3419 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'` 3420 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'` 3421 fi 3422changequote([,])dnl 3423 fi 3424 3425 # Determine plugin support. 3426 if echo "$ld_ver" | grep GNU > /dev/null; then 3427 # Require GNU ld or gold 2.21+ for plugin support by default. 3428 if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then 3429 gcc_cv_lto_plugin=2 3430 # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20. 3431 elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then 3432 gcc_cv_lto_plugin=1 3433 fi 3434 fi 3435 3436 ld_ver="$save_ld_ver" 3437 ld_vers_major="$save_ld_vers_major" 3438 ld_vers_minor="$save_ld_vers_minor" 3439 ld_is_gold="$save_ld_is_gold" 3440fi 3441AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin, 3442 [Define to the level of your linker's plugin support.]) 3443AC_MSG_RESULT($gcc_cv_lto_plugin) 3444 3445case "$target" in 3446 3447 aarch64*-*-*) 3448 # Enable default workaround for AArch64 Cortex-A53 erratum 835769. 3449 AC_ARG_ENABLE(fix-cortex-a53-835769, 3450 [ 3451AS_HELP_STRING([--enable-fix-cortex-a53-835769], 3452 [enable workaround for AArch64 Cortex-A53 erratum 835769 by default]) 3453AS_HELP_STRING([--disable-fix-cortex-a53-835769], 3454 [disable workaround for AArch64 Cortex-A53 erratum 835769 by default]) 3455 ], 3456 [ 3457 case $enableval in 3458 yes) 3459 tm_defines="${tm_defines} TARGET_FIX_ERR_A53_835769_DEFAULT=1" 3460 ;; 3461 no) 3462 ;; 3463 *) 3464 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-835769.\ 3465 Valid choices are 'yes' and 'no'.]) 3466 ;; 3467 3468 esac 3469 ], 3470 []) 3471 ;; 3472 # All TARGET_ABI_OSF targets. 3473 alpha*-*-linux* | alpha*-*-*bsd*) 3474 gcc_GAS_CHECK_FEATURE([explicit relocation support], 3475 gcc_cv_as_alpha_explicit_relocs, [2,12,0],, 3476[ .set nomacro 3477 .text 3478 extbl $3, $2, $3 !lituse_bytoff!1 3479 ldq $2, a($29) !literal!1 3480 ldq $4, b($29) !literal!2 3481 ldq_u $3, 0($2) !lituse_base!1 3482 ldq $27, f($29) !literal!5 3483 jsr $26, ($27), f !lituse_jsr!5 3484 ldah $29, 0($26) !gpdisp!3 3485 lda $0, c($29) !gprel 3486 ldah $1, d($29) !gprelhigh 3487 lda $1, d($1) !gprellow 3488 lda $29, 0($29) !gpdisp!3],, 3489 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1, 3490 [Define if your assembler supports explicit relocations.])]) 3491 gcc_GAS_CHECK_FEATURE([jsrdirect relocation support], 3492 gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],, 3493[ .set nomacro 3494 .text 3495 ldq $27, a($29) !literal!1 3496 jsr $26, ($27), a !lituse_jsrdirect!1],, 3497 [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1, 3498 [Define if your assembler supports the lituse_jsrdirect relocation.])]) 3499 ;; 3500 3501 cris-*-*) 3502 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option], 3503 gcc_cv_as_cris_no_mul_bug,[2,15,91], 3504 [-no-mul-bug-abort], [.text],, 3505 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1, 3506 [Define if your assembler supports the -no-mul-bug-abort option.])]) 3507 ;; 3508 3509 sparc*-*-*) 3510 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,, 3511 [.register %g2, #scratch],, 3512 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1, 3513 [Define if your assembler supports .register.])]) 3514 3515 gcc_GAS_CHECK_FEATURE([@%:@nobits], gcc_cv_as_sparc_nobits,,, 3516 [.section "nobits",#alloc,#write,#nobits 3517 .section "progbits",#alloc,#write,#progbits]) 3518 AC_DEFINE_UNQUOTED(HAVE_AS_SPARC_NOBITS, 3519 [`if test $gcc_cv_as_sparc_nobits = yes; then echo 1; else echo 0; fi`], 3520 [Define to 1 if your assembler supports #nobits, 0 otherwise.]) 3521 3522 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,, 3523 [-relax], [.text],, 3524 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1, 3525 [Define if your assembler supports -relax option.])]) 3526 3527 gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs], 3528 gcc_cv_as_sparc_gotdata_op,, 3529 [-K PIC], 3530[.text 3531.align 4 3532foo: 3533 nop 3534bar: 3535 sethi %gdop_hix22(foo), %g1 3536 xor %g1, %gdop_lox10(foo), %g1 3537 ld [[%l7 + %g1]], %g2, %gdop(foo)], 3538 [if test x$gcc_cv_ld != x \ 3539 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then 3540 if test x$gcc_cv_objdump != x; then 3541 if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \ 3542 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then 3543 gcc_cv_as_sparc_gotdata_op=no 3544 else 3545 gcc_cv_as_sparc_gotdata_op=yes 3546 fi 3547 fi 3548 fi 3549 rm -f conftest], 3550 [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1, 3551 [Define if your assembler and linker support GOTDATA_OP relocs.])]) 3552 3553 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs], 3554 gcc_cv_as_sparc_ua_pcrel,, 3555 [-K PIC], 3556[.text 3557foo: 3558 nop 3559.data 3560.align 4 3561.byte 0 3562.uaword %r_disp32(foo)], 3563 [if test x$gcc_cv_ld != x \ 3564 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then 3565 gcc_cv_as_sparc_ua_pcrel=yes 3566 fi 3567 rm -f conftest], 3568 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1, 3569 [Define if your assembler and linker support unaligned PC relative relocs.]) 3570 3571 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols], 3572 gcc_cv_as_sparc_ua_pcrel_hidden,, 3573 [-K PIC], 3574[.data 3575.align 4 3576.byte 0x31 3577.uaword %r_disp32(foo) 3578.byte 0x32, 0x33, 0x34 3579.global foo 3580.hidden foo 3581foo: 3582.skip 4], 3583 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \ 3584 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \ 3585 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \ 3586 | grep ' 31000000 07323334' > /dev/null 2>&1; then 3587 if $gcc_cv_objdump -R conftest 2> /dev/null \ 3588 | grep 'DISP32' > /dev/null 2>&1; then 3589 : 3590 else 3591 gcc_cv_as_sparc_ua_pcrel_hidden=yes 3592 fi 3593 fi 3594 rm -f conftest], 3595 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1, 3596 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])]) 3597 ]) # unaligned pcrel relocs 3598 3599 gcc_GAS_CHECK_FEATURE([offsetable %lo()], 3600 gcc_cv_as_sparc_offsetable_lo10,, 3601 [-xarch=v9], 3602[.text 3603 or %g1, %lo(ab) + 12, %g1 3604 or %g1, %lo(ab + 12), %g1], 3605 [if test x$gcc_cv_objdump != x \ 3606 && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \ 3607 | grep ' 82106000 82106000' > /dev/null 2>&1; then 3608 gcc_cv_as_sparc_offsetable_lo10=yes 3609 fi], 3610 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1, 3611 [Define if your assembler supports offsetable %lo().])]) 3612 3613 gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions], 3614 gcc_cv_as_sparc_fmaf,, 3615 [-xarch=v9d], 3616 [.text 3617 .register %g2, #scratch 3618 .register %g3, #scratch 3619 .align 4 3620 fmaddd %f0, %f2, %f4, %f6 3621 addxccc %g1, %g2, %g3 3622 fsrl32 %f2, %f4, %f8 3623 fnaddd %f10, %f12, %f14],, 3624 [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1, 3625 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])]) 3626 3627 gcc_GAS_CHECK_FEATURE([SPARC4 instructions], 3628 gcc_cv_as_sparc_sparc4,, 3629 [-xarch=sparc4], 3630 [.text 3631 .register %g2, #scratch 3632 .register %g3, #scratch 3633 .align 4 3634 cxbe %g2, %g3, 1f 36351: cwbneg %g2, %g3, 1f 36361: sha1 3637 md5 3638 aes_kexpand0 %f4, %f6, %f8 3639 des_round %f38, %f40, %f42, %f44 3640 camellia_f %f54, %f56, %f58, %f60 3641 kasumi_fi_xor %f46, %f48, %f50, %f52],, 3642 [AC_DEFINE(HAVE_AS_SPARC4, 1, 3643 [Define if your assembler supports SPARC4 instructions.])]) 3644 3645 gcc_GAS_CHECK_FEATURE([LEON instructions], 3646 gcc_cv_as_sparc_leon,, 3647 [-Aleon], 3648 [.text 3649 .register %g2, #scratch 3650 .register %g3, #scratch 3651 .align 4 3652 smac %g2, %g3, %g1 3653 umac %g2, %g3, %g1 3654 casa [[%g2]] 0xb, %g3, %g1],, 3655 [AC_DEFINE(HAVE_AS_LEON, 1, 3656 [Define if your assembler supports LEON instructions.])]) 3657 ;; 3658 3659changequote(,)dnl 3660 i[34567]86-*-* | x86_64-*-*) 3661changequote([,])dnl 3662 case $target_os in 3663 cygwin*) 3664 # Full C++ conformance when using a shared libstdc++-v3 requires some 3665 # support from the Cygwin DLL, which in more recent versions exports 3666 # wrappers to aid in interposing and redirecting operators new, delete, 3667 # etc., as per n2800 #17.6.4.6 [replacement.functions]. Check if we 3668 # are configuring for a version of Cygwin that exports the wrappers. 3669 if test x$host = x$target; then 3670 AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no]) 3671 else 3672 # Can't check presence of libc functions during cross-compile, so 3673 # we just have to assume we're building for an up-to-date target. 3674 gcc_ac_cygwin_dll_wrappers=yes 3675 fi 3676 AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS, 3677 [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`], 3678 [Define if you want to generate code by default that assumes that the 3679 Cygwin DLL exports wrappers to support libstdc++ function replacement.]) 3680 esac 3681 case $target_os in 3682 cygwin* | pe | mingw32* | interix*) 3683 # Recent binutils allows the three-operand form of ".comm" on PE. This 3684 # definition is used unconditionally to initialise the default state of 3685 # the target option variable that governs usage of the feature. 3686 gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align, 3687 [2,19,52],,[.comm foo,1,32]) 3688 AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM, 3689 [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`], 3690 [Define if your assembler supports specifying the alignment 3691 of objects allocated using the GAS .comm command.]) 3692 # Used for DWARF 2 in PE 3693 gcc_GAS_CHECK_FEATURE([.secrel32 relocs], 3694 gcc_cv_as_ix86_pe_secrel32, 3695 [2,15,91],, 3696[.text 3697foo: nop 3698.data 3699 .secrel32 foo], 3700 [if test x$gcc_cv_ld != x \ 3701 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then 3702 gcc_cv_as_ix86_pe_secrel32=yes 3703 fi 3704 rm -f conftest], 3705 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1, 3706 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])]) 3707 # Test if the assembler supports the extended form of the .section 3708 # directive that specifies section alignment. LTO support uses this, 3709 # but normally only after installation, so we warn but don't fail the 3710 # configure if LTO is enabled but the assembler does not support it. 3711 gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align, 3712 [2,20,1],-fatal-warnings,[.section lto_test,"dr0"]) 3713 if test x$gcc_cv_as_section_has_align != xyes; then 3714 case ",$enable_languages," in 3715 *,lto,*) 3716 AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.]) 3717 ;; 3718 esac 3719 fi 3720 # Test if the assembler supports the section flag 'e' for specifying 3721 # an excluded section. 3722 gcc_GAS_CHECK_FEATURE([.section with e], gcc_cv_as_section_has_e, 3723 [2,22,51],, 3724[.section foo1,"e" 3725.byte 0,0,0,0]) 3726 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE, 3727 [`if test $gcc_cv_as_section_has_e = yes; then echo 1; else echo 0; fi`], 3728 [Define if your assembler supports specifying the section flag e.]) 3729 ;; 3730 esac 3731 3732 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics], 3733 gcc_cv_as_ix86_filds,,, 3734 [filds mem; fists mem],, 3735 [AC_DEFINE(HAVE_AS_IX86_FILDS, 1, 3736 [Define if your assembler uses filds and fists mnemonics.])]) 3737 3738 gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics], 3739 gcc_cv_as_ix86_fildq,,, 3740 [fildq mem; fistpq mem],, 3741 [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1, 3742 [Define if your assembler uses fildq and fistq mnemonics.])]) 3743 3744 gcc_GAS_CHECK_FEATURE([cmov syntax], 3745 gcc_cv_as_ix86_cmov_sun_syntax,,, 3746 [cmovl.l %edx, %eax],, 3747 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1, 3748 [Define if your assembler supports the Sun syntax for cmov.])]) 3749 3750 gcc_GAS_CHECK_FEATURE([ffreep mnemonic], 3751 gcc_cv_as_ix86_ffreep,,, 3752 [ffreep %st(1)],, 3753 [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1, 3754 [Define if your assembler supports the ffreep mnemonic.])]) 3755 3756 gcc_GAS_CHECK_FEATURE([.quad directive], 3757 gcc_cv_as_ix86_quad,,, 3758 [.quad 0],, 3759 [AC_DEFINE(HAVE_AS_IX86_QUAD, 1, 3760 [Define if your assembler supports the .quad directive.])]) 3761 3762 gcc_GAS_CHECK_FEATURE([sahf mnemonic], 3763 gcc_cv_as_ix86_sahf,,, 3764 [.code64 3765 sahf],, 3766 [AC_DEFINE(HAVE_AS_IX86_SAHF, 1, 3767 [Define if your assembler supports the sahf mnemonic in 64bit mode.])]) 3768 3769 gcc_GAS_CHECK_FEATURE([hle prefixes], 3770 gcc_cv_as_ix86_hle,,, 3771 [lock xacquire cmpxchg %esi, (%ecx)],, 3772 [AC_DEFINE(HAVE_AS_IX86_HLE, 1, 3773 [Define if your assembler supports HLE prefixes.])]) 3774 3775 gcc_GAS_CHECK_FEATURE([swap suffix], 3776 gcc_cv_as_ix86_swap,,, 3777 [movl.s %esp, %ebp],, 3778 [AC_DEFINE(HAVE_AS_IX86_SWAP, 1, 3779 [Define if your assembler supports the swap suffix.])]) 3780 3781 gcc_GAS_CHECK_FEATURE([different section symbol subtraction], 3782 gcc_cv_as_ix86_diff_sect_delta,,, 3783 [.section .rodata 3784.L1: 3785 .long .L2-.L1 3786 .long .L3-.L1 3787 .text 3788.L3: nop 3789.L2: nop],, 3790 [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1, 3791 [Define if your assembler supports the subtraction of symbols in different sections.])]) 3792 3793 # These two are used unconditionally by i386.[ch]; it is to be defined 3794 # to 1 if the feature is present, 0 otherwise. 3795 as_ix86_gotoff_in_data_opt= 3796 if test x$gas = xyes; then 3797 as_ix86_gotoff_in_data_opt="--32" 3798 fi 3799 gcc_GAS_CHECK_FEATURE([GOTOFF in data], 3800 gcc_cv_as_ix86_gotoff_in_data, [2,11,0], 3801 [$as_ix86_gotoff_in_data_opt], 3802[ .text 3803.L0: 3804 nop 3805 .data 3806 .long .L0@GOTOFF]) 3807 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA, 3808 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`], 3809 [Define true if the assembler supports '.long foo@GOTOFF'.]) 3810 3811 gcc_GAS_CHECK_FEATURE([rep and lock prefix], 3812 gcc_cv_as_ix86_rep_lock_prefix,,, 3813 [rep movsl 3814 rep ret 3815 rep nop 3816 rep bsf %ecx, %eax 3817 rep bsr %ecx, %eax 3818 lock addl %edi, (%eax,%esi) 3819 lock orl $0, (%esp)],, 3820 [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1, 3821 [Define if the assembler supports 'rep <insn>, lock <insn>'.])]) 3822 3823 gcc_GAS_CHECK_FEATURE([ud2 mnemonic], 3824 gcc_cv_as_ix86_ud2,,, 3825 [ud2],, 3826 [AC_DEFINE(HAVE_AS_IX86_UD2, 1, 3827 [Define if your assembler supports the 'ud2' mnemonic.])]) 3828 3829 gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc], 3830 gcc_cv_as_ix86_tlsgdplt,,, 3831 [call tls_gd@tlsgdplt], 3832 [if test x$gcc_cv_ld != x \ 3833 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then 3834 gcc_cv_as_ix86_tlsgdplt=yes 3835 fi 3836 rm -f conftest], 3837 [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1, 3838 [Define if your assembler and linker support @tlsgdplt.])]) 3839 3840 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc], 3841 gcc_cv_as_ix86_tlsldmplt,,, 3842 [tls_ld: 3843 call tls_ld@tlsldmplt], 3844 [if test x$gcc_cv_ld != x \ 3845 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then 3846 gcc_cv_as_ix86_tlsldmplt=yes 3847 fi 3848 rm -f conftest], 3849 [AC_DEFINE(HAVE_AS_IX86_TLSLDMPLT, 1, 3850 [Define if your assembler and linker support @tlsldmplt.])]) 3851 3852 ;; 3853 3854 ia64*-*-*) 3855 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs], 3856 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],, 3857[ .text 3858 addl r15 = @ltoffx(x#), gp 3859 ;; 3860 ld8.mov r16 = [[r15]], x#],, 3861 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1, 3862 [Define if your assembler supports ltoffx and ldxmov relocations.])]) 3863 3864 ;; 3865 3866 powerpc*-*-*) 3867 case $target in 3868 *-*-aix*) conftest_s=' .machine "pwr5" 3869 .csect .text[[PR]] 3870 mfcr 3,128';; 3871 *-*-darwin*) 3872 gcc_GAS_CHECK_FEATURE([.machine directive support], 3873 gcc_cv_as_machine_directive,,, 3874 [ .machine ppc7400]) 3875 if test x$gcc_cv_as_machine_directive != xyes; then 3876 echo "*** This target requires an assembler supporting \".machine\"" >&2 3877 echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2 3878 test x$build = x$target && exit 1 3879 fi 3880 conftest_s=' .text 3881 mfcr r3,128';; 3882 *) conftest_s=' .machine power4 3883 .text 3884 mfcr 3,128';; 3885 esac 3886 3887 gcc_GAS_CHECK_FEATURE([mfcr field support], 3888 gcc_cv_as_powerpc_mfcrf, [2,14,0],, 3889 [$conftest_s],, 3890 [AC_DEFINE(HAVE_AS_MFCRF, 1, 3891 [Define if your assembler supports mfcr field.])]) 3892 3893 case $target in 3894 *-*-aix*) conftest_s=' .machine "pwr5" 3895 .csect .text[[PR]] 3896 popcntb 3,3';; 3897 *) conftest_s=' .machine power5 3898 .text 3899 popcntb 3,3';; 3900 esac 3901 3902 gcc_GAS_CHECK_FEATURE([popcntb support], 3903 gcc_cv_as_powerpc_popcntb, [2,17,0],, 3904 [$conftest_s],, 3905 [AC_DEFINE(HAVE_AS_POPCNTB, 1, 3906 [Define if your assembler supports popcntb field.])]) 3907 3908 case $target in 3909 *-*-aix*) conftest_s=' .machine "pwr5x" 3910 .csect .text[[PR]] 3911 frin 1,1';; 3912 *) conftest_s=' .machine power5 3913 .text 3914 frin 1,1';; 3915 esac 3916 3917 gcc_GAS_CHECK_FEATURE([fp round support], 3918 gcc_cv_as_powerpc_fprnd, [2,17,0],, 3919 [$conftest_s],, 3920 [AC_DEFINE(HAVE_AS_FPRND, 1, 3921 [Define if your assembler supports fprnd.])]) 3922 3923 case $target in 3924 *-*-aix*) conftest_s=' .machine "pwr6" 3925 .csect .text[[PR]] 3926 mffgpr 1,3';; 3927 *) conftest_s=' .machine power6 3928 .text 3929 mffgpr 1,3';; 3930 esac 3931 3932 gcc_GAS_CHECK_FEATURE([move fp gpr support], 3933 gcc_cv_as_powerpc_mfpgpr, [2,19,2],, 3934 [$conftest_s],, 3935 [AC_DEFINE(HAVE_AS_MFPGPR, 1, 3936 [Define if your assembler supports mffgpr and mftgpr.])]) 3937 3938 case $target in 3939 *-*-aix*) conftest_s=' .csect .text[[PR]] 3940LCF..0: 3941 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';; 3942 *-*-darwin*) 3943 conftest_s=' .text 3944LCF0: 3945 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';; 3946 *) conftest_s=' .text 3947.LCF0: 3948 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';; 3949 esac 3950 3951 gcc_GAS_CHECK_FEATURE([rel16 relocs], 3952 gcc_cv_as_powerpc_rel16, [2,17,0], -a32, 3953 [$conftest_s],, 3954 [AC_DEFINE(HAVE_AS_REL16, 1, 3955 [Define if your assembler supports R_PPC_REL16 relocs.])]) 3956 3957 case $target in 3958 *-*-aix*) conftest_s=' .machine "pwr6" 3959 .csect .text[[PR]] 3960 cmpb 3,4,5';; 3961 *) conftest_s=' .machine power6 3962 .text 3963 cmpb 3,4,5';; 3964 esac 3965 3966 gcc_GAS_CHECK_FEATURE([compare bytes support], 3967 gcc_cv_as_powerpc_cmpb, [2,19,2], -a32, 3968 [$conftest_s],, 3969 [AC_DEFINE(HAVE_AS_CMPB, 1, 3970 [Define if your assembler supports cmpb.])]) 3971 3972 case $target in 3973 *-*-aix*) conftest_s=' .machine "pwr6" 3974 .csect .text[[PR]] 3975 dadd 1,2,3';; 3976 *) conftest_s=' .machine power6 3977 .text 3978 dadd 1,2,3';; 3979 esac 3980 3981 gcc_GAS_CHECK_FEATURE([decimal float support], 3982 gcc_cv_as_powerpc_dfp, [2,19,2], -a32, 3983 [$conftest_s],, 3984 [AC_DEFINE(HAVE_AS_DFP, 1, 3985 [Define if your assembler supports DFP instructions.])]) 3986 3987 case $target in 3988 *-*-aix*) conftest_s=' .machine "pwr7" 3989 .csect .text[[PR]] 3990 lxvd2x 1,2,3';; 3991 *) conftest_s=' .machine power7 3992 .text 3993 lxvd2x 1,2,3';; 3994 esac 3995 3996 gcc_GAS_CHECK_FEATURE([vector-scalar support], 3997 gcc_cv_as_powerpc_vsx, [2,19,2], -a32, 3998 [$conftest_s],, 3999 [AC_DEFINE(HAVE_AS_VSX, 1, 4000 [Define if your assembler supports VSX instructions.])]) 4001 4002 case $target in 4003 *-*-aix*) conftest_s=' .machine "pwr7" 4004 .csect .text[[PR]] 4005 popcntd 3,3';; 4006 *) conftest_s=' .machine power7 4007 .text 4008 popcntd 3,3';; 4009 esac 4010 4011 gcc_GAS_CHECK_FEATURE([popcntd support], 4012 gcc_cv_as_powerpc_popcntd, [2,19,2], -a32, 4013 [$conftest_s],, 4014 [AC_DEFINE(HAVE_AS_POPCNTD, 1, 4015 [Define if your assembler supports POPCNTD instructions.])]) 4016 4017 case $target in 4018 *-*-aix*) conftest_s=' .machine "pwr8" 4019 .csect .text[[PR]]';; 4020 *) conftest_s=' .machine power8 4021 .text';; 4022 esac 4023 4024 gcc_GAS_CHECK_FEATURE([power8 support], 4025 gcc_cv_as_powerpc_power8, [2,19,2], -a32, 4026 [$conftest_s],, 4027 [AC_DEFINE(HAVE_AS_POWER8, 1, 4028 [Define if your assembler supports POWER8 instructions.])]) 4029 4030 case $target in 4031 *-*-aix*) conftest_s=' .csect .text[[PR]] 4032 lwsync';; 4033 *) conftest_s=' .text 4034 lwsync';; 4035 esac 4036 4037 gcc_GAS_CHECK_FEATURE([lwsync support], 4038 gcc_cv_as_powerpc_lwsync, [2,19,2], -a32, 4039 [$conftest_s],, 4040 [AC_DEFINE(HAVE_AS_LWSYNC, 1, 4041 [Define if your assembler supports LWSYNC instructions.])]) 4042 4043 case $target in 4044 *-*-aix*) conftest_s=' .machine "476" 4045 .csect .text[[PR]] 4046 dci 0';; 4047 *) conftest_s=' .machine "476" 4048 .text 4049 dci 0';; 4050 esac 4051 4052 gcc_GAS_CHECK_FEATURE([data cache invalidate support], 4053 gcc_cv_as_powerpc_dci, [9,99,0], -a32, 4054 [$conftest_s],, 4055 [AC_DEFINE(HAVE_AS_DCI, 1, 4056 [Define if your assembler supports the DCI/ICI instructions.])]) 4057 4058 gcc_GAS_CHECK_FEATURE([.gnu_attribute support], 4059 gcc_cv_as_powerpc_gnu_attribute, [2,18,0],, 4060 [.gnu_attribute 4,1],, 4061 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1, 4062 [Define if your assembler supports .gnu_attribute.])]) 4063 4064 gcc_GAS_CHECK_FEATURE([tls marker support], 4065 gcc_cv_as_powerpc_tls_markers, [2,20,0],, 4066 [ bl __tls_get_addr(x@tlsgd)],, 4067 [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1, 4068 [Define if your assembler supports arg info for __tls_get_addr.])]) 4069 4070 case $target in 4071 *-*-aix*) 4072 gcc_GAS_CHECK_FEATURE([.ref support], 4073 gcc_cv_as_aix_ref, [2,21,0],, 4074 [ .csect stuff[[rw]] 4075 stuff: 4076 .long 1 4077 .extern sym 4078 .ref sym 4079 ],, 4080 [AC_DEFINE(HAVE_AS_REF, 1, 4081 [Define if your assembler supports .ref])]) 4082 ;; 4083 esac 4084 ;; 4085 4086 mips*-*-*) 4087 gcc_GAS_CHECK_FEATURE([explicit relocation support], 4088 gcc_cv_as_mips_explicit_relocs, [2,14,0],, 4089[ lw $4,%gp_rel(foo)($4)],, 4090 [if test x$target_cpu_default = x 4091 then target_cpu_default=MASK_EXPLICIT_RELOCS 4092 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS" 4093 fi]) 4094 gcc_GAS_CHECK_FEATURE([-mno-shared support], 4095 gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],, 4096 [AC_DEFINE(HAVE_AS_NO_SHARED, 1, 4097 [Define if the assembler understands -mno-shared.])]) 4098 4099 gcc_GAS_CHECK_FEATURE([.gnu_attribute support], 4100 gcc_cv_as_mips_gnu_attribute, [2,18,0],, 4101 [.gnu_attribute 4,1],, 4102 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1, 4103 [Define if your assembler supports .gnu_attribute.])]) 4104 4105 gcc_GAS_CHECK_FEATURE([.dtprelword support], 4106 gcc_cv_as_mips_dtprelword, [2,18,0],, 4107 [.section .tdata,"awT",@progbits 4108x: 4109 .word 2 4110 .text 4111 .dtprelword x+0x8000],, 4112 [AC_DEFINE(HAVE_AS_DTPRELWORD, 1, 4113 [Define if your assembler supports .dtprelword.])]) 4114 4115 gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support], 4116 gcc_cv_as_mips_dspr1_mult,,, 4117[ .set mips32r2 4118 .set nodspr2 4119 .set dsp 4120 madd $ac3,$4,$5 4121 maddu $ac3,$4,$5 4122 msub $ac3,$4,$5 4123 msubu $ac3,$4,$5 4124 mult $ac3,$4,$5 4125 multu $ac3,$4,$5],, 4126 [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1, 4127 [Define if your assembler supports DSPR1 mult.])]) 4128 4129 AC_MSG_CHECKING(assembler and linker for explicit JALR relocation) 4130 gcc_cv_as_ld_jalr_reloc=no 4131 if test $gcc_cv_as_mips_explicit_relocs = yes; then 4132 if test $in_tree_ld = yes ; then 4133 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 \ 4134 && test $in_tree_ld_is_elf = yes; then 4135 gcc_cv_as_ld_jalr_reloc=yes 4136 fi 4137 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then 4138 echo ' .ent x' > conftest.s 4139 echo 'x: ld $2,%got_disp(y)($3)' >> conftest.s 4140 echo ' ld $25,%call16(y)($28)' >> conftest.s 4141 echo ' .reloc 1f,R_MIPS_JALR,y' >> conftest.s 4142 echo '1: jalr $25' >> conftest.s 4143 echo ' .reloc 1f,R_MIPS_JALR,x' >> conftest.s 4144 echo '1: jalr $25' >> conftest.s 4145 echo ' .end x' >> conftest.s 4146 if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \ 4147 && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then 4148 if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \ 4149 && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then 4150 gcc_cv_as_ld_jalr_reloc=yes 4151 fi 4152 fi 4153 rm -f conftest.* 4154 fi 4155 fi 4156 if test $gcc_cv_as_ld_jalr_reloc = yes; then 4157 if test x$target_cpu_default = x; then 4158 target_cpu_default=MASK_RELAX_PIC_CALLS 4159 else 4160 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS" 4161 fi 4162 fi 4163 AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc) 4164 4165 AC_CACHE_CHECK([linker for .eh_frame personality relaxation], 4166 [gcc_cv_ld_mips_personality_relaxation], 4167 [gcc_cv_ld_mips_personality_relaxation=no 4168 if test $in_tree_ld = yes ; then 4169 if test "$gcc_cv_gld_major_version" -eq 2 \ 4170 -a "$gcc_cv_gld_minor_version" -ge 21 \ 4171 -o "$gcc_cv_gld_major_version" -gt 2; then 4172 gcc_cv_ld_mips_personality_relaxation=yes 4173 fi 4174 elif test x$gcc_cv_as != x \ 4175 -a x$gcc_cv_ld != x \ 4176 -a x$gcc_cv_readelf != x ; then 4177 cat > conftest.s <<EOF 4178 .cfi_startproc 4179 .cfi_personality 0x80,indirect_ptr 4180 .ent test 4181test: 4182 nop 4183 .end test 4184 .cfi_endproc 4185 4186 .section .data,"aw",@progbits 4187indirect_ptr: 4188 .dc.a personality 4189EOF 4190 if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \ 4191 && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then 4192 if $gcc_cv_readelf -d conftest 2>&1 \ 4193 | grep TEXTREL > /dev/null 2>&1; then 4194 : 4195 elif $gcc_cv_readelf --relocs conftest 2>&1 \ 4196 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then 4197 : 4198 else 4199 gcc_cv_ld_mips_personality_relaxation=yes 4200 fi 4201 fi 4202 fi 4203 rm -f conftest.s conftest.o conftest]) 4204 if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then 4205 AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1, 4206 [Define if your linker can relax absolute .eh_frame personality 4207pointers into PC-relative form.]) 4208 fi 4209 ;; 4210esac 4211 4212# Mips and HP-UX need the GNU assembler. 4213# Linux on IA64 might be able to use the Intel assembler. 4214 4215case "$target" in 4216 mips*-*-* | *-*-hpux* ) 4217 if test x$gas_flag = xyes \ 4218 || test x"$host" != x"$build" \ 4219 || test ! -x "$gcc_cv_as" \ 4220 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then 4221 : 4222 else 4223 echo "*** This configuration requires the GNU assembler" >&2 4224 exit 1 4225 fi 4226 ;; 4227esac 4228 4229# ??? Not all targets support dwarf2 debug_line, even within a version 4230# of gas. Moreover, we need to emit a valid instruction to trigger any 4231# info to the output file. So, as supported targets are added to gas 2.11, 4232# add some instruction here to (also) show we expect this might work. 4233# ??? Once 2.11 is released, probably need to add first known working 4234# version to the per-target configury. 4235case "$cpu_type" in 4236 alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze | mips \ 4237 | pa | rs6000 | score | sparc | spu | tilegx | tilepro | xstormy16 | xtensa) 4238 insn="nop" 4239 ;; 4240 ia64 | s390) 4241 insn="nop 0" 4242 ;; 4243 mmix) 4244 insn="swym 0" 4245 ;; 4246esac 4247if test x"$insn" != x; then 4248 conftest_s="\ 4249 .file 1 \"conftest.s\" 4250 .loc 1 3 0 4251 $insn" 4252 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support], 4253 gcc_cv_as_dwarf2_debug_line, 4254 [elf,2,11,0],, [$conftest_s], 4255 [if test x$gcc_cv_objdump != x \ 4256 && $gcc_cv_objdump -h conftest.o 2> /dev/null \ 4257 | grep debug_line > /dev/null 2>&1; then 4258 gcc_cv_as_dwarf2_debug_line=yes 4259 fi]) 4260 4261# The .debug_line file table must be in the exact order that 4262# we specified the files, since these indices are also used 4263# by DW_AT_decl_file. Approximate this test by testing if 4264# the assembler bitches if the same index is assigned twice. 4265 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive], 4266 gcc_cv_as_dwarf2_file_buggy,,, 4267[ .file 1 "foo.s" 4268 .file 1 "bar.s"]) 4269 4270 if test $gcc_cv_as_dwarf2_debug_line = yes \ 4271 && test $gcc_cv_as_dwarf2_file_buggy = no; then 4272 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1, 4273 [Define if your assembler supports dwarf2 .file/.loc directives, 4274 and preserves file table indices exactly as given.]) 4275 fi 4276 4277 gcc_GAS_CHECK_FEATURE([--gdwarf2 option], 4278 gcc_cv_as_gdwarf2_flag, 4279 [elf,2,11,0], [--gdwarf2], [$insn],, 4280 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1, 4281[Define if your assembler supports the --gdwarf2 option.])]) 4282 4283 gcc_GAS_CHECK_FEATURE([--gstabs option], 4284 gcc_cv_as_gstabs_flag, 4285 [elf,2,11,0], [--gstabs], [$insn], 4286 [# The native Solaris 9/Intel assembler doesn't understand --gstabs 4287 # and warns about it, but still exits successfully. So check for 4288 # this. 4289 if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null]) 4290 then : 4291 else gcc_cv_as_gstabs_flag=yes 4292 fi], 4293 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1, 4294[Define if your assembler supports the --gstabs option.])]) 4295 4296 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option], 4297 gcc_cv_as_debug_prefix_map_flag, 4298 [2,18,0], [--debug-prefix-map /a=/b], [$insn],, 4299 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1, 4300[Define if your assembler supports the --debug-prefix-map option.])]) 4301fi 4302 4303gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment, 4304 ,, 4305[.lcomm bar,4,16],, 4306[AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1, 4307 [Define if your assembler supports .lcomm with an alignment field.])]) 4308 4309AC_ARG_ENABLE(gnu-unique-object, 4310 [AS_HELP_STRING([--enable-gnu-unique-object], 4311 [enable the use of the @gnu_unique_object ELF extension on glibc systems])], 4312 [case $enable_gnu_unique_object in 4313 yes | no) ;; 4314 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object. 4315Valid choices are 'yes' and 'no'.]) ;; 4316 esac], 4317 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object, 4318 [elf,2,19,52],, 4319 [.type foo, '$target_type_format_char'gnu_unique_object],, 4320# We need to unquote above to to use the definition from config.gcc. 4321# Also check for ld.so support, i.e. glibc 2.11 or higher. 4322 [[if test x$host = x$build -a x$host = x$target && 4323 ldd --version 2>/dev/null && 4324 glibcver=`ldd --version 2>/dev/null | sed 's/.* //;q'`; then 4325 glibcmajor=`expr "$glibcver" : "\([0-9]*\)"` 4326 glibcminor=`expr "$glibcver" : "[2-9]*\.\([0-9]*\)"` 4327 glibcnum=`expr $glibcmajor \* 1000 + $glibcminor` 4328 if test "$glibcnum" -ge 2011 ; then 4329 enable_gnu_unique_object=yes 4330 fi 4331 fi]])]) 4332if test x$enable_gnu_unique_object = xyes; then 4333 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1, 4334 [Define if your assembler supports @gnu_unique_object.]) 4335fi 4336 4337AC_CACHE_CHECK([assembler for tolerance to line number 0], 4338 [gcc_cv_as_line_zero], 4339 [gcc_cv_as_line_zero=no 4340 if test $in_tree_gas = yes; then 4341 gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes]) 4342 elif test "x$gcc_cv_as" != x; then 4343 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s 4344 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) && 4345 test "x`cat conftest.out`" = x 4346 then 4347 gcc_cv_as_line_zero=yes 4348 else 4349 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD 4350 cat conftest.s >&AS_MESSAGE_LOG_FD 4351 echo "configure: error output was" >&AS_MESSAGE_LOG_FD 4352 cat conftest.out >&AS_MESSAGE_LOG_FD 4353 fi 4354 rm -f conftest.o conftest.s conftest.out 4355 fi]) 4356if test "x$gcc_cv_as_line_zero" = xyes; then 4357 AC_DEFINE([HAVE_AS_LINE_ZERO], 1, 4358[Define if the assembler won't complain about a line such as # 0 "" 2.]) 4359fi 4360 4361AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support) 4362gcc_cv_ld_eh_frame_hdr=no 4363if test $in_tree_ld = yes ; then 4364 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 \ 4365 && test $in_tree_ld_is_elf = yes; then 4366 gcc_cv_ld_eh_frame_hdr=yes 4367 fi 4368elif test x$gcc_cv_ld != x; then 4369 if echo "$ld_ver" | grep GNU > /dev/null; then 4370 # Check if linker supports --eh-frame-hdr option 4371 if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then 4372 gcc_cv_ld_eh_frame_hdr=yes 4373 fi 4374 else 4375 case "$target" in 4376 *-*-solaris2*) 4377 # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251. 4378 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then 4379 gcc_cv_ld_eh_frame_hdr=yes 4380 fi 4381 ;; 4382 esac 4383 fi 4384fi 4385GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR]) 4386if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then 4387 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1, 4388[Define if your linker supports .eh_frame_hdr.]) 4389fi 4390AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr) 4391 4392AC_MSG_CHECKING(linker position independent executable support) 4393gcc_cv_ld_pie=no 4394if test $in_tree_ld = yes ; then 4395 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 \ 4396 && test $in_tree_ld_is_elf = yes; then 4397 gcc_cv_ld_pie=yes 4398 fi 4399elif test x$gcc_cv_ld != x; then 4400 # Check if linker supports -pie option 4401 if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then 4402 gcc_cv_ld_pie=yes 4403 fi 4404fi 4405if test x"$gcc_cv_ld_pie" = xyes; then 4406 AC_DEFINE(HAVE_LD_PIE, 1, 4407[Define if your linker supports -pie option.]) 4408fi 4409AC_MSG_RESULT($gcc_cv_ld_pie) 4410 4411AC_MSG_CHECKING(linker EH-compatible garbage collection of sections) 4412gcc_cv_ld_eh_gc_sections=no 4413if test $in_tree_ld = yes ; then 4414 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 \ 4415 && test $in_tree_ld_is_elf = yes; then 4416 gcc_cv_ld_eh_gc_sections=yes 4417 fi 4418elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then 4419 cat > conftest.s <<EOF 4420 .section .text 4421.globl _start 4422 .type _start, @function 4423_start: 4424 .long foo 4425 .size _start, .-_start 4426 .section .text.foo,"ax",@progbits 4427 .type foo, @function 4428foo: 4429 .long 0 4430 .size foo, .-foo 4431 .section .gcc_except_table.foo,"a",@progbits 4432.L0: 4433 .long 0 4434 .section .eh_frame,"a",@progbits 4435 .long .L0 4436EOF 4437 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then 4438 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \ 4439 | grep "gc-sections option ignored" > /dev/null; then 4440 gcc_cv_ld_eh_gc_sections=no 4441 elif $gcc_cv_objdump -h conftest 2> /dev/null \ 4442 | grep gcc_except_table > /dev/null; then 4443 gcc_cv_ld_eh_gc_sections=yes 4444 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections. 4445 if test x$gcc_cv_as_comdat_group != xyes; then 4446 gcc_cv_ld_eh_gc_sections=no 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 .gnu.linkonce.t.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 gcc_cv_ld_eh_gc_sections=no 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=yes 4472 fi 4473 fi 4474 fi 4475 fi 4476 fi 4477 rm -f conftest.s conftest.o conftest 4478fi 4479case "$target" in 4480 hppa*-*-linux*) 4481 # ??? This apparently exposes a binutils bug with PC-relative relocations. 4482 gcc_cv_ld_eh_gc_sections=no 4483 ;; 4484esac 4485if test x$gcc_cv_ld_eh_gc_sections = xyes; then 4486 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1, 4487 [Define if your linker supports garbage collection of 4488 sections in presence of EH frames.]) 4489fi 4490AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections) 4491 4492AC_MSG_CHECKING(linker EH garbage collection of sections bug) 4493gcc_cv_ld_eh_gc_sections_bug=no 4494if test $in_tree_ld = yes ; then 4495 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 \ 4496 && test $in_tree_ld_is_elf = yes; then 4497 gcc_cv_ld_eh_gc_sections_bug=yes 4498 fi 4499elif 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 4500 gcc_cv_ld_eh_gc_sections_bug=yes 4501 cat > conftest.s <<EOF 4502 .section .text 4503.globl _start 4504 .type _start, @function 4505_start: 4506 .long foo 4507 .size _start, .-_start 4508 .section .text.startup.foo,"ax",@progbits 4509 .type foo, @function 4510foo: 4511 .long 0 4512 .size foo, .-foo 4513 .section .gcc_except_table.foo,"a",@progbits 4514.L0: 4515 .long 0 4516 .section .eh_frame,"a",@progbits 4517 .long .L0 4518EOF 4519 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then 4520 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \ 4521 | grep "gc-sections option ignored" > /dev/null; then 4522 : 4523 elif $gcc_cv_objdump -h conftest 2> /dev/null \ 4524 | grep gcc_except_table > /dev/null; then 4525 gcc_cv_ld_eh_gc_sections_bug=no 4526 fi 4527 fi 4528 rm -f conftest.s conftest.o conftest 4529fi 4530if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then 4531 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1, 4532 [Define if your linker has buggy garbage collection of 4533 sections support when .text.startup.foo like sections are used.]) 4534fi 4535AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug) 4536 4537# -------- 4538# UNSORTED 4539# -------- 4540 4541AC_CACHE_CHECK(linker --as-needed support, 4542gcc_cv_ld_as_needed, 4543[gcc_cv_ld_as_needed=no 4544if test $in_tree_ld = yes ; then 4545 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 \ 4546 && test $in_tree_ld_is_elf = yes; then 4547 gcc_cv_ld_as_needed=yes 4548 fi 4549elif test x$gcc_cv_ld != x; then 4550 # Check if linker supports --as-needed and --no-as-needed options 4551 if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then 4552 gcc_cv_ld_as_needed=yes 4553 fi 4554fi 4555]) 4556if test x"$gcc_cv_ld_as_needed" = xyes; then 4557 AC_DEFINE(HAVE_LD_AS_NEEDED, 1, 4558[Define if your linker supports --as-needed and --no-as-needed options.]) 4559fi 4560 4561case "$target:$tm_file" in 4562 powerpc64-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*) 4563 case "$target" in 4564 *le-*-linux*) 4565 emul_name="-melf64lppc" 4566 ;; 4567 *-*-linux*) 4568 emul_name="-melf64ppc" 4569 ;; 4570 *-*-freebsd*) 4571 emul_name="-melf64ppc_fbsd" 4572 ;; 4573 esac 4574 AC_CACHE_CHECK(linker support for omitting dot symbols, 4575 gcc_cv_ld_no_dot_syms, 4576 [gcc_cv_ld_no_dot_syms=no 4577 if test x"$ld_is_gold" = xyes; then 4578 gcc_cv_ld_no_dot_syms=yes 4579 elif test $in_tree_ld = yes ; then 4580 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 4581 gcc_cv_ld_no_dot_syms=yes 4582 fi 4583 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then 4584 cat > conftest1.s <<EOF 4585 .text 4586 bl .foo 4587EOF 4588 cat > conftest2.s <<EOF 4589 .section ".opd","aw" 4590 .align 3 4591 .globl foo 4592 .type foo,@function 4593foo: 4594 .quad .LEfoo,.TOC.@tocbase,0 4595 .text 4596.LEfoo: 4597 blr 4598 .size foo,.-.LEfoo 4599EOF 4600 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \ 4601 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \ 4602 && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then 4603 gcc_cv_ld_no_dot_syms=yes 4604 fi 4605 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s 4606 fi 4607 ]) 4608 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then 4609 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1, 4610 [Define if your PowerPC64 linker only needs function descriptor syms.]) 4611 fi 4612 4613 AC_CACHE_CHECK(linker large toc support, 4614 gcc_cv_ld_large_toc, 4615 [gcc_cv_ld_large_toc=no 4616 if test x"$ld_is_gold" = xyes; then 4617 gcc_cv_ld_large_toc=yes 4618 elif test $in_tree_ld = yes ; then 4619 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 4620 gcc_cv_ld_large_toc=yes 4621 fi 4622 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then 4623 cat > conftest.s <<EOF 4624 .section ".tbss","awT",@nobits 4625 .align 3 4626ie0: .space 8 4627 .global _start 4628 .text 4629_start: 4630 addis 9,13,ie0@got@tprel@ha 4631 ld 9,ie0@got@tprel@l(9) 4632EOF 4633 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \ 4634 && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then 4635 gcc_cv_ld_large_toc=yes 4636 fi 4637 rm -f conftest conftest.o conftest.s 4638 fi 4639 ]) 4640 if test x"$gcc_cv_ld_large_toc" = xyes; then 4641 AC_DEFINE(HAVE_LD_LARGE_TOC, 1, 4642 [Define if your PowerPC64 linker supports a large TOC.]) 4643 fi 4644 ;; 4645esac 4646 4647case "$target" in 4648 *-*-aix*) 4649 AC_CACHE_CHECK(linker large toc support, 4650 gcc_cv_ld_large_toc, 4651 [gcc_cv_ld_large_toc=no 4652 if test x$gcc_cv_as != x ; then 4653 cat > conftest.s <<EOF 4654 .toc 4655LC..1: 4656 .tc a[[TC]],a[[RW]] 4657 .extern a[[RW]] 4658 .csect .text[[PR]] 4659.largetoctest: 4660 addis 9,LC..1@u(2) 4661 ld 3,LC..1@l(9) 4662EOF 4663 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1; then 4664 gcc_cv_ld_large_toc=yes 4665 fi 4666 rm -f conftest conftest.o conftest.s 4667 fi 4668 ]) 4669 if test x"$gcc_cv_ld_large_toc" = xyes; then 4670 AC_DEFINE(HAVE_LD_LARGE_TOC, 1, 4671 [Define if your PowerPC64 linker supports a large TOC.]) 4672 fi 4673 ;; 4674esac 4675 4676AC_CACHE_CHECK(linker --build-id support, 4677 gcc_cv_ld_buildid, 4678 [gcc_cv_ld_buildid=no 4679 if test $in_tree_ld = yes ; then 4680 if test "$gcc_cv_gld_major_version" -eq 2 -a \ 4681 "$gcc_cv_gld_minor_version" -ge 18 -o \ 4682 "$gcc_cv_gld_major_version" -gt 2 \ 4683 && test $in_tree_ld_is_elf = yes; then 4684 gcc_cv_ld_buildid=yes 4685 fi 4686 elif test x$gcc_cv_ld != x; then 4687 if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then 4688 gcc_cv_ld_buildid=yes 4689 fi 4690 fi]) 4691if test x"$gcc_cv_ld_buildid" = xyes; then 4692 AC_DEFINE(HAVE_LD_BUILDID, 1, 4693 [Define if your linker supports --build-id.]) 4694fi 4695 4696AC_ARG_ENABLE(linker-build-id, 4697[AS_HELP_STRING([--enable-linker-build-id], 4698 [compiler will always pass --build-id to linker])], 4699[], 4700enable_linker_build_id=no) 4701 4702if test x"$enable_linker_build_id" = xyes; then 4703 if test x"$gcc_cv_ld_buildid" = xyes; then 4704 AC_DEFINE(ENABLE_LD_BUILDID, 1, 4705 [Define if gcc should always pass --build-id to linker.]) 4706 else 4707 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored) 4708 fi 4709fi 4710 4711# In binutils 2.21, GNU ld gained support for new emulations fully 4712# supporting the Solaris 2 ABI. Detect their presence in the linker used. 4713AC_CACHE_CHECK(linker *_sol2 emulation support, 4714 gcc_cv_ld_sol2_emulation, 4715 [gcc_cv_ld_sol2_emulation=no 4716 if test $in_tree_ld = yes ; then 4717 if test "$gcc_cv_gld_major_version" -eq 2 -a \ 4718 "$gcc_cv_gld_minor_version" -ge 21 -o \ 4719 "$gcc_cv_gld_major_version" -gt 2 \ 4720 && test $in_tree_ld_is_elf = yes; then 4721 gcc_cv_ld_sol2_emulation=yes 4722 fi 4723 elif test x$gcc_cv_ld != x; then 4724 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \ 4725 grep _sol2 > /dev/null; then 4726 gcc_cv_ld_sol2_emulation=yes 4727 fi 4728 fi]) 4729if test x"$gcc_cv_ld_sol2_emulation" = xyes; then 4730 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1, 4731 [Define if your linker supports the *_sol2 emulations.]) 4732fi 4733 4734AC_CACHE_CHECK(linker --sysroot support, 4735 gcc_cv_ld_sysroot, 4736 [gcc_cv_ld_sysroot=no 4737 if test $in_tree_ld = yes ; then 4738 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 4739 gcc_cv_ld_sysroot=yes 4740 fi 4741 elif test x$gcc_cv_ld != x; then 4742 if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then 4743 gcc_cv_ld_sysroot=yes 4744 fi 4745 fi]) 4746if test x"$gcc_cv_ld_sysroot" = xyes; then 4747 AC_DEFINE(HAVE_LD_SYSROOT, 1, 4748 [Define if your linker supports --sysroot.]) 4749fi 4750 4751if test x$with_sysroot = x && test x$host = x$target \ 4752 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \ 4753 && test "$prefix" != "NONE"; then 4754 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include", 4755[Define to PREFIX/include if cpp should also search that directory.]) 4756fi 4757 4758if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then 4759 if test "x$with_headers" != x; then 4760 target_header_dir=$with_headers 4761 elif test "x$with_sysroot" = x; then 4762 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include" 4763 elif test "x$with_build_sysroot" != "x"; then 4764 target_header_dir="${with_build_sysroot}${native_system_header_dir}" 4765 elif test "x$with_sysroot" = xyes; then 4766 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}" 4767 else 4768 target_header_dir="${with_sysroot}${native_system_header_dir}" 4769 fi 4770else 4771 target_header_dir=${native_system_header_dir} 4772fi 4773 4774# Test for stack protector support in target C library. 4775AC_CACHE_CHECK(__stack_chk_fail in target C library, 4776 gcc_cv_libc_provides_ssp, 4777 [gcc_cv_libc_provides_ssp=no 4778 case "$target" in 4779 *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu) 4780 [# glibc 2.4 and later provides __stack_chk_fail and 4781 # either __stack_chk_guard, or TLS access to stack guard canary. 4782 if test -f $target_header_dir/features.h \ 4783 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \ 4784 $target_header_dir/features.h > /dev/null; then 4785 if $EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+([1-9][0-9]|[3-9])' \ 4786 $target_header_dir/features.h > /dev/null; then 4787 gcc_cv_libc_provides_ssp=yes 4788 elif $EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+2' \ 4789 $target_header_dir/features.h > /dev/null \ 4790 && $EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+([1-9][0-9]|[4-9])' \ 4791 $target_header_dir/features.h > /dev/null; then 4792 gcc_cv_libc_provides_ssp=yes 4793 elif $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \ 4794 $target_header_dir/features.h > /dev/null && \ 4795 test -f $target_header_dir/bits/uClibc_config.h && \ 4796 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \ 4797 $target_header_dir/bits/uClibc_config.h > /dev/null; then 4798 gcc_cv_libc_provides_ssp=yes 4799 fi 4800 # all versions of Bionic support stack protector 4801 elif test -f $target_header_dir/sys/cdefs.h \ 4802 && $EGREP '^[ ]*#[ ]*define[ ]+__BIONIC__[ ]+1' \ 4803 $target_header_dir/sys/cdefs.h > /dev/null; then 4804 gcc_cv_libc_provides_ssp=yes 4805 fi] 4806 ;; 4807 *-*-gnu*) 4808 # Avoid complicated tests (see 4809 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now 4810 # simply assert that glibc does provide this, which is true for all 4811 # realistically usable GNU/Hurd configurations. 4812 gcc_cv_libc_provides_ssp=yes;; 4813 *-*-darwin* | *-*-freebsd*) 4814 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes], 4815 [echo "no __stack_chk_fail on this target"]) 4816 ;; 4817 *) gcc_cv_libc_provides_ssp=no ;; 4818 esac]) 4819 4820if test x$gcc_cv_libc_provides_ssp = xyes; then 4821 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1, 4822 [Define if your target C library provides stack protector support]) 4823fi 4824 4825# Test for <sys/sdt.h> on the target. 4826GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H]) 4827AC_MSG_CHECKING(sys/sdt.h in the target C library) 4828have_sys_sdt_h=no 4829if test -f $target_header_dir/sys/sdt.h; then 4830 have_sys_sdt_h=yes 4831 AC_DEFINE(HAVE_SYS_SDT_H, 1, 4832 [Define if your target C library provides sys/sdt.h]) 4833fi 4834AC_MSG_RESULT($have_sys_sdt_h) 4835 4836# Check if TFmode long double should be used by default or not. 4837# Some glibc targets used DFmode long double, but with glibc 2.4 4838# and later they can use TFmode. 4839case "$target" in 4840 powerpc*-*-linux* | \ 4841 sparc*-*-linux* | \ 4842 s390*-*-linux* | \ 4843 alpha*-*-linux*) 4844 AC_ARG_WITH(long-double-128, 4845 [AS_HELP_STRING([--with-long-double-128], 4846 [use 128-bit long double by default])], 4847 gcc_cv_target_ldbl128="$with_long_double_128", 4848 [[gcc_cv_target_ldbl128=no 4849 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \ 4850 $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \ 4851 && gcc_cv_target_ldbl128=yes 4852 ]]) 4853 ;; 4854esac 4855if test x$gcc_cv_target_ldbl128 = xyes; then 4856 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1, 4857 [Define if TFmode long double should be the default]) 4858fi 4859 4860AC_MSG_CHECKING(dl_iterate_phdr in target C library) 4861gcc_cv_target_dl_iterate_phdr=unknown 4862case "$target" in 4863 # Restrict to Solaris 11+. While most of the Solaris 11 linker changes 4864 # were backported to Solaris 10 Update 10, dl_iterate_phdr only lives in 4865 # libdl there, both complicating its use and breaking compatibility 4866 # between Solaris 10 updates. 4867 *-*-solaris2.1[[1-9]]*) 4868 # <link.h> needs both a dl_iterate_phdr declaration and support for 4869 # compilation with largefile support. 4870 if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \ 4871 && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then 4872 gcc_cv_target_dl_iterate_phdr=yes 4873 else 4874 gcc_cv_target_dl_iterate_phdr=no 4875 fi 4876 ;; 4877esac 4878GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR]) 4879if test x$gcc_cv_target_dl_iterate_phdr = xyes; then 4880 AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1, 4881[Define if your target C library provides the `dl_iterate_phdr' function.]) 4882fi 4883AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr) 4884 4885# We no longer support different GC mechanisms. Emit an error if 4886# the user configures with --with-gc. 4887AC_ARG_WITH(gc, 4888[AS_HELP_STRING([--with-gc={page,zone}], 4889 [this option is not supported anymore. It used to choose 4890 the garbage collection mechanism to use with the compiler])], 4891[AC_MSG_ERROR([Configure option --with-gc is only supported up to GCC 4.7.x])], 4892[]) 4893 4894# Libraries to use on the host. This will normally be set by the top 4895# level Makefile. Here we simply capture the value for our Makefile. 4896if test -z "${HOST_LIBS+set}"; then 4897 HOST_LIBS= 4898fi 4899AC_SUBST(HOST_LIBS) 4900 4901# Use the system's zlib library. 4902zlibdir=-L../zlib 4903zlibinc="-I\$(srcdir)/../zlib" 4904AC_ARG_WITH(system-zlib, 4905[AS_HELP_STRING([--with-system-zlib], [use installed libz])], 4906zlibdir= 4907zlibinc= 4908) 4909AC_SUBST(zlibdir) 4910AC_SUBST(zlibinc) 4911 4912dnl Very limited version of automake's enable-maintainer-mode 4913 4914AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles]) 4915 dnl maintainer-mode is disabled by default 4916 AC_ARG_ENABLE(maintainer-mode, 4917[AS_HELP_STRING([--enable-maintainer-mode], 4918 [enable make rules and dependencies not useful 4919 (and sometimes confusing) to the casual installer])], 4920 maintainer_mode=$enableval, 4921 maintainer_mode=no) 4922 4923AC_MSG_RESULT($maintainer_mode) 4924 4925if test "$maintainer_mode" = "yes"; then 4926 MAINT='' 4927else 4928 MAINT='#' 4929fi 4930AC_SUBST(MAINT)dnl 4931 4932# -------------- 4933# Language hooks 4934# -------------- 4935 4936# Make empty files to contain the specs and options for each language. 4937# Then add #include lines to for a compiler that has specs and/or options. 4938 4939subdirs= 4940lang_opt_files= 4941lang_specs_files= 4942lang_tree_files= 4943# These (without "all_") are set in each config-lang.in. 4944# `language' must be a single word so is spelled singularly. 4945all_languages= 4946all_compilers= 4947all_outputs='Makefile' 4948# List of language makefile fragments. 4949all_lang_makefrags= 4950# Additional files for gengtype 4951all_gtfiles="$target_gtfiles" 4952 4953# These are the languages that are set in --enable-languages, 4954# and are available in the GCC tree. 4955all_selected_languages= 4956 4957# Add the language fragments. 4958# Languages are added via two mechanisms. Some information must be 4959# recorded in makefile variables, these are defined in config-lang.in. 4960# We accumulate them and plug them into the main Makefile. 4961# The other mechanism is a set of hooks for each of the main targets 4962# like `clean', `install', etc. 4963 4964language_hooks="Make-hooks" 4965 4966for lang in ${srcdir}/*/config-lang.in 4967do 4968changequote(,)dnl 4969 test "$lang" = "${srcdir}/*/config-lang.in" && continue 4970 4971 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang` 4972 if test "x$lang_alias" = x 4973 then 4974 echo "$lang doesn't set \$language." 1>&2 4975 exit 1 4976 fi 4977 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`" 4978 subdirs="$subdirs $subdir" 4979 4980 # $gcc_subdir is where the gcc integration files are to be found 4981 # for a language, both for internal compiler purposes (compiler 4982 # sources implementing front-end to GCC tree converters), and for 4983 # build infrastructure purposes (Make-lang.in, etc.) 4984 # 4985 # This will be <subdir> (relative to $srcdir) if a line like 4986 # gcc_subdir="<subdir>" or gcc_subdir=<subdir> 4987 # is found in <langdir>/config-lang.in, and will remain <langdir> 4988 # otherwise. 4989 # 4990 # Except for the language alias (fetched above), the regular 4991 # "config-lang.in" contents are always retrieved from $gcc_subdir, 4992 # so a <langdir>/config-lang.in setting gcc_subdir typically sets 4993 # only this and the language alias. 4994 4995 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang` 4996 if [ "$gcc_subdir" = "" ]; then 4997 gcc_subdir="$subdir" 4998 fi 4999 5000 case ",$enable_languages," in 5001 *,$lang_alias,*) 5002 all_selected_languages="$all_selected_languages $lang_alias" 5003 if test -f $srcdir/$gcc_subdir/lang-specs.h; then 5004 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h" 5005 fi 5006 ;; 5007 esac 5008changequote([,])dnl 5009 5010 language= 5011 boot_language= 5012 compilers= 5013 outputs= 5014 gtfiles= 5015 subdir_requires= 5016 . ${srcdir}/$gcc_subdir/config-lang.in 5017 if test "x$language" = x 5018 then 5019 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2 5020 exit 1 5021 fi 5022 5023 ok=: 5024 case ",$enable_languages," in 5025 *,$lang_alias,*) ;; 5026 *) 5027 for i in $subdir_requires; do 5028 test -f "${srcdir}/$i/config-lang.in" && continue 5029 ok=false 5030 break 5031 done 5032 ;; 5033 esac 5034 $ok || continue 5035 5036 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in" 5037 if test -f $srcdir/$gcc_subdir/lang.opt; then 5038 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt" 5039 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt" 5040 fi 5041 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then 5042 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def" 5043 fi 5044 all_languages="$all_languages $language" 5045 all_compilers="$all_compilers $compilers" 5046 all_outputs="$all_outputs $outputs" 5047 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles" 5048 case ",$enable_languages," in 5049 *,lto,*) 5050 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.]) 5051 enable_lto=yes 5052 AC_SUBST(enable_lto) 5053 ;; 5054 *) ;; 5055 esac 5056done 5057 5058check_languages= 5059for language in $all_selected_languages 5060do 5061 check_languages="$check_languages check-$language" 5062done 5063 5064# We link each language in with a set of hooks, reached indirectly via 5065# lang.${target}. Only do so for selected languages. 5066 5067rm -f Make-hooks 5068touch Make-hooks 5069target_list="all.cross start.encap rest.encap tags \ 5070 install-common install-man install-info install-pdf install-html dvi \ 5071 pdf html uninstall info man srcextra srcman srcinfo \ 5072 mostlyclean clean distclean maintainer-clean install-plugin" 5073 5074for t in $target_list 5075do 5076 x= 5077 for lang in $all_selected_languages 5078 do 5079 x="$x $lang.$t" 5080 done 5081 echo "lang.$t: $x" >> Make-hooks 5082done 5083 5084# -------- 5085# Option include files 5086# -------- 5087 5088${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk 5089option_includes="option-includes.mk" 5090AC_SUBST_FILE(option_includes) 5091 5092# -------- 5093# UNSORTED 5094# -------- 5095 5096# Create .gdbinit. 5097 5098echo "dir ." > .gdbinit 5099echo "dir ${srcdir}" >> .gdbinit 5100if test x$gdb_needs_out_file_path = xyes 5101then 5102 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit 5103fi 5104if test "x$subdirs" != x; then 5105 for s in $subdirs 5106 do 5107 echo "dir ${srcdir}/$s" >> .gdbinit 5108 done 5109fi 5110echo "source ${srcdir}/gdbinit.in" >> .gdbinit 5111 5112gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)' 5113AC_SUBST(gcc_tooldir) 5114AC_SUBST(dollar) 5115 5116# Find a directory in which to install a shared libgcc. 5117 5118AC_ARG_ENABLE(version-specific-runtime-libs, 5119[AS_HELP_STRING([--enable-version-specific-runtime-libs], 5120 [specify that runtime libraries should be 5121 installed in a compiler-specific directory])]) 5122 5123# Substitute configuration variables 5124AC_SUBST(subdirs) 5125AC_SUBST(srcdir) 5126AC_SUBST(all_compilers) 5127AC_SUBST(all_gtfiles) 5128AC_SUBST(all_lang_makefrags) 5129AC_SUBST(all_languages) 5130AC_SUBST(all_selected_languages) 5131AC_SUBST(build_exeext) 5132AC_SUBST(build_install_headers_dir) 5133AC_SUBST(build_xm_file_list) 5134AC_SUBST(build_xm_include_list) 5135AC_SUBST(build_xm_defines) 5136AC_SUBST(build_file_translate) 5137AC_SUBST(check_languages) 5138AC_SUBST(cpp_install_dir) 5139AC_SUBST(xmake_file) 5140AC_SUBST(tmake_file) 5141AC_SUBST(TM_ENDIAN_CONFIG) 5142AC_SUBST(TM_MULTILIB_CONFIG) 5143AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG) 5144AC_SUBST(extra_gcc_objs) 5145AC_SUBST(user_headers_inc_next_pre) 5146AC_SUBST(user_headers_inc_next_post) 5147AC_SUBST(extra_headers_list) 5148AC_SUBST(extra_objs) 5149AC_SUBST(extra_programs) 5150AC_SUBST(float_h_file) 5151AC_SUBST(gcc_config_arguments) 5152AC_SUBST(gcc_gxx_include_dir) 5153AC_SUBST(gcc_gxx_include_dir_add_sysroot) 5154AC_SUBST(host_exeext) 5155AC_SUBST(host_xm_file_list) 5156AC_SUBST(host_xm_include_list) 5157AC_SUBST(host_xm_defines) 5158AC_SUBST(out_host_hook_obj) 5159AC_SUBST(install) 5160AC_SUBST(lang_opt_files) 5161AC_SUBST(lang_specs_files) 5162AC_SUBST(lang_tree_files) 5163AC_SUBST(local_prefix) 5164AC_SUBST(md_file) 5165AC_SUBST(objc_boehm_gc) 5166AC_SUBST(out_file) 5167AC_SUBST(out_object_file) 5168AC_SUBST(common_out_file) 5169AC_SUBST(common_out_object_file) 5170AC_SUBST(tm_file_list) 5171AC_SUBST(tm_include_list) 5172AC_SUBST(tm_defines) 5173AC_SUBST(tm_p_file_list) 5174AC_SUBST(tm_p_include_list) 5175AC_SUBST(xm_file_list) 5176AC_SUBST(xm_include_list) 5177AC_SUBST(xm_defines) 5178AC_SUBST(use_gcc_stdint) 5179AC_SUBST(c_target_objs) 5180AC_SUBST(cxx_target_objs) 5181AC_SUBST(fortran_target_objs) 5182AC_SUBST(target_cpu_default) 5183 5184AC_SUBST_FILE(language_hooks) 5185 5186# Echo link setup. 5187if test x${build} = x${host} ; then 5188 if test x${host} = x${target} ; then 5189 echo "Links are now set up to build a native compiler for ${target}." 1>&2 5190 else 5191 echo "Links are now set up to build a cross-compiler" 1>&2 5192 echo " from ${host} to ${target}." 1>&2 5193 fi 5194else 5195 if test x${host} = x${target} ; then 5196 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2 5197 echo " for ${target}." 1>&2 5198 else 5199 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2 5200 echo " from ${host} to ${target}." 1>&2 5201 fi 5202fi 5203 5204AC_ARG_VAR(GMPLIBS,[How to link GMP]) 5205AC_ARG_VAR(GMPINC,[How to find GMP include files]) 5206 5207AC_ARG_VAR(ISLLIBS,[How to link ISL]) 5208AC_ARG_VAR(ISLINC,[How to find ISL include files]) 5209 5210AC_ARG_VAR(CLOOGLIBS,[How to link CLOOG]) 5211AC_ARG_VAR(CLOOGINC,[How to find CLOOG include files]) 5212if test "x${CLOOGLIBS}" != "x" ; then 5213 AC_DEFINE(HAVE_cloog, 1, [Define if cloog is in use.]) 5214 5215 # Check whether isl_schedule_constraints_compute_schedule is available; 5216 # it's new in ISL-0.13. 5217 saved_CFLAGS="$CFLAGS" 5218 CFLAGS="$CFLAGS $ISLINC" 5219 saved_LIBS="$LIBS" 5220 LIBS="$LIBS $CLOOGLIBS $ISLLIBS $GMPLIBS" 5221 5222 AC_MSG_CHECKING([Checking for isl_schedule_constraints_compute_schedule]) 5223 AC_TRY_LINK([#include <isl/schedule.h>], 5224 [isl_schedule_constraints_compute_schedule (NULL);], 5225 [ac_has_isl_schedule_constraints_compute_schedule=yes], 5226 [ac_has_isl_schedule_constraints_compute_schedule=no]) 5227 AC_MSG_RESULT($ac_has_isl_schedule_constraints_compute_schedule) 5228 5229 LIBS="$saved_LIBS" 5230 CFLAGS="$saved_CFLAGS" 5231 5232 if test x"$ac_has_isl_schedule_constraints_compute_schedule" = x"yes"; then 5233 AC_DEFINE(HAVE_ISL_SCHED_CONSTRAINTS_COMPUTE_SCHEDULE, 1, 5234 [Define if isl_schedule_constraints_compute_schedule exists.]) 5235 fi 5236fi 5237 5238 5239# Check for plugin support 5240AC_ARG_ENABLE(plugin, 5241[AS_HELP_STRING([--enable-plugin], [enable plugin support])], 5242enable_plugin=$enableval, 5243enable_plugin=yes; default_plugin=yes) 5244 5245pluginlibs= 5246 5247case "${host}" in 5248 *-*-darwin*) 5249 if test x$build = x$host; then 5250 export_sym_check="nm${exeext} -g" 5251 elif test x$host = x$target; then 5252 export_sym_check="$gcc_cv_nm -g" 5253 else 5254 export_sym_check= 5255 fi 5256 ;; 5257 *) 5258 if test x$build = x$host; then 5259 export_sym_check="objdump${exeext} -T" 5260 elif test x$host = x$target; then 5261 export_sym_check="$gcc_cv_objdump -T" 5262 else 5263 export_sym_check= 5264 fi 5265 ;; 5266esac 5267 5268if test x"$enable_plugin" = x"yes"; then 5269 5270 AC_MSG_CHECKING([for exported symbols]) 5271 if test "x$export_sym_check" != x; then 5272 echo "int main() {return 0;} int foobar() {return 0;}" > conftest.c 5273 ${CC} ${CFLAGS} ${LDFLAGS} conftest.c -o conftest$ac_exeext > /dev/null 2>&1 5274 if $export_sym_check conftest$ac_exeext | grep -q foobar > /dev/null; then 5275 : # No need to use a flag 5276 AC_MSG_RESULT([yes]) 5277 else 5278 AC_MSG_RESULT([yes]) 5279 AC_MSG_CHECKING([for -rdynamic]) 5280 ${CC} ${CFLAGS} ${LDFLAGS} -rdynamic conftest.c -o conftest$ac_exeext > /dev/null 2>&1 5281 if $export_sym_check conftest$ac_exeext | grep -q foobar > /dev/null; then 5282 plugin_rdynamic=yes 5283 pluginlibs="-rdynamic" 5284 else 5285 plugin_rdynamic=no 5286 enable_plugin=no 5287 fi 5288 AC_MSG_RESULT([$plugin_rdynamic]) 5289 fi 5290 else 5291 AC_MSG_RESULT([unable to check]) 5292 fi 5293 5294 # Check -ldl 5295 saved_LIBS="$LIBS" 5296 AC_SEARCH_LIBS([dlopen], [dl]) 5297 if test x"$ac_cv_search_dlopen" = x"-ldl"; then 5298 pluginlibs="$pluginlibs -ldl" 5299 fi 5300 LIBS="$saved_LIBS" 5301 5302 # Check that we can build shared objects with -fPIC -shared 5303 saved_LDFLAGS="$LDFLAGS" 5304 saved_CFLAGS="$CFLAGS" 5305 case "${host}" in 5306 *-*-darwin*) 5307 CFLAGS=`echo $CFLAGS | sed s/-mdynamic-no-pic//g` 5308 CFLAGS="$CFLAGS -fPIC" 5309 LDFLAGS="$LDFLAGS -shared -undefined dynamic_lookup" 5310 ;; 5311 *) 5312 CFLAGS="$CFLAGS -fPIC" 5313 LDFLAGS="$LDFLAGS -fPIC -shared" 5314 ;; 5315 esac 5316 AC_MSG_CHECKING([for -fPIC -shared]) 5317 AC_TRY_LINK( 5318 [extern int X;],[return X == 0;], 5319 [AC_MSG_RESULT([yes]); have_pic_shared=yes], 5320 [AC_MSG_RESULT([no]); have_pic_shared=no]) 5321 if test x"$have_pic_shared" != x"yes" -o x"$ac_cv_search_dlopen" = x"no"; then 5322 pluginlibs= 5323 enable_plugin=no 5324 fi 5325 LDFLAGS="$saved_LDFLAGS" 5326 CFLAGS="$saved_CFLAGS" 5327 5328 # If plugin support had been requested but not available, fail. 5329 if test x"$enable_plugin" = x"no" ; then 5330 if test x"$default_plugin" != x"yes"; then 5331 AC_MSG_ERROR([ 5332Building GCC with plugin support requires a host that supports 5333-fPIC, -shared, -ldl and -rdynamic.]) 5334 fi 5335 fi 5336fi 5337 5338AC_SUBST(pluginlibs) 5339AC_SUBST(enable_plugin) 5340if test x"$enable_plugin" = x"yes"; then 5341 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.]) 5342fi 5343 5344 5345AC_ARG_ENABLE(libquadmath-support, 5346[AS_HELP_STRING([--disable-libquadmath-support], 5347 [disable libquadmath support for Fortran])], 5348ENABLE_LIBQUADMATH_SUPPORT=$enableval, 5349ENABLE_LIBQUADMATH_SUPPORT=yes) 5350if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then 5351 AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1, 5352 [Define to 1 to enable libquadmath support]) 5353fi 5354 5355 5356# Specify what hash style to use by default. 5357AC_ARG_WITH([linker-hash-style], 5358[AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}], 5359 [specify the linker hash style])], 5360[case x"$withval" in 5361 xsysv) 5362 LINKER_HASH_STYLE=sysv 5363 ;; 5364 xgnu) 5365 LINKER_HASH_STYLE=gnu 5366 ;; 5367 xboth) 5368 LINKER_HASH_STYLE=both 5369 ;; 5370 *) 5371 AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style]) 5372 ;; 5373 esac], 5374[LINKER_HASH_STYLE='']) 5375if test x"${LINKER_HASH_STYLE}" != x; then 5376 AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE", 5377 [The linker hash style]) 5378fi 5379 5380# Configure the subdirectories 5381# AC_CONFIG_SUBDIRS($subdirs) 5382 5383# Create the Makefile 5384# and configure language subdirectories 5385AC_CONFIG_FILES($all_outputs) 5386 5387AC_CONFIG_COMMANDS([default], 5388[ 5389case ${CONFIG_HEADERS} in 5390 *auto-host.h:config.in*) 5391 echo > cstamp-h ;; 5392esac 5393# Make sure all the subdirs exist. 5394for d in $subdirs doc build common c-family 5395do 5396 test -d $d || mkdir $d 5397done 5398], 5399[subdirs='$subdirs']) 5400AC_OUTPUT 5401 5402