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