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