2 # Process this file with autoconf to generate a configuration script.
4 # Copyright (C) 1997-2014 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 # Determine the target- and build-specific subdirectories
44 # Set program_transform_name
47 # Check for bogus environment variables.
48 # Test if LIBRARY_PATH contains the notation for the current directory
49 # since this would lead to problems installing/building glibc.
50 # LIBRARY_PATH contains the current directory if one of the following
52 # - one of the terminals (":" and ";") is the first or last sign
53 # - two terminals occur directly after each other
54 # - the path contains an element with a dot in it
55 AC_MSG_CHECKING(LIBRARY_PATH variable)
57 case ${LIBRARY_PATH} in
58 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
59 library_path_setting="contains current directory"
62 library_path_setting="ok"
66 AC_MSG_RESULT($library_path_setting)
67 if test "$library_path_setting" != "ok"; then
69 *** LIBRARY_PATH shouldn't contain the current directory when
70 *** building gcc. Please change the environment variable
71 *** and run configure again.])
74 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
75 # since this would lead to problems installing/building glibc.
76 # GCC_EXEC_PREFIX contains the current directory if one of the following
78 # - one of the terminals (":" and ";") is the first or last sign
79 # - two terminals occur directly after each other
80 # - the path contains an element with a dot in it
81 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
83 case ${GCC_EXEC_PREFIX} in
84 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
85 gcc_exec_prefix_setting="contains current directory"
88 gcc_exec_prefix_setting="ok"
92 AC_MSG_RESULT($gcc_exec_prefix_setting)
93 if test "$gcc_exec_prefix_setting" != "ok"; then
95 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
96 *** building gcc. Please change the environment variable
97 *** and run configure again.])
104 # Specify the local prefix
106 AC_ARG_WITH(local-prefix,
107 [AS_HELP_STRING([--with-local-prefix=DIR],
108 [specifies directory to put local include])],
109 [case "${withval}" in
110 yes) AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
112 *) local_prefix=$with_local_prefix ;;
115 # Default local prefix if it is empty
116 if test x$local_prefix = x; then
117 local_prefix=/usr/local
120 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
121 # passed in by the toplevel make and thus we'd get different behavior
122 # depending on where we built the sources.
124 # Specify the g++ header file directory
125 AC_ARG_WITH(gxx-include-dir,
126 [AS_HELP_STRING([--with-gxx-include-dir=DIR],
127 [specifies directory to put g++ header files])],
128 [case "${withval}" in
129 yes) AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
131 *) gcc_gxx_include_dir=$with_gxx_include_dir ;;
134 # This logic must match libstdc++-v3/acinclude.m4:GLIBCXX_EXPORT_INSTALL_INFO.
135 if test x${gcc_gxx_include_dir} = x; then
136 if test x${enable_version_specific_runtime_libs} = xyes; then
137 gcc_gxx_include_dir='${libsubdir}/include/c++'
139 libstdcxx_incdir='include/c++/$(version)'
140 if test x$host != x$target; then
141 libstdcxx_incdir="$target_alias/$libstdcxx_incdir"
143 gcc_gxx_include_dir="\$(libsubdir)/\$(libsubdir_to_prefix)$libstdcxx_incdir"
147 gcc_gxx_include_dir_add_sysroot=0
148 if test "${with_sysroot+set}" = set; then
149 gcc_gxx_without_sysroot=`expr "${gcc_gxx_include_dir}" : "${with_sysroot}"'\(.*\)'`
150 if test "${gcc_gxx_without_sysroot}"; then
151 gcc_gxx_include_dir="${gcc_gxx_without_sysroot}"
152 gcc_gxx_include_dir_add_sysroot=1
156 AC_ARG_WITH(cpp_install_dir,
157 [AC_HELP_STRING([--with-cpp-install-dir=DIR],
158 [install the user visible C preprocessor in DIR
159 (relative to PREFIX) as well as PREFIX/bin])],
160 [if test x$withval = xyes; then
161 AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
162 elif test x$withval != xno; then
163 cpp_install_dir=$withval
166 # We would like to our source tree to be readonly. However when releases or
167 # pre-releases are generated, the flex/bison generated files as well as the
168 # various formats of manuals need to be included along with the rest of the
169 # sources. Therefore we have --enable-generated-files-in-srcdir to do
172 AC_MSG_CHECKING([whether to place generated files in the source directory])
173 dnl generated-files-in-srcdir is disabled by default
174 AC_ARG_ENABLE(generated-files-in-srcdir,
175 [AS_HELP_STRING([--enable-generated-files-in-srcdir],
176 [put copies of generated files in source dir
177 intended for creating source tarballs for users
178 without texinfo bison or flex])],
179 generated_files_in_srcdir=$enableval,
180 generated_files_in_srcdir=no)
182 AC_MSG_RESULT($generated_files_in_srcdir)
184 if test "$generated_files_in_srcdir" = "yes"; then
191 # -------------------
192 # Find default linker
193 # -------------------
197 [AS_HELP_STRING([--with-gnu-ld], [arrange to work with GNU ld])],
198 gnu_ld_flag="$with_gnu_ld",
201 # With pre-defined ld
203 [AS_HELP_STRING([--with-ld], [arrange to use the specified ld (full pathname)])],
204 DEFAULT_LINKER="$with_ld")
205 if test x"${DEFAULT_LINKER+set}" = x"set"; then
206 if test ! -x "$DEFAULT_LINKER"; then
207 AC_MSG_ERROR([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
208 elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
211 AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
212 [Define to enable the use of a default linker.])
215 AC_MSG_CHECKING([whether a default linker was specified])
216 if test x"${DEFAULT_LINKER+set}" = x"set"; then
217 if test x"$gnu_ld_flag" = x"no"; then
218 AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
220 AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
226 # With demangler in GNU ld
227 AC_ARG_WITH(demangler-in-ld,
228 [AS_HELP_STRING([--with-demangler-in-ld], [try to use demangler in GNU ld])],
229 demangler_in_ld="$with_demangler_in_ld",
232 # ----------------------
233 # Find default assembler
234 # ----------------------
238 [AS_HELP_STRING([--with-gnu-as], [arrange to work with GNU as])],
239 gas_flag="$with_gnu_as",
243 [AS_HELP_STRING([--with-as], [arrange to use the specified as (full pathname)])],
244 DEFAULT_ASSEMBLER="$with_as")
245 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
246 if test ! -x "$DEFAULT_ASSEMBLER"; then
247 AC_MSG_ERROR([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
248 elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
251 AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
252 [Define to enable the use of a default assembler.])
255 AC_MSG_CHECKING([whether a default assembler was specified])
256 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
257 if test x"$gas_flag" = x"no"; then
258 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
260 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
270 # If a non-executable a.out is present (e.g. created by GNU as above even if
271 # invoked with -v only), the IRIX 6 native ld just overwrites the existing
272 # file, even when creating an executable, so an execution test fails.
273 # Remove possible default executable files to avoid this.
275 # FIXME: This really belongs into AC_PROG_CC and can be removed once
276 # Autoconf includes it.
277 rm -f a.out a.exe b.out
279 # Find the native compiler
282 ACX_PROG_GNAT([-I"$srcdir"/ada])
284 # Remove the -O2: for historical reasons, unless bootstrapping we prefer
285 # optimizations to be activated explicitly by the toplevel.
288 *) CFLAGS=`echo "$CFLAGS " | sed -e "s/-Ofast[[ ]]//" -e "s/-O[[gs]][[ ]]//" -e "s/-O[[0-9]]*[[ ]]//" `
289 CXXFLAGS=`echo "$CXXFLAGS " | sed -e "s/-Ofast[[ ]]//" -e "s/-O[[gs]][[ ]]//" -e "s/-O[[0-9]]*[[ ]]//" ` ;;
294 # Determine PICFLAG for target gnatlib.
295 GCC_PICFLAG_FOR_TARGET
296 AC_SUBST(PICFLAG_FOR_TARGET)
298 # -------------------------
299 # Check C compiler features
300 # -------------------------
302 AC_USE_SYSTEM_EXTENSIONS
308 # sizeof(char) is 1 by definition.
309 AC_CHECK_SIZEOF(void *)
310 AC_CHECK_SIZEOF(short)
312 AC_CHECK_SIZEOF(long)
313 AC_CHECK_TYPES([long long], [AC_CHECK_SIZEOF(long long)])
315 if test x"$ac_cv_c_uint64_t" = x"no" -o x"$ac_cv_c_int64_t" = x"no"; then
316 AC_MSG_ERROR([uint64_t or int64_t not found])
319 # check what underlying integer type int64_t uses
321 AC_CACHE_CHECK(for int64_t underlying type, ac_cv_int64_t_type, [
322 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
326 template <typename T> struct X { };
328 struct X<long> { typedef long t; };
329 ]], [[X<int64_t>::t x;]])],[ac_cv_int64_t_type=long],[ac_cv_int64_t_type="long long"])])
330 if test "$ac_cv_int64_t_type" = "long"; then
331 AC_DEFINE(INT64_T_IS_LONG, 1,
332 [Define if int64_t uses long as underlying type.])
334 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
338 template <typename T> struct X { };
340 struct X<long long> { typedef long long t; };
341 ]], [[X<int64_t>::t x;]])],[],[AC_MSG_ERROR([error verifying int64_t uses long long])])
348 # ---------------------
349 # Warnings and checking
350 # ---------------------
352 # Check $CC warning features (if it's GCC).
353 # We want to use -pedantic, but we don't want warnings about
357 # * C++11 narrowing conversions in { }
358 # So, we only use -pedantic if we can disable those warnings.
360 # In stage 1, disable -Wformat warnings from old GCCs about new % codes
361 AC_ARG_ENABLE(build-format-warnings,
362 AS_HELP_STRING([--disable-build-format-warnings],[don't use -Wformat while building GCC]),
363 [],[enable_build_format_warnings=yes])
364 AS_IF([test $enable_build_format_warnings = no],
365 [wf_opt=-Wno-format],[wf_opt=])
366 ACX_PROG_CC_WARNING_OPTS(
367 m4_quote(m4_do([-W -Wall -Wno-narrowing -Wwrite-strings -Wcast-qual $wf_opt])), [loose_warn])
368 ACX_PROG_CC_WARNING_OPTS(
369 m4_quote(m4_do([-Wstrict-prototypes -Wmissing-prototypes])),
371 ACX_PROG_CC_WARNING_OPTS(
372 m4_quote(m4_do([-Wmissing-format-attribute])), [strict_warn])
373 ACX_PROG_CC_WARNING_OPTS(
374 m4_quote(m4_do([-Woverloaded-virtual])), [strict_warn])
375 ACX_PROG_CC_WARNING_OPTS(
376 m4_quote(m4_do([-Wold-style-definition -Wc++-compat])), [c_strict_warn])
377 ACX_PROG_CC_WARNING_ALMOST_PEDANTIC(
378 m4_quote(m4_do([-Wno-long-long -Wno-variadic-macros ],
379 [-Wno-overlength-strings])), [strict_warn])
380 ACX_PROG_CC_WARNINGS_ARE_ERRORS([manual], [strict_warn])
382 # The above macros do nothing if the compiler is not GCC. However, the
383 # Makefile has more goo to add other flags, so these variables are used
384 # to enable warnings only for GCC.
387 if test "x$GCC" = "xyes"; then
388 warn_cflags='$(GCC_WARN_CFLAGS)'
389 warn_cxxflags='$(GCC_WARN_CXXFLAGS)'
391 AC_SUBST(warn_cflags)
392 AC_SUBST(warn_cxxflags)
394 # Disable exceptions and RTTI if building with g++
395 ACX_PROG_CC_WARNING_OPTS(
396 m4_quote(m4_do([-fno-exceptions -fno-rtti -fasynchronous-unwind-tables])),
399 # Enable expensive internal checks
401 if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then
405 AC_ARG_ENABLE(checking,
406 [AS_HELP_STRING([[--enable-checking[=LIST]]],
407 [enable expensive run-time checks. With LIST,
408 enable only specific categories of checks.
409 Categories are: yes,no,all,none,release.
410 Flags are: assert,df,fold,gc,gcac,gimple,misc,
411 rtlflag,rtl,runtime,tree,valgrind,types])],
412 [ac_checking_flags="${enableval}"],[
413 # Determine the default checks.
414 if test x$is_release = x ; then
415 ac_checking_flags=yes
417 ac_checking_flags=release
419 IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
420 for check in release $ac_checking_flags
423 # these set all the flags to specific states
424 yes) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking= ;
425 ac_fold_checking= ; ac_gc_checking=1 ;
426 ac_gc_always_collect= ; ac_gimple_checking=1 ; ac_rtl_checking= ;
427 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
428 ac_tree_checking=1 ; ac_valgrind_checking= ;
429 ac_types_checking=1 ;;
430 no|none) ac_assert_checking= ; ac_checking= ; ac_df_checking= ;
431 ac_fold_checking= ; ac_gc_checking= ;
432 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
433 ac_rtlflag_checking= ; ac_runtime_checking= ;
434 ac_tree_checking= ; ac_valgrind_checking= ;
435 ac_types_checking= ;;
436 all) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking=1 ;
437 ac_fold_checking=1 ; ac_gc_checking=1 ;
438 ac_gc_always_collect=1 ; ac_gimple_checking=1 ; ac_rtl_checking=1 ;
439 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
440 ac_tree_checking=1 ; ac_valgrind_checking= ;
441 ac_types_checking=1 ;;
442 release) ac_assert_checking=1 ; ac_checking= ; ac_df_checking= ;
443 ac_fold_checking= ; ac_gc_checking= ;
444 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
445 ac_rtlflag_checking= ; ac_runtime_checking=1 ;
446 ac_tree_checking= ; ac_valgrind_checking= ;
447 ac_types_checking= ;;
448 # these enable particular checks
449 assert) ac_assert_checking=1 ;;
450 df) ac_df_checking=1 ;;
451 fold) ac_fold_checking=1 ;;
452 gc) ac_gc_checking=1 ;;
453 gcac) ac_gc_always_collect=1 ;;
454 gimple) ac_gimple_checking=1 ;;
455 misc) ac_checking=1 ;;
456 rtl) ac_rtl_checking=1 ;;
457 rtlflag) ac_rtlflag_checking=1 ;;
458 runtime) ac_runtime_checking=1 ;;
459 tree) ac_tree_checking=1 ;;
460 types) ac_types_checking=1 ;;
461 valgrind) ac_valgrind_checking=1 ;;
462 *) AC_MSG_ERROR(unknown check category $check) ;;
468 if test x$ac_checking != x ; then
469 AC_DEFINE(ENABLE_CHECKING, 1,
470 [Define if you want more run-time sanity checks. This one gets a grab
471 bag of miscellaneous but relatively cheap checks.])
472 nocommon_flag=-fno-common
474 AC_SUBST(nocommon_flag)
475 if test x$ac_df_checking != x ; then
476 AC_DEFINE(ENABLE_DF_CHECKING, 1,
477 [Define if you want more run-time sanity checks for dataflow.])
479 if test x$ac_assert_checking != x ; then
480 AC_DEFINE(ENABLE_ASSERT_CHECKING, 1,
481 [Define if you want assertions enabled. This is a cheap check.])
483 if test x$ac_gimple_checking != x ; then
484 AC_DEFINE(ENABLE_GIMPLE_CHECKING, 1,
485 [Define if you want operations on GIMPLE (the basic data structure of
486 the high-level optimizers) to be checked for dynamic type safety at
487 runtime. This is moderately expensive.])
489 GCC_TARGET_TEMPLATE(ENABLE_RUNTIME_CHECKING)
490 if test x$ac_runtime_checking != x ; then
491 AC_DEFINE(ENABLE_RUNTIME_CHECKING, 1,
492 [Define if you want runtime assertions enabled. This is a cheap check.])
494 if test x$ac_tree_checking != x ; then
495 AC_DEFINE(ENABLE_TREE_CHECKING, 1,
496 [Define if you want all operations on trees (the basic data
497 structure of the front ends) to be checked for dynamic type safety
498 at runtime. This is moderately expensive. The tree browser debugging
499 routines will also be enabled by this option.
501 TREEBROWSER=tree-browser.o
504 if test x$ac_types_checking != x ; then
505 AC_DEFINE(ENABLE_TYPES_CHECKING, 1,
506 [Define if you want all gimple types to be verified after gimplifiation.
510 AC_SUBST(TREEBROWSER)
511 AC_SUBST(TREECHECKING)
512 if test x$ac_rtl_checking != x ; then
513 AC_DEFINE(ENABLE_RTL_CHECKING, 1,
514 [Define if you want all operations on RTL (the basic data structure
515 of the optimizer and back end) to be checked for dynamic type safety
516 at runtime. This is quite expensive.])
518 if test x$ac_rtlflag_checking != x ; then
519 AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
520 [Define if you want RTL flag accesses to be checked against the RTL
521 codes that are supported for each access macro. This is relatively
524 if test x$ac_gc_checking != x ; then
525 AC_DEFINE(ENABLE_GC_CHECKING, 1,
526 [Define if you want the garbage collector to do object poisoning and
527 other memory allocation checks. This is quite expensive.])
529 if test x$ac_gc_always_collect != x ; then
530 AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
531 [Define if you want the garbage collector to operate in maximally
532 paranoid mode, validating the entire heap and collecting garbage at
533 every opportunity. This is extremely expensive.])
535 if test x$ac_fold_checking != x ; then
536 AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
537 [Define if you want fold checked that it never destructs its argument.
538 This is quite expensive.])
540 valgrind_path_defines=
543 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
544 dnl # an if statement. This was the source of very frustrating bugs
545 dnl # in converting to autoconf 2.5x!
546 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
548 # It is certainly possible that there's valgrind but no valgrind.h.
549 # GCC relies on making annotations so we must have both.
550 AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
551 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
552 [[#include <valgrind/memcheck.h>
553 #ifndef VALGRIND_DISCARD
554 #error VALGRIND_DISCARD not defined
556 [gcc_cv_header_valgrind_memcheck_h=yes],
557 [gcc_cv_header_valgrind_memcheck_h=no])
558 AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
559 AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
560 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
561 [[#include <memcheck.h>
562 #ifndef VALGRIND_DISCARD
563 #error VALGRIND_DISCARD not defined
565 [gcc_cv_header_memcheck_h=yes],
566 [gcc_cv_header_memcheck_h=no])
567 AC_MSG_RESULT($gcc_cv_header_memcheck_h)
568 if test $gcc_cv_header_valgrind_memcheck_h = yes; then
569 AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
570 [Define if valgrind's valgrind/memcheck.h header is installed.])
572 if test $gcc_cv_header_memcheck_h = yes; then
573 AC_DEFINE(HAVE_MEMCHECK_H, 1,
574 [Define if valgrind's memcheck.h header is installed.])
577 if test x$ac_valgrind_checking != x ; then
578 AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
579 [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
580 if test "x$valgrind_path" = "x" \
581 || (test $have_valgrind_h = no \
582 && test $gcc_cv_header_memcheck_h = no \
583 && test $gcc_cv_header_valgrind_memcheck_h = no); then
584 AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
586 valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
587 valgrind_command="$valgrind_path -q"
588 AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
589 [Define if you want to run subprograms and generated programs
590 through valgrind (a memory checker). This is extremely expensive.])
592 AC_SUBST(valgrind_path_defines)
593 AC_SUBST(valgrind_command)
595 # Enable code coverage collection
596 AC_ARG_ENABLE(coverage,
597 [AS_HELP_STRING([[--enable-coverage[=LEVEL]]],
598 [enable compiler's code coverage collection.
599 Use to measure compiler performance and locate
600 unused parts of the compiler. With LEVEL, specify
601 optimization. Values are opt, noopt,
603 [case "${enableval}" in
605 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
608 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
611 # a.k.a. --disable-coverage
615 AC_MSG_ERROR(unknown coverage setting $enableval)
619 AC_SUBST(coverage_flags)
621 AC_ARG_ENABLE(gather-detailed-mem-stats,
622 [AS_HELP_STRING([--enable-gather-detailed-mem-stats],
623 [enable detailed memory allocation stats gathering])], [],
624 [enable_gather_detailed_mem_stats=no])
625 gather_stats=`if test $enable_gather_detailed_mem_stats != no; then echo 1; else echo 0; fi`
626 AC_DEFINE_UNQUOTED(GATHER_STATISTICS, $gather_stats,
627 [Define to enable detailed memory allocation stats gathering.])
629 AC_ARG_ENABLE(valgrind-annotations,
630 [AS_HELP_STRING([--enable-valgrind-annotations],
631 [enable valgrind runtime interaction])], [],
632 [enable_valgrind_annotations=no])
633 if test x$enable_valgrind_annotations != xno \
634 || test x$ac_valgrind_checking != x; then
635 if (test $have_valgrind_h = no \
636 && test $gcc_cv_header_memcheck_h = no \
637 && test $gcc_cv_header_valgrind_memcheck_h = no); then
638 AC_MSG_ERROR([*** Can't find valgrind/memcheck.h, memcheck.h or valgrind.h])
640 AC_DEFINE(ENABLE_VALGRIND_ANNOTATIONS, 1,
641 [Define to get calls to the valgrind runtime enabled.])
644 # -------------------------------
645 # Miscenalleous configure options
646 # -------------------------------
650 [AS_HELP_STRING([--with-stabs],
651 [arrange to use stabs instead of host debug format])],
655 # Determine whether or not multilibs are enabled.
656 AC_ARG_ENABLE(multilib,
657 [AS_HELP_STRING([--enable-multilib],
658 [enable library support for multiple ABIs])],
659 [], [enable_multilib=yes])
660 AC_SUBST(enable_multilib)
662 # Determine whether or not multiarch is enabled.
663 AC_ARG_ENABLE(multiarch,
664 [AS_HELP_STRING([--enable-multiarch],
665 [enable support for multiarch paths])],
666 [case "${enableval}" in
667 yes|no|auto) enable_multiarch=$enableval;;
668 *) AC_MSG_ERROR(bad value ${enableval} given for --enable-multiarch option) ;;
669 esac], [enable_multiarch=auto])
670 if test x${enable_multiarch} = xauto; then
671 if test x${with_native_system_header_dir} != x; then
672 ma_msg_suffix=", disabled auto check (configured with --native-system-header-dir)"
675 if test x$host != x$target && test "x$with_sysroot" = x; then
676 ma_msg_suffix=", disabled auto check (cross build configured without --with-sysroot)"
680 AC_MSG_CHECKING(for multiarch configuration)
681 AC_SUBST(enable_multiarch)
682 AC_MSG_RESULT($enable_multiarch$ma_msg_suffix)
684 # needed for setting the multiarch name for soft-float/hard-float ABIs
688 # Enable __cxa_atexit for C++.
689 AC_ARG_ENABLE(__cxa_atexit,
690 [AS_HELP_STRING([--enable-__cxa_atexit], [enable __cxa_atexit for C++])],
693 # Enable C extension for decimal float if target supports it.
694 GCC_AC_ENABLE_DECIMAL_FLOAT([$target])
696 dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi`
697 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp,
698 [Define to 1 to enable decimal float extension to C.])
700 # Use default_decimal_float for dependency.
701 enable_decimal_float=$default_decimal_float
703 bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi`
704 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid,
705 [Define to 1 to specify that we are using the BID decimal floating
706 point format instead of DPD])
708 # Enable C extension for fixed-point arithmetic.
709 AC_ARG_ENABLE(fixed-point,
710 [AS_HELP_STRING([--enable-fixed-point],
711 [enable fixed-point arithmetic extension to C])],
716 enable_fixed_point=yes
720 enable_fixed_point=yes
723 AC_MSG_WARN([fixed-point is not supported for this target, ignored])
724 enable_fixed_point=no
728 AC_SUBST(enable_fixed_point)
730 fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi`
731 AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint,
732 [Define to 1 to enable fixed-point arithmetic extension to C.])
735 # Pass with no value to take the default
736 # Pass with a value to specify a thread package
737 AC_ARG_ENABLE(threads,
738 [AS_HELP_STRING([[--enable-threads[=LIB]]],
739 [enable thread usage for target GCC,
740 using LIB thread package])],,
744 [AS_HELP_STRING([--enable-tls],
745 [enable or disable generation of tls code
746 overriding the assembler check for tls support])],
750 *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
751 Valid choices are 'yes' and 'no'.]) ;;
755 AC_ARG_ENABLE(objc-gc,
756 [AS_HELP_STRING([--enable-objc-gc],
757 [enable the use of Boehm's garbage collector with
758 the GNU Objective-C runtime])],
759 if test x$enable_objc_gc = xno; then
767 [AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2])],
768 dwarf2="$with_dwarf2",
771 AC_ARG_ENABLE(shared,
772 [AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])],
774 case $enable_shared in
778 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
779 for pkg in $enableval; do
780 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
787 ], [enable_shared=yes])
788 AC_SUBST(enable_shared)
790 AC_ARG_WITH([native-system-header-dir],
791 [ --with-native-system-header-dir=dir
792 use dir as the directory to look for standard
793 system header files in. Defaults to /usr/include.],
795 case ${with_native_system_header_dir} in
796 yes|no) AC_MSG_ERROR([bad value ${withval} given for --with-native-system-header-dir]) ;;
797 /* | [[A-Za-z]]:[[\\/]]*) ;;
798 *) AC_MSG_ERROR([--with-native-system-header-dir argument ${withval} must be an absolute directory]) ;;
800 configured_native_system_header_dir="${withval}"
801 ], [configured_native_system_header_dir=])
803 AC_ARG_WITH(build-sysroot,
804 [AS_HELP_STRING([--with-build-sysroot=sysroot],
805 [use sysroot as the system root during the build])],
806 [if test x"$withval" != x ; then
807 SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
809 [SYSROOT_CFLAGS_FOR_TARGET=])
810 AC_SUBST(SYSROOT_CFLAGS_FOR_TARGET)
812 if test "x$prefix" = xNONE; then
813 test_prefix=/usr/local
817 if test "x$exec_prefix" = xNONE; then
818 test_exec_prefix=$test_prefix
820 test_exec_prefix=$exec_prefix
824 [AS_HELP_STRING([[--with-sysroot[=DIR]]],
825 [search for usr/lib, usr/include, et al, within DIR])],
827 case ${with_sysroot} in
828 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
829 *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
832 TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
833 CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
835 case ${TARGET_SYSTEM_ROOT} in
836 "${test_prefix}"|"${test_prefix}/"*|\
837 "${test_exec_prefix}"|"${test_exec_prefix}/"*|\
838 '${prefix}'|'${prefix}/'*|\
839 '${exec_prefix}'|'${exec_prefix}/'*)
840 t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
841 TARGET_SYSTEM_ROOT_DEFINE="$t"
846 TARGET_SYSTEM_ROOT_DEFINE=
847 CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
849 AC_SUBST(TARGET_SYSTEM_ROOT)
850 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
851 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
854 [AS_HELP_STRING([--with-specs=SPECS],
855 [add SPECS to driver command-line processing])],
856 [CONFIGURE_SPECS=$withval],
859 AC_SUBST(CONFIGURE_SPECS)
861 ACX_PKGVERSION([GCC])
862 ACX_BUGURL([http://gcc.gnu.org/bugs.html])
864 # Sanity check enable_languages in case someone does not run the toplevel
865 # configure # script.
866 AC_ARG_ENABLE(languages,
867 [AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])],
868 [case ,${enable_languages}, in
870 # go safe -- we cannot be much sure without the toplevel
872 # analysis of which target libs are present and usable
876 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
881 enable_languages=c,${enable_languages}
884 [enable_languages=c])
886 AC_ARG_WITH(multilib-list,
887 [AS_HELP_STRING([--with-multilib-list], [select multilibs (AArch64, SH and x86-64 only)])],
889 with_multilib_list=default)
891 # -------------------------
892 # Checks for other programs
893 # -------------------------
897 # Find some useful tools
899 # We need awk to create options.c and options.h.
900 # Bail out if it's missing.
902 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
909 AC_SUBST(ranlib_flags)
913 # See if cmp has --ignore-initial.
914 gcc_AC_PROG_CMP_IGNORE_INITIAL
916 # See if we have the mktemp command.
917 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
919 # See if makeinfo has been installed and is modern enough
920 # that we can use it.
921 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
922 [GNU texinfo.* \([0-9][0-9.]*\)],
923 [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
924 if test $gcc_cv_prog_makeinfo_modern = no; then
926 *** Makeinfo is missing or too old.
927 *** Info documentation will not be built.])
934 # Is pod2man recent enough to regenerate manpages?
935 AC_MSG_CHECKING([for recent Pod::Man])
936 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
938 GENERATED_MANPAGES=generated-manpages
943 AC_SUBST(GENERATED_MANPAGES)
945 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
948 dnl Don't use AC_PROG_LEX; we insist on flex.
949 dnl LEXLIB is not useful in gcc.
950 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
953 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
955 # Binutils are not build modules, unlike bison/flex/makeinfo. So we
956 # check for build == host before using them.
959 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
960 && test -d ../binutils ; then
961 NM='${objdir}/../binutils/nm-new'
963 AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
967 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
968 && test -d ../binutils ; then
969 AR='${objdir}/../binutils/ar'
971 AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
974 # The jit documentation looks better if built with sphinx, but can be
975 # built with texinfo if sphinx is not available.
976 # Set "doc_build_sys" to "sphinx" or "texinfo" accordingly.
977 AC_CHECK_PROG(doc_build_sys, sphinx-build, sphinx, texinfo)
979 # --------------------
980 # Checks for C headers
981 # --------------------
983 # Need to reject headers which give warnings, so that the -Werror bootstrap
984 # works later. *sigh* This needs to come before all header checks.
992 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
993 fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
994 sys/resource.h sys/param.h sys/times.h sys/stat.h \
995 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
997 # Check for thread headers.
998 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
999 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
1001 # These tests can't be done till we know if we have limits.h.
1005 # ----------------------
1006 # Checks for C++ headers
1007 # ----------------------
1009 dnl Autoconf will give an error in the configure script if there is no
1010 dnl C++ preprocessor. Hack to prevent that.
1011 m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl
1013 m4_popdef([AC_MSG_ERROR])[]dnl
1017 AC_CHECK_HEADERS(unordered_map)
1018 AC_CHECK_HEADERS(tr1/unordered_map)
1019 AC_CHECK_HEADERS(ext/hash_map)
1024 # Dependency checking.
1029 AC_CONFIG_COMMANDS([gccdepdir],[
1030 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs build/$DEPDIR
1031 for lang in $subdirs c-family common
1033 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs $lang/$DEPDIR
1034 done], [subdirs="$subdirs" ac_aux_dir=$ac_aux_dir DEPDIR=$DEPDIR])
1036 ZW_PROG_COMPILER_DEPENDENCIES([CXX])
1044 # These libraries may be used by collect2.
1045 # We may need a special search path to get them linked.
1046 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
1048 for libs in '' -lld -lmld \
1049 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
1050 '-L/usr/lib/cmplrs/cc3.11 -lmld'
1053 AC_TRY_LINK_FUNC(ldopen,
1054 [gcc_cv_collect2_libs="$libs"; break])
1057 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
1058 case $gcc_cv_collect2_libs in
1060 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
1062 AC_SUBST(COLLECT2_LIBS)
1064 # When building Ada code on Alpha, we need exc_resume which is usually in
1065 # -lexc. So test for it.
1068 AC_SEARCH_LIBS(exc_resume, exc)
1071 AC_SUBST(GNAT_LIBEXC)
1073 # To support -mcpu=native on Solaris/SPARC, we need libkstat.
1076 AC_SEARCH_LIBS(kstat_open, kstat)
1077 EXTRA_GCC_LIBS="$LIBS"
1079 AC_SUBST(EXTRA_GCC_LIBS)
1081 # Some systems put ldexp and frexp in libm instead of libc; assume
1082 # they're both in the same place. jcf-dump needs them.
1085 AC_SEARCH_LIBS(ldexp, m)
1090 # Use <inttypes.h> only if it exists,
1091 # doesn't clash with <sys/types.h>, declares intmax_t and defines
1093 AC_MSG_CHECKING(for inttypes.h)
1094 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
1095 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1096 [[#define __STDC_FORMAT_MACROS
1097 #include <sys/types.h>
1098 #include <inttypes.h>]],
1103 [gcc_cv_header_inttypes_h=yes],
1104 [gcc_cv_header_inttypes_h=no])])
1105 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
1106 if test $gcc_cv_header_inttypes_h = yes; then
1107 AC_DEFINE(HAVE_INTTYPES_H, 1,
1108 [Define if you have a working <inttypes.h> header file.])
1111 dnl Disabled until we have a complete test for buggy enum bitfields.
1112 dnl gcc_AC_C_ENUM_BF_UNSIGNED
1114 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
1115 ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
1116 fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
1117 fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
1118 putchar_unlocked putc_unlocked)
1119 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoll atoq \
1120 popen sysconf strsignal getrusage nl_langinfo \
1121 gettimeofday mbstowcs wcswidth mmap setlocale \
1122 gcc_UNLOCKED_FUNCS madvise)
1124 if test x$ac_cv_func_mbstowcs = xyes; then
1125 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
1126 [ AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
1132 [gcc_cv_func_mbstowcs_works=yes],
1133 [gcc_cv_func_mbstowcs_works=no],
1134 [gcc_cv_func_mbstowcs_works=yes])])
1135 if test x$gcc_cv_func_mbstowcs_works = xyes; then
1136 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
1137 [Define this macro if mbstowcs does not crash when its
1138 first argument is NULL.])
1142 AC_CHECK_TYPE(ssize_t, int)
1143 AC_CHECK_TYPE(caddr_t, char *)
1145 GCC_AC_FUNC_MMAP_BLACKLIST
1149 # Under VMS, vfork works very differently than on Unix. The standard test
1150 # won't work, and it isn't easily adaptable. It makes more sense to
1152 ac_cv_func_vfork_works=yes
1157 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which exposes a different
1158 # iconv() prototype.
1163 # Until we have in-tree GNU iconv:
1165 AC_SUBST(LIBICONV_DEP)
1171 # We will need to find libiberty.h and ansidecl.h
1172 saved_CFLAGS="$CFLAGS"
1173 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1174 saved_CXXFLAGS="$CXXFLAGS"
1175 CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1176 gcc_AC_CHECK_DECLS(getenv atol asprintf sbrk abort atof getcwd getwd \
1177 stpcpy strnlen strsignal strstr strverscmp \
1178 errno snprintf vsnprintf vasprintf malloc realloc calloc \
1179 free basename getopt clock getpagesize ffs gcc_UNLOCKED_FUNCS, , ,[
1180 #include "ansidecl.h"
1181 #include "system.h"])
1183 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1184 #include "ansidecl.h"
1186 #ifdef HAVE_SYS_RESOURCE_H
1187 #include <sys/resource.h>
1191 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1192 #include "ansidecl.h"
1194 #ifdef HAVE_SYS_RESOURCE_H
1195 #include <sys/resource.h>
1197 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1198 [Define to `long' if <sys/resource.h> doesn't define.])])
1200 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1201 # FREAD and FWRITE macros. Fortunately, for GCC's single usage of ldgetname
1202 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1203 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1204 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1205 #include "ansidecl.h"
1214 gcc_AC_CHECK_DECLS(times, , ,[
1215 #include "ansidecl.h"
1217 #ifdef HAVE_SYS_TIMES_H
1218 #include <sys/times.h>
1222 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1223 #include "ansidecl.h"
1228 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which hides the madvise()
1231 gcc_AC_CHECK_DECLS(madvise, , ,[
1232 #include "ansidecl.h"
1237 # More time-related stuff.
1238 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1239 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1240 #include "ansidecl.h"
1242 #ifdef HAVE_SYS_TIMES_H
1243 #include <sys/times.h>
1245 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1246 if test $ac_cv_struct_tms = yes; then
1247 AC_DEFINE(HAVE_STRUCT_TMS, 1,
1248 [Define if <sys/times.h> defines struct tms.])
1251 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1252 # revisit after autoconf 2.50.
1253 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1254 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1255 #include "ansidecl.h"
1257 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1258 if test $gcc_cv_type_clock_t = yes; then
1259 AC_DEFINE(HAVE_CLOCK_T, 1,
1260 [Define if <time.h> defines clock_t.])
1263 # Check if F_SETLKW is supported by fcntl.
1264 AC_CACHE_CHECK(for F_SETLKW, ac_cv_f_setlkw, [
1265 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1266 #include <fcntl.h>]], [[
1272 return fcntl (1, F_SETLKW, &fl);]])],
1273 [ac_cv_f_setlkw=yes],[ac_cv_f_setlkw=no])])
1274 if test $ac_cv_f_setlkw = yes; then
1275 AC_DEFINE(HOST_HAS_F_SETLKW, 1,
1276 [Define if F_SETLKW supported by fcntl.])
1279 # Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1280 CFLAGS="$saved_CFLAGS"
1281 CXXFLAGS="$saved_CXXFLAGS"
1283 # mkdir takes a single argument on some systems.
1284 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1292 # With Setjmp/Longjmp based exception handling.
1293 AC_ARG_ENABLE(sjlj-exceptions,
1294 [AS_HELP_STRING([--enable-sjlj-exceptions],
1295 [arrange to use setjmp/longjmp exception handling])],
1298 if test $enableval != yes; then
1299 AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1304 force_sjlj_exceptions=yes],
1307 force_sjlj_exceptions=yes
1311 force_sjlj_exceptions=yes
1315 force_sjlj_exceptions=no
1318 if test $force_sjlj_exceptions = yes; then
1319 sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1320 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1321 [Define 0/1 to force the choice for exception handling model.])
1324 # --------------------------------------------------------
1325 # Build, host, and target specific configuration fragments
1326 # --------------------------------------------------------
1328 # Collect build-machine-specific information.
1329 . ${srcdir}/config.build
1331 # Collect host-machine-specific information.
1332 . ${srcdir}/config.host
1336 # Collect target-machine-specific information.
1337 . ${srcdir}/config.gcc
1339 extra_objs="${host_extra_objs} ${extra_objs}"
1340 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1342 # Default the target-machine variables that were not explicitly set.
1343 if test x"$tm_file" = x
1344 then tm_file=$cpu_type/$cpu_type.h; fi
1346 if test x"$extra_headers" = x
1347 then extra_headers=; fi
1349 if test x$md_file = x
1350 then md_file=$cpu_type/$cpu_type.md; fi
1352 if test x$out_file = x
1353 then out_file=$cpu_type/$cpu_type.c; fi
1355 if test x"$tmake_file" = x
1356 then tmake_file=$cpu_type/t-$cpu_type
1359 # Support --enable-initfini-array.
1360 if test x$enable_initfini_array != xno; then
1361 tm_file="${tm_file} initfini-array.h"
1364 if test x"$dwarf2" = xyes
1365 then tm_file="$tm_file tm-dwarf2.h"
1368 # Say what files are being used for the output code and MD file.
1369 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1370 echo "Using \`$srcdir/config/$md_file' as machine description file."
1372 # If any of the xm_file variables contain nonexistent files, warn
1373 # about them and drop them.
1376 for x in $build_xm_file; do
1377 if test -f $srcdir/config/$x
1379 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1385 for x in $host_xm_file; do
1386 if test -f $srcdir/config/$x
1388 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1394 for x in $xm_file; do
1395 if test -f $srcdir/config/$x
1397 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1403 for f in $tm_file; do
1406 if test $count = ax; then
1407 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1409 echo "Using the following target machine macro files:"
1410 for f in $tm_file; do
1411 echo " $srcdir/config/$f"
1415 if test x$use_long_long_for_widest_fast_int = xyes; then
1416 AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1417 [Define to 1 if the 'long long' type is wider than 'long' but still
1418 efficiently supported by the host hardware.])
1421 gnu_ld_bool=`if test x"$gnu_ld" = x"yes"; then echo 1; else echo 0; fi`
1422 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld_bool, [Define to 1 if using GNU ld.])
1424 gnu_as_bool=`if test x"$gas" = x"yes"; then echo 1; else echo 0; fi`
1425 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as_bool, [Define to 1 if using GNU as.])
1428 for f in $host_xm_file; do
1431 if test $count = a; then
1433 elif test $count = ax; then
1434 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1436 echo "Using the following host machine macro files:"
1437 for f in $host_xm_file; do
1438 echo " $srcdir/config/$f"
1441 echo "Using ${out_host_hook_obj} for host machine hooks."
1443 if test "$host_xm_file" != "$build_xm_file"; then
1445 for f in $build_xm_file; do
1448 if test $count = a; then
1450 elif test $count = ax; then
1451 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1453 echo "Using the following build machine macro files:"
1454 for f in $build_xm_file; do
1455 echo " $srcdir/config/$f"
1460 if test -n "$configured_native_system_header_dir"; then
1461 native_system_header_dir=$configured_native_system_header_dir
1463 NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir"
1464 AC_SUBST(NATIVE_SYSTEM_HEADER_DIR)
1468 AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1469 gcc_cv_mcontext_underscores,
1471 #include <sys/cdefs.h>
1472 #include <sys/signal.h>
1473 #include <ucontext.h>
1474 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1476 gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1477 if test $gcc_cv_mcontext_underscores = yes; then
1478 AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1479 [mcontext_t fields start with __])
1488 # Check if a valid thread package
1489 case ${enable_threads} in
1492 target_thread_file='single'
1496 target_thread_file='single'
1498 aix | dce | lynx | mipssde | posix | rtems | \
1499 single | tpf | vxworks | win32)
1500 target_thread_file=${enable_threads}
1503 echo "${enable_threads} is an unknown thread package" 1>&2
1508 if test x${thread_file} = x; then
1509 # No thread file set by target-specific clauses in config.gcc,
1510 # so use file chosen by default logic above
1511 thread_file=${target_thread_file}
1519 if test x$enable___cxa_atexit = xyes || \
1520 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1521 if test x$host = x$target; then
1523 # mingw32 doesn't have __cxa_atexit but uses atexit registration
1524 # keyed to flag_use_cxa_atexit
1532 AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1533 [echo "__cxa_atexit can't be enabled on this target"])
1537 # We can't check for __cxa_atexit when building a cross, so assume
1541 if test x$use_cxa_atexit = xyes; then
1542 AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1543 [Define if you want to use __cxa_atexit, rather than atexit, to
1544 register C++ destructors for local statics and global objects.
1545 This is essential for fully standards-compliant handling of
1546 destructors, but requires __cxa_atexit in libc.])
1550 # Look for a file containing extra machine modes.
1551 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1552 extra_modes_file='$(srcdir)'/config/${extra_modes}
1553 AC_SUBST(extra_modes_file)
1554 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1555 [Define to the name of a file containing a list of extra machine modes
1556 for this architecture.])
1559 # Convert extra_options into a form suitable for Makefile use.
1562 for f in $extra_options; do
1563 extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1564 all_opt_files="$all_opt_files $srcdir/config/$f"
1566 AC_SUBST(extra_opt_files)
1568 # auto-host.h is the file containing items generated by autoconf and is
1569 # the first file included by config.h.
1570 # If host=build, it is correct to have bconfig include auto-host.h
1571 # as well. If host!=build, we are in error and need to do more
1572 # work to find out the build config parameters.
1573 if test x$host = x$build
1575 build_auto=auto-host.h
1577 # We create a subdir, then run autoconf in the subdir.
1578 # To prevent recursion we set host and build for the new
1579 # invocation of configure to the build for this invocation
1586 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1587 *) realsrcdir=../${srcdir};;
1589 # Clearing GMPINC is necessary to prevent host headers being
1590 # used by the build compiler. Defining GENERATOR_FILE stops
1591 # system.h from including gmp.h.
1592 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1593 CXX="${CXX_FOR_BUILD}" CXXFLAGS="${CXXFLAGS_FOR_BUILD}" \
1594 LD="${LD_FOR_BUILD}" LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1595 GMPINC="" CPPFLAGS="${CPPFLAGS} -DGENERATOR_FILE" \
1596 ${realsrcdir}/configure \
1597 --enable-languages=${enable_languages-all} \
1598 --target=$target_alias --host=$build_alias --build=$build_alias
1600 # We just finished tests for the build machine, so rename
1601 # the file auto-build.h in the gcc directory.
1602 mv auto-host.h ../auto-build.h
1605 build_auto=auto-build.h
1607 AC_SUBST(build_subdir)
1609 tm_file="${tm_file} defaults.h"
1610 tm_p_file="${tm_p_file} tm-preds.h"
1611 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1612 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1613 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1614 # put this back in temporarily.
1615 xm_file="auto-host.h ansidecl.h ${xm_file}"
1622 # Compile in configure arguments.
1623 if test -f configargs.h ; then
1624 # Being re-configured.
1625 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1626 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1628 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1631 # Double all backslashes and backslash all quotes to turn
1632 # gcc_config_arguments into a C string.
1633 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1634 $gcc_config_arguments
1636 gcc_config_arguments_str=`cat conftest.out`
1639 cat > configargs.h <<EOF
1640 /* Generated automatically. */
1641 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1642 static const char thread_model[] = "$thread_file";
1644 static const struct {
1645 const char *name, *value;
1646 } configure_default_options[] = $configure_default_options;
1651 gcc_BASEVER=`cat $srcdir/BASE-VER`
1652 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
1653 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
1654 if test -f $srcdir/REVISION ; then
1655 gcc_REVISION=`cat $srcdir/REVISION`
1659 cat > plugin-version.h <<EOF
1660 #include "configargs.h"
1662 #define GCCPLUGIN_VERSION_MAJOR `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'`
1663 #define GCCPLUGIN_VERSION_MINOR `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'`
1664 #define GCCPLUGIN_VERSION_PATCHLEVEL `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'`
1665 #define GCCPLUGIN_VERSION (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR)
1667 static char basever[] = "$gcc_BASEVER";
1668 static char datestamp[] = "$gcc_DATESTAMP";
1669 static char devphase[] = "$gcc_DEVPHASE";
1670 static char revision[] = "$gcc_REVISION";
1672 /* FIXME plugins: We should make the version information more precise.
1673 One way to do is to add a checksum. */
1675 static struct plugin_gcc_version gcc_version = {basever, datestamp,
1677 configuration_arguments};
1681 # Internationalization
1682 ZW_GNU_GETTEXT_SISTER_DIR
1684 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1685 # -liconv on the link line twice.
1686 case "$LIBINTL" in *$LIBICONV*)
1690 AC_ARG_ENABLE(secureplt,
1691 [AS_HELP_STRING([--enable-secureplt],
1692 [enable -msecure-plt by default for PowerPC])],
1695 AC_ARG_ENABLE(leading-mingw64-underscores,
1696 AS_HELP_STRING([--enable-leading-mingw64-underscores],
1697 [enable leading underscores on 64 bit mingw targets]),
1699 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
1700 [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
1701 [Define if we should use leading underscore on 64 bit mingw targets])])
1704 [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [],
1707 AC_ARG_ENABLE(frame-pointer,
1708 [AS_HELP_STRING([--enable-frame-pointer],
1709 [enable -fno-omit-frame-pointer by default for 32bit x86])], [],
1712 linux* | darwin[[8912]]*)
1713 # Enable -fomit-frame-pointer by default for Linux and Darwin with
1715 enable_frame_pointer=no
1718 enable_frame_pointer=yes
1723 # Windows32 Registry support for specifying GCC installation paths.
1724 AC_ARG_ENABLE(win32-registry,
1725 [AS_HELP_STRING([--disable-win32-registry],
1726 [disable lookup of installation paths in the
1727 Registry on Windows hosts])
1728 AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)])
1729 AS_HELP_STRING([--enable-win32-registry=KEY],
1730 [use KEY instead of GCC version as the last portion
1731 of the registry key])],,)
1734 win32 | pe | cygwin* | mingw32* | uwin*)
1735 if test "x$enable_win32_registry" != xno; then
1736 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1739 if test "x$enable_win32_registry" != xno; then
1740 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1741 [Define to 1 if installation paths should be looked up in the Windows
1742 Registry. Ignored on non-Windows hosts.])
1744 if test "x$enable_win32_registry" != xyes \
1745 && test "x$enable_win32_registry" != x; then
1746 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1747 [Define to be the last component of the Windows registry key under which
1748 to look for installation paths. The full key used will be
1749 HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1750 The default is the GCC version number.])
1756 # Get an absolute path to the GCC top-level source directory
1757 holddir=`${PWDCMD-pwd}`
1759 topdir=`${PWDCMD-pwd}`
1762 # Conditionalize the makefile for this host machine.
1764 for f in ${host_xmake_file}
1766 if test -f ${srcdir}/config/$f
1768 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1772 # Conditionalize the makefile for this target machine.
1774 for f in ${tmake_file}
1776 if test -f ${srcdir}/config/$f
1778 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1781 tmake_file="${tmake_file_}"
1783 out_object_file=`basename $out_file .c`.o
1784 common_out_object_file=`basename $common_out_file .c`.o
1786 tm_file_list="options.h"
1787 tm_include_list="options.h insn-constants.h"
1788 for f in $tm_file; do
1791 f=`echo $f | sed 's/^..//'`
1792 tm_file_list="${tm_file_list} $f"
1793 tm_include_list="${tm_include_list} $f"
1796 tm_file_list="${tm_file_list} \$(srcdir)/$f"
1797 tm_include_list="${tm_include_list} $f"
1800 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1801 tm_include_list="${tm_include_list} config/$f"
1808 for f in $tm_p_file; do
1811 tm_p_file_list="${tm_p_file_list} $f"
1812 tm_p_include_list="${tm_p_include_list} $f"
1815 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1816 tm_p_include_list="${tm_p_include_list} config/$f"
1822 for f in $xm_file; do
1825 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1826 xm_include_list="${xm_include_list} $f"
1829 xm_file_list="${xm_file_list} $f"
1830 xm_include_list="${xm_include_list} $f"
1833 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1834 xm_include_list="${xm_include_list} config/$f"
1840 host_xm_include_list=
1841 for f in $host_xm_file; do
1844 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1845 host_xm_include_list="${host_xm_include_list} $f"
1848 host_xm_file_list="${host_xm_file_list} $f"
1849 host_xm_include_list="${host_xm_include_list} $f"
1852 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1853 host_xm_include_list="${host_xm_include_list} config/$f"
1859 for f in $build_xm_file; do
1862 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1863 build_xm_include_list="${build_xm_include_list} $f"
1865 auto-build.h | auto-host.h )
1866 build_xm_file_list="${build_xm_file_list} $f"
1867 build_xm_include_list="${build_xm_include_list} $f"
1870 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1871 build_xm_include_list="${build_xm_include_list} config/$f"
1876 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1877 # cross-compiler which does not use the native headers and libraries.
1878 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1879 CROSS= AC_SUBST(CROSS)
1880 ALL=all.internal AC_SUBST(ALL)
1881 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1883 if test "x$with_build_sysroot" != x; then
1884 build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1886 # This value is used, even on a native system, because
1887 # CROSS_SYSTEM_HEADER_DIR is just
1888 # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1889 build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1892 if test x$host != x$target
1894 CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1896 SYSTEM_HEADER_DIR=$build_system_header_dir
1897 case "$host","$target" in
1898 # Darwin crosses can use the host system's libraries and headers,
1899 # because of the fat library support. Of course, it must be the
1900 # same version of Darwin on both sides. Allow the user to
1901 # just say --target=foo-darwin without a version number to mean
1902 # "the version on this system".
1903 *-*-darwin*,*-*-darwin*)
1904 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1905 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1906 if test $hostos = $targetos -o $targetos = darwin ; then
1908 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1913 i?86-*-*,x86_64-*-* \
1914 | powerpc*-*-*,powerpc64*-*-*)
1915 CROSS="$CROSS -DNATIVE_CROSS" ;;
1920 if test "x$with_headers" = x; then
1927 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1928 SYSTEM_HEADER_DIR=$build_system_header_dir
1931 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
1932 if test "x$with_headers" != x; then
1933 target_header_dir=$with_headers
1934 elif test "x$with_sysroot" = x; then
1935 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include"
1936 elif test "x$with_build_sysroot" != "x"; then
1937 target_header_dir="${with_build_sysroot}${native_system_header_dir}"
1938 elif test "x$with_sysroot" = xyes; then
1939 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
1941 target_header_dir="${with_sysroot}${native_system_header_dir}"
1944 target_header_dir=${native_system_header_dir}
1947 # If this is a cross-compiler that does not
1948 # have its own set of headers then define
1951 # If this is using newlib, without having the headers available now,
1952 # then define inhibit_libc in LIBGCC2_CFLAGS.
1953 # This prevents libgcc2 from containing any code which requires libc
1955 : ${inhibit_libc=false}
1956 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1957 test x$with_newlib = xyes ; } &&
1958 { test "x$with_headers" = xno || test ! -f "$target_header_dir/stdio.h"; } ; then
1961 AC_SUBST(inhibit_libc)
1963 # When building gcc with a cross-compiler, we need to adjust things so
1964 # that the generator programs are still built with the native compiler.
1965 # Also, we cannot run fixincludes.
1967 # These are the normal (build=host) settings:
1968 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
1969 CXX_FOR_BUILD='$(CXX)' AC_SUBST(CXX_FOR_BUILD)
1970 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
1971 BUILD_CXXFLAGS='$(ALL_CXXFLAGS)' AC_SUBST(BUILD_CXXFLAGS)
1972 BUILD_LDFLAGS='$(LDFLAGS)' AC_SUBST(BUILD_LDFLAGS)
1973 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
1975 # And these apply if build != host, or we are generating coverage data
1976 if test x$build != x$host || test "x$coverage_flags" != x
1978 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1979 BUILD_CXXFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CXXFLAGS_FOR_BUILD)'
1980 BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
1983 # Expand extra_headers to include complete path.
1984 # This substitutes for lots of t-* files.
1986 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1987 for file in ${extra_headers} ; do
1988 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1991 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
1992 if test x"$use_gcc_tgmath" = xyes
1993 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
1996 # Define collect2 in Makefile.
1997 case $host_can_use_collect2 in
1999 *) collect2='collect2$(exeext)' ;;
2001 AC_SUBST([collect2])
2003 # Add a definition of USE_COLLECT2 if system wants one.
2004 case $use_collect2 in
2005 no) use_collect2= ;;
2008 host_xm_defines="${host_xm_defines} USE_COLLECT2"
2009 xm_defines="${xm_defines} USE_COLLECT2"
2010 case $host_can_use_collect2 in
2012 AC_MSG_ERROR([collect2 is required but cannot be built on this system])
2018 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
2019 [Define to the name of the LTO plugin DSO that must be
2020 passed to the linker's -plugin=LIB option.])
2022 # ---------------------------
2023 # Assembler & linker features
2024 # ---------------------------
2026 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
2027 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
2028 # However when ld-new is first executed from the build tree, libtool will
2029 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
2030 # to the build tree. While doing this we need to use the previous-stage
2031 # linker, or we have an infinite loop. The presence of a shell script as
2032 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
2033 # the gcc/collect-ld script. So we need to know how libtool works, or
2034 # exec-tool will fail.
2036 m4_defun([_LT_CONFIG_COMMANDS], [])
2039 AC_SUBST(enable_fast_install)
2041 # Identify the assembler which will work hand-in-glove with the newly
2042 # built GCC, so that we can examine its features. This is the assembler
2043 # which will be driven by the driver program.
2045 # If build != host, and we aren't building gas in-tree, we identify a
2046 # build->target assembler and hope that it will have the same features
2047 # as the host->target assembler we'll be using.
2048 gcc_cv_gas_major_version=
2049 gcc_cv_gas_minor_version=
2050 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
2052 m4_pattern_allow([AS_FOR_TARGET])dnl
2053 AS_VAR_SET_IF(gcc_cv_as,, [
2054 if test -x "$DEFAULT_ASSEMBLER"; then
2055 gcc_cv_as="$DEFAULT_ASSEMBLER"
2056 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
2057 && test -f ../gas/Makefile \
2058 && test x$build = x$host; then
2059 gcc_cv_as=../gas/as-new$build_exeext
2060 elif test -x as$build_exeext; then
2061 # Build using assembler in the current directory.
2062 gcc_cv_as=./as$build_exeext
2063 elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then
2064 gcc_cv_as="$AS_FOR_TARGET"
2066 AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
2069 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
2070 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
2071 case "$ORIGINAL_AS_FOR_TARGET" in
2072 ./as | ./as$build_exeext) ;;
2073 *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
2076 AC_MSG_CHECKING(what assembler to use)
2077 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
2078 # Single tree build which includes gas. We want to prefer it
2079 # over whatever linker top-level may have detected, since
2080 # we'll use what we're building after installation anyway.
2081 AC_MSG_RESULT(newly built gas)
2083 _gcc_COMPUTE_GAS_VERSION
2084 in_tree_gas_is_elf=no
2085 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2086 || (grep 'obj_format = multi' ../gas/Makefile \
2087 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
2089 in_tree_gas_is_elf=yes
2092 AC_MSG_RESULT($gcc_cv_as)
2098 [[ --enable-ld[=ARG] build ld [ARG={default,yes,no}]]],
2099 [case "${enableval}" in
2105 install_gold_as_default=no
2107 [[ --enable-gold[=ARG] build gold [ARG={default,yes,no}]]],
2108 [case "${enableval}" in
2110 install_gold_as_default=yes
2113 if test x${default_ld} != x; then
2114 install_gold_as_default=yes
2120 AC_MSG_ERROR([invalid --enable-gold argument])
2124 # Identify the linker which will work hand-in-glove with the newly
2125 # built GCC, so that we can examine its features. This is the linker
2126 # which will be driven by the driver program.
2128 # If build != host, and we aren't building gas in-tree, we identify a
2129 # build->target linker and hope that it will have the same features
2130 # as the host->target linker we'll be using.
2131 gcc_cv_gld_major_version=
2132 gcc_cv_gld_minor_version=
2133 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
2134 gcc_cv_ld_gold_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gold
2135 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
2137 AS_VAR_SET_IF(gcc_cv_ld,, [
2138 if test -x "$DEFAULT_LINKER"; then
2139 gcc_cv_ld="$DEFAULT_LINKER"
2140 elif test $install_gold_as_default = yes \
2141 && test -f $gcc_cv_ld_gold_srcdir/configure.ac \
2142 && test -f ../gold/Makefile \
2143 && test x$build = x$host; then
2144 gcc_cv_ld=../gold/ld-new$build_exeext
2145 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
2146 && test -f ../ld/Makefile \
2147 && test x$build = x$host; then
2148 gcc_cv_ld=../ld/ld-new$build_exeext
2149 elif test -x collect-ld$build_exeext; then
2150 # Build using linker in the current directory.
2151 gcc_cv_ld=./collect-ld$build_exeext
2152 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
2153 gcc_cv_ld="$LD_FOR_TARGET"
2155 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
2158 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
2159 PLUGIN_LD_SUFFIX=`basename $gcc_cv_ld | sed -e "s,$target_alias-,,"`
2160 # if the PLUGIN_LD is set ld-new, just have it as ld
2161 # as that is the installed named.
2162 if test x$PLUGIN_LD_SUFFIX = xld-new \
2163 || test x$PLUGIN_LD_SUFFIX = xcollect-ld ; then
2166 AC_ARG_WITH(plugin-ld,
2167 [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])],
2168 [if test x"$withval" != x; then
2169 ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
2170 PLUGIN_LD_SUFFIX=`echo $withval | sed -e "s,$target_alias-,,"`
2172 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
2173 AC_DEFINE_UNQUOTED(PLUGIN_LD_SUFFIX, "$PLUGIN_LD_SUFFIX", [Specify plugin linker])
2175 # Check to see if we are using gold instead of ld
2176 AC_MSG_CHECKING(whether we are using gold)
2178 if test x$gcc_cv_ld != x; then
2179 if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2180 | grep "GNU gold" > /dev/null; then
2184 AC_MSG_RESULT($ld_is_gold)
2186 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
2187 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
2188 case "$ORIGINAL_LD_FOR_TARGET" in
2189 ./collect-ld | ./collect-ld$build_exeext) ;;
2190 *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
2193 AC_MSG_CHECKING(what linker to use)
2194 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \
2195 || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then
2196 # Single tree build which includes ld. We want to prefer it
2197 # over whatever linker top-level may have detected, since
2198 # we'll use what we're building after installation anyway.
2199 AC_MSG_RESULT(newly built ld)
2201 in_tree_ld_is_elf=no
2202 if (grep 'EMUL = .*elf' ../ld/Makefile \
2203 || grep 'EMUL = .*linux' ../ld/Makefile \
2204 || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
2205 in_tree_ld_is_elf=yes
2206 elif test "$ld_is_gold" = yes; then
2207 in_tree_ld_is_elf=yes
2209 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
2212 gcc_cv_gld_version=`sed -n -e 's/^[ ]*VERSION=[^0-9A-Za-z_]*\([0-9]*\.[0-9]*.*\)/VERSION=\1/p' < $f`
2213 if test x$gcc_cv_gld_version != x; then
2217 case $gcc_cv_gld_version in
2220 *) AC_MSG_ERROR([[cannot find version of in-tree linker]]) ;;
2223 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2224 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2226 ORIGINAL_LD_BFD_FOR_TARGET=../ld/ld-new$build_exeext
2227 ORIGINAL_LD_GOLD_FOR_TARGET=../gold/ld-new$build_exeext
2229 AC_MSG_RESULT($gcc_cv_ld)
2231 gcc_cvs_ld_program=`dirname $gcc_cv_ld`/`basename $gcc_cv_ld $host_exeext`
2232 ORIGINAL_LD_BFD_FOR_TARGET=${gcc_cvs_ld_program}.bfd$host_exeext
2233 ORIGINAL_LD_GOLD_FOR_TARGET=${gcc_cvs_ld_program}.gold$host_exeext
2236 AC_SUBST(ORIGINAL_LD_BFD_FOR_TARGET)
2237 AC_SUBST(ORIGINAL_LD_GOLD_FOR_TARGET)
2239 # Figure out what nm we will be using.
2240 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2241 AS_VAR_SET_IF(gcc_cv_nm,, [
2242 if test -f $gcc_cv_binutils_srcdir/configure.in \
2243 && test -f ../binutils/Makefile \
2244 && test x$build = x$host; then
2245 gcc_cv_nm=../binutils/nm-new$build_exeext
2246 elif test -x nm$build_exeext; then
2247 gcc_cv_nm=./nm$build_exeext
2248 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
2249 gcc_cv_nm="$NM_FOR_TARGET"
2251 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2254 AC_MSG_CHECKING(what nm to use)
2255 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2256 # Single tree build which includes binutils.
2257 AC_MSG_RESULT(newly built nm)
2260 AC_MSG_RESULT($gcc_cv_nm)
2264 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2265 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2266 case "$ORIGINAL_NM_FOR_TARGET" in
2267 ./nm | ./nm$build_exeext) ;;
2268 *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2272 # Figure out what objdump we will be using.
2273 AS_VAR_SET_IF(gcc_cv_objdump,, [
2274 if test -f $gcc_cv_binutils_srcdir/configure.in \
2275 && test -f ../binutils/Makefile \
2276 && test x$build = x$host; then
2277 # Single tree build which includes binutils.
2278 gcc_cv_objdump=../binutils/objdump$build_exeext
2279 elif test -x objdump$build_exeext; then
2280 gcc_cv_objdump=./objdump$build_exeext
2281 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2282 gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2284 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2287 AC_MSG_CHECKING(what objdump to use)
2288 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2289 # Single tree build which includes binutils.
2290 AC_MSG_RESULT(newly built objdump)
2291 elif test x$gcc_cv_objdump = x; then
2292 AC_MSG_RESULT(not found)
2294 AC_MSG_RESULT($gcc_cv_objdump)
2297 # Figure out what readelf we will be using.
2298 AS_VAR_SET_IF(gcc_cv_readelf,, [
2299 if test -f $gcc_cv_binutils_srcdir/configure.in \
2300 && test -f ../binutils/Makefile \
2301 && test x$build = x$host; then
2302 # Single tree build which includes binutils.
2303 gcc_cv_readelf=../binutils/readelf$build_exeext
2304 elif test -x readelf$build_exeext; then
2305 gcc_cv_readelf=./readelf$build_exeext
2307 AC_PATH_PROG(gcc_cv_readelf, readelf)
2310 AC_MSG_CHECKING(what readelf to use)
2311 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2312 # Single tree build which includes binutils.
2313 AC_MSG_RESULT(newly built readelf)
2314 elif test x$gcc_cv_readelf = x; then
2315 AC_MSG_RESULT(not found)
2317 AC_MSG_RESULT($gcc_cv_readelf)
2320 # Figure out what assembler alignment features are present.
2321 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2325 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2326 [Define if your assembler supports .balign and .p2align.])])
2328 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2331 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2332 [Define if your assembler supports specifying the maximum number
2333 of bytes to skip when using the GAS .p2align command.])])
2335 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2338 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2339 [Define if your assembler supports .literal16.])])
2341 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2343 [conftest_label1: .word 0
2345 conftest_label2: .word 0
2347 [if test x$gcc_cv_nm != x; then
2348 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2349 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2350 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2352 else gcc_cv_as_subsection_m1=yes
2354 rm -f conftest.nm1 conftest.nm2
2356 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2357 [Define if your assembler supports .subsection and .subsection -1 starts
2358 emitting at the beginning of your section.])])
2360 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2363 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2365 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2367 [ .weakref foobar, barfnot],,
2368 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2370 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2373 .NSUBSPA $CODE$,COMDAT],,
2374 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2376 # .hidden needs to be supported in both the assembler and the linker,
2377 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2378 # This is irritatingly difficult to feature test for; we have to check the
2379 # date string after the version number. If we've got an in-tree
2380 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2382 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2383 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2389 # Darwin as has some visibility support, though with a different syntax.
2390 gcc_cv_as_hidden=yes
2394 # gnu_indirect_function type is an extension proposed at
2395 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2396 # selection of function implementation
2397 AC_ARG_ENABLE(gnu-indirect-function,
2398 [AS_HELP_STRING([--enable-gnu-indirect-function],
2399 [enable the use of the @gnu_indirect_function to glibc systems])],
2400 [case $enable_gnu_indirect_function in
2402 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2403 Valid choices are 'yes' and 'no'.]) ;;
2405 [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2407 gif=`if test x$enable_gnu_indirect_function = xyes; then echo 1; else echo 0; fi`
2408 AC_DEFINE_UNQUOTED(HAVE_GNU_INDIRECT_FUNCTION, $gif,
2409 [Define if your system supports gnu indirect functions.])
2413 if test $in_tree_ld != yes ; then
2414 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2415 if echo "$ld_ver" | grep GNU > /dev/null; then
2416 if test x"$ld_is_gold" = xyes; then
2417 # GNU gold --version looks like this:
2419 # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
2421 # We extract the binutils version which is more familiar and specific
2422 # than the gold version.
2423 ld_vers=`echo $ld_ver | sed -n \
2424 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
2426 # GNU ld --version looks like this:
2428 # GNU ld (GNU Binutils) 2.21.51.20110225
2429 ld_vers=`echo $ld_ver | sed -n \
2430 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2432 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'`
2433 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2434 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2435 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2439 # See acinclude.m4 (gcc_SUN_LD_VERSION) for the version number
2442 # Don't reuse gcc_gv_sun_ld_vers_* in case a linker other than
2443 # /usr/ccs/bin/ld has been configured.
2444 ld_ver=`$gcc_cv_ld -V 2>&1`
2445 if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2446 ld_vers=`echo $ld_ver | sed -n \
2447 -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2448 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2449 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2457 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2458 [[if test $in_tree_ld = yes ; then
2460 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 \
2461 && test $in_tree_ld_is_elf = yes; then
2462 gcc_cv_ld_hidden=yes
2465 gcc_cv_ld_hidden=yes
2466 if test x"$ld_is_gold" = xyes; then
2468 elif echo "$ld_ver" | grep GNU > /dev/null; then
2470 mmix-knuth-mmixware)
2471 # The linker emits by default mmo, not ELF, so "no" is appropriate.
2475 if test 0"$ld_date" -lt 20020404; then
2476 if test -n "$ld_date"; then
2477 # If there was date string, but was earlier than 2002-04-04, fail
2479 elif test -z "$ld_vers"; then
2480 # If there was no date string nor ld version number, something is wrong
2483 test -z "$ld_vers_patch" && ld_vers_patch=0
2484 if test "$ld_vers_major" -lt 2; then
2486 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2487 gcc_cv_ld_hidden="no"
2488 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2496 # Darwin ld has some visibility support.
2497 gcc_cv_ld_hidden=yes
2499 hppa64*-*-hpux* | ia64*-*-hpux*)
2500 gcc_cv_ld_hidden=yes
2502 *-*-solaris2.1[0-9]*)
2503 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2504 # .symbolic was only added in Solaris 9 12/02.
2505 gcc_cv_ld_hidden=yes
2513 libgcc_visibility=no
2514 AC_SUBST(libgcc_visibility)
2515 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2516 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2517 libgcc_visibility=yes
2518 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2519 [Define if your assembler and linker support .hidden.])
2522 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2523 gcc_cv_ld_ro_rw_mix=unknown
2524 if test $in_tree_ld = yes ; then
2525 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 \
2526 && test $in_tree_ld_is_elf = yes; then
2527 gcc_cv_ld_ro_rw_mix=read-write
2529 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2530 echo '.section myfoosect, "a"' > conftest1.s
2531 echo '.section myfoosect, "aw"' > conftest2.s
2532 echo '.byte 1' >> conftest2.s
2533 echo '.section myfoosect, "a"' > conftest3.s
2534 echo '.byte 0' >> conftest3.s
2535 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2536 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2537 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2538 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2539 conftest2.o conftest3.o > /dev/null 2>&1; then
2540 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2541 | sed -e '/myfoosect/!d' -e N`
2542 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2543 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2544 gcc_cv_ld_ro_rw_mix=read-only
2546 gcc_cv_ld_ro_rw_mix=read-write
2551 rm -f conftest.* conftest[123].*
2554 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2555 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2556 [Define if your linker links a mix of read-only
2557 and read-write sections into a read-write section.])
2559 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2561 gcc_AC_INITFINI_ARRAY
2563 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2564 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2572 [[# GAS versions before 2.11 do not support uleb128,
2573 # despite appearing to.
2574 # ??? There exists an elf-specific test that will crash
2575 # the assembler. Perhaps it's better to figure out whether
2576 # arbitrary sections are supported and try the test.
2577 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2578 if echo "$as_ver" | grep GNU > /dev/null; then
2579 as_vers=`echo $as_ver | sed -n \
2580 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2581 as_major=`expr "$as_vers" : '\([0-9]*\)'`
2582 as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2583 if test $as_major -eq 2 && test $as_minor -lt 11
2585 else gcc_cv_as_leb128=yes
2588 [AC_DEFINE(HAVE_AS_LEB128, 1,
2589 [Define if your assembler supports .sleb128 and .uleb128.])])
2591 # Check if we have assembler support for unwind directives.
2592 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2599 .cfi_escape 1, 2, 3, 4, 5
2603 # If the linker used on Solaris (like Sun ld) isn't capable of merging
2604 # read-only and read-write sections, we need to make sure that the
2605 # assembler used emits read-write .eh_frame sections.
2606 if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2607 if test "x$gcc_cv_objdump" != x; then
2608 if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2609 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2610 gcc_cv_as_cfi_directive=no
2613 i?86-*-solaris2.1[[0-9]]* | x86_64-*-solaris2.1[[0-9]]*)
2614 # On Solaris/x86, make sure that GCC and assembler agree on using
2615 # read-only .eh_frame sections for 64-bit.
2616 if test x$gas = xyes; then
2617 as_ix86_64_opt="--64"
2619 as_ix86_64_opt="-xarch=amd64"
2621 if $gcc_cv_as $as_ix86_64_opt -o conftest.o conftest.s > /dev/null 2>&1 && \
2622 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2623 sed -e /.eh_frame/!d -e N | \
2624 grep READONLY > /dev/null; then
2625 gcc_cv_as_cfi_directive=yes
2627 gcc_cv_as_cfi_directive=no
2631 gcc_cv_as_cfi_directive=yes
2636 # no objdump, err on the side of caution
2637 gcc_cv_as_cfi_directive=no
2640 gcc_cv_as_cfi_directive=yes
2644 gcc_cv_as_cfi_directive=yes
2647 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
2648 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2652 .cfi_adjust_cfa_offset 64
2654 .cfi_adjust_cfa_offset 128
2657 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
2658 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then
2659 gcc_cv_as_cfi_advance_working=yes
2663 # no objdump, err on the side of caution
2664 gcc_cv_as_cfi_advance_working=no
2666 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
2667 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2668 [`if test $gcc_cv_as_cfi_directive = yes \
2669 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2670 [Define 0/1 if your assembler supports CFI directives.])
2672 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
2673 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2674 gcc_cv_as_cfi_personality_directive, ,,
2677 .cfi_personality 0, symbol
2679 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2680 [`if test $gcc_cv_as_cfi_personality_directive = yes;
2681 then echo 1; else echo 0; fi`],
2682 [Define 0/1 if your assembler supports .cfi_personality.])
2684 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2685 gcc_cv_as_cfi_sections_directive, ,,
2687 .cfi_sections .debug_frame, .eh_frame
2691 win32 | pe | cygwin* | mingw32* | uwin*)
2692 # Need to check that we generated the correct relocation for the
2693 # .debug_frame section. This was fixed for binutils 2.21.
2694 gcc_cv_as_cfi_sections_directive=no
2695 if test "x$gcc_cv_objdump" != x; then
2696 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
2697 grep secrel > /dev/null; then
2698 gcc_cv_as_cfi_sections_directive=yes
2703 gcc_cv_as_cfi_sections_directive=yes
2706 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
2707 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2708 [`if test $gcc_cv_as_cfi_sections_directive = yes;
2709 then echo 1; else echo 0; fi`],
2710 [Define 0/1 if your assembler supports .cfi_sections.])
2712 # GAS versions up to and including 2.11.0 may mis-optimize
2714 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2722 .section .eh_frame,"aw",@progbits
2724 .4byte .LECIE1-.LSCIE1
2738 .4byte .LEFDE1-.LASFDE1
2740 .4byte .LASFDE1-__FRAME_BEGIN__
2748 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2749 cat > conftest.lit <<EOF
2750 0000 10000000 00000000 017a0001 781a0004 .........z..x...
2751 0010 01000000 12000000 18000000 00000000 ................
2752 0020 08000000 04080000 0044 .........D @&t@
2754 cat > conftest.big <<EOF
2755 0000 00000010 00000000 017a0001 781a0004 .........z..x...
2756 0010 00000001 00000012 00000018 00000000 ................
2757 0020 00000008 04000000 0844 .........D @&t@
2759 # If the assembler didn't choke, and we can objdump,
2760 # and we got the correct data, then succeed.
2761 # The text in the here-document typically retains its unix-style line
2762 # endings, while the output of objdump will use host line endings.
2763 # Therefore, use diff -b for the comparisons.
2764 if test x$gcc_cv_objdump != x \
2765 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2766 | tail -3 > conftest.got \
2767 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2768 || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2770 gcc_cv_as_eh_frame=yes
2771 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2772 gcc_cv_as_eh_frame=buggy
2774 # Uh oh, what do we do now?
2775 gcc_cv_as_eh_frame=no
2778 if test $gcc_cv_as_eh_frame = buggy; then
2779 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2780 [Define if your assembler mis-optimizes .eh_frame data.])
2783 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2784 [elf,2,12,0], [--fatal-warnings],
2785 [.section .rodata.str, "aMS", @progbits, 1])
2786 if test $gcc_cv_as_shf_merge = no; then
2787 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2788 [elf,2,12,0], [--fatal-warnings],
2789 [.section .rodata.str, "aMS", %progbits, 1])
2791 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2792 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2793 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2795 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)],
2796 gcc_cv_as_comdat_group,
2797 [elf,2,16,0], [--fatal-warnings],
2798 [.section .text,"axG",@progbits,.foo,comdat])
2799 if test $gcc_cv_as_comdat_group = yes; then
2800 gcc_cv_as_comdat_group_percent=no
2801 gcc_cv_as_comdat_group_group=no
2803 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
2804 gcc_cv_as_comdat_group_percent,
2805 [elf,2,16,0], [--fatal-warnings],
2806 [.section .text,"axG",%progbits,.foo,comdat])
2807 if test $gcc_cv_as_comdat_group_percent = yes; then
2808 gcc_cv_as_comdat_group_group=no
2811 # Sun as uses a completely different syntax.
2816 .group foo,".text%foo",#comdat
2817 .section ".text%foo", #alloc,#execinstr,#progbits
2822 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2824 .group foo,.text%foo,#comdat
2825 .section .text%foo, "ax", @progbits
2831 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
2832 gcc_cv_as_comdat_group_group,
2836 if test -z "${gcc_cv_as_comdat_group_group+set}"; then
2837 gcc_cv_as_comdat_group_group=no
2841 if test x"$ld_is_gold" = xyes; then
2843 elif test $in_tree_ld = yes ; then
2845 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 \
2846 && test $in_tree_ld_is_elf = yes; then
2849 elif echo "$ld_ver" | grep GNU > /dev/null; then
2851 if test 0"$ld_date" -lt 20050308; then
2852 if test -n "$ld_date"; then
2853 # If there was date string, but was earlier than 2005-03-08, fail
2855 elif test "$ld_vers_major" -lt 2; then
2857 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2864 *-*-solaris2.1[1-9]*)
2866 # Sun ld has COMDAT group support since Solaris 9, but it doesn't
2867 # interoperate with GNU as until Solaris 11 build 130, i.e. ld
2870 # If using Sun as for COMDAT group as emitted by GCC, one needs at
2871 # least ld version 1.2267.
2872 if test "$ld_vers_major" -gt 1; then
2874 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
2876 elif test "$ld_vers_minor" -ge 2267; then
2881 # Assume linkers other than GNU ld don't support COMDAT group.
2887 # Allow overriding the automatic COMDAT group tests above.
2888 AC_ARG_ENABLE(comdat,
2889 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
2890 [comdat_group="$enable_comdat"])
2891 if test $comdat_group = no; then
2892 gcc_cv_as_comdat_group=no
2893 gcc_cv_as_comdat_group_percent=no
2894 gcc_cv_as_comdat_group_group=no
2896 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2897 [`if test $gcc_cv_as_comdat_group = yes \
2898 || test $gcc_cv_as_comdat_group_percent = yes \
2899 || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`],
2900 [Define 0/1 if your assembler and linker support COMDAT groups.])
2902 gcc_GAS_CHECK_FEATURE([line table discriminator support],
2903 gcc_cv_as_discriminator,
2907 .loc 1 1 0 discriminator 1],,
2908 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
2909 [Define if your assembler supports the .loc discriminator sub-directive.])])
2911 # Thread-local storage - the check is heavily parameterized.
2920 .section ".tdata","awT",@progbits
2923 ldq $27,__tls_get_addr($29) !literal!1
2924 lda $16,foo($29) !tlsgd!1
2925 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
2926 ldq $27,__tls_get_addr($29) !literal!2
2927 lda $16,foo($29) !tlsldm!2
2928 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
2929 ldq $1,foo($29) !gotdtprel
2930 ldah $2,foo($29) !dtprelhi
2931 lda $3,foo($2) !dtprello
2932 lda $4,foo($29) !dtprel
2933 ldq $1,foo($29) !gottprel
2934 ldah $2,foo($29) !tprelhi
2935 lda $3,foo($2) !tprello
2936 lda $4,foo($29) !tprel'
2939 tls_as_opt=--fatal-warnings
2941 cris-*-*|crisv32-*-*)
2943 .section ".tdata","awT",@progbits
2950 tls_as_opt=--fatal-warnings
2954 .section ".tdata","awT",@progbits
2966 .section ".tdata","awT",@progbits
2970 addil LT%foo-$tls_gdidx$,gp
2971 ldo RT%foo-$tls_gdidx$(%r1),%arg0
2974 addil LT%foo-$tls_ldidx$,gp
2976 ldo RT%foo-$tls_ldidx$(%r1),%arg0
2977 addil LR%foo-$tls_dtpoff$,%ret0
2978 ldo RR%foo-$tls_dtpoff$(%r1),%t1
2980 addil LT%foo-$tls_ieoff$,gp
2981 ldw RT%foo-$tls_ieoff$(%r1),%t2
2984 addil LR%foo-$tls_leoff$,%t1
2985 ldo RR%foo-$tls_leoff$(%r1),%t2'
2988 tls_as_opt=--fatal-warnings
2992 .section ".tdata","awT",%progbits
3003 i[34567]86-*-* | x86_64-*-*)
3005 i[34567]86-*-solaris2.* | x86_64-*-solaris2.1[0-9]*)
3012 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3014 .section .tdata,"awt",@progbits'
3019 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
3020 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
3024 .section ".tdata","awT",@progbits'
3028 tls_as_opt="--fatal-warnings"
3032 conftest_s="$conftest_s
3036 leal foo@tlsgd(,%ebx,1), %eax
3037 leal foo@tlsldm(%ebx), %eax
3038 leal foo@dtpoff(%eax), %edx
3039 movl foo@gottpoff(%ebx), %eax
3040 subl foo@gottpoff(%ebx), %eax
3041 addl foo@gotntpoff(%ebx), %eax
3042 movl foo@indntpoff, %eax
3043 movl \$foo@tpoff, %eax
3044 subl \$foo@tpoff, %eax
3045 leal foo@ntpoff(%ecx), %eax"
3048 if test x$on_solaris = xyes; then
3050 yes) tls_as_opt="$tls_as_opt --64" ;;
3051 no) tls_as_opt="$tls_as_opt -xarch=amd64" ;;
3054 conftest_s="$conftest_s
3058 leaq foo@tlsgd(%rip), %rdi
3059 leaq foo@tlsld(%rip), %rdi
3060 leaq foo@dtpoff(%rax), %rdx
3061 movq foo@gottpoff(%rip), %rax
3062 movq \$foo@tpoff, %rax"
3068 .section ".tdata","awT",@progbits
3071 addl r16 = @ltoff(@dtpmod(foo#)), gp
3072 addl r17 = @ltoff(@dtprel(foo#)), gp
3073 addl r18 = @ltoff(@tprel(foo#)), gp
3074 addl r19 = @dtprel(foo#), gp
3075 adds r21 = @dtprel(foo#), r13
3076 movl r23 = @dtprel(foo#)
3077 addl r20 = @tprel(foo#), gp
3078 adds r22 = @tprel(foo#), r13
3079 movl r24 = @tprel(foo#)'
3082 tls_as_opt=--fatal-warnings
3086 .section .tdata,"awT",@progbits
3090 addik r5,r20,x@TLSGD
3091 addik r5,r20,x@TLSLDM'
3094 tls_as_opt='--fatal-warnings'
3098 .section .tdata,"awT",@progbits
3102 addiu $4, $28, %tlsgd(x)
3103 addiu $4, $28, %tlsldm(x)
3104 lui $4, %dtprel_hi(x)
3105 addiu $4, $4, %dtprel_lo(x)
3106 lw $4, %gottprel(x)($28)
3107 lui $4, %tprel_hi(x)
3108 addiu $4, $4, %tprel_lo(x)'
3111 tls_as_opt='-32 --fatal-warnings'
3115 .section .tdata,"awT",@progbits
3120 move.l x@TLSGD(%a5),%a0
3121 move.l x@TLSLDM(%a5),%a0
3122 move.l x@TLSLDO(%a5),%a0
3123 move.l x@TLSIE(%a5),%a0
3124 move.l x@TLSLE(%a5),%a0'
3127 tls_as_opt='--fatal-warnings'
3131 .section ".tdata","awT",@progbits'
3134 tls_as_opt="--fatal-warnings"
3138 .section ".tdata","awT",%progbits
3142 add x0, x0, #:tlsgd_lo12:x
3147 tls_as_opt='--fatal-warnings'
3151 .extern __get_tpointer
3169 .section ".tdata","awT",@progbits
3177 addi 3,2,ld0@got@tlsgd
3183 addi 3,2,x1@got@tlsld
3189 addis 9,3,x2@dtprel@ha
3190 addi 9,9,x2@dtprel@l
3193 ld 9,x3@got@dtprel(2)
3199 tls_as_opt="-a64 --fatal-warnings"
3203 .section ".tdata","awT",@progbits
3211 addi 3,31,ld0@got@tlsgd
3213 addi 3,31,x1@got@tlsld
3216 addis 9,3,x2@dtprel@ha
3217 addi 9,9,x2@dtprel@l
3218 lwz 9,x3@got@tprel(31)
3221 addis 9,2,x2@tprel@ha
3222 addi 9,9,x2@tprel@l'
3225 tls_as_opt="-a32 --fatal-warnings"
3229 .section ".tdata","awT",@progbits
3238 l %r1,foo@GOTNTPOFF(%r12)
3239 l %r1,0(%r1):tls_load:foo
3240 bas %r14,0(%r1,%r13):tls_gdcall:foo
3241 bas %r14,0(%r1,%r13):tls_ldcall:foo'
3244 tls_as_opt="-m31 --fatal-warnings"
3248 .section ".tdata","awT",@progbits
3256 lg %r1,foo@GOTNTPOFF(%r12)
3257 larl %r1,foo@INDNTPOFF
3258 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
3259 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
3262 tls_as_opt="-m64 -Aesame --fatal-warnings"
3264 sh-*-* | sh[34]-*-*)
3266 .section ".tdata","awT",@progbits
3276 tls_as_opt=--fatal-warnings
3280 sparc*-sun-solaris2.*)
3287 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3289 .section ".tdata",#alloc,#write,#tls'
3294 .section ".tdata","awT",@progbits'
3297 tls_as_opt="-32 --fatal-warnings"
3299 conftest_s="$conftest_s
3302 sethi %tgd_hi22(foo), %o0
3303 add %o0, %tgd_lo10(foo), %o1
3304 add %l7, %o1, %o0, %tgd_add(foo)
3305 call __tls_get_addr, %tgd_call(foo)
3306 sethi %tldm_hi22(foo), %l1
3307 add %l1, %tldm_lo10(foo), %l2
3308 add %l7, %l2, %o0, %tldm_add(foo)
3309 call __tls_get_addr, %tldm_call(foo)
3310 sethi %tldo_hix22(foo), %l3
3311 xor %l3, %tldo_lox10(foo), %l4
3312 add %o0, %l4, %l5, %tldo_add(foo)
3313 sethi %tie_hi22(foo), %o3
3314 add %o3, %tie_lo10(foo), %o3
3315 ld [%l7 + %o3], %o2, %tie_ld(foo)
3316 add %g7, %o2, %o4, %tie_add(foo)
3317 sethi %tle_hix22(foo), %l1
3318 xor %l1, %tle_lox10(foo), %o5
3319 ld [%g7 + %o5], %o1"
3323 .section ".tdata","awT",@progbits
3326 addli r0, zero, tls_gd(foo)
3327 auli r0, zero, tls_gd_ha16(foo)
3328 addli r0, r0, tls_gd_lo16(foo)
3330 addli r0, zero, tls_ie(foo)
3331 auli r0, r0, tls_ie_ha16(foo)
3332 addli r0, r0, tls_ie_lo16(foo)'
3335 tls_as_opt="--fatal-warnings"
3339 .section ".tdata","awT",@progbits
3342 shl16insli r0, zero, hw0_last_tls_gd(foo)
3343 shl16insli r0, zero, hw1_last_tls_gd(foo)
3344 shl16insli r0, r0, hw0_tls_gd(foo)
3346 shl16insli r0, zero, hw1_last_tls_ie(foo)
3347 shl16insli r0, r0, hw0_tls_ie(foo)'
3350 tls_as_opt="--fatal-warnings"
3354 .section ".tdata","awT",@progbits
3357 movi a8, foo@TLSFUNC
3358 movi a10, foo@TLSARG
3359 callx8.tls a8, foo@TLSCALL'
3366 if test "x$enable_tls" = xno ; then
3367 : # TLS explicitly disabled.
3368 elif test "x$enable_tls" = xyes ; then
3369 set_have_as_tls=yes # TLS explicitly enabled.
3370 elif test -z "$tls_first_major"; then
3371 : # If we don't have a check, assume no support.
3373 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
3374 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
3375 [set_have_as_tls=yes])
3377 if test $set_have_as_tls = yes ; then
3378 AC_DEFINE(HAVE_AS_TLS, 1,
3379 [Define if your assembler and linker support thread-local storage.])
3382 # Target-specific assembler checks.
3384 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3385 gcc_cv_ld_static_dynamic=no
3386 gcc_cv_ld_static_option='-Bstatic'
3387 gcc_cv_ld_dynamic_option='-Bdynamic'
3388 if test $in_tree_ld = yes ; then
3389 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
3390 gcc_cv_ld_static_dynamic=yes
3392 elif test x$gcc_cv_ld != x; then
3393 # Check if linker supports -Bstatic/-Bdynamic option
3394 if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
3395 && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
3396 gcc_cv_ld_static_dynamic=yes
3399 # AIX ld uses -b flags
3400 *-*-aix4.[[23]]* | *-*-aix[[5-9]]*)
3401 gcc_cv_ld_static_dynamic=yes
3402 gcc_cv_ld_static_option="-bstatic"
3403 gcc_cv_ld_dynamic_option="-bdynamic"
3405 # HP-UX ld uses -a flags to select between shared and archive.
3407 if test x"$gnu_ld" = xno; then
3408 gcc_cv_ld_static_dynamic=yes
3409 gcc_cv_ld_static_option="-aarchive_shared"
3410 gcc_cv_ld_dynamic_option="-adefault"
3413 # Solaris 2 ld always supports -Bstatic/-Bdynamic.
3415 gcc_cv_ld_static_dynamic=yes
3420 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3421 AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3422 [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.])
3423 AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option",
3424 [Define to the linker option to disable use of shared objects.])
3425 AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option",
3426 [Define to the linker option to enable use of shared objects.])
3428 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3430 if test x"$demangler_in_ld" = xyes; then
3431 AC_MSG_CHECKING(linker --demangle support)
3432 gcc_cv_ld_demangle=no
3433 if test $in_tree_ld = yes; then
3434 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 \
3435 gcc_cv_ld_demangle=yes
3437 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3438 # Check if the GNU linker supports --demangle option
3439 if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3440 gcc_cv_ld_demangle=yes
3443 if test x"$gcc_cv_ld_demangle" = xyes; then
3444 AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3445 [Define if your linker supports --demangle option.])
3447 AC_MSG_RESULT($gcc_cv_ld_demangle)
3450 AC_MSG_CHECKING(linker plugin support)
3452 if test -f liblto_plugin.la; then
3453 save_ld_ver="$ld_ver"
3454 save_ld_vers_major="$ld_vers_major"
3455 save_ld_vers_minor="$ld_vers_minor"
3456 save_ld_is_gold="$ld_is_gold"
3460 if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
3462 # FIXME: ld_is_gold?
3463 ld_vers_major="$gcc_cv_gld_major_version"
3464 ld_vers_minor="$gcc_cv_gld_minor_version"
3466 # Determine plugin linker version.
3467 # FIXME: Partial duplicate from above, generalize.
3469 ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q`
3470 if echo "$ld_ver" | grep GNU > /dev/null; then
3471 if echo "$ld_ver" | grep "GNU gold" > /dev/null; then
3473 ld_vers=`echo $ld_ver | sed -n \
3474 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
3476 ld_vers=`echo $ld_ver | sed -n \
3477 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
3479 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
3480 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
3485 # Determine plugin support.
3486 if echo "$ld_ver" | grep GNU > /dev/null; then
3487 # Require GNU ld or gold 2.21+ for plugin support by default.
3488 if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then
3490 # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20.
3491 elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then
3496 ld_ver="$save_ld_ver"
3497 ld_vers_major="$save_ld_vers_major"
3498 ld_vers_minor="$save_ld_vers_minor"
3499 ld_is_gold="$save_ld_is_gold"
3501 AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin,
3502 [Define to the level of your linker's plugin support.])
3503 AC_MSG_RESULT($gcc_cv_lto_plugin)
3507 gcc_GAS_CHECK_FEATURE([-mabi option], gcc_cv_as_aarch64_mabi,,
3508 [-mabi=lp64], [.text],,,)
3509 if test x$gcc_cv_as_aarch64_mabi = xyes; then
3510 AC_DEFINE(HAVE_AS_MABI_OPTION, 1,
3511 [Define if your assembler supports the -mabi option.])
3513 if test x$with_abi = xilp32; then
3514 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3515 Upgrade the Assembler.])
3517 if test x"$with_multilib_list" = xdefault; then
3518 TM_MULTILIB_CONFIG=lp64
3520 aarch64_multilibs=`echo $with_multilib_list | sed -e 's/,/ /g'`
3521 for aarch64_multilib in ${aarch64_multilibs}; do
3522 case ${aarch64_multilib} in
3524 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3525 Upgrade the Assembler.])
3533 # Enable default workaround for AArch64 Cortex-A53 erratum 835769.
3534 AC_ARG_ENABLE(fix-cortex-a53-835769,
3536 AS_HELP_STRING([--enable-fix-cortex-a53-835769],
3537 [enable workaround for AArch64 Cortex-A53 erratum 835769 by default])
3538 AS_HELP_STRING([--disable-fix-cortex-a53-835769],
3539 [disable workaround for AArch64 Cortex-A53 erratum 835769 by default])
3544 tm_defines="${tm_defines} TARGET_FIX_ERR_A53_835769_DEFAULT=1"
3549 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-835769.\
3550 Valid choices are 'yes' and 'no'.])
3558 # All TARGET_ABI_OSF targets.
3559 alpha*-*-linux* | alpha*-*-*bsd*)
3560 gcc_GAS_CHECK_FEATURE([explicit relocation support],
3561 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3564 extbl $3, $2, $3 !lituse_bytoff!1
3565 ldq $2, a($29) !literal!1
3566 ldq $4, b($29) !literal!2
3567 ldq_u $3, 0($2) !lituse_base!1
3568 ldq $27, f($29) !literal!5
3569 jsr $26, ($27), f !lituse_jsr!5
3570 ldah $29, 0($26) !gpdisp!3
3571 lda $0, c($29) !gprel
3572 ldah $1, d($29) !gprelhigh
3573 lda $1, d($1) !gprellow
3574 lda $29, 0($29) !gpdisp!3],,
3575 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3576 [Define if your assembler supports explicit relocations.])])
3577 gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3578 gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3581 ldq $27, a($29) !literal!1
3582 jsr $26, ($27), a !lituse_jsrdirect!1],,
3583 [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3584 [Define if your assembler supports the lituse_jsrdirect relocation.])])
3588 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3589 gcc_cv_as_cris_no_mul_bug,[2,15,91],
3590 [-no-mul-bug-abort], [.text],,
3591 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3592 [Define if your assembler supports the -no-mul-bug-abort option.])])
3596 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3597 [.register %g2, #scratch],,
3598 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3599 [Define if your assembler supports .register.])])
3601 gcc_GAS_CHECK_FEATURE([@%:@nobits], gcc_cv_as_sparc_nobits,,,
3602 [.section "nobits",#alloc,#write,#nobits
3603 .section "progbits",#alloc,#write,#progbits])
3604 AC_DEFINE_UNQUOTED(HAVE_AS_SPARC_NOBITS,
3605 [`if test $gcc_cv_as_sparc_nobits = yes; then echo 1; else echo 0; fi`],
3606 [Define to 1 if your assembler supports #nobits, 0 otherwise.])
3608 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3610 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3611 [Define if your assembler supports -relax option.])])
3613 gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3614 gcc_cv_as_sparc_gotdata_op,,
3621 sethi %gdop_hix22(foo), %g1
3622 xor %g1, %gdop_lox10(foo), %g1
3623 ld [[%l7 + %g1]], %g2, %gdop(foo)],
3624 [if test x$gcc_cv_ld != x \
3625 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3626 if test x$gcc_cv_objdump != x; then
3627 if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3628 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3629 gcc_cv_as_sparc_gotdata_op=no
3631 gcc_cv_as_sparc_gotdata_op=yes
3636 [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3637 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3639 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3640 gcc_cv_as_sparc_ua_pcrel,,
3648 .uaword %r_disp32(foo)],
3649 [if test x$gcc_cv_ld != x \
3650 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3651 gcc_cv_as_sparc_ua_pcrel=yes
3654 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3655 [Define if your assembler and linker support unaligned PC relative relocs.])
3657 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3658 gcc_cv_as_sparc_ua_pcrel_hidden,,
3663 .uaword %r_disp32(foo)
3664 .byte 0x32, 0x33, 0x34
3669 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3670 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3671 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3672 | grep ' 31000000 07323334' > /dev/null 2>&1; then
3673 if $gcc_cv_objdump -R conftest 2> /dev/null \
3674 | grep 'DISP32' > /dev/null 2>&1; then
3677 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3681 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3682 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3683 ]) # unaligned pcrel relocs
3685 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3686 gcc_cv_as_sparc_offsetable_lo10,,
3689 or %g1, %lo(ab) + 12, %g1
3690 or %g1, %lo(ab + 12), %g1],
3691 [if test x$gcc_cv_objdump != x \
3692 && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3693 | grep ' 82106000 82106000' > /dev/null 2>&1; then
3694 gcc_cv_as_sparc_offsetable_lo10=yes
3696 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3697 [Define if your assembler supports offsetable %lo().])])
3699 gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions],
3700 gcc_cv_as_sparc_fmaf,,
3703 .register %g2, #scratch
3704 .register %g3, #scratch
3706 fmaddd %f0, %f2, %f4, %f6
3707 addxccc %g1, %g2, %g3
3708 fsrl32 %f2, %f4, %f8
3709 fnaddd %f10, %f12, %f14],,
3710 [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1,
3711 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])])
3713 gcc_GAS_CHECK_FEATURE([SPARC4 instructions],
3714 gcc_cv_as_sparc_sparc4,,
3717 .register %g2, #scratch
3718 .register %g3, #scratch
3721 1: cwbneg %g2, %g3, 1f
3724 aes_kexpand0 %f4, %f6, %f8
3725 des_round %f38, %f40, %f42, %f44
3726 camellia_f %f54, %f56, %f58, %f60
3727 kasumi_fi_xor %f46, %f48, %f50, %f52],,
3728 [AC_DEFINE(HAVE_AS_SPARC4, 1,
3729 [Define if your assembler supports SPARC4 instructions.])])
3731 gcc_GAS_CHECK_FEATURE([LEON instructions],
3732 gcc_cv_as_sparc_leon,,
3735 .register %g2, #scratch
3736 .register %g3, #scratch
3740 casa [[%g2]] 0xb, %g3, %g1],,
3741 [AC_DEFINE(HAVE_AS_LEON, 1,
3742 [Define if your assembler supports LEON instructions.])])
3746 i[34567]86-*-* | x86_64-*-*)
3750 # Full C++ conformance when using a shared libstdc++-v3 requires some
3751 # support from the Cygwin DLL, which in more recent versions exports
3752 # wrappers to aid in interposing and redirecting operators new, delete,
3753 # etc., as per n2800 #17.6.4.6 [replacement.functions]. Check if we
3754 # are configuring for a version of Cygwin that exports the wrappers.
3755 if test x$host = x$target && test x$host_cpu = xi686; then
3756 AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3758 # Can't check presence of libc functions during cross-compile, so
3759 # we just have to assume we're building for an up-to-date target.
3760 gcc_ac_cygwin_dll_wrappers=yes
3762 AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3763 [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3764 [Define if you want to generate code by default that assumes that the
3765 Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3768 cygwin* | pe | mingw32* | interix*)
3769 # Recent binutils allows the three-operand form of ".comm" on PE. This
3770 # definition is used unconditionally to initialise the default state of
3771 # the target option variable that governs usage of the feature.
3772 gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3773 [2,19,52],,[.comm foo,1,32])
3774 AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3775 [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3776 [Define if your assembler supports specifying the alignment
3777 of objects allocated using the GAS .comm command.])
3778 # Used for DWARF 2 in PE
3779 gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3780 gcc_cv_as_ix86_pe_secrel32,
3786 [if test x$gcc_cv_ld != x \
3787 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3788 gcc_cv_as_ix86_pe_secrel32=yes
3791 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3792 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3793 # Test if the assembler supports the extended form of the .section
3794 # directive that specifies section alignment. LTO support uses this,
3795 # but normally only after installation, so we warn but don't fail the
3796 # configure if LTO is enabled but the assembler does not support it.
3797 gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3798 [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3799 if test x$gcc_cv_as_section_has_align != xyes; then
3800 case ",$enable_languages," in
3802 AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3809 # Test if the assembler supports the section flag 'e' for specifying
3810 # an excluded section.
3811 gcc_GAS_CHECK_FEATURE([.section with e], gcc_cv_as_section_has_e,
3812 [2,22,51], [--fatal-warnings],
3815 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3816 [`if test $gcc_cv_as_section_has_e = yes; then echo 1; else echo 0; fi`],
3817 [Define if your assembler supports specifying the section flag e.])
3819 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3820 gcc_cv_as_ix86_filds,,,
3821 [filds mem; fists mem],,
3822 [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3823 [Define if your assembler uses filds and fists mnemonics.])])
3825 gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3826 gcc_cv_as_ix86_fildq,,,
3827 [fildq mem; fistpq mem],,
3828 [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3829 [Define if your assembler uses fildq and fistq mnemonics.])])
3831 gcc_GAS_CHECK_FEATURE([cmov syntax],
3832 gcc_cv_as_ix86_cmov_sun_syntax,,,
3833 [cmovl.l %edx, %eax],,
3834 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3835 [Define if your assembler supports the Sun syntax for cmov.])])
3837 gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3838 gcc_cv_as_ix86_ffreep,,,
3840 [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3841 [Define if your assembler supports the ffreep mnemonic.])])
3843 gcc_GAS_CHECK_FEATURE([.quad directive],
3844 gcc_cv_as_ix86_quad,,,
3846 [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
3847 [Define if your assembler supports the .quad directive.])])
3849 gcc_GAS_CHECK_FEATURE([sahf mnemonic],
3850 gcc_cv_as_ix86_sahf,,,
3853 [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
3854 [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
3856 gcc_GAS_CHECK_FEATURE([interunit movq mnemonic],
3857 gcc_cv_as_ix86_interunit_movq,,,
3861 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_INTERUNIT_MOVQ,
3862 [`if test $gcc_cv_as_ix86_interunit_movq = yes; then echo 1; else echo 0; fi`],
3863 [Define if your assembler supports interunit movq mnemonic.])
3865 gcc_GAS_CHECK_FEATURE([hle prefixes],
3866 gcc_cv_as_ix86_hle,,,
3867 [lock xacquire cmpxchg %esi, (%ecx)],,
3868 [AC_DEFINE(HAVE_AS_IX86_HLE, 1,
3869 [Define if your assembler supports HLE prefixes.])])
3871 gcc_GAS_CHECK_FEATURE([swap suffix],
3872 gcc_cv_as_ix86_swap,,,
3873 [movl.s %esp, %ebp],,
3874 [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
3875 [Define if your assembler supports the swap suffix.])])
3877 gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
3878 gcc_cv_as_ix86_diff_sect_delta,,,
3886 [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
3887 [Define if your assembler supports the subtraction of symbols in different sections.])])
3889 # These two are used unconditionally by i386.[ch]; it is to be defined
3890 # to 1 if the feature is present, 0 otherwise.
3891 as_ix86_gotoff_in_data_opt=
3892 if test x$gas = xyes; then
3893 as_ix86_gotoff_in_data_opt="--32"
3895 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
3896 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],
3897 [$as_ix86_gotoff_in_data_opt],
3903 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
3904 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
3905 [Define true if the assembler supports '.long foo@GOTOFF'.])
3907 gcc_GAS_CHECK_FEATURE([rep and lock prefix],
3908 gcc_cv_as_ix86_rep_lock_prefix,,,
3914 lock addl %edi, (%eax,%esi)
3915 lock orl $0, (%esp)],,
3916 [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
3917 [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
3919 gcc_GAS_CHECK_FEATURE([ud2 mnemonic],
3920 gcc_cv_as_ix86_ud2,,,
3922 [AC_DEFINE(HAVE_AS_IX86_UD2, 1,
3923 [Define if your assembler supports the 'ud2' mnemonic.])])
3925 gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
3926 gcc_cv_as_ix86_tlsgdplt,,,
3927 [call tls_gd@tlsgdplt],
3928 [if test x$gcc_cv_ld != x \
3929 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3930 gcc_cv_as_ix86_tlsgdplt=yes
3933 [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
3934 [Define if your assembler and linker support @tlsgdplt.])])
3937 .section .tdata,"aw'$tls_section_flag'",@progbits
3939 .section .text,"ax",@progbits
3940 call tls_ld@tlsldmplt'
3941 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
3942 gcc_cv_as_ix86_tlsldmplt,,,
3944 [if test x$gcc_cv_ld != x \
3945 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3946 gcc_cv_as_ix86_tlsldmplt=yes
3949 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDMPLT,
3950 [`if test $gcc_cv_as_ix86_tlsldmplt = yes; then echo 1; else echo 0; fi`],
3951 [Define to 1 if your assembler and linker support @tlsldmplt.])
3953 # Enforce 32-bit output with gas and gld.
3954 if test x$gas = xyes; then
3955 as_ix86_tls_ldm_opt="--32"
3957 if echo "$ld_ver" | grep GNU > /dev/null; then
3958 if $gcc_cv_ld -V 2>/dev/null | grep elf_i386_sol2 > /dev/null; then
3959 ld_ix86_tls_ldm_opt="-melf_i386_sol2"
3961 ld_ix86_tls_ldm_opt="-melf_i386"
3965 .section .text,"ax",@progbits
3967 .type _start, @function
3969 leal value@tlsldm(%ebx), %eax
3970 call ___tls_get_addr@plt
3972 .section .tdata,"aw'$tls_section_flag'",@progbits
3973 .type value, @object
3975 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM reloc],
3976 gcc_cv_as_ix86_tlsldm,,
3977 [$as_ix86_tls_ldm_opt],
3979 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3980 && $gcc_cv_ld $ld_ix86_tls_ldm_opt -o conftest conftest.o $ld_tls_libs -lc > /dev/null 2>&1; then
3981 if $gcc_cv_objdump -d conftest 2>/dev/null | grep nop > /dev/null \
3982 || dis conftest 2>/dev/null | grep nop > /dev/null; then
3983 gcc_cv_as_ix86_tlsldm=yes
3987 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDM,
3988 [`if test $gcc_cv_as_ix86_tlsldm = yes; then echo 1; else echo 0; fi`],
3989 [Define to 1 if your assembler and linker support @tlsldm.])
3994 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
3995 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
3997 addl r15 = @ltoffx(x#), gp
3999 ld8.mov r16 = [[r15]], x#],,
4000 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
4001 [Define if your assembler supports ltoffx and ldxmov relocations.])])
4007 *-*-aix*) conftest_s=' .machine "pwr5"
4011 gcc_GAS_CHECK_FEATURE([.machine directive support],
4012 gcc_cv_as_machine_directive,,,
4013 [ .machine ppc7400])
4014 if test x$gcc_cv_as_machine_directive != xyes; then
4015 echo "*** This target requires an assembler supporting \".machine\"" >&2
4016 echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
4017 test x$build = x$target && exit 1
4021 *) conftest_s=' .machine power4
4026 gcc_GAS_CHECK_FEATURE([mfcr field support],
4027 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
4029 [AC_DEFINE(HAVE_AS_MFCRF, 1,
4030 [Define if your assembler supports mfcr field.])])
4033 *-*-aix*) conftest_s=' .machine "pwr5"
4036 *) conftest_s=' .machine power5
4041 gcc_GAS_CHECK_FEATURE([popcntb support],
4042 gcc_cv_as_powerpc_popcntb, [2,17,0],,
4044 [AC_DEFINE(HAVE_AS_POPCNTB, 1,
4045 [Define if your assembler supports popcntb field.])])
4048 *-*-aix*) conftest_s=' .machine "pwr5x"
4051 *) conftest_s=' .machine power5
4056 gcc_GAS_CHECK_FEATURE([fp round support],
4057 gcc_cv_as_powerpc_fprnd, [2,17,0],,
4059 [AC_DEFINE(HAVE_AS_FPRND, 1,
4060 [Define if your assembler supports fprnd.])])
4063 *-*-aix*) conftest_s=' .machine "pwr6"
4066 *) conftest_s=' .machine power6
4071 gcc_GAS_CHECK_FEATURE([move fp gpr support],
4072 gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
4074 [AC_DEFINE(HAVE_AS_MFPGPR, 1,
4075 [Define if your assembler supports mffgpr and mftgpr.])])
4078 *-*-aix*) conftest_s=' .csect .text[[PR]]
4080 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
4084 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
4085 *) conftest_s=' .text
4087 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
4090 gcc_GAS_CHECK_FEATURE([rel16 relocs],
4091 gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
4093 [AC_DEFINE(HAVE_AS_REL16, 1,
4094 [Define if your assembler supports R_PPC_REL16 relocs.])])
4097 *-*-aix*) conftest_s=' .machine "pwr6"
4100 *) conftest_s=' .machine power6
4105 gcc_GAS_CHECK_FEATURE([compare bytes support],
4106 gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
4108 [AC_DEFINE(HAVE_AS_CMPB, 1,
4109 [Define if your assembler supports cmpb.])])
4112 *-*-aix*) conftest_s=' .machine "pwr6"
4115 *) conftest_s=' .machine power6
4120 gcc_GAS_CHECK_FEATURE([decimal float support],
4121 gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
4123 [AC_DEFINE(HAVE_AS_DFP, 1,
4124 [Define if your assembler supports DFP instructions.])])
4127 *-*-aix*) conftest_s=' .machine "pwr7"
4130 *) conftest_s=' .machine power7
4135 gcc_GAS_CHECK_FEATURE([vector-scalar support],
4136 gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
4138 [AC_DEFINE(HAVE_AS_VSX, 1,
4139 [Define if your assembler supports VSX instructions.])])
4142 *-*-aix*) conftest_s=' .machine "pwr7"
4145 *) conftest_s=' .machine power7
4150 gcc_GAS_CHECK_FEATURE([popcntd support],
4151 gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
4153 [AC_DEFINE(HAVE_AS_POPCNTD, 1,
4154 [Define if your assembler supports POPCNTD instructions.])])
4157 *-*-aix*) conftest_s=' .machine "pwr8"
4158 .csect .text[[PR]]';;
4159 *) conftest_s=' .machine power8
4163 gcc_GAS_CHECK_FEATURE([power8 support],
4164 gcc_cv_as_powerpc_power8, [2,19,2], -a32,
4166 [AC_DEFINE(HAVE_AS_POWER8, 1,
4167 [Define if your assembler supports POWER8 instructions.])])
4170 *-*-aix*) conftest_s=' .csect .text[[PR]]
4172 *) conftest_s=' .text
4176 gcc_GAS_CHECK_FEATURE([lwsync support],
4177 gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
4179 [AC_DEFINE(HAVE_AS_LWSYNC, 1,
4180 [Define if your assembler supports LWSYNC instructions.])])
4183 *-*-aix*) conftest_s=' .machine "476"
4186 *) conftest_s=' .machine "476"
4191 gcc_GAS_CHECK_FEATURE([data cache invalidate support],
4192 gcc_cv_as_powerpc_dci, [9,99,0], -a32,
4194 [AC_DEFINE(HAVE_AS_DCI, 1,
4195 [Define if your assembler supports the DCI/ICI instructions.])])
4197 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4198 gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
4199 [.gnu_attribute 4,1],,
4200 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4201 [Define if your assembler supports .gnu_attribute.])])
4203 gcc_GAS_CHECK_FEATURE([tls marker support],
4204 gcc_cv_as_powerpc_tls_markers, [2,20,0],,
4205 [ bl __tls_get_addr(x@tlsgd)],,
4206 [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
4207 [Define if your assembler supports arg info for __tls_get_addr.])])
4211 gcc_GAS_CHECK_FEATURE([.ref support],
4212 gcc_cv_as_aix_ref, [2,21,0],,
4213 [ .csect stuff[[rw]]
4219 [AC_DEFINE(HAVE_AS_REF, 1,
4220 [Define if your assembler supports .ref])])
4226 gcc_GAS_CHECK_FEATURE([explicit relocation support],
4227 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
4228 [ lw $4,%gp_rel(foo)($4)],,
4229 [if test x$target_cpu_default = x
4230 then target_cpu_default=MASK_EXPLICIT_RELOCS
4231 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
4233 gcc_GAS_CHECK_FEATURE([-mno-shared support],
4234 gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
4235 [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
4236 [Define if the assembler understands -mno-shared.])])
4238 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4239 gcc_cv_as_mips_gnu_attribute, [2,18,0],,
4240 [.gnu_attribute 4,1],,
4241 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4242 [Define if your assembler supports .gnu_attribute.])])
4244 gcc_GAS_CHECK_FEATURE([.module support],
4245 gcc_cv_as_mips_dot_module,,,
4247 [AC_DEFINE(HAVE_AS_DOT_MODULE, 1,
4248 [Define if your assembler supports .module.])])
4249 if test x$gcc_cv_as_mips_dot_module = xno \
4250 && test x$with_fp_32 != x; then
4252 [Requesting --with-fp-32= requires assembler support for .module.])
4255 gcc_GAS_CHECK_FEATURE([.micromips support],
4256 gcc_cv_as_micromips_support,,[--fatal-warnings],
4258 [AC_DEFINE(HAVE_GAS_MICROMIPS, 1,
4259 [Define if your assembler supports the .set micromips directive])])
4261 gcc_GAS_CHECK_FEATURE([.dtprelword support],
4262 gcc_cv_as_mips_dtprelword, [2,18,0],,
4263 [.section .tdata,"awT",@progbits
4267 .dtprelword x+0x8000],,
4268 [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
4269 [Define if your assembler supports .dtprelword.])])
4271 gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
4272 gcc_cv_as_mips_dspr1_mult,,,
4282 [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
4283 [Define if your assembler supports DSPR1 mult.])])
4285 AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
4286 gcc_cv_as_ld_jalr_reloc=no
4287 if test $gcc_cv_as_mips_explicit_relocs = yes; then
4288 if test $in_tree_ld = yes ; then
4289 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 \
4290 && test $in_tree_ld_is_elf = yes; then
4291 gcc_cv_as_ld_jalr_reloc=yes
4293 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
4294 echo ' .ent x' > conftest.s
4295 echo 'x: lw $2,%got_disp(y)($3)' >> conftest.s
4296 echo ' lw $25,%call16(y)($28)' >> conftest.s
4297 echo ' .reloc 1f,R_MIPS_JALR,y' >> conftest.s
4298 echo '1: jalr $25' >> conftest.s
4299 echo ' .reloc 1f,R_MIPS_JALR,x' >> conftest.s
4300 echo '1: jalr $25' >> conftest.s
4301 echo ' .end x' >> conftest.s
4302 if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
4303 && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
4304 if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
4305 && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
4306 gcc_cv_as_ld_jalr_reloc=yes
4312 if test $gcc_cv_as_ld_jalr_reloc = yes; then
4313 if test x$target_cpu_default = x; then
4314 target_cpu_default=MASK_RELAX_PIC_CALLS
4316 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
4319 AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
4321 AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
4322 [gcc_cv_ld_mips_personality_relaxation],
4323 [gcc_cv_ld_mips_personality_relaxation=no
4324 if test $in_tree_ld = yes ; then
4325 if test "$gcc_cv_gld_major_version" -eq 2 \
4326 -a "$gcc_cv_gld_minor_version" -ge 21 \
4327 -o "$gcc_cv_gld_major_version" -gt 2; then
4328 gcc_cv_ld_mips_personality_relaxation=yes
4330 elif test x$gcc_cv_as != x \
4331 -a x$gcc_cv_ld != x \
4332 -a x$gcc_cv_readelf != x ; then
4333 cat > conftest.s <<EOF
4335 .cfi_personality 0x80,indirect_ptr
4342 .section .data,"aw",@progbits
4346 if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
4347 && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
4348 if $gcc_cv_readelf -d conftest 2>&1 \
4349 | grep TEXTREL > /dev/null 2>&1; then
4351 elif $gcc_cv_readelf --relocs conftest 2>&1 \
4352 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
4355 gcc_cv_ld_mips_personality_relaxation=yes
4359 rm -f conftest.s conftest.o conftest])
4360 if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
4361 AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
4362 [Define if your linker can relax absolute .eh_frame personality
4363 pointers into PC-relative form.])
4366 gcc_GAS_CHECK_FEATURE([-mnan= support],
4367 gcc_cv_as_mips_nan,,
4369 [AC_DEFINE(HAVE_AS_NAN, 1,
4370 [Define if the assembler understands -mnan=.])])
4371 if test x$gcc_cv_as_mips_nan = xno \
4372 && test x$with_nan != x; then
4374 [Requesting --with-nan= requires assembler support for -mnan=])
4379 # Mips and HP-UX need the GNU assembler.
4380 # Linux on IA64 might be able to use the Intel assembler.
4383 mips*-*-* | *-*-hpux* )
4384 if test x$gas_flag = xyes \
4385 || test x"$host" != x"$build" \
4386 || test ! -x "$gcc_cv_as" \
4387 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
4390 echo "*** This configuration requires the GNU assembler" >&2
4396 # ??? Not all targets support dwarf2 debug_line, even within a version
4397 # of gas. Moreover, we need to emit a valid instruction to trigger any
4398 # info to the output file. So, as supported targets are added to gas 2.11,
4399 # add some instruction here to (also) show we expect this might work.
4400 # ??? Once 2.11 is released, probably need to add first known working
4401 # version to the per-target configury.
4403 aarch64 | alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze \
4404 | mips | nios2 | pa | rs6000 | score | sparc | spu | tilegx | tilepro \
4405 | xstormy16 | xtensa)
4415 if test x"$insn" != x; then
4417 .file 1 \"conftest.s\"
4420 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
4421 gcc_cv_as_dwarf2_debug_line,
4422 [elf,2,11,0],, [$conftest_s],
4423 [if test x$gcc_cv_objdump != x \
4424 && $gcc_cv_objdump -h conftest.o 2> /dev/null \
4425 | grep debug_line > /dev/null 2>&1; then
4426 gcc_cv_as_dwarf2_debug_line=yes
4429 # The .debug_line file table must be in the exact order that
4430 # we specified the files, since these indices are also used
4431 # by DW_AT_decl_file. Approximate this test by testing if
4432 # the assembler bitches if the same index is assigned twice.
4433 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
4434 gcc_cv_as_dwarf2_file_buggy,,,
4438 if test $gcc_cv_as_dwarf2_debug_line = yes \
4439 && test $gcc_cv_as_dwarf2_file_buggy = no; then
4440 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
4441 [Define if your assembler supports dwarf2 .file/.loc directives,
4442 and preserves file table indices exactly as given.])
4445 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
4446 gcc_cv_as_gdwarf2_flag,
4447 [elf,2,11,0], [--gdwarf2], [$insn],,
4448 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
4449 [Define if your assembler supports the --gdwarf2 option.])])
4451 gcc_GAS_CHECK_FEATURE([--gstabs option],
4452 gcc_cv_as_gstabs_flag,
4453 [elf,2,11,0], [--gstabs], [$insn],,
4454 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
4455 [Define if your assembler supports the --gstabs option.])])
4457 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
4458 gcc_cv_as_debug_prefix_map_flag,
4459 [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
4460 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
4461 [Define if your assembler supports the --debug-prefix-map option.])])
4464 gcc_GAS_CHECK_FEATURE([compressed debug sections],
4465 gcc_cv_as_compress_debug,,[--compress-debug-sections],,
4466 [# gas compiled without zlib cannot compress debug sections and warns
4467 # about it, but still exits successfully. So check for this, too.
4468 if $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null
4470 gcc_cv_as_compress_debug=0
4471 elif $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s > /dev/null 2>&1
4473 gcc_cv_as_compress_debug=1
4474 gcc_cv_as_compress_debug_option="--compress-debug-sections"
4475 gcc_cv_as_no_compress_debug_option="--nocompress-debug-sections"
4477 gcc_cv_as_compress_debug=0
4478 # FIXME: Future gas versions will support ELF gABI style via
4479 # --compress-debug-sections[=type].
4481 AC_DEFINE_UNQUOTED(HAVE_AS_COMPRESS_DEBUG, $gcc_cv_as_compress_debug,
4482 [Define to the level of your assembler's compressed debug section support.])
4483 AC_DEFINE_UNQUOTED(AS_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_compress_debug_option",
4484 [Define to the assembler option to enable compressed debug sections.])
4485 AC_DEFINE_UNQUOTED(AS_NO_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_no_compress_debug_option",
4486 [Define to the assembler option to disable compressed debug sections.])
4488 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
4491 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
4492 [Define if your assembler supports .lcomm with an alignment field.])])
4494 if test x$with_sysroot = x && test x$host = x$target \
4495 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4496 && test "$prefix" != "NONE"; then
4497 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4498 [Define to PREFIX/include if cpp should also search that directory.])
4501 # Determine the version of glibc, if any, used on the target.
4502 AC_MSG_CHECKING([for target glibc version])
4503 AC_ARG_WITH([glibc-version],
4504 [AS_HELP_STRING([--with-glibc-version=M.N],
4505 [assume GCC used with glibc version M.N or later])], [
4506 if [echo "$with_glibc_version" | grep '^[0-9][0-9]*\.[0-9][0-9]*$']; then
4507 glibc_version_major=`echo "$with_glibc_version" | sed -e 's/\..*//'`
4508 glibc_version_minor=`echo "$with_glibc_version" | sed -e 's/.*\.//'`
4510 AC_MSG_ERROR([option --with-glibc-version requires a version number M.N])
4512 glibc_version_major=0
4513 glibc_version_minor=0
4514 [if test -f $target_header_dir/features.h \
4515 && glibc_version_major_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+[0-9]' $target_header_dir/features.h` \
4516 && glibc_version_minor_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+[0-9]' $target_header_dir/features.h`; then
4517 glibc_version_major=`echo "$glibc_version_major_define" | sed -e 's/.*__GLIBC__[ ]*//'`
4518 glibc_version_minor=`echo "$glibc_version_minor_define" | sed -e 's/.*__GLIBC_MINOR__[ ]*//'`
4520 AC_MSG_RESULT([$glibc_version_major.$glibc_version_minor])
4521 AC_DEFINE_UNQUOTED([TARGET_GLIBC_MAJOR], [$glibc_version_major],
4522 [GNU C Library major version number used on the target, or 0.])
4523 AC_DEFINE_UNQUOTED([TARGET_GLIBC_MINOR], [$glibc_version_minor],
4524 [GNU C Library minor version number used on the target, or 0.])
4526 AC_ARG_ENABLE(gnu-unique-object,
4527 [AS_HELP_STRING([--enable-gnu-unique-object],
4528 [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
4529 [case $enable_gnu_unique_object in
4531 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
4532 Valid choices are 'yes' and 'no'.]) ;;
4534 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
4536 [.type foo, '$target_type_format_char'gnu_unique_object],,
4537 # We need to unquote above to to use the definition from config.gcc.
4538 # Also check for ld.so support, i.e. glibc 2.11 or higher.
4539 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [11], [enable_gnu_unique_object=yes], )]
4541 if test x$enable_gnu_unique_object = xyes; then
4542 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
4543 [Define if your assembler supports @gnu_unique_object.])
4546 AC_CACHE_CHECK([assembler for tolerance to line number 0],
4547 [gcc_cv_as_line_zero],
4548 [gcc_cv_as_line_zero=no
4549 if test $in_tree_gas = yes; then
4550 gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
4551 elif test "x$gcc_cv_as" != x; then
4552 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
4553 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
4554 test "x`cat conftest.out`" = x
4556 gcc_cv_as_line_zero=yes
4558 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
4559 cat conftest.s >&AS_MESSAGE_LOG_FD
4560 echo "configure: error output was" >&AS_MESSAGE_LOG_FD
4561 cat conftest.out >&AS_MESSAGE_LOG_FD
4563 rm -f conftest.o conftest.s conftest.out
4565 if test "x$gcc_cv_as_line_zero" = xyes; then
4566 AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
4567 [Define if the assembler won't complain about a line such as # 0 "" 2.])
4570 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
4571 gcc_cv_ld_eh_frame_hdr=no
4572 if test $in_tree_ld = yes ; then
4573 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 \
4574 && test $in_tree_ld_is_elf = yes; then
4575 gcc_cv_ld_eh_frame_hdr=yes
4577 elif test x$gcc_cv_ld != x; then
4578 if echo "$ld_ver" | grep GNU > /dev/null; then
4579 # Check if linker supports --eh-frame-hdr option
4580 if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
4581 gcc_cv_ld_eh_frame_hdr=yes
4586 # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
4587 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
4588 gcc_cv_ld_eh_frame_hdr=yes
4594 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
4595 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
4596 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
4597 [Define if your linker supports .eh_frame_hdr.])
4599 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
4601 AC_MSG_CHECKING(linker CIEv3 in .eh_frame support)
4602 gcc_cv_ld_eh_frame_ciev3=no
4603 if test $in_tree_ld = yes ; then
4604 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 \
4605 && test $in_tree_ld_is_elf = yes; then
4606 gcc_cv_ld_eh_frame_ciev3=yes
4608 elif test x$gcc_cv_ld != x; then
4609 if echo "$ld_ver" | grep GNU > /dev/null; then
4610 gcc_cv_ld_eh_frame_ciev3=yes
4611 if test 0"$ld_date" -lt 20040513; then
4612 if test -n "$ld_date"; then
4613 # If there was date string, but was earlier than 2004-05-13, fail
4614 gcc_cv_ld_eh_frame_ciev3=no
4615 elif test "$ld_vers_major" -lt 2; then
4616 gcc_cv_ld_eh_frame_ciev3=no
4617 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
4618 gcc_cv_ld_eh_frame_ciev3=no
4624 # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1.
4625 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then
4626 gcc_cv_ld_eh_frame_ciev3=yes
4632 AC_DEFINE_UNQUOTED(HAVE_LD_EH_FRAME_CIEV3,
4633 [`if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi`],
4634 [Define 0/1 if your linker supports CIE v3 in .eh_frame.])
4635 AC_MSG_RESULT($gcc_cv_ld_eh_frame_ciev3)
4637 AC_MSG_CHECKING(linker position independent executable support)
4639 if test $in_tree_ld = yes ; then
4640 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 \
4641 && test $in_tree_ld_is_elf = yes; then
4644 elif test x$gcc_cv_ld != x; then
4645 # Check if linker supports -pie option
4646 if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
4650 if test x"$gcc_cv_ld_pie" = xyes; then
4651 AC_DEFINE(HAVE_LD_PIE, 1,
4652 [Define if your linker supports -pie option.])
4654 AC_MSG_RESULT($gcc_cv_ld_pie)
4656 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
4657 gcc_cv_ld_eh_gc_sections=no
4658 if test $in_tree_ld = yes ; then
4659 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 \
4660 && test $in_tree_ld_is_elf = yes; then
4661 gcc_cv_ld_eh_gc_sections=yes
4663 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
4664 cat > conftest.s <<EOF
4667 .type _start, @function
4670 .size _start, .-_start
4671 .section .text.foo,"ax",@progbits
4672 .type foo, @function
4676 .section .gcc_except_table.foo,"a",@progbits
4679 .section .eh_frame,"a",@progbits
4682 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4683 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4684 | grep "gc-sections option ignored" > /dev/null; then
4685 gcc_cv_ld_eh_gc_sections=no
4686 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4687 | grep gcc_except_table > /dev/null; then
4688 gcc_cv_ld_eh_gc_sections=yes
4689 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
4690 if test x$gcc_cv_as_comdat_group != xyes; then
4691 gcc_cv_ld_eh_gc_sections=no
4692 cat > conftest.s <<EOF
4695 .type _start, @function
4698 .size _start, .-_start
4699 .section .gnu.linkonce.t.foo,"ax",@progbits
4700 .type foo, @function
4704 .section .gcc_except_table.foo,"a",@progbits
4707 .section .eh_frame,"a",@progbits
4710 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4711 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4712 | grep "gc-sections option ignored" > /dev/null; then
4713 gcc_cv_ld_eh_gc_sections=no
4714 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4715 | grep gcc_except_table > /dev/null; then
4716 gcc_cv_ld_eh_gc_sections=yes
4722 rm -f conftest.s conftest.o conftest
4726 # ??? This apparently exposes a binutils bug with PC-relative relocations.
4727 gcc_cv_ld_eh_gc_sections=no
4730 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
4731 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
4732 [Define if your linker supports garbage collection of
4733 sections in presence of EH frames.])
4735 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
4737 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
4738 gcc_cv_ld_eh_gc_sections_bug=no
4739 if test $in_tree_ld = yes ; then
4740 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 \
4741 && test $in_tree_ld_is_elf = yes; then
4742 gcc_cv_ld_eh_gc_sections_bug=yes
4744 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
4745 gcc_cv_ld_eh_gc_sections_bug=yes
4746 cat > conftest.s <<EOF
4749 .type _start, @function
4752 .size _start, .-_start
4753 .section .text.startup.foo,"ax",@progbits
4754 .type foo, @function
4758 .section .gcc_except_table.foo,"a",@progbits
4761 .section .eh_frame,"a",@progbits
4764 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4765 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4766 | grep "gc-sections option ignored" > /dev/null; then
4768 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4769 | grep gcc_except_table > /dev/null; then
4770 gcc_cv_ld_eh_gc_sections_bug=no
4773 rm -f conftest.s conftest.o conftest
4775 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
4776 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
4777 [Define if your linker has buggy garbage collection of
4778 sections support when .text.startup.foo like sections are used.])
4780 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
4782 AC_MSG_CHECKING(linker for compressed debug sections)
4783 # gold/gld support compressed debug sections since binutils 2.19/2.21
4784 if test $in_tree_ld = yes ; then
4785 gcc_cv_ld_compress_debug=0
4786 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 \
4787 && test $in_tree_ld_is_elf = yes && test $ld_is_gold = yes; then
4788 gcc_cv_ld_compress_debug=2
4789 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
4790 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 \
4791 && test $in_tree_ld_is_elf = yes; then
4792 gcc_cv_ld_compress_debug=1
4794 elif echo "$ld_ver" | grep GNU > /dev/null; then
4795 gcc_cv_ld_compress_debug=1
4796 if test 0"$ld_date" -lt 20050308; then
4797 if test -n "$ld_date"; then
4798 # If there was date string, but was earlier than 2005-03-08, fail
4799 gcc_cv_ld_compress_debug=0
4800 elif test "$ld_vers_major" -lt 2; then
4801 gcc_cv_ld_compress_debug=0
4802 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 21; then
4803 gcc_cv_ld_compress_debug=0
4806 if test $ld_is_gold = yes; then
4807 gcc_cv_ld_compress_debug=2
4808 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
4814 # Introduced in Solaris 11.2.
4815 if $gcc_cv_ld --help 2>&1 | grep -- '-z compress-sections' > /dev/null; then
4816 gcc_cv_ld_compress_debug=3
4817 gcc_cv_ld_compress_debug_option="-z compress-sections"
4819 gcc_cv_ld_compress_debug=0
4823 # Assume linkers other than GNU ld don't support compessed debug
4825 gcc_cv_ld_compress_debug=0
4830 AC_DEFINE_UNQUOTED(HAVE_LD_COMPRESS_DEBUG, $gcc_cv_ld_compress_debug,
4831 [Define to the level of your linker's compressed debug section support.])
4832 AC_DEFINE_UNQUOTED(LD_COMPRESS_DEBUG_OPTION, "$gcc_cv_ld_compress_debug_option",
4833 [Define to the linker option to enable compressed debug sections.])
4834 AC_MSG_RESULT($gcc_cv_ld_compress_debug)
4840 AC_CACHE_CHECK(linker --as-needed support,
4841 gcc_cv_ld_as_needed,
4842 [gcc_cv_ld_as_needed=no
4843 gcc_cv_ld_as_needed_option='--as-needed'
4844 gcc_cv_ld_no_as_needed_option='--no-as-needed'
4845 if test $in_tree_ld = yes ; then
4846 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 \
4847 && test $in_tree_ld_is_elf = yes; then
4848 gcc_cv_ld_as_needed=yes
4850 elif test x$gcc_cv_ld != x; then
4851 # Check if linker supports --as-needed and --no-as-needed options
4852 if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
4853 gcc_cv_ld_as_needed=yes
4856 # Solaris 2 ld always supports -z ignore/-z record.
4858 gcc_cv_ld_as_needed=yes
4859 gcc_cv_ld_as_needed_option="-z ignore"
4860 gcc_cv_ld_no_as_needed_option="-z record"
4865 # --as-needed/-z ignore can only be used if libgcc_s.so.1 uses
4866 # dl_iterate_phdr, i.e. since Solaris 11.
4868 *-*-solaris2.1[[1-9]]*)
4870 i?86-*-* | x86_64-*-*)
4871 if echo "$ld_ver" | grep GNU > /dev/null; then
4872 # Doesn't work with gld on Solaris/x86 due to PR ld/12320.
4873 gcc_cv_ld_as_needed=no
4879 gcc_cv_ld_as_needed=no
4883 if test x"$gcc_cv_ld_as_needed" = xyes; then
4884 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
4885 [Define if your linker supports --as-needed/--no-as-needed or equivalent options.])
4886 AC_DEFINE_UNQUOTED(LD_AS_NEEDED_OPTION, "$gcc_cv_ld_as_needed_option",
4887 [Define to the linker option to ignore unused dependencies.])
4888 AC_DEFINE_UNQUOTED(LD_NO_AS_NEEDED_OPTION, "$gcc_cv_ld_no_as_needed_option",
4889 [Define to the linker option to keep unused dependencies.])
4892 AC_MSG_CHECKING(linker mapfile support for clearing hardware capabilities)
4893 saved_LDFLAGS="$LDFLAGS"
4894 for clearcap_map in sol2-clearcapv2.map sol2-clearcap.map; do
4895 LDFLAGS="$saved_LDFLAGS -Wl,-M,${srcdir}/config/$clearcap_map"
4896 AC_LINK_IFELSE([int main(void) {return 0;}],
4897 [gcc_cv_ld_clearcap=yes; break], [gcc_cv_ld_clearcap=no])
4899 LDFLAGS="$saved_LDFLAGS"
4900 if test "x$gcc_cv_ld_clearcap" = xyes; then
4901 AC_DEFINE([HAVE_LD_CLEARCAP], 1,
4902 [Define if the linker supports clearing hardware capabilities via mapfile.])
4903 AC_CONFIG_LINKS([clearcap.map:${srcdir}/config/$clearcap_map])
4905 AC_MSG_RESULT($gcc_cv_ld_clearcap)
4907 case "$target:$tm_file" in
4908 powerpc64-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
4911 emul_name="-melf64lppc"
4914 emul_name="-melf64ppc"
4917 emul_name="-melf64ppc_fbsd"
4920 AC_CACHE_CHECK(linker support for omitting dot symbols,
4921 gcc_cv_ld_no_dot_syms,
4922 [gcc_cv_ld_no_dot_syms=no
4923 if test x"$ld_is_gold" = xyes; then
4924 gcc_cv_ld_no_dot_syms=yes
4925 elif test $in_tree_ld = yes ; then
4926 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
4927 gcc_cv_ld_no_dot_syms=yes
4929 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4930 cat > conftest1.s <<EOF
4934 cat > conftest2.s <<EOF
4935 .section ".opd","aw"
4940 .quad .LEfoo,.TOC.@tocbase,0
4946 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4947 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4948 && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
4949 gcc_cv_ld_no_dot_syms=yes
4951 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
4954 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
4955 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
4956 [Define if your PowerPC64 linker only needs function descriptor syms.])
4959 AC_CACHE_CHECK(linker large toc support,
4960 gcc_cv_ld_large_toc,
4961 [gcc_cv_ld_large_toc=no
4962 if test x"$ld_is_gold" = xyes; then
4963 gcc_cv_ld_large_toc=yes
4964 elif test $in_tree_ld = yes ; then
4965 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
4966 gcc_cv_ld_large_toc=yes
4968 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4969 cat > conftest.s <<EOF
4970 .section ".tbss","awT",@nobits
4976 addis 9,13,ie0@got@tprel@ha
4977 ld 9,ie0@got@tprel@l(9)
4979 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
4980 && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
4981 gcc_cv_ld_large_toc=yes
4983 rm -f conftest conftest.o conftest.s
4986 if test x"$gcc_cv_ld_large_toc" = xyes; then
4987 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4988 [Define if your PowerPC64 linker supports a large TOC.])
4995 AC_CACHE_CHECK(linker large toc support,
4996 gcc_cv_ld_large_toc,
4997 [gcc_cv_ld_large_toc=no
4998 if test x$gcc_cv_as != x ; then
4999 cat > conftest.s <<EOF
5009 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1; then
5010 gcc_cv_ld_large_toc=yes
5012 rm -f conftest conftest.o conftest.s
5015 if test x"$gcc_cv_ld_large_toc" = xyes; then
5016 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
5017 [Define if your PowerPC64 linker supports a large TOC.])
5022 AC_CACHE_CHECK(linker --build-id support,
5024 [gcc_cv_ld_buildid=no
5025 if test $in_tree_ld = yes ; then
5026 if test "$gcc_cv_gld_major_version" -eq 2 -a \
5027 "$gcc_cv_gld_minor_version" -ge 18 -o \
5028 "$gcc_cv_gld_major_version" -gt 2 \
5029 && test $in_tree_ld_is_elf = yes; then
5030 gcc_cv_ld_buildid=yes
5032 elif test x$gcc_cv_ld != x; then
5033 if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
5034 gcc_cv_ld_buildid=yes
5037 if test x"$gcc_cv_ld_buildid" = xyes; then
5038 AC_DEFINE(HAVE_LD_BUILDID, 1,
5039 [Define if your linker supports --build-id.])
5042 AC_ARG_ENABLE(linker-build-id,
5043 [AS_HELP_STRING([--enable-linker-build-id],
5044 [compiler will always pass --build-id to linker])],
5046 enable_linker_build_id=no)
5048 if test x"$enable_linker_build_id" = xyes; then
5049 if test x"$gcc_cv_ld_buildid" = xyes; then
5050 AC_DEFINE(ENABLE_LD_BUILDID, 1,
5051 [Define if gcc should always pass --build-id to linker.])
5053 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
5057 # In binutils 2.21, GNU ld gained support for new emulations fully
5058 # supporting the Solaris 2 ABI. Detect their presence in the linker used.
5059 AC_CACHE_CHECK(linker *_sol2 emulation support,
5060 gcc_cv_ld_sol2_emulation,
5061 [gcc_cv_ld_sol2_emulation=no
5062 if test $in_tree_ld = yes ; then
5063 if test "$gcc_cv_gld_major_version" -eq 2 -a \
5064 "$gcc_cv_gld_minor_version" -ge 21 -o \
5065 "$gcc_cv_gld_major_version" -gt 2 \
5066 && test $in_tree_ld_is_elf = yes; then
5067 gcc_cv_ld_sol2_emulation=yes
5069 elif test x$gcc_cv_ld != x; then
5070 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
5071 grep _sol2 > /dev/null; then
5072 gcc_cv_ld_sol2_emulation=yes
5075 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
5076 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
5077 [Define if your linker supports the *_sol2 emulations.])
5080 AC_CACHE_CHECK(linker --sysroot support,
5082 [gcc_cv_ld_sysroot=no
5083 if test $in_tree_ld = yes ; then
5084 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
5085 gcc_cv_ld_sysroot=yes
5087 elif test x$gcc_cv_ld != x; then
5088 if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
5089 gcc_cv_ld_sysroot=yes
5092 if test x"$gcc_cv_ld_sysroot" = xyes; then
5093 AC_DEFINE(HAVE_LD_SYSROOT, 1,
5094 [Define if your linker supports --sysroot.])
5097 # Test for stack protector support in target C library.
5098 AC_CACHE_CHECK(__stack_chk_fail in target C library,
5099 gcc_cv_libc_provides_ssp,
5100 [gcc_cv_libc_provides_ssp=no
5102 *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
5103 # glibc 2.4 and later provides __stack_chk_fail and
5104 # either __stack_chk_guard, or TLS access to stack guard canary.
5105 GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_libc_provides_ssp=yes], [
5106 [if test -f $target_header_dir/features.h \
5107 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \
5108 $target_header_dir/features.h > /dev/null; then
5109 if $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \
5110 $target_header_dir/features.h > /dev/null && \
5111 test -f $target_header_dir/bits/uClibc_config.h && \
5112 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \
5113 $target_header_dir/bits/uClibc_config.h > /dev/null; then
5114 gcc_cv_libc_provides_ssp=yes
5116 # all versions of Bionic support stack protector
5117 elif test -f $target_header_dir/sys/cdefs.h \
5118 && $EGREP '^[ ]*#[ ]*define[ ]+__BIONIC__[ ]+1' \
5119 $target_header_dir/sys/cdefs.h > /dev/null; then
5120 gcc_cv_libc_provides_ssp=yes
5124 # Avoid complicated tests (see
5125 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
5126 # simply assert that glibc does provide this, which is true for all
5127 # realistically usable GNU/Hurd configurations.
5128 gcc_cv_libc_provides_ssp=yes;;
5129 *-*-darwin* | *-*-freebsd*)
5130 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
5131 [echo "no __stack_chk_fail on this target"])
5133 *) gcc_cv_libc_provides_ssp=no ;;
5136 if test x$gcc_cv_libc_provides_ssp = xyes; then
5137 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
5138 [Define if your target C library provides stack protector support])
5141 # Test for <sys/sdt.h> on the target.
5142 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
5143 AC_MSG_CHECKING(sys/sdt.h in the target C library)
5145 if test -f $target_header_dir/sys/sdt.h; then
5147 AC_DEFINE(HAVE_SYS_SDT_H, 1,
5148 [Define if your target C library provides sys/sdt.h])
5150 AC_MSG_RESULT($have_sys_sdt_h)
5152 # Check if TFmode long double should be used by default or not.
5153 # Some glibc targets used DFmode long double, but with glibc 2.4
5154 # and later they can use TFmode.
5156 powerpc*-*-linux* | \
5160 AC_ARG_WITH(long-double-128,
5161 [AS_HELP_STRING([--with-long-double-128],
5162 [use 128-bit long double by default])],
5163 gcc_cv_target_ldbl128="$with_long_double_128",
5164 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_target_ldbl128=yes], [
5165 [gcc_cv_target_ldbl128=no
5166 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \
5167 $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
5168 && gcc_cv_target_ldbl128=yes
5172 if test x$gcc_cv_target_ldbl128 = xyes; then
5173 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
5174 [Define if TFmode long double should be the default])
5177 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
5178 gcc_cv_target_dl_iterate_phdr=unknown
5180 # Restrict to Solaris 11+. While most of the Solaris 11 linker changes
5181 # were backported to Solaris 10 Update 10, dl_iterate_phdr only lives in
5182 # libdl there, both complicating its use and breaking compatibility
5183 # between Solaris 10 updates.
5184 *-*-solaris2.1[[1-9]]*)
5185 # <link.h> needs both a dl_iterate_phdr declaration and support for
5186 # compilation with largefile support.
5187 if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
5188 && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
5189 gcc_cv_target_dl_iterate_phdr=yes
5191 gcc_cv_target_dl_iterate_phdr=no
5194 *-*-dragonfly* | *-*-freebsd*)
5195 if grep dl_iterate_phdr $target_header_dir/sys/link_elf.h > /dev/null 2>&1; then
5196 gcc_cv_target_dl_iterate_phdr=yes
5198 gcc_cv_target_dl_iterate_phdr=no
5202 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
5203 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
5204 AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
5205 [Define if your target C library provides the `dl_iterate_phdr' function.])
5207 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
5209 # We no longer support different GC mechanisms. Emit an error if
5210 # the user configures with --with-gc.
5212 [AS_HELP_STRING([--with-gc={page,zone}],
5213 [this option is not supported anymore. It used to choose
5214 the garbage collection mechanism to use with the compiler])],
5215 [AC_MSG_ERROR([Configure option --with-gc is only supported up to GCC 4.7.x])],
5218 # Libraries to use on the host. This will normally be set by the top
5219 # level Makefile. Here we simply capture the value for our Makefile.
5220 if test -z "${HOST_LIBS+set}"; then
5225 # Use the system's zlib library.
5227 zlibinc="-I\$(srcdir)/../zlib"
5228 AC_ARG_WITH(system-zlib,
5229 [AS_HELP_STRING([--with-system-zlib], [use installed libz])],
5236 dnl Very limited version of automake's enable-maintainer-mode
5238 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
5239 dnl maintainer-mode is disabled by default
5240 AC_ARG_ENABLE(maintainer-mode,
5241 [AS_HELP_STRING([--enable-maintainer-mode],
5242 [enable make rules and dependencies not useful
5243 (and sometimes confusing) to the casual installer])],
5244 maintainer_mode=$enableval,
5247 AC_MSG_RESULT($maintainer_mode)
5249 if test "$maintainer_mode" = "yes"; then
5256 dnl Whether to prevent multiple front-ends from linking at the same time
5258 AC_MSG_CHECKING([whether to avoid linking multiple front-ends at once])
5259 AC_ARG_ENABLE(link-mutex,
5260 [AS_HELP_STRING([--enable-link-mutex],
5261 [avoid linking multiple front-ends at once to avoid thrashing
5262 on the build machine])],
5263 do_link_mutex=$enableval,
5265 AC_MSG_RESULT($do_link_mutex)
5267 if test "$do_link_mutex" = "yes"; then
5272 AC_SUBST(DO_LINK_MUTEX)
5278 # Make empty files to contain the specs and options for each language.
5279 # Then add #include lines to for a compiler that has specs and/or options.
5285 # These (without "all_") are set in each config-lang.in.
5286 # `language' must be a single word so is spelled singularly.
5289 all_outputs='Makefile'
5290 # List of language makefile fragments.
5292 # Additional files for gengtype
5293 all_gtfiles="$target_gtfiles"
5295 # These are the languages that are set in --enable-languages,
5296 # and are available in the GCC tree.
5297 all_selected_languages=
5299 # Add the language fragments.
5300 # Languages are added via two mechanisms. Some information must be
5301 # recorded in makefile variables, these are defined in config-lang.in.
5302 # We accumulate them and plug them into the main Makefile.
5303 # The other mechanism is a set of hooks for each of the main targets
5304 # like `clean', `install', etc.
5306 language_hooks="Make-hooks"
5308 for lang in ${srcdir}/*/config-lang.in
5311 test "$lang" = "${srcdir}/*/config-lang.in" && continue
5313 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
5314 if test "x$lang_alias" = x
5316 echo "$lang doesn't set \$language." 1>&2
5319 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
5320 subdirs="$subdirs $subdir"
5322 # $gcc_subdir is where the gcc integration files are to be found
5323 # for a language, both for internal compiler purposes (compiler
5324 # sources implementing front-end to GCC tree converters), and for
5325 # build infrastructure purposes (Make-lang.in, etc.)
5327 # This will be <subdir> (relative to $srcdir) if a line like
5328 # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
5329 # is found in <langdir>/config-lang.in, and will remain <langdir>
5332 # Except for the language alias (fetched above), the regular
5333 # "config-lang.in" contents are always retrieved from $gcc_subdir,
5334 # so a <langdir>/config-lang.in setting gcc_subdir typically sets
5335 # only this and the language alias.
5337 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang`
5338 if [ "$gcc_subdir" = "" ]; then
5339 gcc_subdir="$subdir"
5342 case ",$enable_languages," in
5344 all_selected_languages="$all_selected_languages $lang_alias"
5345 if test -f $srcdir/$gcc_subdir/lang-specs.h; then
5346 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
5358 . ${srcdir}/$gcc_subdir/config-lang.in
5359 if test "x$language" = x
5361 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
5366 case ",$enable_languages," in
5369 for i in $subdir_requires; do
5370 test -f "${srcdir}/$i/config-lang.in" && continue
5378 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
5379 if test -f $srcdir/$gcc_subdir/lang.opt; then
5380 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
5381 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
5383 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
5384 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
5386 all_languages="$all_languages $language"
5387 all_compilers="$all_compilers $compilers"
5388 all_outputs="$all_outputs $outputs"
5389 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
5390 case ",$enable_languages," in
5392 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
5394 AC_SUBST(enable_lto)
5401 for language in $all_selected_languages
5403 check_languages="$check_languages check-$language"
5406 # We link each language in with a set of hooks, reached indirectly via
5407 # lang.${target}. Only do so for selected languages.
5411 target_list="all.cross start.encap rest.encap tags \
5412 install-common install-man install-info install-pdf install-html dvi \
5413 pdf html uninstall info man srcextra srcman srcinfo \
5414 mostlyclean clean distclean maintainer-clean install-plugin"
5416 for t in $target_list
5419 for lang in $all_selected_languages
5423 echo "lang.$t: $x" >> Make-hooks
5427 # Option include files
5430 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
5431 option_includes="option-includes.mk"
5432 AC_SUBST_FILE(option_includes)
5440 echo "dir ." > .gdbinit
5441 echo "dir ${srcdir}" >> .gdbinit
5442 if test x$gdb_needs_out_file_path = xyes
5444 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
5446 if test "x$subdirs" != x; then
5449 echo "dir ${srcdir}/$s" >> .gdbinit
5452 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
5453 echo "python import sys; sys.path.append('${srcdir}'); import gdbhooks" >> .gdbinit
5455 # Put a breakpoint on __asan_report_error to help with debugging buffer
5458 *-fsanitize=address*)
5459 echo "source ${srcdir}/gdbasan.in" >> .gdbinit
5463 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
5464 AC_SUBST(gcc_tooldir)
5467 # Find a directory in which to install a shared libgcc.
5469 AC_ARG_ENABLE(version-specific-runtime-libs,
5470 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
5471 [specify that runtime libraries should be
5472 installed in a compiler-specific directory])])
5474 # Substitute configuration variables
5477 AC_SUBST(all_compilers)
5478 AC_SUBST(all_gtfiles)
5479 AC_SUBST(all_lang_makefrags)
5480 AC_SUBST(all_languages)
5481 AC_SUBST(all_selected_languages)
5482 AC_SUBST(build_exeext)
5483 AC_SUBST(build_install_headers_dir)
5484 AC_SUBST(build_xm_file_list)
5485 AC_SUBST(build_xm_include_list)
5486 AC_SUBST(build_xm_defines)
5487 AC_SUBST(build_file_translate)
5488 AC_SUBST(check_languages)
5489 AC_SUBST(cpp_install_dir)
5490 AC_SUBST(xmake_file)
5491 AC_SUBST(tmake_file)
5492 AC_SUBST(TM_ENDIAN_CONFIG)
5493 AC_SUBST(TM_MULTILIB_CONFIG)
5494 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
5495 AC_SUBST(extra_gcc_objs)
5496 AC_SUBST(user_headers_inc_next_pre)
5497 AC_SUBST(user_headers_inc_next_post)
5498 AC_SUBST(extra_headers_list)
5499 AC_SUBST(extra_objs)
5500 AC_SUBST(extra_programs)
5501 AC_SUBST(float_h_file)
5502 AC_SUBST(gcc_config_arguments)
5503 AC_SUBST(gcc_gxx_include_dir)
5504 AC_SUBST(gcc_gxx_include_dir_add_sysroot)
5505 AC_SUBST(host_exeext)
5506 AC_SUBST(host_xm_file_list)
5507 AC_SUBST(host_xm_include_list)
5508 AC_SUBST(host_xm_defines)
5509 AC_SUBST(out_host_hook_obj)
5511 AC_SUBST(lang_opt_files)
5512 AC_SUBST(lang_specs_files)
5513 AC_SUBST(lang_tree_files)
5514 AC_SUBST(local_prefix)
5516 AC_SUBST(objc_boehm_gc)
5518 AC_SUBST(out_object_file)
5519 AC_SUBST(common_out_file)
5520 AC_SUBST(common_out_object_file)
5521 AC_SUBST(tm_file_list)
5522 AC_SUBST(tm_include_list)
5523 AC_SUBST(tm_defines)
5524 AC_SUBST(tm_p_file_list)
5525 AC_SUBST(tm_p_include_list)
5526 AC_SUBST(xm_file_list)
5527 AC_SUBST(xm_include_list)
5528 AC_SUBST(xm_defines)
5529 AC_SUBST(use_gcc_stdint)
5530 AC_SUBST(c_target_objs)
5531 AC_SUBST(cxx_target_objs)
5532 AC_SUBST(fortran_target_objs)
5533 AC_SUBST(target_cpu_default)
5535 AC_SUBST_FILE(language_hooks)
5538 if test x${build} = x${host} ; then
5539 if test x${host} = x${target} ; then
5540 echo "Links are now set up to build a native compiler for ${target}." 1>&2
5542 echo "Links are now set up to build a cross-compiler" 1>&2
5543 echo " from ${host} to ${target}." 1>&2
5546 if test x${host} = x${target} ; then
5547 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
5548 echo " for ${target}." 1>&2
5550 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
5551 echo " from ${host} to ${target}." 1>&2
5555 AC_ARG_VAR(GMPLIBS,[How to link GMP])
5556 AC_ARG_VAR(GMPINC,[How to find GMP include files])
5558 AC_ARG_VAR(ISLLIBS,[How to link ISL])
5559 AC_ARG_VAR(ISLINC,[How to find ISL include files])
5560 if test "x${ISLLIBS}" != "x" ; then
5561 AC_DEFINE(HAVE_isl, 1, [Define if isl is in use.])
5565 AC_SUBST(pluginlibs)
5566 AC_SUBST(enable_plugin)
5567 if test x"$enable_plugin" = x"yes"; then
5568 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
5572 # Enable --enable-host-shared
5573 AC_ARG_ENABLE(host-shared,
5574 [AS_HELP_STRING([--enable-host-shared],
5575 [build host code as shared libraries])],
5576 [PICFLAG=-fPIC], [PICFLAG=])
5577 AC_SUBST(enable_host_shared)
5581 AC_ARG_ENABLE(libquadmath-support,
5582 [AS_HELP_STRING([--disable-libquadmath-support],
5583 [disable libquadmath support for Fortran])],
5584 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
5585 ENABLE_LIBQUADMATH_SUPPORT=yes)
5586 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
5587 AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
5588 [Define to 1 to enable libquadmath support])
5592 # Specify what hash style to use by default.
5593 AC_ARG_WITH([linker-hash-style],
5594 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
5595 [specify the linker hash style])],
5596 [case x"$withval" in
5598 LINKER_HASH_STYLE=sysv
5601 LINKER_HASH_STYLE=gnu
5604 LINKER_HASH_STYLE=both
5607 AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
5610 [LINKER_HASH_STYLE=''])
5611 if test x"${LINKER_HASH_STYLE}" != x; then
5612 AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
5613 [The linker hash style])
5616 # Generate gcc-driver-name.h containing GCC_DRIVER_NAME for the benefit
5617 # of jit/jit-playback.c.
5618 cat > gcc-driver-name.h <<EOF
5619 #define GCC_DRIVER_NAME "${target_noncanonical}-gcc-${gcc_BASEVER}${exeext}"
5622 # Configure the subdirectories
5623 # AC_CONFIG_SUBDIRS($subdirs)
5625 # Create the Makefile
5626 # and configure language subdirectories
5627 AC_CONFIG_FILES($all_outputs)
5629 AC_CONFIG_COMMANDS([default],
5631 case ${CONFIG_HEADERS} in
5632 *auto-host.h:config.in*)
5635 # Make sure all the subdirs exist.
5636 for d in $subdirs doc build common c-family
5638 test -d $d || mkdir $d
5641 [subdirs='$subdirs'])