2 # Process this file with autoconf to generate a configuration script.
4 # Copyright (C) 1997-2016 Free Software Foundation, Inc.
6 #This file is part of GCC.
8 #GCC is free software; you can redistribute it and/or modify it under
9 #the terms of the GNU General Public License as published by the Free
10 #Software Foundation; either version 3, or (at your option) any later
13 #GCC is distributed in the hope that it will be useful, but WITHOUT
14 #ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 #FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 #You should have received a copy of the GNU General Public License
19 #along with GCC; see the file COPYING3. If not see
20 #<http://www.gnu.org/licenses/>.
22 # --------------------------------
23 # Initialization and sanity checks
24 # --------------------------------
28 AC_CONFIG_SRCDIR(tree.c)
29 AC_CONFIG_HEADER(auto-host.h:config.in)
31 gcc_version=`cat $srcdir/BASE-VER`
33 # Determine the host, build, and target systems
38 # Determine the noncanonical target name, for directory use.
39 ACX_NONCANONICAL_TARGET
41 # Used for constructing correct paths for offload compilers.
42 real_target_noncanonical=${target_noncanonical}
45 # Determine the target- and build-specific subdirectories
48 # Set program_transform_name
51 # Check for bogus environment variables.
52 # Test if LIBRARY_PATH contains the notation for the current directory
53 # since this would lead to problems installing/building glibc.
54 # LIBRARY_PATH contains the current directory if one of the following
56 # - one of the terminals (":" and ";") is the first or last sign
57 # - two terminals occur directly after each other
58 # - the path contains an element with a dot in it
59 AC_MSG_CHECKING(LIBRARY_PATH variable)
61 case ${LIBRARY_PATH} in
62 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
63 library_path_setting="contains current directory"
66 library_path_setting="ok"
70 AC_MSG_RESULT($library_path_setting)
71 if test "$library_path_setting" != "ok"; then
73 *** LIBRARY_PATH shouldn't contain the current directory when
74 *** building gcc. Please change the environment variable
75 *** and run configure again.])
78 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
79 # since this would lead to problems installing/building glibc.
80 # GCC_EXEC_PREFIX contains the current directory if one of the following
82 # - one of the terminals (":" and ";") is the first or last sign
83 # - two terminals occur directly after each other
84 # - the path contains an element with a dot in it
85 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
87 case ${GCC_EXEC_PREFIX} in
88 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
89 gcc_exec_prefix_setting="contains current directory"
92 gcc_exec_prefix_setting="ok"
96 AC_MSG_RESULT($gcc_exec_prefix_setting)
97 if test "$gcc_exec_prefix_setting" != "ok"; then
99 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
100 *** building gcc. Please change the environment variable
101 *** and run configure again.])
108 # Specify the local prefix
110 AC_ARG_WITH(local-prefix,
111 [AS_HELP_STRING([--with-local-prefix=DIR],
112 [specifies directory to put local include])],
113 [case "${withval}" in
114 yes) AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
116 *) local_prefix=$with_local_prefix ;;
119 # Default local prefix if it is empty
120 if test x$local_prefix = x; then
121 local_prefix=/usr/local
124 AC_ARG_WITH([native-system-header-dir],
125 [ --with-native-system-header-dir=dir
126 use dir as the directory to look for standard
127 system header files in. Defaults to /usr/include.],
129 case ${with_native_system_header_dir} in
130 yes|no) AC_MSG_ERROR([bad value ${withval} given for --with-native-system-header-dir]) ;;
131 /* | [[A-Za-z]]:[[\\/]]*) ;;
132 *) AC_MSG_ERROR([--with-native-system-header-dir argument ${withval} must be an absolute directory]) ;;
134 configured_native_system_header_dir="${withval}"
135 ], [configured_native_system_header_dir=])
137 AC_ARG_WITH(build-sysroot,
138 [AS_HELP_STRING([--with-build-sysroot=sysroot],
139 [use sysroot as the system root during the build])],
140 [if test x"$withval" != x ; then
141 SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
143 [SYSROOT_CFLAGS_FOR_TARGET=])
144 AC_SUBST(SYSROOT_CFLAGS_FOR_TARGET)
146 if test "x$prefix" = xNONE; then
147 test_prefix=/usr/local
151 if test "x$exec_prefix" = xNONE; then
152 test_exec_prefix=$test_prefix
154 test_exec_prefix=$exec_prefix
158 [AS_HELP_STRING([[--with-sysroot[=DIR]]],
159 [search for usr/lib, usr/include, et al, within DIR])],
161 case ${with_sysroot} in
163 */) with_sysroot=`echo $with_sysroot | sed 's,/$,,'` ;;
165 case ${with_sysroot} in
166 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
167 *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
170 TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
171 CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
173 case ${TARGET_SYSTEM_ROOT} in
174 "${test_prefix}"|"${test_prefix}/"*|\
175 "${test_exec_prefix}"|"${test_exec_prefix}/"*|\
176 '${prefix}'|'${prefix}/'*|\
177 '${exec_prefix}'|'${exec_prefix}/'*)
178 t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
179 TARGET_SYSTEM_ROOT_DEFINE="$t"
184 TARGET_SYSTEM_ROOT_DEFINE=
185 CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
187 AC_SUBST(TARGET_SYSTEM_ROOT)
188 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
189 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
191 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
192 # passed in by the toplevel make and thus we'd get different behavior
193 # depending on where we built the sources.
195 # Specify the g++ header file directory
196 AC_ARG_WITH(gxx-include-dir,
197 [AS_HELP_STRING([--with-gxx-include-dir=DIR],
198 [specifies directory to put g++ header files])],
199 [case "${withval}" in
200 yes) AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
202 *) gcc_gxx_include_dir=$with_gxx_include_dir ;;
205 # This logic must match libstdc++-v3/acinclude.m4:GLIBCXX_EXPORT_INSTALL_INFO.
206 if test x${gcc_gxx_include_dir} = x; then
207 if test x${enable_version_specific_runtime_libs} = xyes; then
208 gcc_gxx_include_dir='${libsubdir}/include/c++'
210 libstdcxx_incdir='include/c++/$(version)'
211 if test x$host != x$target; then
212 libstdcxx_incdir="$target_alias/$libstdcxx_incdir"
214 gcc_gxx_include_dir="\$(libsubdir)/\$(libsubdir_to_prefix)$libstdcxx_incdir"
218 gcc_gxx_include_dir_add_sysroot=0
219 if test "${with_sysroot+set}" = set; then
220 gcc_gxx_without_sysroot=`expr "${gcc_gxx_include_dir}" : "${with_sysroot}"'\(.*\)'`
221 if test "${gcc_gxx_without_sysroot}"; then
222 if test x${with_sysroot} != x/; then
223 gcc_gxx_include_dir="${gcc_gxx_without_sysroot}"
225 gcc_gxx_include_dir_add_sysroot=1
229 AC_ARG_WITH(cpp_install_dir,
230 [AC_HELP_STRING([--with-cpp-install-dir=DIR],
231 [install the user visible C preprocessor in DIR
232 (relative to PREFIX) as well as PREFIX/bin])],
233 [if test x$withval = xyes; then
234 AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
235 elif test x$withval != xno; then
236 cpp_install_dir=$withval
239 # We would like to our source tree to be readonly. However when releases or
240 # pre-releases are generated, the flex/bison generated files as well as the
241 # various formats of manuals need to be included along with the rest of the
242 # sources. Therefore we have --enable-generated-files-in-srcdir to do
245 AC_MSG_CHECKING([whether to place generated files in the source directory])
246 dnl generated-files-in-srcdir is disabled by default
247 AC_ARG_ENABLE(generated-files-in-srcdir,
248 [AS_HELP_STRING([--enable-generated-files-in-srcdir],
249 [put copies of generated files in source dir
250 intended for creating source tarballs for users
251 without texinfo bison or flex])],
252 generated_files_in_srcdir=$enableval,
253 generated_files_in_srcdir=no)
255 AC_MSG_RESULT($generated_files_in_srcdir)
257 if test "$generated_files_in_srcdir" = "yes"; then
264 # -------------------
265 # Find default linker
266 # -------------------
270 [AS_HELP_STRING([--with-gnu-ld], [arrange to work with GNU ld])],
271 gnu_ld_flag="$with_gnu_ld",
274 # With pre-defined ld
276 [AS_HELP_STRING([--with-ld], [arrange to use the specified ld (full pathname)])],
277 DEFAULT_LINKER="$with_ld")
278 if test x"${DEFAULT_LINKER+set}" = x"set"; then
279 if test ! -x "$DEFAULT_LINKER"; then
280 AC_MSG_ERROR([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
281 elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
284 AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
285 [Define to enable the use of a default linker.])
288 AC_MSG_CHECKING([whether a default linker was specified])
289 if test x"${DEFAULT_LINKER+set}" = x"set"; then
290 if test x"$gnu_ld_flag" = x"no"; then
291 AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
293 AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
299 # With demangler in GNU ld
300 AC_ARG_WITH(demangler-in-ld,
301 [AS_HELP_STRING([--with-demangler-in-ld], [try to use demangler in GNU ld])],
302 demangler_in_ld="$with_demangler_in_ld",
305 # ----------------------
306 # Find default assembler
307 # ----------------------
311 [AS_HELP_STRING([--with-gnu-as], [arrange to work with GNU as])],
312 gas_flag="$with_gnu_as",
316 [AS_HELP_STRING([--with-as], [arrange to use the specified as (full pathname)])],
317 DEFAULT_ASSEMBLER="$with_as")
318 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
319 if test ! -x "$DEFAULT_ASSEMBLER"; then
320 AC_MSG_ERROR([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
321 elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
324 AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
325 [Define to enable the use of a default assembler.])
328 AC_MSG_CHECKING([whether a default assembler was specified])
329 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
330 if test x"$gas_flag" = x"no"; then
331 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
333 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
343 # If a non-executable a.out is present (e.g. created by GNU as above even if
344 # invoked with -v only), the IRIX 6 native ld just overwrites the existing
345 # file, even when creating an executable, so an execution test fails.
346 # Remove possible default executable files to avoid this.
348 # FIXME: This really belongs into AC_PROG_CC and can be removed once
349 # Autoconf includes it.
350 rm -f a.out a.exe b.out
352 # Find the native compiler
355 ACX_PROG_GNAT([-I"$srcdir"/ada])
357 # Do configure tests with the C++ compiler, since that's what we build with.
360 # Remove the -O2: for historical reasons, unless bootstrapping we prefer
361 # optimizations to be activated explicitly by the toplevel.
364 *) CFLAGS=`echo "$CFLAGS " | sed -e "s/-Ofast[[ ]]//" -e "s/-O[[gs]][[ ]]//" -e "s/-O[[0-9]]*[[ ]]//" `
365 CXXFLAGS=`echo "$CXXFLAGS " | sed -e "s/-Ofast[[ ]]//" -e "s/-O[[gs]][[ ]]//" -e "s/-O[[0-9]]*[[ ]]//" ` ;;
370 # Determine PICFLAG for target gnatlib.
371 GCC_PICFLAG_FOR_TARGET
372 AC_SUBST(PICFLAG_FOR_TARGET)
374 # -------------------------
375 # Check C compiler features
376 # -------------------------
378 AC_USE_SYSTEM_EXTENSIONS
384 # sizeof(char) is 1 by definition.
385 AC_CHECK_SIZEOF(void *)
386 AC_CHECK_SIZEOF(short)
388 AC_CHECK_SIZEOF(long)
389 AC_CHECK_TYPES([long long], [AC_CHECK_SIZEOF(long long)])
391 if test x"$ac_cv_c_uint64_t" = x"no" -o x"$ac_cv_c_int64_t" = x"no"; then
392 AC_MSG_ERROR([uint64_t or int64_t not found])
395 # check what underlying integer type int64_t uses
396 AC_CACHE_CHECK(for int64_t underlying type, ac_cv_int64_t_type, [
397 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
401 template <typename T> struct X { };
403 struct X<long> { typedef long t; };
404 ]], [[X<int64_t>::t x;]])],[ac_cv_int64_t_type=long],[ac_cv_int64_t_type="long long"])])
405 if test "$ac_cv_int64_t_type" = "long"; then
406 AC_DEFINE(INT64_T_IS_LONG, 1,
407 [Define if int64_t uses long as underlying type.])
409 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
413 template <typename T> struct X { };
415 struct X<long long> { typedef long long t; };
416 ]], [[X<int64_t>::t x;]])],[],[AC_MSG_ERROR([error verifying int64_t uses long long])])
419 AC_CACHE_CHECK(for std::swap in <utility>, ac_cv_std_swap_in_utility, [
420 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
422 ]], [[int a, b; std::swap(a,b);]])],[ac_cv_std_swap_in_utility=yes],[ac_cv_std_swap_in_utility=no])])
423 if test $ac_cv_std_swap_in_utility = yes; then
424 AC_DEFINE(HAVE_SWAP_IN_UTILITY, 1,
425 [Define if <utility> defines std::swap.])
428 # Check whether compiler is affected by placement new aliasing bug (PR 29286).
429 # If the host compiler is affected by the bug, and we build with optimization
430 # enabled (which happens e.g. when cross-compiling), the pool allocator may
431 # get miscompiled. Use -fno-strict-aliasing to work around this problem.
432 # Since there is no reliable feature check for the presence of this bug,
433 # we simply use a GCC version number check. (This should never trigger for
434 # stages 2 or 3 of a native bootstrap.)
436 if test "$GCC" = yes; then
437 saved_CXXFLAGS="$CXXFLAGS"
439 # The following test compilation will succeed if and only if $CXX accepts
440 # -fno-strict-aliasing *and* is older than GCC 4.3.
441 CXXFLAGS="$CXXFLAGS -fno-strict-aliasing"
442 AC_MSG_CHECKING([whether $CXX is affected by placement new aliasing bug])
444 #if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
445 #error compiler not affected by placement new aliasing bug
448 [AC_MSG_RESULT([yes]); aliasing_flags='-fno-strict-aliasing'],
449 [AC_MSG_RESULT([no])])
451 CXXFLAGS="$saved_CXXFLAGS"
453 AC_SUBST(aliasing_flags)
457 # ---------------------
458 # Warnings and checking
459 # ---------------------
461 # Check $CC warning features (if it's GCC).
462 # We want to use -pedantic, but we don't want warnings about
466 # * C++11 narrowing conversions in { }
467 # So, we only use -pedantic if we can disable those warnings.
469 # In stage 1, disable -Wformat warnings from old GCCs about new % codes
470 AC_ARG_ENABLE(build-format-warnings,
471 AS_HELP_STRING([--disable-build-format-warnings],[don't use -Wformat while building GCC]),
472 [],[enable_build_format_warnings=yes])
473 AS_IF([test $enable_build_format_warnings = no],
474 [wf_opt=-Wno-format],[wf_opt=])
475 ACX_PROG_CXX_WARNING_OPTS(
476 m4_quote(m4_do([-W -Wall -Wno-narrowing -Wwrite-strings -Wcast-qual $wf_opt])), [loose_warn])
477 ACX_PROG_CC_WARNING_OPTS(
478 m4_quote(m4_do([-Wstrict-prototypes -Wmissing-prototypes])),
480 ACX_PROG_CXX_WARNING_OPTS(
481 m4_quote(m4_do([-Wmissing-format-attribute])), [strict_warn])
482 ACX_PROG_CXX_WARNING_OPTS(
483 m4_quote(m4_do([-Woverloaded-virtual])), [strict_warn])
484 ACX_PROG_CC_WARNING_OPTS(
485 m4_quote(m4_do([-Wold-style-definition -Wc++-compat])), [c_strict_warn])
486 ACX_PROG_CXX_WARNING_ALMOST_PEDANTIC(
487 m4_quote(m4_do([-Wno-long-long -Wno-variadic-macros ],
488 [-Wno-overlength-strings])), [strict_warn])
489 ACX_PROG_CXX_WARNINGS_ARE_ERRORS([manual], [strict_warn])
491 # The above macros do nothing if the compiler is not GCC. However, the
492 # Makefile has more goo to add other flags, so these variables are used
493 # to enable warnings only for GCC.
496 if test "x$GCC" = "xyes"; then
497 warn_cflags='$(GCC_WARN_CFLAGS)'
498 warn_cxxflags='$(GCC_WARN_CXXFLAGS)'
500 AC_SUBST(warn_cflags)
501 AC_SUBST(warn_cxxflags)
503 # Disable exceptions and RTTI if building with g++
504 ACX_PROG_CC_WARNING_OPTS(
505 m4_quote(m4_do([-fno-exceptions -fno-rtti -fasynchronous-unwind-tables])),
508 # Enable expensive internal checks
510 if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then
514 AC_ARG_ENABLE(checking,
515 [AS_HELP_STRING([[--enable-checking[=LIST]]],
516 [enable expensive run-time checks. With LIST,
517 enable only specific categories of checks.
518 Categories are: yes,no,all,none,release.
519 Flags are: assert,df,fold,gc,gcac,gimple,misc,
520 rtlflag,rtl,runtime,tree,valgrind,types])],
521 [ac_checking_flags="${enableval}"],[
522 # Determine the default checks.
523 if test x$is_release = x ; then
524 ac_checking_flags=yes
526 ac_checking_flags=release
528 IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
529 for check in release $ac_checking_flags
532 # these set all the flags to specific states
533 yes) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking= ;
534 ac_fold_checking= ; ac_gc_checking=1 ;
535 ac_gc_always_collect= ; ac_gimple_checking=1 ; ac_rtl_checking= ;
536 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
537 ac_tree_checking=1 ; ac_valgrind_checking= ;
538 ac_types_checking=1 ;;
539 no|none) ac_assert_checking= ; ac_checking= ; ac_df_checking= ;
540 ac_fold_checking= ; ac_gc_checking= ;
541 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
542 ac_rtlflag_checking= ; ac_runtime_checking= ;
543 ac_tree_checking= ; ac_valgrind_checking= ;
544 ac_types_checking= ;;
545 all) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking=1 ;
546 ac_fold_checking=1 ; ac_gc_checking=1 ;
547 ac_gc_always_collect=1 ; ac_gimple_checking=1 ; ac_rtl_checking=1 ;
548 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
549 ac_tree_checking=1 ; ac_valgrind_checking= ;
550 ac_types_checking=1 ;;
551 release) ac_assert_checking=1 ; ac_checking= ; ac_df_checking= ;
552 ac_fold_checking= ; ac_gc_checking= ;
553 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
554 ac_rtlflag_checking= ; ac_runtime_checking=1 ;
555 ac_tree_checking= ; ac_valgrind_checking= ;
556 ac_types_checking= ;;
557 # these enable particular checks
558 assert) ac_assert_checking=1 ;;
559 df) ac_df_checking=1 ;;
560 fold) ac_fold_checking=1 ;;
561 gc) ac_gc_checking=1 ;;
562 gcac) ac_gc_always_collect=1 ;;
563 gimple) ac_gimple_checking=1 ;;
564 misc) ac_checking=1 ;;
565 rtl) ac_rtl_checking=1 ;;
566 rtlflag) ac_rtlflag_checking=1 ;;
567 runtime) ac_runtime_checking=1 ;;
568 tree) ac_tree_checking=1 ;;
569 types) ac_types_checking=1 ;;
570 valgrind) ac_valgrind_checking=1 ;;
571 *) AC_MSG_ERROR(unknown check category $check) ;;
577 if test x$ac_checking != x ; then
578 AC_DEFINE(CHECKING_P, 1,
579 [Define to 1 if you want more run-time sanity checks. This one gets a grab
580 bag of miscellaneous but relatively cheap checks.])
581 nocommon_flag=-fno-common
583 AC_DEFINE(CHECKING_P, 0)
585 AC_SUBST(nocommon_flag)
586 if test x$ac_df_checking != x ; then
587 AC_DEFINE(ENABLE_DF_CHECKING, 1,
588 [Define if you want more run-time sanity checks for dataflow.])
590 if test x$ac_assert_checking != x ; then
591 AC_DEFINE(ENABLE_ASSERT_CHECKING, 1,
592 [Define if you want assertions enabled. This is a cheap check.])
594 if test x$ac_gimple_checking != x ; then
595 AC_DEFINE(ENABLE_GIMPLE_CHECKING, 1,
596 [Define if you want operations on GIMPLE (the basic data structure of
597 the high-level optimizers) to be checked for dynamic type safety at
598 runtime. This is moderately expensive.])
600 GCC_TARGET_TEMPLATE(ENABLE_RUNTIME_CHECKING)
601 if test x$ac_runtime_checking != x ; then
602 AC_DEFINE(ENABLE_RUNTIME_CHECKING, 1,
603 [Define if you want runtime assertions enabled. This is a cheap check.])
605 if test x$ac_tree_checking != x ; then
606 AC_DEFINE(ENABLE_TREE_CHECKING, 1,
607 [Define if you want all operations on trees (the basic data
608 structure of the front ends) to be checked for dynamic type safety
609 at runtime. This is moderately expensive.
613 if test x$ac_types_checking != x ; then
614 AC_DEFINE(ENABLE_TYPES_CHECKING, 1,
615 [Define if you want all gimple types to be verified after gimplifiation.
619 AC_SUBST(TREECHECKING)
620 if test x$ac_rtl_checking != x ; then
621 AC_DEFINE(ENABLE_RTL_CHECKING, 1,
622 [Define if you want all operations on RTL (the basic data structure
623 of the optimizer and back end) to be checked for dynamic type safety
624 at runtime. This is quite expensive.])
626 if test x$ac_rtlflag_checking != x ; then
627 AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
628 [Define if you want RTL flag accesses to be checked against the RTL
629 codes that are supported for each access macro. This is relatively
632 if test x$ac_gc_checking != x ; then
633 AC_DEFINE(ENABLE_GC_CHECKING, 1,
634 [Define if you want the garbage collector to do object poisoning and
635 other memory allocation checks. This is quite expensive.])
637 if test x$ac_gc_always_collect != x ; then
638 AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
639 [Define if you want the garbage collector to operate in maximally
640 paranoid mode, validating the entire heap and collecting garbage at
641 every opportunity. This is extremely expensive.])
643 if test x$ac_fold_checking != x ; then
644 AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
645 [Define if you want fold checked that it never destructs its argument.
646 This is quite expensive.])
648 valgrind_path_defines=
651 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
652 dnl # an if statement. This was the source of very frustrating bugs
653 dnl # in converting to autoconf 2.5x!
654 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
656 # It is certainly possible that there's valgrind but no valgrind.h.
657 # GCC relies on making annotations so we must have both.
658 AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
659 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
660 [[#include <valgrind/memcheck.h>
661 #ifndef VALGRIND_DISCARD
662 #error VALGRIND_DISCARD not defined
664 [gcc_cv_header_valgrind_memcheck_h=yes],
665 [gcc_cv_header_valgrind_memcheck_h=no])
666 AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
667 AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
668 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
669 [[#include <memcheck.h>
670 #ifndef VALGRIND_DISCARD
671 #error VALGRIND_DISCARD not defined
673 [gcc_cv_header_memcheck_h=yes],
674 [gcc_cv_header_memcheck_h=no])
675 AC_MSG_RESULT($gcc_cv_header_memcheck_h)
676 if test $gcc_cv_header_valgrind_memcheck_h = yes; then
677 AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
678 [Define if valgrind's valgrind/memcheck.h header is installed.])
680 if test $gcc_cv_header_memcheck_h = yes; then
681 AC_DEFINE(HAVE_MEMCHECK_H, 1,
682 [Define if valgrind's memcheck.h header is installed.])
685 if test x$ac_valgrind_checking != x ; then
686 AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
687 [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
688 if test "x$valgrind_path" = "x" \
689 || (test $have_valgrind_h = no \
690 && test $gcc_cv_header_memcheck_h = no \
691 && test $gcc_cv_header_valgrind_memcheck_h = no); then
692 AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
694 valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
695 valgrind_command="$valgrind_path -q"
696 AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
697 [Define if you want to run subprograms and generated programs
698 through valgrind (a memory checker). This is extremely expensive.])
700 AC_SUBST(valgrind_path_defines)
701 AC_SUBST(valgrind_command)
703 # Enable code coverage collection
704 AC_ARG_ENABLE(coverage,
705 [AS_HELP_STRING([[--enable-coverage[=LEVEL]]],
706 [enable compiler's code coverage collection.
707 Use to measure compiler performance and locate
708 unused parts of the compiler. With LEVEL, specify
709 optimization. Values are opt, noopt,
711 [case "${enableval}" in
713 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
716 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
719 # a.k.a. --disable-coverage
723 AC_MSG_ERROR(unknown coverage setting $enableval)
727 AC_SUBST(coverage_flags)
729 AC_ARG_ENABLE(gather-detailed-mem-stats,
730 [AS_HELP_STRING([--enable-gather-detailed-mem-stats],
731 [enable detailed memory allocation stats gathering])], [],
732 [enable_gather_detailed_mem_stats=no])
733 gather_stats=`if test $enable_gather_detailed_mem_stats != no; then echo 1; else echo 0; fi`
734 AC_DEFINE_UNQUOTED(GATHER_STATISTICS, $gather_stats,
735 [Define to enable detailed memory allocation stats gathering.])
737 AC_ARG_ENABLE(valgrind-annotations,
738 [AS_HELP_STRING([--enable-valgrind-annotations],
739 [enable valgrind runtime interaction])], [],
740 [enable_valgrind_annotations=no])
741 if test x$enable_valgrind_annotations != xno \
742 || test x$ac_valgrind_checking != x; then
743 if (test $have_valgrind_h = no \
744 && test $gcc_cv_header_memcheck_h = no \
745 && test $gcc_cv_header_valgrind_memcheck_h = no); then
746 AC_MSG_ERROR([*** Can't find valgrind/memcheck.h, memcheck.h or valgrind.h])
748 AC_DEFINE(ENABLE_VALGRIND_ANNOTATIONS, 1,
749 [Define to get calls to the valgrind runtime enabled.])
752 # -------------------------------
753 # Miscenalleous configure options
754 # -------------------------------
758 [AS_HELP_STRING([--with-stabs],
759 [arrange to use stabs instead of host debug format])],
763 # Determine whether or not multilibs are enabled.
764 AC_ARG_ENABLE(multilib,
765 [AS_HELP_STRING([--enable-multilib],
766 [enable library support for multiple ABIs])],
767 [], [enable_multilib=yes])
768 AC_SUBST(enable_multilib)
770 # Determine whether or not multiarch is enabled.
771 AC_ARG_ENABLE(multiarch,
772 [AS_HELP_STRING([--enable-multiarch],
773 [enable support for multiarch paths])],
774 [case "${enableval}" in
775 yes|no|auto) enable_multiarch=$enableval;;
776 *) AC_MSG_ERROR(bad value ${enableval} given for --enable-multiarch option) ;;
777 esac], [enable_multiarch=auto])
778 if test x${enable_multiarch} = xauto; then
779 if test x${with_native_system_header_dir} != x; then
780 ma_msg_suffix=", disabled auto check (configured with --native-system-header-dir)"
783 if test x$host != x$target && test "x$with_sysroot" = x; then
784 ma_msg_suffix=", disabled auto check (cross build configured without --with-sysroot)"
788 AC_MSG_CHECKING(for multiarch configuration)
789 AC_SUBST(enable_multiarch)
790 AC_MSG_RESULT($enable_multiarch$ma_msg_suffix)
792 # needed for setting the multiarch name for soft-float/hard-float ABIs
796 # Enable __cxa_atexit for C++.
797 AC_ARG_ENABLE(__cxa_atexit,
798 [AS_HELP_STRING([--enable-__cxa_atexit], [enable __cxa_atexit for C++])],
801 # Enable C extension for decimal float if target supports it.
802 GCC_AC_ENABLE_DECIMAL_FLOAT([$target])
804 dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi`
805 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp,
806 [Define to 1 to enable decimal float extension to C.])
808 # Use default_decimal_float for dependency.
809 enable_decimal_float=$default_decimal_float
811 bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi`
812 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid,
813 [Define to 1 to specify that we are using the BID decimal floating
814 point format instead of DPD])
816 # Enable C extension for fixed-point arithmetic.
817 AC_ARG_ENABLE(fixed-point,
818 [AS_HELP_STRING([--enable-fixed-point],
819 [enable fixed-point arithmetic extension to C])],
824 enable_fixed_point=yes
828 enable_fixed_point=yes
831 AC_MSG_WARN([fixed-point is not supported for this target, ignored])
832 enable_fixed_point=no
836 AC_SUBST(enable_fixed_point)
838 fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi`
839 AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint,
840 [Define to 1 to enable fixed-point arithmetic extension to C.])
843 # Pass with no value to take the default
844 # Pass with a value to specify a thread package
845 AC_ARG_ENABLE(threads,
846 [AS_HELP_STRING([[--enable-threads[=LIB]]],
847 [enable thread usage for target GCC,
848 using LIB thread package])],,
852 [AS_HELP_STRING([--enable-tls],
853 [enable or disable generation of tls code
854 overriding the assembler check for tls support])],
858 *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
859 Valid choices are 'yes' and 'no'.]) ;;
863 AC_ARG_ENABLE(objc-gc,
864 [AS_HELP_STRING([--enable-objc-gc],
865 [enable the use of Boehm's garbage collector with
866 the GNU Objective-C runtime])],
867 if test x$enable_objc_gc = xno; then
875 [AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2])],
876 dwarf2="$with_dwarf2",
879 AC_ARG_ENABLE(shared,
880 [AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])],
882 case $enable_shared in
886 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
887 for pkg in $enableval; do
888 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
895 ], [enable_shared=yes])
896 AC_SUBST(enable_shared)
899 [AS_HELP_STRING([--with-specs=SPECS],
900 [add SPECS to driver command-line processing])],
901 [CONFIGURE_SPECS=$withval],
904 AC_SUBST(CONFIGURE_SPECS)
906 ACX_PKGVERSION([GCC])
907 ACX_BUGURL([http://gcc.gnu.org/bugs.html])
909 # Sanity check enable_languages in case someone does not run the toplevel
910 # configure # script.
911 AC_ARG_ENABLE(languages,
912 [AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])],
913 [case ,${enable_languages}, in
915 # go safe -- we cannot be much sure without the toplevel
917 # analysis of which target libs are present and usable
921 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
926 enable_languages=c,${enable_languages}
929 [enable_languages=c])
931 if test x"$enable_as_accelerator_for" != x; then
932 AC_DEFINE(ACCEL_COMPILER, 1,
933 [Define if this compiler should be built as the offload target compiler.])
934 enable_as_accelerator=yes
937 # In this case we expect offload compiler to be built as native, so we
938 # need to rename the driver to avoid clashes with host's drivers.
939 program_transform_name="s&^&${target}-&" ;;
941 sedscript="s#${target_noncanonical}#${enable_as_accelerator_for}-accel-${target_noncanonical}#"
942 program_transform_name=`echo $program_transform_name | sed $sedscript`
943 accel_dir_suffix=/accel/${target_noncanonical}
944 real_target_noncanonical=${enable_as_accelerator_for}
946 AC_SUBST(enable_as_accelerator)
947 AC_SUBST(real_target_noncanonical)
948 AC_SUBST(accel_dir_suffix)
950 for tgt in `echo $enable_offload_targets | sed 's/,/ /g'`; do
951 tgt=`echo $tgt | sed 's/=.*//'`
953 if echo "$tgt" | grep "^hsa" > /dev/null ; then
959 if test x"$offload_targets" = x; then
962 offload_targets="$offload_targets,$tgt"
965 AC_DEFINE_UNQUOTED(OFFLOAD_TARGETS, "$offload_targets",
966 [Define to offload targets, separated by commas.])
967 if test x"$enable_offloading" != x; then
968 AC_DEFINE(ENABLE_OFFLOADING, 1,
969 [Define this to enable support for offloading.])
971 AC_DEFINE(ENABLE_OFFLOADING, 0,
972 [Define this to enable support for offloading.])
975 if test x"$enable_hsa" = x1 ; then
976 AC_DEFINE(ENABLE_HSA, 1,
977 [Define this to enable support for generating HSAIL.])
980 AC_ARG_WITH(multilib-list,
981 [AS_HELP_STRING([--with-multilib-list], [select multilibs (AArch64, SH and x86-64 only)])],
983 with_multilib_list=default)
985 # -------------------------
986 # Checks for other programs
987 # -------------------------
991 # Find some useful tools
993 # We need awk to create options.c and options.h.
994 # Bail out if it's missing.
996 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
1003 AC_SUBST(ranlib_flags)
1007 # See if cmp has --ignore-initial.
1008 gcc_AC_PROG_CMP_IGNORE_INITIAL
1010 # See if we have the mktemp command.
1011 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
1013 # See if makeinfo has been installed and is modern enough
1014 # that we can use it.
1015 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
1016 [GNU texinfo.* \([0-9][0-9.]*\)],
1017 [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
1018 if test $gcc_cv_prog_makeinfo_modern = no; then
1020 *** Makeinfo is missing or too old.
1021 *** Info documentation will not be built.])
1026 AC_SUBST(BUILD_INFO)
1028 # Is pod2man recent enough to regenerate manpages?
1029 AC_MSG_CHECKING([for recent Pod::Man])
1030 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
1032 GENERATED_MANPAGES=generated-manpages
1037 AC_SUBST(GENERATED_MANPAGES)
1039 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
1042 dnl Don't use AC_PROG_LEX; we insist on flex.
1043 dnl LEXLIB is not useful in gcc.
1044 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
1047 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
1049 # Binutils are not build modules, unlike bison/flex/makeinfo. So we
1050 # check for build == host before using them.
1053 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
1054 && test -d ../binutils ; then
1055 NM='${objdir}/../binutils/nm-new'
1057 AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
1061 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
1062 && test -d ../binutils ; then
1063 AR='${objdir}/../binutils/ar'
1065 AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
1068 # The jit documentation looks better if built with sphinx, but can be
1069 # built with texinfo if sphinx is not available.
1070 # Set "doc_build_sys" to "sphinx" or "texinfo" accordingly.
1071 AC_CHECK_PROG(doc_build_sys, sphinx-build, sphinx, texinfo)
1073 # --------------------
1074 # Checks for C headers
1075 # --------------------
1077 # Need to reject headers which give warnings, so that the -Werror bootstrap
1078 # works later. *sigh* This needs to come before all header checks.
1085 AC_HEADER_TIOCGWINSZ
1086 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
1087 fcntl.h ftw.h unistd.h sys/file.h sys/time.h sys/mman.h \
1088 sys/resource.h sys/param.h sys/times.h sys/stat.h \
1089 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
1091 # Check for thread headers.
1092 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
1093 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
1095 # These tests can't be done till we know if we have limits.h.
1099 # ----------------------
1100 # Checks for C++ headers
1101 # ----------------------
1103 dnl Autoconf will give an error in the configure script if there is no
1104 dnl C++ preprocessor. Hack to prevent that.
1105 m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl
1107 m4_popdef([AC_MSG_ERROR])[]dnl
1109 AC_CHECK_HEADERS(unordered_map)
1110 AC_CHECK_HEADERS(tr1/unordered_map)
1111 AC_CHECK_HEADERS(ext/hash_map)
1114 # Dependency checking.
1118 AC_CONFIG_COMMANDS([gccdepdir],[
1119 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs build/$DEPDIR
1120 for lang in $subdirs c-family common
1122 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs $lang/$DEPDIR
1123 done], [subdirs="$subdirs" ac_aux_dir=$ac_aux_dir DEPDIR=$DEPDIR])
1125 ZW_PROG_COMPILER_DEPENDENCIES([CXX])
1132 # These libraries may be used by collect2.
1133 # We may need a special search path to get them linked.
1134 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
1136 for libs in '' -lld -lmld \
1137 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
1138 '-L/usr/lib/cmplrs/cc3.11 -lmld'
1141 AC_TRY_LINK_FUNC(ldopen,
1142 [gcc_cv_collect2_libs="$libs"; break])
1145 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
1146 case $gcc_cv_collect2_libs in
1148 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
1150 AC_SUBST(COLLECT2_LIBS)
1152 # When building Ada code on Alpha, we need exc_resume which is usually in
1153 # -lexc. So test for it.
1156 AC_SEARCH_LIBS(exc_resume, exc)
1159 AC_SUBST(GNAT_LIBEXC)
1161 # To support -mcpu=native on Solaris/SPARC, we need libkstat.
1164 AC_SEARCH_LIBS(kstat_open, kstat)
1165 EXTRA_GCC_LIBS="$LIBS"
1167 AC_SUBST(EXTRA_GCC_LIBS)
1169 # Some systems put ldexp and frexp in libm instead of libc; assume
1170 # they're both in the same place. jcf-dump needs them.
1173 AC_SEARCH_LIBS(ldexp, m)
1178 # Use <inttypes.h> only if it exists,
1179 # doesn't clash with <sys/types.h>, declares intmax_t and defines
1181 AC_MSG_CHECKING(for inttypes.h)
1182 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
1183 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1184 [[#define __STDC_FORMAT_MACROS
1185 #include <sys/types.h>
1186 #include <inttypes.h>]],
1191 [gcc_cv_header_inttypes_h=yes],
1192 [gcc_cv_header_inttypes_h=no])])
1193 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
1194 if test $gcc_cv_header_inttypes_h = yes; then
1195 AC_DEFINE(HAVE_INTTYPES_H, 1,
1196 [Define if you have a working <inttypes.h> header file.])
1199 dnl Disabled until we have a complete test for buggy enum bitfields.
1200 dnl gcc_AC_C_ENUM_BF_UNSIGNED
1202 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
1203 ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
1204 fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
1205 fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
1206 putchar_unlocked putc_unlocked)
1207 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoq \
1208 popen sysconf strsignal getrusage nl_langinfo \
1209 gettimeofday mbstowcs wcswidth mmap setlocale \
1210 gcc_UNLOCKED_FUNCS madvise)
1212 if test x$ac_cv_func_mbstowcs = xyes; then
1213 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
1214 [ AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
1220 [gcc_cv_func_mbstowcs_works=yes],
1221 [gcc_cv_func_mbstowcs_works=no],
1222 [gcc_cv_func_mbstowcs_works=yes])])
1223 if test x$gcc_cv_func_mbstowcs_works = xyes; then
1224 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
1225 [Define this macro if mbstowcs does not crash when its
1226 first argument is NULL.])
1230 AC_CHECK_TYPE(ssize_t, int)
1231 AC_CHECK_TYPE(caddr_t, char *)
1233 GCC_AC_FUNC_MMAP_BLACKLIST
1237 # Under VMS, vfork works very differently than on Unix. The standard test
1238 # won't work, and it isn't easily adaptable. It makes more sense to
1240 ac_cv_func_vfork_works=yes
1247 # Until we have in-tree GNU iconv:
1249 if test -f "$LTLIBICONV"; then
1250 LIBICONV_DEP=$LTLIBICONV
1252 AC_SUBST(LIBICONV_DEP)
1258 # We will need to find libiberty.h and ansidecl.h
1259 saved_CFLAGS="$CFLAGS"
1260 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1261 saved_CXXFLAGS="$CXXFLAGS"
1262 CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1264 # gcc_AC_CHECK_DECLS doesn't support overloaded functions, so use the
1265 # normal autoconf function for these. But force definition of
1266 # HAVE_DECL_BASENAME like gcc_AC_CHECK_DECLS does, to suppress the bizarre
1267 # basename handling in libiberty.h.
1268 AC_CHECK_DECLS([basename(const char*), strstr(const char*,const char*)], , ,[
1269 #undef HAVE_DECL_BASENAME
1270 #define HAVE_DECL_BASENAME 1
1271 #include "ansidecl.h"
1272 #include "system.h"])
1274 gcc_AC_CHECK_DECLS(getenv atol atoll asprintf sbrk abort atof getcwd getwd \
1275 madvise stpcpy strnlen strsignal strverscmp \
1276 strtol strtoul strtoll strtoull setenv unsetenv \
1277 errno snprintf vsnprintf vasprintf malloc realloc calloc \
1278 free getopt clock getpagesize ffs gcc_UNLOCKED_FUNCS, , ,[
1279 #include "ansidecl.h"
1280 #include "system.h"])
1282 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1283 #include "ansidecl.h"
1285 #ifdef HAVE_SYS_RESOURCE_H
1286 #include <sys/resource.h>
1290 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1291 #include "ansidecl.h"
1293 #ifdef HAVE_SYS_RESOURCE_H
1294 #include <sys/resource.h>
1296 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1297 [Define to `long' if <sys/resource.h> doesn't define.])])
1299 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1300 # FREAD and FWRITE macros. Fortunately, for GCC's single usage of ldgetname
1301 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1302 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1303 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1304 #include "ansidecl.h"
1313 gcc_AC_CHECK_DECLS(times, , ,[
1314 #include "ansidecl.h"
1316 #ifdef HAVE_SYS_TIMES_H
1317 #include <sys/times.h>
1321 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1322 #include "ansidecl.h"
1327 # More time-related stuff.
1328 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1329 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1330 #include "ansidecl.h"
1332 #ifdef HAVE_SYS_TIMES_H
1333 #include <sys/times.h>
1335 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1336 if test $ac_cv_struct_tms = yes; then
1337 AC_DEFINE(HAVE_STRUCT_TMS, 1,
1338 [Define if <sys/times.h> defines struct tms.])
1341 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1342 # revisit after autoconf 2.50.
1343 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1344 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1345 #include "ansidecl.h"
1347 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1348 if test $gcc_cv_type_clock_t = yes; then
1349 AC_DEFINE(HAVE_CLOCK_T, 1,
1350 [Define if <time.h> defines clock_t.])
1353 # Check if F_SETLKW is supported by fcntl.
1354 AC_CACHE_CHECK(for F_SETLKW, ac_cv_f_setlkw, [
1355 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1356 #include <fcntl.h>]], [[
1362 return fcntl (1, F_SETLKW, &fl);]])],
1363 [ac_cv_f_setlkw=yes],[ac_cv_f_setlkw=no])])
1364 if test $ac_cv_f_setlkw = yes; then
1365 AC_DEFINE(HOST_HAS_F_SETLKW, 1,
1366 [Define if F_SETLKW supported by fcntl.])
1369 # Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1370 CFLAGS="$saved_CFLAGS"
1371 CXXFLAGS="$saved_CXXFLAGS"
1373 # mkdir takes a single argument on some systems.
1374 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1382 # With Setjmp/Longjmp based exception handling.
1383 AC_ARG_ENABLE(sjlj-exceptions,
1384 [AS_HELP_STRING([--enable-sjlj-exceptions],
1385 [arrange to use setjmp/longjmp exception handling])],
1388 if test $enableval != yes; then
1389 AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1394 force_sjlj_exceptions=yes],
1397 force_sjlj_exceptions=yes
1401 force_sjlj_exceptions=yes
1405 force_sjlj_exceptions=no
1408 if test $force_sjlj_exceptions = yes; then
1409 sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1410 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1411 [Define 0/1 to force the choice for exception handling model.])
1414 # --------------------------------------------------------
1415 # Build, host, and target specific configuration fragments
1416 # --------------------------------------------------------
1418 # Collect build-machine-specific information.
1419 . ${srcdir}/config.build
1421 # Collect host-machine-specific information.
1422 . ${srcdir}/config.host
1426 # Collect target-machine-specific information.
1427 . ${srcdir}/config.gcc
1429 extra_objs="${host_extra_objs} ${extra_objs}"
1430 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1432 # Default the target-machine variables that were not explicitly set.
1433 if test x"$tm_file" = x
1434 then tm_file=$cpu_type/$cpu_type.h; fi
1436 if test x"$extra_headers" = x
1437 then extra_headers=; fi
1439 if test x$md_file = x
1440 then md_file=$cpu_type/$cpu_type.md; fi
1442 if test x$out_file = x
1443 then out_file=$cpu_type/$cpu_type.c; fi
1445 if test x"$tmake_file" = x
1446 then tmake_file=$cpu_type/t-$cpu_type
1449 # Support --enable-initfini-array.
1450 if test x$enable_initfini_array != xno; then
1451 tm_file="${tm_file} initfini-array.h"
1454 if test x"$dwarf2" = xyes
1455 then tm_file="$tm_file tm-dwarf2.h"
1458 # Say what files are being used for the output code and MD file.
1459 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1460 echo "Using \`$srcdir/config/$md_file' as machine description file."
1462 # If any of the xm_file variables contain nonexistent files, warn
1463 # about them and drop them.
1466 for x in $build_xm_file; do
1467 if test -f $srcdir/config/$x
1469 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1475 for x in $host_xm_file; do
1476 if test -f $srcdir/config/$x
1478 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1484 for x in $xm_file; do
1485 if test -f $srcdir/config/$x
1487 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1493 for f in $tm_file; do
1496 if test $count = ax; then
1497 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1499 echo "Using the following target machine macro files:"
1500 for f in $tm_file; do
1501 echo " $srcdir/config/$f"
1505 if test x$use_long_long_for_widest_fast_int = xyes; then
1506 AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1507 [Define to 1 if the 'long long' type is wider than 'long' but still
1508 efficiently supported by the host hardware.])
1511 gnu_ld_bool=`if test x"$gnu_ld" = x"yes"; then echo 1; else echo 0; fi`
1512 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld_bool, [Define to 1 if using GNU ld.])
1514 gnu_as_bool=`if test x"$gas" = x"yes"; then echo 1; else echo 0; fi`
1515 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as_bool, [Define to 1 if using GNU as.])
1518 for f in $host_xm_file; do
1521 if test $count = a; then
1523 elif test $count = ax; then
1524 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1526 echo "Using the following host machine macro files:"
1527 for f in $host_xm_file; do
1528 echo " $srcdir/config/$f"
1531 echo "Using ${out_host_hook_obj} for host machine hooks."
1533 if test "$host_xm_file" != "$build_xm_file"; then
1535 for f in $build_xm_file; do
1538 if test $count = a; then
1540 elif test $count = ax; then
1541 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1543 echo "Using the following build machine macro files:"
1544 for f in $build_xm_file; do
1545 echo " $srcdir/config/$f"
1550 if test -n "$configured_native_system_header_dir"; then
1551 native_system_header_dir=$configured_native_system_header_dir
1553 NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir"
1554 AC_SUBST(NATIVE_SYSTEM_HEADER_DIR)
1558 AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1559 gcc_cv_mcontext_underscores,
1561 #include <sys/cdefs.h>
1562 #include <sys/signal.h>
1563 #include <ucontext.h>
1564 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1566 gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1567 if test $gcc_cv_mcontext_underscores = yes; then
1568 AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1569 [mcontext_t fields start with __])
1578 # Check if a valid thread package
1579 case ${enable_threads} in
1582 target_thread_file='single'
1586 target_thread_file='single'
1588 aix | dce | lynx | mipssde | posix | rtems | \
1589 single | tpf | vxworks | win32)
1590 target_thread_file=${enable_threads}
1593 echo "${enable_threads} is an unknown thread package" 1>&2
1598 if test x${thread_file} = x; then
1599 # No thread file set by target-specific clauses in config.gcc,
1600 # so use file chosen by default logic above
1601 thread_file=${target_thread_file}
1609 if test x$enable___cxa_atexit = xyes || \
1610 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1611 if test x$host = x$target; then
1613 # mingw32 doesn't have __cxa_atexit but uses atexit registration
1614 # keyed to flag_use_cxa_atexit
1622 AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1623 [echo "__cxa_atexit can't be enabled on this target"])
1627 # We can't check for __cxa_atexit when building a cross, so assume
1631 if test x$use_cxa_atexit = xyes; then
1632 AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1633 [Define if you want to use __cxa_atexit, rather than atexit, to
1634 register C++ destructors for local statics and global objects.
1635 This is essential for fully standards-compliant handling of
1636 destructors, but requires __cxa_atexit in libc.])
1640 # Look for a file containing extra machine modes.
1641 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1642 extra_modes_file='$(srcdir)'/config/${extra_modes}
1643 AC_SUBST(extra_modes_file)
1644 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1645 [Define to the name of a file containing a list of extra machine modes
1646 for this architecture.])
1649 # Convert extra_options into a form suitable for Makefile use.
1652 for f in $extra_options; do
1653 extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1654 all_opt_files="$all_opt_files $srcdir/config/$f"
1656 AC_SUBST(extra_opt_files)
1658 # auto-host.h is the file containing items generated by autoconf and is
1659 # the first file included by config.h.
1660 # If host=build, it is correct to have bconfig include auto-host.h
1661 # as well. If host!=build, we are in error and need to do more
1662 # work to find out the build config parameters.
1663 if test x$host = x$build
1665 build_auto=auto-host.h
1667 # We create a subdir, then run autoconf in the subdir.
1668 # To prevent recursion we set host and build for the new
1669 # invocation of configure to the build for this invocation
1676 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1677 *) realsrcdir=../${srcdir};;
1679 # Clearing GMPINC is necessary to prevent host headers being
1680 # used by the build compiler. Defining GENERATOR_FILE stops
1681 # system.h from including gmp.h.
1682 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1683 CXX="${CXX_FOR_BUILD}" CXXFLAGS="${CXXFLAGS_FOR_BUILD}" \
1684 LD="${LD_FOR_BUILD}" LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1685 GMPINC="" CPPFLAGS="${CPPFLAGS} -DGENERATOR_FILE" \
1686 ${realsrcdir}/configure \
1687 --enable-languages=${enable_languages-all} \
1688 --target=$target_alias --host=$build_alias --build=$build_alias
1690 # We just finished tests for the build machine, so rename
1691 # the file auto-build.h in the gcc directory.
1692 mv auto-host.h ../auto-build.h
1695 build_auto=auto-build.h
1697 AC_SUBST(build_subdir)
1699 tm_file="${tm_file} defaults.h"
1700 tm_p_file="${tm_p_file} tm-preds.h"
1701 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1702 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1703 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1704 # put this back in temporarily.
1705 xm_file="auto-host.h ansidecl.h ${xm_file}"
1712 # Compile in configure arguments.
1713 if test -f configargs.h ; then
1714 # Being re-configured.
1715 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1716 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1718 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1721 # Double all backslashes and backslash all quotes to turn
1722 # gcc_config_arguments into a C string.
1723 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1724 $gcc_config_arguments
1726 gcc_config_arguments_str=`cat conftest.out`
1729 cat > configargs.h <<EOF
1730 /* Generated automatically. */
1731 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1732 static const char thread_model[] = "$thread_file";
1734 static const struct {
1735 const char *name, *value;
1736 } configure_default_options[] = $configure_default_options;
1741 gcc_BASEVER=`cat $srcdir/BASE-VER`
1742 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
1743 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
1744 if test -f $srcdir/REVISION ; then
1745 gcc_REVISION=`cat $srcdir/REVISION`
1749 cat > plugin-version.h <<EOF
1750 #include "configargs.h"
1752 #define GCCPLUGIN_VERSION_MAJOR `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'`
1753 #define GCCPLUGIN_VERSION_MINOR `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'`
1754 #define GCCPLUGIN_VERSION_PATCHLEVEL `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'`
1755 #define GCCPLUGIN_VERSION (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR)
1757 static char basever[] = "$gcc_BASEVER";
1758 static char datestamp[] = "$gcc_DATESTAMP";
1759 static char devphase[] = "$gcc_DEVPHASE";
1760 static char revision[] = "$gcc_REVISION";
1762 /* FIXME plugins: We should make the version information more precise.
1763 One way to do is to add a checksum. */
1765 static struct plugin_gcc_version gcc_version = {basever, datestamp,
1767 configuration_arguments};
1771 # Internationalization
1772 ZW_GNU_GETTEXT_SISTER_DIR
1774 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1775 # -liconv on the link line twice.
1776 case "$LIBINTL" in *$LIBICONV*)
1780 AC_ARG_ENABLE(secureplt,
1781 [AS_HELP_STRING([--enable-secureplt],
1782 [enable -msecure-plt by default for PowerPC])],
1785 AC_ARG_ENABLE(leading-mingw64-underscores,
1786 AS_HELP_STRING([--enable-leading-mingw64-underscores],
1787 [enable leading underscores on 64 bit mingw targets]),
1789 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
1790 [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
1791 [Define if we should use leading underscore on 64 bit mingw targets])])
1794 [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [],
1797 AC_ARG_ENABLE(frame-pointer,
1798 [AS_HELP_STRING([--enable-frame-pointer],
1799 [enable -fno-omit-frame-pointer by default for 32bit x86])], [],
1802 linux* | darwin[[8912]]*)
1803 # Enable -fomit-frame-pointer by default for Linux and Darwin with
1805 enable_frame_pointer=no
1808 enable_frame_pointer=yes
1813 # Windows32 Registry support for specifying GCC installation paths.
1814 AC_ARG_ENABLE(win32-registry,
1815 [AS_HELP_STRING([--disable-win32-registry],
1816 [disable lookup of installation paths in the
1817 Registry on Windows hosts])
1818 AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)])
1819 AS_HELP_STRING([--enable-win32-registry=KEY],
1820 [use KEY instead of GCC version as the last portion
1821 of the registry key])],,)
1824 win32 | pe | cygwin* | mingw32*)
1825 if test "x$enable_win32_registry" != xno; then
1826 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1829 if test "x$enable_win32_registry" != xno; then
1830 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1831 [Define to 1 if installation paths should be looked up in the Windows
1832 Registry. Ignored on non-Windows hosts.])
1834 if test "x$enable_win32_registry" != xyes \
1835 && test "x$enable_win32_registry" != x; then
1836 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1837 [Define to be the last component of the Windows registry key under which
1838 to look for installation paths. The full key used will be
1839 HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1840 The default is the GCC version number.])
1846 # Get an absolute path to the GCC top-level source directory
1847 holddir=`${PWDCMD-pwd}`
1849 topdir=`${PWDCMD-pwd}`
1852 # Conditionalize the makefile for this host machine.
1854 for f in ${host_xmake_file}
1856 if test -f ${srcdir}/config/$f
1858 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1862 # Conditionalize the makefile for this target machine.
1864 for f in ${tmake_file}
1866 if test -f ${srcdir}/config/$f
1868 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1871 tmake_file="${tmake_file_}"
1873 out_object_file=`basename $out_file .c`.o
1874 common_out_object_file=`basename $common_out_file .c`.o
1876 tm_file_list="options.h"
1877 tm_include_list="options.h insn-constants.h"
1878 for f in $tm_file; do
1881 f=`echo $f | sed 's/^..//'`
1882 tm_file_list="${tm_file_list} $f"
1883 tm_include_list="${tm_include_list} $f"
1886 tm_file_list="${tm_file_list} \$(srcdir)/$f"
1887 tm_include_list="${tm_include_list} $f"
1890 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1891 tm_include_list="${tm_include_list} config/$f"
1898 for f in $tm_p_file; do
1901 tm_p_file_list="${tm_p_file_list} $f"
1902 tm_p_include_list="${tm_p_include_list} $f"
1905 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1906 tm_p_include_list="${tm_p_include_list} config/$f"
1912 for f in $xm_file; do
1915 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1916 xm_include_list="${xm_include_list} $f"
1919 xm_file_list="${xm_file_list} $f"
1920 xm_include_list="${xm_include_list} $f"
1923 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1924 xm_include_list="${xm_include_list} config/$f"
1930 host_xm_include_list=
1931 for f in $host_xm_file; do
1934 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1935 host_xm_include_list="${host_xm_include_list} $f"
1938 host_xm_file_list="${host_xm_file_list} $f"
1939 host_xm_include_list="${host_xm_include_list} $f"
1942 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1943 host_xm_include_list="${host_xm_include_list} config/$f"
1949 for f in $build_xm_file; do
1952 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1953 build_xm_include_list="${build_xm_include_list} $f"
1955 auto-build.h | auto-host.h )
1956 build_xm_file_list="${build_xm_file_list} $f"
1957 build_xm_include_list="${build_xm_include_list} $f"
1960 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1961 build_xm_include_list="${build_xm_include_list} config/$f"
1966 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1967 # cross-compiler which does not use the native headers and libraries.
1968 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1969 CROSS= AC_SUBST(CROSS)
1970 ALL=all.internal AC_SUBST(ALL)
1971 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1973 if test "x$with_build_sysroot" != x; then
1974 build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1976 # This value is used, even on a native system, because
1977 # CROSS_SYSTEM_HEADER_DIR is just
1978 # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1979 build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1982 if test x$host != x$target
1984 CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1986 SYSTEM_HEADER_DIR=$build_system_header_dir
1987 case "$host","$target" in
1988 # Darwin crosses can use the host system's libraries and headers,
1989 # because of the fat library support. Of course, it must be the
1990 # same version of Darwin on both sides. Allow the user to
1991 # just say --target=foo-darwin without a version number to mean
1992 # "the version on this system".
1993 *-*-darwin*,*-*-darwin*)
1994 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1995 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1996 if test $hostos = $targetos -o $targetos = darwin ; then
1998 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
2003 i?86-*-*,x86_64-*-* \
2004 | powerpc*-*-*,powerpc64*-*-*)
2005 CROSS="$CROSS -DNATIVE_CROSS" ;;
2010 if test "x$with_headers" = x; then
2017 elif test "x$TARGET_SYSTEM_ROOT" != x; then
2018 SYSTEM_HEADER_DIR=$build_system_header_dir
2021 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
2022 if test "x$with_headers" != x; then
2023 target_header_dir=$with_headers
2024 elif test "x$with_sysroot" = x; then
2025 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include"
2026 elif test "x$with_build_sysroot" != "x"; then
2027 target_header_dir="${with_build_sysroot}${native_system_header_dir}"
2028 elif test "x$with_sysroot" = xyes; then
2029 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
2031 target_header_dir="${with_sysroot}${native_system_header_dir}"
2034 target_header_dir=${native_system_header_dir}
2037 # If this is a cross-compiler that does not
2038 # have its own set of headers then define
2041 # If this is using newlib, without having the headers available now,
2042 # then define inhibit_libc in LIBGCC2_CFLAGS.
2043 # This prevents libgcc2 from containing any code which requires libc
2045 : ${inhibit_libc=false}
2046 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
2047 test x$with_newlib = xyes ; } &&
2048 { test "x$with_headers" = xno || test ! -f "$target_header_dir/stdio.h"; } ; then
2051 AC_SUBST(inhibit_libc)
2053 # When building gcc with a cross-compiler, we need to adjust things so
2054 # that the generator programs are still built with the native compiler.
2055 # Also, we cannot run fixincludes.
2057 # These are the normal (build=host) settings:
2058 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
2059 CXX_FOR_BUILD='$(CXX)' AC_SUBST(CXX_FOR_BUILD)
2060 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
2061 BUILD_CXXFLAGS='$(ALL_CXXFLAGS)' AC_SUBST(BUILD_CXXFLAGS)
2062 BUILD_LDFLAGS='$(LDFLAGS)' AC_SUBST(BUILD_LDFLAGS)
2063 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
2065 BUILD_NO_PIE_CFLAGS='$(NO_PIE_CFLAGS)' AC_SUBST(BUILD_NO_PIE_CFLAGS)
2066 BUILD_NO_PIE_FLAG='$(NO_PIE_FLAG)' AC_SUBST(BUILD_NO_PIE_FLAG)
2068 # And these apply if build != host, or we are generating coverage data
2069 if test x$build != x$host || test "x$coverage_flags" != x
2071 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
2072 BUILD_CXXFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CXXFLAGS_FOR_BUILD)'
2073 BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
2075 NO_PIE_CFLAGS_FOR_BUILD=${NO_PIE_CFLAGS_FOR_BUILD-${NO_PIE_CFLAGS}}
2076 NO_PIE_FLAG_FOR_BUILD=${NO_PIE_FLAG_FOR_BUILD-${NO_PIE_FLAG}}
2077 BUILD_NO_PIE_CFLAGS='$(NO_PIE_CFLAGS_FOR_BUILD)'
2078 BUILD_NO_PIE_FLAG='$(NO_PIE_FLAG_FOR_BUILD)'
2080 AC_SUBST(NO_PIE_CFLAGS_FOR_BUILD)
2081 AC_SUBST(NO_PIE_FLAG_FOR_BUILD)
2083 # Expand extra_headers to include complete path.
2084 # This substitutes for lots of t-* files.
2086 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
2087 for file in ${extra_headers} ; do
2088 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
2091 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
2092 if test x"$use_gcc_tgmath" = xyes
2093 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
2096 # Define collect2 in Makefile.
2097 case $host_can_use_collect2 in
2099 *) collect2='collect2$(exeext)' ;;
2101 AC_SUBST([collect2])
2103 # Add a definition of USE_COLLECT2 if system wants one.
2104 case $use_collect2 in
2105 no) use_collect2= ;;
2108 host_xm_defines="${host_xm_defines} USE_COLLECT2"
2109 xm_defines="${xm_defines} USE_COLLECT2"
2110 case $host_can_use_collect2 in
2112 AC_MSG_ERROR([collect2 is required but cannot be built on this system])
2118 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
2119 [Define to the name of the LTO plugin DSO that must be
2120 passed to the linker's -plugin=LIB option.])
2122 # ---------------------------
2123 # Assembler & linker features
2124 # ---------------------------
2126 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
2127 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
2128 # However when ld-new is first executed from the build tree, libtool will
2129 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
2130 # to the build tree. While doing this we need to use the previous-stage
2131 # linker, or we have an infinite loop. The presence of a shell script as
2132 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
2133 # the gcc/collect-ld script. So we need to know how libtool works, or
2134 # exec-tool will fail.
2136 m4_defun([_LT_CONFIG_COMMANDS], [])
2139 AC_SUBST(enable_fast_install)
2141 # Identify the assembler which will work hand-in-glove with the newly
2142 # built GCC, so that we can examine its features. This is the assembler
2143 # which will be driven by the driver program.
2145 # If build != host, and we aren't building gas in-tree, we identify a
2146 # build->target assembler and hope that it will have the same features
2147 # as the host->target assembler we'll be using.
2148 gcc_cv_gas_major_version=
2149 gcc_cv_gas_minor_version=
2150 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
2152 m4_pattern_allow([AS_FOR_TARGET])dnl
2153 AS_VAR_SET_IF(gcc_cv_as,, [
2154 if test -x "$DEFAULT_ASSEMBLER"; then
2155 gcc_cv_as="$DEFAULT_ASSEMBLER"
2156 elif test -f $gcc_cv_as_gas_srcdir/configure.ac \
2157 && test -f ../gas/Makefile \
2158 && test x$build = x$host; then
2159 gcc_cv_as=../gas/as-new$build_exeext
2160 elif test -x as$build_exeext; then
2161 # Build using assembler in the current directory.
2162 gcc_cv_as=./as$build_exeext
2163 elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then
2164 gcc_cv_as="$AS_FOR_TARGET"
2166 AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
2169 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
2170 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
2171 case "$ORIGINAL_AS_FOR_TARGET" in
2172 ./as | ./as$build_exeext) ;;
2173 *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
2176 AC_MSG_CHECKING(what assembler to use)
2177 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
2178 # Single tree build which includes gas. We want to prefer it
2179 # over whatever linker top-level may have detected, since
2180 # we'll use what we're building after installation anyway.
2181 AC_MSG_RESULT(newly built gas)
2183 _gcc_COMPUTE_GAS_VERSION
2184 in_tree_gas_is_elf=no
2185 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2186 || (grep 'obj_format = multi' ../gas/Makefile \
2187 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
2189 in_tree_gas_is_elf=yes
2192 AC_MSG_RESULT($gcc_cv_as)
2198 [[ --enable-ld[=ARG] build ld [ARG={default,yes,no}]]],
2199 [case "${enableval}" in
2205 install_gold_as_default=no
2207 [[ --enable-gold[=ARG] build gold [ARG={default,yes,no}]]],
2208 [case "${enableval}" in
2210 install_gold_as_default=yes
2213 if test x${default_ld} != x; then
2214 install_gold_as_default=yes
2220 AC_MSG_ERROR([invalid --enable-gold argument])
2224 # Identify the linker which will work hand-in-glove with the newly
2225 # built GCC, so that we can examine its features. This is the linker
2226 # which will be driven by the driver program.
2228 # If build != host, and we aren't building gas in-tree, we identify a
2229 # build->target linker and hope that it will have the same features
2230 # as the host->target linker we'll be using.
2231 gcc_cv_gld_major_version=
2232 gcc_cv_gld_minor_version=
2233 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
2234 gcc_cv_ld_gold_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gold
2235 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
2237 AS_VAR_SET_IF(gcc_cv_ld,, [
2238 if test -x "$DEFAULT_LINKER"; then
2239 gcc_cv_ld="$DEFAULT_LINKER"
2240 elif test $install_gold_as_default = yes \
2241 && test -f $gcc_cv_ld_gold_srcdir/configure.ac \
2242 && test -f ../gold/Makefile \
2243 && test x$build = x$host; then
2244 gcc_cv_ld=../gold/ld-new$build_exeext
2245 elif test -f $gcc_cv_ld_gld_srcdir/configure.ac \
2246 && test -f ../ld/Makefile \
2247 && test x$build = x$host; then
2248 gcc_cv_ld=../ld/ld-new$build_exeext
2249 elif test -x collect-ld$build_exeext; then
2250 # Build using linker in the current directory.
2251 gcc_cv_ld=./collect-ld$build_exeext
2252 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
2253 gcc_cv_ld="$LD_FOR_TARGET"
2255 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
2258 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
2259 PLUGIN_LD_SUFFIX=`basename $gcc_cv_ld | sed -e "s,$target_alias-,,"`
2260 # if the PLUGIN_LD is set ld-new, just have it as ld
2261 # as that is the installed named.
2262 if test x$PLUGIN_LD_SUFFIX = xld-new \
2263 || test x$PLUGIN_LD_SUFFIX = xcollect-ld ; then
2266 AC_ARG_WITH(plugin-ld,
2267 [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])],
2268 [if test x"$withval" != x; then
2269 ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
2270 PLUGIN_LD_SUFFIX="$withval"
2272 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
2273 AC_DEFINE_UNQUOTED(PLUGIN_LD_SUFFIX, "$PLUGIN_LD_SUFFIX", [Specify plugin linker])
2275 # Check to see if we are using gold instead of ld
2276 AC_MSG_CHECKING(whether we are using gold)
2278 if test x$gcc_cv_ld != x; then
2279 if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2280 | grep "GNU gold" > /dev/null; then
2284 AC_MSG_RESULT($ld_is_gold)
2286 AC_MSG_CHECKING(gold linker with split stack support as non default)
2287 # Check to see if default ld is not gold, but gold is
2288 # available and has support for split stack. If gcc was configured
2289 # with gold then no checking is done.
2291 if test x$ld_is_gold = xno && which ${gcc_cv_ld}.gold >/dev/null 2>&1; then
2293 # For platforms other than powerpc64*, enable as appropriate.
2296 ld_gold=`which ${gcc_cv_ld}.gold`
2297 # Make sure this gold has minimal split stack support
2298 if $ld_gold --help 2>/dev/null | grep split-stack-adjust-size >/dev/null 2>&1; then
2299 ld_vers=`$ld_gold --version | sed 1q`
2300 gold_vers=`echo $ld_vers | sed -n \
2301 -e 's,^[[^)]]*[[ ]]\([[0-9]][[0-9]]*\.[[0-9]][[0-9]]*[[^)]]*\)) .*$,\1,p'`
2303 # check that the gold version contains the complete split stack support
2304 # on powerpc64 big and little endian
2306 case "$gold_vers" in
2307 2.25.[[1-9]]*|2.2[[6-9]][[.0-9]]*|2.[[3-9]][[.0-9]]*|[[3-9]].[[.0-9]]*) gold_non_default=yes
2309 *) gold_non_default=no
2315 if test $gold_non_default = yes; then
2316 AC_DEFINE(HAVE_GOLD_NON_DEFAULT_SPLIT_STACK, 1,
2317 [Define if the gold linker supports split stack and is available as a non-default])
2320 AC_MSG_RESULT($gold_non_default)
2322 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
2323 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
2324 case "$ORIGINAL_LD_FOR_TARGET" in
2325 ./collect-ld | ./collect-ld$build_exeext) ;;
2326 *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
2329 AC_MSG_CHECKING(what linker to use)
2330 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \
2331 || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then
2332 # Single tree build which includes ld. We want to prefer it
2333 # over whatever linker top-level may have detected, since
2334 # we'll use what we're building after installation anyway.
2335 AC_MSG_RESULT(newly built ld)
2337 in_tree_ld_is_elf=no
2338 if (grep 'EMUL = .*elf' ../ld/Makefile \
2339 || grep 'EMUL = .*linux' ../ld/Makefile \
2340 || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
2341 in_tree_ld_is_elf=yes
2342 elif test "$ld_is_gold" = yes; then
2343 in_tree_ld_is_elf=yes
2345 for f in $gcc_cv_ld_bfd_srcdir/configure $gcc_cv_ld_gld_srcdir/configure $gcc_cv_ld_gld_srcdir/configure.ac $gcc_cv_ld_gld_srcdir/Makefile.in
2348 gcc_cv_gld_version=`sed -n -e 's/^[ ]*VERSION=[^0-9A-Za-z_]*\([0-9]*\.[0-9]*.*\)/VERSION=\1/p' < $f`
2349 if test x$gcc_cv_gld_version != x; then
2353 case $gcc_cv_gld_version in
2356 *) AC_MSG_ERROR([[cannot find version of in-tree linker]]) ;;
2359 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2360 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2362 ORIGINAL_LD_BFD_FOR_TARGET=../ld/ld-new$build_exeext
2363 ORIGINAL_LD_GOLD_FOR_TARGET=../gold/ld-new$build_exeext
2365 AC_MSG_RESULT($gcc_cv_ld)
2367 gcc_cvs_ld_program=`dirname $gcc_cv_ld`/`basename $gcc_cv_ld $host_exeext`
2368 ORIGINAL_LD_BFD_FOR_TARGET=${gcc_cvs_ld_program}.bfd$host_exeext
2369 ORIGINAL_LD_GOLD_FOR_TARGET=${gcc_cvs_ld_program}.gold$host_exeext
2372 AC_SUBST(ORIGINAL_LD_BFD_FOR_TARGET)
2373 AC_SUBST(ORIGINAL_LD_GOLD_FOR_TARGET)
2375 # Figure out what nm we will be using.
2376 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2377 AS_VAR_SET_IF(gcc_cv_nm,, [
2378 if test -f $gcc_cv_binutils_srcdir/configure.ac \
2379 && test -f ../binutils/Makefile \
2380 && test x$build = x$host; then
2381 gcc_cv_nm=../binutils/nm-new$build_exeext
2382 elif test -x nm$build_exeext; then
2383 gcc_cv_nm=./nm$build_exeext
2384 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
2385 gcc_cv_nm="$NM_FOR_TARGET"
2387 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2390 AC_MSG_CHECKING(what nm to use)
2391 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2392 # Single tree build which includes binutils.
2393 AC_MSG_RESULT(newly built nm)
2396 AC_MSG_RESULT($gcc_cv_nm)
2400 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2401 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2402 case "$ORIGINAL_NM_FOR_TARGET" in
2403 ./nm | ./nm$build_exeext) ;;
2404 *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2408 # Figure out what objdump we will be using.
2409 AS_VAR_SET_IF(gcc_cv_objdump,, [
2410 if test -f $gcc_cv_binutils_srcdir/configure.ac \
2411 && test -f ../binutils/Makefile \
2412 && test x$build = x$host; then
2413 # Single tree build which includes binutils.
2414 gcc_cv_objdump=../binutils/objdump$build_exeext
2415 elif test -x objdump$build_exeext; then
2416 gcc_cv_objdump=./objdump$build_exeext
2417 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2418 gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2420 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2423 AC_MSG_CHECKING(what objdump to use)
2424 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2425 # Single tree build which includes binutils.
2426 AC_MSG_RESULT(newly built objdump)
2427 elif test x$gcc_cv_objdump = x; then
2428 AC_MSG_RESULT(not found)
2430 AC_MSG_RESULT($gcc_cv_objdump)
2433 # Figure out what readelf we will be using.
2434 AS_VAR_SET_IF(gcc_cv_readelf,, [
2435 if test -f $gcc_cv_binutils_srcdir/configure.ac \
2436 && test -f ../binutils/Makefile \
2437 && test x$build = x$host; then
2438 # Single tree build which includes binutils.
2439 gcc_cv_readelf=../binutils/readelf$build_exeext
2440 elif test -x readelf$build_exeext; then
2441 gcc_cv_readelf=./readelf$build_exeext
2442 elif ( set dummy $READELF_FOR_TARGET; test -x $[2] ); then
2443 gcc_cv_readelf="$READELF_FOR_TARGET"
2445 AC_PATH_PROG(gcc_cv_readelf, $READELF_FOR_TARGET)
2448 AC_MSG_CHECKING(what readelf to use)
2449 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2450 # Single tree build which includes binutils.
2451 AC_MSG_RESULT(newly built readelf)
2452 elif test x$gcc_cv_readelf = x; then
2453 AC_MSG_RESULT(not found)
2455 AC_MSG_RESULT($gcc_cv_readelf)
2458 # Figure out what assembler alignment features are present.
2459 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2463 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2464 [Define if your assembler supports .balign and .p2align.])])
2466 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2469 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2470 [Define if your assembler supports specifying the maximum number
2471 of bytes to skip when using the GAS .p2align command.])])
2473 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2476 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2477 [Define if your assembler supports .literal16.])])
2479 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2481 [conftest_label1: .word 0
2483 conftest_label2: .word 0
2485 [if test x$gcc_cv_nm != x; then
2486 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2487 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2488 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2490 else gcc_cv_as_subsection_m1=yes
2492 rm -f conftest.nm1 conftest.nm2
2494 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2495 [Define if your assembler supports .subsection and .subsection -1 starts
2496 emitting at the beginning of your section.])])
2498 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2501 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2503 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2505 [ .weakref foobar, barfnot],,
2506 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2508 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2511 .NSUBSPA $CODE$,COMDAT],,
2512 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2514 # .hidden needs to be supported in both the assembler and the linker,
2515 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2516 # This is irritatingly difficult to feature test for; we have to check the
2517 # date string after the version number. If we've got an in-tree
2518 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2520 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2521 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2527 # Darwin as has some visibility support, though with a different syntax.
2528 gcc_cv_as_hidden=yes
2532 # gnu_indirect_function type is an extension proposed at
2533 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2534 # selection of function implementation
2535 AC_ARG_ENABLE(gnu-indirect-function,
2536 [AS_HELP_STRING([--enable-gnu-indirect-function],
2537 [enable the use of the @gnu_indirect_function to glibc systems])],
2538 [case $enable_gnu_indirect_function in
2540 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2541 Valid choices are 'yes' and 'no'.]) ;;
2543 [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2545 gif=`if test x$enable_gnu_indirect_function = xyes; then echo 1; else echo 0; fi`
2546 AC_DEFINE_UNQUOTED(HAVE_GNU_INDIRECT_FUNCTION, $gif,
2547 [Define if your system supports gnu indirect functions.])
2551 if test $in_tree_ld != yes ; then
2552 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2553 if echo "$ld_ver" | grep GNU > /dev/null; then
2554 if test x"$ld_is_gold" = xyes; then
2555 # GNU gold --version looks like this:
2557 # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
2559 # We extract the binutils version which is more familiar and specific
2560 # than the gold version.
2561 ld_vers=`echo $ld_ver | sed -n \
2562 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
2564 # GNU ld --version looks like this:
2566 # GNU ld (GNU Binutils) 2.21.51.20110225
2567 ld_vers=`echo $ld_ver | sed -n \
2568 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2570 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'`
2571 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2572 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2573 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2577 # See acinclude.m4 (gcc_SUN_LD_VERSION) for the version number
2580 # Don't reuse gcc_gv_sun_ld_vers_* in case a linker other than
2581 # /usr/ccs/bin/ld has been configured.
2582 ld_ver=`$gcc_cv_ld -V 2>&1`
2583 if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2584 ld_vers=`echo $ld_ver | sed -n \
2585 -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2586 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2587 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2595 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2596 [[if test $in_tree_ld = yes ; then
2598 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 \
2599 && test $in_tree_ld_is_elf = yes; then
2600 gcc_cv_ld_hidden=yes
2603 gcc_cv_ld_hidden=yes
2604 if test x"$ld_is_gold" = xyes; then
2606 elif echo "$ld_ver" | grep GNU > /dev/null; then
2608 mmix-knuth-mmixware)
2609 # The linker emits by default mmo, not ELF, so "no" is appropriate.
2613 if test 0"$ld_date" -lt 20020404; then
2614 if test -n "$ld_date"; then
2615 # If there was date string, but was earlier than 2002-04-04, fail
2617 elif test -z "$ld_vers"; then
2618 # If there was no date string nor ld version number, something is wrong
2621 test -z "$ld_vers_patch" && ld_vers_patch=0
2622 if test "$ld_vers_major" -lt 2; then
2624 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2625 gcc_cv_ld_hidden="no"
2626 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2634 # Darwin ld has some visibility support.
2635 gcc_cv_ld_hidden=yes
2637 hppa64*-*-hpux* | ia64*-*-hpux*)
2638 gcc_cv_ld_hidden=yes
2640 *-*-solaris2.1[0-9]*)
2641 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2642 # .symbolic was only added in Solaris 9 12/02.
2643 gcc_cv_ld_hidden=yes
2651 libgcc_visibility=no
2652 AC_SUBST(libgcc_visibility)
2653 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2654 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2655 libgcc_visibility=yes
2656 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2657 [Define if your assembler and linker support .hidden.])
2660 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2661 gcc_cv_ld_ro_rw_mix=unknown
2662 if test $in_tree_ld = yes ; then
2663 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 \
2664 && test $in_tree_ld_is_elf = yes; then
2665 gcc_cv_ld_ro_rw_mix=read-write
2667 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2668 echo '.section myfoosect, "a"' > conftest1.s
2669 echo '.section myfoosect, "aw"' > conftest2.s
2670 echo '.byte 1' >> conftest2.s
2671 echo '.section myfoosect, "a"' > conftest3.s
2672 echo '.byte 0' >> conftest3.s
2673 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2674 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2675 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2676 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2677 conftest2.o conftest3.o > /dev/null 2>&1; then
2678 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2679 | sed -e '/myfoosect/!d' -e N`
2680 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2681 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2682 gcc_cv_ld_ro_rw_mix=read-only
2684 gcc_cv_ld_ro_rw_mix=read-write
2689 rm -f conftest.* conftest[123].*
2692 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2693 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2694 [Define if your linker links a mix of read-only
2695 and read-write sections into a read-write section.])
2697 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2699 gcc_AC_INITFINI_ARRAY
2701 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2702 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2710 [[# GAS versions before 2.11 do not support uleb128,
2711 # despite appearing to.
2712 # ??? There exists an elf-specific test that will crash
2713 # the assembler. Perhaps it's better to figure out whether
2714 # arbitrary sections are supported and try the test.
2715 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2716 if echo "$as_ver" | grep GNU > /dev/null; then
2717 as_vers=`echo $as_ver | sed -n \
2718 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2719 as_major=`expr "$as_vers" : '\([0-9]*\)'`
2720 as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2721 if test $as_major -eq 2 && test $as_minor -lt 11
2723 else gcc_cv_as_leb128=yes
2726 [AC_DEFINE(HAVE_AS_LEB128, 1,
2727 [Define if your assembler supports .sleb128 and .uleb128.])])
2729 # Check if we have assembler support for unwind directives.
2730 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2737 .cfi_escape 1, 2, 3, 4, 5
2741 # If the linker used on Solaris (like Sun ld) isn't capable of merging
2742 # read-only and read-write sections, we need to make sure that the
2743 # assembler used emits read-write .eh_frame sections.
2744 if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2745 if test "x$gcc_cv_objdump" != x; then
2746 if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2747 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2748 gcc_cv_as_cfi_directive=no
2751 i?86-*-solaris2.1[[0-9]]* | x86_64-*-solaris2.1[[0-9]]*)
2752 # On Solaris/x86, make sure that GCC and assembler agree on using
2753 # read-only .eh_frame sections for 64-bit.
2754 if test x$gas = xyes; then
2755 as_ix86_64_opt="--64"
2757 as_ix86_64_opt="-xarch=amd64"
2759 if $gcc_cv_as $as_ix86_64_opt -o conftest.o conftest.s > /dev/null 2>&1 && \
2760 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2761 sed -e /.eh_frame/!d -e N | \
2762 grep READONLY > /dev/null; then
2763 gcc_cv_as_cfi_directive=yes
2765 gcc_cv_as_cfi_directive=no
2769 gcc_cv_as_cfi_directive=yes
2774 # no objdump, err on the side of caution
2775 gcc_cv_as_cfi_directive=no
2778 gcc_cv_as_cfi_directive=yes
2782 gcc_cv_as_cfi_directive=yes
2785 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
2786 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2790 .cfi_adjust_cfa_offset 64
2792 .cfi_adjust_cfa_offset 128
2795 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
2796 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then
2797 gcc_cv_as_cfi_advance_working=yes
2801 # no objdump, err on the side of caution
2802 gcc_cv_as_cfi_advance_working=no
2804 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
2805 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2806 [`if test $gcc_cv_as_cfi_directive = yes \
2807 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2808 [Define 0/1 if your assembler supports CFI directives.])
2810 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
2811 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2812 gcc_cv_as_cfi_personality_directive, ,,
2815 .cfi_personality 0, symbol
2817 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2818 [`if test $gcc_cv_as_cfi_personality_directive = yes;
2819 then echo 1; else echo 0; fi`],
2820 [Define 0/1 if your assembler supports .cfi_personality.])
2822 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2823 gcc_cv_as_cfi_sections_directive, ,,
2825 .cfi_sections .debug_frame, .eh_frame
2829 win32 | pe | cygwin* | mingw32*)
2830 # Need to check that we generated the correct relocation for the
2831 # .debug_frame section. This was fixed for binutils 2.21.
2832 gcc_cv_as_cfi_sections_directive=no
2833 if test "x$gcc_cv_objdump" != x; then
2834 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
2835 grep secrel > /dev/null; then
2836 gcc_cv_as_cfi_sections_directive=yes
2841 gcc_cv_as_cfi_sections_directive=yes
2844 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
2845 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2846 [`if test $gcc_cv_as_cfi_sections_directive = yes;
2847 then echo 1; else echo 0; fi`],
2848 [Define 0/1 if your assembler supports .cfi_sections.])
2850 # GAS versions up to and including 2.11.0 may mis-optimize
2852 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2860 .section .eh_frame,"aw",@progbits
2862 .4byte .LECIE1-.LSCIE1
2876 .4byte .LEFDE1-.LASFDE1
2878 .4byte .LASFDE1-__FRAME_BEGIN__
2886 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2887 cat > conftest.lit <<EOF
2888 0000 10000000 00000000 017a0001 781a0004 .........z..x...
2889 0010 01000000 12000000 18000000 00000000 ................
2890 0020 08000000 04080000 0044 .........D @&t@
2892 cat > conftest.big <<EOF
2893 0000 00000010 00000000 017a0001 781a0004 .........z..x...
2894 0010 00000001 00000012 00000018 00000000 ................
2895 0020 00000008 04000000 0844 .........D @&t@
2897 # If the assembler didn't choke, and we can objdump,
2898 # and we got the correct data, then succeed.
2899 # The text in the here-document typically retains its unix-style line
2900 # endings, while the output of objdump will use host line endings.
2901 # Therefore, use diff -b for the comparisons.
2902 if test x$gcc_cv_objdump != x \
2903 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2904 | tail -3 > conftest.got \
2905 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2906 || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2908 gcc_cv_as_eh_frame=yes
2909 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2910 gcc_cv_as_eh_frame=buggy
2912 # Uh oh, what do we do now?
2913 gcc_cv_as_eh_frame=no
2916 if test $gcc_cv_as_eh_frame = buggy; then
2917 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2918 [Define if your assembler mis-optimizes .eh_frame data.])
2921 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2922 [elf,2,12,0], [--fatal-warnings],
2923 [.section .rodata.str, "aMS", @progbits, 1])
2924 if test $gcc_cv_as_shf_merge = no; then
2925 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2926 [elf,2,12,0], [--fatal-warnings],
2927 [.section .rodata.str, "aMS", %progbits, 1])
2929 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2930 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2931 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2933 gcc_GAS_CHECK_FEATURE([stabs directive], gcc_cv_as_stabs_directive, ,,
2934 [.stabs "gcc2_compiled.",60,0,0,0],,
2935 [AC_DEFINE(HAVE_AS_STABS_DIRECTIVE, 1,
2936 [Define if your assembler supports .stabs.])])
2938 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)],
2939 gcc_cv_as_comdat_group,
2940 [elf,2,16,0], [--fatal-warnings],
2941 [.section .text,"axG",@progbits,.foo,comdat])
2942 if test $gcc_cv_as_comdat_group = yes; then
2943 gcc_cv_as_comdat_group_percent=no
2944 gcc_cv_as_comdat_group_group=no
2946 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
2947 gcc_cv_as_comdat_group_percent,
2948 [elf,2,16,0], [--fatal-warnings],
2949 [.section .text,"axG",%progbits,.foo,comdat])
2950 if test $gcc_cv_as_comdat_group_percent = yes; then
2951 gcc_cv_as_comdat_group_group=no
2954 # Sun as uses a completely different syntax.
2959 .group foo,".text%foo",#comdat
2960 .section ".text%foo", #alloc,#execinstr,#progbits
2965 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2967 .group foo,.text%foo,#comdat
2968 .section .text%foo, "ax", @progbits
2974 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
2975 gcc_cv_as_comdat_group_group,
2979 if test -z "${gcc_cv_as_comdat_group_group+set}"; then
2980 gcc_cv_as_comdat_group_group=no
2984 if test x"$ld_is_gold" = xyes; then
2986 elif test $in_tree_ld = yes ; then
2988 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 \
2989 && test $in_tree_ld_is_elf = yes; then
2992 elif echo "$ld_ver" | grep GNU > /dev/null; then
2994 if test 0"$ld_date" -lt 20050308; then
2995 if test -n "$ld_date"; then
2996 # If there was date string, but was earlier than 2005-03-08, fail
2998 elif test "$ld_vers_major" -lt 2; then
3000 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
3007 *-*-solaris2.1[1-9]*)
3009 # Sun ld has COMDAT group support since Solaris 9, but it doesn't
3010 # interoperate with GNU as until Solaris 11 build 130, i.e. ld
3013 # If using Sun as for COMDAT group as emitted by GCC, one needs at
3014 # least ld version 1.2267.
3015 if test "$ld_vers_major" -gt 1; then
3017 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
3019 elif test "$ld_vers_minor" -ge 2267; then
3024 # Assume linkers other than GNU ld don't support COMDAT group.
3030 # Allow overriding the automatic COMDAT group tests above.
3031 AC_ARG_ENABLE(comdat,
3032 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
3033 [comdat_group="$enable_comdat"])
3034 if test $comdat_group = no; then
3035 gcc_cv_as_comdat_group=no
3036 gcc_cv_as_comdat_group_percent=no
3037 gcc_cv_as_comdat_group_group=no
3039 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
3040 [`if test $gcc_cv_as_comdat_group = yes \
3041 || test $gcc_cv_as_comdat_group_percent = yes \
3042 || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`],
3043 [Define 0/1 if your assembler and linker support COMDAT groups.])
3045 gcc_GAS_CHECK_FEATURE([line table discriminator support],
3046 gcc_cv_as_discriminator,
3050 .loc 1 1 0 discriminator 1],,
3051 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
3052 [Define if your assembler supports the .loc discriminator sub-directive.])])
3054 # Thread-local storage - the check is heavily parameterized.
3063 .section ".tdata","awT",@progbits
3066 ldq $27,__tls_get_addr($29) !literal!1
3067 lda $16,foo($29) !tlsgd!1
3068 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
3069 ldq $27,__tls_get_addr($29) !literal!2
3070 lda $16,foo($29) !tlsldm!2
3071 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
3072 ldq $1,foo($29) !gotdtprel
3073 ldah $2,foo($29) !dtprelhi
3074 lda $3,foo($2) !dtprello
3075 lda $4,foo($29) !dtprel
3076 ldq $1,foo($29) !gottprel
3077 ldah $2,foo($29) !tprelhi
3078 lda $3,foo($2) !tprello
3079 lda $4,foo($29) !tprel'
3082 tls_as_opt=--fatal-warnings
3084 cris-*-*|crisv32-*-*)
3086 .section ".tdata","awT",@progbits
3093 tls_as_opt=--fatal-warnings
3097 .section ".tdata","awT",@progbits
3109 .section ".tdata","awT",@progbits
3113 addil LT%foo-$tls_gdidx$,gp
3114 ldo RT%foo-$tls_gdidx$(%r1),%arg0
3117 addil LT%foo-$tls_ldidx$,gp
3119 ldo RT%foo-$tls_ldidx$(%r1),%arg0
3120 addil LR%foo-$tls_dtpoff$,%ret0
3121 ldo RR%foo-$tls_dtpoff$(%r1),%t1
3123 addil LT%foo-$tls_ieoff$,gp
3124 ldw RT%foo-$tls_ieoff$(%r1),%t2
3127 addil LR%foo-$tls_leoff$,%t1
3128 ldo RR%foo-$tls_leoff$(%r1),%t2'
3131 tls_as_opt=--fatal-warnings
3135 .section ".tdata","awT",%progbits
3146 i[34567]86-*-* | x86_64-*-*)
3148 i[34567]86-*-solaris2.* | x86_64-*-solaris2.1[0-9]*)
3155 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3157 .section .tdata,"awt",@progbits'
3162 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
3163 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
3167 .section ".tdata","awT",@progbits'
3171 tls_as_opt="--fatal-warnings"
3175 conftest_s="$conftest_s
3179 leal foo@tlsgd(,%ebx,1), %eax
3180 leal foo@tlsldm(%ebx), %eax
3181 leal foo@dtpoff(%eax), %edx
3182 movl foo@gottpoff(%ebx), %eax
3183 subl foo@gottpoff(%ebx), %eax
3184 addl foo@gotntpoff(%ebx), %eax
3185 movl foo@indntpoff, %eax
3186 movl \$foo@tpoff, %eax
3187 subl \$foo@tpoff, %eax
3188 leal foo@ntpoff(%ecx), %eax"
3191 if test x$on_solaris = xyes; then
3193 yes) tls_as_opt="$tls_as_opt --64" ;;
3194 no) tls_as_opt="$tls_as_opt -xarch=amd64" ;;
3197 conftest_s="$conftest_s
3201 leaq foo@tlsgd(%rip), %rdi
3202 leaq foo@tlsld(%rip), %rdi
3203 leaq foo@dtpoff(%rax), %rdx
3204 movq foo@gottpoff(%rip), %rax
3205 movq \$foo@tpoff, %rax"
3211 .section ".tdata","awT",@progbits
3214 addl r16 = @ltoff(@dtpmod(foo#)), gp
3215 addl r17 = @ltoff(@dtprel(foo#)), gp
3216 addl r18 = @ltoff(@tprel(foo#)), gp
3217 addl r19 = @dtprel(foo#), gp
3218 adds r21 = @dtprel(foo#), r13
3219 movl r23 = @dtprel(foo#)
3220 addl r20 = @tprel(foo#), gp
3221 adds r22 = @tprel(foo#), r13
3222 movl r24 = @tprel(foo#)'
3225 tls_as_opt=--fatal-warnings
3229 .section .tdata,"awT",@progbits
3233 addik r5,r20,x@TLSGD
3234 addik r5,r20,x@TLSLDM'
3237 tls_as_opt='--fatal-warnings'
3241 .section .tdata,"awT",@progbits
3245 addiu $4, $28, %tlsgd(x)
3246 addiu $4, $28, %tlsldm(x)
3247 lui $4, %dtprel_hi(x)
3248 addiu $4, $4, %dtprel_lo(x)
3249 lw $4, %gottprel(x)($28)
3250 lui $4, %tprel_hi(x)
3251 addiu $4, $4, %tprel_lo(x)'
3254 tls_as_opt='-32 --fatal-warnings'
3258 .section .tdata,"awT",@progbits
3263 move.l x@TLSGD(%a5),%a0
3264 move.l x@TLSLDM(%a5),%a0
3265 move.l x@TLSLDO(%a5),%a0
3266 move.l x@TLSIE(%a5),%a0
3267 move.l x@TLSLE(%a5),%a0'
3270 tls_as_opt='--fatal-warnings'
3274 .section ".tdata","awT",@progbits'
3277 tls_as_opt="--fatal-warnings"
3281 .section ".tdata","awT",%progbits
3285 add x0, x0, #:tlsgd_lo12:x
3290 tls_as_opt='--fatal-warnings'
3294 .extern __get_tpointer
3312 .section ".tdata","awT",@progbits
3320 addi 3,2,ld0@got@tlsgd
3326 addi 3,2,x1@got@tlsld
3332 addis 9,3,x2@dtprel@ha
3333 addi 9,9,x2@dtprel@l
3336 ld 9,x3@got@dtprel(2)
3342 tls_as_opt="-a64 --fatal-warnings"
3346 .section ".tdata","awT",@progbits
3354 addi 3,31,ld0@got@tlsgd
3356 addi 3,31,x1@got@tlsld
3359 addis 9,3,x2@dtprel@ha
3360 addi 9,9,x2@dtprel@l
3361 lwz 9,x3@got@tprel(31)
3364 addis 9,2,x2@tprel@ha
3365 addi 9,9,x2@tprel@l'
3368 tls_as_opt="-a32 --fatal-warnings"
3372 .section ".tdata","awT",@progbits
3381 l %r1,foo@GOTNTPOFF(%r12)
3382 l %r1,0(%r1):tls_load:foo
3383 bas %r14,0(%r1,%r13):tls_gdcall:foo
3384 bas %r14,0(%r1,%r13):tls_ldcall:foo'
3387 tls_as_opt="-m31 --fatal-warnings"
3391 .section ".tdata","awT",@progbits
3399 lg %r1,foo@GOTNTPOFF(%r12)
3400 larl %r1,foo@INDNTPOFF
3401 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
3402 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
3405 tls_as_opt="-m64 -Aesame --fatal-warnings"
3407 sh-*-* | sh[123456789lbe]*-*-*)
3409 .section ".tdata","awT",@progbits
3419 tls_as_opt=--fatal-warnings
3423 sparc*-sun-solaris2.*)
3430 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3432 .section ".tdata",#alloc,#write,#tls'
3437 .section ".tdata","awT",@progbits'
3440 tls_as_opt="-32 --fatal-warnings"
3442 conftest_s="$conftest_s
3445 sethi %tgd_hi22(foo), %o0
3446 add %o0, %tgd_lo10(foo), %o1
3447 add %l7, %o1, %o0, %tgd_add(foo)
3448 call __tls_get_addr, %tgd_call(foo)
3449 sethi %tldm_hi22(foo), %l1
3450 add %l1, %tldm_lo10(foo), %l2
3451 add %l7, %l2, %o0, %tldm_add(foo)
3452 call __tls_get_addr, %tldm_call(foo)
3453 sethi %tldo_hix22(foo), %l3
3454 xor %l3, %tldo_lox10(foo), %l4
3455 add %o0, %l4, %l5, %tldo_add(foo)
3456 sethi %tie_hi22(foo), %o3
3457 add %o3, %tie_lo10(foo), %o3
3458 ld [%l7 + %o3], %o2, %tie_ld(foo)
3459 add %g7, %o2, %o4, %tie_add(foo)
3460 sethi %tle_hix22(foo), %l1
3461 xor %l1, %tle_lox10(foo), %o5
3462 ld [%g7 + %o5], %o1"
3466 .section ".tdata","awT",@progbits
3469 addli r0, zero, tls_gd(foo)
3470 auli r0, zero, tls_gd_ha16(foo)
3471 addli r0, r0, tls_gd_lo16(foo)
3473 addli r0, zero, tls_ie(foo)
3474 auli r0, r0, tls_ie_ha16(foo)
3475 addli r0, r0, tls_ie_lo16(foo)'
3478 tls_as_opt="--fatal-warnings"
3482 .section ".tdata","awT",@progbits
3485 shl16insli r0, zero, hw0_last_tls_gd(foo)
3486 shl16insli r0, zero, hw1_last_tls_gd(foo)
3487 shl16insli r0, r0, hw0_tls_gd(foo)
3489 shl16insli r0, zero, hw1_last_tls_ie(foo)
3490 shl16insli r0, r0, hw0_tls_ie(foo)'
3493 tls_as_opt="--fatal-warnings"
3497 .section ".tdata","awT",@progbits
3500 movi a8, foo@TLSFUNC
3501 movi a10, foo@TLSARG
3502 callx8.tls a8, foo@TLSCALL'
3509 if test "x$enable_tls" = xno ; then
3510 : # TLS explicitly disabled.
3511 elif test "x$enable_tls" = xyes ; then
3512 set_have_as_tls=yes # TLS explicitly enabled.
3513 elif test -z "$tls_first_major"; then
3514 : # If we don't have a check, assume no support.
3516 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
3517 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
3518 [set_have_as_tls=yes])
3520 if test $set_have_as_tls = yes ; then
3521 AC_DEFINE(HAVE_AS_TLS, 1,
3522 [Define if your assembler and linker support thread-local storage.])
3525 # Target-specific assembler checks.
3527 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3528 gcc_cv_ld_static_dynamic=no
3529 gcc_cv_ld_static_option='-Bstatic'
3530 gcc_cv_ld_dynamic_option='-Bdynamic'
3531 if test $in_tree_ld = yes ; then
3532 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
3533 gcc_cv_ld_static_dynamic=yes
3535 elif test x$gcc_cv_ld != x; then
3536 # Check if linker supports -Bstatic/-Bdynamic option
3537 if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
3538 && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
3539 gcc_cv_ld_static_dynamic=yes
3542 # AIX ld uses -b flags
3543 *-*-aix4.[[23]]* | *-*-aix[[5-9]]*)
3544 gcc_cv_ld_static_dynamic=yes
3545 gcc_cv_ld_static_option="-bstatic"
3546 gcc_cv_ld_dynamic_option="-bdynamic"
3548 # HP-UX ld uses -a flags to select between shared and archive.
3550 if test x"$gnu_ld" = xno; then
3551 gcc_cv_ld_static_dynamic=yes
3552 gcc_cv_ld_static_option="-aarchive_shared"
3553 gcc_cv_ld_dynamic_option="-adefault"
3556 # Solaris 2 ld always supports -Bstatic/-Bdynamic.
3558 gcc_cv_ld_static_dynamic=yes
3563 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3564 AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3565 [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.])
3566 AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option",
3567 [Define to the linker option to disable use of shared objects.])
3568 AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option",
3569 [Define to the linker option to enable use of shared objects.])
3571 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3573 if test x"$demangler_in_ld" = xyes; then
3574 AC_MSG_CHECKING(linker --demangle support)
3575 gcc_cv_ld_demangle=no
3576 if test $in_tree_ld = yes; then
3577 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 \
3578 gcc_cv_ld_demangle=yes
3580 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3581 # Check if the GNU linker supports --demangle option
3582 if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3583 gcc_cv_ld_demangle=yes
3586 if test x"$gcc_cv_ld_demangle" = xyes; then
3587 AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3588 [Define if your linker supports --demangle option.])
3590 AC_MSG_RESULT($gcc_cv_ld_demangle)
3593 AC_MSG_CHECKING(linker plugin support)
3595 if test -f liblto_plugin.la; then
3596 save_ld_ver="$ld_ver"
3597 save_ld_vers_major="$ld_vers_major"
3598 save_ld_vers_minor="$ld_vers_minor"
3599 save_ld_is_gold="$ld_is_gold"
3603 if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
3605 # FIXME: ld_is_gold?
3606 ld_vers_major="$gcc_cv_gld_major_version"
3607 ld_vers_minor="$gcc_cv_gld_minor_version"
3609 # Determine plugin linker version.
3610 # FIXME: Partial duplicate from above, generalize.
3612 ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q`
3613 if echo "$ld_ver" | grep GNU > /dev/null; then
3614 if echo "$ld_ver" | grep "GNU gold" > /dev/null; then
3616 ld_vers=`echo $ld_ver | sed -n \
3617 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
3619 ld_vers=`echo $ld_ver | sed -n \
3620 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
3622 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
3623 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
3628 # Determine plugin support.
3629 if echo "$ld_ver" | grep GNU > /dev/null; then
3630 # Require GNU ld or gold 2.21+ for plugin support by default.
3631 if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then
3633 # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20.
3634 elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then
3639 ld_ver="$save_ld_ver"
3640 ld_vers_major="$save_ld_vers_major"
3641 ld_vers_minor="$save_ld_vers_minor"
3642 ld_is_gold="$save_ld_is_gold"
3644 AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin,
3645 [Define to the level of your linker's plugin support.])
3646 AC_MSG_RESULT($gcc_cv_lto_plugin)
3650 gcc_GAS_CHECK_FEATURE([-mabi option], gcc_cv_as_aarch64_mabi,,
3651 [-mabi=lp64], [.text],,,)
3652 if test x$gcc_cv_as_aarch64_mabi = xyes; then
3653 AC_DEFINE(HAVE_AS_MABI_OPTION, 1,
3654 [Define if your assembler supports the -mabi option.])
3656 if test x$with_abi = xilp32; then
3657 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3658 Upgrade the Assembler.])
3660 if test x"$with_multilib_list" = xdefault; then
3661 TM_MULTILIB_CONFIG=lp64
3663 aarch64_multilibs=`echo $with_multilib_list | sed -e 's/,/ /g'`
3664 for aarch64_multilib in ${aarch64_multilibs}; do
3665 case ${aarch64_multilib} in
3667 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3668 Upgrade the Assembler.])
3676 # Check if we have binutils support for relocations types needed by -fpic
3677 gcc_GAS_CHECK_FEATURE([-fpic relocs], gcc_cv_as_aarch64_picreloc,,,
3680 ldr x0, [[x2, #:gotpage_lo15:globalsym]]
3681 ],,[AC_DEFINE(HAVE_AS_SMALL_PIC_RELOCS, 1,
3682 [Define if your assembler supports relocs needed by -fpic.])])
3683 # Enable default workaround for AArch64 Cortex-A53 erratum 835769.
3684 AC_ARG_ENABLE(fix-cortex-a53-835769,
3686 AS_HELP_STRING([--enable-fix-cortex-a53-835769],
3687 [enable workaround for AArch64 Cortex-A53 erratum 835769 by default])
3688 AS_HELP_STRING([--disable-fix-cortex-a53-835769],
3689 [disable workaround for AArch64 Cortex-A53 erratum 835769 by default])
3694 tm_defines="${tm_defines} TARGET_FIX_ERR_A53_835769_DEFAULT=1"
3699 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-835769.\
3700 Valid choices are 'yes' and 'no'.])
3706 # Enable default workaround for AArch64 Cortex-A53 erratum 843419.
3707 AC_ARG_ENABLE(fix-cortex-a53-843419,
3709 AS_HELP_STRING([--enable-fix-cortex-a53-843419],
3710 [enable workaround for AArch64 Cortex-A53 erratum 843419 by default])
3711 AS_HELP_STRING([--disable-fix-cortex-a53-843419],
3712 [disable workaround for AArch64 Cortex-A53 erratum 843419 by default])
3717 tm_defines="${tm_defines} TARGET_FIX_ERR_A53_843419_DEFAULT=1"
3722 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-843419.\
3723 Valid choices are 'yes' and 'no'.])
3731 # All TARGET_ABI_OSF targets.
3732 alpha*-*-linux* | alpha*-*-*bsd*)
3733 gcc_GAS_CHECK_FEATURE([explicit relocation support],
3734 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3737 extbl $3, $2, $3 !lituse_bytoff!1
3738 ldq $2, a($29) !literal!1
3739 ldq $4, b($29) !literal!2
3740 ldq_u $3, 0($2) !lituse_base!1
3741 ldq $27, f($29) !literal!5
3742 jsr $26, ($27), f !lituse_jsr!5
3743 ldah $29, 0($26) !gpdisp!3
3744 lda $0, c($29) !gprel
3745 ldah $1, d($29) !gprelhigh
3746 lda $1, d($1) !gprellow
3747 lda $29, 0($29) !gpdisp!3],,
3748 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3749 [Define if your assembler supports explicit relocations.])])
3750 gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3751 gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3754 ldq $27, a($29) !literal!1
3755 jsr $26, ($27), a !lituse_jsrdirect!1],,
3756 [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3757 [Define if your assembler supports the lituse_jsrdirect relocation.])])
3761 gcc_GAS_CHECK_FEATURE([--mlink-relax option], gcc_cv_as_avr_mlink_relax,,
3762 [--mlink-relax], [.text],,
3763 [AC_DEFINE(HAVE_AS_AVR_MLINK_RELAX_OPTION, 1,
3764 [Define if your avr assembler supports --mlink-relax option.])])
3766 gcc_GAS_CHECK_FEATURE([-mrmw option], gcc_cv_as_avr_mrmw,,
3768 [AC_DEFINE(HAVE_AS_AVR_MRMW_OPTION, 1,
3769 [Define if your avr assembler supports -mrmw option.])])
3773 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3774 gcc_cv_as_cris_no_mul_bug,[2,15,91],
3775 [-no-mul-bug-abort], [.text],,
3776 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3777 [Define if your assembler supports the -no-mul-bug-abort option.])])
3781 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3782 [.register %g2, #scratch],,
3783 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3784 [Define if your assembler supports .register.])])
3786 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3788 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3789 [Define if your assembler supports -relax option.])])
3791 gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3792 gcc_cv_as_sparc_gotdata_op,,
3799 sethi %gdop_hix22(foo), %g1
3800 xor %g1, %gdop_lox10(foo), %g1
3801 ld [[%l7 + %g1]], %g2, %gdop(foo)],
3802 [if test x$gcc_cv_ld != x \
3803 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3804 if test x$gcc_cv_objdump != x; then
3805 if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3806 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3807 gcc_cv_as_sparc_gotdata_op=no
3809 gcc_cv_as_sparc_gotdata_op=yes
3814 [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3815 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3817 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3818 gcc_cv_as_sparc_ua_pcrel,,
3826 .uaword %r_disp32(foo)],
3827 [if test x$gcc_cv_ld != x \
3828 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3829 gcc_cv_as_sparc_ua_pcrel=yes
3832 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3833 [Define if your assembler and linker support unaligned PC relative relocs.])
3835 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3836 gcc_cv_as_sparc_ua_pcrel_hidden,,
3841 .uaword %r_disp32(foo)
3842 .byte 0x32, 0x33, 0x34
3847 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3848 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3849 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3850 | grep ' 31000000 07323334' > /dev/null 2>&1; then
3851 if $gcc_cv_objdump -R conftest 2> /dev/null \
3852 | grep 'DISP32' > /dev/null 2>&1; then
3855 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3859 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3860 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3861 ]) # unaligned pcrel relocs
3863 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3864 gcc_cv_as_sparc_offsetable_lo10,,
3867 or %g1, %lo(ab) + 12, %g1
3868 or %g1, %lo(ab + 12), %g1],
3869 [if test x$gcc_cv_objdump != x \
3870 && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3871 | grep ' 82106000 82106000' > /dev/null 2>&1; then
3872 gcc_cv_as_sparc_offsetable_lo10=yes
3874 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3875 [Define if your assembler supports offsetable %lo().])])
3877 gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions],
3878 gcc_cv_as_sparc_fmaf,,
3881 .register %g2, #scratch
3882 .register %g3, #scratch
3884 fmaddd %f0, %f2, %f4, %f6
3885 addxccc %g1, %g2, %g3
3886 fsrl32 %f2, %f4, %f8
3887 fnaddd %f10, %f12, %f14],,
3888 [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1,
3889 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])])
3891 gcc_GAS_CHECK_FEATURE([SPARC4 instructions],
3892 gcc_cv_as_sparc_sparc4,,
3895 .register %g2, #scratch
3896 .register %g3, #scratch
3899 1: cwbneg %g2, %g3, 1f
3902 aes_kexpand0 %f4, %f6, %f8
3903 des_round %f38, %f40, %f42, %f44
3904 camellia_f %f54, %f56, %f58, %f60
3905 kasumi_fi_xor %f46, %f48, %f50, %f52],,
3906 [AC_DEFINE(HAVE_AS_SPARC4, 1,
3907 [Define if your assembler supports SPARC4 instructions.])])
3909 gcc_GAS_CHECK_FEATURE([LEON instructions],
3910 gcc_cv_as_sparc_leon,,
3913 .register %g2, #scratch
3914 .register %g3, #scratch
3918 casa [[%g2]] 0xb, %g3, %g1],,
3919 [AC_DEFINE(HAVE_AS_LEON, 1,
3920 [Define if your assembler supports LEON instructions.])])
3924 i[34567]86-*-* | x86_64-*-*)
3928 # Full C++ conformance when using a shared libstdc++-v3 requires some
3929 # support from the Cygwin DLL, which in more recent versions exports
3930 # wrappers to aid in interposing and redirecting operators new, delete,
3931 # etc., as per n2800 #17.6.4.6 [replacement.functions]. Check if we
3932 # are configuring for a version of Cygwin that exports the wrappers.
3933 if test x$host = x$target && test x$host_cpu = xi686; then
3934 AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3936 # Can't check presence of libc functions during cross-compile, so
3937 # we just have to assume we're building for an up-to-date target.
3938 gcc_ac_cygwin_dll_wrappers=yes
3940 AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3941 [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3942 [Define if you want to generate code by default that assumes that the
3943 Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3946 cygwin* | pe | mingw32* | interix*)
3947 # Recent binutils allows the three-operand form of ".comm" on PE. This
3948 # definition is used unconditionally to initialise the default state of
3949 # the target option variable that governs usage of the feature.
3950 gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3951 [2,19,52],,[.comm foo,1,32])
3952 AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3953 [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3954 [Define if your assembler supports specifying the alignment
3955 of objects allocated using the GAS .comm command.])
3956 # Used for DWARF 2 in PE
3957 gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3958 gcc_cv_as_ix86_pe_secrel32,
3964 [if test x$gcc_cv_ld != x \
3965 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3966 gcc_cv_as_ix86_pe_secrel32=yes
3969 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3970 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3971 # Test if the assembler supports the extended form of the .section
3972 # directive that specifies section alignment. LTO support uses this,
3973 # but normally only after installation, so we warn but don't fail the
3974 # configure if LTO is enabled but the assembler does not support it.
3975 gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3976 [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3977 if test x$gcc_cv_as_section_has_align != xyes; then
3978 case ",$enable_languages," in
3980 AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3987 # Test if the assembler supports the section flag 'e' for specifying
3988 # an excluded section.
3989 gcc_GAS_CHECK_FEATURE([.section with e], gcc_cv_as_section_has_e,
3990 [2,22,51], [--fatal-warnings],
3993 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3994 [`if test $gcc_cv_as_section_has_e = yes; then echo 1; else echo 0; fi`],
3995 [Define if your assembler supports specifying the section flag e.])
3997 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3998 gcc_cv_as_ix86_filds,,,
3999 [filds (%ebp); fists (%ebp)],,
4000 [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
4001 [Define if your assembler uses filds and fists mnemonics.])])
4003 gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
4004 gcc_cv_as_ix86_fildq,,,
4005 [fildq (%ebp); fistpq (%ebp)],,
4006 [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
4007 [Define if your assembler uses fildq and fistq mnemonics.])])
4009 gcc_GAS_CHECK_FEATURE([cmov syntax],
4010 gcc_cv_as_ix86_cmov_sun_syntax,,,
4011 [cmovl.l %edx, %eax],,
4012 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
4013 [Define if your assembler supports the Sun syntax for cmov.])])
4015 gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
4016 gcc_cv_as_ix86_ffreep,,,
4018 [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
4019 [Define if your assembler supports the ffreep mnemonic.])])
4021 gcc_GAS_CHECK_FEATURE([.quad directive],
4022 gcc_cv_as_ix86_quad,,,
4024 [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
4025 [Define if your assembler supports the .quad directive.])])
4027 gcc_GAS_CHECK_FEATURE([sahf mnemonic],
4028 gcc_cv_as_ix86_sahf,,,
4031 [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
4032 [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
4034 gcc_GAS_CHECK_FEATURE([interunit movq mnemonic],
4035 gcc_cv_as_ix86_interunit_movq,,,
4039 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_INTERUNIT_MOVQ,
4040 [`if test $gcc_cv_as_ix86_interunit_movq = yes; then echo 1; else echo 0; fi`],
4041 [Define if your assembler supports interunit movq mnemonic.])
4043 gcc_GAS_CHECK_FEATURE([hle prefixes],
4044 gcc_cv_as_ix86_hle,,,
4045 [lock xacquire cmpxchg %esi, (%ecx)],,
4046 [AC_DEFINE(HAVE_AS_IX86_HLE, 1,
4047 [Define if your assembler supports HLE prefixes.])])
4049 gcc_GAS_CHECK_FEATURE([swap suffix],
4050 gcc_cv_as_ix86_swap,,,
4051 [movl.s %esp, %ebp],,
4052 [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
4053 [Define if your assembler supports the swap suffix.])])
4055 gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
4056 gcc_cv_as_ix86_diff_sect_delta,,,
4064 [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
4065 [Define if your assembler supports the subtraction of symbols in different sections.])])
4067 # These two are used unconditionally by i386.[ch]; it is to be defined
4068 # to 1 if the feature is present, 0 otherwise.
4069 as_ix86_gotoff_in_data_opt=
4070 if test x$gas = xyes; then
4071 as_ix86_gotoff_in_data_opt="--32"
4073 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
4074 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],
4075 [$as_ix86_gotoff_in_data_opt],
4081 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
4082 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
4083 [Define true if the assembler supports '.long foo@GOTOFF'.])
4085 gcc_GAS_CHECK_FEATURE([rep and lock prefix],
4086 gcc_cv_as_ix86_rep_lock_prefix,,,
4092 lock addl %edi, (%eax,%esi)
4093 lock orl $0, (%esp)],,
4094 [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
4095 [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
4097 gcc_GAS_CHECK_FEATURE([ud2 mnemonic],
4098 gcc_cv_as_ix86_ud2,,,
4100 [AC_DEFINE(HAVE_AS_IX86_UD2, 1,
4101 [Define if your assembler supports the 'ud2' mnemonic.])])
4103 gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
4104 gcc_cv_as_ix86_tlsgdplt,,,
4105 [call tls_gd@tlsgdplt],
4106 [if test x$gcc_cv_ld != x \
4107 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
4108 gcc_cv_as_ix86_tlsgdplt=yes
4111 [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
4112 [Define if your assembler and linker support @tlsgdplt.])])
4115 .section .tdata,"aw'$tls_section_flag'",@progbits
4117 .section .text,"ax",@progbits
4118 call tls_ld@tlsldmplt'
4119 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
4120 gcc_cv_as_ix86_tlsldmplt,,,
4122 [if test x$gcc_cv_ld != x \
4123 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
4124 gcc_cv_as_ix86_tlsldmplt=yes
4127 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDMPLT,
4128 [`if test $gcc_cv_as_ix86_tlsldmplt = yes; then echo 1; else echo 0; fi`],
4129 [Define to 1 if your assembler and linker support @tlsldmplt.])
4131 # Enforce 32-bit output with gas and gld.
4132 if test x$gas = xyes; then
4133 as_ix86_tls_ldm_opt="--32"
4135 if echo "$ld_ver" | grep GNU > /dev/null; then
4136 if $gcc_cv_ld -V 2>/dev/null | grep elf_i386_sol2 > /dev/null; then
4137 ld_ix86_tls_ldm_opt="-melf_i386_sol2"
4139 ld_ix86_tls_ldm_opt="-melf_i386"
4143 .section .text,"ax",@progbits
4145 .type _start, @function
4147 leal value@tlsldm(%ebx), %eax
4148 call ___tls_get_addr@plt
4150 .section .tdata,"aw'$tls_section_flag'",@progbits
4151 .type value, @object
4153 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM reloc],
4154 gcc_cv_as_ix86_tlsldm,,
4155 [$as_ix86_tls_ldm_opt],
4157 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
4158 && $gcc_cv_ld $ld_ix86_tls_ldm_opt -o conftest conftest.o $ld_tls_libs -lc > /dev/null 2>&1; then
4159 if $gcc_cv_objdump -d conftest 2>/dev/null | grep nop > /dev/null \
4160 || dis conftest 2>/dev/null | grep nop > /dev/null; then
4161 gcc_cv_as_ix86_tlsldm=yes
4165 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDM,
4166 [`if test $gcc_cv_as_ix86_tlsldm = yes; then echo 1; else echo 0; fi`],
4167 [Define to 1 if your assembler and linker support @tlsldm.])
4172 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
4173 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
4175 addl r15 = @ltoffx(x#), gp
4177 ld8.mov r16 = [[r15]], x#],,
4178 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
4179 [Define if your assembler supports ltoffx and ldxmov relocations.])])
4187 gcc_GAS_CHECK_FEATURE([.machine directive support],
4188 gcc_cv_as_machine_directive,,,
4189 [ .machine ppc7400])
4190 if test x$gcc_cv_as_machine_directive != xyes; then
4191 echo "*** This target requires an assembler supporting \".machine\"" >&2
4192 echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
4193 test x$build = x$target && exit 1
4199 *-*-aix*) conftest_s=' .machine "pwr5"
4202 *-*-darwin*) conftest_s=' .text
4204 *) conftest_s=' .machine power4
4209 gcc_GAS_CHECK_FEATURE([mfcr field support],
4210 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
4212 [AC_DEFINE(HAVE_AS_MFCRF, 1,
4213 [Define if your assembler supports mfcr field.])])
4216 *-*-aix*) conftest_s=' .machine "pwr5"
4219 *) conftest_s=' .machine power5
4224 gcc_GAS_CHECK_FEATURE([popcntb support],
4225 gcc_cv_as_powerpc_popcntb, [2,17,0],,
4227 [AC_DEFINE(HAVE_AS_POPCNTB, 1,
4228 [Define if your assembler supports popcntb field.])])
4231 *-*-aix*) conftest_s=' .machine "pwr5x"
4234 *) conftest_s=' .machine power5
4239 gcc_GAS_CHECK_FEATURE([fp round support],
4240 gcc_cv_as_powerpc_fprnd, [2,17,0],,
4242 [AC_DEFINE(HAVE_AS_FPRND, 1,
4243 [Define if your assembler supports fprnd.])])
4246 *-*-aix*) conftest_s=' .machine "pwr6"
4249 *) conftest_s=' .machine power6
4254 gcc_GAS_CHECK_FEATURE([move fp gpr support],
4255 gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
4257 [AC_DEFINE(HAVE_AS_MFPGPR, 1,
4258 [Define if your assembler supports mffgpr and mftgpr.])])
4261 *-*-aix*) conftest_s=' .csect .text[[PR]]
4263 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
4267 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
4268 *) conftest_s=' .text
4270 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
4273 gcc_GAS_CHECK_FEATURE([rel16 relocs],
4274 gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
4276 [AC_DEFINE(HAVE_AS_REL16, 1,
4277 [Define if your assembler supports R_PPC_REL16 relocs.])])
4280 *-*-aix*) conftest_s=' .machine "pwr6"
4283 *) conftest_s=' .machine power6
4288 gcc_GAS_CHECK_FEATURE([compare bytes support],
4289 gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
4291 [AC_DEFINE(HAVE_AS_CMPB, 1,
4292 [Define if your assembler supports cmpb.])])
4295 *-*-aix*) conftest_s=' .machine "pwr6"
4298 *) conftest_s=' .machine power6
4303 gcc_GAS_CHECK_FEATURE([decimal float support],
4304 gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
4306 [AC_DEFINE(HAVE_AS_DFP, 1,
4307 [Define if your assembler supports DFP instructions.])])
4310 *-*-aix*) conftest_s=' .machine "pwr7"
4313 *) conftest_s=' .machine power7
4318 gcc_GAS_CHECK_FEATURE([vector-scalar support],
4319 gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
4321 [AC_DEFINE(HAVE_AS_VSX, 1,
4322 [Define if your assembler supports VSX instructions.])])
4325 *-*-aix*) conftest_s=' .machine "pwr7"
4328 *) conftest_s=' .machine power7
4333 gcc_GAS_CHECK_FEATURE([popcntd support],
4334 gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
4336 [AC_DEFINE(HAVE_AS_POPCNTD, 1,
4337 [Define if your assembler supports POPCNTD instructions.])])
4340 *-*-aix*) conftest_s=' .machine "pwr8"
4341 .csect .text[[PR]]';;
4342 *) conftest_s=' .machine power8
4346 gcc_GAS_CHECK_FEATURE([power8 support],
4347 gcc_cv_as_powerpc_power8, [2,19,2], -a32,
4349 [AC_DEFINE(HAVE_AS_POWER8, 1,
4350 [Define if your assembler supports POWER8 instructions.])])
4353 *-*-aix*) conftest_s=' .machine "pwr9"
4354 .csect .text[[PR]]';;
4355 *) conftest_s=' .machine power9
4359 gcc_GAS_CHECK_FEATURE([power9 support],
4360 gcc_cv_as_powerpc_power9, [2,19,2], -a32,
4362 [AC_DEFINE(HAVE_AS_POWER9, 1,
4363 [Define if your assembler supports POWER9 instructions.])])
4366 *-*-aix*) conftest_s=' .csect .text[[PR]]
4368 *) conftest_s=' .text
4372 gcc_GAS_CHECK_FEATURE([lwsync support],
4373 gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
4375 [AC_DEFINE(HAVE_AS_LWSYNC, 1,
4376 [Define if your assembler supports LWSYNC instructions.])])
4379 *-*-aix*) conftest_s=' .machine "476"
4382 *) conftest_s=' .machine "476"
4387 gcc_GAS_CHECK_FEATURE([data cache invalidate support],
4388 gcc_cv_as_powerpc_dci, [9,99,0], -a32,
4390 [AC_DEFINE(HAVE_AS_DCI, 1,
4391 [Define if your assembler supports the DCI/ICI instructions.])])
4393 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4394 gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
4395 [.gnu_attribute 4,1],,
4396 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4397 [Define if your assembler supports .gnu_attribute.])])
4399 gcc_GAS_CHECK_FEATURE([tls marker support],
4400 gcc_cv_as_powerpc_tls_markers, [2,20,0],,
4401 [ bl __tls_get_addr(x@tlsgd)],,
4402 [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
4403 [Define if your assembler supports arg info for __tls_get_addr.])])
4405 gcc_GAS_CHECK_FEATURE([prologue entry point marker support],
4406 gcc_cv_as_powerpc_entry_markers, [2,26,0],-a64 --fatal-warnings,
4407 [ .reloc .,R_PPC64_ENTRY; nop],,
4408 [AC_DEFINE(HAVE_AS_ENTRY_MARKERS, 1,
4409 [Define if your assembler supports the R_PPC64_ENTRY relocation.])])
4413 gcc_GAS_CHECK_FEATURE([AIX .ref support],
4414 gcc_cv_as_aix_ref, [2,21,0],,
4415 [ .csect stuff[[rw]]
4421 [AC_DEFINE(HAVE_AS_REF, 1,
4422 [Define if your assembler supports .ref])])
4424 gcc_GAS_CHECK_FEATURE([AIX DWARF location lists section support],
4425 gcc_cv_as_aix_dwloc, [2,21,0],,
4430 [AC_DEFINE(HAVE_XCOFF_DWARF_EXTRAS, 1,
4431 [Define if your assembler supports AIX debug frame section label reference.])])
4437 gcc_GAS_CHECK_FEATURE([explicit relocation support],
4438 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
4439 [ lw $4,%gp_rel(foo)($4)],,
4440 [if test x$target_cpu_default = x
4441 then target_cpu_default=MASK_EXPLICIT_RELOCS
4442 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
4445 gcc_GAS_CHECK_FEATURE([-mno-shared support],
4446 gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
4447 [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
4448 [Define if the assembler understands -mno-shared.])])
4450 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4451 gcc_cv_as_mips_gnu_attribute, [2,18,0],,
4452 [.gnu_attribute 4,1],,
4453 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4454 [Define if your assembler supports .gnu_attribute.])])
4456 gcc_GAS_CHECK_FEATURE([.module support],
4457 gcc_cv_as_mips_dot_module,,[-32],
4460 [AC_DEFINE(HAVE_AS_DOT_MODULE, 1,
4461 [Define if your assembler supports .module.])])
4462 if test x$gcc_cv_as_mips_dot_module = xno \
4463 && test x$with_fp_32 != x; then
4465 [Requesting --with-fp-32= requires assembler support for .module.])
4468 gcc_GAS_CHECK_FEATURE([.micromips support],
4469 gcc_cv_as_micromips_support,,[--fatal-warnings],
4471 [AC_DEFINE(HAVE_GAS_MICROMIPS, 1,
4472 [Define if your assembler supports the .set micromips directive])])
4474 gcc_GAS_CHECK_FEATURE([.dtprelword support],
4475 gcc_cv_as_mips_dtprelword, [2,18,0],,
4476 [.section .tdata,"awT",@progbits
4480 .dtprelword x+0x8000],,
4481 [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
4482 [Define if your assembler supports .dtprelword.])])
4484 gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
4485 gcc_cv_as_mips_dspr1_mult,,,
4495 [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
4496 [Define if your assembler supports DSPR1 mult.])])
4498 AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
4499 gcc_cv_as_ld_jalr_reloc=no
4500 if test $gcc_cv_as_mips_explicit_relocs = yes; then
4501 if test $in_tree_ld = yes ; then
4502 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 \
4503 && test $in_tree_ld_is_elf = yes; then
4504 gcc_cv_as_ld_jalr_reloc=yes
4506 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
4507 echo ' .ent x' > conftest.s
4508 echo 'x: lw $2,%got_disp(y)($3)' >> conftest.s
4509 echo ' lw $25,%call16(y)($28)' >> conftest.s
4510 echo ' .reloc 1f,R_MIPS_JALR,y' >> conftest.s
4511 echo '1: jalr $25' >> conftest.s
4512 echo ' .reloc 1f,R_MIPS_JALR,x' >> conftest.s
4513 echo '1: jalr $25' >> conftest.s
4514 echo ' .end x' >> conftest.s
4515 if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
4516 && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
4517 if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
4518 && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
4519 gcc_cv_as_ld_jalr_reloc=yes
4525 if test $gcc_cv_as_ld_jalr_reloc = yes; then
4526 if test x$target_cpu_default = x; then
4527 target_cpu_default=MASK_RELAX_PIC_CALLS
4529 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
4532 AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
4534 AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
4535 [gcc_cv_ld_mips_personality_relaxation],
4536 [gcc_cv_ld_mips_personality_relaxation=no
4537 if test $in_tree_ld = yes ; then
4538 if test "$gcc_cv_gld_major_version" -eq 2 \
4539 -a "$gcc_cv_gld_minor_version" -ge 21 \
4540 -o "$gcc_cv_gld_major_version" -gt 2; then
4541 gcc_cv_ld_mips_personality_relaxation=yes
4543 elif test x$gcc_cv_as != x \
4544 -a x$gcc_cv_ld != x \
4545 -a x$gcc_cv_readelf != x ; then
4546 cat > conftest.s <<EOF
4548 .cfi_personality 0x80,indirect_ptr
4555 .section .data,"aw",@progbits
4559 if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
4560 && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
4561 if $gcc_cv_readelf -d conftest 2>&1 \
4562 | grep TEXTREL > /dev/null 2>&1; then
4564 elif $gcc_cv_readelf --relocs conftest 2>&1 \
4565 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
4568 gcc_cv_ld_mips_personality_relaxation=yes
4572 rm -f conftest.s conftest.o conftest])
4573 if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
4574 AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
4575 [Define if your linker can relax absolute .eh_frame personality
4576 pointers into PC-relative form.])
4579 gcc_GAS_CHECK_FEATURE([-mnan= support],
4580 gcc_cv_as_mips_nan,,
4582 [AC_DEFINE(HAVE_AS_NAN, 1,
4583 [Define if the assembler understands -mnan=.])])
4584 if test x$gcc_cv_as_mips_nan = xno \
4585 && test x$with_nan != x; then
4587 [Requesting --with-nan= requires assembler support for -mnan=])
4591 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4592 gcc_cv_as_s390_gnu_attribute, [2,18,0],,
4593 [.gnu_attribute 8,1],,
4594 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4595 [Define if your assembler supports .gnu_attribute.])])
4596 gcc_GAS_CHECK_FEATURE([.machine and .machinemode support],
4597 gcc_cv_as_s390_machine_machinemode, [2,24,0],,
4602 [AC_DEFINE(HAVE_AS_MACHINE_MACHINEMODE, 1,
4603 [Define if your assembler supports .machine and .machinemode.])])
4604 gcc_GAS_CHECK_FEATURE([architecture modifiers support],
4605 gcc_cv_as_s390_architecture_modifiers, [2,26,0],,
4606 [ .machine z13+vx ],,
4607 [AC_DEFINE(HAVE_AS_ARCHITECTURE_MODIFIERS, 1,
4608 [Define if your assembler supports architecture modifiers.])])
4612 # Mips and HP-UX need the GNU assembler.
4613 # Linux on IA64 might be able to use the Intel assembler.
4616 mips*-*-* | *-*-hpux* )
4617 if test x$gas_flag = xyes \
4618 || test x"$host" != x"$build" \
4619 || test ! -x "$gcc_cv_as" \
4620 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
4623 echo "*** This configuration requires the GNU assembler" >&2
4629 # ??? Not all targets support dwarf2 debug_line, even within a version
4630 # of gas. Moreover, we need to emit a valid instruction to trigger any
4631 # info to the output file. So, as supported targets are added to gas 2.11,
4632 # add some instruction here to (also) show we expect this might work.
4633 # ??? Once 2.11 is released, probably need to add first known working
4634 # version to the per-target configury.
4636 aarch64 | alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze \
4637 | mips | nios2 | pa | rs6000 | score | sparc | spu | tilegx | tilepro \
4638 | visium | xstormy16 | xtensa)
4648 if test x"$insn" != x; then
4650 .file 1 \"conftest.s\"
4653 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
4654 gcc_cv_as_dwarf2_debug_line,
4655 [elf,2,11,0],, [$conftest_s],
4656 [if test x$gcc_cv_objdump != x \
4657 && $gcc_cv_objdump -h conftest.o 2> /dev/null \
4658 | grep debug_line > /dev/null 2>&1; then
4659 gcc_cv_as_dwarf2_debug_line=yes
4662 # The .debug_line file table must be in the exact order that
4663 # we specified the files, since these indices are also used
4664 # by DW_AT_decl_file. Approximate this test by testing if
4665 # the assembler bitches if the same index is assigned twice.
4666 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
4667 gcc_cv_as_dwarf2_file_buggy,,,
4671 if test $gcc_cv_as_dwarf2_debug_line = yes \
4672 && test $gcc_cv_as_dwarf2_file_buggy = no; then
4673 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
4674 [Define if your assembler supports dwarf2 .file/.loc directives,
4675 and preserves file table indices exactly as given.])
4678 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
4679 gcc_cv_as_gdwarf2_flag,
4680 [elf,2,11,0], [--gdwarf2], [$insn],,
4681 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
4682 [Define if your assembler supports the --gdwarf2 option.])])
4684 gcc_GAS_CHECK_FEATURE([--gstabs option],
4685 gcc_cv_as_gstabs_flag,
4686 [elf,2,11,0], [--gstabs], [$insn],,
4687 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
4688 [Define if your assembler supports the --gstabs option.])])
4690 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
4691 gcc_cv_as_debug_prefix_map_flag,
4692 [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
4693 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
4694 [Define if your assembler supports the --debug-prefix-map option.])])
4697 gcc_GAS_CHECK_FEATURE([compressed debug sections],
4698 gcc_cv_as_compress_debug,,[--compress-debug-sections],,
4699 [# gas compiled without zlib cannot compress debug sections and warns
4700 # about it, but still exits successfully. So check for this, too.
4701 if $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null
4703 gcc_cv_as_compress_debug=0
4704 elif $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s > /dev/null 2>&1
4706 gcc_cv_as_compress_debug=1
4707 gcc_cv_as_compress_debug_option="--compress-debug-sections"
4708 gcc_cv_as_no_compress_debug_option="--nocompress-debug-sections"
4710 gcc_cv_as_compress_debug=0
4711 # FIXME: Future gas versions will support ELF gABI style via
4712 # --compress-debug-sections[=type].
4714 AC_DEFINE_UNQUOTED(HAVE_AS_COMPRESS_DEBUG, $gcc_cv_as_compress_debug,
4715 [Define to the level of your assembler's compressed debug section support.])
4716 AC_DEFINE_UNQUOTED(AS_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_compress_debug_option",
4717 [Define to the assembler option to enable compressed debug sections.])
4718 AC_DEFINE_UNQUOTED(AS_NO_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_no_compress_debug_option",
4719 [Define to the assembler option to disable compressed debug sections.])
4721 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
4724 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
4725 [Define if your assembler supports .lcomm with an alignment field.])])
4727 if test x$with_sysroot = x && test x$host = x$target \
4728 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4729 && test "$prefix" != "NONE"; then
4730 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4731 [Define to PREFIX/include if cpp should also search that directory.])
4734 # Determine the version of glibc, if any, used on the target.
4735 AC_MSG_CHECKING([for target glibc version])
4736 AC_ARG_WITH([glibc-version],
4737 [AS_HELP_STRING([--with-glibc-version=M.N],
4738 [assume GCC used with glibc version M.N or later])], [
4739 if [echo "$with_glibc_version" | grep '^[0-9][0-9]*\.[0-9][0-9]*$']; then
4740 glibc_version_major=`echo "$with_glibc_version" | sed -e 's/\..*//'`
4741 glibc_version_minor=`echo "$with_glibc_version" | sed -e 's/.*\.//'`
4743 AC_MSG_ERROR([option --with-glibc-version requires a version number M.N])
4745 glibc_version_major=0
4746 glibc_version_minor=0
4747 [if test -f $target_header_dir/features.h \
4748 && glibc_version_major_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+[0-9]' $target_header_dir/features.h` \
4749 && glibc_version_minor_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+[0-9]' $target_header_dir/features.h`; then
4750 glibc_version_major=`echo "$glibc_version_major_define" | sed -e 's/.*__GLIBC__[ ]*//'`
4751 glibc_version_minor=`echo "$glibc_version_minor_define" | sed -e 's/.*__GLIBC_MINOR__[ ]*//'`
4753 AC_MSG_RESULT([$glibc_version_major.$glibc_version_minor])
4754 AC_DEFINE_UNQUOTED([TARGET_GLIBC_MAJOR], [$glibc_version_major],
4755 [GNU C Library major version number used on the target, or 0.])
4756 AC_DEFINE_UNQUOTED([TARGET_GLIBC_MINOR], [$glibc_version_minor],
4757 [GNU C Library minor version number used on the target, or 0.])
4759 AC_ARG_ENABLE(gnu-unique-object,
4760 [AS_HELP_STRING([--enable-gnu-unique-object],
4761 [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
4762 [case $enable_gnu_unique_object in
4764 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
4765 Valid choices are 'yes' and 'no'.]) ;;
4767 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
4769 [.type foo, '$target_type_format_char'gnu_unique_object],,
4770 # We need to unquote above to to use the definition from config.gcc.
4771 # Also check for ld.so support, i.e. glibc 2.11 or higher.
4772 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [11], [enable_gnu_unique_object=yes], )]
4774 if test x$enable_gnu_unique_object = xyes; then
4775 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
4776 [Define if your assembler supports @gnu_unique_object.])
4779 AC_CACHE_CHECK([assembler for tolerance to line number 0],
4780 [gcc_cv_as_line_zero],
4781 [gcc_cv_as_line_zero=no
4782 if test $in_tree_gas = yes; then
4783 gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
4784 elif test "x$gcc_cv_as" != x; then
4785 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
4786 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
4787 test "x`cat conftest.out`" = x
4789 gcc_cv_as_line_zero=yes
4791 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
4792 cat conftest.s >&AS_MESSAGE_LOG_FD
4793 echo "configure: error output was" >&AS_MESSAGE_LOG_FD
4794 cat conftest.out >&AS_MESSAGE_LOG_FD
4796 rm -f conftest.o conftest.s conftest.out
4798 if test "x$gcc_cv_as_line_zero" = xyes; then
4799 AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
4800 [Define if the assembler won't complain about a line such as # 0 "" 2.])
4803 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
4804 gcc_cv_ld_eh_frame_hdr=no
4805 if test $in_tree_ld = yes ; then
4806 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 \
4807 && test $in_tree_ld_is_elf = yes; then
4808 gcc_cv_ld_eh_frame_hdr=yes
4810 elif test x$gcc_cv_ld != x; then
4811 if echo "$ld_ver" | grep GNU > /dev/null; then
4812 # Check if linker supports --eh-frame-hdr option
4813 if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
4814 gcc_cv_ld_eh_frame_hdr=yes
4819 # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
4820 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
4821 gcc_cv_ld_eh_frame_hdr=yes
4827 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
4828 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
4829 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
4830 [Define if your linker supports .eh_frame_hdr.])
4832 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
4834 AC_MSG_CHECKING(linker CIEv3 in .eh_frame support)
4835 gcc_cv_ld_eh_frame_ciev3=no
4836 if test $in_tree_ld = yes ; then
4837 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 \
4838 && test $in_tree_ld_is_elf = yes; then
4839 gcc_cv_ld_eh_frame_ciev3=yes
4841 elif test x$gcc_cv_ld != x; then
4842 if echo "$ld_ver" | grep GNU > /dev/null; then
4843 gcc_cv_ld_eh_frame_ciev3=yes
4844 if test 0"$ld_date" -lt 20040513; then
4845 if test -n "$ld_date"; then
4846 # If there was date string, but was earlier than 2004-05-13, fail
4847 gcc_cv_ld_eh_frame_ciev3=no
4848 elif test "$ld_vers_major" -lt 2; then
4849 gcc_cv_ld_eh_frame_ciev3=no
4850 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
4851 gcc_cv_ld_eh_frame_ciev3=no
4857 # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1.
4858 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then
4859 gcc_cv_ld_eh_frame_ciev3=yes
4865 AC_DEFINE_UNQUOTED(HAVE_LD_EH_FRAME_CIEV3,
4866 [`if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi`],
4867 [Define 0/1 if your linker supports CIE v3 in .eh_frame.])
4868 AC_MSG_RESULT($gcc_cv_ld_eh_frame_ciev3)
4870 AC_MSG_CHECKING(linker position independent executable support)
4872 if test $in_tree_ld = yes ; then
4874 # Full PIE support on Solaris was only introduced in gld 2.26.
4875 *-*-solaris2*) gcc_gld_pie_min_version=26 ;;
4876 *) gcc_gld_pie_min_version=15 ;;
4878 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge "$gcc_gld_pie_min_version" -o "$gcc_cv_gld_major_version" -gt 2 \
4879 && test $in_tree_ld_is_elf = yes; then
4882 elif test x$gcc_cv_ld != x; then
4883 # Check if linker supports -pie option
4884 if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
4888 if echo "$ld_ver" | grep GNU > /dev/null \
4889 && test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 26; then
4896 *-*-solaris2.1[[1-9]]*)
4897 # Solaris 11.x and Solaris 12 added PIE support.
4898 if $gcc_cv_ld -z help 2>&1 | grep -- type.*pie > /dev/null; then
4905 if test x"$gcc_cv_ld_pie" = xyes; then
4906 AC_DEFINE(HAVE_LD_PIE, 1,
4907 [Define if your linker supports PIE option.])
4909 AC_MSG_RESULT($gcc_cv_ld_pie)
4911 AC_MSG_CHECKING(linker PIE support with copy reloc)
4912 gcc_cv_ld_pie_copyreloc=no
4913 if test $gcc_cv_ld_pie = yes ; then
4914 if test $in_tree_ld = yes ; then
4915 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 25 -o "$gcc_cv_gld_major_version" -gt 2; then
4916 gcc_cv_ld_pie_copyreloc=yes
4918 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4919 # Check if linker supports -pie option with copy reloc
4921 i?86-*-linux* | x86_64-*-linux*)
4922 cat > conftest1.s <<EOF
4925 .type a_glob, @object
4930 cat > conftest2.s <<EOF
4933 .type main, @function
4935 movl %eax, a_glob(%rip)
4938 .section .data.rel,"aw",@progbits
4943 if $gcc_cv_as --64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4944 && $gcc_cv_ld -shared -melf_x86_64 -o conftest1.so conftest1.o > /dev/null 2>&1 \
4945 && $gcc_cv_as --64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4946 && $gcc_cv_ld -pie -melf_x86_64 -o conftest conftest2.o conftest1.so > /dev/null 2>&1; then
4947 gcc_cv_ld_pie_copyreloc=yes
4949 rm -f conftest conftest1.so conftest1.o conftest2.o conftest1.s conftest2.s
4954 AC_DEFINE_UNQUOTED(HAVE_LD_PIE_COPYRELOC,
4955 [`if test x"$gcc_cv_ld_pie_copyreloc" = xyes; then echo 1; else echo 0; fi`],
4956 [Define 0/1 if your linker supports -pie option with copy reloc.])
4957 AC_MSG_RESULT($gcc_cv_ld_pie_copyreloc)
4959 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
4960 gcc_cv_ld_eh_gc_sections=no
4961 if test $in_tree_ld = yes ; then
4962 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 \
4963 && test $in_tree_ld_is_elf = yes; then
4964 gcc_cv_ld_eh_gc_sections=yes
4966 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
4967 cat > conftest.s <<EOF
4970 .type _start, @function
4973 .size _start, .-_start
4974 .section .text.foo,"ax",@progbits
4975 .type foo, @function
4979 .section .gcc_except_table.foo,"a",@progbits
4982 .section .eh_frame,"a",@progbits
4985 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4986 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4987 | grep "gc-sections option ignored" > /dev/null; then
4988 gcc_cv_ld_eh_gc_sections=no
4989 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4990 | grep gcc_except_table > /dev/null; then
4991 gcc_cv_ld_eh_gc_sections=yes
4992 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
4993 if test x$gcc_cv_as_comdat_group != xyes; then
4994 gcc_cv_ld_eh_gc_sections=no
4995 cat > conftest.s <<EOF
4998 .type _start, @function
5001 .size _start, .-_start
5002 .section .gnu.linkonce.t.foo,"ax",@progbits
5003 .type foo, @function
5007 .section .gcc_except_table.foo,"a",@progbits
5010 .section .eh_frame,"a",@progbits
5013 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
5014 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
5015 | grep "gc-sections option ignored" > /dev/null; then
5016 gcc_cv_ld_eh_gc_sections=no
5017 elif $gcc_cv_objdump -h conftest 2> /dev/null \
5018 | grep gcc_except_table > /dev/null; then
5019 gcc_cv_ld_eh_gc_sections=yes
5025 rm -f conftest.s conftest.o conftest
5029 # ??? This apparently exposes a binutils bug with PC-relative relocations.
5030 gcc_cv_ld_eh_gc_sections=no
5033 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
5034 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
5035 [Define if your linker supports garbage collection of
5036 sections in presence of EH frames.])
5038 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
5040 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
5041 gcc_cv_ld_eh_gc_sections_bug=no
5042 if test $in_tree_ld = yes ; then
5043 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 \
5044 && test $in_tree_ld_is_elf = yes; then
5045 gcc_cv_ld_eh_gc_sections_bug=yes
5047 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
5048 gcc_cv_ld_eh_gc_sections_bug=yes
5049 cat > conftest.s <<EOF
5052 .type _start, @function
5055 .size _start, .-_start
5056 .section .text.startup.foo,"ax",@progbits
5057 .type foo, @function
5061 .section .gcc_except_table.foo,"a",@progbits
5064 .section .eh_frame,"a",@progbits
5067 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
5068 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
5069 | grep "gc-sections option ignored" > /dev/null; then
5071 elif $gcc_cv_objdump -h conftest 2> /dev/null \
5072 | grep gcc_except_table > /dev/null; then
5073 gcc_cv_ld_eh_gc_sections_bug=no
5076 rm -f conftest.s conftest.o conftest
5078 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
5079 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
5080 [Define if your linker has buggy garbage collection of
5081 sections support when .text.startup.foo like sections are used.])
5083 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
5085 AC_MSG_CHECKING(linker for compressed debug sections)
5086 # gold/gld support compressed debug sections since binutils 2.19/2.21
5087 if test $in_tree_ld = yes ; then
5088 gcc_cv_ld_compress_debug=0
5089 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 \
5090 && test $in_tree_ld_is_elf = yes && test $ld_is_gold = yes; then
5091 gcc_cv_ld_compress_debug=2
5092 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
5093 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 \
5094 && test $in_tree_ld_is_elf = yes; then
5095 gcc_cv_ld_compress_debug=1
5097 elif echo "$ld_ver" | grep GNU > /dev/null; then
5098 gcc_cv_ld_compress_debug=1
5099 if test 0"$ld_date" -lt 20050308; then
5100 if test -n "$ld_date"; then
5101 # If there was date string, but was earlier than 2005-03-08, fail
5102 gcc_cv_ld_compress_debug=0
5103 elif test "$ld_vers_major" -lt 2; then
5104 gcc_cv_ld_compress_debug=0
5105 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 21; then
5106 gcc_cv_ld_compress_debug=0
5109 if test $ld_is_gold = yes; then
5110 gcc_cv_ld_compress_debug=2
5111 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
5117 # Introduced in Solaris 11.2.
5118 if $gcc_cv_ld --help 2>&1 | grep -- '-z compress-sections' > /dev/null; then
5119 gcc_cv_ld_compress_debug=3
5120 gcc_cv_ld_compress_debug_option="-z compress-sections"
5122 gcc_cv_ld_compress_debug=0
5126 # Assume linkers other than GNU ld don't support compessed debug
5128 gcc_cv_ld_compress_debug=0
5133 AC_DEFINE_UNQUOTED(HAVE_LD_COMPRESS_DEBUG, $gcc_cv_ld_compress_debug,
5134 [Define to the level of your linker's compressed debug section support.])
5135 AC_DEFINE_UNQUOTED(LD_COMPRESS_DEBUG_OPTION, "$gcc_cv_ld_compress_debug_option",
5136 [Define to the linker option to enable compressed debug sections.])
5137 AC_MSG_RESULT($gcc_cv_ld_compress_debug)
5143 AC_CACHE_CHECK(linker --as-needed support,
5144 gcc_cv_ld_as_needed,
5145 [gcc_cv_ld_as_needed=no
5146 gcc_cv_ld_as_needed_option='--as-needed'
5147 gcc_cv_ld_no_as_needed_option='--no-as-needed'
5148 if test $in_tree_ld = yes ; then
5149 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 16 -o "$gcc_cv_gld_major_version" -gt 2 \
5150 && test $in_tree_ld_is_elf = yes; then
5151 gcc_cv_ld_as_needed=yes
5153 elif test x$gcc_cv_ld != x; then
5154 # Check if linker supports --as-needed and --no-as-needed options
5155 if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
5156 gcc_cv_ld_as_needed=yes
5159 # Solaris 2 ld always supports -z ignore/-z record.
5161 gcc_cv_ld_as_needed=yes
5162 gcc_cv_ld_as_needed_option="-z ignore"
5163 gcc_cv_ld_no_as_needed_option="-z record"
5168 # --as-needed/-z ignore can only be used if libgcc_s.so.1 uses
5169 # dl_iterate_phdr, i.e. since Solaris 11.
5171 *-*-solaris2.1[[1-9]]*)
5173 i?86-*-* | x86_64-*-*)
5174 if echo "$ld_ver" | grep GNU > /dev/null; then
5175 # Doesn't work with gld on Solaris/x86 due to PR ld/12320.
5176 gcc_cv_ld_as_needed=no
5182 gcc_cv_ld_as_needed=no
5186 if test x"$gcc_cv_ld_as_needed" = xyes; then
5187 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
5188 [Define if your linker supports --as-needed/--no-as-needed or equivalent options.])
5189 AC_DEFINE_UNQUOTED(LD_AS_NEEDED_OPTION, "$gcc_cv_ld_as_needed_option",
5190 [Define to the linker option to ignore unused dependencies.])
5191 AC_DEFINE_UNQUOTED(LD_NO_AS_NEEDED_OPTION, "$gcc_cv_ld_no_as_needed_option",
5192 [Define to the linker option to keep unused dependencies.])
5195 AC_MSG_CHECKING(linker mapfile support for clearing hardware capabilities)
5196 saved_LDFLAGS="$LDFLAGS"
5197 for clearcap_map in sol2-clearcapv2.map sol2-clearcap.map; do
5198 LDFLAGS="$saved_LDFLAGS -Wl,-M,${srcdir}/config/$clearcap_map"
5199 AC_LINK_IFELSE([int main(void) {return 0;}],
5200 [gcc_cv_ld_clearcap=yes; break], [gcc_cv_ld_clearcap=no])
5202 LDFLAGS="$saved_LDFLAGS"
5203 if test "x$gcc_cv_ld_clearcap" = xyes; then
5204 AC_DEFINE([HAVE_LD_CLEARCAP], 1,
5205 [Define if the linker supports clearing hardware capabilities via mapfile.])
5206 AC_CONFIG_LINKS([clearcap.map:${srcdir}/config/$clearcap_map])
5208 AC_MSG_RESULT($gcc_cv_ld_clearcap)
5210 case "$target:$tm_file" in
5211 powerpc64-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
5214 emul_name="-melf64lppc"
5217 emul_name="-melf64ppc"
5220 emul_name="-melf64ppc_fbsd"
5223 AC_CACHE_CHECK(linker support for omitting dot symbols,
5224 gcc_cv_ld_no_dot_syms,
5225 [gcc_cv_ld_no_dot_syms=no
5226 if test x"$ld_is_gold" = xyes; then
5227 gcc_cv_ld_no_dot_syms=yes
5228 elif test $in_tree_ld = yes ; then
5229 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
5230 gcc_cv_ld_no_dot_syms=yes
5232 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
5233 cat > conftest1.s <<EOF
5237 cat > conftest2.s <<EOF
5238 .section ".opd","aw"
5243 .quad .LEfoo,.TOC.@tocbase,0
5249 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
5250 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
5251 && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
5252 gcc_cv_ld_no_dot_syms=yes
5254 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
5257 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
5258 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
5259 [Define if your PowerPC64 linker only needs function descriptor syms.])
5262 AC_CACHE_CHECK(linker large toc support,
5263 gcc_cv_ld_large_toc,
5264 [gcc_cv_ld_large_toc=no
5265 if test x"$ld_is_gold" = xyes; then
5266 gcc_cv_ld_large_toc=yes
5267 elif test $in_tree_ld = yes ; then
5268 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
5269 gcc_cv_ld_large_toc=yes
5271 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
5272 cat > conftest.s <<EOF
5273 .section ".tbss","awT",@nobits
5279 addis 9,13,ie0@got@tprel@ha
5280 ld 9,ie0@got@tprel@l(9)
5282 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
5283 && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
5284 gcc_cv_ld_large_toc=yes
5286 rm -f conftest conftest.o conftest.s
5289 if test x"$gcc_cv_ld_large_toc" = xyes; then
5290 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
5291 [Define if your PowerPC64 linker supports a large TOC.])
5294 AC_CACHE_CHECK(linker toc pointer alignment,
5295 gcc_cv_ld_toc_align,
5296 [if test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_nm != x; then
5297 cat > conftest.s <<EOF
5302 .section .data.rel.ro,"aw",@progbits
5307 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
5308 && $gcc_cv_ld $emul_name -z norelro -o conftest conftest.o > /dev/null 2>&1; then
5309 gcc_cv_ld_toc_align=`$gcc_cv_nm conftest | ${AWK} '/\.TOC\./ { match ($0, "0[[[:xdigit:]]]*", a); print strtonum ("0x" substr(a[[0]], length(a[[0]])-3)) }'`
5311 rm -f conftest conftest.o conftest.s
5314 if test -n "$gcc_cv_ld_toc_align" && test $gcc_cv_ld_toc_align -gt 8; then
5315 AC_DEFINE_UNQUOTED(POWERPC64_TOC_POINTER_ALIGNMENT, $gcc_cv_ld_toc_align,
5316 [Define to .TOC. alignment forced by your linker.])
5323 AC_CACHE_CHECK(linker large toc support,
5324 gcc_cv_ld_large_toc,
5325 [gcc_cv_ld_large_toc=no
5326 if test x$gcc_cv_as != x ; then
5327 cat > conftest.s <<EOF
5337 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1; then
5338 gcc_cv_ld_large_toc=yes
5340 rm -f conftest conftest.o conftest.s
5343 if test x"$gcc_cv_ld_large_toc" = xyes; then
5344 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
5345 [Define if your PowerPC64 linker supports a large TOC.])
5350 AC_CACHE_CHECK(linker --build-id support,
5352 [gcc_cv_ld_buildid=no
5353 if test $in_tree_ld = yes ; then
5354 if test "$gcc_cv_gld_major_version" -eq 2 -a \
5355 "$gcc_cv_gld_minor_version" -ge 18 -o \
5356 "$gcc_cv_gld_major_version" -gt 2 \
5357 && test $in_tree_ld_is_elf = yes; then
5358 gcc_cv_ld_buildid=yes
5360 elif test x$gcc_cv_ld != x; then
5361 if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
5362 gcc_cv_ld_buildid=yes
5365 if test x"$gcc_cv_ld_buildid" = xyes; then
5366 AC_DEFINE(HAVE_LD_BUILDID, 1,
5367 [Define if your linker supports --build-id.])
5370 AC_ARG_ENABLE(linker-build-id,
5371 [AS_HELP_STRING([--enable-linker-build-id],
5372 [compiler will always pass --build-id to linker])],
5374 enable_linker_build_id=no)
5376 if test x"$enable_linker_build_id" = xyes; then
5377 if test x"$gcc_cv_ld_buildid" = xyes; then
5378 AC_DEFINE(ENABLE_LD_BUILDID, 1,
5379 [Define if gcc should always pass --build-id to linker.])
5381 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
5385 # In binutils 2.21, GNU ld gained support for new emulations fully
5386 # supporting the Solaris 2 ABI. Detect their presence in the linker used.
5387 AC_CACHE_CHECK(linker *_sol2 emulation support,
5388 gcc_cv_ld_sol2_emulation,
5389 [gcc_cv_ld_sol2_emulation=no
5390 if test $in_tree_ld = yes ; then
5391 if test "$gcc_cv_gld_major_version" -eq 2 -a \
5392 "$gcc_cv_gld_minor_version" -ge 21 -o \
5393 "$gcc_cv_gld_major_version" -gt 2 \
5394 && test $in_tree_ld_is_elf = yes; then
5395 gcc_cv_ld_sol2_emulation=yes
5397 elif test x$gcc_cv_ld != x; then
5398 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
5399 grep _sol2 > /dev/null; then
5400 gcc_cv_ld_sol2_emulation=yes
5403 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
5404 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
5405 [Define if your linker supports the *_sol2 emulations.])
5408 AC_CACHE_CHECK(linker --sysroot support,
5410 [gcc_cv_ld_sysroot=no
5411 if test $in_tree_ld = yes ; then
5412 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
5413 gcc_cv_ld_sysroot=yes
5415 elif test x$gcc_cv_ld != x; then
5416 if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
5417 gcc_cv_ld_sysroot=yes
5420 if test x"$gcc_cv_ld_sysroot" = xyes; then
5421 AC_DEFINE(HAVE_LD_SYSROOT, 1,
5422 [Define if your linker supports --sysroot.])
5427 # Check for system-provided CRTs on Solaris 11.x and Solaris 12.
5428 AC_CACHE_CHECK([system-provided CRTs on Solaris],
5429 gcc_cv_solaris_crts,
5430 [gcc_cv_solaris_crts=no
5431 if test x$host != x$target; then
5432 if test "x$with_sysroot" = xyes; then
5433 target_sysroot="${test_exec_prefix}/${target_noncanonical}/sys-root"
5435 target_sysroot="${with_sysroot}"
5438 target_libdir="$target_sysroot/usr/lib"
5439 # At the time they were added, gcrt1.o became a symlink for backwards
5440 # compatibility on x86, while crt1.o was added on sparc, so check for that.
5442 i?86-*-solaris2* | x86_64-*-solaris2*)
5443 if test -h "$target_libdir/gcrt1.o"; then gcc_cv_solaris_crts=yes; fi
5446 if test -f "$target_libdir/crt1.o"; then gcc_cv_solaris_crts=yes; fi
5451 if test x$gcc_cv_solaris_crts = xyes; then
5452 AC_DEFINE(HAVE_SOLARIS_CRTS, 1,
5453 [Define if the system-provided CRTs are present on Solaris.])
5456 # Test for stack protector support in target C library.
5457 AC_CACHE_CHECK(__stack_chk_fail in target C library,
5458 gcc_cv_libc_provides_ssp,
5459 [gcc_cv_libc_provides_ssp=no
5462 # All versions of musl provide stack protector
5463 gcc_cv_libc_provides_ssp=yes;;
5464 *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
5465 # glibc 2.4 and later provides __stack_chk_fail and
5466 # either __stack_chk_guard, or TLS access to stack guard canary.
5467 GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_libc_provides_ssp=yes], [
5468 [if test -f $target_header_dir/features.h \
5469 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \
5470 $target_header_dir/features.h > /dev/null; then
5471 if $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \
5472 $target_header_dir/features.h > /dev/null && \
5473 test -f $target_header_dir/bits/uClibc_config.h && \
5474 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \
5475 $target_header_dir/bits/uClibc_config.h > /dev/null; then
5476 gcc_cv_libc_provides_ssp=yes
5478 # all versions of Bionic support stack protector
5479 elif test -f $target_header_dir/sys/cdefs.h \
5480 && $EGREP '^[ ]*#[ ]*define[ ]+__BIONIC__[ ]+1' \
5481 $target_header_dir/sys/cdefs.h > /dev/null; then
5482 gcc_cv_libc_provides_ssp=yes
5486 # Avoid complicated tests (see
5487 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
5488 # simply assert that glibc does provide this, which is true for all
5489 # realistically usable GNU/Hurd configurations.
5490 # All supported versions of musl provide it as well
5491 gcc_cv_libc_provides_ssp=yes;;
5492 *-*-darwin* | *-*-freebsd* | *-*-netbsd*)
5493 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
5494 [echo "no __stack_chk_fail on this target"])
5496 *) gcc_cv_libc_provides_ssp=no ;;
5499 if test x$gcc_cv_libc_provides_ssp = xyes; then
5500 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
5501 [Define if your target C library provides stack protector support])
5504 # Check whether --enable-default-ssp was given.
5505 AC_ARG_ENABLE(default-ssp,
5506 [AS_HELP_STRING([--enable-default-ssp],
5507 [enable Stack Smashing Protection as default])],[
5508 if test x$gcc_cv_libc_provides_ssp = xyes; then
5510 ia64*-*-*) enable_default_ssp=no ;;
5511 *) enable_default_ssp=$enableval ;;
5514 enable_default_ssp=no
5516 enable_default_ssp=no)
5517 if test x$enable_default_ssp = xyes ; then
5518 AC_DEFINE(ENABLE_DEFAULT_SSP, 1,
5519 [Define if your target supports default stack protector and it is enabled.])
5521 AC_SUBST([enable_default_ssp])
5523 # Test for <sys/sdt.h> on the target.
5524 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
5525 AC_MSG_CHECKING(sys/sdt.h in the target C library)
5527 if test -f $target_header_dir/sys/sdt.h; then
5529 AC_DEFINE(HAVE_SYS_SDT_H, 1,
5530 [Define if your target C library provides sys/sdt.h])
5532 AC_MSG_RESULT($have_sys_sdt_h)
5534 # Check if TFmode long double should be used by default or not.
5535 # Some glibc targets used DFmode long double, but with glibc 2.4
5536 # and later they can use TFmode.
5538 powerpc*-*-linux* | \
5542 AC_ARG_WITH(long-double-128,
5543 [AS_HELP_STRING([--with-long-double-128],
5544 [use 128-bit long double by default])],
5545 gcc_cv_target_ldbl128="$with_long_double_128",
5546 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_target_ldbl128=yes], [
5547 [gcc_cv_target_ldbl128=no
5548 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \
5549 $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
5550 && gcc_cv_target_ldbl128=yes
5554 if test x$gcc_cv_target_ldbl128 = xyes; then
5555 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
5556 [Define if TFmode long double should be the default])
5559 # Check if the target LIBC supports exporting the AT_PLATFORM and AT_HWCAP
5560 # values in the TCB. Currently, only GLIBC 2.23 and later support this.
5561 gcc_cv_libc_provides_hwcap_in_tcb=no
5564 GCC_GLIBC_VERSION_GTE_IFELSE([2], [23], [gcc_cv_libc_provides_hwcap_in_tcb=yes], )
5567 if test x$gcc_cv_libc_provides_hwcap_in_tcb = xyes; then
5568 AC_DEFINE(TARGET_LIBC_PROVIDES_HWCAP_IN_TCB, 1,
5569 [Define if your target C Library provides the AT_HWCAP value in the TCB])
5572 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
5573 gcc_cv_target_dl_iterate_phdr=unknown
5575 # Restrict to Solaris 11+. While most of the Solaris 11 linker changes
5576 # were backported to Solaris 10 Update 10, dl_iterate_phdr only lives in
5577 # libdl there, both complicating its use and breaking compatibility
5578 # between Solaris 10 updates.
5579 *-*-solaris2.1[[1-9]]*)
5580 # <link.h> needs both a dl_iterate_phdr declaration and support for
5581 # compilation with largefile support.
5582 if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
5583 && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
5584 gcc_cv_target_dl_iterate_phdr=yes
5586 gcc_cv_target_dl_iterate_phdr=no
5589 *-*-dragonfly* | *-*-freebsd*)
5590 if grep dl_iterate_phdr $target_header_dir/sys/link_elf.h > /dev/null 2>&1; then
5591 gcc_cv_target_dl_iterate_phdr=yes
5593 gcc_cv_target_dl_iterate_phdr=no
5597 gcc_cv_target_dl_iterate_phdr=yes
5600 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
5601 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
5602 AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
5603 [Define if your target C library provides the `dl_iterate_phdr' function.])
5605 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
5607 # We no longer support different GC mechanisms. Emit an error if
5608 # the user configures with --with-gc.
5610 [AS_HELP_STRING([--with-gc={page,zone}],
5611 [this option is not supported anymore. It used to choose
5612 the garbage collection mechanism to use with the compiler])],
5613 [AC_MSG_ERROR([Configure option --with-gc is only supported up to GCC 4.7.x])],
5616 # Libraries to use on the host. This will normally be set by the top
5617 # level Makefile. Here we simply capture the value for our Makefile.
5618 if test -z "${HOST_LIBS+set}"; then
5623 # Use the system's zlib library.
5626 dnl Very limited version of automake's enable-maintainer-mode
5628 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
5629 dnl maintainer-mode is disabled by default
5630 AC_ARG_ENABLE(maintainer-mode,
5631 [AS_HELP_STRING([--enable-maintainer-mode],
5632 [enable make rules and dependencies not useful
5633 (and sometimes confusing) to the casual installer])],
5634 maintainer_mode=$enableval,
5637 AC_MSG_RESULT($maintainer_mode)
5639 if test "$maintainer_mode" = "yes"; then
5646 dnl Whether to prevent multiple front-ends from linking at the same time
5648 AC_MSG_CHECKING([whether to avoid linking multiple front-ends at once])
5649 AC_ARG_ENABLE(link-mutex,
5650 [AS_HELP_STRING([--enable-link-mutex],
5651 [avoid linking multiple front-ends at once to avoid thrashing
5652 on the build machine])],
5653 do_link_mutex=$enableval,
5655 AC_MSG_RESULT($do_link_mutex)
5657 if test "$do_link_mutex" = "yes"; then
5662 AC_SUBST(DO_LINK_MUTEX)
5668 # Make empty files to contain the specs and options for each language.
5669 # Then add #include lines to for a compiler that has specs and/or options.
5675 # These (without "all_") are set in each config-lang.in.
5676 # `language' must be a single word so is spelled singularly.
5679 all_outputs='Makefile'
5680 # List of language makefile fragments.
5682 # Additional files for gengtype
5683 all_gtfiles="$target_gtfiles"
5685 # These are the languages that are set in --enable-languages,
5686 # and are available in the GCC tree.
5687 all_selected_languages=
5689 # Add the language fragments.
5690 # Languages are added via two mechanisms. Some information must be
5691 # recorded in makefile variables, these are defined in config-lang.in.
5692 # We accumulate them and plug them into the main Makefile.
5693 # The other mechanism is a set of hooks for each of the main targets
5694 # like `clean', `install', etc.
5696 language_hooks="Make-hooks"
5698 for lang in ${srcdir}/*/config-lang.in
5701 test "$lang" = "${srcdir}/*/config-lang.in" && continue
5703 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
5704 if test "x$lang_alias" = x
5706 echo "$lang doesn't set \$language." 1>&2
5709 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
5710 subdirs="$subdirs $subdir"
5712 # $gcc_subdir is where the gcc integration files are to be found
5713 # for a language, both for internal compiler purposes (compiler
5714 # sources implementing front-end to GCC tree converters), and for
5715 # build infrastructure purposes (Make-lang.in, etc.)
5717 # This will be <subdir> (relative to $srcdir) if a line like
5718 # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
5719 # is found in <langdir>/config-lang.in, and will remain <langdir>
5722 # Except for the language alias (fetched above), the regular
5723 # "config-lang.in" contents are always retrieved from $gcc_subdir,
5724 # so a <langdir>/config-lang.in setting gcc_subdir typically sets
5725 # only this and the language alias.
5727 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang`
5728 if [ "$gcc_subdir" = "" ]; then
5729 gcc_subdir="$subdir"
5732 case ",$enable_languages," in
5734 all_selected_languages="$all_selected_languages $lang_alias"
5735 if test -f $srcdir/$gcc_subdir/lang-specs.h; then
5736 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
5748 . ${srcdir}/$gcc_subdir/config-lang.in
5749 if test "x$language" = x
5751 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
5756 case ",$enable_languages," in
5759 for i in $subdir_requires; do
5760 test -f "${srcdir}/$i/config-lang.in" && continue
5768 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
5769 if test -f $srcdir/$gcc_subdir/lang.opt; then
5770 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
5771 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
5773 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
5774 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
5776 all_languages="$all_languages $language"
5777 all_compilers="$all_compilers $compilers"
5778 all_outputs="$all_outputs $outputs"
5779 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
5780 case ",$enable_languages," in
5782 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
5784 AC_SUBST(enable_lto)
5791 for language in $all_selected_languages
5793 check_languages="$check_languages check-$language"
5796 # We link each language in with a set of hooks, reached indirectly via
5797 # lang.${target}. Only do so for selected languages.
5801 target_list="all.cross start.encap rest.encap tags \
5802 install-common install-man install-info install-pdf install-html dvi \
5803 pdf html uninstall info man srcextra srcman srcinfo \
5804 mostlyclean clean distclean maintainer-clean install-plugin"
5806 for t in $target_list
5809 for lang in $all_selected_languages
5813 echo "lang.$t: $x" >> Make-hooks
5817 # Option include files
5820 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
5821 option_includes="option-includes.mk"
5822 AC_SUBST_FILE(option_includes)
5830 echo "dir ." > .gdbinit
5831 echo "dir ${srcdir}" >> .gdbinit
5832 if test x$gdb_needs_out_file_path = xyes
5834 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
5836 if test "x$subdirs" != x; then
5839 echo "dir ${srcdir}/$s" >> .gdbinit
5842 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
5843 echo "python import sys; sys.path.append('${srcdir}'); import gdbhooks" >> .gdbinit
5845 # Put a breakpoint on __asan_report_error to help with debugging buffer
5848 *-fsanitize=address*)
5849 echo "source ${srcdir}/gdbasan.in" >> .gdbinit
5853 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
5854 AC_SUBST(gcc_tooldir)
5857 # Find a directory in which to install a shared libgcc.
5859 AC_ARG_ENABLE(version-specific-runtime-libs,
5860 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
5861 [specify that runtime libraries should be
5862 installed in a compiler-specific directory])])
5864 # Substitute configuration variables
5867 AC_SUBST(all_compilers)
5868 AC_SUBST(all_gtfiles)
5869 AC_SUBST(all_lang_makefrags)
5870 AC_SUBST(all_languages)
5871 AC_SUBST(all_selected_languages)
5872 AC_SUBST(build_exeext)
5873 AC_SUBST(build_install_headers_dir)
5874 AC_SUBST(build_xm_file_list)
5875 AC_SUBST(build_xm_include_list)
5876 AC_SUBST(build_xm_defines)
5877 AC_SUBST(build_file_translate)
5878 AC_SUBST(check_languages)
5879 AC_SUBST(cpp_install_dir)
5880 AC_SUBST(xmake_file)
5881 AC_SUBST(tmake_file)
5882 AC_SUBST(TM_ENDIAN_CONFIG)
5883 AC_SUBST(TM_MULTILIB_CONFIG)
5884 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
5885 AC_SUBST(extra_gcc_objs)
5886 AC_SUBST(user_headers_inc_next_pre)
5887 AC_SUBST(user_headers_inc_next_post)
5888 AC_SUBST(extra_headers_list)
5889 AC_SUBST(extra_objs)
5890 AC_SUBST(extra_programs)
5891 AC_SUBST(float_h_file)
5892 AC_SUBST(gcc_config_arguments)
5893 AC_SUBST(gcc_gxx_include_dir)
5894 AC_SUBST(gcc_gxx_include_dir_add_sysroot)
5895 AC_SUBST(host_exeext)
5896 AC_SUBST(host_xm_file_list)
5897 AC_SUBST(host_xm_include_list)
5898 AC_SUBST(host_xm_defines)
5899 AC_SUBST(out_host_hook_obj)
5901 AC_SUBST(lang_opt_files)
5902 AC_SUBST(lang_specs_files)
5903 AC_SUBST(lang_tree_files)
5904 AC_SUBST(local_prefix)
5906 AC_SUBST(objc_boehm_gc)
5908 AC_SUBST(out_object_file)
5909 AC_SUBST(common_out_file)
5910 AC_SUBST(common_out_object_file)
5911 AC_SUBST(tm_file_list)
5912 AC_SUBST(tm_include_list)
5913 AC_SUBST(tm_defines)
5914 AC_SUBST(tm_p_file_list)
5915 AC_SUBST(tm_p_include_list)
5916 AC_SUBST(xm_file_list)
5917 AC_SUBST(xm_include_list)
5918 AC_SUBST(xm_defines)
5919 AC_SUBST(use_gcc_stdint)
5920 AC_SUBST(c_target_objs)
5921 AC_SUBST(cxx_target_objs)
5922 AC_SUBST(fortran_target_objs)
5923 AC_SUBST(target_cpu_default)
5925 AC_SUBST_FILE(language_hooks)
5928 if test x${build} = x${host} ; then
5929 if test x${host} = x${target} ; then
5930 echo "Links are now set up to build a native compiler for ${target}." 1>&2
5932 echo "Links are now set up to build a cross-compiler" 1>&2
5933 echo " from ${host} to ${target}." 1>&2
5936 if test x${host} = x${target} ; then
5937 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
5938 echo " for ${target}." 1>&2
5940 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
5941 echo " from ${host} to ${target}." 1>&2
5945 AC_ARG_VAR(GMPLIBS,[How to link GMP])
5946 AC_ARG_VAR(GMPINC,[How to find GMP include files])
5948 AC_ARG_VAR(ISLLIBS,[How to link isl])
5949 AC_ARG_VAR(ISLINC,[How to find isl include files])
5950 if test "x${ISLLIBS}" != "x" ; then
5951 AC_DEFINE(HAVE_isl, 1, [Define if isl is in use.])
5954 # Check whether isl_options_set_schedule_serialize_sccs is available;
5955 # it's new in isl 0.15.
5956 if test "x${ISLLIBS}" != "x" ; then
5957 saved_CXXFLAGS="$CXXFLAGS"
5958 CXXFLAGS="$CXXFLAGS $ISLINC $GMPINC"
5960 LIBS="$LIBS $ISLLIBS $GMPLIBS"
5962 AC_MSG_CHECKING([Checking for isl_options_set_schedule_serialize_sccs])
5963 AC_TRY_LINK([#include <isl/schedule.h>],
5964 [isl_options_set_schedule_serialize_sccs (NULL, 0);],
5965 [ac_has_isl_options_set_schedule_serialize_sccs=yes],
5966 [ac_has_isl_options_set_schedule_serialize_sccs=no])
5967 AC_MSG_RESULT($ac_has_isl_options_set_schedule_serialize_sccs)
5970 CXXFLAGS="$saved_CXXFLAGS"
5972 if test x"$ac_has_isl_options_set_schedule_serialize_sccs" = x"yes"; then
5973 AC_DEFINE(HAVE_ISL_OPTIONS_SET_SCHEDULE_SERIALIZE_SCCS, 1,
5974 [Define if isl_options_set_schedule_serialize_sccs exists.])
5979 AC_SUBST(pluginlibs)
5980 AC_SUBST(enable_plugin)
5981 if test x"$enable_plugin" = x"yes"; then
5982 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
5986 # Enable --enable-host-shared
5987 AC_ARG_ENABLE(host-shared,
5988 [AS_HELP_STRING([--enable-host-shared],
5989 [build host code as shared libraries])],
5990 [PICFLAG=-fPIC], [PICFLAG=])
5991 AC_SUBST(enable_host_shared)
5995 AC_ARG_ENABLE(libquadmath-support,
5996 [AS_HELP_STRING([--disable-libquadmath-support],
5997 [disable libquadmath support for Fortran])],
5998 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
5999 ENABLE_LIBQUADMATH_SUPPORT=yes)
6000 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
6001 AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
6002 [Define to 1 to enable libquadmath support])
6006 # Specify what hash style to use by default.
6007 AC_ARG_WITH([linker-hash-style],
6008 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
6009 [specify the linker hash style])],
6010 [case x"$withval" in
6012 LINKER_HASH_STYLE=sysv
6015 LINKER_HASH_STYLE=gnu
6018 LINKER_HASH_STYLE=both
6021 AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
6024 [LINKER_HASH_STYLE=''])
6025 if test x"${LINKER_HASH_STYLE}" != x; then
6026 AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
6027 [The linker hash style])
6030 # Specify what should be the default of -fdiagnostics-color option.
6031 AC_ARG_WITH([diagnostics-color],
6032 [AC_HELP_STRING([--with-diagnostics-color={never,auto,auto-if-env,always}],
6033 [specify the default of -fdiagnostics-color option
6034 auto-if-env stands for -fdiagnostics-color=auto if
6035 GCC_COLOR environment variable is present and
6036 -fdiagnostics-color=never otherwise])],
6037 [case x"$withval" in
6039 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_NO
6042 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_AUTO
6045 DIAGNOSTICS_COLOR_DEFAULT=-1
6048 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_YES
6051 AC_MSG_ERROR([$withval is an invalid option to --with-diagnostics-color])
6054 [DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_AUTO])
6055 AC_DEFINE_UNQUOTED(DIAGNOSTICS_COLOR_DEFAULT, $DIAGNOSTICS_COLOR_DEFAULT,
6056 [The default for -fdiagnostics-color option])
6058 # Generate gcc-driver-name.h containing GCC_DRIVER_NAME for the benefit
6059 # of jit/jit-playback.c.
6060 cat > gcc-driver-name.h <<EOF
6061 #define GCC_DRIVER_NAME "${target_noncanonical}-gcc-${gcc_BASEVER}${exeext}"
6064 # Check whether --enable-default-pie was given.
6065 AC_ARG_ENABLE(default-pie,
6066 [AS_HELP_STRING([--enable-default-pie],
6067 [enable Position Independent Executable as default])],
6068 enable_default_pie=$enableval,
6069 enable_default_pie=no)
6070 if test x$enable_default_pie = xyes ; then
6071 AC_DEFINE(ENABLE_DEFAULT_PIE, 1,
6072 [Define if your target supports default PIE and it is enabled.])
6074 AC_SUBST([enable_default_pie])
6076 # Check if -fno-PIE works.
6077 AC_CACHE_CHECK([for -fno-PIE option],
6079 [saved_CXXFLAGS="$CXXFLAGS"
6080 CXXFLAGS="$CXXFLAGS -fno-PIE"
6081 AC_COMPILE_IFELSE([int main(void) {return 0;}],
6082 [gcc_cv_c_no_fpie=yes],
6083 [gcc_cv_c_no_fpie=no])
6084 CXXFLAGS="$saved_CXXFLAGS"])
6085 if test "$gcc_cv_c_no_fpie" = "yes"; then
6086 NO_PIE_CFLAGS="-fno-PIE"
6088 AC_SUBST([NO_PIE_CFLAGS])
6090 # Check if -no-pie works.
6091 AC_CACHE_CHECK([for -no-pie option],
6093 [saved_LDFLAGS="$LDFLAGS"
6094 LDFLAGS="$LDFLAGS -no-pie"
6095 AC_LINK_IFELSE([int main(void) {return 0;}],
6096 [gcc_cv_no_pie=yes],
6098 LDFLAGS="$saved_LDFLAGS"])
6099 if test "$gcc_cv_no_pie" = "yes"; then
6100 NO_PIE_FLAG="-no-pie"
6102 AC_SUBST([NO_PIE_FLAG])
6104 # Check linker supports '-z bndplt'
6105 ld_bndplt_support=no
6106 AC_MSG_CHECKING(linker -z bndplt option)
6107 if test x"$ld_is_gold" = xno; then
6108 if test $in_tree_ld = yes ; then
6109 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 25 -o "$gcc_cv_gld_major_version" -gt 2; then
6110 ld_bndplt_support=yes
6112 elif test x$gcc_cv_ld != x; then
6113 # Check if linker supports -a bndplt option
6114 if $gcc_cv_ld --help 2>/dev/null | grep -- '-z bndplt' > /dev/null; then
6115 ld_bndplt_support=yes
6119 if test x"$ld_bndplt_support" = xyes; then
6120 AC_DEFINE(HAVE_LD_BNDPLT_SUPPORT, 1,
6121 [Define if your linker supports -z bndplt])
6123 AC_MSG_RESULT($ld_bndplt_support)
6125 # Configure the subdirectories
6126 # AC_CONFIG_SUBDIRS($subdirs)
6128 # Create the Makefile
6129 # and configure language subdirectories
6130 AC_CONFIG_FILES($all_outputs)
6132 AC_CONFIG_COMMANDS([default],
6134 case ${CONFIG_HEADERS} in
6135 *auto-host.h:config.in*)
6138 # Make sure all the subdirs exist.
6139 for d in $subdirs doc build common c-family
6141 test -d $d || mkdir $d
6144 [subdirs='$subdirs'])