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]\)[-]*\([0-3][0-9]\).*$,\1\2\3,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 # In Solaris 11.4, this was changed to 2599 # 2600 # ld: Solaris ELF Utilities: 11.4-1.3123 2601 # 2602 # ld and ld.so.1 are guaranteed to be updated in lockstep, so ld version 2603 # numbers can be used in ld.so.1 feature checks even if a different 2604 # linker is configured. 2605 ld_ver=`$gcc_cv_ld -V 2>&1` 2606 if echo "$ld_ver" | $EGREP 'Solaris Link Editors|Solaris ELF Utilities' > /dev/null; then 2607 ld_vers=`echo $ld_ver | sed -n \ 2608 -e 's,^.*: \(5\|1[0-9]\)\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\2,p'` 2609 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'` 2610 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'` 2611 fi 2612 ;; 2613 esac 2614 fi 2615fi 2616changequote([,])dnl 2617 2618AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden, 2619[[if test $in_tree_ld = yes ; then 2620 gcc_cv_ld_hidden=no 2621 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 \ 2622 && test $in_tree_ld_is_elf = yes; then 2623 gcc_cv_ld_hidden=yes 2624 fi 2625else 2626 gcc_cv_ld_hidden=yes 2627 if test x"$ld_is_gold" = xyes; then 2628 : 2629 elif echo "$ld_ver" | grep GNU > /dev/null; then 2630 case "${target}" in 2631 mmix-knuth-mmixware) 2632 # The linker emits by default mmo, not ELF, so "no" is appropriate. 2633 gcc_cv_ld_hidden=no 2634 ;; 2635 esac 2636 if test 0"$ld_date" -lt 20020404; then 2637 if test -n "$ld_date"; then 2638 # If there was date string, but was earlier than 2002-04-04, fail 2639 gcc_cv_ld_hidden=no 2640 elif test -z "$ld_vers"; then 2641 # If there was no date string nor ld version number, something is wrong 2642 gcc_cv_ld_hidden=no 2643 else 2644 test -z "$ld_vers_patch" && ld_vers_patch=0 2645 if test "$ld_vers_major" -lt 2; then 2646 gcc_cv_ld_hidden=no 2647 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then 2648 gcc_cv_ld_hidden="no" 2649 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then 2650 gcc_cv_ld_hidden=no 2651 fi 2652 fi 2653 fi 2654 else 2655 case "${target}" in 2656 *-*-aix[789]*) 2657 gcc_cv_ld_hidden=yes 2658 ;; 2659 *-*-darwin*) 2660 # Darwin ld has some visibility support. 2661 gcc_cv_ld_hidden=yes 2662 ;; 2663 hppa64*-*-hpux* | ia64*-*-hpux*) 2664 gcc_cv_ld_hidden=yes 2665 ;; 2666 *-*-solaris2.1[0-9]*) 2667 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but 2668 # .symbolic was only added in Solaris 9 12/02. 2669 gcc_cv_ld_hidden=yes 2670 ;; 2671 *) 2672 gcc_cv_ld_hidden=no 2673 ;; 2674 esac 2675 fi 2676fi]]) 2677libgcc_visibility=no 2678AC_SUBST(libgcc_visibility) 2679GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN]) 2680if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then 2681 libgcc_visibility=yes 2682 AC_DEFINE(HAVE_GAS_HIDDEN, 1, 2683 [Define if your assembler and linker support .hidden.]) 2684fi 2685 2686AC_MSG_CHECKING(linker read-only and read-write section mixing) 2687gcc_cv_ld_ro_rw_mix=unknown 2688if test $in_tree_ld = yes ; then 2689 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 \ 2690 && test $in_tree_ld_is_elf = yes; then 2691 gcc_cv_ld_ro_rw_mix=read-write 2692 fi 2693elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then 2694 echo '.section myfoosect, "a"' > conftest1.s 2695 echo '.section myfoosect, "aw"' > conftest2.s 2696 echo '.byte 1' >> conftest2.s 2697 echo '.section myfoosect, "a"' > conftest3.s 2698 echo '.byte 0' >> conftest3.s 2699 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \ 2700 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \ 2701 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \ 2702 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \ 2703 conftest2.o conftest3.o > /dev/null 2>&1; then 2704 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \ 2705 | sed -e '/myfoosect/!d' -e N` 2706 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then 2707 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then 2708 gcc_cv_ld_ro_rw_mix=read-only 2709 else 2710 gcc_cv_ld_ro_rw_mix=read-write 2711 fi 2712 fi 2713 fi 2714changequote(,)dnl 2715 rm -f conftest.* conftest[123].* 2716changequote([,])dnl 2717fi 2718if test x$gcc_cv_ld_ro_rw_mix = xread-write; then 2719 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1, 2720 [Define if your linker links a mix of read-only 2721 and read-write sections into a read-write section.]) 2722fi 2723AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix) 2724 2725gcc_AC_INITFINI_ARRAY 2726 2727# Check if we have .[us]leb128, and support symbol arithmetic with it. 2728gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128, 2729 [elf,2,11,0],, 2730[ .data 2731 .uleb128 L2 - L1 2732L1: 2733 .uleb128 1280 2734 .sleb128 -1010 2735L2:], 2736[[# GAS versions before 2.11 do not support uleb128, 2737 # despite appearing to. 2738 # ??? There exists an elf-specific test that will crash 2739 # the assembler. Perhaps it's better to figure out whether 2740 # arbitrary sections are supported and try the test. 2741 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q` 2742 if echo "$as_ver" | grep GNU > /dev/null; then 2743 as_vers=`echo $as_ver | sed -n \ 2744 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'` 2745 as_major=`expr "$as_vers" : '\([0-9]*\)'` 2746 as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'` 2747 if test $as_major -eq 2 && test $as_minor -lt 11 2748 then : 2749 else gcc_cv_as_leb128=yes 2750 fi 2751 fi]], 2752 [AC_DEFINE(HAVE_AS_LEB128, 1, 2753 [Define if your assembler supports .sleb128 and .uleb128.])], 2754 [AC_DEFINE(HAVE_AS_LEB128, 0, 2755 [Define if your assembler supports .sleb128 and .uleb128.])]) 2756 2757# Determine if an .eh_frame section is read-only. 2758gcc_fn_eh_frame_ro () { 2759 $gcc_cv_as $1 -o conftest.o conftest.s > /dev/null 2>&1 && \ 2760 $gcc_cv_objdump -h conftest.o 2>/dev/null | \ 2761 sed -e '/.eh_frame/!d' -e N | grep READONLY > /dev/null 2762} 2763 2764# Check if we have assembler support for unwind directives. 2765gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive, 2766 ,, 2767[ .text 2768 .cfi_startproc 2769 .cfi_offset 0, 0 2770 .cfi_same_value 1 2771 .cfi_def_cfa 1, 2 2772 .cfi_escape 1, 2, 3, 4, 5 2773 .cfi_endproc], 2774[case "$target" in 2775 *-*-solaris*) 2776 # If the linker used on Solaris (like Sun ld) isn't capable of merging 2777 # read-only and read-write sections, we need to make sure that the 2778 # assembler used emits read-write .eh_frame sections. 2779 if test "x$gcc_cv_ld_ro_rw_mix" = xread-write; then 2780 gcc_cv_as_cfi_directive=yes 2781 elif test "x$gcc_cv_objdump" = x; then 2782 # No objdump, err on the side of caution. 2783 gcc_cv_as_cfi_directive=no 2784 else 2785 if test x$gas = xyes; then 2786 as_32_opt="--32" 2787 as_64_opt="--64" 2788 else 2789 as_32_opt="-m32" 2790 as_64_opt="-m64" 2791 fi 2792 case "$target" in 2793 sparc*-*-solaris2.*) 2794 # On Solaris/SPARC, .eh_frame sections should always be read-write. 2795 if gcc_fn_eh_frame_ro $as_32_opt \ 2796 || gcc_fn_eh_frame_ro $as_64_opt; then 2797 gcc_cv_as_cfi_directive=no 2798 else 2799 gcc_cv_as_cfi_directive=yes 2800 fi 2801 ;; 2802 i?86-*-solaris2.* | x86_64-*-solaris2.*) 2803 # On Solaris/x86, make sure that GCC and assembler agree on using 2804 # read-only .eh_frame sections for 64-bit. 2805 if gcc_fn_eh_frame_ro $as_32_opt; then 2806 gcc_cv_as_cfi_directive=no 2807 elif gcc_fn_eh_frame_ro $as_64_opt; then 2808 gcc_cv_as_cfi_directive=yes 2809 else 2810 gcc_cv_as_cfi_directive=no 2811 fi 2812 ;; 2813 esac 2814 fi 2815 ;; 2816 *-*-*) 2817 gcc_cv_as_cfi_directive=yes 2818 ;; 2819esac]) 2820if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then 2821gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working, 2822 ,, 2823[ .text 2824 .cfi_startproc 2825 .cfi_adjust_cfa_offset 64 2826 .skip 75040, 0 2827 .cfi_adjust_cfa_offset 128 2828 .cfi_endproc], 2829[[ 2830if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \ 2831 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then 2832 gcc_cv_as_cfi_advance_working=yes 2833fi 2834]]) 2835else 2836 # no objdump, err on the side of caution 2837 gcc_cv_as_cfi_advance_working=no 2838fi 2839GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE) 2840AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE, 2841 [`if test $gcc_cv_as_cfi_directive = yes \ 2842 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`], 2843 [Define 0/1 if your assembler supports CFI directives.]) 2844 2845GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE) 2846gcc_GAS_CHECK_FEATURE([cfi personality directive], 2847 gcc_cv_as_cfi_personality_directive, ,, 2848[ .text 2849 .cfi_startproc 2850 .cfi_personality 0, symbol 2851 .cfi_endproc]) 2852AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE, 2853 [`if test $gcc_cv_as_cfi_personality_directive = yes; 2854 then echo 1; else echo 0; fi`], 2855 [Define 0/1 if your assembler supports .cfi_personality.]) 2856 2857gcc_GAS_CHECK_FEATURE([cfi sections directive], 2858 gcc_cv_as_cfi_sections_directive, ,, 2859[ .text 2860 .cfi_sections .debug_frame, .eh_frame 2861 .cfi_startproc 2862 .cfi_endproc], 2863[case $target_os in 2864 win32 | pe | cygwin* | mingw32*) 2865 # Need to check that we generated the correct relocation for the 2866 # .debug_frame section. This was fixed for binutils 2.21. 2867 gcc_cv_as_cfi_sections_directive=no 2868 if test "x$gcc_cv_objdump" != x; then 2869 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \ 2870 grep secrel > /dev/null; then 2871 gcc_cv_as_cfi_sections_directive=yes 2872 fi 2873 fi 2874 ;; 2875 *) 2876 gcc_cv_as_cfi_sections_directive=yes 2877 ;; 2878esac]) 2879GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE) 2880AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE, 2881 [`if test $gcc_cv_as_cfi_sections_directive = yes; 2882 then echo 1; else echo 0; fi`], 2883 [Define 0/1 if your assembler supports .cfi_sections.]) 2884 2885# GAS versions up to and including 2.11.0 may mis-optimize 2886# .eh_frame data. 2887gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame, 2888 [elf,2,12,0],, 2889[ .text 2890.LFB1: 2891 .4byte 0 2892.L1: 2893 .4byte 0 2894.LFE1: 2895 .section .eh_frame,"aw",@progbits 2896__FRAME_BEGIN__: 2897 .4byte .LECIE1-.LSCIE1 2898.LSCIE1: 2899 .4byte 0x0 2900 .byte 0x1 2901 .ascii "z\0" 2902 .byte 0x1 2903 .byte 0x78 2904 .byte 0x1a 2905 .byte 0x0 2906 .byte 0x4 2907 .4byte 1 2908 .p2align 1 2909.LECIE1: 2910.LSFDE1: 2911 .4byte .LEFDE1-.LASFDE1 2912.LASFDE1: 2913 .4byte .LASFDE1-__FRAME_BEGIN__ 2914 .4byte .LFB1 2915 .4byte .LFE1-.LFB1 2916 .byte 0x4 2917 .4byte .LFE1-.LFB1 2918 .byte 0x4 2919 .4byte .L1-.LFB1 2920.LEFDE1:], 2921[ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@. 2922cat > conftest.lit <<EOF 2923 0000 10000000 00000000 017a0001 781a0004 .........z..x... 2924 0010 01000000 12000000 18000000 00000000 ................ 2925 0020 08000000 04080000 0044 .........D @&t@ 2926EOF 2927cat > conftest.big <<EOF 2928 0000 00000010 00000000 017a0001 781a0004 .........z..x... 2929 0010 00000001 00000012 00000018 00000000 ................ 2930 0020 00000008 04000000 0844 .........D @&t@ 2931EOF 2932 # If the assembler didn't choke, and we can objdump, 2933 # and we got the correct data, then succeed. 2934 # The text in the here-document typically retains its unix-style line 2935 # endings, while the output of objdump will use host line endings. 2936 # Therefore, use diff -b for the comparisons. 2937 if test x$gcc_cv_objdump != x \ 2938 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \ 2939 | tail -3 > conftest.got \ 2940 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \ 2941 || diff -b conftest.big conftest.got > /dev/null 2>&1; } 2942 then 2943 gcc_cv_as_eh_frame=yes 2944 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then 2945 gcc_cv_as_eh_frame=buggy 2946 else 2947 # Uh oh, what do we do now? 2948 gcc_cv_as_eh_frame=no 2949 fi]) 2950 2951if test $gcc_cv_as_eh_frame = buggy; then 2952 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1, 2953 [Define if your assembler mis-optimizes .eh_frame data.]) 2954fi 2955 2956gcc_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]) 2959if test $gcc_cv_as_shf_merge = no; then 2960 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge, 2961 [elf,2,12,0], [--fatal-warnings], 2962 [.section .rodata.str, "aMS", %progbits, 1]) 2963fi 2964case "$target" in 2965 i?86-*-solaris2.10* | x86_64-*-solaris2.10*) 2966 # SHF_MERGE support in Solaris 10/x86 ld is broken. 2967 if test x"$gnu_ld" = xno; then 2968 gcc_cv_as_shf_merge=no 2969 fi 2970 ;; 2971esac 2972AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE, 2973 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`], 2974[Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.]) 2975 2976gcc_GAS_CHECK_FEATURE([stabs directive], gcc_cv_as_stabs_directive, ,, 2977[.stabs "gcc2_compiled.",60,0,0,0],, 2978[AC_DEFINE(HAVE_AS_STABS_DIRECTIVE, 1, 2979 [Define if your assembler supports .stabs.])]) 2980 2981gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)], 2982 gcc_cv_as_comdat_group, 2983 [elf,2,16,0], [--fatal-warnings], 2984 [.section .text,"axG",@progbits,.foo,comdat]) 2985if test $gcc_cv_as_comdat_group = yes; then 2986 gcc_cv_as_comdat_group_percent=no 2987 gcc_cv_as_comdat_group_group=no 2988else 2989 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)], 2990 gcc_cv_as_comdat_group_percent, 2991 [elf,2,16,0], [--fatal-warnings], 2992 [.section .text,"axG",%progbits,.foo,comdat]) 2993 if test $gcc_cv_as_comdat_group_percent = yes; then 2994 gcc_cv_as_comdat_group_group=no 2995 else 2996 case "${target}" in 2997 # Sun as uses a completely different syntax. 2998 *-*-solaris2*) 2999 case "${target}" in 3000 sparc*-*-solaris2*) 3001 conftest_s=' 3002 .group foo,".text%foo",#comdat 3003 .section ".text%foo", #alloc,#execinstr,#progbits 3004 .globl foo 3005 foo: 3006 ' 3007 ;; 3008 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*) 3009 conftest_s=' 3010 .group foo,.text%foo,#comdat 3011 .section .text%foo, "ax", @progbits 3012 .globl foo 3013 foo: 3014 ' 3015 ;; 3016 esac 3017 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)], 3018 gcc_cv_as_comdat_group_group, 3019 ,, [$conftest_s]) 3020 ;; 3021 esac 3022 if test -z "${gcc_cv_as_comdat_group_group+set}"; then 3023 gcc_cv_as_comdat_group_group=no 3024 fi 3025 fi 3026fi 3027if test x"$ld_is_gold" = xyes; then 3028 comdat_group=yes 3029elif test $in_tree_ld = yes ; then 3030 comdat_group=no 3031 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 \ 3032 && test $in_tree_ld_is_elf = yes; then 3033 comdat_group=yes 3034 fi 3035elif echo "$ld_ver" | grep GNU > /dev/null; then 3036 comdat_group=yes 3037 if test 0"$ld_date" -lt 20050308; then 3038 if test -n "$ld_date"; then 3039 # If there was date string, but was earlier than 2005-03-08, fail 3040 comdat_group=no 3041 elif test "$ld_vers_major" -lt 2; then 3042 comdat_group=no 3043 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then 3044 comdat_group=no 3045 fi 3046 fi 3047else 3048changequote(,)dnl 3049 case "${target}" in 3050 *-*-solaris2.1[1-9]*) 3051 comdat_group=no 3052 # Sun ld has COMDAT group support since Solaris 9, but it doesn't 3053 # interoperate with GNU as until Solaris 11 build 130, i.e. ld 3054 # version 1.688. 3055 # 3056 # If using Sun as for COMDAT group as emitted by GCC, one needs at 3057 # least ld version 1.2267. 3058 if test "$ld_vers_major" -gt 1; then 3059 comdat_group=yes 3060 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then 3061 comdat_group=yes 3062 elif test "$ld_vers_minor" -ge 2267; then 3063 comdat_group=yes 3064 fi 3065 ;; 3066 *) 3067 # Assume linkers other than GNU ld don't support COMDAT group. 3068 comdat_group=no 3069 ;; 3070 esac 3071changequote([,])dnl 3072fi 3073# Allow overriding the automatic COMDAT group tests above. 3074AC_ARG_ENABLE(comdat, 3075 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])], 3076 [comdat_group="$enable_comdat"]) 3077if test $comdat_group = no; then 3078 gcc_cv_as_comdat_group=no 3079 gcc_cv_as_comdat_group_percent=no 3080 gcc_cv_as_comdat_group_group=no 3081fi 3082AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP, 3083 [`if test $gcc_cv_as_comdat_group = yes \ 3084 || test $gcc_cv_as_comdat_group_percent = yes \ 3085 || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`], 3086[Define 0/1 if your assembler and linker support COMDAT groups.]) 3087 3088# Restrict this test to Solaris/x86: other targets define this statically. 3089case "${target}" in 3090 i?86-*-solaris2* | x86_64-*-solaris2*) 3091 AC_MSG_CHECKING(support for hidden thunks in linkonce sections) 3092 if test $in_tree_ld = yes || echo "$ld_ver" | grep GNU > /dev/null; then 3093 hidden_linkonce=yes 3094 else 3095 case "${target}" in 3096 # Full support for hidden thunks in linkonce sections only appeared in 3097 # Solaris 11/OpenSolaris. 3098 *-*-solaris2.1[[1-9]]*) 3099 hidden_linkonce=yes 3100 ;; 3101 *) 3102 hidden_linkonce=no 3103 ;; 3104 esac 3105 fi 3106 AC_MSG_RESULT($hidden_linkonce) 3107 AC_DEFINE_UNQUOTED(USE_HIDDEN_LINKONCE, 3108 [`if test $hidden_linkonce = yes; then echo 1; else echo 0; fi`], 3109 [Define 0/1 if your linker supports hidden thunks in linkonce sections.]) 3110 ;; 3111esac 3112 3113gcc_GAS_CHECK_FEATURE([line table discriminator support], 3114 gcc_cv_as_discriminator, 3115 [2,19,51],, 3116[ .text 3117 .file 1 "conf.c" 3118 .loc 1 1 0 discriminator 1],, 3119[AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1, 3120 [Define if your assembler supports the .loc discriminator sub-directive.])]) 3121 3122# Thread-local storage - the check is heavily parameterized. 3123conftest_s= 3124tls_first_major= 3125tls_first_minor= 3126tls_as_opt= 3127case "$target" in 3128changequote(,)dnl 3129 alpha*-*-*) 3130 conftest_s=' 3131 .section ".tdata","awT",@progbits 3132foo: .long 25 3133 .text 3134 ldq $27,__tls_get_addr($29) !literal!1 3135 lda $16,foo($29) !tlsgd!1 3136 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1 3137 ldq $27,__tls_get_addr($29) !literal!2 3138 lda $16,foo($29) !tlsldm!2 3139 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2 3140 ldq $1,foo($29) !gotdtprel 3141 ldah $2,foo($29) !dtprelhi 3142 lda $3,foo($2) !dtprello 3143 lda $4,foo($29) !dtprel 3144 ldq $1,foo($29) !gottprel 3145 ldah $2,foo($29) !tprelhi 3146 lda $3,foo($2) !tprello 3147 lda $4,foo($29) !tprel' 3148 tls_first_major=2 3149 tls_first_minor=13 3150 tls_as_opt=--fatal-warnings 3151 ;; 3152 arc*-*-*) 3153 conftest_s=' 3154 add_s r0,r0, @foo@tpoff' 3155 tls_first_major=2 3156 tls_first_minor=23 3157 ;; 3158 cris-*-*|crisv32-*-*) 3159 conftest_s=' 3160 .section ".tdata","awT",@progbits 3161x: .long 25 3162 .text 3163 move.d x:IE,$r10 3164 nop' 3165 tls_first_major=2 3166 tls_first_minor=20 3167 tls_as_opt=--fatal-warnings 3168 ;; 3169 frv*-*-*) 3170 conftest_s=' 3171 .section ".tdata","awT",@progbits 3172x: .long 25 3173 .text 3174 call #gettlsoff(x)' 3175 tls_first_major=2 3176 tls_first_minor=14 3177 ;; 3178 hppa*-*-linux*) 3179 conftest_s=' 3180t1: .reg %r20 3181t2: .reg %r21 3182gp: .reg %r19 3183 .section ".tdata","awT",@progbits 3184foo: .long 25 3185 .text 3186 .align 4 3187 addil LT%foo-$tls_gdidx$,gp 3188 ldo RT%foo-$tls_gdidx$(%r1),%arg0 3189 b __tls_get_addr 3190 nop 3191 addil LT%foo-$tls_ldidx$,gp 3192 b __tls_get_addr 3193 ldo RT%foo-$tls_ldidx$(%r1),%arg0 3194 addil LR%foo-$tls_dtpoff$,%ret0 3195 ldo RR%foo-$tls_dtpoff$(%r1),%t1 3196 mfctl %cr27,%t1 3197 addil LT%foo-$tls_ieoff$,gp 3198 ldw RT%foo-$tls_ieoff$(%r1),%t2 3199 add %t1,%t2,%t3 3200 mfctl %cr27,%t1 3201 addil LR%foo-$tls_leoff$,%t1 3202 ldo RR%foo-$tls_leoff$(%r1),%t2' 3203 tls_first_major=2 3204 tls_first_minor=15 3205 tls_as_opt=--fatal-warnings 3206 ;; 3207 arm*-*-*) 3208 conftest_s=' 3209 .section ".tdata","awT",%progbits 3210foo: .long 25 3211 .text 3212.word foo(gottpoff) 3213.word foo(tpoff) 3214.word foo(tlsgd) 3215.word foo(tlsldm) 3216.word foo(tlsldo)' 3217 tls_first_major=2 3218 tls_first_minor=17 3219 ;; 3220 i[34567]86-*-* | x86_64-*-*) 3221 case "$target" in 3222 i[34567]86-*-solaris2.* | x86_64-*-solaris2.1[0-9]*) 3223 on_solaris=yes 3224 ;; 3225 *) 3226 on_solaris=no 3227 ;; 3228 esac 3229 if test x$on_solaris = xyes && test x$gas_flag = xno; then 3230 conftest_s=' 3231 .section .tdata,"awt",@progbits' 3232 tls_first_major=0 3233 tls_first_minor=0 3234 tls_section_flag=t 3235changequote([,])dnl 3236 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't', 3237[Define to the flag used to mark TLS sections if the default (`T') doesn't work.]) 3238changequote(,)dnl 3239 else 3240 conftest_s=' 3241 .section ".tdata","awT",@progbits' 3242 tls_first_major=2 3243 tls_first_minor=14 3244 tls_section_flag=T 3245 tls_as_opt="--fatal-warnings" 3246 fi 3247 case "$target" in 3248 i[34567]86-*-*) 3249 conftest_s="$conftest_s 3250foo: .long 25 3251 .text 3252 movl %gs:0, %eax 3253 leal foo@tlsgd(,%ebx,1), %eax 3254 leal foo@tlsldm(%ebx), %eax 3255 leal foo@dtpoff(%eax), %edx 3256 movl foo@gottpoff(%ebx), %eax 3257 subl foo@gottpoff(%ebx), %eax 3258 addl foo@gotntpoff(%ebx), %eax 3259 movl foo@indntpoff, %eax 3260 movl \$foo@tpoff, %eax 3261 subl \$foo@tpoff, %eax 3262 leal foo@ntpoff(%ecx), %eax" 3263 ;; 3264 x86_64-*-*) 3265 if test x$on_solaris = xyes; then 3266 case $gas_flag in 3267 yes) tls_as_opt="$tls_as_opt --64" ;; 3268 no) tls_as_opt="$tls_as_opt -xarch=amd64" ;; 3269 esac 3270 fi 3271 conftest_s="$conftest_s 3272foo: .long 25 3273 .text 3274 movq %fs:0, %rax 3275 leaq foo@tlsgd(%rip), %rdi 3276 leaq foo@tlsld(%rip), %rdi 3277 leaq foo@dtpoff(%rax), %rdx 3278 movq foo@gottpoff(%rip), %rax 3279 movq \$foo@tpoff, %rax" 3280 ;; 3281 esac 3282 ;; 3283 ia64-*-*) 3284 conftest_s=' 3285 .section ".tdata","awT",@progbits 3286foo: data8 25 3287 .text 3288 addl r16 = @ltoff(@dtpmod(foo#)), gp 3289 addl r17 = @ltoff(@dtprel(foo#)), gp 3290 addl r18 = @ltoff(@tprel(foo#)), gp 3291 addl r19 = @dtprel(foo#), gp 3292 adds r21 = @dtprel(foo#), r13 3293 movl r23 = @dtprel(foo#) 3294 addl r20 = @tprel(foo#), gp 3295 adds r22 = @tprel(foo#), r13 3296 movl r24 = @tprel(foo#)' 3297 tls_first_major=2 3298 tls_first_minor=13 3299 tls_as_opt=--fatal-warnings 3300 ;; 3301 microblaze*-*-*) 3302 conftest_s=' 3303 .section .tdata,"awT",@progbits 3304x: 3305 .word 2 3306 .text 3307 addik r5,r20,x@TLSGD 3308 addik r5,r20,x@TLSLDM' 3309 tls_first_major=2 3310 tls_first_minor=20 3311 tls_as_opt='--fatal-warnings' 3312 ;; 3313 mips*-*-*) 3314 conftest_s=' 3315 .section .tdata,"awT",@progbits 3316x: 3317 .word 2 3318 .text 3319 addiu $4, $28, %tlsgd(x) 3320 addiu $4, $28, %tlsldm(x) 3321 lui $4, %dtprel_hi(x) 3322 addiu $4, $4, %dtprel_lo(x) 3323 lw $4, %gottprel(x)($28) 3324 lui $4, %tprel_hi(x) 3325 addiu $4, $4, %tprel_lo(x)' 3326 tls_first_major=2 3327 tls_first_minor=16 3328 tls_as_opt='-32 --fatal-warnings' 3329 ;; 3330 m68k-*-*) 3331 conftest_s=' 3332 .section .tdata,"awT",@progbits 3333x: 3334 .word 2 3335 .text 3336foo: 3337 move.l x@TLSGD(%a5),%a0 3338 move.l x@TLSLDM(%a5),%a0 3339 move.l x@TLSLDO(%a5),%a0 3340 move.l x@TLSIE(%a5),%a0 3341 move.l x@TLSLE(%a5),%a0' 3342 tls_first_major=2 3343 tls_first_minor=19 3344 tls_as_opt='--fatal-warnings' 3345 ;; 3346 nios2-*-*) 3347 conftest_s=' 3348 .section ".tdata","awT",@progbits' 3349 tls_first_major=2 3350 tls_first_minor=23 3351 tls_as_opt="--fatal-warnings" 3352 ;; 3353 aarch64*-*-*) 3354 conftest_s=' 3355 .section ".tdata","awT",%progbits 3356foo: .long 25 3357 .text 3358 adrp x0, :tlsgd:x 3359 add x0, x0, #:tlsgd_lo12:x 3360 bl __tls_get_addr 3361 nop' 3362 tls_first_major=2 3363 tls_first_minor=20 3364 tls_as_opt='--fatal-warnings' 3365 ;; 3366 powerpc-ibm-aix*) 3367 conftest_s=' 3368 .extern __get_tpointer 3369 .toc 3370LC..1: 3371 .tc a[TC],a[TL]@le 3372 .csect .text[PR] 3373.tlstest: 3374 lwz 9,LC..1(2) 3375 bla __get_tpointer 3376 lwzx 3,9,3 3377 .globl a 3378 .csect a[TL],4 3379a: 3380 .space 4' 3381 tls_first_major=0 3382 tls_first_minor=0 3383 ;; 3384 powerpc64*-*-*) 3385 conftest_s=' 3386 .section ".tdata","awT",@progbits 3387 .align 3 3388ld0: .space 8 3389ld1: .space 8 3390x1: .space 8 3391x2: .space 8 3392x3: .space 8 3393 .text 3394 addi 3,2,ld0@got@tlsgd 3395 bl .__tls_get_addr 3396 nop 3397 addi 3,2,ld1@toc 3398 bl .__tls_get_addr 3399 nop 3400 addi 3,2,x1@got@tlsld 3401 bl .__tls_get_addr 3402 nop 3403 addi 9,3,x1@dtprel 3404 bl .__tls_get_addr 3405 nop 3406 addis 9,3,x2@dtprel@ha 3407 addi 9,9,x2@dtprel@l 3408 bl .__tls_get_addr 3409 nop 3410 ld 9,x3@got@dtprel(2) 3411 add 9,9,3 3412 bl .__tls_get_addr 3413 nop' 3414 tls_first_major=2 3415 tls_first_minor=14 3416 tls_as_opt="-a64 --fatal-warnings" 3417 ;; 3418 powerpc*-*-*) 3419 conftest_s=' 3420 .section ".tdata","awT",@progbits 3421 .align 2 3422ld0: .space 4 3423ld1: .space 4 3424x1: .space 4 3425x2: .space 4 3426x3: .space 4 3427 .text 3428 addi 3,31,ld0@got@tlsgd 3429 bl __tls_get_addr 3430 addi 3,31,x1@got@tlsld 3431 bl __tls_get_addr 3432 addi 9,3,x1@dtprel 3433 addis 9,3,x2@dtprel@ha 3434 addi 9,9,x2@dtprel@l 3435 lwz 9,x3@got@tprel(31) 3436 add 9,9,x@tls 3437 addi 9,2,x1@tprel 3438 addis 9,2,x2@tprel@ha 3439 addi 9,9,x2@tprel@l' 3440 tls_first_major=2 3441 tls_first_minor=14 3442 tls_as_opt="-a32 --fatal-warnings" 3443 ;; 3444 riscv*-*-*) 3445 conftest_s=' 3446 .section .tdata,"awT",@progbits 3447x: .word 2 3448 .text 3449 la.tls.gd a0,x 3450 call __tls_get_addr' 3451 tls_first_major=2 3452 tls_first_minor=21 3453 tls_as_opt='--fatal-warnings' 3454 ;; 3455 s390-*-*) 3456 conftest_s=' 3457 .section ".tdata","awT",@progbits 3458foo: .long 25 3459 .text 3460 .long foo@TLSGD 3461 .long foo@TLSLDM 3462 .long foo@DTPOFF 3463 .long foo@NTPOFF 3464 .long foo@GOTNTPOFF 3465 .long foo@INDNTPOFF 3466 l %r1,foo@GOTNTPOFF(%r12) 3467 l %r1,0(%r1):tls_load:foo 3468 bas %r14,0(%r1,%r13):tls_gdcall:foo 3469 bas %r14,0(%r1,%r13):tls_ldcall:foo' 3470 tls_first_major=2 3471 tls_first_minor=14 3472 tls_as_opt="-m31 --fatal-warnings" 3473 ;; 3474 s390x-*-*) 3475 conftest_s=' 3476 .section ".tdata","awT",@progbits 3477foo: .long 25 3478 .text 3479 .quad foo@TLSGD 3480 .quad foo@TLSLDM 3481 .quad foo@DTPOFF 3482 .quad foo@NTPOFF 3483 .quad foo@GOTNTPOFF 3484 lg %r1,foo@GOTNTPOFF(%r12) 3485 larl %r1,foo@INDNTPOFF 3486 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo 3487 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo' 3488 tls_first_major=2 3489 tls_first_minor=14 3490 tls_as_opt="-m64 -Aesame --fatal-warnings" 3491 ;; 3492 sh-*-* | sh[123456789lbe]*-*-*) 3493 conftest_s=' 3494 .section ".tdata","awT",@progbits 3495foo: .long 25 3496 .text 3497 .long foo@TLSGD 3498 .long foo@TLSLDM 3499 .long foo@DTPOFF 3500 .long foo@GOTTPOFF 3501 .long foo@TPOFF' 3502 tls_first_major=2 3503 tls_first_minor=13 3504 tls_as_opt=--fatal-warnings 3505 ;; 3506 sparc*-*-*) 3507 case "$target" in 3508 sparc*-sun-solaris2.*) 3509 on_solaris=yes 3510 ;; 3511 *) 3512 on_solaris=no 3513 ;; 3514 esac 3515 if test x$on_solaris = xyes && test x$gas_flag = xno; then 3516 conftest_s=' 3517 .section ".tdata",#alloc,#write,#tls' 3518 tls_first_major=0 3519 tls_first_minor=0 3520 else 3521 conftest_s=' 3522 .section ".tdata","awT",@progbits' 3523 tls_first_major=2 3524 tls_first_minor=14 3525 tls_as_opt="-32 --fatal-warnings" 3526 fi 3527 conftest_s="$conftest_s 3528foo: .long 25 3529 .text 3530 sethi %tgd_hi22(foo), %o0 3531 add %o0, %tgd_lo10(foo), %o1 3532 add %l7, %o1, %o0, %tgd_add(foo) 3533 call __tls_get_addr, %tgd_call(foo) 3534 sethi %tldm_hi22(foo), %l1 3535 add %l1, %tldm_lo10(foo), %l2 3536 add %l7, %l2, %o0, %tldm_add(foo) 3537 call __tls_get_addr, %tldm_call(foo) 3538 sethi %tldo_hix22(foo), %l3 3539 xor %l3, %tldo_lox10(foo), %l4 3540 add %o0, %l4, %l5, %tldo_add(foo) 3541 sethi %tie_hi22(foo), %o3 3542 add %o3, %tie_lo10(foo), %o3 3543 ld [%l7 + %o3], %o2, %tie_ld(foo) 3544 add %g7, %o2, %o4, %tie_add(foo) 3545 sethi %tle_hix22(foo), %l1 3546 xor %l1, %tle_lox10(foo), %o5 3547 ld [%g7 + %o5], %o1" 3548 ;; 3549 tilepro*-*-*) 3550 conftest_s=' 3551 .section ".tdata","awT",@progbits 3552foo: .long 25 3553 .text 3554 addli r0, zero, tls_gd(foo) 3555 auli r0, zero, tls_gd_ha16(foo) 3556 addli r0, r0, tls_gd_lo16(foo) 3557 jal __tls_get_addr 3558 addli r0, zero, tls_ie(foo) 3559 auli r0, r0, tls_ie_ha16(foo) 3560 addli r0, r0, tls_ie_lo16(foo)' 3561 tls_first_major=2 3562 tls_first_minor=22 3563 tls_as_opt="--fatal-warnings" 3564 ;; 3565 tilegx*-*-*) 3566 conftest_s=' 3567 .section ".tdata","awT",@progbits 3568foo: .long 25 3569 .text 3570 shl16insli r0, zero, hw0_last_tls_gd(foo) 3571 shl16insli r0, zero, hw1_last_tls_gd(foo) 3572 shl16insli r0, r0, hw0_tls_gd(foo) 3573 jal __tls_get_addr 3574 shl16insli r0, zero, hw1_last_tls_ie(foo) 3575 shl16insli r0, r0, hw0_tls_ie(foo)' 3576 tls_first_major=2 3577 tls_first_minor=22 3578 tls_as_opt="--fatal-warnings" 3579 ;; 3580 xtensa*-*-*) 3581 conftest_s=' 3582 .section ".tdata","awT",@progbits 3583foo: .long 25 3584 .text 3585 movi a8, foo@TLSFUNC 3586 movi a10, foo@TLSARG 3587 callx8.tls a8, foo@TLSCALL' 3588 tls_first_major=2 3589 tls_first_minor=19 3590 ;; 3591changequote([,])dnl 3592esac 3593set_have_as_tls=no 3594if test "x$enable_tls" = xno ; then 3595 : # TLS explicitly disabled. 3596elif test "x$enable_tls" = xyes ; then 3597 set_have_as_tls=yes # TLS explicitly enabled. 3598elif test -z "$tls_first_major"; then 3599 : # If we don't have a check, assume no support. 3600else 3601 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls, 3602 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],, 3603 [set_have_as_tls=yes]) 3604fi 3605if test $set_have_as_tls = yes ; then 3606 AC_DEFINE(HAVE_AS_TLS, 1, 3607 [Define if your assembler and linker support thread-local storage.]) 3608fi 3609 3610# Target-specific assembler checks. 3611 3612AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option) 3613gcc_cv_ld_static_dynamic=no 3614gcc_cv_ld_static_option='-Bstatic' 3615gcc_cv_ld_dynamic_option='-Bdynamic' 3616if test $in_tree_ld = yes ; then 3617 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 3618 gcc_cv_ld_static_dynamic=yes 3619 fi 3620elif test x$gcc_cv_ld != x; then 3621 # Check if linker supports -Bstatic/-Bdynamic option 3622 if $gcc_cv_ld --help 2>&1 | grep -- -Bstatic > /dev/null \ 3623 && $gcc_cv_ld --help 2>&1 | grep -- -Bdynamic > /dev/null; then 3624 gcc_cv_ld_static_dynamic=yes 3625 else 3626 case "$target" in 3627 # AIX ld uses -b flags 3628 *-*-aix4.[[23]]* | *-*-aix[[5-9]]*) 3629 gcc_cv_ld_static_dynamic=yes 3630 gcc_cv_ld_static_option="-bstatic" 3631 gcc_cv_ld_dynamic_option="-bdynamic" 3632 ;; 3633 # HP-UX ld uses -a flags to select between shared and archive. 3634 *-*-hpux*) 3635 if test x"$gnu_ld" = xno; then 3636 gcc_cv_ld_static_dynamic=yes 3637 gcc_cv_ld_static_option="-aarchive_shared" 3638 gcc_cv_ld_dynamic_option="-adefault" 3639 fi 3640 ;; 3641 # Solaris 2 ld always supports -Bstatic/-Bdynamic. 3642 *-*-solaris2*) 3643 gcc_cv_ld_static_dynamic=yes 3644 ;; 3645 esac 3646 fi 3647fi 3648if test x"$gcc_cv_ld_static_dynamic" = xyes; then 3649 AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1, 3650[Define if your linker supports -Bstatic/-Bdynamic or equivalent options.]) 3651 AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option", 3652[Define to the linker option to disable use of shared objects.]) 3653 AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option", 3654[Define to the linker option to enable use of shared objects.]) 3655fi 3656AC_MSG_RESULT($gcc_cv_ld_static_dynamic) 3657 3658AC_MSG_CHECKING(linker --version-script option) 3659gcc_cv_ld_version_script=no 3660ld_version_script_option='' 3661if test $in_tree_ld = yes || test x"$gnu_ld" = xyes; then 3662 gcc_cv_ld_version_script=yes 3663 ld_version_script_option='--version-script' 3664elif test x$gcc_cv_ld != x; then 3665 case "$target" in 3666 # Solaris 2 ld always supports -M. It also supports a subset of 3667 # --version-script since Solaris 11.4, but requires 3668 # -z gnu-version-script-compat to activate. 3669 *-*-solaris2*) 3670 gcc_cv_ld_version_script=yes 3671 ld_version_script_option='-M' 3672 ;; 3673 esac 3674fi 3675# Don't AC_DEFINE result, only used in jit/Make-lang.in so far. 3676AC_MSG_RESULT($gcc_cv_ld_version_script) 3677AC_SUBST(ld_version_script_option) 3678 3679AC_MSG_CHECKING(linker soname option) 3680gcc_cv_ld_soname=no 3681if test $in_tree_ld = yes || test x"$gnu_ld" = xyes; then 3682 gcc_cv_ld_soname=yes 3683 ld_soname_option='-soname' 3684elif test x$gcc_cv_ld != x; then 3685 case "$target" in 3686 *-*-darwin*) 3687 gcc_cv_ld_soname=yes 3688 ld_soname_option='-install_name' 3689 ;; 3690 # Solaris 2 ld always supports -h. It also supports --soname for GNU 3691 # ld compatiblity since some Solaris 10 update. 3692 *-*-solaris2*) 3693 gcc_cv_ld_soname=yes 3694 ld_soname_option='-h' 3695 ;; 3696 esac 3697fi 3698# Don't AC_DEFINE result, only used in jit/Make-lang.in so far. 3699AC_MSG_RESULT($gcc_cv_ld_soname) 3700AC_SUBST(ld_soname_option) 3701 3702if test x"$demangler_in_ld" = xyes; then 3703 AC_MSG_CHECKING(linker --demangle support) 3704 gcc_cv_ld_demangle=no 3705 if test $in_tree_ld = yes; then 3706 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 \ 3707 gcc_cv_ld_demangle=yes 3708 fi 3709 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then 3710 # Check if the GNU linker supports --demangle option 3711 if $gcc_cv_ld --help 2>&1 | grep no-demangle > /dev/null; then 3712 gcc_cv_ld_demangle=yes 3713 fi 3714 fi 3715 if test x"$gcc_cv_ld_demangle" = xyes; then 3716 AC_DEFINE(HAVE_LD_DEMANGLE, 1, 3717[Define if your linker supports --demangle option.]) 3718 fi 3719 AC_MSG_RESULT($gcc_cv_ld_demangle) 3720fi 3721 3722AC_MSG_CHECKING(linker plugin support) 3723gcc_cv_lto_plugin=0 3724if test -f liblto_plugin.la; then 3725 save_ld_ver="$ld_ver" 3726 save_ld_vers_major="$ld_vers_major" 3727 save_ld_vers_minor="$ld_vers_minor" 3728 save_ld_is_gold="$ld_is_gold" 3729 3730 ld_is_gold=no 3731 3732 if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then 3733 ld_ver="GNU ld" 3734 # FIXME: ld_is_gold? 3735 ld_vers_major="$gcc_cv_gld_major_version" 3736 ld_vers_minor="$gcc_cv_gld_minor_version" 3737 else 3738 # Determine plugin linker version. 3739 # FIXME: Partial duplicate from above, generalize. 3740changequote(,)dnl 3741 ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q` 3742 if echo "$ld_ver" | grep GNU > /dev/null; then 3743 if echo "$ld_ver" | grep "GNU gold" > /dev/null; then 3744 ld_is_gold=yes 3745 ld_vers=`echo $ld_ver | sed -n \ 3746 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'` 3747 else 3748 ld_vers=`echo $ld_ver | sed -n \ 3749 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'` 3750 fi 3751 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'` 3752 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'` 3753 fi 3754changequote([,])dnl 3755 fi 3756 3757 # Determine plugin support. 3758 if echo "$ld_ver" | grep GNU > /dev/null; then 3759 # Require GNU ld or gold 2.21+ for plugin support by default. 3760 if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then 3761 gcc_cv_lto_plugin=2 3762 # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20. 3763 elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then 3764 gcc_cv_lto_plugin=1 3765 fi 3766 fi 3767 3768 ld_ver="$save_ld_ver" 3769 ld_vers_major="$save_ld_vers_major" 3770 ld_vers_minor="$save_ld_vers_minor" 3771 ld_is_gold="$save_ld_is_gold" 3772fi 3773AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin, 3774 [Define to the level of your linker's plugin support.]) 3775AC_MSG_RESULT($gcc_cv_lto_plugin) 3776 3777# Target OS-specific assembler checks. 3778 3779case "$target_os" in 3780 darwin*) 3781 gcc_GAS_CHECK_FEATURE([-mmacosx-version-min option], 3782 gcc_cv_as_mmacosx_version_min,, 3783 [-mmacosx-version-min=10.1], [.text],, 3784 [AC_DEFINE(HAVE_AS_MMACOSX_VERSION_MIN_OPTION, 1, 3785 [Define if your Mac OS X assembler supports the -mmacos-version-min option.])]) 3786 ;; 3787esac 3788 3789# Target CPU-specific assembler checks. 3790 3791case "$target" in 3792 aarch64*-*-*) 3793 gcc_GAS_CHECK_FEATURE([-mabi option], gcc_cv_as_aarch64_mabi,, 3794 [-mabi=lp64], [.text],,,) 3795 if test x$gcc_cv_as_aarch64_mabi = xyes; then 3796 AC_DEFINE(HAVE_AS_MABI_OPTION, 1, 3797 [Define if your assembler supports the -mabi option.]) 3798 else 3799 if test x$with_abi = xilp32; then 3800 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\ 3801 Upgrade the Assembler.]) 3802 fi 3803 if test x"$with_multilib_list" = xdefault; then 3804 TM_MULTILIB_CONFIG=lp64 3805 else 3806 aarch64_multilibs=`echo $with_multilib_list | sed -e 's/,/ /g'` 3807 for aarch64_multilib in ${aarch64_multilibs}; do 3808 case ${aarch64_multilib} in 3809 ilp32) 3810 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\ 3811 Upgrade the Assembler.]) 3812 ;; 3813 *) 3814 ;; 3815 esac 3816 done 3817 fi 3818 fi 3819 # Check if we have binutils support for relocations types needed by -fpic 3820 gcc_GAS_CHECK_FEATURE([-fpic relocs], gcc_cv_as_aarch64_picreloc,,, 3821 [ 3822 .text 3823 ldr x0, [[x2, #:gotpage_lo15:globalsym]] 3824 ],,[AC_DEFINE(HAVE_AS_SMALL_PIC_RELOCS, 1, 3825 [Define if your assembler supports relocs needed by -fpic.])]) 3826 # Enable default workaround for AArch64 Cortex-A53 erratum 835769. 3827 AC_ARG_ENABLE(fix-cortex-a53-835769, 3828 [ 3829AS_HELP_STRING([--enable-fix-cortex-a53-835769], 3830 [enable workaround for AArch64 Cortex-A53 erratum 835769 by default]) 3831AS_HELP_STRING([--disable-fix-cortex-a53-835769], 3832 [disable workaround for AArch64 Cortex-A53 erratum 835769 by default]) 3833 ], 3834 [ 3835 case $enableval in 3836 yes) 3837 tm_defines="${tm_defines} TARGET_FIX_ERR_A53_835769_DEFAULT=1" 3838 ;; 3839 no) 3840 ;; 3841 *) 3842 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-835769.\ 3843 Valid choices are 'yes' and 'no'.]) 3844 ;; 3845 3846 esac 3847 ], 3848 []) 3849 # Enable default workaround for AArch64 Cortex-A53 erratum 843419. 3850 AC_ARG_ENABLE(fix-cortex-a53-843419, 3851 [ 3852AS_HELP_STRING([--enable-fix-cortex-a53-843419], 3853 [enable workaround for AArch64 Cortex-A53 erratum 843419 by default]) 3854AS_HELP_STRING([--disable-fix-cortex-a53-843419], 3855 [disable workaround for AArch64 Cortex-A53 erratum 843419 by default]) 3856 ], 3857 [ 3858 case $enableval in 3859 yes) 3860 tm_defines="${tm_defines} TARGET_FIX_ERR_A53_843419_DEFAULT=1" 3861 ;; 3862 no) 3863 ;; 3864 *) 3865 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-843419.\ 3866 Valid choices are 'yes' and 'no'.]) 3867 ;; 3868 3869 esac 3870 ], 3871 []) 3872 ;; 3873 3874 # All TARGET_ABI_OSF targets. 3875 alpha*-*-linux* | alpha*-*-*bsd*) 3876 gcc_GAS_CHECK_FEATURE([explicit relocation support], 3877 gcc_cv_as_alpha_explicit_relocs, [2,12,0],, 3878[ .set nomacro 3879 .text 3880 extbl $3, $2, $3 !lituse_bytoff!1 3881 ldq $2, a($29) !literal!1 3882 ldq $4, b($29) !literal!2 3883 ldq_u $3, 0($2) !lituse_base!1 3884 ldq $27, f($29) !literal!5 3885 jsr $26, ($27), f !lituse_jsr!5 3886 ldah $29, 0($26) !gpdisp!3 3887 lda $0, c($29) !gprel 3888 ldah $1, d($29) !gprelhigh 3889 lda $1, d($1) !gprellow 3890 lda $29, 0($29) !gpdisp!3],, 3891 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1, 3892 [Define if your assembler supports explicit relocations.])]) 3893 gcc_GAS_CHECK_FEATURE([jsrdirect relocation support], 3894 gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],, 3895[ .set nomacro 3896 .text 3897 ldq $27, a($29) !literal!1 3898 jsr $26, ($27), a !lituse_jsrdirect!1],, 3899 [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1, 3900 [Define if your assembler supports the lituse_jsrdirect relocation.])]) 3901 ;; 3902 3903 avr-*-*) 3904 gcc_GAS_CHECK_FEATURE([--mlink-relax option], gcc_cv_as_avr_mlink_relax,, 3905 [--mlink-relax], [.text],, 3906 [AC_DEFINE(HAVE_AS_AVR_MLINK_RELAX_OPTION, 1, 3907 [Define if your avr assembler supports --mlink-relax option.])]) 3908 3909 gcc_GAS_CHECK_FEATURE([-mrmw option], gcc_cv_as_avr_mrmw,, 3910 [-mrmw], [.text],, 3911 [AC_DEFINE(HAVE_AS_AVR_MRMW_OPTION, 1, 3912 [Define if your avr assembler supports -mrmw option.])]) 3913 3914 gcc_GAS_CHECK_FEATURE([__gcc_isr pseudo instruction], 3915 gcc_cv_as_avr_mgccisr,, 3916 [-mgcc-isr], [.text 3917 __gcc_isr 1 3918 __gcc_isr 2 3919 __gcc_isr 0,r24 3920 ],, 3921 [AC_DEFINE(HAVE_AS_AVR_MGCCISR_OPTION, 1, 3922 [Define if your avr assembler supports -mgcc-isr option.])]) 3923 3924 # Check how default linker description file implements .rodata for 3925 # avrxmega3 (PR21472). avr-gcc assumes .rodata is *not* loaded to 3926 # RAM so avr-gcc skips __do_copy_data for .rodata objects. 3927 AC_MSG_CHECKING(binutils for avrxmega3 .rodata support) 3928 cat > conftest.s <<EOF 3929 .section .rodata,"a",@progbits 3930 .global xxvaryy 3931 ;; avr-nm should print "... R xxvaryy", not "... D xxvaryy". 3932 xxvaryy: 3933 .word 1 3934EOF 3935 rm -f conftest.nm 3936 AC_TRY_COMMAND([$gcc_cv_as -mmcu=avrxmega3 conftest.s -o conftest.o]) 3937 AC_TRY_COMMAND([$gcc_cv_ld -mavrxmega3 conftest.o -o conftest.elf]) 3938 AC_TRY_COMMAND([$gcc_cv_nm conftest.elf > conftest.nm]) 3939 if test -s conftest.nm 3940 then 3941 if grep ' R xxvaryy' conftest.nm > /dev/null; then 3942 AC_MSG_RESULT(yes) 3943 AC_DEFINE(HAVE_LD_AVR_AVRXMEGA3_RODATA_IN_FLASH, 1, 3944 [Define if your default avr linker script for avrxmega3 leaves .rodata in flash.]) 3945 else 3946 AC_MSG_RESULT(no: avrxmega3 .rodata located in RAM) 3947 echo "$as_me: nm output was" >&AS_MESSAGE_LOG_FD 3948 cat conftest.nm >&AS_MESSAGE_LOG_FD 3949 avr_ld_ver="`$gcc_cv_ld -v | sed -e 's:^.* ::'`" 3950 AC_MSG_WARN([[support for avrxmega3 .rodata in flash needs Binutils 2.29 or higher (have $avr_ld_ver)]]) 3951 fi 3952 else 3953 AC_MSG_RESULT(test failed) 3954 echo "$as_me: failed program was" >&AS_MESSAGE_LOG_FD 3955 cat conftest.s >&AS_MESSAGE_LOG_FD 3956 AC_MSG_WARN([[see `config.log' for details]]) 3957 fi 3958 rm -f conftest.s conftest.o conftest.elf conftest.nm 3959 ;; 3960 3961 cris-*-*) 3962 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option], 3963 gcc_cv_as_cris_no_mul_bug,[2,15,91], 3964 [-no-mul-bug-abort], [.text],, 3965 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1, 3966 [Define if your assembler supports the -no-mul-bug-abort option.])]) 3967 ;; 3968 3969 sparc*-*-*) 3970 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,, 3971 [.register %g2, #scratch],, 3972 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1, 3973 [Define if your assembler supports .register.])]) 3974 3975 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,, 3976 [-relax], [.text],, 3977 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1, 3978 [Define if your assembler supports -relax option.])]) 3979 3980 gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs], 3981 gcc_cv_as_sparc_gotdata_op,, 3982 [-K PIC], 3983[.text 3984.align 4 3985foo: 3986 nop 3987bar: 3988 sethi %gdop_hix22(foo), %g1 3989 xor %g1, %gdop_lox10(foo), %g1 3990 ld [[%l7 + %g1]], %g2, %gdop(foo)], 3991 [if test x$gcc_cv_ld != x \ 3992 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then 3993 if test x$gcc_cv_objdump != x; then 3994 if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \ 3995 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then 3996 gcc_cv_as_sparc_gotdata_op=no 3997 else 3998 gcc_cv_as_sparc_gotdata_op=yes 3999 fi 4000 fi 4001 fi 4002 rm -f conftest], 4003 [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1, 4004 [Define if your assembler and linker support GOTDATA_OP relocs.])]) 4005 4006 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs], 4007 gcc_cv_as_sparc_ua_pcrel,, 4008 [-K PIC], 4009[.text 4010foo: 4011 nop 4012.data 4013.align 4 4014.byte 0 4015.uaword %r_disp32(foo)], 4016 [if test x$gcc_cv_ld != x \ 4017 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then 4018 gcc_cv_as_sparc_ua_pcrel=yes 4019 fi 4020 rm -f conftest], 4021 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1, 4022 [Define if your assembler and linker support unaligned PC relative relocs.]) 4023 4024 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols], 4025 gcc_cv_as_sparc_ua_pcrel_hidden,, 4026 [-K PIC], 4027[.data 4028.align 4 4029.byte 0x31 4030.uaword %r_disp32(foo) 4031.byte 0x32, 0x33, 0x34 4032.global foo 4033.hidden foo 4034foo: 4035.skip 4], 4036 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \ 4037 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \ 4038 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \ 4039 | grep ' 31000000 07323334' > /dev/null 2>&1; then 4040 if $gcc_cv_objdump -R conftest 2> /dev/null \ 4041 | grep 'DISP32' > /dev/null 2>&1; then 4042 : 4043 else 4044 gcc_cv_as_sparc_ua_pcrel_hidden=yes 4045 fi 4046 fi 4047 rm -f conftest], 4048 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1, 4049 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])]) 4050 ]) # unaligned pcrel relocs 4051 4052 gcc_GAS_CHECK_FEATURE([offsetable %lo()], 4053 gcc_cv_as_sparc_offsetable_lo10,, 4054 [-xarch=v9], 4055[.text 4056 or %g1, %lo(ab) + 12, %g1 4057 or %g1, %lo(ab + 12), %g1], 4058 [if test x$gcc_cv_objdump != x \ 4059 && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \ 4060 | grep ' 82106000 82106000' > /dev/null 2>&1; then 4061 gcc_cv_as_sparc_offsetable_lo10=yes 4062 fi], 4063 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1, 4064 [Define if your assembler supports offsetable %lo().])]) 4065 4066 gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions], 4067 gcc_cv_as_sparc_fmaf,, 4068 [-xarch=v9d], 4069 [.text 4070 .register %g2, #scratch 4071 .register %g3, #scratch 4072 .align 4 4073 fmaddd %f0, %f2, %f4, %f6 4074 addxccc %g1, %g2, %g3 4075 fsrl32 %f2, %f4, %f8 4076 fnaddd %f10, %f12, %f14],, 4077 [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1, 4078 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])]) 4079 4080 gcc_GAS_CHECK_FEATURE([SPARC4 instructions], 4081 gcc_cv_as_sparc_sparc4,, 4082 [-xarch=sparc4], 4083 [.text 4084 .register %g2, #scratch 4085 .register %g3, #scratch 4086 .align 4 4087 cxbe %g2, %g3, 1f 40881: cwbneg %g2, %g3, 1f 40891: sha1 4090 md5 4091 aes_kexpand0 %f4, %f6, %f8 4092 des_round %f38, %f40, %f42, %f44 4093 camellia_f %f54, %f56, %f58, %f60 4094 kasumi_fi_xor %f46, %f48, %f50, %f52],, 4095 [AC_DEFINE(HAVE_AS_SPARC4, 1, 4096 [Define if your assembler supports SPARC4 instructions.])]) 4097 4098 gcc_GAS_CHECK_FEATURE([SPARC5 and VIS 4.0 instructions], 4099 gcc_cv_as_sparc_sparc5,, 4100 [-xarch=sparc5], 4101 [.text 4102 .register %g2, #scratch 4103 .register %g3, #scratch 4104 .align 4 4105 subxc %g1, %g2, %g3 4106 fpadd8 %f0, %f2, %f4],, 4107 [AC_DEFINE(HAVE_AS_SPARC5_VIS4, 1, 4108 [Define if your assembler supports SPARC5 and VIS 4.0 instructions.])]) 4109 4110 gcc_GAS_CHECK_FEATURE([SPARC6 instructions], 4111 gcc_cv_as_sparc_sparc6,, 4112 [-xarch=sparc6], 4113 [.text 4114 .register %g2, #scratch 4115 .register %g3, #scratch 4116 .align 4 4117 rd %entropy, %g1 4118 fpsll64x %f0, %f2, %f4],, 4119 [AC_DEFINE(HAVE_AS_SPARC6, 1, 4120 [Define if your assembler supports SPARC6 instructions.])]) 4121 4122 gcc_GAS_CHECK_FEATURE([LEON instructions], 4123 gcc_cv_as_sparc_leon,, 4124 [-Aleon], 4125 [.text 4126 .register %g2, #scratch 4127 .register %g3, #scratch 4128 .align 4 4129 smac %g2, %g3, %g1 4130 umac %g2, %g3, %g1 4131 casa [[%g2]] 0xb, %g3, %g1],, 4132 [AC_DEFINE(HAVE_AS_LEON, 1, 4133 [Define if your assembler supports LEON instructions.])]) 4134 ;; 4135 4136changequote(,)dnl 4137 i[34567]86-*-* | x86_64-*-*) 4138changequote([,])dnl 4139 case $target_os in 4140 cygwin*) 4141 # Full C++ conformance when using a shared libstdc++-v3 requires some 4142 # support from the Cygwin DLL, which in more recent versions exports 4143 # wrappers to aid in interposing and redirecting operators new, delete, 4144 # etc., as per n2800 #17.6.4.6 [replacement.functions]. Check if we 4145 # are configuring for a version of Cygwin that exports the wrappers. 4146 if test x$host = x$target && test x$host_cpu = xi686; then 4147 AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no]) 4148 else 4149 # Can't check presence of libc functions during cross-compile, so 4150 # we just have to assume we're building for an up-to-date target. 4151 gcc_ac_cygwin_dll_wrappers=yes 4152 fi 4153 AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS, 4154 [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`], 4155 [Define if you want to generate code by default that assumes that the 4156 Cygwin DLL exports wrappers to support libstdc++ function replacement.]) 4157 esac 4158 case $target_os in 4159 cygwin* | pe | mingw32*) 4160 # Recent binutils allows the three-operand form of ".comm" on PE. This 4161 # definition is used unconditionally to initialise the default state of 4162 # the target option variable that governs usage of the feature. 4163 gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align, 4164 [2,19,52],,[.comm foo,1,32]) 4165 AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM, 4166 [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`], 4167 [Define if your assembler supports specifying the alignment 4168 of objects allocated using the GAS .comm command.]) 4169 # Used for DWARF 2 in PE 4170 gcc_GAS_CHECK_FEATURE([.secrel32 relocs], 4171 gcc_cv_as_ix86_pe_secrel32, 4172 [2,15,91],, 4173[.text 4174foo: nop 4175.data 4176 .secrel32 foo], 4177 [if test x$gcc_cv_ld != x \ 4178 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then 4179 gcc_cv_as_ix86_pe_secrel32=yes 4180 fi 4181 rm -f conftest], 4182 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1, 4183 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])]) 4184 # Test if the assembler supports the extended form of the .section 4185 # directive that specifies section alignment. LTO support uses this, 4186 # but normally only after installation, so we warn but don't fail the 4187 # configure if LTO is enabled but the assembler does not support it. 4188 gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align, 4189 [2,20,1],-fatal-warnings,[.section lto_test,"dr0"]) 4190 if test x$gcc_cv_as_section_has_align != xyes; then 4191 case ",$enable_languages," in 4192 *,lto,*) 4193 AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.]) 4194 ;; 4195 esac 4196 fi 4197 ;; 4198 esac 4199 4200 gcc_GAS_CHECK_FEATURE([-xbrace_comment], gcc_cv_as_ix86_xbrace_comment,, 4201 [-xbrace_comment=no], [.text],, 4202 [AC_DEFINE(HAVE_AS_XBRACE_COMMENT_OPTION, 1, 4203 [Define if your assembler supports -xbrace_comment option.])]) 4204 4205 # Test if the assembler supports the section flag 'e' for specifying 4206 # an excluded section. 4207 gcc_GAS_CHECK_FEATURE([.section with e], gcc_cv_as_section_has_e, 4208 [2,22,51], [--fatal-warnings], 4209[.section foo1,"e" 4210.byte 0,0,0,0]) 4211 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE, 4212 [`if test $gcc_cv_as_section_has_e = yes; then echo 1; else echo 0; fi`], 4213 [Define if your assembler supports specifying the section flag e.]) 4214 4215 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics], 4216 gcc_cv_as_ix86_filds,,, 4217 [filds (%ebp); fists (%ebp)],, 4218 [AC_DEFINE(HAVE_AS_IX86_FILDS, 1, 4219 [Define if your assembler uses filds and fists mnemonics.])]) 4220 4221 gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics], 4222 gcc_cv_as_ix86_fildq,,, 4223 [fildq (%ebp); fistpq (%ebp)],, 4224 [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1, 4225 [Define if your assembler uses fildq and fistq mnemonics.])]) 4226 4227 gcc_GAS_CHECK_FEATURE([cmov syntax], 4228 gcc_cv_as_ix86_cmov_sun_syntax,,, 4229 [cmovl.l %edx, %eax],, 4230 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1, 4231 [Define if your assembler supports the Sun syntax for cmov.])]) 4232 4233 gcc_GAS_CHECK_FEATURE([ffreep mnemonic], 4234 gcc_cv_as_ix86_ffreep,,, 4235 [ffreep %st(1)],, 4236 [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1, 4237 [Define if your assembler supports the ffreep mnemonic.])]) 4238 4239 gcc_GAS_CHECK_FEATURE([.quad directive], 4240 gcc_cv_as_ix86_quad,,, 4241 [.quad 0],, 4242 [AC_DEFINE(HAVE_AS_IX86_QUAD, 1, 4243 [Define if your assembler supports the .quad directive.])]) 4244 4245 gcc_GAS_CHECK_FEATURE([sahf mnemonic], 4246 gcc_cv_as_ix86_sahf,,, 4247 [.code64 4248 sahf],, 4249 [AC_DEFINE(HAVE_AS_IX86_SAHF, 1, 4250 [Define if your assembler supports the sahf mnemonic in 64bit mode.])]) 4251 4252 gcc_GAS_CHECK_FEATURE([interunit movq mnemonic], 4253 gcc_cv_as_ix86_interunit_movq,,, 4254 [.code64 4255 movq %mm0, %rax 4256 movq %rax, %xmm0]) 4257 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_INTERUNIT_MOVQ, 4258 [`if test $gcc_cv_as_ix86_interunit_movq = yes; then echo 1; else echo 0; fi`], 4259 [Define if your assembler supports interunit movq mnemonic.]) 4260 4261 gcc_GAS_CHECK_FEATURE([hle prefixes], 4262 gcc_cv_as_ix86_hle,,, 4263 [lock xacquire cmpxchg %esi, (%ecx)],, 4264 [AC_DEFINE(HAVE_AS_IX86_HLE, 1, 4265 [Define if your assembler supports HLE prefixes.])]) 4266 4267 gcc_GAS_CHECK_FEATURE([swap suffix], 4268 gcc_cv_as_ix86_swap,,, 4269 [movl.s %esp, %ebp],, 4270 [AC_DEFINE(HAVE_AS_IX86_SWAP, 1, 4271 [Define if your assembler supports the swap suffix.])]) 4272 4273 gcc_GAS_CHECK_FEATURE([different section symbol subtraction], 4274 gcc_cv_as_ix86_diff_sect_delta,,, 4275 [.section .rodata 4276.L1: 4277 .long .L2-.L1 4278 .long .L3-.L1 4279 .text 4280.L3: nop 4281.L2: nop],, 4282 [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1, 4283 [Define if your assembler supports the subtraction of symbols in different sections.])]) 4284 4285 gcc_GAS_CHECK_FEATURE([rep and lock prefix], 4286 gcc_cv_as_ix86_rep_lock_prefix,,, 4287 [rep movsl 4288 rep ret 4289 rep nop 4290 rep bsf %ecx, %eax 4291 rep bsr %ecx, %eax 4292 lock addl %edi, (%eax,%esi) 4293 lock orl $0, (%esp)],, 4294 [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1, 4295 [Define if the assembler supports 'rep <insn>, lock <insn>'.])]) 4296 4297 gcc_GAS_CHECK_FEATURE([ud2 mnemonic], 4298 gcc_cv_as_ix86_ud2,,, 4299 [ud2],, 4300 [AC_DEFINE(HAVE_AS_IX86_UD2, 1, 4301 [Define if your assembler supports the 'ud2' mnemonic.])]) 4302 4303 # Enforce 32-bit output with gas and gld. 4304 if test x$gas = xyes; then 4305 as_ix86_gas_32_opt="--32" 4306 fi 4307 if echo "$ld_ver" | grep GNU > /dev/null; then 4308 if $gcc_cv_ld -V 2>/dev/null | grep elf_i386_sol2 > /dev/null; then 4309 ld_ix86_gld_32_opt="-melf_i386_sol2" 4310 else 4311 ld_ix86_gld_32_opt="-melf_i386" 4312 fi 4313 fi 4314 4315 gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc], 4316 gcc_cv_as_ix86_tlsgdplt,, 4317 [$as_ix86_gas_32_opt], 4318 [call tls_gd@tlsgdplt], 4319 [if test x$gcc_cv_ld != x \ 4320 && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o -G > /dev/null 2>&1; then 4321 gcc_cv_as_ix86_tlsgdplt=yes 4322 fi 4323 rm -f conftest], 4324 [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1, 4325 [Define if your assembler and linker support @tlsgdplt.])]) 4326 4327 conftest_s=' 4328 .section .tdata,"aw'$tls_section_flag'",@progbits 4329tls_ld: 4330 .section .text,"ax",@progbits 4331 call tls_ld@tlsldmplt' 4332 4333 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc], 4334 gcc_cv_as_ix86_tlsldmplt,, 4335 [$as_ix86_gas_32_opt], 4336 [$conftest_s], 4337 [if test x$gcc_cv_ld != x \ 4338 && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o -G > /dev/null 2>&1; then 4339 gcc_cv_as_ix86_tlsldmplt=yes 4340 fi 4341 rm -f conftest]) 4342 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDMPLT, 4343 [`if test $gcc_cv_as_ix86_tlsldmplt = yes; then echo 1; else echo 0; fi`], 4344 [Define to 1 if your assembler and linker support @tlsldmplt.]) 4345 4346 conftest_s=' 4347 .section .text,"ax",@progbits 4348 .globl _start 4349 .type _start, @function 4350_start: 4351 leal value@tlsldm(%ebx), %eax 4352 call ___tls_get_addr@plt 4353 4354 .section .tdata,"aw'$tls_section_flag'",@progbits 4355 .type value, @object 4356value:' 4357 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM reloc], 4358 gcc_cv_as_ix86_tlsldm,, 4359 [$as_ix86_gas_32_opt], 4360 [$conftest_s], 4361 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \ 4362 && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o $ld_tls_libs -lc > /dev/null 2>&1; then 4363 if $gcc_cv_objdump -d conftest 2>/dev/null | grep nop > /dev/null \ 4364 || dis conftest 2>/dev/null | grep nop > /dev/null; then 4365 gcc_cv_as_ix86_tlsldm=yes 4366 fi 4367 fi 4368 rm -f conftest]) 4369 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDM, 4370 [`if test $gcc_cv_as_ix86_tlsldm = yes; then echo 1; else echo 0; fi`], 4371 [Define to 1 if your assembler and linker support @tlsldm.]) 4372 4373 conftest_s=' 4374 .data 4375bar: 4376 .byte 1 4377 .text 4378 .global _start 4379_start: 4380 cmpl $0, bar@GOT 4381 jmp *_start@GOT' 4382 gcc_GAS_CHECK_FEATURE([R_386_GOT32X reloc], 4383 gcc_cv_as_ix86_got32x,, 4384 [$as_ix86_gas_32_opt], 4385 [$conftest_s], 4386 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \ 4387 && test x$gcc_cv_readelf != x \ 4388 && $gcc_cv_readelf --relocs --wide conftest.o 2>&1 \ 4389 | grep R_386_GOT32X > /dev/null 2>&1 \ 4390 && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o > /dev/null 2>&1; then 4391 if $gcc_cv_objdump -dw conftest 2>&1 \ 4392 | grep 0xffffff > /dev/null 2>&1; then 4393 gcc_cv_as_ix86_got32x=no 4394 else 4395 gcc_cv_as_ix86_got32x=yes 4396 fi 4397 fi 4398 rm -f conftest]) 4399 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_GOT32X, 4400 [`if test x"$gcc_cv_as_ix86_got32x" = xyes; then echo 1; else echo 0; fi`], 4401 [Define 0/1 if your assembler and linker support @GOT.]) 4402 4403 gcc_GAS_CHECK_FEATURE([GOTOFF in data], 4404 gcc_cv_as_ix86_gotoff_in_data, [2,11,0], 4405 [$as_ix86_gas_32_opt], 4406[ .text 4407.L0: 4408 nop 4409 .data 4410 .long .L0@GOTOFF]) 4411 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA, 4412 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`], 4413 [Define true if the assembler supports '.long foo@GOTOFF'.]) 4414 4415 conftest_s=' 4416 .section .text,"ax",@progbits 4417 .globl _start 4418 .type _start, @function 4419_start: 4420 leal ld@tlsldm(%ecx), %eax 4421 call *___tls_get_addr@GOT(%ecx) 4422 leal gd@tlsgd(%ecx), %eax 4423 call *___tls_get_addr@GOT(%ecx) 4424 4425 .section .tdata,"aw'$tls_section_flag'",@progbits 4426 .type ld, @object 4427ld: 4428 .byte 0 4429 .globl gd 4430 .type gd, @object 4431gd: 4432 .byte 0' 4433 gcc_GAS_CHECK_FEATURE([calling ___tls_get_addr via GOT], 4434 gcc_cv_as_ix86_tls_get_addr_via_got,, 4435 [$as_ix86_gas_32_opt], 4436 [$conftest_s], 4437 [if test x$gcc_cv_ld != x \ 4438 && $gcc_cv_ld $ld_ix86_gld_32_opt -o conftest conftest.o > /dev/null 2>&1; then 4439 gcc_cv_as_ix86_tls_get_addr_via_got=yes 4440 fi 4441 rm -f conftest]) 4442 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLS_GET_ADDR_GOT, 4443 [`if test x"$gcc_cv_as_ix86_tls_get_addr_via_got" = xyes; then echo 1; else echo 0; fi`], 4444 [Define 0/1 if your assembler and linker support calling ___tls_get_addr via GOT.]) 4445 ;; 4446 4447 ia64*-*-*) 4448 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs], 4449 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],, 4450[ .text 4451 addl r15 = @ltoffx(x#), gp 4452 ;; 4453 ld8.mov r16 = [[r15]], x#],, 4454 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1, 4455 [Define if your assembler supports ltoffx and ldxmov relocations.])]) 4456 4457 ;; 4458 4459 powerpc*-*-*) 4460 4461 case $target in 4462 *-*-darwin*) 4463 gcc_GAS_CHECK_FEATURE([.machine directive support], 4464 gcc_cv_as_machine_directive,,, 4465 [ .machine ppc7400]) 4466 if test x$gcc_cv_as_machine_directive != xyes; then 4467 echo "*** This target requires an assembler supporting \".machine\"" >&2 4468 echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2 4469 test x$build = x$target && exit 1 4470 fi 4471 ;; 4472 esac 4473 4474 case $target in 4475 *-*-aix*) conftest_s=' .machine "pwr5" 4476 .csect .text[[PR]] 4477 mfcr 3,128';; 4478 *-*-darwin*) conftest_s=' .text 4479 mfcr r3,128';; 4480 *) conftest_s=' .machine power4 4481 .text 4482 mfcr 3,128';; 4483 esac 4484 4485 gcc_GAS_CHECK_FEATURE([mfcr field support], 4486 gcc_cv_as_powerpc_mfcrf, [2,14,0],, 4487 [$conftest_s],, 4488 [AC_DEFINE(HAVE_AS_MFCRF, 1, 4489 [Define if your assembler supports mfcr field.])]) 4490 4491 case $target in 4492 *-*-aix*) conftest_s=' .machine "pwr5" 4493 .csect .text[[PR]] 4494 popcntb 3,3';; 4495 *) conftest_s=' .machine power5 4496 .text 4497 popcntb 3,3';; 4498 esac 4499 4500 gcc_GAS_CHECK_FEATURE([popcntb support], 4501 gcc_cv_as_powerpc_popcntb, [2,17,0],, 4502 [$conftest_s],, 4503 [AC_DEFINE(HAVE_AS_POPCNTB, 1, 4504 [Define if your assembler supports popcntb field.])]) 4505 4506 case $target in 4507 *-*-aix*) conftest_s=' .machine "pwr5x" 4508 .csect .text[[PR]] 4509 frin 1,1';; 4510 *) conftest_s=' .machine power5 4511 .text 4512 frin 1,1';; 4513 esac 4514 4515 gcc_GAS_CHECK_FEATURE([fp round support], 4516 gcc_cv_as_powerpc_fprnd, [2,17,0],, 4517 [$conftest_s],, 4518 [AC_DEFINE(HAVE_AS_FPRND, 1, 4519 [Define if your assembler supports fprnd.])]) 4520 4521 case $target in 4522 *-*-aix*) conftest_s=' .machine "pwr6" 4523 .csect .text[[PR]] 4524 mffgpr 1,3';; 4525 *) conftest_s=' .machine power6 4526 .text 4527 mffgpr 1,3';; 4528 esac 4529 4530 gcc_GAS_CHECK_FEATURE([move fp gpr support], 4531 gcc_cv_as_powerpc_mfpgpr, [2,19,2],, 4532 [$conftest_s],, 4533 [AC_DEFINE(HAVE_AS_MFPGPR, 1, 4534 [Define if your assembler supports mffgpr and mftgpr.])]) 4535 4536 case $target in 4537 *-*-aix*) conftest_s=' .csect .text[[PR]] 4538LCF..0: 4539 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';; 4540 *-*-darwin*) 4541 conftest_s=' .text 4542LCF0: 4543 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';; 4544 *) conftest_s=' .text 4545.LCF0: 4546 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';; 4547 esac 4548 4549 gcc_GAS_CHECK_FEATURE([rel16 relocs], 4550 gcc_cv_as_powerpc_rel16, [2,17,0], -a32, 4551 [$conftest_s],, 4552 [AC_DEFINE(HAVE_AS_REL16, 1, 4553 [Define if your assembler supports R_PPC_REL16 relocs.])]) 4554 4555 case $target in 4556 *-*-aix*) conftest_s=' .machine "pwr6" 4557 .csect .text[[PR]] 4558 cmpb 3,4,5';; 4559 *) conftest_s=' .machine power6 4560 .text 4561 cmpb 3,4,5';; 4562 esac 4563 4564 gcc_GAS_CHECK_FEATURE([compare bytes support], 4565 gcc_cv_as_powerpc_cmpb, [2,19,2], -a32, 4566 [$conftest_s],, 4567 [AC_DEFINE(HAVE_AS_CMPB, 1, 4568 [Define if your assembler supports cmpb.])]) 4569 4570 case $target in 4571 *-*-aix*) conftest_s=' .machine "pwr6" 4572 .csect .text[[PR]] 4573 dadd 1,2,3';; 4574 *) conftest_s=' .machine power6 4575 .text 4576 dadd 1,2,3';; 4577 esac 4578 4579 gcc_GAS_CHECK_FEATURE([decimal float support], 4580 gcc_cv_as_powerpc_dfp, [2,19,2], -a32, 4581 [$conftest_s],, 4582 [AC_DEFINE(HAVE_AS_DFP, 1, 4583 [Define if your assembler supports DFP instructions.])]) 4584 4585 case $target in 4586 *-*-aix*) conftest_s=' .machine "pwr7" 4587 .csect .text[[PR]] 4588 lxvd2x 1,2,3';; 4589 *) conftest_s=' .machine power7 4590 .text 4591 lxvd2x 1,2,3';; 4592 esac 4593 4594 gcc_GAS_CHECK_FEATURE([vector-scalar support], 4595 gcc_cv_as_powerpc_vsx, [2,19,2], -a32, 4596 [$conftest_s],, 4597 [AC_DEFINE(HAVE_AS_VSX, 1, 4598 [Define if your assembler supports VSX instructions.])]) 4599 4600 case $target in 4601 *-*-aix*) conftest_s=' .machine "pwr7" 4602 .csect .text[[PR]] 4603 popcntd 3,3';; 4604 *) conftest_s=' .machine power7 4605 .text 4606 popcntd 3,3';; 4607 esac 4608 4609 gcc_GAS_CHECK_FEATURE([popcntd support], 4610 gcc_cv_as_powerpc_popcntd, [2,19,2], -a32, 4611 [$conftest_s],, 4612 [AC_DEFINE(HAVE_AS_POPCNTD, 1, 4613 [Define if your assembler supports POPCNTD instructions.])]) 4614 4615 case $target in 4616 *-*-aix*) conftest_s=' .machine "pwr8" 4617 .csect .text[[PR]]';; 4618 *) conftest_s=' .machine power8 4619 .text';; 4620 esac 4621 4622 gcc_GAS_CHECK_FEATURE([power8 support], 4623 gcc_cv_as_powerpc_power8, [2,19,2], -a32, 4624 [$conftest_s],, 4625 [AC_DEFINE(HAVE_AS_POWER8, 1, 4626 [Define if your assembler supports POWER8 instructions.])]) 4627 4628 case $target in 4629 *-*-aix*) conftest_s=' .machine "pwr9" 4630 .csect .text[[PR]]';; 4631 *) conftest_s=' .machine power9 4632 .text';; 4633 esac 4634 4635 gcc_GAS_CHECK_FEATURE([power9 support], 4636 gcc_cv_as_powerpc_power9, [2,19,2], -a32, 4637 [$conftest_s],, 4638 [AC_DEFINE(HAVE_AS_POWER9, 1, 4639 [Define if your assembler supports POWER9 instructions.])]) 4640 4641 case $target in 4642 *-*-aix*) conftest_s=' .csect .text[[PR]] 4643 lwsync';; 4644 *) conftest_s=' .text 4645 lwsync';; 4646 esac 4647 4648 gcc_GAS_CHECK_FEATURE([lwsync support], 4649 gcc_cv_as_powerpc_lwsync, [2,19,2], -a32, 4650 [$conftest_s],, 4651 [AC_DEFINE(HAVE_AS_LWSYNC, 1, 4652 [Define if your assembler supports LWSYNC instructions.])]) 4653 4654 case $target in 4655 *-*-aix*) conftest_s=' .machine "476" 4656 .csect .text[[PR]] 4657 dci 0';; 4658 *) conftest_s=' .machine "476" 4659 .text 4660 dci 0';; 4661 esac 4662 4663 gcc_GAS_CHECK_FEATURE([data cache invalidate support], 4664 gcc_cv_as_powerpc_dci, [9,99,0], -a32, 4665 [$conftest_s],, 4666 [AC_DEFINE(HAVE_AS_DCI, 1, 4667 [Define if your assembler supports the DCI/ICI instructions.])]) 4668 4669 gcc_GAS_CHECK_FEATURE([.gnu_attribute support], 4670 gcc_cv_as_powerpc_gnu_attribute, [2,18,0],, 4671 [.gnu_attribute 4,1],, 4672 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1, 4673 [Define if your assembler supports .gnu_attribute.])]) 4674 4675 gcc_GAS_CHECK_FEATURE([tls marker support], 4676 gcc_cv_as_powerpc_tls_markers, [2,20,0],, 4677 [ bl __tls_get_addr(x@tlsgd)],, 4678 [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1, 4679 [Define if your assembler supports arg info for __tls_get_addr.])]) 4680 4681 gcc_GAS_CHECK_FEATURE([prologue entry point marker support], 4682 gcc_cv_as_powerpc_entry_markers, [2,26,0],-a64 --fatal-warnings, 4683 [ .reloc .,R_PPC64_ENTRY; nop],, 4684 [AC_DEFINE(HAVE_AS_ENTRY_MARKERS, 1, 4685 [Define if your assembler supports the R_PPC64_ENTRY relocation.])]) 4686 4687 case $target in 4688 *-*-aix*) 4689 gcc_GAS_CHECK_FEATURE([AIX .ref support], 4690 gcc_cv_as_aix_ref, [2,21,0],, 4691 [ .csect stuff[[rw]] 4692 stuff: 4693 .long 1 4694 .extern sym 4695 .ref sym 4696 ],, 4697 [AC_DEFINE(HAVE_AS_REF, 1, 4698 [Define if your assembler supports .ref])]) 4699 4700 gcc_GAS_CHECK_FEATURE([AIX DWARF location lists section support], 4701 gcc_cv_as_aix_dwloc, [2,21,0],, 4702 [ .dwsect 0xA0000 4703 Lframe..0: 4704 .vbyte 4,Lframe..0 4705 ],, 4706 [AC_DEFINE(HAVE_XCOFF_DWARF_EXTRAS, 1, 4707 [Define if your assembler supports AIX debug frame section label reference.])]) 4708 ;; 4709 esac 4710 ;; 4711 4712 mips*-*-*) 4713 gcc_GAS_CHECK_FEATURE([explicit relocation support], 4714 gcc_cv_as_mips_explicit_relocs, [2,14,0],, 4715[ lw $4,%gp_rel(foo)($4)],, 4716 [if test x$target_cpu_default = x 4717 then target_cpu_default=MASK_EXPLICIT_RELOCS 4718 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS" 4719 fi]) 4720 4721 gcc_GAS_CHECK_FEATURE([-mno-shared support], 4722 gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],, 4723 [AC_DEFINE(HAVE_AS_NO_SHARED, 1, 4724 [Define if the assembler understands -mno-shared.])]) 4725 4726 gcc_GAS_CHECK_FEATURE([.gnu_attribute support], 4727 gcc_cv_as_mips_gnu_attribute, [2,18,0],, 4728 [.gnu_attribute 4,1],, 4729 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1, 4730 [Define if your assembler supports .gnu_attribute.])]) 4731 4732 gcc_GAS_CHECK_FEATURE([.module support], 4733 gcc_cv_as_mips_dot_module,,[-32], 4734 [.module mips2 4735 .module fp=xx],, 4736 [AC_DEFINE(HAVE_AS_DOT_MODULE, 1, 4737 [Define if your assembler supports .module.])]) 4738 if test x$gcc_cv_as_mips_dot_module = xno \ 4739 && test x$with_fp_32 != x; then 4740 AC_MSG_ERROR( 4741 [Requesting --with-fp-32= requires assembler support for .module.]) 4742 fi 4743 4744 gcc_GAS_CHECK_FEATURE([.micromips support], 4745 gcc_cv_as_micromips_support,,[--fatal-warnings], 4746 [.set micromips],, 4747 [AC_DEFINE(HAVE_GAS_MICROMIPS, 1, 4748 [Define if your assembler supports the .set micromips directive])]) 4749 4750 gcc_GAS_CHECK_FEATURE([.dtprelword support], 4751 gcc_cv_as_mips_dtprelword, [2,18,0],, 4752 [.section .tdata,"awT",@progbits 4753x: 4754 .word 2 4755 .text 4756 .dtprelword x+0x8000],, 4757 [AC_DEFINE(HAVE_AS_DTPRELWORD, 1, 4758 [Define if your assembler supports .dtprelword.])]) 4759 4760 gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support], 4761 gcc_cv_as_mips_dspr1_mult,,, 4762[ .set mips32r2 4763 .set nodspr2 4764 .set dsp 4765 madd $ac3,$4,$5 4766 maddu $ac3,$4,$5 4767 msub $ac3,$4,$5 4768 msubu $ac3,$4,$5 4769 mult $ac3,$4,$5 4770 multu $ac3,$4,$5],, 4771 [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1, 4772 [Define if your assembler supports DSPR1 mult.])]) 4773 4774 AC_MSG_CHECKING(assembler and linker for explicit JALR relocation) 4775 gcc_cv_as_ld_jalr_reloc=no 4776 if test $gcc_cv_as_mips_explicit_relocs = yes; then 4777 if test $in_tree_ld = yes ; then 4778 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 \ 4779 && test $in_tree_ld_is_elf = yes; then 4780 gcc_cv_as_ld_jalr_reloc=yes 4781 fi 4782 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then 4783 echo ' .ent x' > conftest.s 4784 echo 'x: lw $2,%got_disp(y)($3)' >> conftest.s 4785 echo ' lw $25,%call16(y)($28)' >> conftest.s 4786 echo ' .reloc 1f,R_MIPS_JALR,y' >> conftest.s 4787 echo '1: jalr $25' >> conftest.s 4788 echo ' .reloc 1f,R_MIPS_JALR,x' >> conftest.s 4789 echo '1: jalr $25' >> conftest.s 4790 echo ' .end x' >> conftest.s 4791 if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \ 4792 && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then 4793 if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \ 4794 && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then 4795 gcc_cv_as_ld_jalr_reloc=yes 4796 fi 4797 fi 4798 rm -f conftest.* 4799 fi 4800 fi 4801 if test $gcc_cv_as_ld_jalr_reloc = yes; then 4802 if test x$target_cpu_default = x; then 4803 target_cpu_default=MASK_RELAX_PIC_CALLS 4804 else 4805 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS" 4806 fi 4807 fi 4808 AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc) 4809 4810 AC_CACHE_CHECK([linker for .eh_frame personality relaxation], 4811 [gcc_cv_ld_mips_personality_relaxation], 4812 [gcc_cv_ld_mips_personality_relaxation=no 4813 if test $in_tree_ld = yes ; then 4814 if test "$gcc_cv_gld_major_version" -eq 2 \ 4815 -a "$gcc_cv_gld_minor_version" -ge 21 \ 4816 -o "$gcc_cv_gld_major_version" -gt 2; then 4817 gcc_cv_ld_mips_personality_relaxation=yes 4818 fi 4819 elif test x$gcc_cv_as != x \ 4820 -a x$gcc_cv_ld != x \ 4821 -a x$gcc_cv_readelf != x ; then 4822 cat > conftest.s <<EOF 4823 .cfi_startproc 4824 .cfi_personality 0x80,indirect_ptr 4825 .ent test 4826test: 4827 nop 4828 .end test 4829 .cfi_endproc 4830 4831 .section .data,"aw",@progbits 4832indirect_ptr: 4833 .dc.a personality 4834EOF 4835 if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \ 4836 && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then 4837 if $gcc_cv_readelf -d conftest 2>&1 \ 4838 | grep TEXTREL > /dev/null 2>&1; then 4839 : 4840 elif $gcc_cv_readelf --relocs conftest 2>&1 \ 4841 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then 4842 : 4843 else 4844 gcc_cv_ld_mips_personality_relaxation=yes 4845 fi 4846 fi 4847 fi 4848 rm -f conftest.s conftest.o conftest]) 4849 if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then 4850 AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1, 4851 [Define if your linker can relax absolute .eh_frame personality 4852pointers into PC-relative form.]) 4853 fi 4854 4855 gcc_GAS_CHECK_FEATURE([-mnan= support], 4856 gcc_cv_as_mips_nan,, 4857 [-mnan=2008],,, 4858 [AC_DEFINE(HAVE_AS_NAN, 1, 4859 [Define if the assembler understands -mnan=.])]) 4860 if test x$gcc_cv_as_mips_nan = xno \ 4861 && test x$with_nan != x; then 4862 AC_MSG_ERROR( 4863 [Requesting --with-nan= requires assembler support for -mnan=]) 4864 fi 4865 ;; 4866 s390*-*-*) 4867 gcc_GAS_CHECK_FEATURE([.gnu_attribute support], 4868 gcc_cv_as_s390_gnu_attribute, [2,18,0],, 4869 [.gnu_attribute 8,1],, 4870 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1, 4871 [Define if your assembler supports .gnu_attribute.])]) 4872 gcc_GAS_CHECK_FEATURE([.machine and .machinemode support], 4873 gcc_cv_as_s390_machine_machinemode, [2,24,0],, 4874 [ .machinemode push 4875 .machinemode pop 4876 .machine push 4877 .machine pop],, 4878 [AC_DEFINE(HAVE_AS_MACHINE_MACHINEMODE, 1, 4879 [Define if your assembler supports .machine and .machinemode.])]) 4880 gcc_GAS_CHECK_FEATURE([architecture modifiers support], 4881 gcc_cv_as_s390_architecture_modifiers, [2,26,0],, 4882 [ .machine z13+vx ],, 4883 [AC_DEFINE(HAVE_AS_ARCHITECTURE_MODIFIERS, 1, 4884 [Define if your assembler supports architecture modifiers.])]) 4885 ;; 4886esac 4887 4888# Mips and HP-UX need the GNU assembler. 4889# Linux on IA64 might be able to use the Intel assembler. 4890 4891case "$target" in 4892 mips*-*-* | *-*-hpux* ) 4893 if test x$gas_flag = xyes \ 4894 || test x"$host" != x"$build" \ 4895 || test ! -x "$gcc_cv_as" \ 4896 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then 4897 : 4898 else 4899 echo "*** This configuration requires the GNU assembler" >&2 4900 exit 1 4901 fi 4902 ;; 4903esac 4904 4905# ??? Not all targets support dwarf2 debug_line, even within a version 4906# of gas. Moreover, we need to emit a valid instruction to trigger any 4907# info to the output file. So, as supported targets are added to gas 2.11, 4908# add some instruction here to (also) show we expect this might work. 4909# ??? Once 2.11 is released, probably need to add first known working 4910# version to the per-target configury. 4911case "$cpu_type" in 4912 aarch64 | alpha | arc | arm | avr | bfin | cris | i386 | m32c | m68k \ 4913 | microblaze | mips | nios2 | pa | riscv | rs6000 | score | sparc | spu \ 4914 | tilegx | tilepro | visium | xstormy16 | xtensa) 4915 insn="nop" 4916 ;; 4917 ia64 | s390) 4918 insn="nop 0" 4919 ;; 4920 mmix) 4921 insn="swym 0" 4922 ;; 4923esac 4924if test x"$insn" != x; then 4925 conftest_s="\ 4926 .file 1 \"conftest.s\" 4927 .loc 1 3 0 4928 $insn" 4929 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support], 4930 gcc_cv_as_dwarf2_debug_line, 4931 [elf,2,11,0],, [$conftest_s], 4932 [if test x$gcc_cv_objdump != x \ 4933 && $gcc_cv_objdump -h conftest.o 2> /dev/null \ 4934 | grep debug_line > /dev/null 2>&1; then 4935 gcc_cv_as_dwarf2_debug_line=yes 4936 fi]) 4937 4938# The .debug_line file table must be in the exact order that 4939# we specified the files, since these indices are also used 4940# by DW_AT_decl_file. Approximate this test by testing if 4941# the assembler bitches if the same index is assigned twice. 4942 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive], 4943 gcc_cv_as_dwarf2_file_buggy,,, 4944[ .file 1 "foo.s" 4945 .file 1 "bar.s"]) 4946 4947 if test $gcc_cv_as_dwarf2_debug_line = yes \ 4948 && test $gcc_cv_as_dwarf2_file_buggy = no; then 4949 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1, 4950 [Define if your assembler supports dwarf2 .file/.loc directives, 4951 and preserves file table indices exactly as given.]) 4952 4953 if test $gcc_cv_as_leb128 = yes; then 4954 conftest_s="\ 4955 .file 1 \"conftest.s\" 4956 .loc 1 3 0 view .LVU1 4957 $insn 4958 .data 4959 .uleb128 .LVU1 4960 .uleb128 .LVU1 4961" 4962 gcc_GAS_CHECK_FEATURE([dwarf2 debug_view support], 4963 gcc_cv_as_dwarf2_debug_view, 4964 [elf,2,27,0],,[$conftest_s],, 4965 [AC_DEFINE(HAVE_AS_DWARF2_DEBUG_VIEW, 1, 4966 [Define if your assembler supports views in dwarf2 .loc directives.])]) 4967 fi 4968 fi 4969 4970 gcc_GAS_CHECK_FEATURE([--gdwarf2 option], 4971 gcc_cv_as_gdwarf2_flag, 4972 [elf,2,11,0], [--gdwarf2], [$insn],, 4973 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1, 4974[Define if your assembler supports the --gdwarf2 option.])]) 4975 4976 gcc_GAS_CHECK_FEATURE([--gstabs option], 4977 gcc_cv_as_gstabs_flag, 4978 [elf,2,11,0], [--gstabs], [$insn],, 4979 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1, 4980[Define if your assembler supports the --gstabs option.])]) 4981 4982 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option], 4983 gcc_cv_as_debug_prefix_map_flag, 4984 [2,18,0], [--debug-prefix-map /a=/b], [$insn],, 4985 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1, 4986[Define if your assembler supports the --debug-prefix-map option.])]) 4987fi 4988 4989gcc_GAS_CHECK_FEATURE([compressed debug sections], 4990 gcc_cv_as_compress_debug,,,, 4991 [# gas compiled without zlib cannot compress debug sections and warns 4992 # about it, but still exits successfully. So check for this, too. 4993 if $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null 4994 then 4995 gcc_cv_as_compress_debug=0 4996 # Since binutils 2.26, gas supports --compress-debug-sections=type, 4997 # defaulting to the ELF gABI format. 4998 elif $gcc_cv_as --compress-debug-sections=zlib-gnu -o conftest.o conftest.s > /dev/null 2>&1 4999 then 5000 gcc_cv_as_compress_debug=2 5001 gcc_cv_as_compress_debug_option="--compress-debug-sections" 5002 gcc_cv_as_no_compress_debug_option="--nocompress-debug-sections" 5003 # Before binutils 2.26, gas only supported --compress-debug-options and 5004 # emitted the traditional GNU format. 5005 elif $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s > /dev/null 2>&1 5006 then 5007 gcc_cv_as_compress_debug=1 5008 gcc_cv_as_compress_debug_option="--compress-debug-sections" 5009 gcc_cv_as_no_compress_debug_option="--nocompress-debug-sections" 5010 else 5011 gcc_cv_as_compress_debug=0 5012 fi]) 5013AC_DEFINE_UNQUOTED(HAVE_AS_COMPRESS_DEBUG, $gcc_cv_as_compress_debug, 5014[Define to the level of your assembler's compressed debug section support.]) 5015AC_DEFINE_UNQUOTED(AS_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_compress_debug_option", 5016[Define to the assembler option to enable compressed debug sections.]) 5017AC_DEFINE_UNQUOTED(AS_NO_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_no_compress_debug_option", 5018[Define to the assembler option to disable compressed debug sections.]) 5019 5020gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment, 5021 ,, 5022[.lcomm bar,4,16],, 5023[AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1, 5024 [Define if your assembler supports .lcomm with an alignment field.])]) 5025 5026if test x$with_sysroot = x && test x$host = x$target \ 5027 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \ 5028 && test "$prefix" != "NONE"; then 5029 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include", 5030[Define to PREFIX/include if cpp should also search that directory.]) 5031fi 5032 5033# Determine the version of glibc, if any, used on the target. 5034AC_MSG_CHECKING([for target glibc version]) 5035AC_ARG_WITH([glibc-version], 5036 [AS_HELP_STRING([--with-glibc-version=M.N], 5037 [assume GCC used with glibc version M.N or later])], [ 5038if [echo "$with_glibc_version" | grep '^[0-9][0-9]*\.[0-9][0-9]*$']; then 5039 glibc_version_major=`echo "$with_glibc_version" | sed -e 's/\..*//'` 5040 glibc_version_minor=`echo "$with_glibc_version" | sed -e 's/.*\.//'` 5041else 5042 AC_MSG_ERROR([option --with-glibc-version requires a version number M.N]) 5043fi], [ 5044glibc_version_major=0 5045glibc_version_minor=0 5046[if test -f $target_header_dir/features.h \ 5047 && glibc_version_major_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+[0-9]' $target_header_dir/features.h` \ 5048 && glibc_version_minor_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+[0-9]' $target_header_dir/features.h`; then 5049 glibc_version_major=`echo "$glibc_version_major_define" | sed -e 's/.*__GLIBC__[ ]*//'` 5050 glibc_version_minor=`echo "$glibc_version_minor_define" | sed -e 's/.*__GLIBC_MINOR__[ ]*//'` 5051fi]]) 5052AC_MSG_RESULT([$glibc_version_major.$glibc_version_minor]) 5053AC_DEFINE_UNQUOTED([TARGET_GLIBC_MAJOR], [$glibc_version_major], 5054[GNU C Library major version number used on the target, or 0.]) 5055AC_DEFINE_UNQUOTED([TARGET_GLIBC_MINOR], [$glibc_version_minor], 5056[GNU C Library minor version number used on the target, or 0.]) 5057 5058AC_ARG_ENABLE(gnu-unique-object, 5059 [AS_HELP_STRING([--enable-gnu-unique-object], 5060 [enable the use of the @gnu_unique_object ELF extension on glibc systems])], 5061 [case $enable_gnu_unique_object in 5062 yes | no) ;; 5063 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object. 5064Valid choices are 'yes' and 'no'.]) ;; 5065 esac], 5066 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object, 5067 [elf,2,19,52],, 5068 [.type foo, '$target_type_format_char'gnu_unique_object],, 5069# We need to unquote above to to use the definition from config.gcc. 5070# Also check for ld.so support, i.e. glibc 2.11 or higher. 5071 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [11], [enable_gnu_unique_object=yes], )] 5072 )]) 5073if test x$enable_gnu_unique_object = xyes; then 5074 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1, 5075 [Define if your assembler supports @gnu_unique_object.]) 5076fi 5077 5078AC_CACHE_CHECK([assembler for tolerance to line number 0], 5079 [gcc_cv_as_line_zero], 5080 [gcc_cv_as_line_zero=no 5081 if test $in_tree_gas = yes; then 5082 gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes]) 5083 elif test "x$gcc_cv_as" != x; then 5084 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s 5085 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) && 5086 test "x`cat conftest.out`" = x 5087 then 5088 gcc_cv_as_line_zero=yes 5089 else 5090 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD 5091 cat conftest.s >&AS_MESSAGE_LOG_FD 5092 echo "configure: error output was" >&AS_MESSAGE_LOG_FD 5093 cat conftest.out >&AS_MESSAGE_LOG_FD 5094 fi 5095 rm -f conftest.o conftest.s conftest.out 5096 fi]) 5097if test "x$gcc_cv_as_line_zero" = xyes; then 5098 AC_DEFINE([HAVE_AS_LINE_ZERO], 1, 5099[Define if the assembler won't complain about a line such as # 0 "" 2.]) 5100fi 5101 5102AC_MSG_CHECKING(support for thin archives) 5103thin_archive_support=no 5104echo 'int main (void) { return 0; }' > conftest.c 5105if ($AR --version | sed 1q | grep "GNU ar" \ 5106 && $CC $CFLAGS -c conftest.c \ 5107 && $AR rcT conftest.a conftest.o \ 5108 && $CC $CFLAGS $LDFLAGS -o conftest conftest.a) >/dev/null 2>&1; then 5109 thin_archive_support=yes 5110fi 5111rm -f conftest.c conftest.o conftest.a conftest 5112AC_MSG_RESULT($thin_archive_support) 5113AC_SUBST(thin_archive_support) 5114 5115AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support) 5116gcc_cv_ld_eh_frame_hdr=no 5117if test $in_tree_ld = yes ; then 5118 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 \ 5119 && test $in_tree_ld_is_elf = yes; then 5120 gcc_cv_ld_eh_frame_hdr=yes 5121 fi 5122elif test x$gcc_cv_ld != x; then 5123 if echo "$ld_ver" | grep GNU > /dev/null; then 5124 # Check if linker supports --eh-frame-hdr option 5125 if $gcc_cv_ld --help 2>&1 | grep eh-frame-hdr > /dev/null; then 5126 gcc_cv_ld_eh_frame_hdr=yes 5127 fi 5128 else 5129 case "$target" in 5130 *-*-solaris2*) 5131 # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251. 5132 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then 5133 gcc_cv_ld_eh_frame_hdr=yes 5134 fi 5135 ;; 5136 esac 5137 fi 5138fi 5139GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR]) 5140if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then 5141 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1, 5142[Define if your linker supports .eh_frame_hdr.]) 5143fi 5144AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr) 5145 5146AC_MSG_CHECKING(linker CIEv3 in .eh_frame support) 5147gcc_cv_ld_eh_frame_ciev3=no 5148if test $in_tree_ld = yes ; then 5149 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 \ 5150 && test $in_tree_ld_is_elf = yes; then 5151 gcc_cv_ld_eh_frame_ciev3=yes 5152 fi 5153elif test x$gcc_cv_ld != x; then 5154 if echo "$ld_ver" | grep GNU > /dev/null; then 5155 gcc_cv_ld_eh_frame_ciev3=yes 5156 if test 0"$ld_date" -lt 20040513; then 5157 if test -n "$ld_date"; then 5158 # If there was date string, but was earlier than 2004-05-13, fail 5159 gcc_cv_ld_eh_frame_ciev3=no 5160 elif test "$ld_vers_major" -lt 2; then 5161 gcc_cv_ld_eh_frame_ciev3=no 5162 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then 5163 gcc_cv_ld_eh_frame_ciev3=no 5164 fi 5165 fi 5166 else 5167 case "$target" in 5168 *-*-solaris2*) 5169 # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1. 5170 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then 5171 gcc_cv_ld_eh_frame_ciev3=yes 5172 fi 5173 ;; 5174 esac 5175 fi 5176fi 5177AC_DEFINE_UNQUOTED(HAVE_LD_EH_FRAME_CIEV3, 5178 [`if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi`], 5179 [Define 0/1 if your linker supports CIE v3 in .eh_frame.]) 5180AC_MSG_RESULT($gcc_cv_ld_eh_frame_ciev3) 5181 5182AC_MSG_CHECKING(linker position independent executable support) 5183gcc_cv_ld_pie=no 5184if test $in_tree_ld = yes ; then 5185 case "$target" in 5186 # Full PIE support on Solaris was only introduced in gld 2.26. 5187 *-*-solaris2*) gcc_gld_pie_min_version=26 ;; 5188 *) gcc_gld_pie_min_version=15 ;; 5189 esac 5190 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 \ 5191 && test $in_tree_ld_is_elf = yes; then 5192 gcc_cv_ld_pie=yes 5193 fi 5194elif test x$gcc_cv_ld != x; then 5195 # Check if linker supports -pie option 5196 if $gcc_cv_ld --help 2>&1 | grep -- -pie > /dev/null; then 5197 gcc_cv_ld_pie=yes 5198 case "$target" in 5199 *-*-solaris2*) 5200 if echo "$ld_ver" | grep GNU > /dev/null \ 5201 && test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 26; then 5202 gcc_cv_ld_pie=no 5203 fi 5204 ;; 5205 esac 5206 else 5207 case "$target" in 5208 *-*-solaris2.1[[1-9]]*) 5209 # Solaris 11.3 added PIE support. 5210 if $gcc_cv_ld -z help 2>&1 | grep -- type.*pie > /dev/null; then 5211 gcc_cv_ld_pie=yes 5212 fi 5213 ;; 5214 esac 5215 fi 5216fi 5217if test x"$gcc_cv_ld_pie" = xyes; then 5218 AC_DEFINE(HAVE_LD_PIE, 1, 5219[Define if your linker supports PIE option.]) 5220fi 5221AC_MSG_RESULT($gcc_cv_ld_pie) 5222 5223AC_MSG_CHECKING(linker PIE support with copy reloc) 5224gcc_cv_ld_pie_copyreloc=no 5225if test $gcc_cv_ld_pie = yes ; then 5226 if test $in_tree_ld = yes ; then 5227 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 5228 gcc_cv_ld_pie_copyreloc=yes 5229 fi 5230 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then 5231 # Check if linker supports -pie option with copy reloc 5232 case "$target" in 5233 i?86-*-linux* | x86_64-*-linux*) 5234 cat > conftest1.s <<EOF 5235 .globl a_glob 5236 .data 5237 .type a_glob, @object 5238 .size a_glob, 4 5239a_glob: 5240 .long 2 5241EOF 5242 cat > conftest2.s <<EOF 5243 .text 5244 .globl main 5245 .type main, @function 5246main: 5247 movl %eax, a_glob(%rip) 5248 .size main, .-main 5249 .globl ptr 5250 .section .data.rel,"aw",@progbits 5251 .type ptr, @object 5252ptr: 5253 .quad a_glob 5254EOF 5255 if $gcc_cv_as --64 -o conftest1.o conftest1.s > /dev/null 2>&1 \ 5256 && $gcc_cv_ld -shared -melf_x86_64 -o conftest1.so conftest1.o > /dev/null 2>&1 \ 5257 && $gcc_cv_as --64 -o conftest2.o conftest2.s > /dev/null 2>&1 \ 5258 && $gcc_cv_ld -pie -melf_x86_64 -o conftest conftest2.o conftest1.so > /dev/null 2>&1; then 5259 gcc_cv_ld_pie_copyreloc=yes 5260 fi 5261 rm -f conftest conftest1.so conftest1.o conftest2.o conftest1.s conftest2.s 5262 ;; 5263 esac 5264 fi 5265fi 5266AC_DEFINE_UNQUOTED(HAVE_LD_PIE_COPYRELOC, 5267 [`if test x"$gcc_cv_ld_pie_copyreloc" = xyes; then echo 1; else echo 0; fi`], 5268 [Define 0/1 if your linker supports -pie option with copy reloc.]) 5269AC_MSG_RESULT($gcc_cv_ld_pie_copyreloc) 5270 5271AC_MSG_CHECKING(linker EH-compatible garbage collection of sections) 5272gcc_cv_ld_eh_gc_sections=no 5273if test $in_tree_ld = yes ; then 5274 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 \ 5275 && test $in_tree_ld_is_elf = yes; then 5276 gcc_cv_ld_eh_gc_sections=yes 5277 fi 5278elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then 5279 cat > conftest.s <<EOF 5280 .section .text 5281.globl _start 5282 .type _start, @function 5283_start: 5284 .long foo 5285 .size _start, .-_start 5286 .section .text.foo,"ax",@progbits 5287 .type foo, @function 5288foo: 5289 .long 0 5290 .size foo, .-foo 5291 .section .gcc_except_table.foo,"a",@progbits 5292.L0: 5293 .long 0 5294 .section .eh_frame,"a",@progbits 5295 .long .L0 5296EOF 5297 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then 5298 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \ 5299 | grep "gc-sections option ignored" > /dev/null; then 5300 gcc_cv_ld_eh_gc_sections=no 5301 elif $gcc_cv_objdump -h conftest 2> /dev/null \ 5302 | grep gcc_except_table > /dev/null; then 5303 gcc_cv_ld_eh_gc_sections=yes 5304 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections. 5305 if test x$gcc_cv_as_comdat_group != xyes; then 5306 gcc_cv_ld_eh_gc_sections=no 5307 cat > conftest.s <<EOF 5308 .section .text 5309.globl _start 5310 .type _start, @function 5311_start: 5312 .long foo 5313 .size _start, .-_start 5314 .section .gnu.linkonce.t.foo,"ax",@progbits 5315 .type foo, @function 5316foo: 5317 .long 0 5318 .size foo, .-foo 5319 .section .gcc_except_table.foo,"a",@progbits 5320.L0: 5321 .long 0 5322 .section .eh_frame,"a",@progbits 5323 .long .L0 5324EOF 5325 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then 5326 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \ 5327 | grep "gc-sections option ignored" > /dev/null; then 5328 gcc_cv_ld_eh_gc_sections=no 5329 elif $gcc_cv_objdump -h conftest 2> /dev/null \ 5330 | grep gcc_except_table > /dev/null; then 5331 gcc_cv_ld_eh_gc_sections=yes 5332 fi 5333 fi 5334 fi 5335 fi 5336 fi 5337 rm -f conftest.s conftest.o conftest 5338fi 5339case "$target" in 5340 hppa*-*-linux*) 5341 # ??? This apparently exposes a binutils bug with PC-relative relocations. 5342 gcc_cv_ld_eh_gc_sections=no 5343 ;; 5344esac 5345if test x$gcc_cv_ld_eh_gc_sections = xyes; then 5346 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1, 5347 [Define if your linker supports garbage collection of 5348 sections in presence of EH frames.]) 5349fi 5350AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections) 5351 5352AC_MSG_CHECKING(linker EH garbage collection of sections bug) 5353gcc_cv_ld_eh_gc_sections_bug=no 5354if test $in_tree_ld = yes ; then 5355 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 \ 5356 && test $in_tree_ld_is_elf = yes; then 5357 gcc_cv_ld_eh_gc_sections_bug=yes 5358 fi 5359elif 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 5360 gcc_cv_ld_eh_gc_sections_bug=yes 5361 cat > conftest.s <<EOF 5362 .section .text 5363.globl _start 5364 .type _start, @function 5365_start: 5366 .long foo 5367 .size _start, .-_start 5368 .section .text.startup.foo,"ax",@progbits 5369 .type foo, @function 5370foo: 5371 .long 0 5372 .size foo, .-foo 5373 .section .gcc_except_table.foo,"a",@progbits 5374.L0: 5375 .long 0 5376 .section .eh_frame,"a",@progbits 5377 .long .L0 5378EOF 5379 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then 5380 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \ 5381 | grep "gc-sections option ignored" > /dev/null; then 5382 : 5383 elif $gcc_cv_objdump -h conftest 2> /dev/null \ 5384 | grep gcc_except_table > /dev/null; then 5385 gcc_cv_ld_eh_gc_sections_bug=no 5386 fi 5387 fi 5388 rm -f conftest.s conftest.o conftest 5389fi 5390if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then 5391 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1, 5392 [Define if your linker has buggy garbage collection of 5393 sections support when .text.startup.foo like sections are used.]) 5394fi 5395AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug) 5396 5397AC_MSG_CHECKING(linker for compressed debug sections) 5398# gold/gld support compressed debug sections since binutils 2.19/2.21 5399# In binutils 2.26, gld gained support for the ELF gABI format. 5400if test $in_tree_ld = yes ; then 5401 gcc_cv_ld_compress_debug=0 5402 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 \ 5403 && test $in_tree_ld_is_elf = yes && test $ld_is_gold = yes; then 5404 gcc_cv_ld_compress_debug=2 5405 gcc_cv_ld_compress_debug_option="--compress-debug-sections" 5406 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 \ 5407 && test $in_tree_ld_is_elf = yes && test $ld_is_gold = no; then 5408 gcc_cv_ld_compress_debug=3 5409 gcc_cv_ld_compress_debug_option="--compress-debug-sections" 5410 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 \ 5411 && test $in_tree_ld_is_elf = yes; then 5412 gcc_cv_ld_compress_debug=1 5413 fi 5414elif echo "$ld_ver" | grep GNU > /dev/null; then 5415 if test "$ld_vers_major" -lt 2 \ 5416 || test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 21; then 5417 gcc_cv_ld_compress_debug=0 5418 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 26; then 5419 gcc_cv_ld_compress_debug=1 5420 else 5421 gcc_cv_ld_compress_debug=3 5422 gcc_cv_ld_compress_debug_option="--compress-debug-sections" 5423 fi 5424 if test $ld_is_gold = yes; then 5425 gcc_cv_ld_compress_debug=2 5426 gcc_cv_ld_compress_debug_option="--compress-debug-sections" 5427 fi 5428else 5429changequote(,)dnl 5430 case "${target}" in 5431 *-*-solaris2*) 5432 # Introduced in Solaris 11.2. 5433 if $gcc_cv_ld --help 2>&1 | grep -- '-z compress-sections' > /dev/null; then 5434 gcc_cv_ld_compress_debug=3 5435 gcc_cv_ld_compress_debug_option="-z compress-sections" 5436 else 5437 gcc_cv_ld_compress_debug=0 5438 fi 5439 ;; 5440 *) 5441 # Assume linkers other than GNU ld don't support compessed debug 5442 # sections. 5443 gcc_cv_ld_compress_debug=0 5444 ;; 5445 esac 5446changequote([,])dnl 5447fi 5448AC_DEFINE_UNQUOTED(HAVE_LD_COMPRESS_DEBUG, $gcc_cv_ld_compress_debug, 5449[Define to the level of your linker's compressed debug section support.]) 5450AC_DEFINE_UNQUOTED(LD_COMPRESS_DEBUG_OPTION, "$gcc_cv_ld_compress_debug_option", 5451[Define to the linker option to enable compressed debug sections.]) 5452AC_MSG_RESULT($gcc_cv_ld_compress_debug) 5453 5454if test x"$ld64_flag" = x"yes"; then 5455 5456 # Set defaults for possibly untestable items. 5457 gcc_cv_ld64_export_dynamic=0 5458 5459 if test "$build" = "$host"; then 5460 darwin_try_test=1 5461 else 5462 darwin_try_test=0 5463 fi 5464 5465 # On Darwin, because of FAT library support, it is often possible to execute 5466 # exes from compatible archs even when the host differs from the build system. 5467 case "$build","$host" in 5468 x86_64-*-darwin*,i?86-*-darwin* | powerpc64*-*-darwin*,powerpc*-*-darwin*) 5469 darwin_try_test=1;; 5470 *) ;; 5471 esac 5472 5473 # If the configurer specified a minimum ld64 version to be supported, then use 5474 # that to determine feature support. 5475 if test x"${gcc_cv_ld64_version}" != x; then 5476 AC_MSG_CHECKING(ld64 specified version) 5477 gcc_cv_ld64_major=`echo "$gcc_cv_ld64_version" | sed -e 's/\..*//'` 5478 AC_MSG_RESULT($gcc_cv_ld64_major) 5479 if test "$gcc_cv_ld64_major" -ge 236; then 5480 gcc_cv_ld64_export_dynamic=1 5481 fi 5482 elif test -x "$gcc_cv_ld" -a "$darwin_try_test" -eq 1; then 5483 # If the version was not specified, try to find it. 5484 AC_MSG_CHECKING(linker version) 5485 if test x"${gcc_cv_ld64_version}" = x; then 5486 gcc_cv_ld64_version=`$gcc_cv_ld -v 2>&1 | grep ld64 | sed s/.*ld64-// | awk '{print $1}'` 5487 fi 5488 AC_MSG_RESULT($gcc_cv_ld64_version) 5489 5490 AC_MSG_CHECKING(linker for -export_dynamic support) 5491 gcc_cv_ld64_export_dynamic=1 5492 if $gcc_cv_ld -export_dynamic < /dev/null 2>&1 | grep 'unknown option' > /dev/null; then 5493 gcc_cv_ld64_export_dynamic=0 5494 fi 5495 AC_MSG_RESULT($gcc_cv_ld64_export_dynamic) 5496 fi 5497 5498 if test x"${gcc_cv_ld64_version}" != x; then 5499 AC_DEFINE_UNQUOTED(LD64_VERSION, "${gcc_cv_ld64_version}", 5500 [Define to ld64 version.]) 5501 fi 5502 5503 AC_DEFINE_UNQUOTED(LD64_HAS_EXPORT_DYNAMIC, $gcc_cv_ld64_export_dynamic, 5504 [Define to 1 if ld64 supports '-export_dynamic'.]) 5505fi 5506 5507# -------- 5508# UNSORTED 5509# -------- 5510 5511AC_CACHE_CHECK(linker --as-needed support, 5512gcc_cv_ld_as_needed, 5513[gcc_cv_ld_as_needed=no 5514gcc_cv_ld_as_needed_option='--as-needed' 5515gcc_cv_ld_no_as_needed_option='--no-as-needed' 5516if test $in_tree_ld = yes ; then 5517 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 \ 5518 && test $in_tree_ld_is_elf = yes; then 5519 gcc_cv_ld_as_needed=yes 5520 fi 5521elif test x$gcc_cv_ld != x; then 5522 # Check if linker supports --as-needed and --no-as-needed options 5523 if $gcc_cv_ld --help 2>&1 | grep as-needed > /dev/null; then 5524 gcc_cv_ld_as_needed=yes 5525 fi 5526 case "$target:$gnu_ld" in 5527 *-*-solaris2*:no) 5528 # Solaris 2 ld always supports -z ignore/-z record. Prefer the native 5529 # forms. 5530 gcc_cv_ld_as_needed=yes 5531 gcc_cv_ld_as_needed_option="-z ignore" 5532 gcc_cv_ld_no_as_needed_option="-z record" 5533 ;; 5534 esac 5535fi 5536# --as-needed/-z ignore can only be used if libgcc_s.so.1 uses 5537# dl_iterate_phdr, i.e. since Solaris 11. 5538case "$target" in 5539 *-*-solaris2.1[[1-9]]*) 5540 case "$target" in 5541 i?86-*-* | x86_64-*-*) 5542 if echo "$ld_ver" | grep GNU > /dev/null; then 5543 # Doesn't work with gld on Solaris/x86 due to PR ld/12320. 5544 gcc_cv_ld_as_needed=no 5545 fi 5546 ;; 5547 esac 5548 ;; 5549 *-*-solaris2*) 5550 gcc_cv_ld_as_needed=no 5551 ;; 5552esac 5553]) 5554if test x"$gcc_cv_ld_as_needed" = xyes; then 5555 AC_DEFINE(HAVE_LD_AS_NEEDED, 1, 5556[Define if your linker supports --as-needed/--no-as-needed or equivalent options.]) 5557 AC_DEFINE_UNQUOTED(LD_AS_NEEDED_OPTION, "$gcc_cv_ld_as_needed_option", 5558[Define to the linker option to ignore unused dependencies.]) 5559 AC_DEFINE_UNQUOTED(LD_NO_AS_NEEDED_OPTION, "$gcc_cv_ld_no_as_needed_option", 5560[Define to the linker option to keep unused dependencies.]) 5561fi 5562 5563AC_MSG_CHECKING(linker mapfile support for clearing hardware capabilities) 5564saved_LDFLAGS="$LDFLAGS" 5565for clearcap_map in sol2-clearcapv2.map sol2-clearcap.map; do 5566 LDFLAGS="$saved_LDFLAGS -Wl,-M,${srcdir}/config/$clearcap_map" 5567 AC_LINK_IFELSE([int main(void) {return 0;}], 5568 [gcc_cv_ld_clearcap=yes; break], [gcc_cv_ld_clearcap=no]) 5569done 5570LDFLAGS="$saved_LDFLAGS" 5571if test "x$gcc_cv_ld_clearcap" = xyes; then 5572 AC_DEFINE([HAVE_LD_CLEARCAP], 1, 5573[Define if the linker supports clearing hardware capabilities via mapfile.]) 5574 AC_CONFIG_LINKS([clearcap.map:${srcdir}/config/$clearcap_map]) 5575fi 5576AC_MSG_RESULT($gcc_cv_ld_clearcap) 5577 5578case "$target" in 5579 powerpc*-*-*) 5580 case "$target" in 5581 *le-*-linux*) 5582 emul_name="-melf32lppc" 5583 ;; 5584 *) 5585 emul_name="-melf32ppc" 5586 ;; 5587 esac 5588 AC_CACHE_CHECK(linker .gnu.attributes long double support, 5589 gcc_cv_ld_ppc_attr, 5590 [gcc_cv_ld_ppc_attr=no 5591 if test x"$ld_is_gold" = xyes; then 5592 gcc_cv_ld_ppc_attr=yes 5593 elif test $in_tree_ld = yes ; then 5594 if test "$gcc_cv_gld_major_version" -eq 2 \ 5595 -a "$gcc_cv_gld_minor_version" -ge 28 \ 5596 -o "$gcc_cv_gld_major_version" -gt 2; then 5597 gcc_cv_ld_ppc_attr=yes 5598 fi 5599 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then 5600 # check that merging the long double .gnu_attribute doesn't warn 5601 cat > conftest1.s <<EOF 5602 .gnu_attribute 4,1 5603EOF 5604 cat > conftest2.s <<EOF 5605 .gnu_attribute 4,9 5606EOF 5607 if $gcc_cv_as -a32 -o conftest1.o conftest1.s > /dev/null 2>&1 \ 5608 && $gcc_cv_as -a32 -o conftest2.o conftest2.s > /dev/null 2>&1 \ 5609 && $gcc_cv_ld $emul_name -r -o conftest.o conftest1.o conftest2.o > /dev/null 2> conftest.err \ 5610 && test ! -s conftest.err; then 5611 gcc_cv_ld_ppc_attr=yes 5612 fi 5613 rm -f conftest.err conftest.o conftest1.o conftest2.o conftest1.s conftest2.s 5614 fi 5615 ]) 5616 if test x$gcc_cv_ld_ppc_attr = xyes; then 5617 AC_DEFINE(HAVE_LD_PPC_GNU_ATTR_LONG_DOUBLE, 1, 5618 [Define if your PowerPC linker has .gnu.attributes long double support.]) 5619 fi 5620 ;; 5621esac 5622 5623case "$target:$tm_file" in 5624 powerpc64-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*) 5625 case "$target" in 5626 *le-*-linux*) 5627 emul_name="-melf64lppc" 5628 ;; 5629 *-*-linux*) 5630 emul_name="-melf64ppc" 5631 ;; 5632 *-*-freebsd*) 5633 emul_name="-melf64ppc_fbsd" 5634 ;; 5635 esac 5636 AC_CACHE_CHECK(linker support for omitting dot symbols, 5637 gcc_cv_ld_no_dot_syms, 5638 [gcc_cv_ld_no_dot_syms=no 5639 if test x"$ld_is_gold" = xyes; then 5640 gcc_cv_ld_no_dot_syms=yes 5641 elif test $in_tree_ld = yes ; then 5642 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 5643 gcc_cv_ld_no_dot_syms=yes 5644 fi 5645 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then 5646 cat > conftest1.s <<EOF 5647 .text 5648 bl .foo 5649EOF 5650 cat > conftest2.s <<EOF 5651 .section ".opd","aw" 5652 .align 3 5653 .globl foo 5654 .type foo,@function 5655foo: 5656 .quad .LEfoo,.TOC.@tocbase,0 5657 .text 5658.LEfoo: 5659 blr 5660 .size foo,.-.LEfoo 5661EOF 5662 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \ 5663 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \ 5664 && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then 5665 gcc_cv_ld_no_dot_syms=yes 5666 fi 5667 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s 5668 fi 5669 ]) 5670 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then 5671 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1, 5672 [Define if your PowerPC64 linker only needs function descriptor syms.]) 5673 fi 5674 5675 AC_CACHE_CHECK(linker large toc support, 5676 gcc_cv_ld_large_toc, 5677 [gcc_cv_ld_large_toc=no 5678 if test x"$ld_is_gold" = xyes; then 5679 gcc_cv_ld_large_toc=yes 5680 elif test $in_tree_ld = yes ; then 5681 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 5682 gcc_cv_ld_large_toc=yes 5683 fi 5684 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then 5685 cat > conftest.s <<EOF 5686 .section ".tbss","awT",@nobits 5687 .align 3 5688ie0: .space 8 5689 .global _start 5690 .text 5691_start: 5692 addis 9,13,ie0@got@tprel@ha 5693 ld 9,ie0@got@tprel@l(9) 5694EOF 5695 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \ 5696 && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then 5697 gcc_cv_ld_large_toc=yes 5698 fi 5699 rm -f conftest conftest.o conftest.s 5700 fi 5701 ]) 5702 if test x"$gcc_cv_ld_large_toc" = xyes; then 5703 AC_DEFINE(HAVE_LD_LARGE_TOC, 1, 5704 [Define if your PowerPC64 linker supports a large TOC.]) 5705 fi 5706 5707 AC_CACHE_CHECK(linker toc pointer alignment, 5708 gcc_cv_ld_toc_align, 5709 [if test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_nm != x; then 5710 cat > conftest.s <<EOF 5711 .global _start 5712 .text 5713_start: 5714 addis 9,2,x@got@ha 5715 .section .data.rel.ro,"aw",@progbits 5716 .p2align 16 5717 .space 32768 5718x: .quad .TOC. 5719EOF 5720 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \ 5721 && $gcc_cv_ld $emul_name -z norelro -o conftest conftest.o > /dev/null 2>&1; then 5722 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)) }'` 5723 fi 5724 rm -f conftest conftest.o conftest.s 5725 fi 5726 ]) 5727 if test -n "$gcc_cv_ld_toc_align" && test $gcc_cv_ld_toc_align -gt 8; then 5728 AC_DEFINE_UNQUOTED(POWERPC64_TOC_POINTER_ALIGNMENT, $gcc_cv_ld_toc_align, 5729 [Define to .TOC. alignment forced by your linker.]) 5730 fi 5731 ;; 5732esac 5733 5734case "$target" in 5735 *-*-aix*) 5736 AC_CACHE_CHECK(linker large toc support, 5737 gcc_cv_ld_large_toc, 5738 [gcc_cv_ld_large_toc=no 5739 if test x$gcc_cv_as != x ; then 5740 cat > conftest.s <<EOF 5741 .toc 5742LC..1: 5743 .tc a[[TC]],a[[RW]] 5744 .extern a[[RW]] 5745 .csect .text[[PR]] 5746.largetoctest: 5747 addis 9,LC..1@u(2) 5748 ld 3,LC..1@l(9) 5749EOF 5750 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1; then 5751 gcc_cv_ld_large_toc=yes 5752 fi 5753 rm -f conftest conftest.o conftest.s 5754 fi 5755 ]) 5756 if test x"$gcc_cv_ld_large_toc" = xyes; then 5757 AC_DEFINE(HAVE_LD_LARGE_TOC, 1, 5758 [Define if your PowerPC64 linker supports a large TOC.]) 5759 fi 5760 ;; 5761esac 5762 5763AC_CACHE_CHECK(linker --build-id support, 5764 gcc_cv_ld_buildid, 5765 [gcc_cv_ld_buildid=no 5766 if test $in_tree_ld = yes ; then 5767 if test "$gcc_cv_gld_major_version" -eq 2 -a \ 5768 "$gcc_cv_gld_minor_version" -ge 18 -o \ 5769 "$gcc_cv_gld_major_version" -gt 2 \ 5770 && test $in_tree_ld_is_elf = yes; then 5771 gcc_cv_ld_buildid=yes 5772 fi 5773 elif test x$gcc_cv_ld != x; then 5774 if $gcc_cv_ld --help 2>&1 | grep build-id > /dev/null; then 5775 gcc_cv_ld_buildid=yes 5776 fi 5777 fi]) 5778if test x"$gcc_cv_ld_buildid" = xyes; then 5779 AC_DEFINE(HAVE_LD_BUILDID, 1, 5780 [Define if your linker supports --build-id.]) 5781fi 5782 5783AC_ARG_ENABLE(linker-build-id, 5784[AS_HELP_STRING([--enable-linker-build-id], 5785 [compiler will always pass --build-id to linker])], 5786[], 5787enable_linker_build_id=no) 5788 5789if test x"$enable_linker_build_id" = xyes; then 5790 if test x"$gcc_cv_ld_buildid" = xyes; then 5791 AC_DEFINE(ENABLE_LD_BUILDID, 1, 5792 [Define if gcc should always pass --build-id to linker.]) 5793 else 5794 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored) 5795 fi 5796fi 5797 5798# In binutils 2.21, GNU ld gained support for new emulations fully 5799# supporting the Solaris 2 ABI. Detect their presence in the linker used. 5800AC_CACHE_CHECK(linker *_sol2 emulation support, 5801 gcc_cv_ld_sol2_emulation, 5802 [gcc_cv_ld_sol2_emulation=no 5803 if test $in_tree_ld = yes ; then 5804 if test "$gcc_cv_gld_major_version" -eq 2 -a \ 5805 "$gcc_cv_gld_minor_version" -ge 21 -o \ 5806 "$gcc_cv_gld_major_version" -gt 2 \ 5807 && test $in_tree_ld_is_elf = yes; then 5808 gcc_cv_ld_sol2_emulation=yes 5809 fi 5810 elif test x$gcc_cv_ld != x; then 5811 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \ 5812 grep _sol2 > /dev/null; then 5813 gcc_cv_ld_sol2_emulation=yes 5814 fi 5815 fi]) 5816if test x"$gcc_cv_ld_sol2_emulation" = xyes; then 5817 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1, 5818 [Define if your linker supports the *_sol2 emulations.]) 5819fi 5820 5821AC_CACHE_CHECK(linker --sysroot support, 5822 gcc_cv_ld_sysroot, 5823 [gcc_cv_ld_sysroot=no 5824 if test $in_tree_ld = yes ; then 5825 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 5826 gcc_cv_ld_sysroot=yes 5827 fi 5828 elif test x$gcc_cv_ld != x; then 5829 if $gcc_cv_ld --help 2>&1 | grep sysroot > /dev/null; then 5830 gcc_cv_ld_sysroot=yes 5831 fi 5832 fi]) 5833if test x"$gcc_cv_ld_sysroot" = xyes; then 5834 AC_DEFINE(HAVE_LD_SYSROOT, 1, 5835 [Define if your linker supports --sysroot.]) 5836fi 5837 5838case $target in 5839*-*-solaris2*) 5840 # Check for system-provided CRTs on Solaris 11.x and Solaris 12. 5841 AC_CACHE_CHECK([system-provided CRTs on Solaris], 5842 gcc_cv_solaris_crts, 5843 [gcc_cv_solaris_crts=no 5844 if test x$host != x$target; then 5845 if test "x$with_sysroot" = xyes; then 5846 target_sysroot="${test_exec_prefix}/${target_noncanonical}/sys-root" 5847 else 5848 target_sysroot="${with_sysroot}" 5849 fi 5850 fi 5851 target_libdir="$target_sysroot/usr/lib" 5852 # At the time they were added, gcrt1.o became a symlink for backwards 5853 # compatibility on x86, while crt1.o was added on sparc, so check for that. 5854 case $target in 5855 i?86-*-solaris2* | x86_64-*-solaris2*) 5856 if test -h "$target_libdir/gcrt1.o"; then gcc_cv_solaris_crts=yes; fi 5857 ;; 5858 sparc*-*-solaris2*) 5859 if test -f "$target_libdir/crt1.o"; then gcc_cv_solaris_crts=yes; fi 5860 ;; 5861 esac]) 5862 ;; 5863esac 5864if test x$gcc_cv_solaris_crts = xyes; then 5865 AC_DEFINE(HAVE_SOLARIS_CRTS, 1, 5866 [Define if the system-provided CRTs are present on Solaris.]) 5867fi 5868 5869AC_ARG_ENABLE(libssp, 5870[AS_HELP_STRING([--enable-libssp], [enable linking against libssp])], 5871[case "${enableval}" in 5872 yes|no) 5873 ;; 5874 *) 5875 AC_MSG_ERROR([unknown libssp setting $enableval]) 5876 ;; 5877esac], []) 5878 5879# Test for stack protector support in target C library. 5880AC_CACHE_CHECK(__stack_chk_fail in target C library, 5881 gcc_cv_libc_provides_ssp, 5882 [gcc_cv_libc_provides_ssp=no 5883 if test "x$enable_libssp" = "xno"; then 5884 gcc_cv_libc_provides_ssp=yes 5885 elif test "x$enable_libssp" = "xyes"; then 5886 gcc_cv_libc_provides_ssp=no 5887 else 5888 case "$target" in 5889 *-*-musl*) 5890 # All versions of musl provide stack protector 5891 gcc_cv_libc_provides_ssp=yes;; 5892 *-*-linux* | *-*-kfreebsd*-gnu) 5893 # glibc 2.4 and later provides __stack_chk_fail and 5894 # either __stack_chk_guard, or TLS access to stack guard canary. 5895 GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_libc_provides_ssp=yes], [ 5896 [if test -f $target_header_dir/features.h \ 5897 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \ 5898 $target_header_dir/features.h > /dev/null; then 5899 if $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \ 5900 $target_header_dir/features.h > /dev/null && \ 5901 test -f $target_header_dir/bits/uClibc_config.h && \ 5902 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \ 5903 $target_header_dir/bits/uClibc_config.h > /dev/null; then 5904 gcc_cv_libc_provides_ssp=yes 5905 fi 5906 # all versions of Bionic support stack protector 5907 elif test -f $target_header_dir/sys/cdefs.h \ 5908 && $EGREP '^[ ]*#[ ]*define[ ]+__BIONIC__[ ]+1' \ 5909 $target_header_dir/sys/cdefs.h > /dev/null; then 5910 gcc_cv_libc_provides_ssp=yes 5911 fi]]) 5912 ;; 5913 *-*-gnu*) 5914 # Avoid complicated tests (see 5915 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now 5916 # simply assert that glibc does provide this, which is true for all 5917 # realistically usable GNU/Hurd configurations. 5918 # All supported versions of musl provide it as well 5919 gcc_cv_libc_provides_ssp=yes;; 5920 *-*-darwin* | *-*-freebsd* | *-*-netbsd*) 5921 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes], 5922 [echo "no __stack_chk_fail on this target"]) 5923 ;; 5924 *) gcc_cv_libc_provides_ssp=no ;; 5925 esac 5926 fi]) 5927 5928if test x$gcc_cv_libc_provides_ssp = xyes; then 5929 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1, 5930 [Define if your target C library provides stack protector support]) 5931fi 5932 5933# Check whether --enable-default-ssp was given. 5934AC_ARG_ENABLE(default-ssp, 5935[AS_HELP_STRING([--enable-default-ssp], 5936 [enable Stack Smashing Protection as default])],[ 5937if test x$gcc_cv_libc_provides_ssp = xyes; then 5938 case "$target" in 5939 ia64*-*-*) enable_default_ssp=no ;; 5940 *) enable_default_ssp=$enableval ;; 5941 esac 5942else 5943 enable_default_ssp=no 5944fi], 5945enable_default_ssp=no) 5946if test x$enable_default_ssp = xyes ; then 5947 AC_DEFINE(ENABLE_DEFAULT_SSP, 1, 5948 [Define if your target supports default stack protector and it is enabled.]) 5949fi 5950AC_SUBST([enable_default_ssp]) 5951 5952# Test for <sys/sdt.h> on the target. 5953GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H]) 5954AC_MSG_CHECKING(sys/sdt.h in the target C library) 5955have_sys_sdt_h=no 5956if test -f $target_header_dir/sys/sdt.h; then 5957 have_sys_sdt_h=yes 5958 AC_DEFINE(HAVE_SYS_SDT_H, 1, 5959 [Define if your target C library provides sys/sdt.h]) 5960fi 5961AC_MSG_RESULT($have_sys_sdt_h) 5962 5963# Check if TFmode long double should be used by default or not. 5964# Some glibc targets used DFmode long double, but with glibc 2.4 5965# and later they can use TFmode. 5966case "$target" in 5967 powerpc*-*-linux* | \ 5968 sparc*-*-linux* | \ 5969 s390*-*-linux* | \ 5970 alpha*-*-linux*) 5971 AC_ARG_WITH(long-double-128, 5972 [AS_HELP_STRING([--with-long-double-128], 5973 [use 128-bit long double by default])], 5974 gcc_cv_target_ldbl128="$with_long_double_128", 5975 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_target_ldbl128=yes], [ 5976 [gcc_cv_target_ldbl128=no 5977 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \ 5978 $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \ 5979 && gcc_cv_target_ldbl128=yes 5980 ]])]) 5981 ;; 5982esac 5983if test x$gcc_cv_target_ldbl128 = xyes; then 5984 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1, 5985 [Define if TFmode long double should be the default]) 5986fi 5987 5988# Check if TFmode long double target should use the IBM extended double or IEEE 5989# 128-bit floating point formats if long doubles are 128-bits long. The long 5990# double type can only be switched on powerpc64 bit Linux systems where VSX is 5991# supported. Other PowerPC systems do not build the IEEE 128-bit emulator in 5992# libgcc. 5993AC_ARG_WITH([long-double-format], 5994 [AS_HELP_STRING([--with-long-double-format={ieee,ibm}] 5995 [Specify whether PowerPC long double uses IEEE or IBM format])],[ 5996case "$target:$with_long_double_format" in 5997 powerpc64le-*-linux*:ieee | powerpc64le-*-linux*:ibm) 5998 : 5999 ;; 6000 powerpc64-*-linux*:ieee | powerpc64-*-linux*:ibm) 6001 # IEEE 128-bit emulation is only built on 64-bit VSX Linux systems 6002 case "$with_cpu" in 6003 power7 | power8 | power9 | power1*) 6004 : 6005 ;; 6006 *) 6007 AC_MSG_ERROR([Configuration option --with-long-double-format is only \ 6008supported if the default cpu is power7 or newer]) 6009 with_long_double_format="" 6010 ;; 6011 esac 6012 ;; 6013 xpowerpc64*-*-linux*:*) 6014 AC_MSG_ERROR([--with-long-double-format argument should be ibm or ieee]) 6015 with_long_double_format="" 6016 ;; 6017 *) 6018 AC_MSG_ERROR([Configure option --with-long-double-format is only supported \ 6019on 64-bit PowerPC VSX Linux systems]) 6020 with_long_double_format="" 6021 ;; 6022esac], 6023 []) 6024 6025# Check if the target LIBC supports exporting the AT_PLATFORM and AT_HWCAP 6026# values in the TCB. Currently, only GLIBC 2.23 and later support this. 6027gcc_cv_libc_provides_hwcap_in_tcb=no 6028case "$target" in 6029 powerpc*-*-linux*) 6030 GCC_GLIBC_VERSION_GTE_IFELSE([2], [23], [gcc_cv_libc_provides_hwcap_in_tcb=yes], ) 6031 ;; 6032esac 6033if test x$gcc_cv_libc_provides_hwcap_in_tcb = xyes; then 6034 AC_DEFINE(TARGET_LIBC_PROVIDES_HWCAP_IN_TCB, 1, 6035 [Define if your target C Library provides the AT_HWCAP value in the TCB]) 6036fi 6037 6038AC_MSG_CHECKING(dl_iterate_phdr in target C library) 6039gcc_cv_target_dl_iterate_phdr=unknown 6040case "$target" in 6041 # Restrict to Solaris 11+. While most of the Solaris 11 linker changes 6042 # were backported to Solaris 10 Update 10, dl_iterate_phdr only lives in 6043 # libdl there, both complicating its use and breaking compatibility 6044 # between Solaris 10 updates. 6045 *-*-solaris2.1[[1-9]]*) 6046 # <link.h> needs both a dl_iterate_phdr declaration and support for 6047 # compilation with largefile support. 6048 if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \ 6049 && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then 6050 gcc_cv_target_dl_iterate_phdr=yes 6051 else 6052 gcc_cv_target_dl_iterate_phdr=no 6053 fi 6054 ;; 6055 *-*-dragonfly* | *-*-freebsd*) 6056 if grep dl_iterate_phdr $target_header_dir/sys/link_elf.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 *-linux-musl*) 6063 gcc_cv_target_dl_iterate_phdr=yes 6064 ;; 6065esac 6066GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR]) 6067if test x$gcc_cv_target_dl_iterate_phdr = xyes; then 6068 AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1, 6069[Define if your target C library provides the `dl_iterate_phdr' function.]) 6070fi 6071AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr) 6072 6073# We no longer support different GC mechanisms. Emit an error if 6074# the user configures with --with-gc. 6075AC_ARG_WITH(gc, 6076[AS_HELP_STRING([--with-gc={page,zone}], 6077 [this option is not supported anymore. It used to choose 6078 the garbage collection mechanism to use with the compiler])], 6079[AC_MSG_ERROR([Configure option --with-gc is only supported up to GCC 4.7.x])], 6080[]) 6081 6082# Libraries to use on the host. This will normally be set by the top 6083# level Makefile. Here we simply capture the value for our Makefile. 6084if test -z "${HOST_LIBS+set}"; then 6085 HOST_LIBS= 6086fi 6087AC_SUBST(HOST_LIBS) 6088 6089# Use the system's zlib library. 6090AM_ZLIB 6091 6092dnl Very limited version of automake's enable-maintainer-mode 6093 6094AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles]) 6095 dnl maintainer-mode is disabled by default 6096 AC_ARG_ENABLE(maintainer-mode, 6097[AS_HELP_STRING([--enable-maintainer-mode], 6098 [enable make rules and dependencies not useful 6099 (and sometimes confusing) to the casual installer])], 6100 maintainer_mode=$enableval, 6101 maintainer_mode=no) 6102 6103AC_MSG_RESULT($maintainer_mode) 6104 6105if test "$maintainer_mode" = "yes"; then 6106 MAINT='' 6107else 6108 MAINT='#' 6109fi 6110AC_SUBST(MAINT)dnl 6111 6112dnl Whether to prevent multiple front-ends from linking at the same time 6113 6114AC_MSG_CHECKING([whether to avoid linking multiple front-ends at once]) 6115 AC_ARG_ENABLE(link-mutex, 6116[AS_HELP_STRING([--enable-link-mutex], 6117 [avoid linking multiple front-ends at once to avoid thrashing 6118 on the build machine])], 6119 do_link_mutex=$enableval, 6120 do_link_mutex=no) 6121AC_MSG_RESULT($do_link_mutex) 6122 6123if test "$do_link_mutex" = "yes"; then 6124 DO_LINK_MUTEX=true 6125else 6126 DO_LINK_MUTEX=false 6127fi 6128AC_SUBST(DO_LINK_MUTEX) 6129 6130# -------------- 6131# Language hooks 6132# -------------- 6133 6134# Make empty files to contain the specs and options for each language. 6135# Then add #include lines to for a compiler that has specs and/or options. 6136 6137subdirs= 6138lang_opt_files= 6139lang_specs_files= 6140lang_tree_files= 6141# These (without "all_") are set in each config-lang.in. 6142# `language' must be a single word so is spelled singularly. 6143all_languages= 6144all_compilers= 6145all_outputs='Makefile' 6146# List of language makefile fragments. 6147all_lang_makefrags= 6148# Additional files for gengtype 6149all_gtfiles="$target_gtfiles" 6150 6151# These are the languages that are set in --enable-languages, 6152# and are available in the GCC tree. 6153all_selected_languages= 6154 6155# Add the language fragments. 6156# Languages are added via two mechanisms. Some information must be 6157# recorded in makefile variables, these are defined in config-lang.in. 6158# We accumulate them and plug them into the main Makefile. 6159# The other mechanism is a set of hooks for each of the main targets 6160# like `clean', `install', etc. 6161 6162language_hooks="Make-hooks" 6163 6164for lang in ${srcdir}/*/config-lang.in 6165do 6166changequote(,)dnl 6167 test "$lang" = "${srcdir}/*/config-lang.in" && continue 6168 6169 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang` 6170 if test "x$lang_alias" = x 6171 then 6172 echo "$lang doesn't set \$language." 1>&2 6173 exit 1 6174 fi 6175 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`" 6176 subdirs="$subdirs $subdir" 6177 6178 # $gcc_subdir is where the gcc integration files are to be found 6179 # for a language, both for internal compiler purposes (compiler 6180 # sources implementing front-end to GCC tree converters), and for 6181 # build infrastructure purposes (Make-lang.in, etc.) 6182 # 6183 # This will be <subdir> (relative to $srcdir) if a line like 6184 # gcc_subdir="<subdir>" or gcc_subdir=<subdir> 6185 # is found in <langdir>/config-lang.in, and will remain <langdir> 6186 # otherwise. 6187 # 6188 # Except for the language alias (fetched above), the regular 6189 # "config-lang.in" contents are always retrieved from $gcc_subdir, 6190 # so a <langdir>/config-lang.in setting gcc_subdir typically sets 6191 # only this and the language alias. 6192 6193 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang` 6194 if [ "$gcc_subdir" = "" ]; then 6195 gcc_subdir="$subdir" 6196 fi 6197 6198 case ",$enable_languages," in 6199 *,$lang_alias,*) 6200 all_selected_languages="$all_selected_languages $lang_alias" 6201 if test -f $srcdir/$gcc_subdir/lang-specs.h; then 6202 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h" 6203 fi 6204 ;; 6205 esac 6206changequote([,])dnl 6207 6208 language= 6209 boot_language= 6210 compilers= 6211 outputs= 6212 gtfiles= 6213 subdir_requires= 6214 . ${srcdir}/$gcc_subdir/config-lang.in 6215 if test "x$language" = x 6216 then 6217 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2 6218 exit 1 6219 fi 6220 6221 ok=: 6222 case ",$enable_languages," in 6223 *,$lang_alias,*) ;; 6224 *) 6225 for i in $subdir_requires; do 6226 test -f "${srcdir}/$i/config-lang.in" && continue 6227 ok=false 6228 break 6229 done 6230 ;; 6231 esac 6232 $ok || continue 6233 6234 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in" 6235 if test -f $srcdir/$gcc_subdir/lang.opt; then 6236 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt" 6237 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt" 6238 fi 6239 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then 6240 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def" 6241 fi 6242 all_languages="$all_languages $language" 6243 all_compilers="$all_compilers $compilers" 6244 all_outputs="$all_outputs $outputs" 6245 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles" 6246 case ",$enable_languages," in 6247 *,lto,*) 6248 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.]) 6249 enable_lto=yes 6250 AC_SUBST(enable_lto) 6251 ;; 6252 *) ;; 6253 esac 6254done 6255 6256check_languages= 6257for language in $all_selected_languages 6258do 6259 check_languages="$check_languages check-$language" 6260done 6261 6262# We link each language in with a set of hooks, reached indirectly via 6263# lang.${target}. Only do so for selected languages. 6264 6265rm -f Make-hooks 6266touch Make-hooks 6267target_list="all.cross start.encap rest.encap tags \ 6268 install-common install-man install-info install-pdf install-html dvi \ 6269 pdf html uninstall info man srcextra srcman srcinfo \ 6270 mostlyclean clean distclean maintainer-clean install-plugin" 6271 6272for t in $target_list 6273do 6274 x= 6275 for lang in $all_selected_languages 6276 do 6277 x="$x $lang.$t" 6278 done 6279 echo "lang.$t: $x" >> Make-hooks 6280done 6281 6282# -------- 6283# Option include files 6284# -------- 6285 6286${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk 6287option_includes="option-includes.mk" 6288AC_SUBST_FILE(option_includes) 6289 6290# -------- 6291# UNSORTED 6292# -------- 6293 6294# Create .gdbinit. 6295 6296echo "dir ." > .gdbinit 6297echo "dir ${srcdir}" >> .gdbinit 6298if test x$gdb_needs_out_file_path = xyes 6299then 6300 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit 6301fi 6302if test "x$subdirs" != x; then 6303 for s in $subdirs 6304 do 6305 echo "dir ${srcdir}/$s" >> .gdbinit 6306 done 6307fi 6308echo "source ${srcdir}/gdbinit.in" >> .gdbinit 6309echo "python import sys; sys.path.append('${srcdir}'); import gdbhooks" >> .gdbinit 6310 6311# Put a breakpoint on __asan_report_error to help with debugging buffer 6312# overflow. 6313case "$CFLAGS" in 6314*-fsanitize=address*) 6315 echo "source ${srcdir}/gdbasan.in" >> .gdbinit 6316 ;; 6317esac 6318 6319gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)' 6320AC_SUBST(gcc_tooldir) 6321AC_SUBST(dollar) 6322 6323# Find a directory in which to install a shared libgcc. 6324 6325AC_ARG_ENABLE(version-specific-runtime-libs, 6326[AS_HELP_STRING([--enable-version-specific-runtime-libs], 6327 [specify that runtime libraries should be 6328 installed in a compiler-specific directory])]) 6329 6330# Substitute configuration variables 6331AC_SUBST(subdirs) 6332AC_SUBST(srcdir) 6333AC_SUBST(all_compilers) 6334AC_SUBST(all_gtfiles) 6335AC_SUBST(all_lang_makefrags) 6336AC_SUBST(all_languages) 6337AC_SUBST(all_selected_languages) 6338AC_SUBST(build_exeext) 6339AC_SUBST(build_install_headers_dir) 6340AC_SUBST(build_xm_file_list) 6341AC_SUBST(build_xm_include_list) 6342AC_SUBST(build_xm_defines) 6343AC_SUBST(build_file_translate) 6344AC_SUBST(check_languages) 6345AC_SUBST(cpp_install_dir) 6346AC_SUBST(xmake_file) 6347AC_SUBST(tmake_file) 6348AC_SUBST(TM_ENDIAN_CONFIG) 6349AC_SUBST(TM_MULTILIB_CONFIG) 6350AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG) 6351AC_SUBST(extra_gcc_objs) 6352AC_SUBST(user_headers_inc_next_pre) 6353AC_SUBST(user_headers_inc_next_post) 6354AC_SUBST(extra_headers_list) 6355AC_SUBST(extra_objs) 6356AC_SUBST(extra_programs) 6357AC_SUBST(float_h_file) 6358AC_SUBST(gcc_config_arguments) 6359AC_SUBST(gcc_gxx_include_dir) 6360AC_SUBST(gcc_gxx_include_dir_add_sysroot) 6361AC_SUBST(host_exeext) 6362AC_SUBST(host_xm_file_list) 6363AC_SUBST(host_xm_include_list) 6364AC_SUBST(host_xm_defines) 6365AC_SUBST(out_host_hook_obj) 6366AC_SUBST(install) 6367AC_SUBST(lang_opt_files) 6368AC_SUBST(lang_specs_files) 6369AC_SUBST(lang_tree_files) 6370AC_SUBST(local_prefix) 6371AC_SUBST(md_file) 6372AC_SUBST(objc_boehm_gc) 6373AC_SUBST(out_file) 6374AC_SUBST(out_object_file) 6375AC_SUBST(common_out_file) 6376AC_SUBST(common_out_object_file) 6377AC_SUBST(tm_file_list) 6378AC_SUBST(tm_include_list) 6379AC_SUBST(tm_defines) 6380AC_SUBST(tm_p_file_list) 6381AC_SUBST(tm_p_include_list) 6382AC_SUBST(xm_file_list) 6383AC_SUBST(xm_include_list) 6384AC_SUBST(xm_defines) 6385AC_SUBST(use_gcc_stdint) 6386AC_SUBST(c_target_objs) 6387AC_SUBST(cxx_target_objs) 6388AC_SUBST(fortran_target_objs) 6389AC_SUBST(target_cpu_default) 6390 6391AC_SUBST_FILE(language_hooks) 6392 6393# Echo link setup. 6394if test x${build} = x${host} ; then 6395 if test x${host} = x${target} ; then 6396 echo "Links are now set up to build a native compiler for ${target}." 1>&2 6397 else 6398 echo "Links are now set up to build a cross-compiler" 1>&2 6399 echo " from ${host} to ${target}." 1>&2 6400 fi 6401else 6402 if test x${host} = x${target} ; then 6403 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2 6404 echo " for ${target}." 1>&2 6405 else 6406 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2 6407 echo " from ${host} to ${target}." 1>&2 6408 fi 6409fi 6410 6411AC_ARG_VAR(GMPLIBS,[How to link GMP]) 6412AC_ARG_VAR(GMPINC,[How to find GMP include files]) 6413 6414AC_ARG_VAR(ISLLIBS,[How to link isl]) 6415AC_ARG_VAR(ISLINC,[How to find isl include files]) 6416if test "x${ISLLIBS}" != "x" ; then 6417 AC_DEFINE(HAVE_isl, 1, [Define if isl is in use.]) 6418fi 6419 6420GCC_ENABLE_PLUGINS 6421AC_SUBST(pluginlibs) 6422AC_SUBST(enable_plugin) 6423if test x"$enable_plugin" = x"yes"; then 6424 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.]) 6425fi 6426 6427 6428# Enable --enable-host-shared 6429AC_ARG_ENABLE(host-shared, 6430[AS_HELP_STRING([--enable-host-shared], 6431 [build host code as shared libraries])], 6432[PICFLAG=-fPIC], [PICFLAG=]) 6433AC_SUBST(enable_host_shared) 6434AC_SUBST(PICFLAG) 6435 6436 6437AC_ARG_ENABLE(libquadmath-support, 6438[AS_HELP_STRING([--disable-libquadmath-support], 6439 [disable libquadmath support for Fortran])], 6440ENABLE_LIBQUADMATH_SUPPORT=$enableval, 6441ENABLE_LIBQUADMATH_SUPPORT=yes) 6442if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then 6443 AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1, 6444 [Define to 1 to enable libquadmath support]) 6445fi 6446 6447 6448# Specify what hash style to use by default. 6449AC_ARG_WITH([linker-hash-style], 6450[AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}], 6451 [specify the linker hash style])], 6452[case x"$withval" in 6453 xsysv) 6454 LINKER_HASH_STYLE=sysv 6455 ;; 6456 xgnu) 6457 LINKER_HASH_STYLE=gnu 6458 ;; 6459 xboth) 6460 LINKER_HASH_STYLE=both 6461 ;; 6462 *) 6463 AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style]) 6464 ;; 6465 esac], 6466[LINKER_HASH_STYLE='']) 6467if test x"${LINKER_HASH_STYLE}" != x; then 6468 AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE", 6469 [The linker hash style]) 6470fi 6471 6472# Specify what should be the default of -fdiagnostics-color option. 6473AC_ARG_WITH([diagnostics-color], 6474[AC_HELP_STRING([--with-diagnostics-color={never,auto,auto-if-env,always}], 6475 [specify the default of -fdiagnostics-color option 6476 auto-if-env stands for -fdiagnostics-color=auto if 6477 GCC_COLOR environment variable is present and 6478 -fdiagnostics-color=never otherwise])], 6479[case x"$withval" in 6480 xnever) 6481 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_NO 6482 ;; 6483 xauto) 6484 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_AUTO 6485 ;; 6486 xauto-if-env) 6487 DIAGNOSTICS_COLOR_DEFAULT=-1 6488 ;; 6489 xalways) 6490 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_YES 6491 ;; 6492 *) 6493 AC_MSG_ERROR([$withval is an invalid option to --with-diagnostics-color]) 6494 ;; 6495 esac], 6496[DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_AUTO]) 6497AC_DEFINE_UNQUOTED(DIAGNOSTICS_COLOR_DEFAULT, $DIAGNOSTICS_COLOR_DEFAULT, 6498 [The default for -fdiagnostics-color option]) 6499 6500# Generate gcc-driver-name.h containing GCC_DRIVER_NAME for the benefit 6501# of jit/jit-playback.c. 6502gcc_driver_version=`eval "${get_gcc_base_ver} $srcdir/BASE-VER"` 6503echo "gcc_driver_version: ${gcc_driver_version}" 6504cat > gcc-driver-name.h <<EOF 6505#define GCC_DRIVER_NAME "${target_noncanonical}-gcc-${gcc_driver_version}${exeext}" 6506EOF 6507 6508# Check whether --enable-default-pie was given. 6509AC_ARG_ENABLE(default-pie, 6510[AS_HELP_STRING([--enable-default-pie], 6511 [enable Position Independent Executable as default])], 6512enable_default_pie=$enableval, 6513enable_default_pie=no) 6514if test x$enable_default_pie = xyes ; then 6515 AC_DEFINE(ENABLE_DEFAULT_PIE, 1, 6516 [Define if your target supports default PIE and it is enabled.]) 6517fi 6518AC_SUBST([enable_default_pie]) 6519 6520# Check if -fno-PIE works. 6521AC_CACHE_CHECK([for -fno-PIE option], 6522 [gcc_cv_c_no_fpie], 6523 [saved_CXXFLAGS="$CXXFLAGS" 6524 CXXFLAGS="$CXXFLAGS -fno-PIE" 6525 AC_COMPILE_IFELSE([int main(void) {return 0;}], 6526 [gcc_cv_c_no_fpie=yes], 6527 [gcc_cv_c_no_fpie=no]) 6528 CXXFLAGS="$saved_CXXFLAGS"]) 6529if test "$gcc_cv_c_no_fpie" = "yes"; then 6530 NO_PIE_CFLAGS="-fno-PIE" 6531fi 6532AC_SUBST([NO_PIE_CFLAGS]) 6533 6534# Check if -no-pie works. 6535AC_CACHE_CHECK([for -no-pie option], 6536 [gcc_cv_no_pie], 6537 [saved_LDFLAGS="$LDFLAGS" 6538 LDFLAGS="$LDFLAGS -no-pie" 6539 AC_LINK_IFELSE([int main(void) {return 0;}], 6540 [gcc_cv_no_pie=yes], 6541 [gcc_cv_no_pie=no]) 6542 LDFLAGS="$saved_LDFLAGS"]) 6543if test "$gcc_cv_no_pie" = "yes"; then 6544 NO_PIE_FLAG="-no-pie" 6545fi 6546AC_SUBST([NO_PIE_FLAG]) 6547 6548# Check linker supports '-z bndplt' 6549ld_bndplt_support=no 6550AC_MSG_CHECKING(linker -z bndplt option) 6551if test x"$ld_is_gold" = xno; then 6552 if test $in_tree_ld = yes ; then 6553 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 6554 ld_bndplt_support=yes 6555 fi 6556 elif test x$gcc_cv_ld != x; then 6557 # Check if linker supports -a bndplt option 6558 if $gcc_cv_ld --help 2>&1 | grep -- '-z bndplt' > /dev/null; then 6559 ld_bndplt_support=yes 6560 fi 6561 fi 6562fi 6563if test x"$ld_bndplt_support" = xyes; then 6564 AC_DEFINE(HAVE_LD_BNDPLT_SUPPORT, 1, 6565 [Define if your linker supports -z bndplt]) 6566fi 6567AC_MSG_RESULT($ld_bndplt_support) 6568 6569# Check linker supports '--push-state'/'--pop-state' 6570ld_pushpopstate_support=no 6571AC_MSG_CHECKING(linker --push-state/--pop-state options) 6572if test x"$ld_is_gold" = xno; then 6573 if test $in_tree_ld = yes ; then 6574 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 6575 ld_pushpopstate_support=yes 6576 fi 6577 elif test x$gcc_cv_ld != x; then 6578 # Check if linker supports --push-state/--pop-state options 6579 if $gcc_cv_ld --help 2>&1 | grep -- '--push-state' > /dev/null; then 6580 ld_pushpopstate_support=yes 6581 fi 6582 fi 6583fi 6584if test x"$ld_pushpopstate_support" = xyes; then 6585 AC_DEFINE(HAVE_LD_PUSHPOPSTATE_SUPPORT, 1, 6586 [Define if your linker supports --push-state/--pop-state]) 6587fi 6588AC_MSG_RESULT($ld_pushpopstate_support) 6589 6590# Configure the subdirectories 6591# AC_CONFIG_SUBDIRS($subdirs) 6592 6593# Create the Makefile 6594# and configure language subdirectories 6595AC_CONFIG_FILES($all_outputs) 6596 6597AC_CONFIG_COMMANDS([default], 6598[ 6599case ${CONFIG_HEADERS} in 6600 *auto-host.h:config.in*) 6601 echo > cstamp-h ;; 6602esac 6603# Make sure all the subdirs exist. 6604for d in $subdirs doc build common c-family 6605do 6606 test -d $d || mkdir $d 6607done 6608], 6609[subdirs='$subdirs']) 6610AC_OUTPUT 6611 6612