2 # Process this file with autoconf to generate a configuration script.
4 # Copyright (C) 1997-2015 Free Software Foundation, Inc.
6 #This file is part of GCC.
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
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
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/>.
22 # --------------------------------
23 # Initialization and sanity checks
24 # --------------------------------
28 AC_CONFIG_SRCDIR(tree.c)
29 AC_CONFIG_HEADER(auto-host.h:config.in)
31 gcc_version=`cat $srcdir/BASE-VER`
33 # Determine the host, build, and target systems
38 # Determine the noncanonical target name, for directory use.
39 ACX_NONCANONICAL_TARGET
41 # Used for constructing correct paths for offload compilers.
42 real_target_noncanonical=${target_noncanonical}
45 # Determine the target- and build-specific subdirectories
48 # Set program_transform_name
51 # Check for bogus environment variables.
52 # Test if LIBRARY_PATH contains the notation for the current directory
53 # since this would lead to problems installing/building glibc.
54 # LIBRARY_PATH contains the current directory if one of the following
56 # - one of the terminals (":" and ";") is the first or last sign
57 # - two terminals occur directly after each other
58 # - the path contains an element with a dot in it
59 AC_MSG_CHECKING(LIBRARY_PATH variable)
61 case ${LIBRARY_PATH} in
62 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
63 library_path_setting="contains current directory"
66 library_path_setting="ok"
70 AC_MSG_RESULT($library_path_setting)
71 if test "$library_path_setting" != "ok"; then
73 *** LIBRARY_PATH shouldn't contain the current directory when
74 *** building gcc. Please change the environment variable
75 *** and run configure again.])
78 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
79 # since this would lead to problems installing/building glibc.
80 # GCC_EXEC_PREFIX contains the current directory if one of the following
82 # - one of the terminals (":" and ";") is the first or last sign
83 # - two terminals occur directly after each other
84 # - the path contains an element with a dot in it
85 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
87 case ${GCC_EXEC_PREFIX} in
88 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
89 gcc_exec_prefix_setting="contains current directory"
92 gcc_exec_prefix_setting="ok"
96 AC_MSG_RESULT($gcc_exec_prefix_setting)
97 if test "$gcc_exec_prefix_setting" != "ok"; then
99 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
100 *** building gcc. Please change the environment variable
101 *** and run configure again.])
108 # Specify the local prefix
110 AC_ARG_WITH(local-prefix,
111 [AS_HELP_STRING([--with-local-prefix=DIR],
112 [specifies directory to put local include])],
113 [case "${withval}" in
114 yes) AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
116 *) local_prefix=$with_local_prefix ;;
119 # Default local prefix if it is empty
120 if test x$local_prefix = x; then
121 local_prefix=/usr/local
124 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
125 # passed in by the toplevel make and thus we'd get different behavior
126 # depending on where we built the sources.
128 # Specify the g++ header file directory
129 AC_ARG_WITH(gxx-include-dir,
130 [AS_HELP_STRING([--with-gxx-include-dir=DIR],
131 [specifies directory to put g++ header files])],
132 [case "${withval}" in
133 yes) AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
135 *) gcc_gxx_include_dir=$with_gxx_include_dir ;;
138 # This logic must match libstdc++-v3/acinclude.m4:GLIBCXX_EXPORT_INSTALL_INFO.
139 if test x${gcc_gxx_include_dir} = x; then
140 if test x${enable_version_specific_runtime_libs} = xyes; then
141 gcc_gxx_include_dir='${libsubdir}/include/c++'
143 libstdcxx_incdir='include/c++/$(version)'
144 if test x$host != x$target; then
145 libstdcxx_incdir="$target_alias/$libstdcxx_incdir"
147 gcc_gxx_include_dir="\$(libsubdir)/\$(libsubdir_to_prefix)$libstdcxx_incdir"
151 gcc_gxx_include_dir_add_sysroot=0
152 if test "${with_sysroot+set}" = set; then
153 gcc_gxx_without_sysroot=`expr "${gcc_gxx_include_dir}" : "${with_sysroot}"'\(.*\)'`
154 if test "${gcc_gxx_without_sysroot}"; then
155 gcc_gxx_include_dir="${gcc_gxx_without_sysroot}"
156 gcc_gxx_include_dir_add_sysroot=1
160 AC_ARG_WITH(cpp_install_dir,
161 [AC_HELP_STRING([--with-cpp-install-dir=DIR],
162 [install the user visible C preprocessor in DIR
163 (relative to PREFIX) as well as PREFIX/bin])],
164 [if test x$withval = xyes; then
165 AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
166 elif test x$withval != xno; then
167 cpp_install_dir=$withval
170 # We would like to our source tree to be readonly. However when releases or
171 # pre-releases are generated, the flex/bison generated files as well as the
172 # various formats of manuals need to be included along with the rest of the
173 # sources. Therefore we have --enable-generated-files-in-srcdir to do
176 AC_MSG_CHECKING([whether to place generated files in the source directory])
177 dnl generated-files-in-srcdir is disabled by default
178 AC_ARG_ENABLE(generated-files-in-srcdir,
179 [AS_HELP_STRING([--enable-generated-files-in-srcdir],
180 [put copies of generated files in source dir
181 intended for creating source tarballs for users
182 without texinfo bison or flex])],
183 generated_files_in_srcdir=$enableval,
184 generated_files_in_srcdir=no)
186 AC_MSG_RESULT($generated_files_in_srcdir)
188 if test "$generated_files_in_srcdir" = "yes"; then
195 # -------------------
196 # Find default linker
197 # -------------------
201 [AS_HELP_STRING([--with-gnu-ld], [arrange to work with GNU ld])],
202 gnu_ld_flag="$with_gnu_ld",
205 # With pre-defined ld
207 [AS_HELP_STRING([--with-ld], [arrange to use the specified ld (full pathname)])],
208 DEFAULT_LINKER="$with_ld")
209 if test x"${DEFAULT_LINKER+set}" = x"set"; then
210 if test ! -x "$DEFAULT_LINKER"; then
211 AC_MSG_ERROR([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
212 elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
215 AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
216 [Define to enable the use of a default linker.])
219 AC_MSG_CHECKING([whether a default linker was specified])
220 if test x"${DEFAULT_LINKER+set}" = x"set"; then
221 if test x"$gnu_ld_flag" = x"no"; then
222 AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
224 AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
230 # With demangler in GNU ld
231 AC_ARG_WITH(demangler-in-ld,
232 [AS_HELP_STRING([--with-demangler-in-ld], [try to use demangler in GNU ld])],
233 demangler_in_ld="$with_demangler_in_ld",
236 # ----------------------
237 # Find default assembler
238 # ----------------------
242 [AS_HELP_STRING([--with-gnu-as], [arrange to work with GNU as])],
243 gas_flag="$with_gnu_as",
247 [AS_HELP_STRING([--with-as], [arrange to use the specified as (full pathname)])],
248 DEFAULT_ASSEMBLER="$with_as")
249 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
250 if test ! -x "$DEFAULT_ASSEMBLER"; then
251 AC_MSG_ERROR([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
252 elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
255 AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
256 [Define to enable the use of a default assembler.])
259 AC_MSG_CHECKING([whether a default assembler was specified])
260 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
261 if test x"$gas_flag" = x"no"; then
262 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
264 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
274 # If a non-executable a.out is present (e.g. created by GNU as above even if
275 # invoked with -v only), the IRIX 6 native ld just overwrites the existing
276 # file, even when creating an executable, so an execution test fails.
277 # Remove possible default executable files to avoid this.
279 # FIXME: This really belongs into AC_PROG_CC and can be removed once
280 # Autoconf includes it.
281 rm -f a.out a.exe b.out
283 # Find the native compiler
286 ACX_PROG_GNAT([-I"$srcdir"/ada])
288 # Do configure tests with the C++ compiler, since that's what we build with.
291 # Remove the -O2: for historical reasons, unless bootstrapping we prefer
292 # optimizations to be activated explicitly by the toplevel.
295 *) CFLAGS=`echo "$CFLAGS " | sed -e "s/-Ofast[[ ]]//" -e "s/-O[[gs]][[ ]]//" -e "s/-O[[0-9]]*[[ ]]//" `
296 CXXFLAGS=`echo "$CXXFLAGS " | sed -e "s/-Ofast[[ ]]//" -e "s/-O[[gs]][[ ]]//" -e "s/-O[[0-9]]*[[ ]]//" ` ;;
301 # Determine PICFLAG for target gnatlib.
302 GCC_PICFLAG_FOR_TARGET
303 AC_SUBST(PICFLAG_FOR_TARGET)
305 # -------------------------
306 # Check C compiler features
307 # -------------------------
309 AC_USE_SYSTEM_EXTENSIONS
315 # sizeof(char) is 1 by definition.
316 AC_CHECK_SIZEOF(void *)
317 AC_CHECK_SIZEOF(short)
319 AC_CHECK_SIZEOF(long)
320 AC_CHECK_TYPES([long long], [AC_CHECK_SIZEOF(long long)])
322 if test x"$ac_cv_c_uint64_t" = x"no" -o x"$ac_cv_c_int64_t" = x"no"; then
323 AC_MSG_ERROR([uint64_t or int64_t not found])
326 # check what underlying integer type int64_t uses
327 AC_CACHE_CHECK(for int64_t underlying type, ac_cv_int64_t_type, [
328 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
332 template <typename T> struct X { };
334 struct X<long> { typedef long t; };
335 ]], [[X<int64_t>::t x;]])],[ac_cv_int64_t_type=long],[ac_cv_int64_t_type="long long"])])
336 if test "$ac_cv_int64_t_type" = "long"; then
337 AC_DEFINE(INT64_T_IS_LONG, 1,
338 [Define if int64_t uses long as underlying type.])
340 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
344 template <typename T> struct X { };
346 struct X<long long> { typedef long long t; };
347 ]], [[X<int64_t>::t x;]])],[],[AC_MSG_ERROR([error verifying int64_t uses long long])])
353 # ---------------------
354 # Warnings and checking
355 # ---------------------
357 # Check $CC warning features (if it's GCC).
358 # We want to use -pedantic, but we don't want warnings about
362 # * C++11 narrowing conversions in { }
363 # So, we only use -pedantic if we can disable those warnings.
365 # In stage 1, disable -Wformat warnings from old GCCs about new % codes
366 AC_ARG_ENABLE(build-format-warnings,
367 AS_HELP_STRING([--disable-build-format-warnings],[don't use -Wformat while building GCC]),
368 [],[enable_build_format_warnings=yes])
369 AS_IF([test $enable_build_format_warnings = no],
370 [wf_opt=-Wno-format],[wf_opt=])
371 ACX_PROG_CXX_WARNING_OPTS(
372 m4_quote(m4_do([-W -Wall -Wno-narrowing -Wwrite-strings -Wcast-qual $wf_opt])), [loose_warn])
373 ACX_PROG_CC_WARNING_OPTS(
374 m4_quote(m4_do([-Wstrict-prototypes -Wmissing-prototypes])),
376 ACX_PROG_CXX_WARNING_OPTS(
377 m4_quote(m4_do([-Wmissing-format-attribute])), [strict_warn])
378 ACX_PROG_CXX_WARNING_OPTS(
379 m4_quote(m4_do([-Woverloaded-virtual])), [strict_warn])
380 ACX_PROG_CC_WARNING_OPTS(
381 m4_quote(m4_do([-Wold-style-definition -Wc++-compat])), [c_strict_warn])
382 ACX_PROG_CXX_WARNING_ALMOST_PEDANTIC(
383 m4_quote(m4_do([-Wno-long-long -Wno-variadic-macros ],
384 [-Wno-overlength-strings])), [strict_warn])
385 ACX_PROG_CXX_WARNINGS_ARE_ERRORS([manual], [strict_warn])
387 # The above macros do nothing if the compiler is not GCC. However, the
388 # Makefile has more goo to add other flags, so these variables are used
389 # to enable warnings only for GCC.
392 if test "x$GCC" = "xyes"; then
393 warn_cflags='$(GCC_WARN_CFLAGS)'
394 warn_cxxflags='$(GCC_WARN_CXXFLAGS)'
396 AC_SUBST(warn_cflags)
397 AC_SUBST(warn_cxxflags)
399 # Disable exceptions and RTTI if building with g++
400 ACX_PROG_CC_WARNING_OPTS(
401 m4_quote(m4_do([-fno-exceptions -fno-rtti -fasynchronous-unwind-tables])),
404 # Enable expensive internal checks
406 if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then
410 AC_ARG_ENABLE(checking,
411 [AS_HELP_STRING([[--enable-checking[=LIST]]],
412 [enable expensive run-time checks. With LIST,
413 enable only specific categories of checks.
414 Categories are: yes,no,all,none,release.
415 Flags are: assert,df,fold,gc,gcac,gimple,misc,
416 rtlflag,rtl,runtime,tree,valgrind,types])],
417 [ac_checking_flags="${enableval}"],[
418 # Determine the default checks.
419 if test x$is_release = x ; then
420 ac_checking_flags=yes
422 ac_checking_flags=release
424 IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
425 for check in release $ac_checking_flags
428 # these set all the flags to specific states
429 yes) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking= ;
430 ac_fold_checking= ; ac_gc_checking=1 ;
431 ac_gc_always_collect= ; ac_gimple_checking=1 ; ac_rtl_checking= ;
432 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
433 ac_tree_checking=1 ; ac_valgrind_checking= ;
434 ac_types_checking=1 ;;
435 no|none) ac_assert_checking= ; ac_checking= ; ac_df_checking= ;
436 ac_fold_checking= ; ac_gc_checking= ;
437 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
438 ac_rtlflag_checking= ; ac_runtime_checking= ;
439 ac_tree_checking= ; ac_valgrind_checking= ;
440 ac_types_checking= ;;
441 all) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking=1 ;
442 ac_fold_checking=1 ; ac_gc_checking=1 ;
443 ac_gc_always_collect=1 ; ac_gimple_checking=1 ; ac_rtl_checking=1 ;
444 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
445 ac_tree_checking=1 ; ac_valgrind_checking= ;
446 ac_types_checking=1 ;;
447 release) ac_assert_checking=1 ; ac_checking= ; ac_df_checking= ;
448 ac_fold_checking= ; ac_gc_checking= ;
449 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
450 ac_rtlflag_checking= ; ac_runtime_checking=1 ;
451 ac_tree_checking= ; ac_valgrind_checking= ;
452 ac_types_checking= ;;
453 # these enable particular checks
454 assert) ac_assert_checking=1 ;;
455 df) ac_df_checking=1 ;;
456 fold) ac_fold_checking=1 ;;
457 gc) ac_gc_checking=1 ;;
458 gcac) ac_gc_always_collect=1 ;;
459 gimple) ac_gimple_checking=1 ;;
460 misc) ac_checking=1 ;;
461 rtl) ac_rtl_checking=1 ;;
462 rtlflag) ac_rtlflag_checking=1 ;;
463 runtime) ac_runtime_checking=1 ;;
464 tree) ac_tree_checking=1 ;;
465 types) ac_types_checking=1 ;;
466 valgrind) ac_valgrind_checking=1 ;;
467 *) AC_MSG_ERROR(unknown check category $check) ;;
473 if test x$ac_checking != x ; then
474 AC_DEFINE(ENABLE_CHECKING, 1,
475 [Define if you want more run-time sanity checks. This one gets a grab
476 bag of miscellaneous but relatively cheap checks.])
477 nocommon_flag=-fno-common
479 AC_SUBST(nocommon_flag)
480 if test x$ac_df_checking != x ; then
481 AC_DEFINE(ENABLE_DF_CHECKING, 1,
482 [Define if you want more run-time sanity checks for dataflow.])
484 if test x$ac_assert_checking != x ; then
485 AC_DEFINE(ENABLE_ASSERT_CHECKING, 1,
486 [Define if you want assertions enabled. This is a cheap check.])
488 if test x$ac_gimple_checking != x ; then
489 AC_DEFINE(ENABLE_GIMPLE_CHECKING, 1,
490 [Define if you want operations on GIMPLE (the basic data structure of
491 the high-level optimizers) to be checked for dynamic type safety at
492 runtime. This is moderately expensive.])
494 GCC_TARGET_TEMPLATE(ENABLE_RUNTIME_CHECKING)
495 if test x$ac_runtime_checking != x ; then
496 AC_DEFINE(ENABLE_RUNTIME_CHECKING, 1,
497 [Define if you want runtime assertions enabled. This is a cheap check.])
499 if test x$ac_tree_checking != x ; then
500 AC_DEFINE(ENABLE_TREE_CHECKING, 1,
501 [Define if you want all operations on trees (the basic data
502 structure of the front ends) to be checked for dynamic type safety
503 at runtime. This is moderately expensive. The tree browser debugging
504 routines will also be enabled by this option.
506 TREEBROWSER=tree-browser.o
509 if test x$ac_types_checking != x ; then
510 AC_DEFINE(ENABLE_TYPES_CHECKING, 1,
511 [Define if you want all gimple types to be verified after gimplifiation.
515 AC_SUBST(TREEBROWSER)
516 AC_SUBST(TREECHECKING)
517 if test x$ac_rtl_checking != x ; then
518 AC_DEFINE(ENABLE_RTL_CHECKING, 1,
519 [Define if you want all operations on RTL (the basic data structure
520 of the optimizer and back end) to be checked for dynamic type safety
521 at runtime. This is quite expensive.])
523 if test x$ac_rtlflag_checking != x ; then
524 AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
525 [Define if you want RTL flag accesses to be checked against the RTL
526 codes that are supported for each access macro. This is relatively
529 if test x$ac_gc_checking != x ; then
530 AC_DEFINE(ENABLE_GC_CHECKING, 1,
531 [Define if you want the garbage collector to do object poisoning and
532 other memory allocation checks. This is quite expensive.])
534 if test x$ac_gc_always_collect != x ; then
535 AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
536 [Define if you want the garbage collector to operate in maximally
537 paranoid mode, validating the entire heap and collecting garbage at
538 every opportunity. This is extremely expensive.])
540 if test x$ac_fold_checking != x ; then
541 AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
542 [Define if you want fold checked that it never destructs its argument.
543 This is quite expensive.])
545 valgrind_path_defines=
548 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
549 dnl # an if statement. This was the source of very frustrating bugs
550 dnl # in converting to autoconf 2.5x!
551 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
553 # It is certainly possible that there's valgrind but no valgrind.h.
554 # GCC relies on making annotations so we must have both.
555 AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
556 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
557 [[#include <valgrind/memcheck.h>
558 #ifndef VALGRIND_DISCARD
559 #error VALGRIND_DISCARD not defined
561 [gcc_cv_header_valgrind_memcheck_h=yes],
562 [gcc_cv_header_valgrind_memcheck_h=no])
563 AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
564 AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
565 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
566 [[#include <memcheck.h>
567 #ifndef VALGRIND_DISCARD
568 #error VALGRIND_DISCARD not defined
570 [gcc_cv_header_memcheck_h=yes],
571 [gcc_cv_header_memcheck_h=no])
572 AC_MSG_RESULT($gcc_cv_header_memcheck_h)
573 if test $gcc_cv_header_valgrind_memcheck_h = yes; then
574 AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
575 [Define if valgrind's valgrind/memcheck.h header is installed.])
577 if test $gcc_cv_header_memcheck_h = yes; then
578 AC_DEFINE(HAVE_MEMCHECK_H, 1,
579 [Define if valgrind's memcheck.h header is installed.])
582 if test x$ac_valgrind_checking != x ; then
583 AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
584 [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
585 if test "x$valgrind_path" = "x" \
586 || (test $have_valgrind_h = no \
587 && test $gcc_cv_header_memcheck_h = no \
588 && test $gcc_cv_header_valgrind_memcheck_h = no); then
589 AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
591 valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
592 valgrind_command="$valgrind_path -q"
593 AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
594 [Define if you want to run subprograms and generated programs
595 through valgrind (a memory checker). This is extremely expensive.])
597 AC_SUBST(valgrind_path_defines)
598 AC_SUBST(valgrind_command)
600 # Enable code coverage collection
601 AC_ARG_ENABLE(coverage,
602 [AS_HELP_STRING([[--enable-coverage[=LEVEL]]],
603 [enable compiler's code coverage collection.
604 Use to measure compiler performance and locate
605 unused parts of the compiler. With LEVEL, specify
606 optimization. Values are opt, noopt,
608 [case "${enableval}" in
610 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
613 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
616 # a.k.a. --disable-coverage
620 AC_MSG_ERROR(unknown coverage setting $enableval)
624 AC_SUBST(coverage_flags)
626 AC_ARG_ENABLE(gather-detailed-mem-stats,
627 [AS_HELP_STRING([--enable-gather-detailed-mem-stats],
628 [enable detailed memory allocation stats gathering])], [],
629 [enable_gather_detailed_mem_stats=no])
630 gather_stats=`if test $enable_gather_detailed_mem_stats != no; then echo 1; else echo 0; fi`
631 AC_DEFINE_UNQUOTED(GATHER_STATISTICS, $gather_stats,
632 [Define to enable detailed memory allocation stats gathering.])
634 AC_ARG_ENABLE(valgrind-annotations,
635 [AS_HELP_STRING([--enable-valgrind-annotations],
636 [enable valgrind runtime interaction])], [],
637 [enable_valgrind_annotations=no])
638 if test x$enable_valgrind_annotations != xno \
639 || test x$ac_valgrind_checking != x; then
640 if (test $have_valgrind_h = no \
641 && test $gcc_cv_header_memcheck_h = no \
642 && test $gcc_cv_header_valgrind_memcheck_h = no); then
643 AC_MSG_ERROR([*** Can't find valgrind/memcheck.h, memcheck.h or valgrind.h])
645 AC_DEFINE(ENABLE_VALGRIND_ANNOTATIONS, 1,
646 [Define to get calls to the valgrind runtime enabled.])
649 # -------------------------------
650 # Miscenalleous configure options
651 # -------------------------------
655 [AS_HELP_STRING([--with-stabs],
656 [arrange to use stabs instead of host debug format])],
660 # Determine whether or not multilibs are enabled.
661 AC_ARG_ENABLE(multilib,
662 [AS_HELP_STRING([--enable-multilib],
663 [enable library support for multiple ABIs])],
664 [], [enable_multilib=yes])
665 AC_SUBST(enable_multilib)
667 # Determine whether or not multiarch is enabled.
668 AC_ARG_ENABLE(multiarch,
669 [AS_HELP_STRING([--enable-multiarch],
670 [enable support for multiarch paths])],
671 [case "${enableval}" in
672 yes|no|auto) enable_multiarch=$enableval;;
673 *) AC_MSG_ERROR(bad value ${enableval} given for --enable-multiarch option) ;;
674 esac], [enable_multiarch=auto])
675 if test x${enable_multiarch} = xauto; then
676 if test x${with_native_system_header_dir} != x; then
677 ma_msg_suffix=", disabled auto check (configured with --native-system-header-dir)"
680 if test x$host != x$target && test "x$with_sysroot" = x; then
681 ma_msg_suffix=", disabled auto check (cross build configured without --with-sysroot)"
685 AC_MSG_CHECKING(for multiarch configuration)
686 AC_SUBST(enable_multiarch)
687 AC_MSG_RESULT($enable_multiarch$ma_msg_suffix)
689 # needed for setting the multiarch name for soft-float/hard-float ABIs
693 # Enable __cxa_atexit for C++.
694 AC_ARG_ENABLE(__cxa_atexit,
695 [AS_HELP_STRING([--enable-__cxa_atexit], [enable __cxa_atexit for C++])],
698 # Enable C extension for decimal float if target supports it.
699 GCC_AC_ENABLE_DECIMAL_FLOAT([$target])
701 dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi`
702 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp,
703 [Define to 1 to enable decimal float extension to C.])
705 # Use default_decimal_float for dependency.
706 enable_decimal_float=$default_decimal_float
708 bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi`
709 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid,
710 [Define to 1 to specify that we are using the BID decimal floating
711 point format instead of DPD])
713 # Enable C extension for fixed-point arithmetic.
714 AC_ARG_ENABLE(fixed-point,
715 [AS_HELP_STRING([--enable-fixed-point],
716 [enable fixed-point arithmetic extension to C])],
721 enable_fixed_point=yes
725 enable_fixed_point=yes
728 AC_MSG_WARN([fixed-point is not supported for this target, ignored])
729 enable_fixed_point=no
733 AC_SUBST(enable_fixed_point)
735 fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi`
736 AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint,
737 [Define to 1 to enable fixed-point arithmetic extension to C.])
740 # Pass with no value to take the default
741 # Pass with a value to specify a thread package
742 AC_ARG_ENABLE(threads,
743 [AS_HELP_STRING([[--enable-threads[=LIB]]],
744 [enable thread usage for target GCC,
745 using LIB thread package])],,
749 [AS_HELP_STRING([--enable-tls],
750 [enable or disable generation of tls code
751 overriding the assembler check for tls support])],
755 *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
756 Valid choices are 'yes' and 'no'.]) ;;
760 AC_ARG_ENABLE(objc-gc,
761 [AS_HELP_STRING([--enable-objc-gc],
762 [enable the use of Boehm's garbage collector with
763 the GNU Objective-C runtime])],
764 if test x$enable_objc_gc = xno; then
772 [AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2])],
773 dwarf2="$with_dwarf2",
776 AC_ARG_ENABLE(shared,
777 [AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])],
779 case $enable_shared in
783 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
784 for pkg in $enableval; do
785 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
792 ], [enable_shared=yes])
793 AC_SUBST(enable_shared)
795 AC_ARG_WITH([native-system-header-dir],
796 [ --with-native-system-header-dir=dir
797 use dir as the directory to look for standard
798 system header files in. Defaults to /usr/include.],
800 case ${with_native_system_header_dir} in
801 yes|no) AC_MSG_ERROR([bad value ${withval} given for --with-native-system-header-dir]) ;;
802 /* | [[A-Za-z]]:[[\\/]]*) ;;
803 *) AC_MSG_ERROR([--with-native-system-header-dir argument ${withval} must be an absolute directory]) ;;
805 configured_native_system_header_dir="${withval}"
806 ], [configured_native_system_header_dir=])
808 AC_ARG_WITH(build-sysroot,
809 [AS_HELP_STRING([--with-build-sysroot=sysroot],
810 [use sysroot as the system root during the build])],
811 [if test x"$withval" != x ; then
812 SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
814 [SYSROOT_CFLAGS_FOR_TARGET=])
815 AC_SUBST(SYSROOT_CFLAGS_FOR_TARGET)
817 if test "x$prefix" = xNONE; then
818 test_prefix=/usr/local
822 if test "x$exec_prefix" = xNONE; then
823 test_exec_prefix=$test_prefix
825 test_exec_prefix=$exec_prefix
829 [AS_HELP_STRING([[--with-sysroot[=DIR]]],
830 [search for usr/lib, usr/include, et al, within DIR])],
832 case ${with_sysroot} in
833 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
834 *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
837 TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
838 CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
840 case ${TARGET_SYSTEM_ROOT} in
841 "${test_prefix}"|"${test_prefix}/"*|\
842 "${test_exec_prefix}"|"${test_exec_prefix}/"*|\
843 '${prefix}'|'${prefix}/'*|\
844 '${exec_prefix}'|'${exec_prefix}/'*)
845 t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
846 TARGET_SYSTEM_ROOT_DEFINE="$t"
851 TARGET_SYSTEM_ROOT_DEFINE=
852 CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
854 AC_SUBST(TARGET_SYSTEM_ROOT)
855 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
856 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
859 [AS_HELP_STRING([--with-specs=SPECS],
860 [add SPECS to driver command-line processing])],
861 [CONFIGURE_SPECS=$withval],
864 AC_SUBST(CONFIGURE_SPECS)
866 ACX_PKGVERSION([GCC])
867 ACX_BUGURL([http://gcc.gnu.org/bugs.html])
869 # Sanity check enable_languages in case someone does not run the toplevel
870 # configure # script.
871 AC_ARG_ENABLE(languages,
872 [AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])],
873 [case ,${enable_languages}, in
875 # go safe -- we cannot be much sure without the toplevel
877 # analysis of which target libs are present and usable
881 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
886 enable_languages=c,${enable_languages}
889 [enable_languages=c])
891 if test x"$enable_as_accelerator_for" != x; then
892 AC_DEFINE(ACCEL_COMPILER, 1,
893 [Define if this compiler should be built as the offload target compiler.])
894 enable_as_accelerator=yes
897 # In this case we expect offload compiler to be built as native, so we
898 # need to rename the driver to avoid clashes with host's drivers.
899 program_transform_name="s&^&${target}-&" ;;
901 sedscript="s#${target_noncanonical}#${enable_as_accelerator_for}-accel-${target_noncanonical}#"
902 program_transform_name=`echo $program_transform_name | sed $sedscript`
903 accel_dir_suffix=/accel/${target_noncanonical}
904 real_target_noncanonical=${enable_as_accelerator_for}
906 AC_SUBST(enable_as_accelerator)
907 AC_SUBST(real_target_noncanonical)
908 AC_SUBST(accel_dir_suffix)
910 for tgt in `echo $enable_offload_targets | sed 's/,/ /g'`; do
911 tgt=`echo $tgt | sed 's/=.*//'`
912 if test x"$offload_targets" = x; then
915 offload_targets="$offload_targets:$tgt"
918 AC_DEFINE_UNQUOTED(OFFLOAD_TARGETS, "$offload_targets",
919 [Define to hold the list of target names suitable for offloading.])
920 if test x"$offload_targets" != x; then
921 AC_DEFINE(ENABLE_OFFLOADING, 1,
922 [Define this to enable support for offloading.])
925 AC_ARG_WITH(multilib-list,
926 [AS_HELP_STRING([--with-multilib-list], [select multilibs (AArch64, SH and x86-64 only)])],
928 with_multilib_list=default)
930 # -------------------------
931 # Checks for other programs
932 # -------------------------
936 # Find some useful tools
938 # We need awk to create options.c and options.h.
939 # Bail out if it's missing.
941 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
948 AC_SUBST(ranlib_flags)
952 # See if cmp has --ignore-initial.
953 gcc_AC_PROG_CMP_IGNORE_INITIAL
955 # See if we have the mktemp command.
956 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
958 # See if makeinfo has been installed and is modern enough
959 # that we can use it.
960 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
961 [GNU texinfo.* \([0-9][0-9.]*\)],
962 [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
963 if test $gcc_cv_prog_makeinfo_modern = no; then
965 *** Makeinfo is missing or too old.
966 *** Info documentation will not be built.])
973 # Is pod2man recent enough to regenerate manpages?
974 AC_MSG_CHECKING([for recent Pod::Man])
975 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
977 GENERATED_MANPAGES=generated-manpages
982 AC_SUBST(GENERATED_MANPAGES)
984 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
987 dnl Don't use AC_PROG_LEX; we insist on flex.
988 dnl LEXLIB is not useful in gcc.
989 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
992 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
994 # Binutils are not build modules, unlike bison/flex/makeinfo. So we
995 # check for build == host before using them.
998 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
999 && test -d ../binutils ; then
1000 NM='${objdir}/../binutils/nm-new'
1002 AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
1006 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
1007 && test -d ../binutils ; then
1008 AR='${objdir}/../binutils/ar'
1010 AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
1013 # The jit documentation looks better if built with sphinx, but can be
1014 # built with texinfo if sphinx is not available.
1015 # Set "doc_build_sys" to "sphinx" or "texinfo" accordingly.
1016 AC_CHECK_PROG(doc_build_sys, sphinx-build, sphinx, texinfo)
1018 # --------------------
1019 # Checks for C headers
1020 # --------------------
1022 # Need to reject headers which give warnings, so that the -Werror bootstrap
1023 # works later. *sigh* This needs to come before all header checks.
1030 AC_HEADER_TIOCGWINSZ
1031 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
1032 fcntl.h ftw.h unistd.h sys/file.h sys/time.h sys/mman.h \
1033 sys/resource.h sys/param.h sys/times.h sys/stat.h \
1034 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
1036 # Check for thread headers.
1037 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
1038 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
1040 # These tests can't be done till we know if we have limits.h.
1044 # ----------------------
1045 # Checks for C++ headers
1046 # ----------------------
1048 dnl Autoconf will give an error in the configure script if there is no
1049 dnl C++ preprocessor. Hack to prevent that.
1050 m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl
1052 m4_popdef([AC_MSG_ERROR])[]dnl
1054 AC_CHECK_HEADERS(unordered_map)
1055 AC_CHECK_HEADERS(tr1/unordered_map)
1056 AC_CHECK_HEADERS(ext/hash_map)
1059 # Dependency checking.
1063 AC_CONFIG_COMMANDS([gccdepdir],[
1064 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs build/$DEPDIR
1065 for lang in $subdirs c-family common
1067 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs $lang/$DEPDIR
1068 done], [subdirs="$subdirs" ac_aux_dir=$ac_aux_dir DEPDIR=$DEPDIR])
1070 ZW_PROG_COMPILER_DEPENDENCIES([CXX])
1077 # These libraries may be used by collect2.
1078 # We may need a special search path to get them linked.
1079 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
1081 for libs in '' -lld -lmld \
1082 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
1083 '-L/usr/lib/cmplrs/cc3.11 -lmld'
1086 AC_TRY_LINK_FUNC(ldopen,
1087 [gcc_cv_collect2_libs="$libs"; break])
1090 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
1091 case $gcc_cv_collect2_libs in
1093 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
1095 AC_SUBST(COLLECT2_LIBS)
1097 # When building Ada code on Alpha, we need exc_resume which is usually in
1098 # -lexc. So test for it.
1101 AC_SEARCH_LIBS(exc_resume, exc)
1104 AC_SUBST(GNAT_LIBEXC)
1106 # To support -mcpu=native on Solaris/SPARC, we need libkstat.
1109 AC_SEARCH_LIBS(kstat_open, kstat)
1110 EXTRA_GCC_LIBS="$LIBS"
1112 AC_SUBST(EXTRA_GCC_LIBS)
1114 # Some systems put ldexp and frexp in libm instead of libc; assume
1115 # they're both in the same place. jcf-dump needs them.
1118 AC_SEARCH_LIBS(ldexp, m)
1123 # Use <inttypes.h> only if it exists,
1124 # doesn't clash with <sys/types.h>, declares intmax_t and defines
1126 AC_MSG_CHECKING(for inttypes.h)
1127 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
1128 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1129 [[#define __STDC_FORMAT_MACROS
1130 #include <sys/types.h>
1131 #include <inttypes.h>]],
1136 [gcc_cv_header_inttypes_h=yes],
1137 [gcc_cv_header_inttypes_h=no])])
1138 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
1139 if test $gcc_cv_header_inttypes_h = yes; then
1140 AC_DEFINE(HAVE_INTTYPES_H, 1,
1141 [Define if you have a working <inttypes.h> header file.])
1144 dnl Disabled until we have a complete test for buggy enum bitfields.
1145 dnl gcc_AC_C_ENUM_BF_UNSIGNED
1147 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
1148 ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
1149 fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
1150 fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
1151 putchar_unlocked putc_unlocked)
1152 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoq \
1153 popen sysconf strsignal getrusage nl_langinfo \
1154 gettimeofday mbstowcs wcswidth mmap setlocale \
1155 gcc_UNLOCKED_FUNCS madvise)
1157 if test x$ac_cv_func_mbstowcs = xyes; then
1158 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
1159 [ AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
1165 [gcc_cv_func_mbstowcs_works=yes],
1166 [gcc_cv_func_mbstowcs_works=no],
1167 [gcc_cv_func_mbstowcs_works=yes])])
1168 if test x$gcc_cv_func_mbstowcs_works = xyes; then
1169 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
1170 [Define this macro if mbstowcs does not crash when its
1171 first argument is NULL.])
1175 AC_CHECK_TYPE(ssize_t, int)
1176 AC_CHECK_TYPE(caddr_t, char *)
1178 GCC_AC_FUNC_MMAP_BLACKLIST
1182 # Under VMS, vfork works very differently than on Unix. The standard test
1183 # won't work, and it isn't easily adaptable. It makes more sense to
1185 ac_cv_func_vfork_works=yes
1192 # Until we have in-tree GNU iconv:
1194 AC_SUBST(LIBICONV_DEP)
1200 # We will need to find libiberty.h and ansidecl.h
1201 saved_CFLAGS="$CFLAGS"
1202 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1203 saved_CXXFLAGS="$CXXFLAGS"
1204 CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1206 # gcc_AC_CHECK_DECLS doesn't support overloaded functions, so use the
1207 # normal autoconf function for these. But force definition of
1208 # HAVE_DECL_BASENAME like gcc_AC_CHECK_DECLS does, to suppress the bizarre
1209 # basename handling in libiberty.h.
1210 AC_CHECK_DECLS([basename(const char*), strstr(const char*,const char*)], , ,[
1211 #undef HAVE_DECL_BASENAME
1212 #define HAVE_DECL_BASENAME 1
1213 #include "ansidecl.h"
1214 #include "system.h"])
1216 gcc_AC_CHECK_DECLS(getenv atol atoll asprintf sbrk abort atof getcwd getwd \
1217 madvise stpcpy strnlen strsignal strverscmp \
1218 strtol strtoul strtoll strtoull \
1219 errno snprintf vsnprintf vasprintf malloc realloc calloc \
1220 free getopt clock getpagesize ffs gcc_UNLOCKED_FUNCS, , ,[
1221 #include "ansidecl.h"
1222 #include "system.h"])
1224 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1225 #include "ansidecl.h"
1227 #ifdef HAVE_SYS_RESOURCE_H
1228 #include <sys/resource.h>
1232 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1233 #include "ansidecl.h"
1235 #ifdef HAVE_SYS_RESOURCE_H
1236 #include <sys/resource.h>
1238 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1239 [Define to `long' if <sys/resource.h> doesn't define.])])
1241 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1242 # FREAD and FWRITE macros. Fortunately, for GCC's single usage of ldgetname
1243 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1244 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1245 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1246 #include "ansidecl.h"
1255 gcc_AC_CHECK_DECLS(times, , ,[
1256 #include "ansidecl.h"
1258 #ifdef HAVE_SYS_TIMES_H
1259 #include <sys/times.h>
1263 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1264 #include "ansidecl.h"
1269 # More time-related stuff.
1270 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1271 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1272 #include "ansidecl.h"
1274 #ifdef HAVE_SYS_TIMES_H
1275 #include <sys/times.h>
1277 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1278 if test $ac_cv_struct_tms = yes; then
1279 AC_DEFINE(HAVE_STRUCT_TMS, 1,
1280 [Define if <sys/times.h> defines struct tms.])
1283 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1284 # revisit after autoconf 2.50.
1285 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1286 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1287 #include "ansidecl.h"
1289 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1290 if test $gcc_cv_type_clock_t = yes; then
1291 AC_DEFINE(HAVE_CLOCK_T, 1,
1292 [Define if <time.h> defines clock_t.])
1295 # Check if F_SETLKW is supported by fcntl.
1296 AC_CACHE_CHECK(for F_SETLKW, ac_cv_f_setlkw, [
1297 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1298 #include <fcntl.h>]], [[
1304 return fcntl (1, F_SETLKW, &fl);]])],
1305 [ac_cv_f_setlkw=yes],[ac_cv_f_setlkw=no])])
1306 if test $ac_cv_f_setlkw = yes; then
1307 AC_DEFINE(HOST_HAS_F_SETLKW, 1,
1308 [Define if F_SETLKW supported by fcntl.])
1311 # Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1312 CFLAGS="$saved_CFLAGS"
1313 CXXFLAGS="$saved_CXXFLAGS"
1315 # mkdir takes a single argument on some systems.
1316 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1324 # With Setjmp/Longjmp based exception handling.
1325 AC_ARG_ENABLE(sjlj-exceptions,
1326 [AS_HELP_STRING([--enable-sjlj-exceptions],
1327 [arrange to use setjmp/longjmp exception handling])],
1330 if test $enableval != yes; then
1331 AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1336 force_sjlj_exceptions=yes],
1339 force_sjlj_exceptions=yes
1343 force_sjlj_exceptions=yes
1347 force_sjlj_exceptions=no
1350 if test $force_sjlj_exceptions = yes; then
1351 sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1352 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1353 [Define 0/1 to force the choice for exception handling model.])
1356 # --------------------------------------------------------
1357 # Build, host, and target specific configuration fragments
1358 # --------------------------------------------------------
1360 # Collect build-machine-specific information.
1361 . ${srcdir}/config.build
1363 # Collect host-machine-specific information.
1364 . ${srcdir}/config.host
1368 # Collect target-machine-specific information.
1369 . ${srcdir}/config.gcc
1371 extra_objs="${host_extra_objs} ${extra_objs}"
1372 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1374 # Default the target-machine variables that were not explicitly set.
1375 if test x"$tm_file" = x
1376 then tm_file=$cpu_type/$cpu_type.h; fi
1378 if test x"$extra_headers" = x
1379 then extra_headers=; fi
1381 if test x$md_file = x
1382 then md_file=$cpu_type/$cpu_type.md; fi
1384 if test x$out_file = x
1385 then out_file=$cpu_type/$cpu_type.c; fi
1387 if test x"$tmake_file" = x
1388 then tmake_file=$cpu_type/t-$cpu_type
1391 # Support --enable-initfini-array.
1392 if test x$enable_initfini_array != xno; then
1393 tm_file="${tm_file} initfini-array.h"
1396 if test x"$dwarf2" = xyes
1397 then tm_file="$tm_file tm-dwarf2.h"
1400 # Say what files are being used for the output code and MD file.
1401 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1402 echo "Using \`$srcdir/config/$md_file' as machine description file."
1404 # If any of the xm_file variables contain nonexistent files, warn
1405 # about them and drop them.
1408 for x in $build_xm_file; do
1409 if test -f $srcdir/config/$x
1411 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1417 for x in $host_xm_file; do
1418 if test -f $srcdir/config/$x
1420 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1426 for x in $xm_file; do
1427 if test -f $srcdir/config/$x
1429 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1435 for f in $tm_file; do
1438 if test $count = ax; then
1439 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1441 echo "Using the following target machine macro files:"
1442 for f in $tm_file; do
1443 echo " $srcdir/config/$f"
1447 if test x$use_long_long_for_widest_fast_int = xyes; then
1448 AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1449 [Define to 1 if the 'long long' type is wider than 'long' but still
1450 efficiently supported by the host hardware.])
1453 gnu_ld_bool=`if test x"$gnu_ld" = x"yes"; then echo 1; else echo 0; fi`
1454 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld_bool, [Define to 1 if using GNU ld.])
1456 gnu_as_bool=`if test x"$gas" = x"yes"; then echo 1; else echo 0; fi`
1457 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as_bool, [Define to 1 if using GNU as.])
1460 for f in $host_xm_file; do
1463 if test $count = a; then
1465 elif test $count = ax; then
1466 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1468 echo "Using the following host machine macro files:"
1469 for f in $host_xm_file; do
1470 echo " $srcdir/config/$f"
1473 echo "Using ${out_host_hook_obj} for host machine hooks."
1475 if test "$host_xm_file" != "$build_xm_file"; then
1477 for f in $build_xm_file; do
1480 if test $count = a; then
1482 elif test $count = ax; then
1483 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1485 echo "Using the following build machine macro files:"
1486 for f in $build_xm_file; do
1487 echo " $srcdir/config/$f"
1492 if test -n "$configured_native_system_header_dir"; then
1493 native_system_header_dir=$configured_native_system_header_dir
1495 NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir"
1496 AC_SUBST(NATIVE_SYSTEM_HEADER_DIR)
1500 AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1501 gcc_cv_mcontext_underscores,
1503 #include <sys/cdefs.h>
1504 #include <sys/signal.h>
1505 #include <ucontext.h>
1506 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1508 gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1509 if test $gcc_cv_mcontext_underscores = yes; then
1510 AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1511 [mcontext_t fields start with __])
1520 # Check if a valid thread package
1521 case ${enable_threads} in
1524 target_thread_file='single'
1528 target_thread_file='single'
1530 aix | dce | lynx | mipssde | posix | rtems | \
1531 single | tpf | vxworks | win32)
1532 target_thread_file=${enable_threads}
1535 echo "${enable_threads} is an unknown thread package" 1>&2
1540 if test x${thread_file} = x; then
1541 # No thread file set by target-specific clauses in config.gcc,
1542 # so use file chosen by default logic above
1543 thread_file=${target_thread_file}
1551 if test x$enable___cxa_atexit = xyes || \
1552 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1553 if test x$host = x$target; then
1555 # mingw32 doesn't have __cxa_atexit but uses atexit registration
1556 # keyed to flag_use_cxa_atexit
1564 AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1565 [echo "__cxa_atexit can't be enabled on this target"])
1569 # We can't check for __cxa_atexit when building a cross, so assume
1573 if test x$use_cxa_atexit = xyes; then
1574 AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1575 [Define if you want to use __cxa_atexit, rather than atexit, to
1576 register C++ destructors for local statics and global objects.
1577 This is essential for fully standards-compliant handling of
1578 destructors, but requires __cxa_atexit in libc.])
1582 # Look for a file containing extra machine modes.
1583 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1584 extra_modes_file='$(srcdir)'/config/${extra_modes}
1585 AC_SUBST(extra_modes_file)
1586 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1587 [Define to the name of a file containing a list of extra machine modes
1588 for this architecture.])
1591 # Convert extra_options into a form suitable for Makefile use.
1594 for f in $extra_options; do
1595 extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1596 all_opt_files="$all_opt_files $srcdir/config/$f"
1598 AC_SUBST(extra_opt_files)
1600 # auto-host.h is the file containing items generated by autoconf and is
1601 # the first file included by config.h.
1602 # If host=build, it is correct to have bconfig include auto-host.h
1603 # as well. If host!=build, we are in error and need to do more
1604 # work to find out the build config parameters.
1605 if test x$host = x$build
1607 build_auto=auto-host.h
1609 # We create a subdir, then run autoconf in the subdir.
1610 # To prevent recursion we set host and build for the new
1611 # invocation of configure to the build for this invocation
1618 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1619 *) realsrcdir=../${srcdir};;
1621 # Clearing GMPINC is necessary to prevent host headers being
1622 # used by the build compiler. Defining GENERATOR_FILE stops
1623 # system.h from including gmp.h.
1624 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1625 CXX="${CXX_FOR_BUILD}" CXXFLAGS="${CXXFLAGS_FOR_BUILD}" \
1626 LD="${LD_FOR_BUILD}" LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1627 GMPINC="" CPPFLAGS="${CPPFLAGS} -DGENERATOR_FILE" \
1628 ${realsrcdir}/configure \
1629 --enable-languages=${enable_languages-all} \
1630 --target=$target_alias --host=$build_alias --build=$build_alias
1632 # We just finished tests for the build machine, so rename
1633 # the file auto-build.h in the gcc directory.
1634 mv auto-host.h ../auto-build.h
1637 build_auto=auto-build.h
1639 AC_SUBST(build_subdir)
1641 tm_file="${tm_file} defaults.h"
1642 tm_p_file="${tm_p_file} tm-preds.h"
1643 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1644 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1645 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1646 # put this back in temporarily.
1647 xm_file="auto-host.h ansidecl.h ${xm_file}"
1654 # Compile in configure arguments.
1655 if test -f configargs.h ; then
1656 # Being re-configured.
1657 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1658 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1660 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1663 # Double all backslashes and backslash all quotes to turn
1664 # gcc_config_arguments into a C string.
1665 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1666 $gcc_config_arguments
1668 gcc_config_arguments_str=`cat conftest.out`
1671 cat > configargs.h <<EOF
1672 /* Generated automatically. */
1673 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1674 static const char thread_model[] = "$thread_file";
1676 static const struct {
1677 const char *name, *value;
1678 } configure_default_options[] = $configure_default_options;
1683 gcc_BASEVER=`cat $srcdir/BASE-VER`
1684 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
1685 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
1686 if test -f $srcdir/REVISION ; then
1687 gcc_REVISION=`cat $srcdir/REVISION`
1691 cat > plugin-version.h <<EOF
1692 #include "configargs.h"
1694 #define GCCPLUGIN_VERSION_MAJOR `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'`
1695 #define GCCPLUGIN_VERSION_MINOR `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'`
1696 #define GCCPLUGIN_VERSION_PATCHLEVEL `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'`
1697 #define GCCPLUGIN_VERSION (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR)
1699 static char basever[] = "$gcc_BASEVER";
1700 static char datestamp[] = "$gcc_DATESTAMP";
1701 static char devphase[] = "$gcc_DEVPHASE";
1702 static char revision[] = "$gcc_REVISION";
1704 /* FIXME plugins: We should make the version information more precise.
1705 One way to do is to add a checksum. */
1707 static struct plugin_gcc_version gcc_version = {basever, datestamp,
1709 configuration_arguments};
1713 # Internationalization
1714 ZW_GNU_GETTEXT_SISTER_DIR
1716 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1717 # -liconv on the link line twice.
1718 case "$LIBINTL" in *$LIBICONV*)
1722 AC_ARG_ENABLE(secureplt,
1723 [AS_HELP_STRING([--enable-secureplt],
1724 [enable -msecure-plt by default for PowerPC])],
1727 AC_ARG_ENABLE(leading-mingw64-underscores,
1728 AS_HELP_STRING([--enable-leading-mingw64-underscores],
1729 [enable leading underscores on 64 bit mingw targets]),
1731 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
1732 [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
1733 [Define if we should use leading underscore on 64 bit mingw targets])])
1736 [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [],
1739 AC_ARG_ENABLE(frame-pointer,
1740 [AS_HELP_STRING([--enable-frame-pointer],
1741 [enable -fno-omit-frame-pointer by default for 32bit x86])], [],
1744 linux* | darwin[[8912]]*)
1745 # Enable -fomit-frame-pointer by default for Linux and Darwin with
1747 enable_frame_pointer=no
1750 enable_frame_pointer=yes
1755 # Windows32 Registry support for specifying GCC installation paths.
1756 AC_ARG_ENABLE(win32-registry,
1757 [AS_HELP_STRING([--disable-win32-registry],
1758 [disable lookup of installation paths in the
1759 Registry on Windows hosts])
1760 AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)])
1761 AS_HELP_STRING([--enable-win32-registry=KEY],
1762 [use KEY instead of GCC version as the last portion
1763 of the registry key])],,)
1766 win32 | pe | cygwin* | mingw32* | uwin*)
1767 if test "x$enable_win32_registry" != xno; then
1768 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1771 if test "x$enable_win32_registry" != xno; then
1772 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1773 [Define to 1 if installation paths should be looked up in the Windows
1774 Registry. Ignored on non-Windows hosts.])
1776 if test "x$enable_win32_registry" != xyes \
1777 && test "x$enable_win32_registry" != x; then
1778 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1779 [Define to be the last component of the Windows registry key under which
1780 to look for installation paths. The full key used will be
1781 HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1782 The default is the GCC version number.])
1788 # Get an absolute path to the GCC top-level source directory
1789 holddir=`${PWDCMD-pwd}`
1791 topdir=`${PWDCMD-pwd}`
1794 # Conditionalize the makefile for this host machine.
1796 for f in ${host_xmake_file}
1798 if test -f ${srcdir}/config/$f
1800 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1804 # Conditionalize the makefile for this target machine.
1806 for f in ${tmake_file}
1808 if test -f ${srcdir}/config/$f
1810 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1813 tmake_file="${tmake_file_}"
1815 out_object_file=`basename $out_file .c`.o
1816 common_out_object_file=`basename $common_out_file .c`.o
1818 tm_file_list="options.h"
1819 tm_include_list="options.h insn-constants.h"
1820 for f in $tm_file; do
1823 f=`echo $f | sed 's/^..//'`
1824 tm_file_list="${tm_file_list} $f"
1825 tm_include_list="${tm_include_list} $f"
1828 tm_file_list="${tm_file_list} \$(srcdir)/$f"
1829 tm_include_list="${tm_include_list} $f"
1832 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1833 tm_include_list="${tm_include_list} config/$f"
1840 for f in $tm_p_file; do
1843 tm_p_file_list="${tm_p_file_list} $f"
1844 tm_p_include_list="${tm_p_include_list} $f"
1847 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1848 tm_p_include_list="${tm_p_include_list} config/$f"
1854 for f in $xm_file; do
1857 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1858 xm_include_list="${xm_include_list} $f"
1861 xm_file_list="${xm_file_list} $f"
1862 xm_include_list="${xm_include_list} $f"
1865 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1866 xm_include_list="${xm_include_list} config/$f"
1872 host_xm_include_list=
1873 for f in $host_xm_file; do
1876 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1877 host_xm_include_list="${host_xm_include_list} $f"
1880 host_xm_file_list="${host_xm_file_list} $f"
1881 host_xm_include_list="${host_xm_include_list} $f"
1884 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1885 host_xm_include_list="${host_xm_include_list} config/$f"
1891 for f in $build_xm_file; do
1894 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1895 build_xm_include_list="${build_xm_include_list} $f"
1897 auto-build.h | auto-host.h )
1898 build_xm_file_list="${build_xm_file_list} $f"
1899 build_xm_include_list="${build_xm_include_list} $f"
1902 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1903 build_xm_include_list="${build_xm_include_list} config/$f"
1908 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1909 # cross-compiler which does not use the native headers and libraries.
1910 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1911 CROSS= AC_SUBST(CROSS)
1912 ALL=all.internal AC_SUBST(ALL)
1913 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1915 if test "x$with_build_sysroot" != x; then
1916 build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1918 # This value is used, even on a native system, because
1919 # CROSS_SYSTEM_HEADER_DIR is just
1920 # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1921 build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1924 if test x$host != x$target
1926 CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1928 SYSTEM_HEADER_DIR=$build_system_header_dir
1929 case "$host","$target" in
1930 # Darwin crosses can use the host system's libraries and headers,
1931 # because of the fat library support. Of course, it must be the
1932 # same version of Darwin on both sides. Allow the user to
1933 # just say --target=foo-darwin without a version number to mean
1934 # "the version on this system".
1935 *-*-darwin*,*-*-darwin*)
1936 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1937 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1938 if test $hostos = $targetos -o $targetos = darwin ; then
1940 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1945 i?86-*-*,x86_64-*-* \
1946 | powerpc*-*-*,powerpc64*-*-*)
1947 CROSS="$CROSS -DNATIVE_CROSS" ;;
1952 if test "x$with_headers" = x; then
1959 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1960 SYSTEM_HEADER_DIR=$build_system_header_dir
1963 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
1964 if test "x$with_headers" != x; then
1965 target_header_dir=$with_headers
1966 elif test "x$with_sysroot" = x; then
1967 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include"
1968 elif test "x$with_build_sysroot" != "x"; then
1969 target_header_dir="${with_build_sysroot}${native_system_header_dir}"
1970 elif test "x$with_sysroot" = xyes; then
1971 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
1973 target_header_dir="${with_sysroot}${native_system_header_dir}"
1976 target_header_dir=${native_system_header_dir}
1979 # If this is a cross-compiler that does not
1980 # have its own set of headers then define
1983 # If this is using newlib, without having the headers available now,
1984 # then define inhibit_libc in LIBGCC2_CFLAGS.
1985 # This prevents libgcc2 from containing any code which requires libc
1987 : ${inhibit_libc=false}
1988 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1989 test x$with_newlib = xyes ; } &&
1990 { test "x$with_headers" = xno || test ! -f "$target_header_dir/stdio.h"; } ; then
1993 AC_SUBST(inhibit_libc)
1995 # When building gcc with a cross-compiler, we need to adjust things so
1996 # that the generator programs are still built with the native compiler.
1997 # Also, we cannot run fixincludes.
1999 # These are the normal (build=host) settings:
2000 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
2001 CXX_FOR_BUILD='$(CXX)' AC_SUBST(CXX_FOR_BUILD)
2002 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
2003 BUILD_CXXFLAGS='$(ALL_CXXFLAGS)' AC_SUBST(BUILD_CXXFLAGS)
2004 BUILD_LDFLAGS='$(LDFLAGS)' AC_SUBST(BUILD_LDFLAGS)
2005 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
2007 # And these apply if build != host, or we are generating coverage data
2008 if test x$build != x$host || test "x$coverage_flags" != x
2010 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
2011 BUILD_CXXFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CXXFLAGS_FOR_BUILD)'
2012 BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
2015 # Expand extra_headers to include complete path.
2016 # This substitutes for lots of t-* files.
2018 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
2019 for file in ${extra_headers} ; do
2020 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
2023 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
2024 if test x"$use_gcc_tgmath" = xyes
2025 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
2028 # Define collect2 in Makefile.
2029 case $host_can_use_collect2 in
2031 *) collect2='collect2$(exeext)' ;;
2033 AC_SUBST([collect2])
2035 # Add a definition of USE_COLLECT2 if system wants one.
2036 case $use_collect2 in
2037 no) use_collect2= ;;
2040 host_xm_defines="${host_xm_defines} USE_COLLECT2"
2041 xm_defines="${xm_defines} USE_COLLECT2"
2042 case $host_can_use_collect2 in
2044 AC_MSG_ERROR([collect2 is required but cannot be built on this system])
2050 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
2051 [Define to the name of the LTO plugin DSO that must be
2052 passed to the linker's -plugin=LIB option.])
2054 # ---------------------------
2055 # Assembler & linker features
2056 # ---------------------------
2058 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
2059 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
2060 # However when ld-new is first executed from the build tree, libtool will
2061 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
2062 # to the build tree. While doing this we need to use the previous-stage
2063 # linker, or we have an infinite loop. The presence of a shell script as
2064 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
2065 # the gcc/collect-ld script. So we need to know how libtool works, or
2066 # exec-tool will fail.
2068 m4_defun([_LT_CONFIG_COMMANDS], [])
2071 AC_SUBST(enable_fast_install)
2073 # Identify the assembler which will work hand-in-glove with the newly
2074 # built GCC, so that we can examine its features. This is the assembler
2075 # which will be driven by the driver program.
2077 # If build != host, and we aren't building gas in-tree, we identify a
2078 # build->target assembler and hope that it will have the same features
2079 # as the host->target assembler we'll be using.
2080 gcc_cv_gas_major_version=
2081 gcc_cv_gas_minor_version=
2082 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
2084 m4_pattern_allow([AS_FOR_TARGET])dnl
2085 AS_VAR_SET_IF(gcc_cv_as,, [
2086 if test -x "$DEFAULT_ASSEMBLER"; then
2087 gcc_cv_as="$DEFAULT_ASSEMBLER"
2088 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
2089 && test -f ../gas/Makefile \
2090 && test x$build = x$host; then
2091 gcc_cv_as=../gas/as-new$build_exeext
2092 elif test -x as$build_exeext; then
2093 # Build using assembler in the current directory.
2094 gcc_cv_as=./as$build_exeext
2095 elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then
2096 gcc_cv_as="$AS_FOR_TARGET"
2098 AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
2101 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
2102 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
2103 case "$ORIGINAL_AS_FOR_TARGET" in
2104 ./as | ./as$build_exeext) ;;
2105 *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
2108 AC_MSG_CHECKING(what assembler to use)
2109 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
2110 # Single tree build which includes gas. We want to prefer it
2111 # over whatever linker top-level may have detected, since
2112 # we'll use what we're building after installation anyway.
2113 AC_MSG_RESULT(newly built gas)
2115 _gcc_COMPUTE_GAS_VERSION
2116 in_tree_gas_is_elf=no
2117 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2118 || (grep 'obj_format = multi' ../gas/Makefile \
2119 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
2121 in_tree_gas_is_elf=yes
2124 AC_MSG_RESULT($gcc_cv_as)
2130 [[ --enable-ld[=ARG] build ld [ARG={default,yes,no}]]],
2131 [case "${enableval}" in
2137 install_gold_as_default=no
2139 [[ --enable-gold[=ARG] build gold [ARG={default,yes,no}]]],
2140 [case "${enableval}" in
2142 install_gold_as_default=yes
2145 if test x${default_ld} != x; then
2146 install_gold_as_default=yes
2152 AC_MSG_ERROR([invalid --enable-gold argument])
2156 # Identify the linker which will work hand-in-glove with the newly
2157 # built GCC, so that we can examine its features. This is the linker
2158 # which will be driven by the driver program.
2160 # If build != host, and we aren't building gas in-tree, we identify a
2161 # build->target linker and hope that it will have the same features
2162 # as the host->target linker we'll be using.
2163 gcc_cv_gld_major_version=
2164 gcc_cv_gld_minor_version=
2165 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
2166 gcc_cv_ld_gold_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gold
2167 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
2169 AS_VAR_SET_IF(gcc_cv_ld,, [
2170 if test -x "$DEFAULT_LINKER"; then
2171 gcc_cv_ld="$DEFAULT_LINKER"
2172 elif test $install_gold_as_default = yes \
2173 && test -f $gcc_cv_ld_gold_srcdir/configure.ac \
2174 && test -f ../gold/Makefile \
2175 && test x$build = x$host; then
2176 gcc_cv_ld=../gold/ld-new$build_exeext
2177 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
2178 && test -f ../ld/Makefile \
2179 && test x$build = x$host; then
2180 gcc_cv_ld=../ld/ld-new$build_exeext
2181 elif test -x collect-ld$build_exeext; then
2182 # Build using linker in the current directory.
2183 gcc_cv_ld=./collect-ld$build_exeext
2184 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
2185 gcc_cv_ld="$LD_FOR_TARGET"
2187 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
2190 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
2191 PLUGIN_LD_SUFFIX=`basename $gcc_cv_ld | sed -e "s,$target_alias-,,"`
2192 # if the PLUGIN_LD is set ld-new, just have it as ld
2193 # as that is the installed named.
2194 if test x$PLUGIN_LD_SUFFIX = xld-new \
2195 || test x$PLUGIN_LD_SUFFIX = xcollect-ld ; then
2198 AC_ARG_WITH(plugin-ld,
2199 [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])],
2200 [if test x"$withval" != x; then
2201 ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
2202 PLUGIN_LD_SUFFIX=`echo $withval | sed -e "s,$target_alias-,,"`
2204 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
2205 AC_DEFINE_UNQUOTED(PLUGIN_LD_SUFFIX, "$PLUGIN_LD_SUFFIX", [Specify plugin linker])
2207 # Check to see if we are using gold instead of ld
2208 AC_MSG_CHECKING(whether we are using gold)
2210 if test x$gcc_cv_ld != x; then
2211 if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2212 | grep "GNU gold" > /dev/null; then
2216 AC_MSG_RESULT($ld_is_gold)
2218 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
2219 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
2220 case "$ORIGINAL_LD_FOR_TARGET" in
2221 ./collect-ld | ./collect-ld$build_exeext) ;;
2222 *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
2225 AC_MSG_CHECKING(what linker to use)
2226 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \
2227 || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then
2228 # Single tree build which includes ld. We want to prefer it
2229 # over whatever linker top-level may have detected, since
2230 # we'll use what we're building after installation anyway.
2231 AC_MSG_RESULT(newly built ld)
2233 in_tree_ld_is_elf=no
2234 if (grep 'EMUL = .*elf' ../ld/Makefile \
2235 || grep 'EMUL = .*linux' ../ld/Makefile \
2236 || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
2237 in_tree_ld_is_elf=yes
2238 elif test "$ld_is_gold" = yes; then
2239 in_tree_ld_is_elf=yes
2241 for f in $gcc_cv_ld_bfd_srcdir/configure $gcc_cv_ld_gld_srcdir/configure $gcc_cv_ld_gld_srcdir/configure.in $gcc_cv_ld_gld_srcdir/Makefile.in
2244 gcc_cv_gld_version=`sed -n -e 's/^[ ]*VERSION=[^0-9A-Za-z_]*\([0-9]*\.[0-9]*.*\)/VERSION=\1/p' < $f`
2245 if test x$gcc_cv_gld_version != x; then
2249 case $gcc_cv_gld_version in
2252 *) AC_MSG_ERROR([[cannot find version of in-tree linker]]) ;;
2255 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2256 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2258 ORIGINAL_LD_BFD_FOR_TARGET=../ld/ld-new$build_exeext
2259 ORIGINAL_LD_GOLD_FOR_TARGET=../gold/ld-new$build_exeext
2261 AC_MSG_RESULT($gcc_cv_ld)
2263 gcc_cvs_ld_program=`dirname $gcc_cv_ld`/`basename $gcc_cv_ld $host_exeext`
2264 ORIGINAL_LD_BFD_FOR_TARGET=${gcc_cvs_ld_program}.bfd$host_exeext
2265 ORIGINAL_LD_GOLD_FOR_TARGET=${gcc_cvs_ld_program}.gold$host_exeext
2268 AC_SUBST(ORIGINAL_LD_BFD_FOR_TARGET)
2269 AC_SUBST(ORIGINAL_LD_GOLD_FOR_TARGET)
2271 # Figure out what nm we will be using.
2272 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2273 AS_VAR_SET_IF(gcc_cv_nm,, [
2274 if test -f $gcc_cv_binutils_srcdir/configure.in \
2275 && test -f ../binutils/Makefile \
2276 && test x$build = x$host; then
2277 gcc_cv_nm=../binutils/nm-new$build_exeext
2278 elif test -x nm$build_exeext; then
2279 gcc_cv_nm=./nm$build_exeext
2280 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
2281 gcc_cv_nm="$NM_FOR_TARGET"
2283 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2286 AC_MSG_CHECKING(what nm to use)
2287 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2288 # Single tree build which includes binutils.
2289 AC_MSG_RESULT(newly built nm)
2292 AC_MSG_RESULT($gcc_cv_nm)
2296 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2297 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2298 case "$ORIGINAL_NM_FOR_TARGET" in
2299 ./nm | ./nm$build_exeext) ;;
2300 *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2304 # Figure out what objdump we will be using.
2305 AS_VAR_SET_IF(gcc_cv_objdump,, [
2306 if test -f $gcc_cv_binutils_srcdir/configure.in \
2307 && test -f ../binutils/Makefile \
2308 && test x$build = x$host; then
2309 # Single tree build which includes binutils.
2310 gcc_cv_objdump=../binutils/objdump$build_exeext
2311 elif test -x objdump$build_exeext; then
2312 gcc_cv_objdump=./objdump$build_exeext
2313 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2314 gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2316 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2319 AC_MSG_CHECKING(what objdump to use)
2320 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2321 # Single tree build which includes binutils.
2322 AC_MSG_RESULT(newly built objdump)
2323 elif test x$gcc_cv_objdump = x; then
2324 AC_MSG_RESULT(not found)
2326 AC_MSG_RESULT($gcc_cv_objdump)
2329 # Figure out what readelf we will be using.
2330 AS_VAR_SET_IF(gcc_cv_readelf,, [
2331 if test -f $gcc_cv_binutils_srcdir/configure.in \
2332 && test -f ../binutils/Makefile \
2333 && test x$build = x$host; then
2334 # Single tree build which includes binutils.
2335 gcc_cv_readelf=../binutils/readelf$build_exeext
2336 elif test -x readelf$build_exeext; then
2337 gcc_cv_readelf=./readelf$build_exeext
2339 AC_PATH_PROG(gcc_cv_readelf, readelf)
2342 AC_MSG_CHECKING(what readelf to use)
2343 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2344 # Single tree build which includes binutils.
2345 AC_MSG_RESULT(newly built readelf)
2346 elif test x$gcc_cv_readelf = x; then
2347 AC_MSG_RESULT(not found)
2349 AC_MSG_RESULT($gcc_cv_readelf)
2352 # Figure out what assembler alignment features are present.
2353 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2357 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2358 [Define if your assembler supports .balign and .p2align.])])
2360 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2363 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2364 [Define if your assembler supports specifying the maximum number
2365 of bytes to skip when using the GAS .p2align command.])])
2367 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2370 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2371 [Define if your assembler supports .literal16.])])
2373 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2375 [conftest_label1: .word 0
2377 conftest_label2: .word 0
2379 [if test x$gcc_cv_nm != x; then
2380 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2381 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2382 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2384 else gcc_cv_as_subsection_m1=yes
2386 rm -f conftest.nm1 conftest.nm2
2388 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2389 [Define if your assembler supports .subsection and .subsection -1 starts
2390 emitting at the beginning of your section.])])
2392 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2395 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2397 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2399 [ .weakref foobar, barfnot],,
2400 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2402 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2405 .NSUBSPA $CODE$,COMDAT],,
2406 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2408 # .hidden needs to be supported in both the assembler and the linker,
2409 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2410 # This is irritatingly difficult to feature test for; we have to check the
2411 # date string after the version number. If we've got an in-tree
2412 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2414 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2415 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2421 # Darwin as has some visibility support, though with a different syntax.
2422 gcc_cv_as_hidden=yes
2426 # gnu_indirect_function type is an extension proposed at
2427 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2428 # selection of function implementation
2429 AC_ARG_ENABLE(gnu-indirect-function,
2430 [AS_HELP_STRING([--enable-gnu-indirect-function],
2431 [enable the use of the @gnu_indirect_function to glibc systems])],
2432 [case $enable_gnu_indirect_function in
2434 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2435 Valid choices are 'yes' and 'no'.]) ;;
2437 [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2439 gif=`if test x$enable_gnu_indirect_function = xyes; then echo 1; else echo 0; fi`
2440 AC_DEFINE_UNQUOTED(HAVE_GNU_INDIRECT_FUNCTION, $gif,
2441 [Define if your system supports gnu indirect functions.])
2445 if test $in_tree_ld != yes ; then
2446 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2447 if echo "$ld_ver" | grep GNU > /dev/null; then
2448 if test x"$ld_is_gold" = xyes; then
2449 # GNU gold --version looks like this:
2451 # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
2453 # We extract the binutils version which is more familiar and specific
2454 # than the gold version.
2455 ld_vers=`echo $ld_ver | sed -n \
2456 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
2458 # GNU ld --version looks like this:
2460 # GNU ld (GNU Binutils) 2.21.51.20110225
2461 ld_vers=`echo $ld_ver | sed -n \
2462 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2464 ld_date=`echo $ld_ver | sed -n 's,^.*\([2-9][0-9][0-9][0-9]\)[-]*\([01][0-9]\)[-]*\([0-3][0-9]\).*$,\1\2\3,p'`
2465 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2466 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2467 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2471 # See acinclude.m4 (gcc_SUN_LD_VERSION) for the version number
2474 # Don't reuse gcc_gv_sun_ld_vers_* in case a linker other than
2475 # /usr/ccs/bin/ld has been configured.
2476 ld_ver=`$gcc_cv_ld -V 2>&1`
2477 if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2478 ld_vers=`echo $ld_ver | sed -n \
2479 -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2480 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2481 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2489 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2490 [[if test $in_tree_ld = yes ; then
2492 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 \
2493 && test $in_tree_ld_is_elf = yes; then
2494 gcc_cv_ld_hidden=yes
2497 gcc_cv_ld_hidden=yes
2498 if test x"$ld_is_gold" = xyes; then
2500 elif echo "$ld_ver" | grep GNU > /dev/null; then
2502 mmix-knuth-mmixware)
2503 # The linker emits by default mmo, not ELF, so "no" is appropriate.
2507 if test 0"$ld_date" -lt 20020404; then
2508 if test -n "$ld_date"; then
2509 # If there was date string, but was earlier than 2002-04-04, fail
2511 elif test -z "$ld_vers"; then
2512 # If there was no date string nor ld version number, something is wrong
2515 test -z "$ld_vers_patch" && ld_vers_patch=0
2516 if test "$ld_vers_major" -lt 2; then
2518 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2519 gcc_cv_ld_hidden="no"
2520 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2528 # Darwin ld has some visibility support.
2529 gcc_cv_ld_hidden=yes
2531 hppa64*-*-hpux* | ia64*-*-hpux*)
2532 gcc_cv_ld_hidden=yes
2534 *-*-solaris2.1[0-9]*)
2535 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2536 # .symbolic was only added in Solaris 9 12/02.
2537 gcc_cv_ld_hidden=yes
2545 libgcc_visibility=no
2546 AC_SUBST(libgcc_visibility)
2547 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2548 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2549 libgcc_visibility=yes
2550 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2551 [Define if your assembler and linker support .hidden.])
2554 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2555 gcc_cv_ld_ro_rw_mix=unknown
2556 if test $in_tree_ld = yes ; then
2557 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 \
2558 && test $in_tree_ld_is_elf = yes; then
2559 gcc_cv_ld_ro_rw_mix=read-write
2561 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2562 echo '.section myfoosect, "a"' > conftest1.s
2563 echo '.section myfoosect, "aw"' > conftest2.s
2564 echo '.byte 1' >> conftest2.s
2565 echo '.section myfoosect, "a"' > conftest3.s
2566 echo '.byte 0' >> conftest3.s
2567 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2568 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2569 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2570 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2571 conftest2.o conftest3.o > /dev/null 2>&1; then
2572 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2573 | sed -e '/myfoosect/!d' -e N`
2574 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2575 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2576 gcc_cv_ld_ro_rw_mix=read-only
2578 gcc_cv_ld_ro_rw_mix=read-write
2583 rm -f conftest.* conftest[123].*
2586 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2587 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2588 [Define if your linker links a mix of read-only
2589 and read-write sections into a read-write section.])
2591 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2593 gcc_AC_INITFINI_ARRAY
2595 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2596 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2604 [[# GAS versions before 2.11 do not support uleb128,
2605 # despite appearing to.
2606 # ??? There exists an elf-specific test that will crash
2607 # the assembler. Perhaps it's better to figure out whether
2608 # arbitrary sections are supported and try the test.
2609 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2610 if echo "$as_ver" | grep GNU > /dev/null; then
2611 as_vers=`echo $as_ver | sed -n \
2612 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2613 as_major=`expr "$as_vers" : '\([0-9]*\)'`
2614 as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2615 if test $as_major -eq 2 && test $as_minor -lt 11
2617 else gcc_cv_as_leb128=yes
2620 [AC_DEFINE(HAVE_AS_LEB128, 1,
2621 [Define if your assembler supports .sleb128 and .uleb128.])])
2623 # Check if we have assembler support for unwind directives.
2624 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2631 .cfi_escape 1, 2, 3, 4, 5
2635 # If the linker used on Solaris (like Sun ld) isn't capable of merging
2636 # read-only and read-write sections, we need to make sure that the
2637 # assembler used emits read-write .eh_frame sections.
2638 if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2639 if test "x$gcc_cv_objdump" != x; then
2640 if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2641 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2642 gcc_cv_as_cfi_directive=no
2645 i?86-*-solaris2.1[[0-9]]* | x86_64-*-solaris2.1[[0-9]]*)
2646 # On Solaris/x86, make sure that GCC and assembler agree on using
2647 # read-only .eh_frame sections for 64-bit.
2648 if test x$gas = xyes; then
2649 as_ix86_64_opt="--64"
2651 as_ix86_64_opt="-xarch=amd64"
2653 if $gcc_cv_as $as_ix86_64_opt -o conftest.o conftest.s > /dev/null 2>&1 && \
2654 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2655 sed -e /.eh_frame/!d -e N | \
2656 grep READONLY > /dev/null; then
2657 gcc_cv_as_cfi_directive=yes
2659 gcc_cv_as_cfi_directive=no
2663 gcc_cv_as_cfi_directive=yes
2668 # no objdump, err on the side of caution
2669 gcc_cv_as_cfi_directive=no
2672 gcc_cv_as_cfi_directive=yes
2676 gcc_cv_as_cfi_directive=yes
2679 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
2680 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2684 .cfi_adjust_cfa_offset 64
2686 .cfi_adjust_cfa_offset 128
2689 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
2690 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then
2691 gcc_cv_as_cfi_advance_working=yes
2695 # no objdump, err on the side of caution
2696 gcc_cv_as_cfi_advance_working=no
2698 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
2699 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2700 [`if test $gcc_cv_as_cfi_directive = yes \
2701 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2702 [Define 0/1 if your assembler supports CFI directives.])
2704 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
2705 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2706 gcc_cv_as_cfi_personality_directive, ,,
2709 .cfi_personality 0, symbol
2711 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2712 [`if test $gcc_cv_as_cfi_personality_directive = yes;
2713 then echo 1; else echo 0; fi`],
2714 [Define 0/1 if your assembler supports .cfi_personality.])
2716 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2717 gcc_cv_as_cfi_sections_directive, ,,
2719 .cfi_sections .debug_frame, .eh_frame
2723 win32 | pe | cygwin* | mingw32* | uwin*)
2724 # Need to check that we generated the correct relocation for the
2725 # .debug_frame section. This was fixed for binutils 2.21.
2726 gcc_cv_as_cfi_sections_directive=no
2727 if test "x$gcc_cv_objdump" != x; then
2728 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
2729 grep secrel > /dev/null; then
2730 gcc_cv_as_cfi_sections_directive=yes
2735 gcc_cv_as_cfi_sections_directive=yes
2738 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
2739 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2740 [`if test $gcc_cv_as_cfi_sections_directive = yes;
2741 then echo 1; else echo 0; fi`],
2742 [Define 0/1 if your assembler supports .cfi_sections.])
2744 # GAS versions up to and including 2.11.0 may mis-optimize
2746 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2754 .section .eh_frame,"aw",@progbits
2756 .4byte .LECIE1-.LSCIE1
2770 .4byte .LEFDE1-.LASFDE1
2772 .4byte .LASFDE1-__FRAME_BEGIN__
2780 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2781 cat > conftest.lit <<EOF
2782 0000 10000000 00000000 017a0001 781a0004 .........z..x...
2783 0010 01000000 12000000 18000000 00000000 ................
2784 0020 08000000 04080000 0044 .........D @&t@
2786 cat > conftest.big <<EOF
2787 0000 00000010 00000000 017a0001 781a0004 .........z..x...
2788 0010 00000001 00000012 00000018 00000000 ................
2789 0020 00000008 04000000 0844 .........D @&t@
2791 # If the assembler didn't choke, and we can objdump,
2792 # and we got the correct data, then succeed.
2793 # The text in the here-document typically retains its unix-style line
2794 # endings, while the output of objdump will use host line endings.
2795 # Therefore, use diff -b for the comparisons.
2796 if test x$gcc_cv_objdump != x \
2797 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2798 | tail -3 > conftest.got \
2799 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2800 || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2802 gcc_cv_as_eh_frame=yes
2803 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2804 gcc_cv_as_eh_frame=buggy
2806 # Uh oh, what do we do now?
2807 gcc_cv_as_eh_frame=no
2810 if test $gcc_cv_as_eh_frame = buggy; then
2811 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2812 [Define if your assembler mis-optimizes .eh_frame data.])
2815 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2816 [elf,2,12,0], [--fatal-warnings],
2817 [.section .rodata.str, "aMS", @progbits, 1])
2818 if test $gcc_cv_as_shf_merge = no; then
2819 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2820 [elf,2,12,0], [--fatal-warnings],
2821 [.section .rodata.str, "aMS", %progbits, 1])
2823 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2824 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2825 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2827 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)],
2828 gcc_cv_as_comdat_group,
2829 [elf,2,16,0], [--fatal-warnings],
2830 [.section .text,"axG",@progbits,.foo,comdat])
2831 if test $gcc_cv_as_comdat_group = yes; then
2832 gcc_cv_as_comdat_group_percent=no
2833 gcc_cv_as_comdat_group_group=no
2835 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
2836 gcc_cv_as_comdat_group_percent,
2837 [elf,2,16,0], [--fatal-warnings],
2838 [.section .text,"axG",%progbits,.foo,comdat])
2839 if test $gcc_cv_as_comdat_group_percent = yes; then
2840 gcc_cv_as_comdat_group_group=no
2843 # Sun as uses a completely different syntax.
2848 .group foo,".text%foo",#comdat
2849 .section ".text%foo", #alloc,#execinstr,#progbits
2854 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2856 .group foo,.text%foo,#comdat
2857 .section .text%foo, "ax", @progbits
2863 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
2864 gcc_cv_as_comdat_group_group,
2868 if test -z "${gcc_cv_as_comdat_group_group+set}"; then
2869 gcc_cv_as_comdat_group_group=no
2873 if test x"$ld_is_gold" = xyes; then
2875 elif test $in_tree_ld = yes ; then
2877 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 \
2878 && test $in_tree_ld_is_elf = yes; then
2881 elif echo "$ld_ver" | grep GNU > /dev/null; then
2883 if test 0"$ld_date" -lt 20050308; then
2884 if test -n "$ld_date"; then
2885 # If there was date string, but was earlier than 2005-03-08, fail
2887 elif test "$ld_vers_major" -lt 2; then
2889 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2896 *-*-solaris2.1[1-9]*)
2898 # Sun ld has COMDAT group support since Solaris 9, but it doesn't
2899 # interoperate with GNU as until Solaris 11 build 130, i.e. ld
2902 # If using Sun as for COMDAT group as emitted by GCC, one needs at
2903 # least ld version 1.2267.
2904 if test "$ld_vers_major" -gt 1; then
2906 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
2908 elif test "$ld_vers_minor" -ge 2267; then
2913 # Assume linkers other than GNU ld don't support COMDAT group.
2919 # Allow overriding the automatic COMDAT group tests above.
2920 AC_ARG_ENABLE(comdat,
2921 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
2922 [comdat_group="$enable_comdat"])
2923 if test $comdat_group = no; then
2924 gcc_cv_as_comdat_group=no
2925 gcc_cv_as_comdat_group_percent=no
2926 gcc_cv_as_comdat_group_group=no
2928 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2929 [`if test $gcc_cv_as_comdat_group = yes \
2930 || test $gcc_cv_as_comdat_group_percent = yes \
2931 || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`],
2932 [Define 0/1 if your assembler and linker support COMDAT groups.])
2934 gcc_GAS_CHECK_FEATURE([line table discriminator support],
2935 gcc_cv_as_discriminator,
2939 .loc 1 1 0 discriminator 1],,
2940 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
2941 [Define if your assembler supports the .loc discriminator sub-directive.])])
2943 # Thread-local storage - the check is heavily parameterized.
2952 .section ".tdata","awT",@progbits
2955 ldq $27,__tls_get_addr($29) !literal!1
2956 lda $16,foo($29) !tlsgd!1
2957 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
2958 ldq $27,__tls_get_addr($29) !literal!2
2959 lda $16,foo($29) !tlsldm!2
2960 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
2961 ldq $1,foo($29) !gotdtprel
2962 ldah $2,foo($29) !dtprelhi
2963 lda $3,foo($2) !dtprello
2964 lda $4,foo($29) !dtprel
2965 ldq $1,foo($29) !gottprel
2966 ldah $2,foo($29) !tprelhi
2967 lda $3,foo($2) !tprello
2968 lda $4,foo($29) !tprel'
2971 tls_as_opt=--fatal-warnings
2973 cris-*-*|crisv32-*-*)
2975 .section ".tdata","awT",@progbits
2982 tls_as_opt=--fatal-warnings
2986 .section ".tdata","awT",@progbits
2998 .section ".tdata","awT",@progbits
3002 addil LT%foo-$tls_gdidx$,gp
3003 ldo RT%foo-$tls_gdidx$(%r1),%arg0
3006 addil LT%foo-$tls_ldidx$,gp
3008 ldo RT%foo-$tls_ldidx$(%r1),%arg0
3009 addil LR%foo-$tls_dtpoff$,%ret0
3010 ldo RR%foo-$tls_dtpoff$(%r1),%t1
3012 addil LT%foo-$tls_ieoff$,gp
3013 ldw RT%foo-$tls_ieoff$(%r1),%t2
3016 addil LR%foo-$tls_leoff$,%t1
3017 ldo RR%foo-$tls_leoff$(%r1),%t2'
3020 tls_as_opt=--fatal-warnings
3024 .section ".tdata","awT",%progbits
3035 i[34567]86-*-* | x86_64-*-*)
3037 i[34567]86-*-solaris2.* | x86_64-*-solaris2.1[0-9]*)
3044 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3046 .section .tdata,"awt",@progbits'
3051 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
3052 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
3056 .section ".tdata","awT",@progbits'
3060 tls_as_opt="--fatal-warnings"
3064 conftest_s="$conftest_s
3068 leal foo@tlsgd(,%ebx,1), %eax
3069 leal foo@tlsldm(%ebx), %eax
3070 leal foo@dtpoff(%eax), %edx
3071 movl foo@gottpoff(%ebx), %eax
3072 subl foo@gottpoff(%ebx), %eax
3073 addl foo@gotntpoff(%ebx), %eax
3074 movl foo@indntpoff, %eax
3075 movl \$foo@tpoff, %eax
3076 subl \$foo@tpoff, %eax
3077 leal foo@ntpoff(%ecx), %eax"
3080 if test x$on_solaris = xyes; then
3082 yes) tls_as_opt="$tls_as_opt --64" ;;
3083 no) tls_as_opt="$tls_as_opt -xarch=amd64" ;;
3086 conftest_s="$conftest_s
3090 leaq foo@tlsgd(%rip), %rdi
3091 leaq foo@tlsld(%rip), %rdi
3092 leaq foo@dtpoff(%rax), %rdx
3093 movq foo@gottpoff(%rip), %rax
3094 movq \$foo@tpoff, %rax"
3100 .section ".tdata","awT",@progbits
3103 addl r16 = @ltoff(@dtpmod(foo#)), gp
3104 addl r17 = @ltoff(@dtprel(foo#)), gp
3105 addl r18 = @ltoff(@tprel(foo#)), gp
3106 addl r19 = @dtprel(foo#), gp
3107 adds r21 = @dtprel(foo#), r13
3108 movl r23 = @dtprel(foo#)
3109 addl r20 = @tprel(foo#), gp
3110 adds r22 = @tprel(foo#), r13
3111 movl r24 = @tprel(foo#)'
3114 tls_as_opt=--fatal-warnings
3118 .section .tdata,"awT",@progbits
3122 addik r5,r20,x@TLSGD
3123 addik r5,r20,x@TLSLDM'
3126 tls_as_opt='--fatal-warnings'
3130 .section .tdata,"awT",@progbits
3134 addiu $4, $28, %tlsgd(x)
3135 addiu $4, $28, %tlsldm(x)
3136 lui $4, %dtprel_hi(x)
3137 addiu $4, $4, %dtprel_lo(x)
3138 lw $4, %gottprel(x)($28)
3139 lui $4, %tprel_hi(x)
3140 addiu $4, $4, %tprel_lo(x)'
3143 tls_as_opt='-32 --fatal-warnings'
3147 .section .tdata,"awT",@progbits
3152 move.l x@TLSGD(%a5),%a0
3153 move.l x@TLSLDM(%a5),%a0
3154 move.l x@TLSLDO(%a5),%a0
3155 move.l x@TLSIE(%a5),%a0
3156 move.l x@TLSLE(%a5),%a0'
3159 tls_as_opt='--fatal-warnings'
3163 .section ".tdata","awT",@progbits'
3166 tls_as_opt="--fatal-warnings"
3170 .section ".tdata","awT",%progbits
3174 add x0, x0, #:tlsgd_lo12:x
3179 tls_as_opt='--fatal-warnings'
3183 .extern __get_tpointer
3201 .section ".tdata","awT",@progbits
3209 addi 3,2,ld0@got@tlsgd
3215 addi 3,2,x1@got@tlsld
3221 addis 9,3,x2@dtprel@ha
3222 addi 9,9,x2@dtprel@l
3225 ld 9,x3@got@dtprel(2)
3231 tls_as_opt="-a64 --fatal-warnings"
3235 .section ".tdata","awT",@progbits
3243 addi 3,31,ld0@got@tlsgd
3245 addi 3,31,x1@got@tlsld
3248 addis 9,3,x2@dtprel@ha
3249 addi 9,9,x2@dtprel@l
3250 lwz 9,x3@got@tprel(31)
3253 addis 9,2,x2@tprel@ha
3254 addi 9,9,x2@tprel@l'
3257 tls_as_opt="-a32 --fatal-warnings"
3261 .section ".tdata","awT",@progbits
3270 l %r1,foo@GOTNTPOFF(%r12)
3271 l %r1,0(%r1):tls_load:foo
3272 bas %r14,0(%r1,%r13):tls_gdcall:foo
3273 bas %r14,0(%r1,%r13):tls_ldcall:foo'
3276 tls_as_opt="-m31 --fatal-warnings"
3280 .section ".tdata","awT",@progbits
3288 lg %r1,foo@GOTNTPOFF(%r12)
3289 larl %r1,foo@INDNTPOFF
3290 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
3291 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
3294 tls_as_opt="-m64 -Aesame --fatal-warnings"
3296 sh-*-* | sh[34]-*-*)
3298 .section ".tdata","awT",@progbits
3308 tls_as_opt=--fatal-warnings
3312 sparc*-sun-solaris2.*)
3319 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3321 .section ".tdata",#alloc,#write,#tls'
3326 .section ".tdata","awT",@progbits'
3329 tls_as_opt="-32 --fatal-warnings"
3331 conftest_s="$conftest_s
3334 sethi %tgd_hi22(foo), %o0
3335 add %o0, %tgd_lo10(foo), %o1
3336 add %l7, %o1, %o0, %tgd_add(foo)
3337 call __tls_get_addr, %tgd_call(foo)
3338 sethi %tldm_hi22(foo), %l1
3339 add %l1, %tldm_lo10(foo), %l2
3340 add %l7, %l2, %o0, %tldm_add(foo)
3341 call __tls_get_addr, %tldm_call(foo)
3342 sethi %tldo_hix22(foo), %l3
3343 xor %l3, %tldo_lox10(foo), %l4
3344 add %o0, %l4, %l5, %tldo_add(foo)
3345 sethi %tie_hi22(foo), %o3
3346 add %o3, %tie_lo10(foo), %o3
3347 ld [%l7 + %o3], %o2, %tie_ld(foo)
3348 add %g7, %o2, %o4, %tie_add(foo)
3349 sethi %tle_hix22(foo), %l1
3350 xor %l1, %tle_lox10(foo), %o5
3351 ld [%g7 + %o5], %o1"
3355 .section ".tdata","awT",@progbits
3358 addli r0, zero, tls_gd(foo)
3359 auli r0, zero, tls_gd_ha16(foo)
3360 addli r0, r0, tls_gd_lo16(foo)
3362 addli r0, zero, tls_ie(foo)
3363 auli r0, r0, tls_ie_ha16(foo)
3364 addli r0, r0, tls_ie_lo16(foo)'
3367 tls_as_opt="--fatal-warnings"
3371 .section ".tdata","awT",@progbits
3374 shl16insli r0, zero, hw0_last_tls_gd(foo)
3375 shl16insli r0, zero, hw1_last_tls_gd(foo)
3376 shl16insli r0, r0, hw0_tls_gd(foo)
3378 shl16insli r0, zero, hw1_last_tls_ie(foo)
3379 shl16insli r0, r0, hw0_tls_ie(foo)'
3382 tls_as_opt="--fatal-warnings"
3386 .section ".tdata","awT",@progbits
3389 movi a8, foo@TLSFUNC
3390 movi a10, foo@TLSARG
3391 callx8.tls a8, foo@TLSCALL'
3398 if test "x$enable_tls" = xno ; then
3399 : # TLS explicitly disabled.
3400 elif test "x$enable_tls" = xyes ; then
3401 set_have_as_tls=yes # TLS explicitly enabled.
3402 elif test -z "$tls_first_major"; then
3403 : # If we don't have a check, assume no support.
3405 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
3406 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
3407 [set_have_as_tls=yes])
3409 if test $set_have_as_tls = yes ; then
3410 AC_DEFINE(HAVE_AS_TLS, 1,
3411 [Define if your assembler and linker support thread-local storage.])
3414 # Target-specific assembler checks.
3416 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3417 gcc_cv_ld_static_dynamic=no
3418 gcc_cv_ld_static_option='-Bstatic'
3419 gcc_cv_ld_dynamic_option='-Bdynamic'
3420 if test $in_tree_ld = yes ; then
3421 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
3422 gcc_cv_ld_static_dynamic=yes
3424 elif test x$gcc_cv_ld != x; then
3425 # Check if linker supports -Bstatic/-Bdynamic option
3426 if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
3427 && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
3428 gcc_cv_ld_static_dynamic=yes
3431 # AIX ld uses -b flags
3432 *-*-aix4.[[23]]* | *-*-aix[[5-9]]*)
3433 gcc_cv_ld_static_dynamic=yes
3434 gcc_cv_ld_static_option="-bstatic"
3435 gcc_cv_ld_dynamic_option="-bdynamic"
3437 # HP-UX ld uses -a flags to select between shared and archive.
3439 if test x"$gnu_ld" = xno; then
3440 gcc_cv_ld_static_dynamic=yes
3441 gcc_cv_ld_static_option="-aarchive_shared"
3442 gcc_cv_ld_dynamic_option="-adefault"
3445 # Solaris 2 ld always supports -Bstatic/-Bdynamic.
3447 gcc_cv_ld_static_dynamic=yes
3452 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3453 AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3454 [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.])
3455 AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option",
3456 [Define to the linker option to disable use of shared objects.])
3457 AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option",
3458 [Define to the linker option to enable use of shared objects.])
3460 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3462 if test x"$demangler_in_ld" = xyes; then
3463 AC_MSG_CHECKING(linker --demangle support)
3464 gcc_cv_ld_demangle=no
3465 if test $in_tree_ld = yes; then
3466 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 \
3467 gcc_cv_ld_demangle=yes
3469 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3470 # Check if the GNU linker supports --demangle option
3471 if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3472 gcc_cv_ld_demangle=yes
3475 if test x"$gcc_cv_ld_demangle" = xyes; then
3476 AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3477 [Define if your linker supports --demangle option.])
3479 AC_MSG_RESULT($gcc_cv_ld_demangle)
3482 AC_MSG_CHECKING(linker plugin support)
3484 if test -f liblto_plugin.la; then
3485 save_ld_ver="$ld_ver"
3486 save_ld_vers_major="$ld_vers_major"
3487 save_ld_vers_minor="$ld_vers_minor"
3488 save_ld_is_gold="$ld_is_gold"
3492 if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
3494 # FIXME: ld_is_gold?
3495 ld_vers_major="$gcc_cv_gld_major_version"
3496 ld_vers_minor="$gcc_cv_gld_minor_version"
3498 # Determine plugin linker version.
3499 # FIXME: Partial duplicate from above, generalize.
3501 ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q`
3502 if echo "$ld_ver" | grep GNU > /dev/null; then
3503 if echo "$ld_ver" | grep "GNU gold" > /dev/null; then
3505 ld_vers=`echo $ld_ver | sed -n \
3506 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
3508 ld_vers=`echo $ld_ver | sed -n \
3509 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
3511 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
3512 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
3517 # Determine plugin support.
3518 if echo "$ld_ver" | grep GNU > /dev/null; then
3519 # Require GNU ld or gold 2.21+ for plugin support by default.
3520 if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then
3522 # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20.
3523 elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then
3528 ld_ver="$save_ld_ver"
3529 ld_vers_major="$save_ld_vers_major"
3530 ld_vers_minor="$save_ld_vers_minor"
3531 ld_is_gold="$save_ld_is_gold"
3533 AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin,
3534 [Define to the level of your linker's plugin support.])
3535 AC_MSG_RESULT($gcc_cv_lto_plugin)
3539 gcc_GAS_CHECK_FEATURE([-mabi option], gcc_cv_as_aarch64_mabi,,
3540 [-mabi=lp64], [.text],,,)
3541 if test x$gcc_cv_as_aarch64_mabi = xyes; then
3542 AC_DEFINE(HAVE_AS_MABI_OPTION, 1,
3543 [Define if your assembler supports the -mabi option.])
3545 if test x$with_abi = xilp32; then
3546 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3547 Upgrade the Assembler.])
3549 if test x"$with_multilib_list" = xdefault; then
3550 TM_MULTILIB_CONFIG=lp64
3552 aarch64_multilibs=`echo $with_multilib_list | sed -e 's/,/ /g'`
3553 for aarch64_multilib in ${aarch64_multilibs}; do
3554 case ${aarch64_multilib} in
3556 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3557 Upgrade the Assembler.])
3565 # Enable default workaround for AArch64 Cortex-A53 erratum 835769.
3566 AC_ARG_ENABLE(fix-cortex-a53-835769,
3568 AS_HELP_STRING([--enable-fix-cortex-a53-835769],
3569 [enable workaround for AArch64 Cortex-A53 erratum 835769 by default])
3570 AS_HELP_STRING([--disable-fix-cortex-a53-835769],
3571 [disable workaround for AArch64 Cortex-A53 erratum 835769 by default])
3576 tm_defines="${tm_defines} TARGET_FIX_ERR_A53_835769_DEFAULT=1"
3581 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-835769.\
3582 Valid choices are 'yes' and 'no'.])
3588 # Enable default workaround for AArch64 Cortex-A53 erratum 843419.
3589 AC_ARG_ENABLE(fix-cortex-a53-843419,
3591 AS_HELP_STRING([--enable-fix-cortex-a53-843419],
3592 [enable workaround for AArch64 Cortex-A53 erratum 843419 by default])
3593 AS_HELP_STRING([--disable-fix-cortex-a53-843419],
3594 [disable workaround for AArch64 Cortex-A53 erratum 843419 by default])
3599 tm_defines="${tm_defines} TARGET_FIX_ERR_A53_843419_DEFAULT=1"
3604 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-843419.\
3605 Valid choices are 'yes' and 'no'.])
3613 # All TARGET_ABI_OSF targets.
3614 alpha*-*-linux* | alpha*-*-*bsd*)
3615 gcc_GAS_CHECK_FEATURE([explicit relocation support],
3616 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3619 extbl $3, $2, $3 !lituse_bytoff!1
3620 ldq $2, a($29) !literal!1
3621 ldq $4, b($29) !literal!2
3622 ldq_u $3, 0($2) !lituse_base!1
3623 ldq $27, f($29) !literal!5
3624 jsr $26, ($27), f !lituse_jsr!5
3625 ldah $29, 0($26) !gpdisp!3
3626 lda $0, c($29) !gprel
3627 ldah $1, d($29) !gprelhigh
3628 lda $1, d($1) !gprellow
3629 lda $29, 0($29) !gpdisp!3],,
3630 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3631 [Define if your assembler supports explicit relocations.])])
3632 gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3633 gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3636 ldq $27, a($29) !literal!1
3637 jsr $26, ($27), a !lituse_jsrdirect!1],,
3638 [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3639 [Define if your assembler supports the lituse_jsrdirect relocation.])])
3643 gcc_GAS_CHECK_FEATURE([--mlink-relax option], gcc_cv_as_avr_mlink_relax,,
3644 [--mlink-relax], [.text],,
3645 [AC_DEFINE(HAVE_AS_AVR_MLINK_RELAX_OPTION, 1,
3646 [Define if your avr assembler supports --mlink-relax option.])])
3648 gcc_GAS_CHECK_FEATURE([-mrmw option], gcc_cv_as_avr_mrmw,,
3650 [AC_DEFINE(HAVE_AS_AVR_MRMW_OPTION, 1,
3651 [Define if your avr assembler supports -mrmw option.])])
3655 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3656 gcc_cv_as_cris_no_mul_bug,[2,15,91],
3657 [-no-mul-bug-abort], [.text],,
3658 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3659 [Define if your assembler supports the -no-mul-bug-abort option.])])
3663 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3664 [.register %g2, #scratch],,
3665 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3666 [Define if your assembler supports .register.])])
3668 gcc_GAS_CHECK_FEATURE([@%:@nobits], gcc_cv_as_sparc_nobits,,,
3669 [.section "nobits",#alloc,#write,#nobits
3670 .section "progbits",#alloc,#write,#progbits])
3671 AC_DEFINE_UNQUOTED(HAVE_AS_SPARC_NOBITS,
3672 [`if test $gcc_cv_as_sparc_nobits = yes; then echo 1; else echo 0; fi`],
3673 [Define to 1 if your assembler supports #nobits, 0 otherwise.])
3675 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3677 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3678 [Define if your assembler supports -relax option.])])
3680 gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3681 gcc_cv_as_sparc_gotdata_op,,
3688 sethi %gdop_hix22(foo), %g1
3689 xor %g1, %gdop_lox10(foo), %g1
3690 ld [[%l7 + %g1]], %g2, %gdop(foo)],
3691 [if test x$gcc_cv_ld != x \
3692 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3693 if test x$gcc_cv_objdump != x; then
3694 if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3695 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3696 gcc_cv_as_sparc_gotdata_op=no
3698 gcc_cv_as_sparc_gotdata_op=yes
3703 [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3704 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3706 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3707 gcc_cv_as_sparc_ua_pcrel,,
3715 .uaword %r_disp32(foo)],
3716 [if test x$gcc_cv_ld != x \
3717 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3718 gcc_cv_as_sparc_ua_pcrel=yes
3721 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3722 [Define if your assembler and linker support unaligned PC relative relocs.])
3724 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3725 gcc_cv_as_sparc_ua_pcrel_hidden,,
3730 .uaword %r_disp32(foo)
3731 .byte 0x32, 0x33, 0x34
3736 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3737 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3738 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3739 | grep ' 31000000 07323334' > /dev/null 2>&1; then
3740 if $gcc_cv_objdump -R conftest 2> /dev/null \
3741 | grep 'DISP32' > /dev/null 2>&1; then
3744 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3748 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3749 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3750 ]) # unaligned pcrel relocs
3752 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3753 gcc_cv_as_sparc_offsetable_lo10,,
3756 or %g1, %lo(ab) + 12, %g1
3757 or %g1, %lo(ab + 12), %g1],
3758 [if test x$gcc_cv_objdump != x \
3759 && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3760 | grep ' 82106000 82106000' > /dev/null 2>&1; then
3761 gcc_cv_as_sparc_offsetable_lo10=yes
3763 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3764 [Define if your assembler supports offsetable %lo().])])
3766 gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions],
3767 gcc_cv_as_sparc_fmaf,,
3770 .register %g2, #scratch
3771 .register %g3, #scratch
3773 fmaddd %f0, %f2, %f4, %f6
3774 addxccc %g1, %g2, %g3
3775 fsrl32 %f2, %f4, %f8
3776 fnaddd %f10, %f12, %f14],,
3777 [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1,
3778 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])])
3780 gcc_GAS_CHECK_FEATURE([SPARC4 instructions],
3781 gcc_cv_as_sparc_sparc4,,
3784 .register %g2, #scratch
3785 .register %g3, #scratch
3788 1: cwbneg %g2, %g3, 1f
3791 aes_kexpand0 %f4, %f6, %f8
3792 des_round %f38, %f40, %f42, %f44
3793 camellia_f %f54, %f56, %f58, %f60
3794 kasumi_fi_xor %f46, %f48, %f50, %f52],,
3795 [AC_DEFINE(HAVE_AS_SPARC4, 1,
3796 [Define if your assembler supports SPARC4 instructions.])])
3798 gcc_GAS_CHECK_FEATURE([LEON instructions],
3799 gcc_cv_as_sparc_leon,,
3802 .register %g2, #scratch
3803 .register %g3, #scratch
3807 casa [[%g2]] 0xb, %g3, %g1],,
3808 [AC_DEFINE(HAVE_AS_LEON, 1,
3809 [Define if your assembler supports LEON instructions.])])
3813 i[34567]86-*-* | x86_64-*-*)
3817 # Full C++ conformance when using a shared libstdc++-v3 requires some
3818 # support from the Cygwin DLL, which in more recent versions exports
3819 # wrappers to aid in interposing and redirecting operators new, delete,
3820 # etc., as per n2800 #17.6.4.6 [replacement.functions]. Check if we
3821 # are configuring for a version of Cygwin that exports the wrappers.
3822 if test x$host = x$target && test x$host_cpu = xi686; then
3823 AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3825 # Can't check presence of libc functions during cross-compile, so
3826 # we just have to assume we're building for an up-to-date target.
3827 gcc_ac_cygwin_dll_wrappers=yes
3829 AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3830 [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3831 [Define if you want to generate code by default that assumes that the
3832 Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3835 cygwin* | pe | mingw32* | interix*)
3836 # Recent binutils allows the three-operand form of ".comm" on PE. This
3837 # definition is used unconditionally to initialise the default state of
3838 # the target option variable that governs usage of the feature.
3839 gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3840 [2,19,52],,[.comm foo,1,32])
3841 AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3842 [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3843 [Define if your assembler supports specifying the alignment
3844 of objects allocated using the GAS .comm command.])
3845 # Used for DWARF 2 in PE
3846 gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3847 gcc_cv_as_ix86_pe_secrel32,
3853 [if test x$gcc_cv_ld != x \
3854 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3855 gcc_cv_as_ix86_pe_secrel32=yes
3858 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3859 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3860 # Test if the assembler supports the extended form of the .section
3861 # directive that specifies section alignment. LTO support uses this,
3862 # but normally only after installation, so we warn but don't fail the
3863 # configure if LTO is enabled but the assembler does not support it.
3864 gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3865 [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3866 if test x$gcc_cv_as_section_has_align != xyes; then
3867 case ",$enable_languages," in
3869 AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3876 # Test if the assembler supports the section flag 'e' for specifying
3877 # an excluded section.
3878 gcc_GAS_CHECK_FEATURE([.section with e], gcc_cv_as_section_has_e,
3879 [2,22,51], [--fatal-warnings],
3882 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3883 [`if test $gcc_cv_as_section_has_e = yes; then echo 1; else echo 0; fi`],
3884 [Define if your assembler supports specifying the section flag e.])
3886 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3887 gcc_cv_as_ix86_filds,,,
3888 [filds (%ebp); fists (%ebp)],,
3889 [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3890 [Define if your assembler uses filds and fists mnemonics.])])
3892 gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3893 gcc_cv_as_ix86_fildq,,,
3894 [fildq (%ebp); fistpq (%ebp)],,
3895 [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3896 [Define if your assembler uses fildq and fistq mnemonics.])])
3898 gcc_GAS_CHECK_FEATURE([cmov syntax],
3899 gcc_cv_as_ix86_cmov_sun_syntax,,,
3900 [cmovl.l %edx, %eax],,
3901 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3902 [Define if your assembler supports the Sun syntax for cmov.])])
3904 gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3905 gcc_cv_as_ix86_ffreep,,,
3907 [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3908 [Define if your assembler supports the ffreep mnemonic.])])
3910 gcc_GAS_CHECK_FEATURE([.quad directive],
3911 gcc_cv_as_ix86_quad,,,
3913 [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
3914 [Define if your assembler supports the .quad directive.])])
3916 gcc_GAS_CHECK_FEATURE([sahf mnemonic],
3917 gcc_cv_as_ix86_sahf,,,
3920 [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
3921 [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
3923 gcc_GAS_CHECK_FEATURE([interunit movq mnemonic],
3924 gcc_cv_as_ix86_interunit_movq,,,
3928 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_INTERUNIT_MOVQ,
3929 [`if test $gcc_cv_as_ix86_interunit_movq = yes; then echo 1; else echo 0; fi`],
3930 [Define if your assembler supports interunit movq mnemonic.])
3932 gcc_GAS_CHECK_FEATURE([hle prefixes],
3933 gcc_cv_as_ix86_hle,,,
3934 [lock xacquire cmpxchg %esi, (%ecx)],,
3935 [AC_DEFINE(HAVE_AS_IX86_HLE, 1,
3936 [Define if your assembler supports HLE prefixes.])])
3938 gcc_GAS_CHECK_FEATURE([swap suffix],
3939 gcc_cv_as_ix86_swap,,,
3940 [movl.s %esp, %ebp],,
3941 [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
3942 [Define if your assembler supports the swap suffix.])])
3944 gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
3945 gcc_cv_as_ix86_diff_sect_delta,,,
3953 [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
3954 [Define if your assembler supports the subtraction of symbols in different sections.])])
3956 # These two are used unconditionally by i386.[ch]; it is to be defined
3957 # to 1 if the feature is present, 0 otherwise.
3958 as_ix86_gotoff_in_data_opt=
3959 if test x$gas = xyes; then
3960 as_ix86_gotoff_in_data_opt="--32"
3962 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
3963 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],
3964 [$as_ix86_gotoff_in_data_opt],
3970 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
3971 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
3972 [Define true if the assembler supports '.long foo@GOTOFF'.])
3974 gcc_GAS_CHECK_FEATURE([rep and lock prefix],
3975 gcc_cv_as_ix86_rep_lock_prefix,,,
3981 lock addl %edi, (%eax,%esi)
3982 lock orl $0, (%esp)],,
3983 [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
3984 [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
3986 gcc_GAS_CHECK_FEATURE([ud2 mnemonic],
3987 gcc_cv_as_ix86_ud2,,,
3989 [AC_DEFINE(HAVE_AS_IX86_UD2, 1,
3990 [Define if your assembler supports the 'ud2' mnemonic.])])
3992 gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
3993 gcc_cv_as_ix86_tlsgdplt,,,
3994 [call tls_gd@tlsgdplt],
3995 [if test x$gcc_cv_ld != x \
3996 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3997 gcc_cv_as_ix86_tlsgdplt=yes
4000 [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
4001 [Define if your assembler and linker support @tlsgdplt.])])
4004 .section .tdata,"aw'$tls_section_flag'",@progbits
4006 .section .text,"ax",@progbits
4007 call tls_ld@tlsldmplt'
4008 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
4009 gcc_cv_as_ix86_tlsldmplt,,,
4011 [if test x$gcc_cv_ld != x \
4012 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
4013 gcc_cv_as_ix86_tlsldmplt=yes
4016 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDMPLT,
4017 [`if test $gcc_cv_as_ix86_tlsldmplt = yes; then echo 1; else echo 0; fi`],
4018 [Define to 1 if your assembler and linker support @tlsldmplt.])
4020 # Enforce 32-bit output with gas and gld.
4021 if test x$gas = xyes; then
4022 as_ix86_tls_ldm_opt="--32"
4024 if echo "$ld_ver" | grep GNU > /dev/null; then
4025 if $gcc_cv_ld -V 2>/dev/null | grep elf_i386_sol2 > /dev/null; then
4026 ld_ix86_tls_ldm_opt="-melf_i386_sol2"
4028 ld_ix86_tls_ldm_opt="-melf_i386"
4032 .section .text,"ax",@progbits
4034 .type _start, @function
4036 leal value@tlsldm(%ebx), %eax
4037 call ___tls_get_addr@plt
4039 .section .tdata,"aw'$tls_section_flag'",@progbits
4040 .type value, @object
4042 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM reloc],
4043 gcc_cv_as_ix86_tlsldm,,
4044 [$as_ix86_tls_ldm_opt],
4046 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
4047 && $gcc_cv_ld $ld_ix86_tls_ldm_opt -o conftest conftest.o $ld_tls_libs -lc > /dev/null 2>&1; then
4048 if $gcc_cv_objdump -d conftest 2>/dev/null | grep nop > /dev/null \
4049 || dis conftest 2>/dev/null | grep nop > /dev/null; then
4050 gcc_cv_as_ix86_tlsldm=yes
4054 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDM,
4055 [`if test $gcc_cv_as_ix86_tlsldm = yes; then echo 1; else echo 0; fi`],
4056 [Define to 1 if your assembler and linker support @tlsldm.])
4061 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
4062 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
4064 addl r15 = @ltoffx(x#), gp
4066 ld8.mov r16 = [[r15]], x#],,
4067 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
4068 [Define if your assembler supports ltoffx and ldxmov relocations.])])
4074 *-*-aix*) conftest_s=' .machine "pwr5"
4078 gcc_GAS_CHECK_FEATURE([.machine directive support],
4079 gcc_cv_as_machine_directive,,,
4080 [ .machine ppc7400])
4081 if test x$gcc_cv_as_machine_directive != xyes; then
4082 echo "*** This target requires an assembler supporting \".machine\"" >&2
4083 echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
4084 test x$build = x$target && exit 1
4088 *) conftest_s=' .machine power4
4093 gcc_GAS_CHECK_FEATURE([mfcr field support],
4094 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
4096 [AC_DEFINE(HAVE_AS_MFCRF, 1,
4097 [Define if your assembler supports mfcr field.])])
4100 *-*-aix*) conftest_s=' .machine "pwr5"
4103 *) conftest_s=' .machine power5
4108 gcc_GAS_CHECK_FEATURE([popcntb support],
4109 gcc_cv_as_powerpc_popcntb, [2,17,0],,
4111 [AC_DEFINE(HAVE_AS_POPCNTB, 1,
4112 [Define if your assembler supports popcntb field.])])
4115 *-*-aix*) conftest_s=' .machine "pwr5x"
4118 *) conftest_s=' .machine power5
4123 gcc_GAS_CHECK_FEATURE([fp round support],
4124 gcc_cv_as_powerpc_fprnd, [2,17,0],,
4126 [AC_DEFINE(HAVE_AS_FPRND, 1,
4127 [Define if your assembler supports fprnd.])])
4130 *-*-aix*) conftest_s=' .machine "pwr6"
4133 *) conftest_s=' .machine power6
4138 gcc_GAS_CHECK_FEATURE([move fp gpr support],
4139 gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
4141 [AC_DEFINE(HAVE_AS_MFPGPR, 1,
4142 [Define if your assembler supports mffgpr and mftgpr.])])
4145 *-*-aix*) conftest_s=' .csect .text[[PR]]
4147 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
4151 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
4152 *) conftest_s=' .text
4154 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
4157 gcc_GAS_CHECK_FEATURE([rel16 relocs],
4158 gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
4160 [AC_DEFINE(HAVE_AS_REL16, 1,
4161 [Define if your assembler supports R_PPC_REL16 relocs.])])
4164 *-*-aix*) conftest_s=' .machine "pwr6"
4167 *) conftest_s=' .machine power6
4172 gcc_GAS_CHECK_FEATURE([compare bytes support],
4173 gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
4175 [AC_DEFINE(HAVE_AS_CMPB, 1,
4176 [Define if your assembler supports cmpb.])])
4179 *-*-aix*) conftest_s=' .machine "pwr6"
4182 *) conftest_s=' .machine power6
4187 gcc_GAS_CHECK_FEATURE([decimal float support],
4188 gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
4190 [AC_DEFINE(HAVE_AS_DFP, 1,
4191 [Define if your assembler supports DFP instructions.])])
4194 *-*-aix*) conftest_s=' .machine "pwr7"
4197 *) conftest_s=' .machine power7
4202 gcc_GAS_CHECK_FEATURE([vector-scalar support],
4203 gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
4205 [AC_DEFINE(HAVE_AS_VSX, 1,
4206 [Define if your assembler supports VSX instructions.])])
4209 *-*-aix*) conftest_s=' .machine "pwr7"
4212 *) conftest_s=' .machine power7
4217 gcc_GAS_CHECK_FEATURE([popcntd support],
4218 gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
4220 [AC_DEFINE(HAVE_AS_POPCNTD, 1,
4221 [Define if your assembler supports POPCNTD instructions.])])
4224 *-*-aix*) conftest_s=' .machine "pwr8"
4225 .csect .text[[PR]]';;
4226 *) conftest_s=' .machine power8
4230 gcc_GAS_CHECK_FEATURE([power8 support],
4231 gcc_cv_as_powerpc_power8, [2,19,2], -a32,
4233 [AC_DEFINE(HAVE_AS_POWER8, 1,
4234 [Define if your assembler supports POWER8 instructions.])])
4237 *-*-aix*) conftest_s=' .csect .text[[PR]]
4239 *) conftest_s=' .text
4243 gcc_GAS_CHECK_FEATURE([lwsync support],
4244 gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
4246 [AC_DEFINE(HAVE_AS_LWSYNC, 1,
4247 [Define if your assembler supports LWSYNC instructions.])])
4250 *-*-aix*) conftest_s=' .machine "476"
4253 *) conftest_s=' .machine "476"
4258 gcc_GAS_CHECK_FEATURE([data cache invalidate support],
4259 gcc_cv_as_powerpc_dci, [9,99,0], -a32,
4261 [AC_DEFINE(HAVE_AS_DCI, 1,
4262 [Define if your assembler supports the DCI/ICI instructions.])])
4264 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4265 gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
4266 [.gnu_attribute 4,1],,
4267 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4268 [Define if your assembler supports .gnu_attribute.])])
4270 gcc_GAS_CHECK_FEATURE([tls marker support],
4271 gcc_cv_as_powerpc_tls_markers, [2,20,0],,
4272 [ bl __tls_get_addr(x@tlsgd)],,
4273 [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
4274 [Define if your assembler supports arg info for __tls_get_addr.])])
4278 gcc_GAS_CHECK_FEATURE([.ref support],
4279 gcc_cv_as_aix_ref, [2,21,0],,
4280 [ .csect stuff[[rw]]
4286 [AC_DEFINE(HAVE_AS_REF, 1,
4287 [Define if your assembler supports .ref])])
4293 gcc_GAS_CHECK_FEATURE([explicit relocation support],
4294 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
4295 [ lw $4,%gp_rel(foo)($4)],,
4296 [if test x$target_cpu_default = x
4297 then target_cpu_default=MASK_EXPLICIT_RELOCS
4298 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
4300 gcc_GAS_CHECK_FEATURE([-mno-shared support],
4301 gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
4302 [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
4303 [Define if the assembler understands -mno-shared.])])
4305 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4306 gcc_cv_as_mips_gnu_attribute, [2,18,0],,
4307 [.gnu_attribute 4,1],,
4308 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4309 [Define if your assembler supports .gnu_attribute.])])
4311 gcc_GAS_CHECK_FEATURE([.module support],
4312 gcc_cv_as_mips_dot_module,,[-32],
4315 [AC_DEFINE(HAVE_AS_DOT_MODULE, 1,
4316 [Define if your assembler supports .module.])])
4317 if test x$gcc_cv_as_mips_dot_module = xno \
4318 && test x$with_fp_32 != x; then
4320 [Requesting --with-fp-32= requires assembler support for .module.])
4323 gcc_GAS_CHECK_FEATURE([.micromips support],
4324 gcc_cv_as_micromips_support,,[--fatal-warnings],
4326 [AC_DEFINE(HAVE_GAS_MICROMIPS, 1,
4327 [Define if your assembler supports the .set micromips directive])])
4329 gcc_GAS_CHECK_FEATURE([.dtprelword support],
4330 gcc_cv_as_mips_dtprelword, [2,18,0],,
4331 [.section .tdata,"awT",@progbits
4335 .dtprelword x+0x8000],,
4336 [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
4337 [Define if your assembler supports .dtprelword.])])
4339 gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
4340 gcc_cv_as_mips_dspr1_mult,,,
4350 [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
4351 [Define if your assembler supports DSPR1 mult.])])
4353 AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
4354 gcc_cv_as_ld_jalr_reloc=no
4355 if test $gcc_cv_as_mips_explicit_relocs = yes; then
4356 if test $in_tree_ld = yes ; then
4357 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 \
4358 && test $in_tree_ld_is_elf = yes; then
4359 gcc_cv_as_ld_jalr_reloc=yes
4361 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
4362 echo ' .ent x' > conftest.s
4363 echo 'x: lw $2,%got_disp(y)($3)' >> conftest.s
4364 echo ' lw $25,%call16(y)($28)' >> conftest.s
4365 echo ' .reloc 1f,R_MIPS_JALR,y' >> conftest.s
4366 echo '1: jalr $25' >> conftest.s
4367 echo ' .reloc 1f,R_MIPS_JALR,x' >> conftest.s
4368 echo '1: jalr $25' >> conftest.s
4369 echo ' .end x' >> conftest.s
4370 if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
4371 && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
4372 if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
4373 && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
4374 gcc_cv_as_ld_jalr_reloc=yes
4380 if test $gcc_cv_as_ld_jalr_reloc = yes; then
4381 if test x$target_cpu_default = x; then
4382 target_cpu_default=MASK_RELAX_PIC_CALLS
4384 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
4387 AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
4389 AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
4390 [gcc_cv_ld_mips_personality_relaxation],
4391 [gcc_cv_ld_mips_personality_relaxation=no
4392 if test $in_tree_ld = yes ; then
4393 if test "$gcc_cv_gld_major_version" -eq 2 \
4394 -a "$gcc_cv_gld_minor_version" -ge 21 \
4395 -o "$gcc_cv_gld_major_version" -gt 2; then
4396 gcc_cv_ld_mips_personality_relaxation=yes
4398 elif test x$gcc_cv_as != x \
4399 -a x$gcc_cv_ld != x \
4400 -a x$gcc_cv_readelf != x ; then
4401 cat > conftest.s <<EOF
4403 .cfi_personality 0x80,indirect_ptr
4410 .section .data,"aw",@progbits
4414 if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
4415 && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
4416 if $gcc_cv_readelf -d conftest 2>&1 \
4417 | grep TEXTREL > /dev/null 2>&1; then
4419 elif $gcc_cv_readelf --relocs conftest 2>&1 \
4420 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
4423 gcc_cv_ld_mips_personality_relaxation=yes
4427 rm -f conftest.s conftest.o conftest])
4428 if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
4429 AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
4430 [Define if your linker can relax absolute .eh_frame personality
4431 pointers into PC-relative form.])
4434 gcc_GAS_CHECK_FEATURE([-mnan= support],
4435 gcc_cv_as_mips_nan,,
4437 [AC_DEFINE(HAVE_AS_NAN, 1,
4438 [Define if the assembler understands -mnan=.])])
4439 if test x$gcc_cv_as_mips_nan = xno \
4440 && test x$with_nan != x; then
4442 [Requesting --with-nan= requires assembler support for -mnan=])
4446 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4447 gcc_cv_as_s390_gnu_attribute, [2,18,0],,
4448 [.gnu_attribute 8,1],,
4449 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4450 [Define if your assembler supports .gnu_attribute.])])
4454 # Mips and HP-UX need the GNU assembler.
4455 # Linux on IA64 might be able to use the Intel assembler.
4458 mips*-*-* | *-*-hpux* )
4459 if test x$gas_flag = xyes \
4460 || test x"$host" != x"$build" \
4461 || test ! -x "$gcc_cv_as" \
4462 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
4465 echo "*** This configuration requires the GNU assembler" >&2
4471 # ??? Not all targets support dwarf2 debug_line, even within a version
4472 # of gas. Moreover, we need to emit a valid instruction to trigger any
4473 # info to the output file. So, as supported targets are added to gas 2.11,
4474 # add some instruction here to (also) show we expect this might work.
4475 # ??? Once 2.11 is released, probably need to add first known working
4476 # version to the per-target configury.
4478 aarch64 | alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze \
4479 | mips | nios2 | pa | rs6000 | score | sparc | spu | tilegx | tilepro \
4480 | visium | xstormy16 | xtensa)
4490 if test x"$insn" != x; then
4492 .file 1 \"conftest.s\"
4495 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
4496 gcc_cv_as_dwarf2_debug_line,
4497 [elf,2,11,0],, [$conftest_s],
4498 [if test x$gcc_cv_objdump != x \
4499 && $gcc_cv_objdump -h conftest.o 2> /dev/null \
4500 | grep debug_line > /dev/null 2>&1; then
4501 gcc_cv_as_dwarf2_debug_line=yes
4504 # The .debug_line file table must be in the exact order that
4505 # we specified the files, since these indices are also used
4506 # by DW_AT_decl_file. Approximate this test by testing if
4507 # the assembler bitches if the same index is assigned twice.
4508 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
4509 gcc_cv_as_dwarf2_file_buggy,,,
4513 if test $gcc_cv_as_dwarf2_debug_line = yes \
4514 && test $gcc_cv_as_dwarf2_file_buggy = no; then
4515 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
4516 [Define if your assembler supports dwarf2 .file/.loc directives,
4517 and preserves file table indices exactly as given.])
4520 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
4521 gcc_cv_as_gdwarf2_flag,
4522 [elf,2,11,0], [--gdwarf2], [$insn],,
4523 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
4524 [Define if your assembler supports the --gdwarf2 option.])])
4526 gcc_GAS_CHECK_FEATURE([--gstabs option],
4527 gcc_cv_as_gstabs_flag,
4528 [elf,2,11,0], [--gstabs], [$insn],,
4529 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
4530 [Define if your assembler supports the --gstabs option.])])
4532 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
4533 gcc_cv_as_debug_prefix_map_flag,
4534 [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
4535 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
4536 [Define if your assembler supports the --debug-prefix-map option.])])
4539 gcc_GAS_CHECK_FEATURE([compressed debug sections],
4540 gcc_cv_as_compress_debug,,[--compress-debug-sections],,
4541 [# gas compiled without zlib cannot compress debug sections and warns
4542 # about it, but still exits successfully. So check for this, too.
4543 if $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null
4545 gcc_cv_as_compress_debug=0
4546 elif $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s > /dev/null 2>&1
4548 gcc_cv_as_compress_debug=1
4549 gcc_cv_as_compress_debug_option="--compress-debug-sections"
4550 gcc_cv_as_no_compress_debug_option="--nocompress-debug-sections"
4552 gcc_cv_as_compress_debug=0
4553 # FIXME: Future gas versions will support ELF gABI style via
4554 # --compress-debug-sections[=type].
4556 AC_DEFINE_UNQUOTED(HAVE_AS_COMPRESS_DEBUG, $gcc_cv_as_compress_debug,
4557 [Define to the level of your assembler's compressed debug section support.])
4558 AC_DEFINE_UNQUOTED(AS_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_compress_debug_option",
4559 [Define to the assembler option to enable compressed debug sections.])
4560 AC_DEFINE_UNQUOTED(AS_NO_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_no_compress_debug_option",
4561 [Define to the assembler option to disable compressed debug sections.])
4563 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
4566 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
4567 [Define if your assembler supports .lcomm with an alignment field.])])
4569 if test x$with_sysroot = x && test x$host = x$target \
4570 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4571 && test "$prefix" != "NONE"; then
4572 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4573 [Define to PREFIX/include if cpp should also search that directory.])
4576 # Determine the version of glibc, if any, used on the target.
4577 AC_MSG_CHECKING([for target glibc version])
4578 AC_ARG_WITH([glibc-version],
4579 [AS_HELP_STRING([--with-glibc-version=M.N],
4580 [assume GCC used with glibc version M.N or later])], [
4581 if [echo "$with_glibc_version" | grep '^[0-9][0-9]*\.[0-9][0-9]*$']; then
4582 glibc_version_major=`echo "$with_glibc_version" | sed -e 's/\..*//'`
4583 glibc_version_minor=`echo "$with_glibc_version" | sed -e 's/.*\.//'`
4585 AC_MSG_ERROR([option --with-glibc-version requires a version number M.N])
4587 glibc_version_major=0
4588 glibc_version_minor=0
4589 [if test -f $target_header_dir/features.h \
4590 && glibc_version_major_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+[0-9]' $target_header_dir/features.h` \
4591 && glibc_version_minor_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+[0-9]' $target_header_dir/features.h`; then
4592 glibc_version_major=`echo "$glibc_version_major_define" | sed -e 's/.*__GLIBC__[ ]*//'`
4593 glibc_version_minor=`echo "$glibc_version_minor_define" | sed -e 's/.*__GLIBC_MINOR__[ ]*//'`
4595 AC_MSG_RESULT([$glibc_version_major.$glibc_version_minor])
4596 AC_DEFINE_UNQUOTED([TARGET_GLIBC_MAJOR], [$glibc_version_major],
4597 [GNU C Library major version number used on the target, or 0.])
4598 AC_DEFINE_UNQUOTED([TARGET_GLIBC_MINOR], [$glibc_version_minor],
4599 [GNU C Library minor version number used on the target, or 0.])
4601 AC_ARG_ENABLE(gnu-unique-object,
4602 [AS_HELP_STRING([--enable-gnu-unique-object],
4603 [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
4604 [case $enable_gnu_unique_object in
4606 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
4607 Valid choices are 'yes' and 'no'.]) ;;
4609 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
4611 [.type foo, '$target_type_format_char'gnu_unique_object],,
4612 # We need to unquote above to to use the definition from config.gcc.
4613 # Also check for ld.so support, i.e. glibc 2.11 or higher.
4614 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [11], [enable_gnu_unique_object=yes], )]
4616 if test x$enable_gnu_unique_object = xyes; then
4617 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
4618 [Define if your assembler supports @gnu_unique_object.])
4621 AC_CACHE_CHECK([assembler for tolerance to line number 0],
4622 [gcc_cv_as_line_zero],
4623 [gcc_cv_as_line_zero=no
4624 if test $in_tree_gas = yes; then
4625 gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
4626 elif test "x$gcc_cv_as" != x; then
4627 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
4628 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
4629 test "x`cat conftest.out`" = x
4631 gcc_cv_as_line_zero=yes
4633 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
4634 cat conftest.s >&AS_MESSAGE_LOG_FD
4635 echo "configure: error output was" >&AS_MESSAGE_LOG_FD
4636 cat conftest.out >&AS_MESSAGE_LOG_FD
4638 rm -f conftest.o conftest.s conftest.out
4640 if test "x$gcc_cv_as_line_zero" = xyes; then
4641 AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
4642 [Define if the assembler won't complain about a line such as # 0 "" 2.])
4645 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
4646 gcc_cv_ld_eh_frame_hdr=no
4647 if test $in_tree_ld = yes ; then
4648 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 \
4649 && test $in_tree_ld_is_elf = yes; then
4650 gcc_cv_ld_eh_frame_hdr=yes
4652 elif test x$gcc_cv_ld != x; then
4653 if echo "$ld_ver" | grep GNU > /dev/null; then
4654 # Check if linker supports --eh-frame-hdr option
4655 if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
4656 gcc_cv_ld_eh_frame_hdr=yes
4661 # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
4662 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
4663 gcc_cv_ld_eh_frame_hdr=yes
4669 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
4670 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
4671 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
4672 [Define if your linker supports .eh_frame_hdr.])
4674 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
4676 AC_MSG_CHECKING(linker CIEv3 in .eh_frame support)
4677 gcc_cv_ld_eh_frame_ciev3=no
4678 if test $in_tree_ld = yes ; then
4679 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 \
4680 && test $in_tree_ld_is_elf = yes; then
4681 gcc_cv_ld_eh_frame_ciev3=yes
4683 elif test x$gcc_cv_ld != x; then
4684 if echo "$ld_ver" | grep GNU > /dev/null; then
4685 gcc_cv_ld_eh_frame_ciev3=yes
4686 if test 0"$ld_date" -lt 20040513; then
4687 if test -n "$ld_date"; then
4688 # If there was date string, but was earlier than 2004-05-13, fail
4689 gcc_cv_ld_eh_frame_ciev3=no
4690 elif test "$ld_vers_major" -lt 2; then
4691 gcc_cv_ld_eh_frame_ciev3=no
4692 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
4693 gcc_cv_ld_eh_frame_ciev3=no
4699 # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1.
4700 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then
4701 gcc_cv_ld_eh_frame_ciev3=yes
4707 AC_DEFINE_UNQUOTED(HAVE_LD_EH_FRAME_CIEV3,
4708 [`if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi`],
4709 [Define 0/1 if your linker supports CIE v3 in .eh_frame.])
4710 AC_MSG_RESULT($gcc_cv_ld_eh_frame_ciev3)
4712 AC_MSG_CHECKING(linker position independent executable support)
4714 if test $in_tree_ld = yes ; then
4715 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 15 -o "$gcc_cv_gld_major_version" -gt 2 \
4716 && test $in_tree_ld_is_elf = yes; then
4719 elif test x$gcc_cv_ld != x; then
4720 # Check if linker supports -pie option
4721 if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
4725 if test x"$gcc_cv_ld_pie" = xyes; then
4726 AC_DEFINE(HAVE_LD_PIE, 1,
4727 [Define if your linker supports -pie option.])
4729 AC_MSG_RESULT($gcc_cv_ld_pie)
4731 AC_MSG_CHECKING(linker PIE support with copy reloc)
4732 gcc_cv_ld_pie_copyreloc=no
4733 if test $gcc_cv_ld_pie = yes ; then
4734 if test $in_tree_ld = yes ; then
4735 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
4736 gcc_cv_ld_pie_copyreloc=yes
4738 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4739 # Check if linker supports -pie option with copy reloc
4741 i?86-*-linux* | x86_64-*-linux*)
4742 cat > conftest1.s <<EOF
4745 .type a_glob, @object
4750 cat > conftest2.s <<EOF
4753 .type main, @function
4755 movl %eax, a_glob(%rip)
4758 .section .data.rel,"aw",@progbits
4763 if $gcc_cv_as --64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4764 && $gcc_cv_ld -shared -melf_x86_64 -o conftest1.so conftest1.o > /dev/null 2>&1 \
4765 && $gcc_cv_as --64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4766 && $gcc_cv_ld -pie -melf_x86_64 -o conftest conftest2.o conftest1.so > /dev/null 2>&1; then
4767 gcc_cv_ld_pie_copyreloc=yes
4769 rm -f conftest conftest1.so conftest1.o conftest2.o conftest1.s conftest2.s
4774 AC_DEFINE_UNQUOTED(HAVE_LD_PIE_COPYRELOC,
4775 [`if test x"$gcc_cv_ld_pie_copyreloc" = xyes; then echo 1; else echo 0; fi`],
4776 [Define 0/1 if your linker supports -pie option with copy reloc.])
4777 AC_MSG_RESULT($gcc_cv_ld_pie_copyreloc)
4779 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
4780 gcc_cv_ld_eh_gc_sections=no
4781 if test $in_tree_ld = yes ; then
4782 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 \
4783 && test $in_tree_ld_is_elf = yes; then
4784 gcc_cv_ld_eh_gc_sections=yes
4786 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
4787 cat > conftest.s <<EOF
4790 .type _start, @function
4793 .size _start, .-_start
4794 .section .text.foo,"ax",@progbits
4795 .type foo, @function
4799 .section .gcc_except_table.foo,"a",@progbits
4802 .section .eh_frame,"a",@progbits
4805 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4806 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4807 | grep "gc-sections option ignored" > /dev/null; then
4808 gcc_cv_ld_eh_gc_sections=no
4809 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4810 | grep gcc_except_table > /dev/null; then
4811 gcc_cv_ld_eh_gc_sections=yes
4812 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
4813 if test x$gcc_cv_as_comdat_group != xyes; then
4814 gcc_cv_ld_eh_gc_sections=no
4815 cat > conftest.s <<EOF
4818 .type _start, @function
4821 .size _start, .-_start
4822 .section .gnu.linkonce.t.foo,"ax",@progbits
4823 .type foo, @function
4827 .section .gcc_except_table.foo,"a",@progbits
4830 .section .eh_frame,"a",@progbits
4833 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4834 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4835 | grep "gc-sections option ignored" > /dev/null; then
4836 gcc_cv_ld_eh_gc_sections=no
4837 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4838 | grep gcc_except_table > /dev/null; then
4839 gcc_cv_ld_eh_gc_sections=yes
4845 rm -f conftest.s conftest.o conftest
4849 # ??? This apparently exposes a binutils bug with PC-relative relocations.
4850 gcc_cv_ld_eh_gc_sections=no
4853 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
4854 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
4855 [Define if your linker supports garbage collection of
4856 sections in presence of EH frames.])
4858 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
4860 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
4861 gcc_cv_ld_eh_gc_sections_bug=no
4862 if test $in_tree_ld = yes ; then
4863 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 \
4864 && test $in_tree_ld_is_elf = yes; then
4865 gcc_cv_ld_eh_gc_sections_bug=yes
4867 elif 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
4868 gcc_cv_ld_eh_gc_sections_bug=yes
4869 cat > conftest.s <<EOF
4872 .type _start, @function
4875 .size _start, .-_start
4876 .section .text.startup.foo,"ax",@progbits
4877 .type foo, @function
4881 .section .gcc_except_table.foo,"a",@progbits
4884 .section .eh_frame,"a",@progbits
4887 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4888 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4889 | grep "gc-sections option ignored" > /dev/null; then
4891 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4892 | grep gcc_except_table > /dev/null; then
4893 gcc_cv_ld_eh_gc_sections_bug=no
4896 rm -f conftest.s conftest.o conftest
4898 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
4899 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
4900 [Define if your linker has buggy garbage collection of
4901 sections support when .text.startup.foo like sections are used.])
4903 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
4905 AC_MSG_CHECKING(linker for compressed debug sections)
4906 # gold/gld support compressed debug sections since binutils 2.19/2.21
4907 if test $in_tree_ld = yes ; then
4908 gcc_cv_ld_compress_debug=0
4909 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 \
4910 && test $in_tree_ld_is_elf = yes && test $ld_is_gold = yes; then
4911 gcc_cv_ld_compress_debug=2
4912 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
4913 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 \
4914 && test $in_tree_ld_is_elf = yes; then
4915 gcc_cv_ld_compress_debug=1
4917 elif echo "$ld_ver" | grep GNU > /dev/null; then
4918 gcc_cv_ld_compress_debug=1
4919 if test 0"$ld_date" -lt 20050308; then
4920 if test -n "$ld_date"; then
4921 # If there was date string, but was earlier than 2005-03-08, fail
4922 gcc_cv_ld_compress_debug=0
4923 elif test "$ld_vers_major" -lt 2; then
4924 gcc_cv_ld_compress_debug=0
4925 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 21; then
4926 gcc_cv_ld_compress_debug=0
4929 if test $ld_is_gold = yes; then
4930 gcc_cv_ld_compress_debug=2
4931 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
4937 # Introduced in Solaris 11.2.
4938 if $gcc_cv_ld --help 2>&1 | grep -- '-z compress-sections' > /dev/null; then
4939 gcc_cv_ld_compress_debug=3
4940 gcc_cv_ld_compress_debug_option="-z compress-sections"
4942 gcc_cv_ld_compress_debug=0
4946 # Assume linkers other than GNU ld don't support compessed debug
4948 gcc_cv_ld_compress_debug=0
4953 AC_DEFINE_UNQUOTED(HAVE_LD_COMPRESS_DEBUG, $gcc_cv_ld_compress_debug,
4954 [Define to the level of your linker's compressed debug section support.])
4955 AC_DEFINE_UNQUOTED(LD_COMPRESS_DEBUG_OPTION, "$gcc_cv_ld_compress_debug_option",
4956 [Define to the linker option to enable compressed debug sections.])
4957 AC_MSG_RESULT($gcc_cv_ld_compress_debug)
4963 AC_CACHE_CHECK(linker --as-needed support,
4964 gcc_cv_ld_as_needed,
4965 [gcc_cv_ld_as_needed=no
4966 gcc_cv_ld_as_needed_option='--as-needed'
4967 gcc_cv_ld_no_as_needed_option='--no-as-needed'
4968 if test $in_tree_ld = yes ; then
4969 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 \
4970 && test $in_tree_ld_is_elf = yes; then
4971 gcc_cv_ld_as_needed=yes
4973 elif test x$gcc_cv_ld != x; then
4974 # Check if linker supports --as-needed and --no-as-needed options
4975 if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
4976 gcc_cv_ld_as_needed=yes
4979 # Solaris 2 ld always supports -z ignore/-z record.
4981 gcc_cv_ld_as_needed=yes
4982 gcc_cv_ld_as_needed_option="-z ignore"
4983 gcc_cv_ld_no_as_needed_option="-z record"
4988 # --as-needed/-z ignore can only be used if libgcc_s.so.1 uses
4989 # dl_iterate_phdr, i.e. since Solaris 11.
4991 *-*-solaris2.1[[1-9]]*)
4993 i?86-*-* | x86_64-*-*)
4994 if echo "$ld_ver" | grep GNU > /dev/null; then
4995 # Doesn't work with gld on Solaris/x86 due to PR ld/12320.
4996 gcc_cv_ld_as_needed=no
5002 gcc_cv_ld_as_needed=no
5006 if test x"$gcc_cv_ld_as_needed" = xyes; then
5007 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
5008 [Define if your linker supports --as-needed/--no-as-needed or equivalent options.])
5009 AC_DEFINE_UNQUOTED(LD_AS_NEEDED_OPTION, "$gcc_cv_ld_as_needed_option",
5010 [Define to the linker option to ignore unused dependencies.])
5011 AC_DEFINE_UNQUOTED(LD_NO_AS_NEEDED_OPTION, "$gcc_cv_ld_no_as_needed_option",
5012 [Define to the linker option to keep unused dependencies.])
5015 AC_MSG_CHECKING(linker mapfile support for clearing hardware capabilities)
5016 saved_LDFLAGS="$LDFLAGS"
5017 for clearcap_map in sol2-clearcapv2.map sol2-clearcap.map; do
5018 LDFLAGS="$saved_LDFLAGS -Wl,-M,${srcdir}/config/$clearcap_map"
5019 AC_LINK_IFELSE([int main(void) {return 0;}],
5020 [gcc_cv_ld_clearcap=yes; break], [gcc_cv_ld_clearcap=no])
5022 LDFLAGS="$saved_LDFLAGS"
5023 if test "x$gcc_cv_ld_clearcap" = xyes; then
5024 AC_DEFINE([HAVE_LD_CLEARCAP], 1,
5025 [Define if the linker supports clearing hardware capabilities via mapfile.])
5026 AC_CONFIG_LINKS([clearcap.map:${srcdir}/config/$clearcap_map])
5028 AC_MSG_RESULT($gcc_cv_ld_clearcap)
5030 case "$target:$tm_file" in
5031 powerpc64-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
5034 emul_name="-melf64lppc"
5037 emul_name="-melf64ppc"
5040 emul_name="-melf64ppc_fbsd"
5043 AC_CACHE_CHECK(linker support for omitting dot symbols,
5044 gcc_cv_ld_no_dot_syms,
5045 [gcc_cv_ld_no_dot_syms=no
5046 if test x"$ld_is_gold" = xyes; then
5047 gcc_cv_ld_no_dot_syms=yes
5048 elif test $in_tree_ld = yes ; then
5049 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
5050 gcc_cv_ld_no_dot_syms=yes
5052 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
5053 cat > conftest1.s <<EOF
5057 cat > conftest2.s <<EOF
5058 .section ".opd","aw"
5063 .quad .LEfoo,.TOC.@tocbase,0
5069 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
5070 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
5071 && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
5072 gcc_cv_ld_no_dot_syms=yes
5074 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
5077 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
5078 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
5079 [Define if your PowerPC64 linker only needs function descriptor syms.])
5082 AC_CACHE_CHECK(linker large toc support,
5083 gcc_cv_ld_large_toc,
5084 [gcc_cv_ld_large_toc=no
5085 if test x"$ld_is_gold" = xyes; then
5086 gcc_cv_ld_large_toc=yes
5087 elif test $in_tree_ld = yes ; then
5088 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
5089 gcc_cv_ld_large_toc=yes
5091 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
5092 cat > conftest.s <<EOF
5093 .section ".tbss","awT",@nobits
5099 addis 9,13,ie0@got@tprel@ha
5100 ld 9,ie0@got@tprel@l(9)
5102 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
5103 && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
5104 gcc_cv_ld_large_toc=yes
5106 rm -f conftest conftest.o conftest.s
5109 if test x"$gcc_cv_ld_large_toc" = xyes; then
5110 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
5111 [Define if your PowerPC64 linker supports a large TOC.])
5114 AC_CACHE_CHECK(linker toc pointer alignment,
5115 gcc_cv_ld_toc_align,
5116 [if test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_nm != x; then
5117 cat > conftest.s <<EOF
5122 .section .data.rel.ro,"aw",@progbits
5127 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
5128 && $gcc_cv_ld $emul_name -o conftest conftest.o > /dev/null 2>&1; then
5129 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)) }'`
5131 rm -f conftest conftest.o conftest.s
5134 if test -n "$gcc_cv_ld_toc_align" && test $gcc_cv_ld_toc_align -gt 8; then
5135 AC_DEFINE_UNQUOTED(POWERPC64_TOC_POINTER_ALIGNMENT, $gcc_cv_ld_toc_align,
5136 [Define to .TOC. alignment forced by your linker.])
5143 AC_CACHE_CHECK(linker large toc support,
5144 gcc_cv_ld_large_toc,
5145 [gcc_cv_ld_large_toc=no
5146 if test x$gcc_cv_as != x ; then
5147 cat > conftest.s <<EOF
5157 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1; then
5158 gcc_cv_ld_large_toc=yes
5160 rm -f conftest conftest.o conftest.s
5163 if test x"$gcc_cv_ld_large_toc" = xyes; then
5164 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
5165 [Define if your PowerPC64 linker supports a large TOC.])
5170 AC_CACHE_CHECK(linker --build-id support,
5172 [gcc_cv_ld_buildid=no
5173 if test $in_tree_ld = yes ; then
5174 if test "$gcc_cv_gld_major_version" -eq 2 -a \
5175 "$gcc_cv_gld_minor_version" -ge 18 -o \
5176 "$gcc_cv_gld_major_version" -gt 2 \
5177 && test $in_tree_ld_is_elf = yes; then
5178 gcc_cv_ld_buildid=yes
5180 elif test x$gcc_cv_ld != x; then
5181 if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
5182 gcc_cv_ld_buildid=yes
5185 if test x"$gcc_cv_ld_buildid" = xyes; then
5186 AC_DEFINE(HAVE_LD_BUILDID, 1,
5187 [Define if your linker supports --build-id.])
5190 AC_ARG_ENABLE(linker-build-id,
5191 [AS_HELP_STRING([--enable-linker-build-id],
5192 [compiler will always pass --build-id to linker])],
5194 enable_linker_build_id=no)
5196 if test x"$enable_linker_build_id" = xyes; then
5197 if test x"$gcc_cv_ld_buildid" = xyes; then
5198 AC_DEFINE(ENABLE_LD_BUILDID, 1,
5199 [Define if gcc should always pass --build-id to linker.])
5201 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
5205 # In binutils 2.21, GNU ld gained support for new emulations fully
5206 # supporting the Solaris 2 ABI. Detect their presence in the linker used.
5207 AC_CACHE_CHECK(linker *_sol2 emulation support,
5208 gcc_cv_ld_sol2_emulation,
5209 [gcc_cv_ld_sol2_emulation=no
5210 if test $in_tree_ld = yes ; then
5211 if test "$gcc_cv_gld_major_version" -eq 2 -a \
5212 "$gcc_cv_gld_minor_version" -ge 21 -o \
5213 "$gcc_cv_gld_major_version" -gt 2 \
5214 && test $in_tree_ld_is_elf = yes; then
5215 gcc_cv_ld_sol2_emulation=yes
5217 elif test x$gcc_cv_ld != x; then
5218 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
5219 grep _sol2 > /dev/null; then
5220 gcc_cv_ld_sol2_emulation=yes
5223 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
5224 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
5225 [Define if your linker supports the *_sol2 emulations.])
5228 AC_CACHE_CHECK(linker --sysroot support,
5230 [gcc_cv_ld_sysroot=no
5231 if test $in_tree_ld = yes ; then
5232 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
5233 gcc_cv_ld_sysroot=yes
5235 elif test x$gcc_cv_ld != x; then
5236 if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
5237 gcc_cv_ld_sysroot=yes
5240 if test x"$gcc_cv_ld_sysroot" = xyes; then
5241 AC_DEFINE(HAVE_LD_SYSROOT, 1,
5242 [Define if your linker supports --sysroot.])
5245 # Test for stack protector support in target C library.
5246 AC_CACHE_CHECK(__stack_chk_fail in target C library,
5247 gcc_cv_libc_provides_ssp,
5248 [gcc_cv_libc_provides_ssp=no
5251 # All versions of musl provide stack protector
5252 gcc_cv_libc_provides_ssp=yes;;
5253 *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
5254 # glibc 2.4 and later provides __stack_chk_fail and
5255 # either __stack_chk_guard, or TLS access to stack guard canary.
5256 GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_libc_provides_ssp=yes], [
5257 [if test -f $target_header_dir/features.h \
5258 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \
5259 $target_header_dir/features.h > /dev/null; then
5260 if $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \
5261 $target_header_dir/features.h > /dev/null && \
5262 test -f $target_header_dir/bits/uClibc_config.h && \
5263 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \
5264 $target_header_dir/bits/uClibc_config.h > /dev/null; then
5265 gcc_cv_libc_provides_ssp=yes
5267 # all versions of Bionic support stack protector
5268 elif test -f $target_header_dir/sys/cdefs.h \
5269 && $EGREP '^[ ]*#[ ]*define[ ]+__BIONIC__[ ]+1' \
5270 $target_header_dir/sys/cdefs.h > /dev/null; then
5271 gcc_cv_libc_provides_ssp=yes
5275 # Avoid complicated tests (see
5276 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
5277 # simply assert that glibc does provide this, which is true for all
5278 # realistically usable GNU/Hurd configurations.
5279 # All supported versions of musl provide it as well
5280 gcc_cv_libc_provides_ssp=yes;;
5281 *-*-darwin* | *-*-freebsd*)
5282 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
5283 [echo "no __stack_chk_fail on this target"])
5285 *) gcc_cv_libc_provides_ssp=no ;;
5288 if test x$gcc_cv_libc_provides_ssp = xyes; then
5289 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
5290 [Define if your target C library provides stack protector support])
5293 # Test for <sys/sdt.h> on the target.
5294 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
5295 AC_MSG_CHECKING(sys/sdt.h in the target C library)
5297 if test -f $target_header_dir/sys/sdt.h; then
5299 AC_DEFINE(HAVE_SYS_SDT_H, 1,
5300 [Define if your target C library provides sys/sdt.h])
5302 AC_MSG_RESULT($have_sys_sdt_h)
5304 # Check if TFmode long double should be used by default or not.
5305 # Some glibc targets used DFmode long double, but with glibc 2.4
5306 # and later they can use TFmode.
5308 powerpc*-*-linux* | \
5312 AC_ARG_WITH(long-double-128,
5313 [AS_HELP_STRING([--with-long-double-128],
5314 [use 128-bit long double by default])],
5315 gcc_cv_target_ldbl128="$with_long_double_128",
5316 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_target_ldbl128=yes], [
5317 [gcc_cv_target_ldbl128=no
5318 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \
5319 $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
5320 && gcc_cv_target_ldbl128=yes
5324 if test x$gcc_cv_target_ldbl128 = xyes; then
5325 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
5326 [Define if TFmode long double should be the default])
5329 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
5330 gcc_cv_target_dl_iterate_phdr=unknown
5332 # Restrict to Solaris 11+. While most of the Solaris 11 linker changes
5333 # were backported to Solaris 10 Update 10, dl_iterate_phdr only lives in
5334 # libdl there, both complicating its use and breaking compatibility
5335 # between Solaris 10 updates.
5336 *-*-solaris2.1[[1-9]]*)
5337 # <link.h> needs both a dl_iterate_phdr declaration and support for
5338 # compilation with largefile support.
5339 if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
5340 && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
5341 gcc_cv_target_dl_iterate_phdr=yes
5343 gcc_cv_target_dl_iterate_phdr=no
5346 *-*-dragonfly* | *-*-freebsd*)
5347 if grep dl_iterate_phdr $target_header_dir/sys/link_elf.h > /dev/null 2>&1; then
5348 gcc_cv_target_dl_iterate_phdr=yes
5350 gcc_cv_target_dl_iterate_phdr=no
5354 gcc_cv_target_dl_iterate_phdr=yes
5357 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
5358 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
5359 AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
5360 [Define if your target C library provides the `dl_iterate_phdr' function.])
5362 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
5364 # We no longer support different GC mechanisms. Emit an error if
5365 # the user configures with --with-gc.
5367 [AS_HELP_STRING([--with-gc={page,zone}],
5368 [this option is not supported anymore. It used to choose
5369 the garbage collection mechanism to use with the compiler])],
5370 [AC_MSG_ERROR([Configure option --with-gc is only supported up to GCC 4.7.x])],
5373 # Libraries to use on the host. This will normally be set by the top
5374 # level Makefile. Here we simply capture the value for our Makefile.
5375 if test -z "${HOST_LIBS+set}"; then
5380 # Use the system's zlib library.
5382 zlibinc="-I\$(srcdir)/../zlib"
5383 AC_ARG_WITH(system-zlib,
5384 [AS_HELP_STRING([--with-system-zlib], [use installed libz])],
5391 dnl Very limited version of automake's enable-maintainer-mode
5393 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
5394 dnl maintainer-mode is disabled by default
5395 AC_ARG_ENABLE(maintainer-mode,
5396 [AS_HELP_STRING([--enable-maintainer-mode],
5397 [enable make rules and dependencies not useful
5398 (and sometimes confusing) to the casual installer])],
5399 maintainer_mode=$enableval,
5402 AC_MSG_RESULT($maintainer_mode)
5404 if test "$maintainer_mode" = "yes"; then
5411 dnl Whether to prevent multiple front-ends from linking at the same time
5413 AC_MSG_CHECKING([whether to avoid linking multiple front-ends at once])
5414 AC_ARG_ENABLE(link-mutex,
5415 [AS_HELP_STRING([--enable-link-mutex],
5416 [avoid linking multiple front-ends at once to avoid thrashing
5417 on the build machine])],
5418 do_link_mutex=$enableval,
5420 AC_MSG_RESULT($do_link_mutex)
5422 if test "$do_link_mutex" = "yes"; then
5427 AC_SUBST(DO_LINK_MUTEX)
5433 # Make empty files to contain the specs and options for each language.
5434 # Then add #include lines to for a compiler that has specs and/or options.
5440 # These (without "all_") are set in each config-lang.in.
5441 # `language' must be a single word so is spelled singularly.
5444 all_outputs='Makefile'
5445 # List of language makefile fragments.
5447 # Additional files for gengtype
5448 all_gtfiles="$target_gtfiles"
5450 # These are the languages that are set in --enable-languages,
5451 # and are available in the GCC tree.
5452 all_selected_languages=
5454 # Add the language fragments.
5455 # Languages are added via two mechanisms. Some information must be
5456 # recorded in makefile variables, these are defined in config-lang.in.
5457 # We accumulate them and plug them into the main Makefile.
5458 # The other mechanism is a set of hooks for each of the main targets
5459 # like `clean', `install', etc.
5461 language_hooks="Make-hooks"
5463 for lang in ${srcdir}/*/config-lang.in
5466 test "$lang" = "${srcdir}/*/config-lang.in" && continue
5468 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
5469 if test "x$lang_alias" = x
5471 echo "$lang doesn't set \$language." 1>&2
5474 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
5475 subdirs="$subdirs $subdir"
5477 # $gcc_subdir is where the gcc integration files are to be found
5478 # for a language, both for internal compiler purposes (compiler
5479 # sources implementing front-end to GCC tree converters), and for
5480 # build infrastructure purposes (Make-lang.in, etc.)
5482 # This will be <subdir> (relative to $srcdir) if a line like
5483 # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
5484 # is found in <langdir>/config-lang.in, and will remain <langdir>
5487 # Except for the language alias (fetched above), the regular
5488 # "config-lang.in" contents are always retrieved from $gcc_subdir,
5489 # so a <langdir>/config-lang.in setting gcc_subdir typically sets
5490 # only this and the language alias.
5492 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang`
5493 if [ "$gcc_subdir" = "" ]; then
5494 gcc_subdir="$subdir"
5497 case ",$enable_languages," in
5499 all_selected_languages="$all_selected_languages $lang_alias"
5500 if test -f $srcdir/$gcc_subdir/lang-specs.h; then
5501 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
5513 . ${srcdir}/$gcc_subdir/config-lang.in
5514 if test "x$language" = x
5516 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
5521 case ",$enable_languages," in
5524 for i in $subdir_requires; do
5525 test -f "${srcdir}/$i/config-lang.in" && continue
5533 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
5534 if test -f $srcdir/$gcc_subdir/lang.opt; then
5535 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
5536 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
5538 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
5539 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
5541 all_languages="$all_languages $language"
5542 all_compilers="$all_compilers $compilers"
5543 all_outputs="$all_outputs $outputs"
5544 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
5545 case ",$enable_languages," in
5547 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
5549 AC_SUBST(enable_lto)
5556 for language in $all_selected_languages
5558 check_languages="$check_languages check-$language"
5561 # We link each language in with a set of hooks, reached indirectly via
5562 # lang.${target}. Only do so for selected languages.
5566 target_list="all.cross start.encap rest.encap tags \
5567 install-common install-man install-info install-pdf install-html dvi \
5568 pdf html uninstall info man srcextra srcman srcinfo \
5569 mostlyclean clean distclean maintainer-clean install-plugin"
5571 for t in $target_list
5574 for lang in $all_selected_languages
5578 echo "lang.$t: $x" >> Make-hooks
5582 # Option include files
5585 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
5586 option_includes="option-includes.mk"
5587 AC_SUBST_FILE(option_includes)
5595 echo "dir ." > .gdbinit
5596 echo "dir ${srcdir}" >> .gdbinit
5597 if test x$gdb_needs_out_file_path = xyes
5599 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
5601 if test "x$subdirs" != x; then
5604 echo "dir ${srcdir}/$s" >> .gdbinit
5607 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
5608 echo "python import sys; sys.path.append('${srcdir}'); import gdbhooks" >> .gdbinit
5610 # Put a breakpoint on __asan_report_error to help with debugging buffer
5613 *-fsanitize=address*)
5614 echo "source ${srcdir}/gdbasan.in" >> .gdbinit
5618 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
5619 AC_SUBST(gcc_tooldir)
5622 # Find a directory in which to install a shared libgcc.
5624 AC_ARG_ENABLE(version-specific-runtime-libs,
5625 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
5626 [specify that runtime libraries should be
5627 installed in a compiler-specific directory])])
5629 # Substitute configuration variables
5632 AC_SUBST(all_compilers)
5633 AC_SUBST(all_gtfiles)
5634 AC_SUBST(all_lang_makefrags)
5635 AC_SUBST(all_languages)
5636 AC_SUBST(all_selected_languages)
5637 AC_SUBST(build_exeext)
5638 AC_SUBST(build_install_headers_dir)
5639 AC_SUBST(build_xm_file_list)
5640 AC_SUBST(build_xm_include_list)
5641 AC_SUBST(build_xm_defines)
5642 AC_SUBST(build_file_translate)
5643 AC_SUBST(check_languages)
5644 AC_SUBST(cpp_install_dir)
5645 AC_SUBST(xmake_file)
5646 AC_SUBST(tmake_file)
5647 AC_SUBST(TM_ENDIAN_CONFIG)
5648 AC_SUBST(TM_MULTILIB_CONFIG)
5649 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
5650 AC_SUBST(extra_gcc_objs)
5651 AC_SUBST(user_headers_inc_next_pre)
5652 AC_SUBST(user_headers_inc_next_post)
5653 AC_SUBST(extra_headers_list)
5654 AC_SUBST(extra_objs)
5655 AC_SUBST(extra_programs)
5656 AC_SUBST(float_h_file)
5657 AC_SUBST(gcc_config_arguments)
5658 AC_SUBST(gcc_gxx_include_dir)
5659 AC_SUBST(gcc_gxx_include_dir_add_sysroot)
5660 AC_SUBST(host_exeext)
5661 AC_SUBST(host_xm_file_list)
5662 AC_SUBST(host_xm_include_list)
5663 AC_SUBST(host_xm_defines)
5664 AC_SUBST(out_host_hook_obj)
5666 AC_SUBST(lang_opt_files)
5667 AC_SUBST(lang_specs_files)
5668 AC_SUBST(lang_tree_files)
5669 AC_SUBST(local_prefix)
5671 AC_SUBST(objc_boehm_gc)
5673 AC_SUBST(out_object_file)
5674 AC_SUBST(common_out_file)
5675 AC_SUBST(common_out_object_file)
5676 AC_SUBST(tm_file_list)
5677 AC_SUBST(tm_include_list)
5678 AC_SUBST(tm_defines)
5679 AC_SUBST(tm_p_file_list)
5680 AC_SUBST(tm_p_include_list)
5681 AC_SUBST(xm_file_list)
5682 AC_SUBST(xm_include_list)
5683 AC_SUBST(xm_defines)
5684 AC_SUBST(use_gcc_stdint)
5685 AC_SUBST(c_target_objs)
5686 AC_SUBST(cxx_target_objs)
5687 AC_SUBST(fortran_target_objs)
5688 AC_SUBST(target_cpu_default)
5690 AC_SUBST_FILE(language_hooks)
5693 if test x${build} = x${host} ; then
5694 if test x${host} = x${target} ; then
5695 echo "Links are now set up to build a native compiler for ${target}." 1>&2
5697 echo "Links are now set up to build a cross-compiler" 1>&2
5698 echo " from ${host} to ${target}." 1>&2
5701 if test x${host} = x${target} ; then
5702 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
5703 echo " for ${target}." 1>&2
5705 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
5706 echo " from ${host} to ${target}." 1>&2
5710 AC_ARG_VAR(GMPLIBS,[How to link GMP])
5711 AC_ARG_VAR(GMPINC,[How to find GMP include files])
5713 AC_ARG_VAR(ISLLIBS,[How to link ISL])
5714 AC_ARG_VAR(ISLINC,[How to find ISL include files])
5715 if test "x${ISLLIBS}" != "x" ; then
5716 AC_DEFINE(HAVE_isl, 1, [Define if isl is in use.])
5719 # Check whether isl_schedule_constraints_compute_schedule is available;
5720 # it's new in ISL-0.13.
5721 if test "x${ISLLIBS}" != "x" ; then
5722 saved_CXXFLAGS="$CXXFLAGS"
5723 CXXFLAGS="$CXXFLAGS $ISLINC"
5725 LIBS="$LIBS $ISLLIBS $GMPLIBS"
5727 AC_MSG_CHECKING([Checking for isl_schedule_constraints_compute_schedule])
5728 AC_TRY_LINK([#include <isl/schedule.h>],
5729 [isl_schedule_constraints_compute_schedule (NULL);],
5730 [ac_has_isl_schedule_constraints_compute_schedule=yes],
5731 [ac_has_isl_schedule_constraints_compute_schedule=no])
5732 AC_MSG_RESULT($ac_has_isl_schedule_constraints_compute_schedule)
5735 CXXFLAGS="$saved_CXXFLAGS"
5737 if test x"$ac_has_isl_schedule_constraints_compute_schedule" = x"yes"; then
5738 AC_DEFINE(HAVE_ISL_SCHED_CONSTRAINTS_COMPUTE_SCHEDULE, 1,
5739 [Define if isl_schedule_constraints_compute_schedule exists.])
5744 AC_SUBST(pluginlibs)
5745 AC_SUBST(enable_plugin)
5746 if test x"$enable_plugin" = x"yes"; then
5747 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
5751 # Enable --enable-host-shared
5752 AC_ARG_ENABLE(host-shared,
5753 [AS_HELP_STRING([--enable-host-shared],
5754 [build host code as shared libraries])],
5755 [PICFLAG=-fPIC], [PICFLAG=])
5756 AC_SUBST(enable_host_shared)
5760 AC_ARG_ENABLE(libquadmath-support,
5761 [AS_HELP_STRING([--disable-libquadmath-support],
5762 [disable libquadmath support for Fortran])],
5763 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
5764 ENABLE_LIBQUADMATH_SUPPORT=yes)
5765 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
5766 AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
5767 [Define to 1 to enable libquadmath support])
5771 # Specify what hash style to use by default.
5772 AC_ARG_WITH([linker-hash-style],
5773 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
5774 [specify the linker hash style])],
5775 [case x"$withval" in
5777 LINKER_HASH_STYLE=sysv
5780 LINKER_HASH_STYLE=gnu
5783 LINKER_HASH_STYLE=both
5786 AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
5789 [LINKER_HASH_STYLE=''])
5790 if test x"${LINKER_HASH_STYLE}" != x; then
5791 AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
5792 [The linker hash style])
5795 # Specify what should be the default of -fdiagnostics-color option.
5796 AC_ARG_WITH([diagnostics-color],
5797 [AC_HELP_STRING([--with-diagnostics-color={never,auto,auto-if-env,always}],
5798 [specify the default of -fdiagnostics-color option
5799 auto-if-env stands for -fdiagnostics-color=auto if
5800 GCC_COLOR environment variable is present and
5801 -fdiagnostics-color=never otherwise])],
5802 [case x"$withval" in
5804 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_NO
5807 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_AUTO
5810 DIAGNOSTICS_COLOR_DEFAULT=-1
5813 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_YES
5816 AC_MSG_ERROR([$withval is an invalid option to --with-diagnostics-color])
5819 [DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_AUTO])
5820 AC_DEFINE_UNQUOTED(DIAGNOSTICS_COLOR_DEFAULT, $DIAGNOSTICS_COLOR_DEFAULT,
5821 [The default for -fdiagnostics-color option])
5823 # Generate gcc-driver-name.h containing GCC_DRIVER_NAME for the benefit
5824 # of jit/jit-playback.c.
5825 cat > gcc-driver-name.h <<EOF
5826 #define GCC_DRIVER_NAME "${target_noncanonical}-gcc-${gcc_BASEVER}${exeext}"
5829 # Check whether --enable-default-pie was given.
5830 AC_ARG_ENABLE(default-pie,
5831 [AS_HELP_STRING([--enable-default-pie],
5832 [enable Position Independent Executable as default])],
5833 enable_default_pie=$enableval,
5834 enable_default_pie=no)
5835 if test x$enable_default_pie == xyes ; then
5836 AC_DEFINE(ENABLE_DEFAULT_PIE, 1,
5837 [Define if your target supports default PIE and it is enabled.])
5839 AC_SUBST([enable_default_pie])
5841 # Check if -fno-PIE works.
5842 AC_CACHE_CHECK([for -fno-PIE option],
5844 [saved_CXXFLAGS="$CXXFLAGS"
5845 CXXFLAGS="$CXXFLAGS -fno-PIE"
5846 AC_COMPILE_IFELSE([int main(void) {return 0;}],
5847 [gcc_cv_c_no_fpie=yes],
5848 [gcc_cv_c_no_fpie=no])
5849 CXXFLAGS="$saved_CXXFLAGS"])
5850 if test "$gcc_cv_c_no_fpie" = "yes"; then
5851 NO_PIE_CFLAGS="-fno-PIE"
5853 AC_SUBST([NO_PIE_CFLAGS])
5855 # Check if -no-pie works.
5856 AC_CACHE_CHECK([for -no-pie option],
5858 [saved_LDFLAGS="$LDFLAGS"
5859 LDFLAGS="$LDFLAGS -no-pie"
5860 AC_LINK_IFELSE([int main(void) {return 0;}],
5861 [gcc_cv_no_pie=yes],
5863 LDFLAGS="$saved_LDFLAGS"])
5864 if test "$gcc_cv_no_pie" = "yes"; then
5865 NO_PIE_FLAG="-no-pie"
5867 AC_SUBST([NO_PIE_FLAG])
5869 # Configure the subdirectories
5870 # AC_CONFIG_SUBDIRS($subdirs)
5872 # Create the Makefile
5873 # and configure language subdirectories
5874 AC_CONFIG_FILES($all_outputs)
5876 AC_CONFIG_COMMANDS([default],
5878 case ${CONFIG_HEADERS} in
5879 *auto-host.h:config.in*)
5882 # Make sure all the subdirs exist.
5883 for d in $subdirs doc build common c-family
5885 test -d $d || mkdir $d
5888 [subdirs='$subdirs'])