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