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