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