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# handle --with-hybrid-secondary 653AC_ARG_WITH(hybrid_secondary, 654 [AS_HELP_STRING([--with-hybrid_secondary], 655 [specify the packaging architecture for building a secondary compiler for a Haiku hybrid system])], 656 [HYBRID_SECONDARY=$withval], 657 [HYBRID_SECONDARY=] 658) 659AC_SUBST(HYBRID_SECONDARY) 660 661# With stabs 662AC_ARG_WITH(stabs, 663[AS_HELP_STRING([--with-stabs], 664 [arrange to use stabs instead of host debug format])], 665stabs="$with_stabs", 666stabs=no) 667 668# Determine whether or not multilibs are enabled. 669AC_ARG_ENABLE(multilib, 670[AS_HELP_STRING([--enable-multilib], 671 [enable library support for multiple ABIs])], 672[], [enable_multilib=yes]) 673AC_SUBST(enable_multilib) 674 675# Determine whether or not multiarch is enabled. 676AC_ARG_ENABLE(multiarch, 677[AS_HELP_STRING([--enable-multiarch], 678 [enable support for multiarch paths])], 679[case "${enableval}" in 680yes|no|auto) enable_multiarch=$enableval;; 681*) AC_MSG_ERROR(bad value ${enableval} given for --enable-multiarch option) ;; 682esac], [enable_multiarch=auto]) 683if test x${enable_multiarch} = xauto; then 684 if test x${with_native_system_header_dir} != x; then 685 ma_msg_suffix=", disabled auto check (configured with --native-system-header-dir)" 686 enable_multiarch=no 687 fi 688 if test x$host != x$target && test "x$with_sysroot" = x; then 689 ma_msg_suffix=", disabled auto check (cross build configured without --with-sysroot)" 690 enable_multiarch=no 691 fi 692fi 693AC_MSG_CHECKING(for multiarch configuration) 694AC_SUBST(enable_multiarch) 695AC_MSG_RESULT($enable_multiarch$ma_msg_suffix) 696 697# needed for setting the multiarch name for soft-float/hard-float ABIs 698AC_SUBST(with_cpu) 699AC_SUBST(with_float) 700 701# Enable __cxa_atexit for C++. 702AC_ARG_ENABLE(__cxa_atexit, 703[AS_HELP_STRING([--enable-__cxa_atexit], [enable __cxa_atexit for C++])], 704[], []) 705 706# Enable C extension for decimal float if target supports it. 707GCC_AC_ENABLE_DECIMAL_FLOAT([$target]) 708 709dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi` 710AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp, 711[Define to 1 to enable decimal float extension to C.]) 712 713# Use default_decimal_float for dependency. 714enable_decimal_float=$default_decimal_float 715 716bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi` 717AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid, 718[Define to 1 to specify that we are using the BID decimal floating 719point format instead of DPD]) 720 721# Enable C extension for fixed-point arithmetic. 722AC_ARG_ENABLE(fixed-point, 723[AS_HELP_STRING([--enable-fixed-point], 724 [enable fixed-point arithmetic extension to C])], 725[], 726[ 727 case $target in 728 arm*) 729 enable_fixed_point=yes 730 ;; 731 732 mips*-*-*) 733 enable_fixed_point=yes 734 ;; 735 *) 736 AC_MSG_WARN([fixed-point is not supported for this target, ignored]) 737 enable_fixed_point=no 738 ;; 739 esac 740]) 741AC_SUBST(enable_fixed_point) 742 743fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi` 744AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint, 745[Define to 1 to enable fixed-point arithmetic extension to C.]) 746 747# Enable threads 748# Pass with no value to take the default 749# Pass with a value to specify a thread package 750AC_ARG_ENABLE(threads, 751[AS_HELP_STRING([[--enable-threads[=LIB]]], 752 [enable thread usage for target GCC, 753 using LIB thread package])],, 754[enable_threads='']) 755 756AC_ARG_ENABLE(tls, 757[AS_HELP_STRING([--enable-tls], 758 [enable or disable generation of tls code 759 overriding the assembler check for tls support])], 760[ 761 case $enable_tls in 762 yes | no) ;; 763 *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls. 764Valid choices are 'yes' and 'no'.]) ;; 765 esac 766], [enable_tls='']) 767 768AC_ARG_ENABLE(objc-gc, 769[AS_HELP_STRING([--enable-objc-gc], 770 [enable the use of Boehm's garbage collector with 771 the GNU Objective-C runtime])], 772if test x$enable_objc_gc = xno; then 773 objc_boehm_gc='' 774else 775 objc_boehm_gc=1 776fi, 777objc_boehm_gc='') 778 779AC_ARG_WITH(dwarf2, 780[AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2])], 781dwarf2="$with_dwarf2", 782dwarf2=no) 783 784AC_ARG_ENABLE(shared, 785[AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])], 786[ 787 case $enable_shared in 788 yes | no) ;; 789 *) 790 enable_shared=no 791 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:," 792 for pkg in $enableval; do 793 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then 794 enable_shared=yes 795 fi 796 done 797 IFS="$ac_save_ifs" 798 ;; 799 esac 800], [enable_shared=yes]) 801AC_SUBST(enable_shared) 802 803AC_ARG_WITH([native-system-header-dir], 804 [ --with-native-system-header-dir=dir 805 use dir as the directory to look for standard 806 system header files in. Defaults to /usr/include.], 807[ 808 case ${with_native_system_header_dir} in 809 yes|no) AC_MSG_ERROR([bad value ${withval} given for --with-native-system-header-dir]) ;; 810 /* | [[A-Za-z]]:[[\\/]]*) ;; 811 *) AC_MSG_ERROR([--with-native-system-header-dir argument ${withval} must be an absolute directory]) ;; 812 esac 813 configured_native_system_header_dir="${withval}" 814], [configured_native_system_header_dir=]) 815 816AC_ARG_WITH(build-sysroot, 817 [AS_HELP_STRING([--with-build-sysroot=sysroot], 818 [use sysroot as the system root during the build])], 819 [if test x"$withval" != x ; then 820 SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval" 821 fi], 822 [SYSROOT_CFLAGS_FOR_TARGET=]) 823AC_SUBST(SYSROOT_CFLAGS_FOR_TARGET) 824 825if test "x$prefix" = xNONE; then 826 test_prefix=/usr/local 827else 828 test_prefix=$prefix 829fi 830if test "x$exec_prefix" = xNONE; then 831 test_exec_prefix=$test_prefix 832else 833 test_exec_prefix=$exec_prefix 834fi 835 836AC_ARG_WITH(sysroot, 837[AS_HELP_STRING([[--with-sysroot[=DIR]]], 838 [search for usr/lib, usr/include, et al, within DIR])], 839[ 840 case ${with_sysroot} in 841 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;; 842 *) TARGET_SYSTEM_ROOT=$with_sysroot ;; 843 esac 844 845 TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"' 846 CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)' 847 848 case ${TARGET_SYSTEM_ROOT} in 849 "${test_prefix}"|"${test_prefix}/"*|\ 850 "${test_exec_prefix}"|"${test_exec_prefix}/"*|\ 851 '${prefix}'|'${prefix}/'*|\ 852 '${exec_prefix}'|'${exec_prefix}/'*) 853 t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE" 854 TARGET_SYSTEM_ROOT_DEFINE="$t" 855 ;; 856 esac 857], [ 858 TARGET_SYSTEM_ROOT= 859 TARGET_SYSTEM_ROOT_DEFINE= 860 CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include' 861]) 862AC_SUBST(TARGET_SYSTEM_ROOT) 863AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE) 864AC_SUBST(CROSS_SYSTEM_HEADER_DIR) 865 866AC_ARG_WITH(specs, 867 [AS_HELP_STRING([--with-specs=SPECS], 868 [add SPECS to driver command-line processing])], 869 [CONFIGURE_SPECS=$withval], 870 [CONFIGURE_SPECS=] 871) 872AC_SUBST(CONFIGURE_SPECS) 873 874ACX_PKGVERSION([GCC]) 875ACX_BUGURL([http://gcc.gnu.org/bugs.html]) 876 877# Sanity check enable_languages in case someone does not run the toplevel 878# configure # script. 879AC_ARG_ENABLE(languages, 880[AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])], 881[case ,${enable_languages}, in 882 ,,|,yes,) 883 # go safe -- we cannot be much sure without the toplevel 884 # configure's 885 # analysis of which target libs are present and usable 886 enable_languages=c 887 ;; 888 *,all,*) 889 AC_MSG_ERROR([only the toplevel supports --enable-languages=all]) 890 ;; 891 *,c,*) 892 ;; 893 *) 894 enable_languages=c,${enable_languages} 895 ;; 896esac], 897[enable_languages=c]) 898 899if test x"$enable_as_accelerator_for" != x; then 900 AC_DEFINE(ACCEL_COMPILER, 1, 901 [Define if this compiler should be built as the offload target compiler.]) 902 enable_as_accelerator=yes 903 case "${target}" in 904 *-intelmicemul-*) 905 # In this case we expect offload compiler to be built as native, so we 906 # need to rename the driver to avoid clashes with host's drivers. 907 program_transform_name="s&^&${target}-&" ;; 908 esac 909 sedscript="s#${target_noncanonical}#${enable_as_accelerator_for}-accel-${target_noncanonical}#" 910 program_transform_name=`echo $program_transform_name | sed $sedscript` 911 accel_dir_suffix=/accel/${target_noncanonical} 912 real_target_noncanonical=${enable_as_accelerator_for} 913fi 914AC_SUBST(enable_as_accelerator) 915AC_SUBST(real_target_noncanonical) 916AC_SUBST(accel_dir_suffix) 917 918for tgt in `echo $enable_offload_targets | sed 's/,/ /g'`; do 919 tgt=`echo $tgt | sed 's/=.*//'` 920 if test x"$offload_targets" = x; then 921 offload_targets=$tgt 922 else 923 offload_targets="$offload_targets:$tgt" 924 fi 925done 926AC_DEFINE_UNQUOTED(OFFLOAD_TARGETS, "$offload_targets", 927 [Define to hold the list of target names suitable for offloading.]) 928if test x"$offload_targets" != x; then 929 AC_DEFINE(ENABLE_OFFLOADING, 1, 930 [Define this to enable support for offloading.]) 931fi 932 933AC_ARG_WITH(multilib-list, 934[AS_HELP_STRING([--with-multilib-list], [select multilibs (AArch64, SH and x86-64 only)])], 935:, 936with_multilib_list=default) 937 938# ------------------------- 939# Checks for other programs 940# ------------------------- 941 942AC_PROG_MAKE_SET 943 944# Find some useful tools 945AC_PROG_AWK 946# We need awk to create options.c and options.h. 947# Bail out if it's missing. 948case ${AWK} in 949 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;; 950esac 951 952gcc_AC_PROG_LN_S 953ACX_PROG_LN($LN_S) 954AC_PROG_RANLIB 955ranlib_flags="" 956AC_SUBST(ranlib_flags) 957 958gcc_AC_PROG_INSTALL 959 960# See if cmp has --ignore-initial. 961gcc_AC_PROG_CMP_IGNORE_INITIAL 962 963# See if we have the mktemp command. 964AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no) 965 966# See if makeinfo has been installed and is modern enough 967# that we can use it. 968ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version, 969 [GNU texinfo.* \([0-9][0-9.]*\)], 970 [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*]) 971if test $gcc_cv_prog_makeinfo_modern = no; then 972 AC_MSG_WARN([ 973*** Makeinfo is missing or too old. 974*** Info documentation will not be built.]) 975 BUILD_INFO= 976else 977 BUILD_INFO=info 978fi 979AC_SUBST(BUILD_INFO) 980 981# Is pod2man recent enough to regenerate manpages? 982AC_MSG_CHECKING([for recent Pod::Man]) 983if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then 984 AC_MSG_RESULT(yes) 985 GENERATED_MANPAGES=generated-manpages 986else 987 AC_MSG_RESULT(no) 988 GENERATED_MANPAGES= 989fi 990AC_SUBST(GENERATED_MANPAGES) 991 992MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing" 993 994# How about lex? 995dnl Don't use AC_PROG_LEX; we insist on flex. 996dnl LEXLIB is not useful in gcc. 997AC_CHECK_PROGS([FLEX], flex, [$MISSING flex]) 998 999# Bison? 1000AC_CHECK_PROGS([BISON], bison, [$MISSING bison]) 1001 1002# Binutils are not build modules, unlike bison/flex/makeinfo. So we 1003# check for build == host before using them. 1004 1005# NM 1006if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \ 1007 && test -d ../binutils ; then 1008 NM='${objdir}/../binutils/nm-new' 1009else 1010 AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm) 1011fi 1012 1013# AR 1014if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \ 1015 && test -d ../binutils ; then 1016 AR='${objdir}/../binutils/ar' 1017else 1018 AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar) 1019fi 1020 1021# The jit documentation looks better if built with sphinx, but can be 1022# built with texinfo if sphinx is not available. 1023# Set "doc_build_sys" to "sphinx" or "texinfo" accordingly. 1024AC_CHECK_PROG(doc_build_sys, sphinx-build, sphinx, texinfo) 1025 1026# -------------------- 1027# Checks for C headers 1028# -------------------- 1029 1030# Need to reject headers which give warnings, so that the -Werror bootstrap 1031# works later. *sigh* This needs to come before all header checks. 1032AC_PROG_CPP_WERROR 1033 1034AC_HEADER_STDC 1035AC_HEADER_TIME 1036ACX_HEADER_STRING 1037AC_HEADER_SYS_WAIT 1038AC_HEADER_TIOCGWINSZ 1039AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \ 1040 fcntl.h ftw.h unistd.h sys/file.h sys/time.h sys/mman.h \ 1041 sys/resource.h sys/param.h sys/times.h sys/stat.h \ 1042 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h) 1043 1044# Check for thread headers. 1045AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=]) 1046AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=]) 1047 1048# These tests can't be done till we know if we have limits.h. 1049gcc_AC_C_CHAR_BIT 1050AC_C_BIGENDIAN 1051 1052# ---------------------- 1053# Checks for C++ headers 1054# ---------------------- 1055 1056dnl Autoconf will give an error in the configure script if there is no 1057dnl C++ preprocessor. Hack to prevent that. 1058m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl 1059AC_PROG_CXXCPP 1060m4_popdef([AC_MSG_ERROR])[]dnl 1061 1062AC_LANG_PUSH(C++) 1063 1064AC_CHECK_HEADERS(unordered_map) 1065AC_CHECK_HEADERS(tr1/unordered_map) 1066AC_CHECK_HEADERS(ext/hash_map) 1067 1068AC_LANG_POP(C++) 1069 1070# -------- 1071# Dependency checking. 1072# -------- 1073 1074AC_LANG_PUSH(C++) 1075ZW_CREATE_DEPDIR 1076AC_CONFIG_COMMANDS([gccdepdir],[ 1077 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs build/$DEPDIR 1078 for lang in $subdirs c-family common 1079 do 1080 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs $lang/$DEPDIR 1081 done], [subdirs="$subdirs" ac_aux_dir=$ac_aux_dir DEPDIR=$DEPDIR]) 1082 1083ZW_PROG_COMPILER_DEPENDENCIES([CXX]) 1084AC_LANG_POP(C++) 1085 1086# -------- 1087# UNSORTED 1088# -------- 1089 1090 1091# Configure -lm usage for host tools that need it 1092build_math_library="-lm" 1093case $build in 1094 *-*-haiku*) 1095 # no separate math library needed 1096 build_math_library= 1097 ;; 1098esac 1099AC_SUBST(build_math_library) 1100 1101# These libraries may be used by collect2. 1102# We may need a special search path to get them linked. 1103AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs, 1104[save_LIBS="$LIBS" 1105for libs in '' -lld -lmld \ 1106 '-L/usr/lib/cmplrs/cc2.11 -lmld' \ 1107 '-L/usr/lib/cmplrs/cc3.11 -lmld' 1108do 1109 LIBS="$libs" 1110 AC_TRY_LINK_FUNC(ldopen, 1111 [gcc_cv_collect2_libs="$libs"; break]) 1112done 1113LIBS="$save_LIBS" 1114test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required']) 1115case $gcc_cv_collect2_libs in 1116 "none required") ;; 1117 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;; 1118esac 1119AC_SUBST(COLLECT2_LIBS) 1120 1121# When building Ada code on Alpha, we need exc_resume which is usually in 1122# -lexc. So test for it. 1123save_LIBS="$LIBS" 1124LIBS= 1125AC_SEARCH_LIBS(exc_resume, exc) 1126GNAT_LIBEXC="$LIBS" 1127LIBS="$save_LIBS" 1128AC_SUBST(GNAT_LIBEXC) 1129 1130# To support -mcpu=native on Solaris/SPARC, we need libkstat. 1131save_LIBS="$LIBS" 1132LIBS= 1133AC_SEARCH_LIBS(kstat_open, kstat) 1134EXTRA_GCC_LIBS="$LIBS" 1135LIBS="$save_LIBS" 1136AC_SUBST(EXTRA_GCC_LIBS) 1137 1138# Some systems put ldexp and frexp in libm instead of libc; assume 1139# they're both in the same place. jcf-dump needs them. 1140save_LIBS="$LIBS" 1141LIBS= 1142AC_SEARCH_LIBS(ldexp, m) 1143LDEXP_LIB="$LIBS" 1144LIBS="$save_LIBS" 1145AC_SUBST(LDEXP_LIB) 1146 1147# Use <inttypes.h> only if it exists, 1148# doesn't clash with <sys/types.h>, declares intmax_t and defines 1149# PRId64 1150AC_MSG_CHECKING(for inttypes.h) 1151AC_CACHE_VAL(gcc_cv_header_inttypes_h, 1152[AC_COMPILE_IFELSE([AC_LANG_PROGRAM( 1153[[#define __STDC_FORMAT_MACROS 1154#include <sys/types.h> 1155#include <inttypes.h>]], 1156 [[intmax_t i = -1; 1157#ifndef PRId64 1158choke me 1159#endif]])], 1160 [gcc_cv_header_inttypes_h=yes], 1161 [gcc_cv_header_inttypes_h=no])]) 1162AC_MSG_RESULT($gcc_cv_header_inttypes_h) 1163if test $gcc_cv_header_inttypes_h = yes; then 1164 AC_DEFINE(HAVE_INTTYPES_H, 1, 1165 [Define if you have a working <inttypes.h> header file.]) 1166fi 1167 1168dnl Disabled until we have a complete test for buggy enum bitfields. 1169dnl gcc_AC_C_ENUM_BF_UNSIGNED 1170 1171define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl 1172 ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl 1173 fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl 1174 fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl 1175 putchar_unlocked putc_unlocked) 1176AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoll atoq \ 1177 popen sysconf strsignal getrusage nl_langinfo \ 1178 gettimeofday mbstowcs wcswidth mmap setlocale \ 1179 gcc_UNLOCKED_FUNCS madvise) 1180 1181if test x$ac_cv_func_mbstowcs = xyes; then 1182 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works, 1183[ AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h> 1184int main() 1185{ 1186 mbstowcs(0, "", 0); 1187 return 0; 1188}]])], 1189 [gcc_cv_func_mbstowcs_works=yes], 1190 [gcc_cv_func_mbstowcs_works=no], 1191 [gcc_cv_func_mbstowcs_works=yes])]) 1192 if test x$gcc_cv_func_mbstowcs_works = xyes; then 1193 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1, 1194 [Define this macro if mbstowcs does not crash when its 1195 first argument is NULL.]) 1196 fi 1197fi 1198 1199AC_CHECK_TYPE(ssize_t, int) 1200AC_CHECK_TYPE(caddr_t, char *) 1201 1202GCC_AC_FUNC_MMAP_BLACKLIST 1203 1204case "${host}" in 1205*-*-*vms*) 1206 # Under VMS, vfork works very differently than on Unix. The standard test 1207 # won't work, and it isn't easily adaptable. It makes more sense to 1208 # just force it. 1209 ac_cv_func_vfork_works=yes 1210 ;; 1211esac 1212AC_FUNC_FORK 1213 1214# g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which exposes a different 1215# iconv() prototype. 1216AC_LANG_PUSH([C++]) 1217AM_ICONV 1218AC_LANG_POP([C++]) 1219 1220# Until we have in-tree GNU iconv: 1221LIBICONV_DEP= 1222AC_SUBST(LIBICONV_DEP) 1223 1224AM_LC_MESSAGES 1225 1226AM_LANGINFO_CODESET 1227 1228# We will need to find libiberty.h and ansidecl.h 1229saved_CFLAGS="$CFLAGS" 1230CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC" 1231saved_CXXFLAGS="$CXXFLAGS" 1232CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC" 1233gcc_AC_CHECK_DECLS(getenv atol asprintf sbrk abort atof getcwd getwd \ 1234 stpcpy strnlen strsignal strstr strverscmp \ 1235 strtol strtoul strtoll strtoull \ 1236 errno snprintf vsnprintf vasprintf malloc realloc calloc \ 1237 free basename getopt clock getpagesize ffs gcc_UNLOCKED_FUNCS, , ,[ 1238#include "ansidecl.h" 1239#include "system.h"]) 1240 1241gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[ 1242#include "ansidecl.h" 1243#include "system.h" 1244#ifdef HAVE_SYS_RESOURCE_H 1245#include <sys/resource.h> 1246#endif 1247]) 1248 1249AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 1250#include "ansidecl.h" 1251#include "system.h" 1252#ifdef HAVE_SYS_RESOURCE_H 1253#include <sys/resource.h> 1254#endif 1255]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long], 1256[Define to `long' if <sys/resource.h> doesn't define.])]) 1257 1258# On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible 1259# FREAD and FWRITE macros. Fortunately, for GCC's single usage of ldgetname 1260# in collect2.c, <fcntl.h> isn't visible, but the configure test below needs 1261# to undef these macros to get the correct value for HAVE_DECL_LDGETNAME. 1262gcc_AC_CHECK_DECLS(ldgetname, , ,[ 1263#include "ansidecl.h" 1264#include "system.h" 1265#ifdef HAVE_LDFCN_H 1266#undef FREAD 1267#undef FWRITE 1268#include <ldfcn.h> 1269#endif 1270]) 1271 1272gcc_AC_CHECK_DECLS(times, , ,[ 1273#include "ansidecl.h" 1274#include "system.h" 1275#ifdef HAVE_SYS_TIMES_H 1276#include <sys/times.h> 1277#endif 1278]) 1279 1280gcc_AC_CHECK_DECLS(sigaltstack, , ,[ 1281#include "ansidecl.h" 1282#include "system.h" 1283#include <signal.h> 1284]) 1285 1286# g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which hides the madvise() 1287# prototype. 1288AC_LANG_PUSH([C++]) 1289gcc_AC_CHECK_DECLS(madvise, , ,[ 1290 #include "ansidecl.h" 1291 #include "system.h" 1292]) 1293AC_LANG_POP([C++]) 1294 1295# More time-related stuff. 1296AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [ 1297AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 1298#include "ansidecl.h" 1299#include "system.h" 1300#ifdef HAVE_SYS_TIMES_H 1301#include <sys/times.h> 1302#endif 1303]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])]) 1304if test $ac_cv_struct_tms = yes; then 1305 AC_DEFINE(HAVE_STRUCT_TMS, 1, 1306 [Define if <sys/times.h> defines struct tms.]) 1307fi 1308 1309# use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE. 1310# revisit after autoconf 2.50. 1311AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [ 1312AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 1313#include "ansidecl.h" 1314#include "system.h" 1315]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])]) 1316if test $gcc_cv_type_clock_t = yes; then 1317 AC_DEFINE(HAVE_CLOCK_T, 1, 1318 [Define if <time.h> defines clock_t.]) 1319fi 1320 1321# Check if F_SETLKW is supported by fcntl. 1322AC_CACHE_CHECK(for F_SETLKW, ac_cv_f_setlkw, [ 1323AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ 1324#include <fcntl.h>]], [[ 1325struct flock fl; 1326fl.l_whence = 0; 1327fl.l_start = 0; 1328fl.l_len = 0; 1329fl.l_pid = 0; 1330return fcntl (1, F_SETLKW, &fl);]])], 1331[ac_cv_f_setlkw=yes],[ac_cv_f_setlkw=no])]) 1332if test $ac_cv_f_setlkw = yes; then 1333 AC_DEFINE(HOST_HAS_F_SETLKW, 1, 1334 [Define if F_SETLKW supported by fcntl.]) 1335fi 1336 1337# Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests. 1338CFLAGS="$saved_CFLAGS" 1339CXXFLAGS="$saved_CXXFLAGS" 1340 1341# mkdir takes a single argument on some systems. 1342gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG 1343 1344# File extensions 1345manext='.1' 1346objext='.o' 1347AC_SUBST(manext) 1348AC_SUBST(objext) 1349 1350# With Setjmp/Longjmp based exception handling. 1351AC_ARG_ENABLE(sjlj-exceptions, 1352[AS_HELP_STRING([--enable-sjlj-exceptions], 1353 [arrange to use setjmp/longjmp exception handling])], 1354[case $target in 1355 *-*-hpux10*) 1356 if test $enableval != yes; then 1357 AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced]) 1358 enableval=yes 1359 fi 1360 ;; 1361esac 1362force_sjlj_exceptions=yes], 1363[case $target in 1364 *-*-hpux10*) 1365 force_sjlj_exceptions=yes 1366 enableval=yes 1367 ;; 1368 lm32*-*-*) 1369 force_sjlj_exceptions=yes 1370 enableval=yes 1371 ;; 1372 *) 1373 force_sjlj_exceptions=no 1374 ;; 1375esac]) 1376if test $force_sjlj_exceptions = yes; then 1377 sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi` 1378 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj, 1379 [Define 0/1 to force the choice for exception handling model.]) 1380fi 1381 1382# -------------------------------------------------------- 1383# Build, host, and target specific configuration fragments 1384# -------------------------------------------------------- 1385 1386# Collect build-machine-specific information. 1387. ${srcdir}/config.build 1388 1389# Collect host-machine-specific information. 1390. ${srcdir}/config.host 1391 1392target_gtfiles= 1393 1394# Collect target-machine-specific information. 1395. ${srcdir}/config.gcc 1396 1397extra_objs="${host_extra_objs} ${extra_objs}" 1398extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}" 1399 1400# Default the target-machine variables that were not explicitly set. 1401if test x"$tm_file" = x 1402then tm_file=$cpu_type/$cpu_type.h; fi 1403 1404if test x"$extra_headers" = x 1405then extra_headers=; fi 1406 1407if test x$md_file = x 1408then md_file=$cpu_type/$cpu_type.md; fi 1409 1410if test x$out_file = x 1411then out_file=$cpu_type/$cpu_type.c; fi 1412 1413if test x"$tmake_file" = x 1414then tmake_file=$cpu_type/t-$cpu_type 1415fi 1416 1417# Support --enable-initfini-array. 1418if test x$enable_initfini_array != xno; then 1419 tm_file="${tm_file} initfini-array.h" 1420fi 1421 1422if test x"$dwarf2" = xyes 1423then tm_file="$tm_file tm-dwarf2.h" 1424fi 1425 1426# Say what files are being used for the output code and MD file. 1427echo "Using \`$srcdir/config/$out_file' for machine-specific logic." 1428echo "Using \`$srcdir/config/$md_file' as machine description file." 1429 1430# If any of the xm_file variables contain nonexistent files, warn 1431# about them and drop them. 1432 1433bx= 1434for x in $build_xm_file; do 1435 if test -f $srcdir/config/$x 1436 then bx="$bx $x" 1437 else AC_MSG_WARN($srcdir/config/$x does not exist.) 1438 fi 1439done 1440build_xm_file="$bx" 1441 1442hx= 1443for x in $host_xm_file; do 1444 if test -f $srcdir/config/$x 1445 then hx="$hx $x" 1446 else AC_MSG_WARN($srcdir/config/$x does not exist.) 1447 fi 1448done 1449host_xm_file="$hx" 1450 1451tx= 1452for x in $xm_file; do 1453 if test -f $srcdir/config/$x 1454 then tx="$tx $x" 1455 else AC_MSG_WARN($srcdir/config/$x does not exist.) 1456 fi 1457done 1458xm_file="$tx" 1459 1460count=a 1461for f in $tm_file; do 1462 count=${count}x 1463done 1464if test $count = ax; then 1465 echo "Using \`$srcdir/config/$tm_file' as target machine macro file." 1466else 1467 echo "Using the following target machine macro files:" 1468 for f in $tm_file; do 1469 echo " $srcdir/config/$f" 1470 done 1471fi 1472 1473if test x$use_long_long_for_widest_fast_int = xyes; then 1474 AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1, 1475[Define to 1 if the 'long long' type is wider than 'long' but still 1476efficiently supported by the host hardware.]) 1477fi 1478 1479gnu_ld_bool=`if test x"$gnu_ld" = x"yes"; then echo 1; else echo 0; fi` 1480AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld_bool, [Define to 1 if using GNU ld.]) 1481 1482gnu_as_bool=`if test x"$gas" = x"yes"; then echo 1; else echo 0; fi` 1483AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as_bool, [Define to 1 if using GNU as.]) 1484 1485count=a 1486for f in $host_xm_file; do 1487 count=${count}x 1488done 1489if test $count = a; then 1490 : 1491elif test $count = ax; then 1492 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file." 1493else 1494 echo "Using the following host machine macro files:" 1495 for f in $host_xm_file; do 1496 echo " $srcdir/config/$f" 1497 done 1498fi 1499echo "Using ${out_host_hook_obj} for host machine hooks." 1500 1501if test "$host_xm_file" != "$build_xm_file"; then 1502 count=a 1503 for f in $build_xm_file; do 1504 count=${count}x 1505 done 1506 if test $count = a; then 1507 : 1508 elif test $count = ax; then 1509 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file." 1510 else 1511 echo "Using the following build machine macro files:" 1512 for f in $build_xm_file; do 1513 echo " $srcdir/config/$f" 1514 done 1515 fi 1516fi 1517 1518if test -n "$configured_native_system_header_dir"; then 1519 native_system_header_dir=$configured_native_system_header_dir 1520fi 1521NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir" 1522AC_SUBST(NATIVE_SYSTEM_HEADER_DIR) 1523 1524case ${host} in 1525 powerpc*-*-darwin*) 1526 AC_CACHE_CHECK([whether mcontext_t fields have underscores], 1527 gcc_cv_mcontext_underscores, 1528 AC_COMPILE_IFELSE([ 1529#include <sys/cdefs.h> 1530#include <sys/signal.h> 1531#include <ucontext.h> 1532int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; } 1533], 1534 gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes)) 1535 if test $gcc_cv_mcontext_underscores = yes; then 1536 AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl 1537 [mcontext_t fields start with __]) 1538 fi 1539 ;; 1540esac 1541 1542# --------- 1543# Threading 1544# --------- 1545 1546# Check if a valid thread package 1547case ${enable_threads} in 1548 "" | no) 1549 # No threads 1550 target_thread_file='single' 1551 ;; 1552 yes) 1553 # default 1554 target_thread_file='single' 1555 ;; 1556 aix | dce | haiku | lynx | mipssde | posix | rtems | \ 1557 single | tpf | vxworks | win32) 1558 target_thread_file=${enable_threads} 1559 ;; 1560 *) 1561 echo "${enable_threads} is an unknown thread package" 1>&2 1562 exit 1 1563 ;; 1564esac 1565 1566if test x${thread_file} = x; then 1567 # No thread file set by target-specific clauses in config.gcc, 1568 # so use file chosen by default logic above 1569 thread_file=${target_thread_file} 1570fi 1571 1572# -------- 1573# UNSORTED 1574# -------- 1575 1576use_cxa_atexit=no 1577if test x$enable___cxa_atexit = xyes || \ 1578 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then 1579 if test x$host = x$target; then 1580 case $host in 1581 # mingw32 doesn't have __cxa_atexit but uses atexit registration 1582 # keyed to flag_use_cxa_atexit 1583 *-*-mingw32*) 1584 use_cxa_atexit=yes 1585 ;; 1586 powerpc-ibm-aix*) 1587 use_cxa_atexit=yes 1588 ;; 1589 *) 1590 AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes], 1591 [echo "__cxa_atexit can't be enabled on this target"]) 1592 ;; 1593 esac 1594 else 1595 # We can't check for __cxa_atexit when building a cross, so assume 1596 # it is available 1597 use_cxa_atexit=yes 1598 fi 1599 if test x$use_cxa_atexit = xyes; then 1600 AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2, 1601 [Define if you want to use __cxa_atexit, rather than atexit, to 1602 register C++ destructors for local statics and global objects. 1603 This is essential for fully standards-compliant handling of 1604 destructors, but requires __cxa_atexit in libc.]) 1605 fi 1606fi 1607 1608# Look for a file containing extra machine modes. 1609if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then 1610 extra_modes_file='$(srcdir)'/config/${extra_modes} 1611 AC_SUBST(extra_modes_file) 1612 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes", 1613 [Define to the name of a file containing a list of extra machine modes 1614 for this architecture.]) 1615fi 1616 1617# Convert extra_options into a form suitable for Makefile use. 1618extra_opt_files= 1619all_opt_files= 1620for f in $extra_options; do 1621 extra_opt_files="$extra_opt_files \$(srcdir)/config/$f" 1622 all_opt_files="$all_opt_files $srcdir/config/$f" 1623done 1624AC_SUBST(extra_opt_files) 1625 1626# auto-host.h is the file containing items generated by autoconf and is 1627# the first file included by config.h. 1628# If host=build, it is correct to have bconfig include auto-host.h 1629# as well. If host!=build, we are in error and need to do more 1630# work to find out the build config parameters. 1631if test x$host = x$build 1632then 1633 build_auto=auto-host.h 1634else 1635 # We create a subdir, then run autoconf in the subdir. 1636 # To prevent recursion we set host and build for the new 1637 # invocation of configure to the build for this invocation 1638 # of configure. 1639 tempdir=build.$$ 1640 rm -rf $tempdir 1641 mkdir $tempdir 1642 cd $tempdir 1643 case ${srcdir} in 1644 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};; 1645 *) realsrcdir=../${srcdir};; 1646 esac 1647 # Clearing GMPINC is necessary to prevent host headers being 1648 # used by the build compiler. Defining GENERATOR_FILE stops 1649 # system.h from including gmp.h. 1650 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \ 1651 CXX="${CXX_FOR_BUILD}" CXXFLAGS="${CXXFLAGS_FOR_BUILD}" \ 1652 LD="${LD_FOR_BUILD}" LDFLAGS="${LDFLAGS_FOR_BUILD}" \ 1653 GMPINC="" CPPFLAGS="${CPPFLAGS} -DGENERATOR_FILE" \ 1654 ${realsrcdir}/configure \ 1655 --enable-languages=${enable_languages-all} \ 1656 --target=$target_alias --host=$build_alias --build=$build_alias 1657 1658 # We just finished tests for the build machine, so rename 1659 # the file auto-build.h in the gcc directory. 1660 mv auto-host.h ../auto-build.h 1661 cd .. 1662 rm -rf $tempdir 1663 build_auto=auto-build.h 1664fi 1665AC_SUBST(build_subdir) 1666 1667tm_file="${tm_file} defaults.h" 1668tm_p_file="${tm_p_file} tm-preds.h" 1669host_xm_file="auto-host.h ansidecl.h ${host_xm_file}" 1670build_xm_file="${build_auto} ansidecl.h ${build_xm_file}" 1671# We don't want ansidecl.h in target files, write code there in ISO/GNU C. 1672# put this back in temporarily. 1673xm_file="auto-host.h ansidecl.h ${xm_file}" 1674 1675# -------- 1676# UNSORTED 1677# -------- 1678 1679changequote(,)dnl 1680# Compile in configure arguments. 1681if test -f configargs.h ; then 1682 # Being re-configured. 1683 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'` 1684 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS" 1685else 1686 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS" 1687fi 1688 1689# Double all backslashes and backslash all quotes to turn 1690# gcc_config_arguments into a C string. 1691sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out 1692$gcc_config_arguments 1693EOF 1694gcc_config_arguments_str=`cat conftest.out` 1695rm -f conftest.out 1696 1697cat > configargs.h <<EOF 1698/* Generated automatically. */ 1699static const char configuration_arguments[] = "$gcc_config_arguments_str"; 1700static const char thread_model[] = "$thread_file"; 1701 1702static const struct { 1703 const char *name, *value; 1704} configure_default_options[] = $configure_default_options; 1705EOF 1706changequote([,])dnl 1707 1708changequote(,)dnl 1709gcc_BASEVER=`cat $srcdir/BASE-VER` 1710gcc_DEVPHASE=`cat $srcdir/DEV-PHASE` 1711gcc_DATESTAMP=`cat $srcdir/DATESTAMP` 1712if test -f $srcdir/REVISION ; then 1713 gcc_REVISION=`cat $srcdir/REVISION` 1714else 1715 gcc_REVISION="" 1716fi 1717cat > plugin-version.h <<EOF 1718#include "configargs.h" 1719 1720#define GCCPLUGIN_VERSION_MAJOR `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'` 1721#define GCCPLUGIN_VERSION_MINOR `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'` 1722#define GCCPLUGIN_VERSION_PATCHLEVEL `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'` 1723#define GCCPLUGIN_VERSION (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR) 1724 1725static char basever[] = "$gcc_BASEVER"; 1726static char datestamp[] = "$gcc_DATESTAMP"; 1727static char devphase[] = "$gcc_DEVPHASE"; 1728static char revision[] = "$gcc_REVISION"; 1729 1730/* FIXME plugins: We should make the version information more precise. 1731 One way to do is to add a checksum. */ 1732 1733static struct plugin_gcc_version gcc_version = {basever, datestamp, 1734 devphase, revision, 1735 configuration_arguments}; 1736EOF 1737changequote([,])dnl 1738 1739# Internationalization 1740ZW_GNU_GETTEXT_SISTER_DIR 1741 1742# If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get 1743# -liconv on the link line twice. 1744case "$LIBINTL" in *$LIBICONV*) 1745 LIBICONV= ;; 1746esac 1747 1748AC_ARG_ENABLE(secureplt, 1749[AS_HELP_STRING([--enable-secureplt], 1750 [enable -msecure-plt by default for PowerPC])], 1751[], []) 1752 1753AC_ARG_ENABLE(leading-mingw64-underscores, 1754 AS_HELP_STRING([--enable-leading-mingw64-underscores], 1755 [enable leading underscores on 64 bit mingw targets]), 1756 [],[]) 1757AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ], 1758 [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1, 1759 [Define if we should use leading underscore on 64 bit mingw targets])]) 1760 1761AC_ARG_ENABLE(cld, 1762[AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [], 1763[enable_cld=no]) 1764 1765AC_ARG_ENABLE(frame-pointer, 1766[AS_HELP_STRING([--enable-frame-pointer], 1767 [enable -fno-omit-frame-pointer by default for 32bit x86])], [], 1768[ 1769case $target_os in 1770linux* | darwin[[8912]]*) 1771 # Enable -fomit-frame-pointer by default for Linux and Darwin with 1772 # DWARF2. 1773 enable_frame_pointer=no 1774 ;; 1775*) 1776 enable_frame_pointer=yes 1777 ;; 1778esac 1779]) 1780 1781# Windows32 Registry support for specifying GCC installation paths. 1782AC_ARG_ENABLE(win32-registry, 1783[AS_HELP_STRING([--disable-win32-registry], 1784 [disable lookup of installation paths in the 1785 Registry on Windows hosts]) 1786AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)]) 1787AS_HELP_STRING([--enable-win32-registry=KEY], 1788 [use KEY instead of GCC version as the last portion 1789 of the registry key])],,) 1790 1791case $host_os in 1792 win32 | pe | cygwin* | mingw32* | uwin*) 1793 if test "x$enable_win32_registry" != xno; then 1794 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no]) 1795 fi 1796 1797 if test "x$enable_win32_registry" != xno; then 1798 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1, 1799 [Define to 1 if installation paths should be looked up in the Windows 1800 Registry. Ignored on non-Windows hosts.]) 1801 1802 if test "x$enable_win32_registry" != xyes \ 1803 && test "x$enable_win32_registry" != x; then 1804 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry", 1805 [Define to be the last component of the Windows registry key under which 1806 to look for installation paths. The full key used will be 1807 HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}. 1808 The default is the GCC version number.]) 1809 fi 1810 fi 1811 ;; 1812esac 1813 1814# Get an absolute path to the GCC top-level source directory 1815holddir=`${PWDCMD-pwd}` 1816cd $srcdir 1817topdir=`${PWDCMD-pwd}` 1818cd $holddir 1819 1820# Conditionalize the makefile for this host machine. 1821xmake_file= 1822for f in ${host_xmake_file} 1823do 1824 if test -f ${srcdir}/config/$f 1825 then 1826 xmake_file="${xmake_file} \$(srcdir)/config/$f" 1827 fi 1828done 1829 1830# Conditionalize the makefile for this target machine. 1831tmake_file_= 1832for f in ${tmake_file} 1833do 1834 if test -f ${srcdir}/config/$f 1835 then 1836 tmake_file_="${tmake_file_} \$(srcdir)/config/$f" 1837 fi 1838done 1839tmake_file="${tmake_file_}" 1840 1841out_object_file=`basename $out_file .c`.o 1842common_out_object_file=`basename $common_out_file .c`.o 1843 1844tm_file_list="options.h" 1845tm_include_list="options.h insn-constants.h" 1846for f in $tm_file; do 1847 case $f in 1848 ./* ) 1849 f=`echo $f | sed 's/^..//'` 1850 tm_file_list="${tm_file_list} $f" 1851 tm_include_list="${tm_include_list} $f" 1852 ;; 1853 defaults.h ) 1854 tm_file_list="${tm_file_list} \$(srcdir)/$f" 1855 tm_include_list="${tm_include_list} $f" 1856 ;; 1857 * ) 1858 tm_file_list="${tm_file_list} \$(srcdir)/config/$f" 1859 tm_include_list="${tm_include_list} config/$f" 1860 ;; 1861 esac 1862done 1863 1864tm_p_file_list= 1865tm_p_include_list= 1866for f in $tm_p_file; do 1867 case $f in 1868 tm-preds.h ) 1869 tm_p_file_list="${tm_p_file_list} $f" 1870 tm_p_include_list="${tm_p_include_list} $f" 1871 ;; 1872 * ) 1873 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f" 1874 tm_p_include_list="${tm_p_include_list} config/$f" 1875 esac 1876done 1877 1878xm_file_list= 1879xm_include_list= 1880for f in $xm_file; do 1881 case $f in 1882 ansidecl.h ) 1883 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f" 1884 xm_include_list="${xm_include_list} $f" 1885 ;; 1886 auto-host.h ) 1887 xm_file_list="${xm_file_list} $f" 1888 xm_include_list="${xm_include_list} $f" 1889 ;; 1890 * ) 1891 xm_file_list="${xm_file_list} \$(srcdir)/config/$f" 1892 xm_include_list="${xm_include_list} config/$f" 1893 ;; 1894 esac 1895done 1896 1897host_xm_file_list= 1898host_xm_include_list= 1899for f in $host_xm_file; do 1900 case $f in 1901 ansidecl.h ) 1902 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f" 1903 host_xm_include_list="${host_xm_include_list} $f" 1904 ;; 1905 auto-host.h ) 1906 host_xm_file_list="${host_xm_file_list} $f" 1907 host_xm_include_list="${host_xm_include_list} $f" 1908 ;; 1909 * ) 1910 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f" 1911 host_xm_include_list="${host_xm_include_list} config/$f" 1912 ;; 1913 esac 1914done 1915 1916build_xm_file_list= 1917for f in $build_xm_file; do 1918 case $f in 1919 ansidecl.h ) 1920 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f" 1921 build_xm_include_list="${build_xm_include_list} $f" 1922 ;; 1923 auto-build.h | auto-host.h ) 1924 build_xm_file_list="${build_xm_file_list} $f" 1925 build_xm_include_list="${build_xm_include_list} $f" 1926 ;; 1927 * ) 1928 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f" 1929 build_xm_include_list="${build_xm_include_list} config/$f" 1930 ;; 1931 esac 1932done 1933 1934# Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a 1935# cross-compiler which does not use the native headers and libraries. 1936# Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR. 1937CROSS= AC_SUBST(CROSS) 1938ALL=all.internal AC_SUBST(ALL) 1939SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR) 1940 1941if test "x$with_build_sysroot" != x; then 1942 build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)' 1943else 1944 # This value is used, even on a native system, because 1945 # CROSS_SYSTEM_HEADER_DIR is just 1946 # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR). 1947 build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)' 1948fi 1949 1950if test x$host != x$target 1951then 1952 CROSS="-DCROSS_DIRECTORY_STRUCTURE" 1953 ALL=all.cross 1954 SYSTEM_HEADER_DIR=$build_system_header_dir 1955 case "$host","$target" in 1956 # Darwin crosses can use the host system's libraries and headers, 1957 # because of the fat library support. Of course, it must be the 1958 # same version of Darwin on both sides. Allow the user to 1959 # just say --target=foo-darwin without a version number to mean 1960 # "the version on this system". 1961 *-*-darwin*,*-*-darwin*) 1962 hostos=`echo $host | sed 's/.*-darwin/darwin/'` 1963 targetos=`echo $target | sed 's/.*-darwin/darwin/'` 1964 if test $hostos = $targetos -o $targetos = darwin ; then 1965 CROSS= 1966 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' 1967 with_headers=yes 1968 fi 1969 ;; 1970 1971 i?86-*-*,x86_64-*-* \ 1972 | powerpc*-*-*,powerpc64*-*-*) 1973 CROSS="$CROSS -DNATIVE_CROSS" ;; 1974 esac 1975 1976 case $target in 1977 *-*-mingw*) 1978 if test "x$with_headers" = x; then 1979 with_headers=yes 1980 fi 1981 ;; 1982 *) 1983 ;; 1984 esac 1985elif test "x$TARGET_SYSTEM_ROOT" != x; then 1986 SYSTEM_HEADER_DIR=$build_system_header_dir 1987fi 1988 1989if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then 1990 if test "x$with_headers" != x; then 1991 target_header_dir=$with_headers 1992 elif test "x$with_sysroot" = x; then 1993 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include" 1994 elif test "x$with_build_sysroot" != "x"; then 1995 target_header_dir="${with_build_sysroot}${native_system_header_dir}" 1996 elif test "x$with_sysroot" = xyes; then 1997 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}" 1998 else 1999 target_header_dir="${with_sysroot}${native_system_header_dir}" 2000 fi 2001else 2002 target_header_dir=${native_system_header_dir} 2003fi 2004 2005# If this is a cross-compiler that does not 2006# have its own set of headers then define 2007# inhibit_libc 2008 2009# If this is using newlib, without having the headers available now, 2010# then define inhibit_libc in LIBGCC2_CFLAGS. 2011# This prevents libgcc2 from containing any code which requires libc 2012# support. 2013: ${inhibit_libc=false} 2014if { { test x$host != x$target && test "x$with_sysroot" = x ; } || 2015 test x$with_newlib = xyes ; } && 2016 { test "x$with_headers" = xno || test ! -f "$target_header_dir/stdio.h"; } ; then 2017 inhibit_libc=true 2018fi 2019AC_SUBST(inhibit_libc) 2020 2021# When building gcc with a cross-compiler, we need to adjust things so 2022# that the generator programs are still built with the native compiler. 2023# Also, we cannot run fixincludes. 2024 2025# These are the normal (build=host) settings: 2026CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD) 2027CXX_FOR_BUILD='$(CXX)' AC_SUBST(CXX_FOR_BUILD) 2028BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS) 2029BUILD_CXXFLAGS='$(ALL_CXXFLAGS)' AC_SUBST(BUILD_CXXFLAGS) 2030BUILD_LDFLAGS='$(LDFLAGS)' AC_SUBST(BUILD_LDFLAGS) 2031STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC) 2032 2033# And these apply if build != host, or we are generating coverage data 2034if test x$build != x$host || test "x$coverage_flags" != x 2035then 2036 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)' 2037 BUILD_CXXFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CXXFLAGS_FOR_BUILD)' 2038 BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)' 2039fi 2040 2041# Expand extra_headers to include complete path. 2042# This substitutes for lots of t-* files. 2043extra_headers_list= 2044# Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers. 2045for file in ${extra_headers} ; do 2046 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}" 2047done 2048 2049# If use_gcc_tgmath is set, append ginclude/tgmath.h. 2050if test x"$use_gcc_tgmath" = xyes 2051then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h" 2052fi 2053 2054# Define collect2 in Makefile. 2055case $host_can_use_collect2 in 2056 no) collect2= ;; 2057 *) collect2='collect2$(exeext)' ;; 2058esac 2059AC_SUBST([collect2]) 2060 2061# Add a definition of USE_COLLECT2 if system wants one. 2062case $use_collect2 in 2063 no) use_collect2= ;; 2064 "") ;; 2065 *) 2066 host_xm_defines="${host_xm_defines} USE_COLLECT2" 2067 xm_defines="${xm_defines} USE_COLLECT2" 2068 case $host_can_use_collect2 in 2069 no) 2070 AC_MSG_ERROR([collect2 is required but cannot be built on this system]) 2071 ;; 2072 esac 2073 ;; 2074esac 2075 2076AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}", 2077[Define to the name of the LTO plugin DSO that must be 2078 passed to the linker's -plugin=LIB option.]) 2079 2080# --------------------------- 2081# Assembler & linker features 2082# --------------------------- 2083 2084# During stage 2, ld is actually gcc/collect-ld, which is a small script to 2085# discern between when to use prev-ld/ld-new and when to use ld/ld-new. 2086# However when ld-new is first executed from the build tree, libtool will 2087# relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers 2088# to the build tree. While doing this we need to use the previous-stage 2089# linker, or we have an infinite loop. The presence of a shell script as 2090# ld/ld-new, and the fact that the script *uses ld itself*, is what confuses 2091# the gcc/collect-ld script. So we need to know how libtool works, or 2092# exec-tool will fail. 2093 2094m4_defun([_LT_CONFIG_COMMANDS], []) 2095AC_PROG_LIBTOOL 2096AC_SUBST(objdir) 2097AC_SUBST(enable_fast_install) 2098 2099# Identify the assembler which will work hand-in-glove with the newly 2100# built GCC, so that we can examine its features. This is the assembler 2101# which will be driven by the driver program. 2102# 2103# If build != host, and we aren't building gas in-tree, we identify a 2104# build->target assembler and hope that it will have the same features 2105# as the host->target assembler we'll be using. 2106gcc_cv_gas_major_version= 2107gcc_cv_gas_minor_version= 2108gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas 2109 2110m4_pattern_allow([AS_FOR_TARGET])dnl 2111AS_VAR_SET_IF(gcc_cv_as,, [ 2112if test -x "$DEFAULT_ASSEMBLER"; then 2113 gcc_cv_as="$DEFAULT_ASSEMBLER" 2114elif test -f $gcc_cv_as_gas_srcdir/configure.in \ 2115 && test -f ../gas/Makefile \ 2116 && test x$build = x$host; then 2117 gcc_cv_as=../gas/as-new$build_exeext 2118elif test -x as$build_exeext; then 2119 # Build using assembler in the current directory. 2120 gcc_cv_as=./as$build_exeext 2121elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then 2122 gcc_cv_as="$AS_FOR_TARGET" 2123else 2124 AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET) 2125fi]) 2126 2127ORIGINAL_AS_FOR_TARGET=$gcc_cv_as 2128AC_SUBST(ORIGINAL_AS_FOR_TARGET) 2129case "$ORIGINAL_AS_FOR_TARGET" in 2130 ./as | ./as$build_exeext) ;; 2131 *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;; 2132esac 2133 2134AC_MSG_CHECKING(what assembler to use) 2135if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then 2136 # Single tree build which includes gas. We want to prefer it 2137 # over whatever linker top-level may have detected, since 2138 # we'll use what we're building after installation anyway. 2139 AC_MSG_RESULT(newly built gas) 2140 in_tree_gas=yes 2141 _gcc_COMPUTE_GAS_VERSION 2142 in_tree_gas_is_elf=no 2143 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \ 2144 || (grep 'obj_format = multi' ../gas/Makefile \ 2145 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null 2146 then 2147 in_tree_gas_is_elf=yes 2148 fi 2149else 2150 AC_MSG_RESULT($gcc_cv_as) 2151 in_tree_gas=no 2152fi 2153 2154default_ld= 2155AC_ARG_ENABLE(ld, 2156[[ --enable-ld[=ARG] build ld [ARG={default,yes,no}]]], 2157[case "${enableval}" in 2158 no) 2159 default_ld=ld.gold 2160 ;; 2161 esac]) 2162 2163install_gold_as_default=no 2164AC_ARG_ENABLE(gold, 2165[[ --enable-gold[=ARG] build gold [ARG={default,yes,no}]]], 2166[case "${enableval}" in 2167 default) 2168 install_gold_as_default=yes 2169 ;; 2170 yes) 2171 if test x${default_ld} != x; then 2172 install_gold_as_default=yes 2173 fi 2174 ;; 2175 no) 2176 ;; 2177 *) 2178 AC_MSG_ERROR([invalid --enable-gold argument]) 2179 ;; 2180 esac]) 2181 2182# Identify the linker which will work hand-in-glove with the newly 2183# built GCC, so that we can examine its features. This is the linker 2184# which will be driven by the driver program. 2185# 2186# If build != host, and we aren't building gas in-tree, we identify a 2187# build->target linker and hope that it will have the same features 2188# as the host->target linker we'll be using. 2189gcc_cv_gld_major_version= 2190gcc_cv_gld_minor_version= 2191gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld 2192gcc_cv_ld_gold_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gold 2193gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd 2194 2195AS_VAR_SET_IF(gcc_cv_ld,, [ 2196if test -x "$DEFAULT_LINKER"; then 2197 gcc_cv_ld="$DEFAULT_LINKER" 2198elif test $install_gold_as_default = yes \ 2199 && test -f $gcc_cv_ld_gold_srcdir/configure.ac \ 2200 && test -f ../gold/Makefile \ 2201 && test x$build = x$host; then 2202 gcc_cv_ld=../gold/ld-new$build_exeext 2203elif test -f $gcc_cv_ld_gld_srcdir/configure.in \ 2204 && test -f ../ld/Makefile \ 2205 && test x$build = x$host; then 2206 gcc_cv_ld=../ld/ld-new$build_exeext 2207elif test -x collect-ld$build_exeext; then 2208 # Build using linker in the current directory. 2209 gcc_cv_ld=./collect-ld$build_exeext 2210elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then 2211 gcc_cv_ld="$LD_FOR_TARGET" 2212else 2213 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET) 2214fi]) 2215 2216ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld 2217PLUGIN_LD_SUFFIX=`basename $gcc_cv_ld | sed -e "s,$target_alias-,,"` 2218# if the PLUGIN_LD is set ld-new, just have it as ld 2219# as that is the installed named. 2220if test x$PLUGIN_LD_SUFFIX = xld-new \ 2221 || test x$PLUGIN_LD_SUFFIX = xcollect-ld ; then 2222 PLUGIN_LD_SUFFIX=ld 2223fi 2224AC_ARG_WITH(plugin-ld, 2225[AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])], 2226[if test x"$withval" != x; then 2227 ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval" 2228 PLUGIN_LD_SUFFIX="$withval" 2229 fi]) 2230AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET) 2231AC_DEFINE_UNQUOTED(PLUGIN_LD_SUFFIX, "$PLUGIN_LD_SUFFIX", [Specify plugin linker]) 2232 2233# Check to see if we are using gold instead of ld 2234AC_MSG_CHECKING(whether we are using gold) 2235ld_is_gold=no 2236if test x$gcc_cv_ld != x; then 2237 if $gcc_cv_ld --version 2>/dev/null | sed 1q \ 2238 | grep "GNU gold" > /dev/null; then 2239 ld_is_gold=yes 2240 fi 2241fi 2242AC_MSG_RESULT($ld_is_gold) 2243 2244ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld 2245AC_SUBST(ORIGINAL_LD_FOR_TARGET) 2246case "$ORIGINAL_LD_FOR_TARGET" in 2247 ./collect-ld | ./collect-ld$build_exeext) ;; 2248 *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;; 2249esac 2250 2251AC_MSG_CHECKING(what linker to use) 2252if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \ 2253 || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then 2254 # Single tree build which includes ld. We want to prefer it 2255 # over whatever linker top-level may have detected, since 2256 # we'll use what we're building after installation anyway. 2257 AC_MSG_RESULT(newly built ld) 2258 in_tree_ld=yes 2259 in_tree_ld_is_elf=no 2260 if (grep 'EMUL = .*elf' ../ld/Makefile \ 2261 || grep 'EMUL = .*linux' ../ld/Makefile \ 2262 || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then 2263 in_tree_ld_is_elf=yes 2264 elif test "$ld_is_gold" = yes; then 2265 in_tree_ld_is_elf=yes 2266 fi 2267 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 2268 do 2269changequote(,)dnl 2270 gcc_cv_gld_version=`sed -n -e 's/^[ ]*VERSION=[^0-9A-Za-z_]*\([0-9]*\.[0-9]*.*\)/VERSION=\1/p' < $f` 2271 if test x$gcc_cv_gld_version != x; then 2272 break 2273 fi 2274 done 2275 case $gcc_cv_gld_version in 2276 VERSION=[0-9]*) ;; 2277changequote([,])dnl 2278 *) AC_MSG_ERROR([[cannot find version of in-tree linker]]) ;; 2279changequote(,)dnl 2280 esac 2281 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"` 2282 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"` 2283changequote([,])dnl 2284 ORIGINAL_LD_BFD_FOR_TARGET=../ld/ld-new$build_exeext 2285 ORIGINAL_LD_GOLD_FOR_TARGET=../gold/ld-new$build_exeext 2286else 2287 AC_MSG_RESULT($gcc_cv_ld) 2288 in_tree_ld=no 2289 gcc_cvs_ld_program=`dirname $gcc_cv_ld`/`basename $gcc_cv_ld $host_exeext` 2290 ORIGINAL_LD_BFD_FOR_TARGET=${gcc_cvs_ld_program}.bfd$host_exeext 2291 ORIGINAL_LD_GOLD_FOR_TARGET=${gcc_cvs_ld_program}.gold$host_exeext 2292fi 2293 2294AC_SUBST(ORIGINAL_LD_BFD_FOR_TARGET) 2295AC_SUBST(ORIGINAL_LD_GOLD_FOR_TARGET) 2296 2297# Figure out what nm we will be using. 2298gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils 2299AS_VAR_SET_IF(gcc_cv_nm,, [ 2300if test -f $gcc_cv_binutils_srcdir/configure.in \ 2301 && test -f ../binutils/Makefile \ 2302 && test x$build = x$host; then 2303 gcc_cv_nm=../binutils/nm-new$build_exeext 2304elif test -x nm$build_exeext; then 2305 gcc_cv_nm=./nm$build_exeext 2306elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then 2307 gcc_cv_nm="$NM_FOR_TARGET" 2308else 2309 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET) 2310fi]) 2311 2312AC_MSG_CHECKING(what nm to use) 2313if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then 2314 # Single tree build which includes binutils. 2315 AC_MSG_RESULT(newly built nm) 2316 in_tree_nm=yes 2317else 2318 AC_MSG_RESULT($gcc_cv_nm) 2319 in_tree_nm=no 2320fi 2321 2322ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm 2323AC_SUBST(ORIGINAL_NM_FOR_TARGET) 2324case "$ORIGINAL_NM_FOR_TARGET" in 2325 ./nm | ./nm$build_exeext) ;; 2326 *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;; 2327esac 2328 2329 2330# Figure out what objdump we will be using. 2331AS_VAR_SET_IF(gcc_cv_objdump,, [ 2332if test -f $gcc_cv_binutils_srcdir/configure.in \ 2333 && test -f ../binutils/Makefile \ 2334 && test x$build = x$host; then 2335 # Single tree build which includes binutils. 2336 gcc_cv_objdump=../binutils/objdump$build_exeext 2337elif test -x objdump$build_exeext; then 2338 gcc_cv_objdump=./objdump$build_exeext 2339elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then 2340 gcc_cv_objdump="$OBJDUMP_FOR_TARGET" 2341else 2342 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET) 2343fi]) 2344 2345AC_MSG_CHECKING(what objdump to use) 2346if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then 2347 # Single tree build which includes binutils. 2348 AC_MSG_RESULT(newly built objdump) 2349elif test x$gcc_cv_objdump = x; then 2350 AC_MSG_RESULT(not found) 2351else 2352 AC_MSG_RESULT($gcc_cv_objdump) 2353fi 2354 2355# Figure out what readelf we will be using. 2356AS_VAR_SET_IF(gcc_cv_readelf,, [ 2357if test -f $gcc_cv_binutils_srcdir/configure.in \ 2358 && test -f ../binutils/Makefile \ 2359 && test x$build = x$host; then 2360 # Single tree build which includes binutils. 2361 gcc_cv_readelf=../binutils/readelf$build_exeext 2362elif test -x readelf$build_exeext; then 2363 gcc_cv_readelf=./readelf$build_exeext 2364else 2365 AC_PATH_PROG(gcc_cv_readelf, readelf) 2366fi]) 2367 2368AC_MSG_CHECKING(what readelf to use) 2369if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then 2370 # Single tree build which includes binutils. 2371 AC_MSG_RESULT(newly built readelf) 2372elif test x$gcc_cv_readelf = x; then 2373 AC_MSG_RESULT(not found) 2374else 2375 AC_MSG_RESULT($gcc_cv_readelf) 2376fi 2377 2378# Figure out what assembler alignment features are present. 2379gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align, 2380 [2,6,0],, 2381[.balign 4 2382.p2align 2],, 2383[AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1, 2384 [Define if your assembler supports .balign and .p2align.])]) 2385 2386gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align, 2387 [2,8,0],, 2388 [.p2align 4,,7],, 2389[AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1, 2390 [Define if your assembler supports specifying the maximum number 2391 of bytes to skip when using the GAS .p2align command.])]) 2392 2393gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16, 2394 [2,8,0],, 2395 [.literal16],, 2396[AC_DEFINE(HAVE_GAS_LITERAL16, 1, 2397 [Define if your assembler supports .literal16.])]) 2398 2399gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1, 2400 [elf,2,9,0],, 2401 [conftest_label1: .word 0 2402.subsection -1 2403conftest_label2: .word 0 2404.previous], 2405 [if test x$gcc_cv_nm != x; then 2406 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1 2407 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2 2408 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1 2409 then : 2410 else gcc_cv_as_subsection_m1=yes 2411 fi 2412 rm -f conftest.nm1 conftest.nm2 2413 fi], 2414 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1, 2415 [Define if your assembler supports .subsection and .subsection -1 starts 2416 emitting at the beginning of your section.])]) 2417 2418gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak, 2419 [2,2,0],, 2420 [ .weak foobar],, 2421[AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])]) 2422 2423gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref, 2424 [2,17,0],, 2425 [ .weakref foobar, barfnot],, 2426[AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])]) 2427 2428gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat, 2429 [2,15,91],, 2430 [ .SPACE $TEXT$ 2431 .NSUBSPA $CODE$,COMDAT],, 2432[AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])]) 2433 2434# .hidden needs to be supported in both the assembler and the linker, 2435# because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN. 2436# This is irritatingly difficult to feature test for; we have to check the 2437# date string after the version number. If we've got an in-tree 2438# ld, we don't know its patchlevel version, so we set the baseline at 2.13 2439# to be safe. 2440# The gcc_GAS_CHECK_FEATURE call just sets a cache variable. 2441gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden, 2442 [elf,2,13,0],, 2443[ .hidden foobar 2444foobar:]) 2445case "${target}" in 2446 *-*-darwin*) 2447 # Darwin as has some visibility support, though with a different syntax. 2448 gcc_cv_as_hidden=yes 2449 ;; 2450esac 2451 2452# gnu_indirect_function type is an extension proposed at 2453# http://groups.google/com/group/generic-abi/files. It allows dynamic runtime 2454# selection of function implementation 2455AC_ARG_ENABLE(gnu-indirect-function, 2456 [AS_HELP_STRING([--enable-gnu-indirect-function], 2457 [enable the use of the @gnu_indirect_function to glibc systems])], 2458 [case $enable_gnu_indirect_function in 2459 yes | no) ;; 2460 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function. 2461Valid choices are 'yes' and 'no'.]) ;; 2462 esac], 2463 [enable_gnu_indirect_function="$default_gnu_indirect_function"]) 2464 2465gif=`if test x$enable_gnu_indirect_function = xyes; then echo 1; else echo 0; fi` 2466AC_DEFINE_UNQUOTED(HAVE_GNU_INDIRECT_FUNCTION, $gif, 2467[Define if your system supports gnu indirect functions.]) 2468 2469 2470changequote(,)dnl 2471if test $in_tree_ld != yes ; then 2472 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q` 2473 if echo "$ld_ver" | grep GNU > /dev/null; then 2474 if test x"$ld_is_gold" = xyes; then 2475 # GNU gold --version looks like this: 2476 # 2477 # GNU gold (GNU Binutils 2.21.51.20110225) 1.11 2478 # 2479 # We extract the binutils version which is more familiar and specific 2480 # than the gold version. 2481 ld_vers=`echo $ld_ver | sed -n \ 2482 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'` 2483 else 2484 # GNU ld --version looks like this: 2485 # 2486 # GNU ld (GNU Binutils) 2.21.51.20110225 2487 ld_vers=`echo $ld_ver | sed -n \ 2488 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'` 2489 fi 2490 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'` 2491 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'` 2492 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'` 2493 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'` 2494 else 2495 case "${target}" in 2496 *-*-solaris2*) 2497 # See acinclude.m4 (gcc_SUN_LD_VERSION) for the version number 2498 # format. 2499 # 2500 # Don't reuse gcc_gv_sun_ld_vers_* in case a linker other than 2501 # /usr/ccs/bin/ld has been configured. 2502 ld_ver=`$gcc_cv_ld -V 2>&1` 2503 if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then 2504 ld_vers=`echo $ld_ver | sed -n \ 2505 -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'` 2506 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'` 2507 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'` 2508 fi 2509 ;; 2510 esac 2511 fi 2512fi 2513changequote([,])dnl 2514 2515AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden, 2516[[if test $in_tree_ld = yes ; then 2517 gcc_cv_ld_hidden=no 2518 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 \ 2519 && test $in_tree_ld_is_elf = yes; then 2520 gcc_cv_ld_hidden=yes 2521 fi 2522else 2523 gcc_cv_ld_hidden=yes 2524 if test x"$ld_is_gold" = xyes; then 2525 : 2526 elif echo "$ld_ver" | grep GNU > /dev/null; then 2527 case "${target}" in 2528 mmix-knuth-mmixware) 2529 # The linker emits by default mmo, not ELF, so "no" is appropriate. 2530 gcc_cv_ld_hidden=no 2531 ;; 2532 esac 2533 if test 0"$ld_date" -lt 20020404; then 2534 if test -n "$ld_date"; then 2535 # If there was date string, but was earlier than 2002-04-04, fail 2536 gcc_cv_ld_hidden=no 2537 elif test -z "$ld_vers"; then 2538 # If there was no date string nor ld version number, something is wrong 2539 gcc_cv_ld_hidden=no 2540 else 2541 test -z "$ld_vers_patch" && ld_vers_patch=0 2542 if test "$ld_vers_major" -lt 2; then 2543 gcc_cv_ld_hidden=no 2544 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then 2545 gcc_cv_ld_hidden="no" 2546 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then 2547 gcc_cv_ld_hidden=no 2548 fi 2549 fi 2550 fi 2551 else 2552 case "${target}" in 2553 *-*-darwin*) 2554 # Darwin ld has some visibility support. 2555 gcc_cv_ld_hidden=yes 2556 ;; 2557 hppa64*-*-hpux* | ia64*-*-hpux*) 2558 gcc_cv_ld_hidden=yes 2559 ;; 2560 *-*-solaris2.1[0-9]*) 2561 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but 2562 # .symbolic was only added in Solaris 9 12/02. 2563 gcc_cv_ld_hidden=yes 2564 ;; 2565 *) 2566 gcc_cv_ld_hidden=no 2567 ;; 2568 esac 2569 fi 2570fi]]) 2571libgcc_visibility=no 2572AC_SUBST(libgcc_visibility) 2573GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN]) 2574if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then 2575 libgcc_visibility=yes 2576 AC_DEFINE(HAVE_GAS_HIDDEN, 1, 2577 [Define if your assembler and linker support .hidden.]) 2578fi 2579 2580AC_MSG_CHECKING(linker read-only and read-write section mixing) 2581gcc_cv_ld_ro_rw_mix=unknown 2582if test $in_tree_ld = yes ; then 2583 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 \ 2584 && test $in_tree_ld_is_elf = yes; then 2585 gcc_cv_ld_ro_rw_mix=read-write 2586 fi 2587elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then 2588 echo '.section myfoosect, "a"' > conftest1.s 2589 echo '.section myfoosect, "aw"' > conftest2.s 2590 echo '.byte 1' >> conftest2.s 2591 echo '.section myfoosect, "a"' > conftest3.s 2592 echo '.byte 0' >> conftest3.s 2593 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \ 2594 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \ 2595 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \ 2596 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \ 2597 conftest2.o conftest3.o > /dev/null 2>&1; then 2598 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \ 2599 | sed -e '/myfoosect/!d' -e N` 2600 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then 2601 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then 2602 gcc_cv_ld_ro_rw_mix=read-only 2603 else 2604 gcc_cv_ld_ro_rw_mix=read-write 2605 fi 2606 fi 2607 fi 2608changequote(,)dnl 2609 rm -f conftest.* conftest[123].* 2610changequote([,])dnl 2611fi 2612if test x$gcc_cv_ld_ro_rw_mix = xread-write; then 2613 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1, 2614 [Define if your linker links a mix of read-only 2615 and read-write sections into a read-write section.]) 2616fi 2617AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix) 2618 2619gcc_AC_INITFINI_ARRAY 2620 2621# Check if we have .[us]leb128, and support symbol arithmetic with it. 2622gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128, 2623 [elf,2,11,0],, 2624[ .data 2625 .uleb128 L2 - L1 2626L1: 2627 .uleb128 1280 2628 .sleb128 -1010 2629L2:], 2630[[# GAS versions before 2.11 do not support uleb128, 2631 # despite appearing to. 2632 # ??? There exists an elf-specific test that will crash 2633 # the assembler. Perhaps it's better to figure out whether 2634 # arbitrary sections are supported and try the test. 2635 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q` 2636 if echo "$as_ver" | grep GNU > /dev/null; then 2637 as_vers=`echo $as_ver | sed -n \ 2638 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'` 2639 as_major=`expr "$as_vers" : '\([0-9]*\)'` 2640 as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'` 2641 if test $as_major -eq 2 && test $as_minor -lt 11 2642 then : 2643 else gcc_cv_as_leb128=yes 2644 fi 2645 fi]], 2646 [AC_DEFINE(HAVE_AS_LEB128, 1, 2647 [Define if your assembler supports .sleb128 and .uleb128.])]) 2648 2649# Check if we have assembler support for unwind directives. 2650gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive, 2651 ,, 2652[ .text 2653 .cfi_startproc 2654 .cfi_offset 0, 0 2655 .cfi_same_value 1 2656 .cfi_def_cfa 1, 2 2657 .cfi_escape 1, 2, 3, 4, 5 2658 .cfi_endproc], 2659[case "$target" in 2660 *-*-solaris*) 2661 # If the linker used on Solaris (like Sun ld) isn't capable of merging 2662 # read-only and read-write sections, we need to make sure that the 2663 # assembler used emits read-write .eh_frame sections. 2664 if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then 2665 if test "x$gcc_cv_objdump" != x; then 2666 if $gcc_cv_objdump -h conftest.o 2>/dev/null | \ 2667 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then 2668 gcc_cv_as_cfi_directive=no 2669 else 2670 case "$target" in 2671 i?86-*-solaris2.1[[0-9]]* | x86_64-*-solaris2.1[[0-9]]*) 2672 # On Solaris/x86, make sure that GCC and assembler agree on using 2673 # read-only .eh_frame sections for 64-bit. 2674 if test x$gas = xyes; then 2675 as_ix86_64_opt="--64" 2676 else 2677 as_ix86_64_opt="-xarch=amd64" 2678 fi 2679 if $gcc_cv_as $as_ix86_64_opt -o conftest.o conftest.s > /dev/null 2>&1 && \ 2680 $gcc_cv_objdump -h conftest.o 2>/dev/null | \ 2681 sed -e /.eh_frame/!d -e N | \ 2682 grep READONLY > /dev/null; then 2683 gcc_cv_as_cfi_directive=yes 2684 else 2685 gcc_cv_as_cfi_directive=no 2686 fi 2687 ;; 2688 *) 2689 gcc_cv_as_cfi_directive=yes 2690 ;; 2691 esac 2692 fi 2693 else 2694 # no objdump, err on the side of caution 2695 gcc_cv_as_cfi_directive=no 2696 fi 2697 else 2698 gcc_cv_as_cfi_directive=yes 2699 fi 2700 ;; 2701 *-*-*) 2702 gcc_cv_as_cfi_directive=yes 2703 ;; 2704esac]) 2705if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then 2706gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working, 2707 ,, 2708[ .text 2709 .cfi_startproc 2710 .cfi_adjust_cfa_offset 64 2711 .skip 75040, 0 2712 .cfi_adjust_cfa_offset 128 2713 .cfi_endproc], 2714[[ 2715if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \ 2716 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then 2717 gcc_cv_as_cfi_advance_working=yes 2718fi 2719]]) 2720else 2721 # no objdump, err on the side of caution 2722 gcc_cv_as_cfi_advance_working=no 2723fi 2724GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE) 2725AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE, 2726 [`if test $gcc_cv_as_cfi_directive = yes \ 2727 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`], 2728 [Define 0/1 if your assembler supports CFI directives.]) 2729 2730GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE) 2731gcc_GAS_CHECK_FEATURE([cfi personality directive], 2732 gcc_cv_as_cfi_personality_directive, ,, 2733[ .text 2734 .cfi_startproc 2735 .cfi_personality 0, symbol 2736 .cfi_endproc]) 2737AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE, 2738 [`if test $gcc_cv_as_cfi_personality_directive = yes; 2739 then echo 1; else echo 0; fi`], 2740 [Define 0/1 if your assembler supports .cfi_personality.]) 2741 2742gcc_GAS_CHECK_FEATURE([cfi sections directive], 2743 gcc_cv_as_cfi_sections_directive, ,, 2744[ .text 2745 .cfi_sections .debug_frame, .eh_frame 2746 .cfi_startproc 2747 .cfi_endproc], 2748[case $target_os in 2749 win32 | pe | cygwin* | mingw32* | uwin*) 2750 # Need to check that we generated the correct relocation for the 2751 # .debug_frame section. This was fixed for binutils 2.21. 2752 gcc_cv_as_cfi_sections_directive=no 2753 if test "x$gcc_cv_objdump" != x; then 2754 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \ 2755 grep secrel > /dev/null; then 2756 gcc_cv_as_cfi_sections_directive=yes 2757 fi 2758 fi 2759 ;; 2760 *) 2761 gcc_cv_as_cfi_sections_directive=yes 2762 ;; 2763esac]) 2764GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE) 2765AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE, 2766 [`if test $gcc_cv_as_cfi_sections_directive = yes; 2767 then echo 1; else echo 0; fi`], 2768 [Define 0/1 if your assembler supports .cfi_sections.]) 2769 2770# GAS versions up to and including 2.11.0 may mis-optimize 2771# .eh_frame data. 2772gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame, 2773 [elf,2,12,0],, 2774[ .text 2775.LFB1: 2776 .4byte 0 2777.L1: 2778 .4byte 0 2779.LFE1: 2780 .section .eh_frame,"aw",@progbits 2781__FRAME_BEGIN__: 2782 .4byte .LECIE1-.LSCIE1 2783.LSCIE1: 2784 .4byte 0x0 2785 .byte 0x1 2786 .ascii "z\0" 2787 .byte 0x1 2788 .byte 0x78 2789 .byte 0x1a 2790 .byte 0x0 2791 .byte 0x4 2792 .4byte 1 2793 .p2align 1 2794.LECIE1: 2795.LSFDE1: 2796 .4byte .LEFDE1-.LASFDE1 2797.LASFDE1: 2798 .4byte .LASFDE1-__FRAME_BEGIN__ 2799 .4byte .LFB1 2800 .4byte .LFE1-.LFB1 2801 .byte 0x4 2802 .4byte .LFE1-.LFB1 2803 .byte 0x4 2804 .4byte .L1-.LFB1 2805.LEFDE1:], 2806[ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@. 2807cat > conftest.lit <<EOF 2808 0000 10000000 00000000 017a0001 781a0004 .........z..x... 2809 0010 01000000 12000000 18000000 00000000 ................ 2810 0020 08000000 04080000 0044 .........D @&t@ 2811EOF 2812cat > conftest.big <<EOF 2813 0000 00000010 00000000 017a0001 781a0004 .........z..x... 2814 0010 00000001 00000012 00000018 00000000 ................ 2815 0020 00000008 04000000 0844 .........D @&t@ 2816EOF 2817 # If the assembler didn't choke, and we can objdump, 2818 # and we got the correct data, then succeed. 2819 # The text in the here-document typically retains its unix-style line 2820 # endings, while the output of objdump will use host line endings. 2821 # Therefore, use diff -b for the comparisons. 2822 if test x$gcc_cv_objdump != x \ 2823 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \ 2824 | tail -3 > conftest.got \ 2825 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \ 2826 || diff -b conftest.big conftest.got > /dev/null 2>&1; } 2827 then 2828 gcc_cv_as_eh_frame=yes 2829 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then 2830 gcc_cv_as_eh_frame=buggy 2831 else 2832 # Uh oh, what do we do now? 2833 gcc_cv_as_eh_frame=no 2834 fi]) 2835 2836if test $gcc_cv_as_eh_frame = buggy; then 2837 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1, 2838 [Define if your assembler mis-optimizes .eh_frame data.]) 2839fi 2840 2841gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge, 2842 [elf,2,12,0], [--fatal-warnings], 2843 [.section .rodata.str, "aMS", @progbits, 1]) 2844if test $gcc_cv_as_shf_merge = no; then 2845 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge, 2846 [elf,2,12,0], [--fatal-warnings], 2847 [.section .rodata.str, "aMS", %progbits, 1]) 2848fi 2849AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE, 2850 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`], 2851[Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.]) 2852 2853gcc_GAS_CHECK_FEATURE([stabs directive], gcc_cv_as_stabs_directive, ,, 2854[.stabs "gcc2_compiled.",60,0,0,0],, 2855[AC_DEFINE(HAVE_AS_STABS_DIRECTIVE, 1, 2856 [Define if your assembler supports .stabs.])]) 2857 2858gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)], 2859 gcc_cv_as_comdat_group, 2860 [elf,2,16,0], [--fatal-warnings], 2861 [.section .text,"axG",@progbits,.foo,comdat]) 2862if test $gcc_cv_as_comdat_group = yes; then 2863 gcc_cv_as_comdat_group_percent=no 2864 gcc_cv_as_comdat_group_group=no 2865else 2866 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)], 2867 gcc_cv_as_comdat_group_percent, 2868 [elf,2,16,0], [--fatal-warnings], 2869 [.section .text,"axG",%progbits,.foo,comdat]) 2870 if test $gcc_cv_as_comdat_group_percent = yes; then 2871 gcc_cv_as_comdat_group_group=no 2872 else 2873 case "${target}" in 2874 # Sun as uses a completely different syntax. 2875 *-*-solaris2*) 2876 case "${target}" in 2877 sparc*-*-solaris2*) 2878 conftest_s=' 2879 .group foo,".text%foo",#comdat 2880 .section ".text%foo", #alloc,#execinstr,#progbits 2881 .globl foo 2882 foo: 2883 ' 2884 ;; 2885 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*) 2886 conftest_s=' 2887 .group foo,.text%foo,#comdat 2888 .section .text%foo, "ax", @progbits 2889 .globl foo 2890 foo: 2891 ' 2892 ;; 2893 esac 2894 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)], 2895 gcc_cv_as_comdat_group_group, 2896 ,, [$conftest_s]) 2897 ;; 2898 esac 2899 if test -z "${gcc_cv_as_comdat_group_group+set}"; then 2900 gcc_cv_as_comdat_group_group=no 2901 fi 2902 fi 2903fi 2904if test x"$ld_is_gold" = xyes; then 2905 comdat_group=yes 2906elif test $in_tree_ld = yes ; then 2907 comdat_group=no 2908 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 \ 2909 && test $in_tree_ld_is_elf = yes; then 2910 comdat_group=yes 2911 fi 2912elif echo "$ld_ver" | grep GNU > /dev/null; then 2913 comdat_group=yes 2914 if test 0"$ld_date" -lt 20050308; then 2915 if test -n "$ld_date"; then 2916 # If there was date string, but was earlier than 2005-03-08, fail 2917 comdat_group=no 2918 elif test "$ld_vers_major" -lt 2; then 2919 comdat_group=no 2920 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then 2921 comdat_group=no 2922 fi 2923 fi 2924else 2925changequote(,)dnl 2926 case "${target}" in 2927 *-*-solaris2.1[1-9]*) 2928 comdat_group=no 2929 # Sun ld has COMDAT group support since Solaris 9, but it doesn't 2930 # interoperate with GNU as until Solaris 11 build 130, i.e. ld 2931 # version 1.688. 2932 # 2933 # If using Sun as for COMDAT group as emitted by GCC, one needs at 2934 # least ld version 1.2267. 2935 if test "$ld_vers_major" -gt 1; then 2936 comdat_group=yes 2937 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then 2938 comdat_group=yes 2939 elif test "$ld_vers_minor" -ge 2267; then 2940 comdat_group=yes 2941 fi 2942 ;; 2943 *) 2944 # Assume linkers other than GNU ld don't support COMDAT group. 2945 comdat_group=no 2946 ;; 2947 esac 2948changequote([,])dnl 2949fi 2950# Allow overriding the automatic COMDAT group tests above. 2951AC_ARG_ENABLE(comdat, 2952 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])], 2953 [comdat_group="$enable_comdat"]) 2954if test $comdat_group = no; then 2955 gcc_cv_as_comdat_group=no 2956 gcc_cv_as_comdat_group_percent=no 2957 gcc_cv_as_comdat_group_group=no 2958fi 2959AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP, 2960 [`if test $gcc_cv_as_comdat_group = yes \ 2961 || test $gcc_cv_as_comdat_group_percent = yes \ 2962 || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`], 2963[Define 0/1 if your assembler and linker support COMDAT groups.]) 2964 2965gcc_GAS_CHECK_FEATURE([line table discriminator support], 2966 gcc_cv_as_discriminator, 2967 [2,19,51],, 2968[ .text 2969 .file 1 "conf.c" 2970 .loc 1 1 0 discriminator 1],, 2971[AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1, 2972 [Define if your assembler supports the .loc discriminator sub-directive.])]) 2973 2974# Thread-local storage - the check is heavily parameterized. 2975conftest_s= 2976tls_first_major= 2977tls_first_minor= 2978tls_as_opt= 2979case "$target" in 2980changequote(,)dnl 2981 alpha*-*-*) 2982 conftest_s=' 2983 .section ".tdata","awT",@progbits 2984foo: .long 25 2985 .text 2986 ldq $27,__tls_get_addr($29) !literal!1 2987 lda $16,foo($29) !tlsgd!1 2988 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1 2989 ldq $27,__tls_get_addr($29) !literal!2 2990 lda $16,foo($29) !tlsldm!2 2991 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2 2992 ldq $1,foo($29) !gotdtprel 2993 ldah $2,foo($29) !dtprelhi 2994 lda $3,foo($2) !dtprello 2995 lda $4,foo($29) !dtprel 2996 ldq $1,foo($29) !gottprel 2997 ldah $2,foo($29) !tprelhi 2998 lda $3,foo($2) !tprello 2999 lda $4,foo($29) !tprel' 3000 tls_first_major=2 3001 tls_first_minor=13 3002 tls_as_opt=--fatal-warnings 3003 ;; 3004 cris-*-*|crisv32-*-*) 3005 conftest_s=' 3006 .section ".tdata","awT",@progbits 3007x: .long 25 3008 .text 3009 move.d x:IE,$r10 3010 nop' 3011 tls_first_major=2 3012 tls_first_minor=20 3013 tls_as_opt=--fatal-warnings 3014 ;; 3015 frv*-*-*) 3016 conftest_s=' 3017 .section ".tdata","awT",@progbits 3018x: .long 25 3019 .text 3020 call #gettlsoff(x)' 3021 tls_first_major=2 3022 tls_first_minor=14 3023 ;; 3024 hppa*-*-linux*) 3025 conftest_s=' 3026t1: .reg %r20 3027t2: .reg %r21 3028gp: .reg %r19 3029 .section ".tdata","awT",@progbits 3030foo: .long 25 3031 .text 3032 .align 4 3033 addil LT%foo-$tls_gdidx$,gp 3034 ldo RT%foo-$tls_gdidx$(%r1),%arg0 3035 b __tls_get_addr 3036 nop 3037 addil LT%foo-$tls_ldidx$,gp 3038 b __tls_get_addr 3039 ldo RT%foo-$tls_ldidx$(%r1),%arg0 3040 addil LR%foo-$tls_dtpoff$,%ret0 3041 ldo RR%foo-$tls_dtpoff$(%r1),%t1 3042 mfctl %cr27,%t1 3043 addil LT%foo-$tls_ieoff$,gp 3044 ldw RT%foo-$tls_ieoff$(%r1),%t2 3045 add %t1,%t2,%t3 3046 mfctl %cr27,%t1 3047 addil LR%foo-$tls_leoff$,%t1 3048 ldo RR%foo-$tls_leoff$(%r1),%t2' 3049 tls_first_major=2 3050 tls_first_minor=15 3051 tls_as_opt=--fatal-warnings 3052 ;; 3053 arm*-*-*) 3054 conftest_s=' 3055 .section ".tdata","awT",%progbits 3056foo: .long 25 3057 .text 3058.word foo(gottpoff) 3059.word foo(tpoff) 3060.word foo(tlsgd) 3061.word foo(tlsldm) 3062.word foo(tlsldo)' 3063 tls_first_major=2 3064 tls_first_minor=17 3065 ;; 3066 i[34567]86-*-* | x86_64-*-*) 3067 case "$target" in 3068 i[34567]86-*-solaris2.* | x86_64-*-solaris2.1[0-9]*) 3069 on_solaris=yes 3070 ;; 3071 *) 3072 on_solaris=no 3073 ;; 3074 esac 3075 if test x$on_solaris = xyes && test x$gas_flag = xno; then 3076 conftest_s=' 3077 .section .tdata,"awt",@progbits' 3078 tls_first_major=0 3079 tls_first_minor=0 3080 tls_section_flag=t 3081changequote([,])dnl 3082 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't', 3083[Define to the flag used to mark TLS sections if the default (`T') doesn't work.]) 3084changequote(,)dnl 3085 else 3086 conftest_s=' 3087 .section ".tdata","awT",@progbits' 3088 tls_first_major=2 3089 tls_first_minor=14 3090 tls_section_flag=T 3091 tls_as_opt="--fatal-warnings" 3092 fi 3093 case "$target" in 3094 i[34567]86-*-*) 3095 conftest_s="$conftest_s 3096foo: .long 25 3097 .text 3098 movl %gs:0, %eax 3099 leal foo@tlsgd(,%ebx,1), %eax 3100 leal foo@tlsldm(%ebx), %eax 3101 leal foo@dtpoff(%eax), %edx 3102 movl foo@gottpoff(%ebx), %eax 3103 subl foo@gottpoff(%ebx), %eax 3104 addl foo@gotntpoff(%ebx), %eax 3105 movl foo@indntpoff, %eax 3106 movl \$foo@tpoff, %eax 3107 subl \$foo@tpoff, %eax 3108 leal foo@ntpoff(%ecx), %eax" 3109 ;; 3110 x86_64-*-*) 3111 if test x$on_solaris = xyes; then 3112 case $gas_flag in 3113 yes) tls_as_opt="$tls_as_opt --64" ;; 3114 no) tls_as_opt="$tls_as_opt -xarch=amd64" ;; 3115 esac 3116 fi 3117 conftest_s="$conftest_s 3118foo: .long 25 3119 .text 3120 movq %fs:0, %rax 3121 leaq foo@tlsgd(%rip), %rdi 3122 leaq foo@tlsld(%rip), %rdi 3123 leaq foo@dtpoff(%rax), %rdx 3124 movq foo@gottpoff(%rip), %rax 3125 movq \$foo@tpoff, %rax" 3126 ;; 3127 esac 3128 ;; 3129 ia64-*-*) 3130 conftest_s=' 3131 .section ".tdata","awT",@progbits 3132foo: data8 25 3133 .text 3134 addl r16 = @ltoff(@dtpmod(foo#)), gp 3135 addl r17 = @ltoff(@dtprel(foo#)), gp 3136 addl r18 = @ltoff(@tprel(foo#)), gp 3137 addl r19 = @dtprel(foo#), gp 3138 adds r21 = @dtprel(foo#), r13 3139 movl r23 = @dtprel(foo#) 3140 addl r20 = @tprel(foo#), gp 3141 adds r22 = @tprel(foo#), r13 3142 movl r24 = @tprel(foo#)' 3143 tls_first_major=2 3144 tls_first_minor=13 3145 tls_as_opt=--fatal-warnings 3146 ;; 3147 microblaze*-*-*) 3148 conftest_s=' 3149 .section .tdata,"awT",@progbits 3150x: 3151 .word 2 3152 .text 3153 addik r5,r20,x@TLSGD 3154 addik r5,r20,x@TLSLDM' 3155 tls_first_major=2 3156 tls_first_minor=20 3157 tls_as_opt='--fatal-warnings' 3158 ;; 3159 mips*-*-*) 3160 conftest_s=' 3161 .section .tdata,"awT",@progbits 3162x: 3163 .word 2 3164 .text 3165 addiu $4, $28, %tlsgd(x) 3166 addiu $4, $28, %tlsldm(x) 3167 lui $4, %dtprel_hi(x) 3168 addiu $4, $4, %dtprel_lo(x) 3169 lw $4, %gottprel(x)($28) 3170 lui $4, %tprel_hi(x) 3171 addiu $4, $4, %tprel_lo(x)' 3172 tls_first_major=2 3173 tls_first_minor=16 3174 tls_as_opt='-32 --fatal-warnings' 3175 ;; 3176 m68k-*-*) 3177 conftest_s=' 3178 .section .tdata,"awT",@progbits 3179x: 3180 .word 2 3181 .text 3182foo: 3183 move.l x@TLSGD(%a5),%a0 3184 move.l x@TLSLDM(%a5),%a0 3185 move.l x@TLSLDO(%a5),%a0 3186 move.l x@TLSIE(%a5),%a0 3187 move.l x@TLSLE(%a5),%a0' 3188 tls_first_major=2 3189 tls_first_minor=19 3190 tls_as_opt='--fatal-warnings' 3191 ;; 3192 nios2-*-*) 3193 conftest_s=' 3194 .section ".tdata","awT",@progbits' 3195 tls_first_major=2 3196 tls_first_minor=23 3197 tls_as_opt="--fatal-warnings" 3198 ;; 3199 aarch64*-*-*) 3200 conftest_s=' 3201 .section ".tdata","awT",%progbits 3202foo: .long 25 3203 .text 3204 adrp x0, :tlsgd:x 3205 add x0, x0, #:tlsgd_lo12:x 3206 bl __tls_get_addr 3207 nop' 3208 tls_first_major=2 3209 tls_first_minor=20 3210 tls_as_opt='--fatal-warnings' 3211 ;; 3212 powerpc-ibm-aix*) 3213 conftest_s=' 3214 .extern __get_tpointer 3215 .toc 3216LC..1: 3217 .tc a[TC],a[TL]@le 3218 .csect .text[PR] 3219.tlstest: 3220 lwz 9,LC..1(2) 3221 bla __get_tpointer 3222 lwzx 3,9,3 3223 .globl a 3224 .csect a[TL],4 3225a: 3226 .space 4' 3227 tls_first_major=0 3228 tls_first_minor=0 3229 ;; 3230 powerpc64*-*-*) 3231 conftest_s=' 3232 .section ".tdata","awT",@progbits 3233 .align 3 3234ld0: .space 8 3235ld1: .space 8 3236x1: .space 8 3237x2: .space 8 3238x3: .space 8 3239 .text 3240 addi 3,2,ld0@got@tlsgd 3241 bl .__tls_get_addr 3242 nop 3243 addi 3,2,ld1@toc 3244 bl .__tls_get_addr 3245 nop 3246 addi 3,2,x1@got@tlsld 3247 bl .__tls_get_addr 3248 nop 3249 addi 9,3,x1@dtprel 3250 bl .__tls_get_addr 3251 nop 3252 addis 9,3,x2@dtprel@ha 3253 addi 9,9,x2@dtprel@l 3254 bl .__tls_get_addr 3255 nop 3256 ld 9,x3@got@dtprel(2) 3257 add 9,9,3 3258 bl .__tls_get_addr 3259 nop' 3260 tls_first_major=2 3261 tls_first_minor=14 3262 tls_as_opt="-a64 --fatal-warnings" 3263 ;; 3264 powerpc*-*-*) 3265 conftest_s=' 3266 .section ".tdata","awT",@progbits 3267 .align 2 3268ld0: .space 4 3269ld1: .space 4 3270x1: .space 4 3271x2: .space 4 3272x3: .space 4 3273 .text 3274 addi 3,31,ld0@got@tlsgd 3275 bl __tls_get_addr 3276 addi 3,31,x1@got@tlsld 3277 bl __tls_get_addr 3278 addi 9,3,x1@dtprel 3279 addis 9,3,x2@dtprel@ha 3280 addi 9,9,x2@dtprel@l 3281 lwz 9,x3@got@tprel(31) 3282 add 9,9,x@tls 3283 addi 9,2,x1@tprel 3284 addis 9,2,x2@tprel@ha 3285 addi 9,9,x2@tprel@l' 3286 tls_first_major=2 3287 tls_first_minor=14 3288 tls_as_opt="-a32 --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]-*-*) 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*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*) 5085 case "$target" in 5086 *le-*-linux*) 5087 emul_name="-melf64lppc" 5088 ;; 5089 *-*-linux*) 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*) 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