2 # Process this file with autoconf to generate a configuration script.
4 # Copyright (C) 1997-2015 Free Software Foundation, Inc.
6 #This file is part of GCC.
8 #GCC is free software; you can redistribute it and/or modify it under
9 #the terms of the GNU General Public License as published by the Free
10 #Software Foundation; either version 3, or (at your option) any later
13 #GCC is distributed in the hope that it will be useful, but WITHOUT
14 #ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 #FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 #You should have received a copy of the GNU General Public License
19 #along with GCC; see the file COPYING3. If not see
20 #<http://www.gnu.org/licenses/>.
22 # --------------------------------
23 # Initialization and sanity checks
24 # --------------------------------
28 AC_CONFIG_SRCDIR(tree.c)
29 AC_CONFIG_HEADER(auto-host.h:config.in)
31 gcc_version=`cat $srcdir/BASE-VER`
33 # Determine the host, build, and target systems
38 # Determine the noncanonical target name, for directory use.
39 ACX_NONCANONICAL_TARGET
41 # Used for constructing correct paths for offload compilers.
42 real_target_noncanonical=${target_noncanonical}
45 # Determine the target- and build-specific subdirectories
48 # Set program_transform_name
51 # Check for bogus environment variables.
52 # Test if LIBRARY_PATH contains the notation for the current directory
53 # since this would lead to problems installing/building glibc.
54 # LIBRARY_PATH contains the current directory if one of the following
56 # - one of the terminals (":" and ";") is the first or last sign
57 # - two terminals occur directly after each other
58 # - the path contains an element with a dot in it
59 AC_MSG_CHECKING(LIBRARY_PATH variable)
61 case ${LIBRARY_PATH} in
62 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
63 library_path_setting="contains current directory"
66 library_path_setting="ok"
70 AC_MSG_RESULT($library_path_setting)
71 if test "$library_path_setting" != "ok"; then
73 *** LIBRARY_PATH shouldn't contain the current directory when
74 *** building gcc. Please change the environment variable
75 *** and run configure again.])
78 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
79 # since this would lead to problems installing/building glibc.
80 # GCC_EXEC_PREFIX contains the current directory if one of the following
82 # - one of the terminals (":" and ";") is the first or last sign
83 # - two terminals occur directly after each other
84 # - the path contains an element with a dot in it
85 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
87 case ${GCC_EXEC_PREFIX} in
88 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
89 gcc_exec_prefix_setting="contains current directory"
92 gcc_exec_prefix_setting="ok"
96 AC_MSG_RESULT($gcc_exec_prefix_setting)
97 if test "$gcc_exec_prefix_setting" != "ok"; then
99 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
100 *** building gcc. Please change the environment variable
101 *** and run configure again.])
108 # Specify the local prefix
110 AC_ARG_WITH(local-prefix,
111 [AS_HELP_STRING([--with-local-prefix=DIR],
112 [specifies directory to put local include])],
113 [case "${withval}" in
114 yes) AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
116 *) local_prefix=$with_local_prefix ;;
119 # Default local prefix if it is empty
120 if test x$local_prefix = x; then
121 local_prefix=/usr/local
124 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 # Check whether compiler is affected by placement new aliasing bug (PR 29286).
420 # If the host compiler is affected by the bug, and we build with optimization
421 # enabled (which happens e.g. when cross-compiling), the pool allocator may
422 # get miscompiled. Use -fno-strict-aliasing to work around this problem.
423 # Since there is no reliable feature check for the presence of this bug,
424 # we simply use a GCC version number check. (This should never trigger for
425 # stages 2 or 3 of a native bootstrap.)
427 if test "$GCC" = yes; then
428 saved_CXXFLAGS="$CXXFLAGS"
430 # The following test compilation will succeed if and only if $CXX accepts
431 # -fno-strict-aliasing *and* is older than GCC 4.3.
432 CXXFLAGS="$CXXFLAGS -fno-strict-aliasing"
433 AC_MSG_CHECKING([whether $CXX is affected by placement new aliasing bug])
435 #if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
436 #error compiler not affected by placement new aliasing bug
439 [AC_MSG_RESULT([yes]); aliasing_flags='-fno-strict-aliasing'],
440 [AC_MSG_RESULT([no])])
442 CXXFLAGS="$saved_CXXFLAGS"
444 AC_SUBST(aliasing_flags)
448 # ---------------------
449 # Warnings and checking
450 # ---------------------
452 # Check $CC warning features (if it's GCC).
453 # We want to use -pedantic, but we don't want warnings about
457 # * C++11 narrowing conversions in { }
458 # So, we only use -pedantic if we can disable those warnings.
460 # In stage 1, disable -Wformat warnings from old GCCs about new % codes
461 AC_ARG_ENABLE(build-format-warnings,
462 AS_HELP_STRING([--disable-build-format-warnings],[don't use -Wformat while building GCC]),
463 [],[enable_build_format_warnings=yes])
464 AS_IF([test $enable_build_format_warnings = no],
465 [wf_opt=-Wno-format],[wf_opt=])
466 ACX_PROG_CXX_WARNING_OPTS(
467 m4_quote(m4_do([-W -Wall -Wno-narrowing -Wwrite-strings -Wcast-qual $wf_opt])), [loose_warn])
468 ACX_PROG_CC_WARNING_OPTS(
469 m4_quote(m4_do([-Wstrict-prototypes -Wmissing-prototypes])),
471 ACX_PROG_CXX_WARNING_OPTS(
472 m4_quote(m4_do([-Wmissing-format-attribute])), [strict_warn])
473 ACX_PROG_CXX_WARNING_OPTS(
474 m4_quote(m4_do([-Woverloaded-virtual])), [strict_warn])
475 ACX_PROG_CC_WARNING_OPTS(
476 m4_quote(m4_do([-Wold-style-definition -Wc++-compat])), [c_strict_warn])
477 ACX_PROG_CXX_WARNING_ALMOST_PEDANTIC(
478 m4_quote(m4_do([-Wno-long-long -Wno-variadic-macros ],
479 [-Wno-overlength-strings])), [strict_warn])
480 ACX_PROG_CXX_WARNINGS_ARE_ERRORS([manual], [strict_warn])
482 # The above macros do nothing if the compiler is not GCC. However, the
483 # Makefile has more goo to add other flags, so these variables are used
484 # to enable warnings only for GCC.
487 if test "x$GCC" = "xyes"; then
488 warn_cflags='$(GCC_WARN_CFLAGS)'
489 warn_cxxflags='$(GCC_WARN_CXXFLAGS)'
491 AC_SUBST(warn_cflags)
492 AC_SUBST(warn_cxxflags)
494 # Disable exceptions and RTTI if building with g++
495 ACX_PROG_CC_WARNING_OPTS(
496 m4_quote(m4_do([-fno-exceptions -fno-rtti -fasynchronous-unwind-tables])),
499 # Enable expensive internal checks
501 if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then
505 AC_ARG_ENABLE(checking,
506 [AS_HELP_STRING([[--enable-checking[=LIST]]],
507 [enable expensive run-time checks. With LIST,
508 enable only specific categories of checks.
509 Categories are: yes,no,all,none,release.
510 Flags are: assert,df,fold,gc,gcac,gimple,misc,
511 rtlflag,rtl,runtime,tree,valgrind,types])],
512 [ac_checking_flags="${enableval}"],[
513 # Determine the default checks.
514 if test x$is_release = x ; then
515 ac_checking_flags=yes
517 ac_checking_flags=release
519 IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
520 for check in release $ac_checking_flags
523 # these set all the flags to specific states
524 yes) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking= ;
525 ac_fold_checking= ; ac_gc_checking=1 ;
526 ac_gc_always_collect= ; ac_gimple_checking=1 ; ac_rtl_checking= ;
527 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
528 ac_tree_checking=1 ; ac_valgrind_checking= ;
529 ac_types_checking=1 ;;
530 no|none) ac_assert_checking= ; ac_checking= ; ac_df_checking= ;
531 ac_fold_checking= ; ac_gc_checking= ;
532 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
533 ac_rtlflag_checking= ; ac_runtime_checking= ;
534 ac_tree_checking= ; ac_valgrind_checking= ;
535 ac_types_checking= ;;
536 all) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking=1 ;
537 ac_fold_checking=1 ; ac_gc_checking=1 ;
538 ac_gc_always_collect=1 ; ac_gimple_checking=1 ; ac_rtl_checking=1 ;
539 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
540 ac_tree_checking=1 ; ac_valgrind_checking= ;
541 ac_types_checking=1 ;;
542 release) ac_assert_checking=1 ; ac_checking= ; ac_df_checking= ;
543 ac_fold_checking= ; ac_gc_checking= ;
544 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
545 ac_rtlflag_checking= ; ac_runtime_checking=1 ;
546 ac_tree_checking= ; ac_valgrind_checking= ;
547 ac_types_checking= ;;
548 # these enable particular checks
549 assert) ac_assert_checking=1 ;;
550 df) ac_df_checking=1 ;;
551 fold) ac_fold_checking=1 ;;
552 gc) ac_gc_checking=1 ;;
553 gcac) ac_gc_always_collect=1 ;;
554 gimple) ac_gimple_checking=1 ;;
555 misc) ac_checking=1 ;;
556 rtl) ac_rtl_checking=1 ;;
557 rtlflag) ac_rtlflag_checking=1 ;;
558 runtime) ac_runtime_checking=1 ;;
559 tree) ac_tree_checking=1 ;;
560 types) ac_types_checking=1 ;;
561 valgrind) ac_valgrind_checking=1 ;;
562 *) AC_MSG_ERROR(unknown check category $check) ;;
568 if test x$ac_checking != x ; then
569 AC_DEFINE(CHECKING_P, 1,
570 [Define to 1 if you want more run-time sanity checks. This one gets a grab
571 bag of miscellaneous but relatively cheap checks.])
572 nocommon_flag=-fno-common
574 AC_DEFINE(CHECKING_P, 0)
576 AC_SUBST(nocommon_flag)
577 if test x$ac_df_checking != x ; then
578 AC_DEFINE(ENABLE_DF_CHECKING, 1,
579 [Define if you want more run-time sanity checks for dataflow.])
581 if test x$ac_assert_checking != x ; then
582 AC_DEFINE(ENABLE_ASSERT_CHECKING, 1,
583 [Define if you want assertions enabled. This is a cheap check.])
585 if test x$ac_gimple_checking != x ; then
586 AC_DEFINE(ENABLE_GIMPLE_CHECKING, 1,
587 [Define if you want operations on GIMPLE (the basic data structure of
588 the high-level optimizers) to be checked for dynamic type safety at
589 runtime. This is moderately expensive.])
591 GCC_TARGET_TEMPLATE(ENABLE_RUNTIME_CHECKING)
592 if test x$ac_runtime_checking != x ; then
593 AC_DEFINE(ENABLE_RUNTIME_CHECKING, 1,
594 [Define if you want runtime assertions enabled. This is a cheap check.])
596 if test x$ac_tree_checking != x ; then
597 AC_DEFINE(ENABLE_TREE_CHECKING, 1,
598 [Define if you want all operations on trees (the basic data
599 structure of the front ends) to be checked for dynamic type safety
600 at runtime. This is moderately expensive.
604 if test x$ac_types_checking != x ; then
605 AC_DEFINE(ENABLE_TYPES_CHECKING, 1,
606 [Define if you want all gimple types to be verified after gimplifiation.
610 AC_SUBST(TREECHECKING)
611 if test x$ac_rtl_checking != x ; then
612 AC_DEFINE(ENABLE_RTL_CHECKING, 1,
613 [Define if you want all operations on RTL (the basic data structure
614 of the optimizer and back end) to be checked for dynamic type safety
615 at runtime. This is quite expensive.])
617 if test x$ac_rtlflag_checking != x ; then
618 AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
619 [Define if you want RTL flag accesses to be checked against the RTL
620 codes that are supported for each access macro. This is relatively
623 if test x$ac_gc_checking != x ; then
624 AC_DEFINE(ENABLE_GC_CHECKING, 1,
625 [Define if you want the garbage collector to do object poisoning and
626 other memory allocation checks. This is quite expensive.])
628 if test x$ac_gc_always_collect != x ; then
629 AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
630 [Define if you want the garbage collector to operate in maximally
631 paranoid mode, validating the entire heap and collecting garbage at
632 every opportunity. This is extremely expensive.])
634 if test x$ac_fold_checking != x ; then
635 AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
636 [Define if you want fold checked that it never destructs its argument.
637 This is quite expensive.])
639 valgrind_path_defines=
642 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
643 dnl # an if statement. This was the source of very frustrating bugs
644 dnl # in converting to autoconf 2.5x!
645 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
647 # It is certainly possible that there's valgrind but no valgrind.h.
648 # GCC relies on making annotations so we must have both.
649 AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
650 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
651 [[#include <valgrind/memcheck.h>
652 #ifndef VALGRIND_DISCARD
653 #error VALGRIND_DISCARD not defined
655 [gcc_cv_header_valgrind_memcheck_h=yes],
656 [gcc_cv_header_valgrind_memcheck_h=no])
657 AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
658 AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
659 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
660 [[#include <memcheck.h>
661 #ifndef VALGRIND_DISCARD
662 #error VALGRIND_DISCARD not defined
664 [gcc_cv_header_memcheck_h=yes],
665 [gcc_cv_header_memcheck_h=no])
666 AC_MSG_RESULT($gcc_cv_header_memcheck_h)
667 if test $gcc_cv_header_valgrind_memcheck_h = yes; then
668 AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
669 [Define if valgrind's valgrind/memcheck.h header is installed.])
671 if test $gcc_cv_header_memcheck_h = yes; then
672 AC_DEFINE(HAVE_MEMCHECK_H, 1,
673 [Define if valgrind's memcheck.h header is installed.])
676 if test x$ac_valgrind_checking != x ; then
677 AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
678 [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
679 if test "x$valgrind_path" = "x" \
680 || (test $have_valgrind_h = no \
681 && test $gcc_cv_header_memcheck_h = no \
682 && test $gcc_cv_header_valgrind_memcheck_h = no); then
683 AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
685 valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
686 valgrind_command="$valgrind_path -q"
687 AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
688 [Define if you want to run subprograms and generated programs
689 through valgrind (a memory checker). This is extremely expensive.])
691 AC_SUBST(valgrind_path_defines)
692 AC_SUBST(valgrind_command)
694 # Enable code coverage collection
695 AC_ARG_ENABLE(coverage,
696 [AS_HELP_STRING([[--enable-coverage[=LEVEL]]],
697 [enable compiler's code coverage collection.
698 Use to measure compiler performance and locate
699 unused parts of the compiler. With LEVEL, specify
700 optimization. Values are opt, noopt,
702 [case "${enableval}" in
704 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
707 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
710 # a.k.a. --disable-coverage
714 AC_MSG_ERROR(unknown coverage setting $enableval)
718 AC_SUBST(coverage_flags)
720 AC_ARG_ENABLE(gather-detailed-mem-stats,
721 [AS_HELP_STRING([--enable-gather-detailed-mem-stats],
722 [enable detailed memory allocation stats gathering])], [],
723 [enable_gather_detailed_mem_stats=no])
724 gather_stats=`if test $enable_gather_detailed_mem_stats != no; then echo 1; else echo 0; fi`
725 AC_DEFINE_UNQUOTED(GATHER_STATISTICS, $gather_stats,
726 [Define to enable detailed memory allocation stats gathering.])
728 AC_ARG_ENABLE(valgrind-annotations,
729 [AS_HELP_STRING([--enable-valgrind-annotations],
730 [enable valgrind runtime interaction])], [],
731 [enable_valgrind_annotations=no])
732 if test x$enable_valgrind_annotations != xno \
733 || test x$ac_valgrind_checking != x; then
734 if (test $have_valgrind_h = no \
735 && test $gcc_cv_header_memcheck_h = no \
736 && test $gcc_cv_header_valgrind_memcheck_h = no); then
737 AC_MSG_ERROR([*** Can't find valgrind/memcheck.h, memcheck.h or valgrind.h])
739 AC_DEFINE(ENABLE_VALGRIND_ANNOTATIONS, 1,
740 [Define to get calls to the valgrind runtime enabled.])
743 # -------------------------------
744 # Miscenalleous configure options
745 # -------------------------------
749 [AS_HELP_STRING([--with-stabs],
750 [arrange to use stabs instead of host debug format])],
754 # Determine whether or not multilibs are enabled.
755 AC_ARG_ENABLE(multilib,
756 [AS_HELP_STRING([--enable-multilib],
757 [enable library support for multiple ABIs])],
758 [], [enable_multilib=yes])
759 AC_SUBST(enable_multilib)
761 # Determine whether or not multiarch is enabled.
762 AC_ARG_ENABLE(multiarch,
763 [AS_HELP_STRING([--enable-multiarch],
764 [enable support for multiarch paths])],
765 [case "${enableval}" in
766 yes|no|auto) enable_multiarch=$enableval;;
767 *) AC_MSG_ERROR(bad value ${enableval} given for --enable-multiarch option) ;;
768 esac], [enable_multiarch=auto])
769 if test x${enable_multiarch} = xauto; then
770 if test x${with_native_system_header_dir} != x; then
771 ma_msg_suffix=", disabled auto check (configured with --native-system-header-dir)"
774 if test x$host != x$target && test "x$with_sysroot" = x; then
775 ma_msg_suffix=", disabled auto check (cross build configured without --with-sysroot)"
779 AC_MSG_CHECKING(for multiarch configuration)
780 AC_SUBST(enable_multiarch)
781 AC_MSG_RESULT($enable_multiarch$ma_msg_suffix)
783 # needed for setting the multiarch name for soft-float/hard-float ABIs
787 # Enable __cxa_atexit for C++.
788 AC_ARG_ENABLE(__cxa_atexit,
789 [AS_HELP_STRING([--enable-__cxa_atexit], [enable __cxa_atexit for C++])],
792 # Enable C extension for decimal float if target supports it.
793 GCC_AC_ENABLE_DECIMAL_FLOAT([$target])
795 dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi`
796 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp,
797 [Define to 1 to enable decimal float extension to C.])
799 # Use default_decimal_float for dependency.
800 enable_decimal_float=$default_decimal_float
802 bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi`
803 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid,
804 [Define to 1 to specify that we are using the BID decimal floating
805 point format instead of DPD])
807 # Enable C extension for fixed-point arithmetic.
808 AC_ARG_ENABLE(fixed-point,
809 [AS_HELP_STRING([--enable-fixed-point],
810 [enable fixed-point arithmetic extension to C])],
815 enable_fixed_point=yes
819 enable_fixed_point=yes
822 AC_MSG_WARN([fixed-point is not supported for this target, ignored])
823 enable_fixed_point=no
827 AC_SUBST(enable_fixed_point)
829 fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi`
830 AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint,
831 [Define to 1 to enable fixed-point arithmetic extension to C.])
834 # Pass with no value to take the default
835 # Pass with a value to specify a thread package
836 AC_ARG_ENABLE(threads,
837 [AS_HELP_STRING([[--enable-threads[=LIB]]],
838 [enable thread usage for target GCC,
839 using LIB thread package])],,
843 [AS_HELP_STRING([--enable-tls],
844 [enable or disable generation of tls code
845 overriding the assembler check for tls support])],
849 *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
850 Valid choices are 'yes' and 'no'.]) ;;
854 AC_ARG_ENABLE(objc-gc,
855 [AS_HELP_STRING([--enable-objc-gc],
856 [enable the use of Boehm's garbage collector with
857 the GNU Objective-C runtime])],
858 if test x$enable_objc_gc = xno; then
866 [AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2])],
867 dwarf2="$with_dwarf2",
870 AC_ARG_ENABLE(shared,
871 [AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])],
873 case $enable_shared in
877 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
878 for pkg in $enableval; do
879 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
886 ], [enable_shared=yes])
887 AC_SUBST(enable_shared)
890 [AS_HELP_STRING([--with-specs=SPECS],
891 [add SPECS to driver command-line processing])],
892 [CONFIGURE_SPECS=$withval],
895 AC_SUBST(CONFIGURE_SPECS)
897 ACX_PKGVERSION([GCC])
898 ACX_BUGURL([http://gcc.gnu.org/bugs.html])
900 # Sanity check enable_languages in case someone does not run the toplevel
901 # configure # script.
902 AC_ARG_ENABLE(languages,
903 [AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])],
904 [case ,${enable_languages}, in
906 # go safe -- we cannot be much sure without the toplevel
908 # analysis of which target libs are present and usable
912 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
917 enable_languages=c,${enable_languages}
920 [enable_languages=c])
922 if test x"$enable_as_accelerator_for" != x; then
923 AC_DEFINE(ACCEL_COMPILER, 1,
924 [Define if this compiler should be built as the offload target compiler.])
925 enable_as_accelerator=yes
928 # In this case we expect offload compiler to be built as native, so we
929 # need to rename the driver to avoid clashes with host's drivers.
930 program_transform_name="s&^&${target}-&" ;;
932 sedscript="s#${target_noncanonical}#${enable_as_accelerator_for}-accel-${target_noncanonical}#"
933 program_transform_name=`echo $program_transform_name | sed $sedscript`
934 accel_dir_suffix=/accel/${target_noncanonical}
935 real_target_noncanonical=${enable_as_accelerator_for}
937 AC_SUBST(enable_as_accelerator)
938 AC_SUBST(real_target_noncanonical)
939 AC_SUBST(accel_dir_suffix)
941 for tgt in `echo $enable_offload_targets | sed 's/,/ /g'`; do
942 tgt=`echo $tgt | sed 's/=.*//'`
943 if test x"$offload_targets" = x; then
946 offload_targets="$offload_targets,$tgt"
949 AC_DEFINE_UNQUOTED(OFFLOAD_TARGETS, "$offload_targets",
950 [Define to offload targets, separated by commas.])
951 if test x"$offload_targets" != x; then
952 AC_DEFINE(ENABLE_OFFLOADING, 1,
953 [Define this to enable support for offloading.])
955 AC_DEFINE(ENABLE_OFFLOADING, 0,
956 [Define this to enable support for offloading.])
959 AC_ARG_WITH(multilib-list,
960 [AS_HELP_STRING([--with-multilib-list], [select multilibs (AArch64, SH and x86-64 only)])],
962 with_multilib_list=default)
964 # -------------------------
965 # Checks for other programs
966 # -------------------------
970 # Find some useful tools
972 # We need awk to create options.c and options.h.
973 # Bail out if it's missing.
975 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
982 AC_SUBST(ranlib_flags)
986 # See if cmp has --ignore-initial.
987 gcc_AC_PROG_CMP_IGNORE_INITIAL
989 # See if we have the mktemp command.
990 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
992 # See if makeinfo has been installed and is modern enough
993 # that we can use it.
994 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
995 [GNU texinfo.* \([0-9][0-9.]*\)],
996 [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
997 if test $gcc_cv_prog_makeinfo_modern = no; then
999 *** Makeinfo is missing or too old.
1000 *** Info documentation will not be built.])
1005 AC_SUBST(BUILD_INFO)
1007 # Is pod2man recent enough to regenerate manpages?
1008 AC_MSG_CHECKING([for recent Pod::Man])
1009 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
1011 GENERATED_MANPAGES=generated-manpages
1016 AC_SUBST(GENERATED_MANPAGES)
1018 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
1021 dnl Don't use AC_PROG_LEX; we insist on flex.
1022 dnl LEXLIB is not useful in gcc.
1023 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
1026 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
1028 # Binutils are not build modules, unlike bison/flex/makeinfo. So we
1029 # check for build == host before using them.
1032 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
1033 && test -d ../binutils ; then
1034 NM='${objdir}/../binutils/nm-new'
1036 AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
1040 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
1041 && test -d ../binutils ; then
1042 AR='${objdir}/../binutils/ar'
1044 AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
1047 # The jit documentation looks better if built with sphinx, but can be
1048 # built with texinfo if sphinx is not available.
1049 # Set "doc_build_sys" to "sphinx" or "texinfo" accordingly.
1050 AC_CHECK_PROG(doc_build_sys, sphinx-build, sphinx, texinfo)
1052 # --------------------
1053 # Checks for C headers
1054 # --------------------
1056 # Need to reject headers which give warnings, so that the -Werror bootstrap
1057 # works later. *sigh* This needs to come before all header checks.
1064 AC_HEADER_TIOCGWINSZ
1065 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
1066 fcntl.h ftw.h unistd.h sys/file.h sys/time.h sys/mman.h \
1067 sys/resource.h sys/param.h sys/times.h sys/stat.h \
1068 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
1070 # Check for thread headers.
1071 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
1072 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
1074 # These tests can't be done till we know if we have limits.h.
1078 # ----------------------
1079 # Checks for C++ headers
1080 # ----------------------
1082 dnl Autoconf will give an error in the configure script if there is no
1083 dnl C++ preprocessor. Hack to prevent that.
1084 m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl
1086 m4_popdef([AC_MSG_ERROR])[]dnl
1088 AC_CHECK_HEADERS(unordered_map)
1089 AC_CHECK_HEADERS(tr1/unordered_map)
1090 AC_CHECK_HEADERS(ext/hash_map)
1093 # Dependency checking.
1097 AC_CONFIG_COMMANDS([gccdepdir],[
1098 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs build/$DEPDIR
1099 for lang in $subdirs c-family common
1101 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs $lang/$DEPDIR
1102 done], [subdirs="$subdirs" ac_aux_dir=$ac_aux_dir DEPDIR=$DEPDIR])
1104 ZW_PROG_COMPILER_DEPENDENCIES([CXX])
1111 # These libraries may be used by collect2.
1112 # We may need a special search path to get them linked.
1113 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
1115 for libs in '' -lld -lmld \
1116 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
1117 '-L/usr/lib/cmplrs/cc3.11 -lmld'
1120 AC_TRY_LINK_FUNC(ldopen,
1121 [gcc_cv_collect2_libs="$libs"; break])
1124 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
1125 case $gcc_cv_collect2_libs in
1127 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
1129 AC_SUBST(COLLECT2_LIBS)
1131 # When building Ada code on Alpha, we need exc_resume which is usually in
1132 # -lexc. So test for it.
1135 AC_SEARCH_LIBS(exc_resume, exc)
1138 AC_SUBST(GNAT_LIBEXC)
1140 # To support -mcpu=native on Solaris/SPARC, we need libkstat.
1143 AC_SEARCH_LIBS(kstat_open, kstat)
1144 EXTRA_GCC_LIBS="$LIBS"
1146 AC_SUBST(EXTRA_GCC_LIBS)
1148 # Some systems put ldexp and frexp in libm instead of libc; assume
1149 # they're both in the same place. jcf-dump needs them.
1152 AC_SEARCH_LIBS(ldexp, m)
1157 # Use <inttypes.h> only if it exists,
1158 # doesn't clash with <sys/types.h>, declares intmax_t and defines
1160 AC_MSG_CHECKING(for inttypes.h)
1161 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
1162 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1163 [[#define __STDC_FORMAT_MACROS
1164 #include <sys/types.h>
1165 #include <inttypes.h>]],
1170 [gcc_cv_header_inttypes_h=yes],
1171 [gcc_cv_header_inttypes_h=no])])
1172 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
1173 if test $gcc_cv_header_inttypes_h = yes; then
1174 AC_DEFINE(HAVE_INTTYPES_H, 1,
1175 [Define if you have a working <inttypes.h> header file.])
1178 dnl Disabled until we have a complete test for buggy enum bitfields.
1179 dnl gcc_AC_C_ENUM_BF_UNSIGNED
1181 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
1182 ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
1183 fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
1184 fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
1185 putchar_unlocked putc_unlocked)
1186 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoq \
1187 popen sysconf strsignal getrusage nl_langinfo \
1188 gettimeofday mbstowcs wcswidth mmap setlocale \
1189 gcc_UNLOCKED_FUNCS madvise)
1191 if test x$ac_cv_func_mbstowcs = xyes; then
1192 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
1193 [ AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
1199 [gcc_cv_func_mbstowcs_works=yes],
1200 [gcc_cv_func_mbstowcs_works=no],
1201 [gcc_cv_func_mbstowcs_works=yes])])
1202 if test x$gcc_cv_func_mbstowcs_works = xyes; then
1203 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
1204 [Define this macro if mbstowcs does not crash when its
1205 first argument is NULL.])
1209 AC_CHECK_TYPE(ssize_t, int)
1210 AC_CHECK_TYPE(caddr_t, char *)
1212 GCC_AC_FUNC_MMAP_BLACKLIST
1216 # Under VMS, vfork works very differently than on Unix. The standard test
1217 # won't work, and it isn't easily adaptable. It makes more sense to
1219 ac_cv_func_vfork_works=yes
1226 # Until we have in-tree GNU iconv:
1228 if test -f "$LTLIBICONV"; then
1229 LIBICONV_DEP=$LTLIBICONV
1231 AC_SUBST(LIBICONV_DEP)
1237 # We will need to find libiberty.h and ansidecl.h
1238 saved_CFLAGS="$CFLAGS"
1239 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1240 saved_CXXFLAGS="$CXXFLAGS"
1241 CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1243 # gcc_AC_CHECK_DECLS doesn't support overloaded functions, so use the
1244 # normal autoconf function for these. But force definition of
1245 # HAVE_DECL_BASENAME like gcc_AC_CHECK_DECLS does, to suppress the bizarre
1246 # basename handling in libiberty.h.
1247 AC_CHECK_DECLS([basename(const char*), strstr(const char*,const char*)], , ,[
1248 #undef HAVE_DECL_BASENAME
1249 #define HAVE_DECL_BASENAME 1
1250 #include "ansidecl.h"
1251 #include "system.h"])
1253 gcc_AC_CHECK_DECLS(getenv atol atoll asprintf sbrk abort atof getcwd getwd \
1254 madvise stpcpy strnlen strsignal strverscmp \
1255 strtol strtoul strtoll strtoull setenv unsetenv \
1256 errno snprintf vsnprintf vasprintf malloc realloc calloc \
1257 free getopt clock getpagesize ffs gcc_UNLOCKED_FUNCS, , ,[
1258 #include "ansidecl.h"
1259 #include "system.h"])
1261 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1262 #include "ansidecl.h"
1264 #ifdef HAVE_SYS_RESOURCE_H
1265 #include <sys/resource.h>
1269 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1270 #include "ansidecl.h"
1272 #ifdef HAVE_SYS_RESOURCE_H
1273 #include <sys/resource.h>
1275 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1276 [Define to `long' if <sys/resource.h> doesn't define.])])
1278 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1279 # FREAD and FWRITE macros. Fortunately, for GCC's single usage of ldgetname
1280 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1281 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1282 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1283 #include "ansidecl.h"
1292 gcc_AC_CHECK_DECLS(times, , ,[
1293 #include "ansidecl.h"
1295 #ifdef HAVE_SYS_TIMES_H
1296 #include <sys/times.h>
1300 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1301 #include "ansidecl.h"
1306 # More time-related stuff.
1307 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1308 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1309 #include "ansidecl.h"
1311 #ifdef HAVE_SYS_TIMES_H
1312 #include <sys/times.h>
1314 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1315 if test $ac_cv_struct_tms = yes; then
1316 AC_DEFINE(HAVE_STRUCT_TMS, 1,
1317 [Define if <sys/times.h> defines struct tms.])
1320 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1321 # revisit after autoconf 2.50.
1322 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1323 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1324 #include "ansidecl.h"
1326 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1327 if test $gcc_cv_type_clock_t = yes; then
1328 AC_DEFINE(HAVE_CLOCK_T, 1,
1329 [Define if <time.h> defines clock_t.])
1332 # Check if F_SETLKW is supported by fcntl.
1333 AC_CACHE_CHECK(for F_SETLKW, ac_cv_f_setlkw, [
1334 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1335 #include <fcntl.h>]], [[
1341 return fcntl (1, F_SETLKW, &fl);]])],
1342 [ac_cv_f_setlkw=yes],[ac_cv_f_setlkw=no])])
1343 if test $ac_cv_f_setlkw = yes; then
1344 AC_DEFINE(HOST_HAS_F_SETLKW, 1,
1345 [Define if F_SETLKW supported by fcntl.])
1348 # Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1349 CFLAGS="$saved_CFLAGS"
1350 CXXFLAGS="$saved_CXXFLAGS"
1352 # mkdir takes a single argument on some systems.
1353 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1361 # With Setjmp/Longjmp based exception handling.
1362 AC_ARG_ENABLE(sjlj-exceptions,
1363 [AS_HELP_STRING([--enable-sjlj-exceptions],
1364 [arrange to use setjmp/longjmp exception handling])],
1367 if test $enableval != yes; then
1368 AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1373 force_sjlj_exceptions=yes],
1376 force_sjlj_exceptions=yes
1380 force_sjlj_exceptions=yes
1384 force_sjlj_exceptions=no
1387 if test $force_sjlj_exceptions = yes; then
1388 sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1389 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1390 [Define 0/1 to force the choice for exception handling model.])
1393 # --------------------------------------------------------
1394 # Build, host, and target specific configuration fragments
1395 # --------------------------------------------------------
1397 # Collect build-machine-specific information.
1398 . ${srcdir}/config.build
1400 # Collect host-machine-specific information.
1401 . ${srcdir}/config.host
1405 # Collect target-machine-specific information.
1406 . ${srcdir}/config.gcc
1408 extra_objs="${host_extra_objs} ${extra_objs}"
1409 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1411 # Default the target-machine variables that were not explicitly set.
1412 if test x"$tm_file" = x
1413 then tm_file=$cpu_type/$cpu_type.h; fi
1415 if test x"$extra_headers" = x
1416 then extra_headers=; fi
1418 if test x$md_file = x
1419 then md_file=$cpu_type/$cpu_type.md; fi
1421 if test x$out_file = x
1422 then out_file=$cpu_type/$cpu_type.c; fi
1424 if test x"$tmake_file" = x
1425 then tmake_file=$cpu_type/t-$cpu_type
1428 # Support --enable-initfini-array.
1429 if test x$enable_initfini_array != xno; then
1430 tm_file="${tm_file} initfini-array.h"
1433 if test x"$dwarf2" = xyes
1434 then tm_file="$tm_file tm-dwarf2.h"
1437 # Say what files are being used for the output code and MD file.
1438 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1439 echo "Using \`$srcdir/config/$md_file' as machine description file."
1441 # If any of the xm_file variables contain nonexistent files, warn
1442 # about them and drop them.
1445 for x in $build_xm_file; do
1446 if test -f $srcdir/config/$x
1448 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1454 for x in $host_xm_file; do
1455 if test -f $srcdir/config/$x
1457 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1463 for x in $xm_file; do
1464 if test -f $srcdir/config/$x
1466 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1472 for f in $tm_file; do
1475 if test $count = ax; then
1476 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1478 echo "Using the following target machine macro files:"
1479 for f in $tm_file; do
1480 echo " $srcdir/config/$f"
1484 if test x$use_long_long_for_widest_fast_int = xyes; then
1485 AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1486 [Define to 1 if the 'long long' type is wider than 'long' but still
1487 efficiently supported by the host hardware.])
1490 gnu_ld_bool=`if test x"$gnu_ld" = x"yes"; then echo 1; else echo 0; fi`
1491 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld_bool, [Define to 1 if using GNU ld.])
1493 gnu_as_bool=`if test x"$gas" = x"yes"; then echo 1; else echo 0; fi`
1494 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as_bool, [Define to 1 if using GNU as.])
1497 for f in $host_xm_file; do
1500 if test $count = a; then
1502 elif test $count = ax; then
1503 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1505 echo "Using the following host machine macro files:"
1506 for f in $host_xm_file; do
1507 echo " $srcdir/config/$f"
1510 echo "Using ${out_host_hook_obj} for host machine hooks."
1512 if test "$host_xm_file" != "$build_xm_file"; then
1514 for f in $build_xm_file; do
1517 if test $count = a; then
1519 elif test $count = ax; then
1520 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1522 echo "Using the following build machine macro files:"
1523 for f in $build_xm_file; do
1524 echo " $srcdir/config/$f"
1529 if test -n "$configured_native_system_header_dir"; then
1530 native_system_header_dir=$configured_native_system_header_dir
1532 NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir"
1533 AC_SUBST(NATIVE_SYSTEM_HEADER_DIR)
1537 AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1538 gcc_cv_mcontext_underscores,
1540 #include <sys/cdefs.h>
1541 #include <sys/signal.h>
1542 #include <ucontext.h>
1543 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1545 gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1546 if test $gcc_cv_mcontext_underscores = yes; then
1547 AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1548 [mcontext_t fields start with __])
1557 # Check if a valid thread package
1558 case ${enable_threads} in
1561 target_thread_file='single'
1565 target_thread_file='single'
1567 aix | dce | lynx | mipssde | posix | rtems | \
1568 single | tpf | vxworks | win32)
1569 target_thread_file=${enable_threads}
1572 echo "${enable_threads} is an unknown thread package" 1>&2
1577 if test x${thread_file} = x; then
1578 # No thread file set by target-specific clauses in config.gcc,
1579 # so use file chosen by default logic above
1580 thread_file=${target_thread_file}
1588 if test x$enable___cxa_atexit = xyes || \
1589 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1590 if test x$host = x$target; then
1592 # mingw32 doesn't have __cxa_atexit but uses atexit registration
1593 # keyed to flag_use_cxa_atexit
1601 AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1602 [echo "__cxa_atexit can't be enabled on this target"])
1606 # We can't check for __cxa_atexit when building a cross, so assume
1610 if test x$use_cxa_atexit = xyes; then
1611 AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1612 [Define if you want to use __cxa_atexit, rather than atexit, to
1613 register C++ destructors for local statics and global objects.
1614 This is essential for fully standards-compliant handling of
1615 destructors, but requires __cxa_atexit in libc.])
1619 # Look for a file containing extra machine modes.
1620 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1621 extra_modes_file='$(srcdir)'/config/${extra_modes}
1622 AC_SUBST(extra_modes_file)
1623 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1624 [Define to the name of a file containing a list of extra machine modes
1625 for this architecture.])
1628 # Convert extra_options into a form suitable for Makefile use.
1631 for f in $extra_options; do
1632 extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1633 all_opt_files="$all_opt_files $srcdir/config/$f"
1635 AC_SUBST(extra_opt_files)
1637 # auto-host.h is the file containing items generated by autoconf and is
1638 # the first file included by config.h.
1639 # If host=build, it is correct to have bconfig include auto-host.h
1640 # as well. If host!=build, we are in error and need to do more
1641 # work to find out the build config parameters.
1642 if test x$host = x$build
1644 build_auto=auto-host.h
1646 # We create a subdir, then run autoconf in the subdir.
1647 # To prevent recursion we set host and build for the new
1648 # invocation of configure to the build for this invocation
1655 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1656 *) realsrcdir=../${srcdir};;
1658 # Clearing GMPINC is necessary to prevent host headers being
1659 # used by the build compiler. Defining GENERATOR_FILE stops
1660 # system.h from including gmp.h.
1661 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1662 CXX="${CXX_FOR_BUILD}" CXXFLAGS="${CXXFLAGS_FOR_BUILD}" \
1663 LD="${LD_FOR_BUILD}" LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1664 GMPINC="" CPPFLAGS="${CPPFLAGS} -DGENERATOR_FILE" \
1665 ${realsrcdir}/configure \
1666 --enable-languages=${enable_languages-all} \
1667 --target=$target_alias --host=$build_alias --build=$build_alias
1669 # We just finished tests for the build machine, so rename
1670 # the file auto-build.h in the gcc directory.
1671 mv auto-host.h ../auto-build.h
1674 build_auto=auto-build.h
1676 AC_SUBST(build_subdir)
1678 tm_file="${tm_file} defaults.h"
1679 tm_p_file="${tm_p_file} tm-preds.h"
1680 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1681 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1682 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1683 # put this back in temporarily.
1684 xm_file="auto-host.h ansidecl.h ${xm_file}"
1691 # Compile in configure arguments.
1692 if test -f configargs.h ; then
1693 # Being re-configured.
1694 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1695 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1697 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1700 # Double all backslashes and backslash all quotes to turn
1701 # gcc_config_arguments into a C string.
1702 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1703 $gcc_config_arguments
1705 gcc_config_arguments_str=`cat conftest.out`
1708 cat > configargs.h <<EOF
1709 /* Generated automatically. */
1710 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1711 static const char thread_model[] = "$thread_file";
1713 static const struct {
1714 const char *name, *value;
1715 } configure_default_options[] = $configure_default_options;
1720 gcc_BASEVER=`cat $srcdir/BASE-VER`
1721 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
1722 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
1723 if test -f $srcdir/REVISION ; then
1724 gcc_REVISION=`cat $srcdir/REVISION`
1728 cat > plugin-version.h <<EOF
1729 #include "configargs.h"
1731 #define GCCPLUGIN_VERSION_MAJOR `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'`
1732 #define GCCPLUGIN_VERSION_MINOR `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'`
1733 #define GCCPLUGIN_VERSION_PATCHLEVEL `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'`
1734 #define GCCPLUGIN_VERSION (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR)
1736 static char basever[] = "$gcc_BASEVER";
1737 static char datestamp[] = "$gcc_DATESTAMP";
1738 static char devphase[] = "$gcc_DEVPHASE";
1739 static char revision[] = "$gcc_REVISION";
1741 /* FIXME plugins: We should make the version information more precise.
1742 One way to do is to add a checksum. */
1744 static struct plugin_gcc_version gcc_version = {basever, datestamp,
1746 configuration_arguments};
1750 # Internationalization
1751 ZW_GNU_GETTEXT_SISTER_DIR
1753 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1754 # -liconv on the link line twice.
1755 case "$LIBINTL" in *$LIBICONV*)
1759 AC_ARG_ENABLE(secureplt,
1760 [AS_HELP_STRING([--enable-secureplt],
1761 [enable -msecure-plt by default for PowerPC])],
1764 AC_ARG_ENABLE(leading-mingw64-underscores,
1765 AS_HELP_STRING([--enable-leading-mingw64-underscores],
1766 [enable leading underscores on 64 bit mingw targets]),
1768 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
1769 [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
1770 [Define if we should use leading underscore on 64 bit mingw targets])])
1773 [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [],
1776 AC_ARG_ENABLE(frame-pointer,
1777 [AS_HELP_STRING([--enable-frame-pointer],
1778 [enable -fno-omit-frame-pointer by default for 32bit x86])], [],
1781 linux* | darwin[[8912]]*)
1782 # Enable -fomit-frame-pointer by default for Linux and Darwin with
1784 enable_frame_pointer=no
1787 enable_frame_pointer=yes
1792 # Windows32 Registry support for specifying GCC installation paths.
1793 AC_ARG_ENABLE(win32-registry,
1794 [AS_HELP_STRING([--disable-win32-registry],
1795 [disable lookup of installation paths in the
1796 Registry on Windows hosts])
1797 AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)])
1798 AS_HELP_STRING([--enable-win32-registry=KEY],
1799 [use KEY instead of GCC version as the last portion
1800 of the registry key])],,)
1803 win32 | pe | cygwin* | mingw32*)
1804 if test "x$enable_win32_registry" != xno; then
1805 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1808 if test "x$enable_win32_registry" != xno; then
1809 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1810 [Define to 1 if installation paths should be looked up in the Windows
1811 Registry. Ignored on non-Windows hosts.])
1813 if test "x$enable_win32_registry" != xyes \
1814 && test "x$enable_win32_registry" != x; then
1815 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1816 [Define to be the last component of the Windows registry key under which
1817 to look for installation paths. The full key used will be
1818 HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1819 The default is the GCC version number.])
1825 # Get an absolute path to the GCC top-level source directory
1826 holddir=`${PWDCMD-pwd}`
1828 topdir=`${PWDCMD-pwd}`
1831 # Conditionalize the makefile for this host machine.
1833 for f in ${host_xmake_file}
1835 if test -f ${srcdir}/config/$f
1837 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1841 # Conditionalize the makefile for this target machine.
1843 for f in ${tmake_file}
1845 if test -f ${srcdir}/config/$f
1847 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1850 tmake_file="${tmake_file_}"
1852 out_object_file=`basename $out_file .c`.o
1853 common_out_object_file=`basename $common_out_file .c`.o
1855 tm_file_list="options.h"
1856 tm_include_list="options.h insn-constants.h"
1857 for f in $tm_file; do
1860 f=`echo $f | sed 's/^..//'`
1861 tm_file_list="${tm_file_list} $f"
1862 tm_include_list="${tm_include_list} $f"
1865 tm_file_list="${tm_file_list} \$(srcdir)/$f"
1866 tm_include_list="${tm_include_list} $f"
1869 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1870 tm_include_list="${tm_include_list} config/$f"
1877 for f in $tm_p_file; do
1880 tm_p_file_list="${tm_p_file_list} $f"
1881 tm_p_include_list="${tm_p_include_list} $f"
1884 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1885 tm_p_include_list="${tm_p_include_list} config/$f"
1891 for f in $xm_file; do
1894 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1895 xm_include_list="${xm_include_list} $f"
1898 xm_file_list="${xm_file_list} $f"
1899 xm_include_list="${xm_include_list} $f"
1902 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1903 xm_include_list="${xm_include_list} config/$f"
1909 host_xm_include_list=
1910 for f in $host_xm_file; do
1913 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1914 host_xm_include_list="${host_xm_include_list} $f"
1917 host_xm_file_list="${host_xm_file_list} $f"
1918 host_xm_include_list="${host_xm_include_list} $f"
1921 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1922 host_xm_include_list="${host_xm_include_list} config/$f"
1928 for f in $build_xm_file; do
1931 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1932 build_xm_include_list="${build_xm_include_list} $f"
1934 auto-build.h | auto-host.h )
1935 build_xm_file_list="${build_xm_file_list} $f"
1936 build_xm_include_list="${build_xm_include_list} $f"
1939 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1940 build_xm_include_list="${build_xm_include_list} config/$f"
1945 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1946 # cross-compiler which does not use the native headers and libraries.
1947 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1948 CROSS= AC_SUBST(CROSS)
1949 ALL=all.internal AC_SUBST(ALL)
1950 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1952 if test "x$with_build_sysroot" != x; then
1953 build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1955 # This value is used, even on a native system, because
1956 # CROSS_SYSTEM_HEADER_DIR is just
1957 # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1958 build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1961 if test x$host != x$target
1963 CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1965 SYSTEM_HEADER_DIR=$build_system_header_dir
1966 case "$host","$target" in
1967 # Darwin crosses can use the host system's libraries and headers,
1968 # because of the fat library support. Of course, it must be the
1969 # same version of Darwin on both sides. Allow the user to
1970 # just say --target=foo-darwin without a version number to mean
1971 # "the version on this system".
1972 *-*-darwin*,*-*-darwin*)
1973 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1974 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1975 if test $hostos = $targetos -o $targetos = darwin ; then
1977 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1982 i?86-*-*,x86_64-*-* \
1983 | powerpc*-*-*,powerpc64*-*-*)
1984 CROSS="$CROSS -DNATIVE_CROSS" ;;
1989 if test "x$with_headers" = x; then
1996 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1997 SYSTEM_HEADER_DIR=$build_system_header_dir
2000 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
2001 if test "x$with_headers" != x; then
2002 target_header_dir=$with_headers
2003 elif test "x$with_sysroot" = x; then
2004 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include"
2005 elif test "x$with_build_sysroot" != "x"; then
2006 target_header_dir="${with_build_sysroot}${native_system_header_dir}"
2007 elif test "x$with_sysroot" = xyes; then
2008 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
2010 target_header_dir="${with_sysroot}${native_system_header_dir}"
2013 target_header_dir=${native_system_header_dir}
2016 # If this is a cross-compiler that does not
2017 # have its own set of headers then define
2020 # If this is using newlib, without having the headers available now,
2021 # then define inhibit_libc in LIBGCC2_CFLAGS.
2022 # This prevents libgcc2 from containing any code which requires libc
2024 : ${inhibit_libc=false}
2025 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
2026 test x$with_newlib = xyes ; } &&
2027 { test "x$with_headers" = xno || test ! -f "$target_header_dir/stdio.h"; } ; then
2030 AC_SUBST(inhibit_libc)
2032 # When building gcc with a cross-compiler, we need to adjust things so
2033 # that the generator programs are still built with the native compiler.
2034 # Also, we cannot run fixincludes.
2036 # These are the normal (build=host) settings:
2037 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
2038 CXX_FOR_BUILD='$(CXX)' AC_SUBST(CXX_FOR_BUILD)
2039 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
2040 BUILD_CXXFLAGS='$(ALL_CXXFLAGS)' AC_SUBST(BUILD_CXXFLAGS)
2041 BUILD_LDFLAGS='$(LDFLAGS)' AC_SUBST(BUILD_LDFLAGS)
2042 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
2044 BUILD_NO_PIE_CFLAGS='$(NO_PIE_CFLAGS)' AC_SUBST(BUILD_NO_PIE_CFLAGS)
2045 BUILD_NO_PIE_FLAG='$(NO_PIE_FLAG)' AC_SUBST(BUILD_NO_PIE_FLAG)
2047 # And these apply if build != host, or we are generating coverage data
2048 if test x$build != x$host || test "x$coverage_flags" != x
2050 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
2051 BUILD_CXXFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CXXFLAGS_FOR_BUILD)'
2052 BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
2054 NO_PIE_CFLAGS_FOR_BUILD=${NO_PIE_CFLAGS_FOR_BUILD-${NO_PIE_CFLAGS}}
2055 NO_PIE_FLAG_FOR_BUILD=${NO_PIE_FLAG_FOR_BUILD-${NO_PIE_FLAG}}
2056 BUILD_NO_PIE_CFLAGS='$(NO_PIE_CFLAGS_FOR_BUILD)'
2057 BUILD_NO_PIE_FLAG='$(NO_PIE_FLAG_FOR_BUILD)'
2059 AC_SUBST(NO_PIE_CFLAGS_FOR_BUILD)
2060 AC_SUBST(NO_PIE_FLAG_FOR_BUILD)
2062 # Expand extra_headers to include complete path.
2063 # This substitutes for lots of t-* files.
2065 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
2066 for file in ${extra_headers} ; do
2067 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
2070 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
2071 if test x"$use_gcc_tgmath" = xyes
2072 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
2075 # Define collect2 in Makefile.
2076 case $host_can_use_collect2 in
2078 *) collect2='collect2$(exeext)' ;;
2080 AC_SUBST([collect2])
2082 # Add a definition of USE_COLLECT2 if system wants one.
2083 case $use_collect2 in
2084 no) use_collect2= ;;
2087 host_xm_defines="${host_xm_defines} USE_COLLECT2"
2088 xm_defines="${xm_defines} USE_COLLECT2"
2089 case $host_can_use_collect2 in
2091 AC_MSG_ERROR([collect2 is required but cannot be built on this system])
2097 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
2098 [Define to the name of the LTO plugin DSO that must be
2099 passed to the linker's -plugin=LIB option.])
2101 # ---------------------------
2102 # Assembler & linker features
2103 # ---------------------------
2105 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
2106 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
2107 # However when ld-new is first executed from the build tree, libtool will
2108 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
2109 # to the build tree. While doing this we need to use the previous-stage
2110 # linker, or we have an infinite loop. The presence of a shell script as
2111 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
2112 # the gcc/collect-ld script. So we need to know how libtool works, or
2113 # exec-tool will fail.
2115 m4_defun([_LT_CONFIG_COMMANDS], [])
2118 AC_SUBST(enable_fast_install)
2120 # Identify the assembler which will work hand-in-glove with the newly
2121 # built GCC, so that we can examine its features. This is the assembler
2122 # which will be driven by the driver program.
2124 # If build != host, and we aren't building gas in-tree, we identify a
2125 # build->target assembler and hope that it will have the same features
2126 # as the host->target assembler we'll be using.
2127 gcc_cv_gas_major_version=
2128 gcc_cv_gas_minor_version=
2129 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
2131 m4_pattern_allow([AS_FOR_TARGET])dnl
2132 AS_VAR_SET_IF(gcc_cv_as,, [
2133 if test -x "$DEFAULT_ASSEMBLER"; then
2134 gcc_cv_as="$DEFAULT_ASSEMBLER"
2135 elif test -f $gcc_cv_as_gas_srcdir/configure.ac \
2136 && test -f ../gas/Makefile \
2137 && test x$build = x$host; then
2138 gcc_cv_as=../gas/as-new$build_exeext
2139 elif test -x as$build_exeext; then
2140 # Build using assembler in the current directory.
2141 gcc_cv_as=./as$build_exeext
2142 elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then
2143 gcc_cv_as="$AS_FOR_TARGET"
2145 AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
2148 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
2149 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
2150 case "$ORIGINAL_AS_FOR_TARGET" in
2151 ./as | ./as$build_exeext) ;;
2152 *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
2155 AC_MSG_CHECKING(what assembler to use)
2156 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
2157 # Single tree build which includes gas. We want to prefer it
2158 # over whatever linker top-level may have detected, since
2159 # we'll use what we're building after installation anyway.
2160 AC_MSG_RESULT(newly built gas)
2162 _gcc_COMPUTE_GAS_VERSION
2163 in_tree_gas_is_elf=no
2164 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2165 || (grep 'obj_format = multi' ../gas/Makefile \
2166 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
2168 in_tree_gas_is_elf=yes
2171 AC_MSG_RESULT($gcc_cv_as)
2177 [[ --enable-ld[=ARG] build ld [ARG={default,yes,no}]]],
2178 [case "${enableval}" in
2184 install_gold_as_default=no
2186 [[ --enable-gold[=ARG] build gold [ARG={default,yes,no}]]],
2187 [case "${enableval}" in
2189 install_gold_as_default=yes
2192 if test x${default_ld} != x; then
2193 install_gold_as_default=yes
2199 AC_MSG_ERROR([invalid --enable-gold argument])
2203 # Identify the linker which will work hand-in-glove with the newly
2204 # built GCC, so that we can examine its features. This is the linker
2205 # which will be driven by the driver program.
2207 # If build != host, and we aren't building gas in-tree, we identify a
2208 # build->target linker and hope that it will have the same features
2209 # as the host->target linker we'll be using.
2210 gcc_cv_gld_major_version=
2211 gcc_cv_gld_minor_version=
2212 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
2213 gcc_cv_ld_gold_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gold
2214 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
2216 AS_VAR_SET_IF(gcc_cv_ld,, [
2217 if test -x "$DEFAULT_LINKER"; then
2218 gcc_cv_ld="$DEFAULT_LINKER"
2219 elif test $install_gold_as_default = yes \
2220 && test -f $gcc_cv_ld_gold_srcdir/configure.ac \
2221 && test -f ../gold/Makefile \
2222 && test x$build = x$host; then
2223 gcc_cv_ld=../gold/ld-new$build_exeext
2224 elif test -f $gcc_cv_ld_gld_srcdir/configure.ac \
2225 && test -f ../ld/Makefile \
2226 && test x$build = x$host; then
2227 gcc_cv_ld=../ld/ld-new$build_exeext
2228 elif test -x collect-ld$build_exeext; then
2229 # Build using linker in the current directory.
2230 gcc_cv_ld=./collect-ld$build_exeext
2231 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
2232 gcc_cv_ld="$LD_FOR_TARGET"
2234 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
2237 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
2238 PLUGIN_LD_SUFFIX=`basename $gcc_cv_ld | sed -e "s,$target_alias-,,"`
2239 # if the PLUGIN_LD is set ld-new, just have it as ld
2240 # as that is the installed named.
2241 if test x$PLUGIN_LD_SUFFIX = xld-new \
2242 || test x$PLUGIN_LD_SUFFIX = xcollect-ld ; then
2245 AC_ARG_WITH(plugin-ld,
2246 [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])],
2247 [if test x"$withval" != x; then
2248 ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
2249 PLUGIN_LD_SUFFIX="$withval"
2251 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
2252 AC_DEFINE_UNQUOTED(PLUGIN_LD_SUFFIX, "$PLUGIN_LD_SUFFIX", [Specify plugin linker])
2254 # Check to see if we are using gold instead of ld
2255 AC_MSG_CHECKING(whether we are using gold)
2257 if test x$gcc_cv_ld != x; then
2258 if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2259 | grep "GNU gold" > /dev/null; then
2263 AC_MSG_RESULT($ld_is_gold)
2265 AC_MSG_CHECKING(gold linker with split stack support as non default)
2266 # Check to see if default ld is not gold, but gold is
2267 # available and has support for split stack. If gcc was configured
2268 # with gold then no checking is done.
2270 if test x$ld_is_gold = xno && which ${gcc_cv_ld}.gold >/dev/null 2>&1; then
2272 # For platforms other than powerpc64*, enable as appropriate.
2275 ld_gold=`which ${gcc_cv_ld}.gold`
2276 # Make sure this gold has minimal split stack support
2277 if $ld_gold --help 2>/dev/null | grep split-stack-adjust-size >/dev/null 2>&1; then
2278 ld_vers=`$ld_gold --version | sed 1q`
2279 gold_vers=`echo $ld_vers | sed -n \
2280 -e 's,^[[^)]]*[[ ]]\([[0-9]][[0-9]]*\.[[0-9]][[0-9]]*[[^)]]*\)) .*$,\1,p'`
2282 # check that the gold version contains the complete split stack support
2283 # on powerpc64 big and little endian
2285 case "$gold_vers" in
2286 2.25.[[1-9]]*|2.2[[6-9]][[.0-9]]*|2.[[3-9]][[.0-9]]*|[[3-9]].[[.0-9]]*) gold_non_default=yes
2288 *) gold_non_default=no
2294 if test $gold_non_default = yes; then
2295 AC_DEFINE(HAVE_GOLD_NON_DEFAULT_SPLIT_STACK, 1,
2296 [Define if the gold linker supports split stack and is available as a non-default])
2299 AC_MSG_RESULT($gold_non_default)
2301 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
2302 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
2303 case "$ORIGINAL_LD_FOR_TARGET" in
2304 ./collect-ld | ./collect-ld$build_exeext) ;;
2305 *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
2308 AC_MSG_CHECKING(what linker to use)
2309 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \
2310 || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then
2311 # Single tree build which includes ld. We want to prefer it
2312 # over whatever linker top-level may have detected, since
2313 # we'll use what we're building after installation anyway.
2314 AC_MSG_RESULT(newly built ld)
2316 in_tree_ld_is_elf=no
2317 if (grep 'EMUL = .*elf' ../ld/Makefile \
2318 || grep 'EMUL = .*linux' ../ld/Makefile \
2319 || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
2320 in_tree_ld_is_elf=yes
2321 elif test "$ld_is_gold" = yes; then
2322 in_tree_ld_is_elf=yes
2324 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
2327 gcc_cv_gld_version=`sed -n -e 's/^[ ]*VERSION=[^0-9A-Za-z_]*\([0-9]*\.[0-9]*.*\)/VERSION=\1/p' < $f`
2328 if test x$gcc_cv_gld_version != x; then
2332 case $gcc_cv_gld_version in
2335 *) AC_MSG_ERROR([[cannot find version of in-tree linker]]) ;;
2338 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2339 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2341 ORIGINAL_LD_BFD_FOR_TARGET=../ld/ld-new$build_exeext
2342 ORIGINAL_LD_GOLD_FOR_TARGET=../gold/ld-new$build_exeext
2344 AC_MSG_RESULT($gcc_cv_ld)
2346 gcc_cvs_ld_program=`dirname $gcc_cv_ld`/`basename $gcc_cv_ld $host_exeext`
2347 ORIGINAL_LD_BFD_FOR_TARGET=${gcc_cvs_ld_program}.bfd$host_exeext
2348 ORIGINAL_LD_GOLD_FOR_TARGET=${gcc_cvs_ld_program}.gold$host_exeext
2351 AC_SUBST(ORIGINAL_LD_BFD_FOR_TARGET)
2352 AC_SUBST(ORIGINAL_LD_GOLD_FOR_TARGET)
2354 # Figure out what nm we will be using.
2355 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2356 AS_VAR_SET_IF(gcc_cv_nm,, [
2357 if test -f $gcc_cv_binutils_srcdir/configure.ac \
2358 && test -f ../binutils/Makefile \
2359 && test x$build = x$host; then
2360 gcc_cv_nm=../binutils/nm-new$build_exeext
2361 elif test -x nm$build_exeext; then
2362 gcc_cv_nm=./nm$build_exeext
2363 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
2364 gcc_cv_nm="$NM_FOR_TARGET"
2366 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2369 AC_MSG_CHECKING(what nm to use)
2370 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2371 # Single tree build which includes binutils.
2372 AC_MSG_RESULT(newly built nm)
2375 AC_MSG_RESULT($gcc_cv_nm)
2379 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2380 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2381 case "$ORIGINAL_NM_FOR_TARGET" in
2382 ./nm | ./nm$build_exeext) ;;
2383 *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2387 # Figure out what objdump we will be using.
2388 AS_VAR_SET_IF(gcc_cv_objdump,, [
2389 if test -f $gcc_cv_binutils_srcdir/configure.ac \
2390 && test -f ../binutils/Makefile \
2391 && test x$build = x$host; then
2392 # Single tree build which includes binutils.
2393 gcc_cv_objdump=../binutils/objdump$build_exeext
2394 elif test -x objdump$build_exeext; then
2395 gcc_cv_objdump=./objdump$build_exeext
2396 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2397 gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2399 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2402 AC_MSG_CHECKING(what objdump to use)
2403 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2404 # Single tree build which includes binutils.
2405 AC_MSG_RESULT(newly built objdump)
2406 elif test x$gcc_cv_objdump = x; then
2407 AC_MSG_RESULT(not found)
2409 AC_MSG_RESULT($gcc_cv_objdump)
2412 # Figure out what readelf we will be using.
2413 AS_VAR_SET_IF(gcc_cv_readelf,, [
2414 if test -f $gcc_cv_binutils_srcdir/configure.ac \
2415 && test -f ../binutils/Makefile \
2416 && test x$build = x$host; then
2417 # Single tree build which includes binutils.
2418 gcc_cv_readelf=../binutils/readelf$build_exeext
2419 elif test -x readelf$build_exeext; then
2420 gcc_cv_readelf=./readelf$build_exeext
2421 elif ( set dummy $READELF_FOR_TARGET; test -x $[2] ); then
2422 gcc_cv_readelf="$READELF_FOR_TARGET"
2424 AC_PATH_PROG(gcc_cv_readelf, $READELF_FOR_TARGET)
2427 AC_MSG_CHECKING(what readelf to use)
2428 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2429 # Single tree build which includes binutils.
2430 AC_MSG_RESULT(newly built readelf)
2431 elif test x$gcc_cv_readelf = x; then
2432 AC_MSG_RESULT(not found)
2434 AC_MSG_RESULT($gcc_cv_readelf)
2437 # Figure out what assembler alignment features are present.
2438 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2442 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2443 [Define if your assembler supports .balign and .p2align.])])
2445 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2448 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2449 [Define if your assembler supports specifying the maximum number
2450 of bytes to skip when using the GAS .p2align command.])])
2452 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2455 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2456 [Define if your assembler supports .literal16.])])
2458 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2460 [conftest_label1: .word 0
2462 conftest_label2: .word 0
2464 [if test x$gcc_cv_nm != x; then
2465 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2466 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2467 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2469 else gcc_cv_as_subsection_m1=yes
2471 rm -f conftest.nm1 conftest.nm2
2473 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2474 [Define if your assembler supports .subsection and .subsection -1 starts
2475 emitting at the beginning of your section.])])
2477 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2480 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2482 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2484 [ .weakref foobar, barfnot],,
2485 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2487 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2490 .NSUBSPA $CODE$,COMDAT],,
2491 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2493 # .hidden needs to be supported in both the assembler and the linker,
2494 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2495 # This is irritatingly difficult to feature test for; we have to check the
2496 # date string after the version number. If we've got an in-tree
2497 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2499 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2500 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2506 # Darwin as has some visibility support, though with a different syntax.
2507 gcc_cv_as_hidden=yes
2511 # gnu_indirect_function type is an extension proposed at
2512 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2513 # selection of function implementation
2514 AC_ARG_ENABLE(gnu-indirect-function,
2515 [AS_HELP_STRING([--enable-gnu-indirect-function],
2516 [enable the use of the @gnu_indirect_function to glibc systems])],
2517 [case $enable_gnu_indirect_function in
2519 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2520 Valid choices are 'yes' and 'no'.]) ;;
2522 [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2524 gif=`if test x$enable_gnu_indirect_function = xyes; then echo 1; else echo 0; fi`
2525 AC_DEFINE_UNQUOTED(HAVE_GNU_INDIRECT_FUNCTION, $gif,
2526 [Define if your system supports gnu indirect functions.])
2530 if test $in_tree_ld != yes ; then
2531 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2532 if echo "$ld_ver" | grep GNU > /dev/null; then
2533 if test x"$ld_is_gold" = xyes; then
2534 # GNU gold --version looks like this:
2536 # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
2538 # We extract the binutils version which is more familiar and specific
2539 # than the gold version.
2540 ld_vers=`echo $ld_ver | sed -n \
2541 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
2543 # GNU ld --version looks like this:
2545 # GNU ld (GNU Binutils) 2.21.51.20110225
2546 ld_vers=`echo $ld_ver | sed -n \
2547 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2549 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'`
2550 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2551 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2552 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2556 # See acinclude.m4 (gcc_SUN_LD_VERSION) for the version number
2559 # Don't reuse gcc_gv_sun_ld_vers_* in case a linker other than
2560 # /usr/ccs/bin/ld has been configured.
2561 ld_ver=`$gcc_cv_ld -V 2>&1`
2562 if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2563 ld_vers=`echo $ld_ver | sed -n \
2564 -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2565 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2566 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2574 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2575 [[if test $in_tree_ld = yes ; then
2577 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 \
2578 && test $in_tree_ld_is_elf = yes; then
2579 gcc_cv_ld_hidden=yes
2582 gcc_cv_ld_hidden=yes
2583 if test x"$ld_is_gold" = xyes; then
2585 elif echo "$ld_ver" | grep GNU > /dev/null; then
2587 mmix-knuth-mmixware)
2588 # The linker emits by default mmo, not ELF, so "no" is appropriate.
2592 if test 0"$ld_date" -lt 20020404; then
2593 if test -n "$ld_date"; then
2594 # If there was date string, but was earlier than 2002-04-04, fail
2596 elif test -z "$ld_vers"; then
2597 # If there was no date string nor ld version number, something is wrong
2600 test -z "$ld_vers_patch" && ld_vers_patch=0
2601 if test "$ld_vers_major" -lt 2; then
2603 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2604 gcc_cv_ld_hidden="no"
2605 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2613 # Darwin ld has some visibility support.
2614 gcc_cv_ld_hidden=yes
2616 hppa64*-*-hpux* | ia64*-*-hpux*)
2617 gcc_cv_ld_hidden=yes
2619 *-*-solaris2.1[0-9]*)
2620 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2621 # .symbolic was only added in Solaris 9 12/02.
2622 gcc_cv_ld_hidden=yes
2630 libgcc_visibility=no
2631 AC_SUBST(libgcc_visibility)
2632 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2633 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2634 libgcc_visibility=yes
2635 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2636 [Define if your assembler and linker support .hidden.])
2639 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2640 gcc_cv_ld_ro_rw_mix=unknown
2641 if test $in_tree_ld = yes ; then
2642 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 \
2643 && test $in_tree_ld_is_elf = yes; then
2644 gcc_cv_ld_ro_rw_mix=read-write
2646 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2647 echo '.section myfoosect, "a"' > conftest1.s
2648 echo '.section myfoosect, "aw"' > conftest2.s
2649 echo '.byte 1' >> conftest2.s
2650 echo '.section myfoosect, "a"' > conftest3.s
2651 echo '.byte 0' >> conftest3.s
2652 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2653 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2654 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2655 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2656 conftest2.o conftest3.o > /dev/null 2>&1; then
2657 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2658 | sed -e '/myfoosect/!d' -e N`
2659 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2660 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2661 gcc_cv_ld_ro_rw_mix=read-only
2663 gcc_cv_ld_ro_rw_mix=read-write
2668 rm -f conftest.* conftest[123].*
2671 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2672 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2673 [Define if your linker links a mix of read-only
2674 and read-write sections into a read-write section.])
2676 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2678 gcc_AC_INITFINI_ARRAY
2680 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2681 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2689 [[# GAS versions before 2.11 do not support uleb128,
2690 # despite appearing to.
2691 # ??? There exists an elf-specific test that will crash
2692 # the assembler. Perhaps it's better to figure out whether
2693 # arbitrary sections are supported and try the test.
2694 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2695 if echo "$as_ver" | grep GNU > /dev/null; then
2696 as_vers=`echo $as_ver | sed -n \
2697 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2698 as_major=`expr "$as_vers" : '\([0-9]*\)'`
2699 as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2700 if test $as_major -eq 2 && test $as_minor -lt 11
2702 else gcc_cv_as_leb128=yes
2705 [AC_DEFINE(HAVE_AS_LEB128, 1,
2706 [Define if your assembler supports .sleb128 and .uleb128.])])
2708 # Check if we have assembler support for unwind directives.
2709 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2716 .cfi_escape 1, 2, 3, 4, 5
2720 # If the linker used on Solaris (like Sun ld) isn't capable of merging
2721 # read-only and read-write sections, we need to make sure that the
2722 # assembler used emits read-write .eh_frame sections.
2723 if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2724 if test "x$gcc_cv_objdump" != x; then
2725 if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2726 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2727 gcc_cv_as_cfi_directive=no
2730 i?86-*-solaris2.1[[0-9]]* | x86_64-*-solaris2.1[[0-9]]*)
2731 # On Solaris/x86, make sure that GCC and assembler agree on using
2732 # read-only .eh_frame sections for 64-bit.
2733 if test x$gas = xyes; then
2734 as_ix86_64_opt="--64"
2736 as_ix86_64_opt="-xarch=amd64"
2738 if $gcc_cv_as $as_ix86_64_opt -o conftest.o conftest.s > /dev/null 2>&1 && \
2739 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2740 sed -e /.eh_frame/!d -e N | \
2741 grep READONLY > /dev/null; then
2742 gcc_cv_as_cfi_directive=yes
2744 gcc_cv_as_cfi_directive=no
2748 gcc_cv_as_cfi_directive=yes
2753 # no objdump, err on the side of caution
2754 gcc_cv_as_cfi_directive=no
2757 gcc_cv_as_cfi_directive=yes
2761 gcc_cv_as_cfi_directive=yes
2764 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
2765 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2769 .cfi_adjust_cfa_offset 64
2771 .cfi_adjust_cfa_offset 128
2774 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
2775 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then
2776 gcc_cv_as_cfi_advance_working=yes
2780 # no objdump, err on the side of caution
2781 gcc_cv_as_cfi_advance_working=no
2783 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
2784 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2785 [`if test $gcc_cv_as_cfi_directive = yes \
2786 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2787 [Define 0/1 if your assembler supports CFI directives.])
2789 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
2790 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2791 gcc_cv_as_cfi_personality_directive, ,,
2794 .cfi_personality 0, symbol
2796 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2797 [`if test $gcc_cv_as_cfi_personality_directive = yes;
2798 then echo 1; else echo 0; fi`],
2799 [Define 0/1 if your assembler supports .cfi_personality.])
2801 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2802 gcc_cv_as_cfi_sections_directive, ,,
2804 .cfi_sections .debug_frame, .eh_frame
2808 win32 | pe | cygwin* | mingw32*)
2809 # Need to check that we generated the correct relocation for the
2810 # .debug_frame section. This was fixed for binutils 2.21.
2811 gcc_cv_as_cfi_sections_directive=no
2812 if test "x$gcc_cv_objdump" != x; then
2813 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
2814 grep secrel > /dev/null; then
2815 gcc_cv_as_cfi_sections_directive=yes
2820 gcc_cv_as_cfi_sections_directive=yes
2823 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
2824 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2825 [`if test $gcc_cv_as_cfi_sections_directive = yes;
2826 then echo 1; else echo 0; fi`],
2827 [Define 0/1 if your assembler supports .cfi_sections.])
2829 # GAS versions up to and including 2.11.0 may mis-optimize
2831 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2839 .section .eh_frame,"aw",@progbits
2841 .4byte .LECIE1-.LSCIE1
2855 .4byte .LEFDE1-.LASFDE1
2857 .4byte .LASFDE1-__FRAME_BEGIN__
2865 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2866 cat > conftest.lit <<EOF
2867 0000 10000000 00000000 017a0001 781a0004 .........z..x...
2868 0010 01000000 12000000 18000000 00000000 ................
2869 0020 08000000 04080000 0044 .........D @&t@
2871 cat > conftest.big <<EOF
2872 0000 00000010 00000000 017a0001 781a0004 .........z..x...
2873 0010 00000001 00000012 00000018 00000000 ................
2874 0020 00000008 04000000 0844 .........D @&t@
2876 # If the assembler didn't choke, and we can objdump,
2877 # and we got the correct data, then succeed.
2878 # The text in the here-document typically retains its unix-style line
2879 # endings, while the output of objdump will use host line endings.
2880 # Therefore, use diff -b for the comparisons.
2881 if test x$gcc_cv_objdump != x \
2882 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2883 | tail -3 > conftest.got \
2884 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2885 || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2887 gcc_cv_as_eh_frame=yes
2888 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2889 gcc_cv_as_eh_frame=buggy
2891 # Uh oh, what do we do now?
2892 gcc_cv_as_eh_frame=no
2895 if test $gcc_cv_as_eh_frame = buggy; then
2896 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2897 [Define if your assembler mis-optimizes .eh_frame data.])
2900 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2901 [elf,2,12,0], [--fatal-warnings],
2902 [.section .rodata.str, "aMS", @progbits, 1])
2903 if test $gcc_cv_as_shf_merge = no; then
2904 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2905 [elf,2,12,0], [--fatal-warnings],
2906 [.section .rodata.str, "aMS", %progbits, 1])
2908 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2909 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2910 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2912 gcc_GAS_CHECK_FEATURE([stabs directive], gcc_cv_as_stabs_directive, ,,
2913 [.stabs "gcc2_compiled.",60,0,0,0],,
2914 [AC_DEFINE(HAVE_AS_STABS_DIRECTIVE, 1,
2915 [Define if your assembler supports .stabs.])])
2917 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)],
2918 gcc_cv_as_comdat_group,
2919 [elf,2,16,0], [--fatal-warnings],
2920 [.section .text,"axG",@progbits,.foo,comdat])
2921 if test $gcc_cv_as_comdat_group = yes; then
2922 gcc_cv_as_comdat_group_percent=no
2923 gcc_cv_as_comdat_group_group=no
2925 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
2926 gcc_cv_as_comdat_group_percent,
2927 [elf,2,16,0], [--fatal-warnings],
2928 [.section .text,"axG",%progbits,.foo,comdat])
2929 if test $gcc_cv_as_comdat_group_percent = yes; then
2930 gcc_cv_as_comdat_group_group=no
2933 # Sun as uses a completely different syntax.
2938 .group foo,".text%foo",#comdat
2939 .section ".text%foo", #alloc,#execinstr,#progbits
2944 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2946 .group foo,.text%foo,#comdat
2947 .section .text%foo, "ax", @progbits
2953 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
2954 gcc_cv_as_comdat_group_group,
2958 if test -z "${gcc_cv_as_comdat_group_group+set}"; then
2959 gcc_cv_as_comdat_group_group=no
2963 if test x"$ld_is_gold" = xyes; then
2965 elif test $in_tree_ld = yes ; then
2967 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 \
2968 && test $in_tree_ld_is_elf = yes; then
2971 elif echo "$ld_ver" | grep GNU > /dev/null; then
2973 if test 0"$ld_date" -lt 20050308; then
2974 if test -n "$ld_date"; then
2975 # If there was date string, but was earlier than 2005-03-08, fail
2977 elif test "$ld_vers_major" -lt 2; then
2979 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2986 *-*-solaris2.1[1-9]*)
2988 # Sun ld has COMDAT group support since Solaris 9, but it doesn't
2989 # interoperate with GNU as until Solaris 11 build 130, i.e. ld
2992 # If using Sun as for COMDAT group as emitted by GCC, one needs at
2993 # least ld version 1.2267.
2994 if test "$ld_vers_major" -gt 1; then
2996 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
2998 elif test "$ld_vers_minor" -ge 2267; then
3003 # Assume linkers other than GNU ld don't support COMDAT group.
3009 # Allow overriding the automatic COMDAT group tests above.
3010 AC_ARG_ENABLE(comdat,
3011 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
3012 [comdat_group="$enable_comdat"])
3013 if test $comdat_group = no; then
3014 gcc_cv_as_comdat_group=no
3015 gcc_cv_as_comdat_group_percent=no
3016 gcc_cv_as_comdat_group_group=no
3018 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
3019 [`if test $gcc_cv_as_comdat_group = yes \
3020 || test $gcc_cv_as_comdat_group_percent = yes \
3021 || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`],
3022 [Define 0/1 if your assembler and linker support COMDAT groups.])
3024 gcc_GAS_CHECK_FEATURE([line table discriminator support],
3025 gcc_cv_as_discriminator,
3029 .loc 1 1 0 discriminator 1],,
3030 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
3031 [Define if your assembler supports the .loc discriminator sub-directive.])])
3033 # Thread-local storage - the check is heavily parameterized.
3042 .section ".tdata","awT",@progbits
3045 ldq $27,__tls_get_addr($29) !literal!1
3046 lda $16,foo($29) !tlsgd!1
3047 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
3048 ldq $27,__tls_get_addr($29) !literal!2
3049 lda $16,foo($29) !tlsldm!2
3050 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
3051 ldq $1,foo($29) !gotdtprel
3052 ldah $2,foo($29) !dtprelhi
3053 lda $3,foo($2) !dtprello
3054 lda $4,foo($29) !dtprel
3055 ldq $1,foo($29) !gottprel
3056 ldah $2,foo($29) !tprelhi
3057 lda $3,foo($2) !tprello
3058 lda $4,foo($29) !tprel'
3061 tls_as_opt=--fatal-warnings
3063 cris-*-*|crisv32-*-*)
3065 .section ".tdata","awT",@progbits
3072 tls_as_opt=--fatal-warnings
3076 .section ".tdata","awT",@progbits
3088 .section ".tdata","awT",@progbits
3092 addil LT%foo-$tls_gdidx$,gp
3093 ldo RT%foo-$tls_gdidx$(%r1),%arg0
3096 addil LT%foo-$tls_ldidx$,gp
3098 ldo RT%foo-$tls_ldidx$(%r1),%arg0
3099 addil LR%foo-$tls_dtpoff$,%ret0
3100 ldo RR%foo-$tls_dtpoff$(%r1),%t1
3102 addil LT%foo-$tls_ieoff$,gp
3103 ldw RT%foo-$tls_ieoff$(%r1),%t2
3106 addil LR%foo-$tls_leoff$,%t1
3107 ldo RR%foo-$tls_leoff$(%r1),%t2'
3110 tls_as_opt=--fatal-warnings
3114 .section ".tdata","awT",%progbits
3125 i[34567]86-*-* | x86_64-*-*)
3127 i[34567]86-*-solaris2.* | x86_64-*-solaris2.1[0-9]*)
3134 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3136 .section .tdata,"awt",@progbits'
3141 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
3142 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
3146 .section ".tdata","awT",@progbits'
3150 tls_as_opt="--fatal-warnings"
3154 conftest_s="$conftest_s
3158 leal foo@tlsgd(,%ebx,1), %eax
3159 leal foo@tlsldm(%ebx), %eax
3160 leal foo@dtpoff(%eax), %edx
3161 movl foo@gottpoff(%ebx), %eax
3162 subl foo@gottpoff(%ebx), %eax
3163 addl foo@gotntpoff(%ebx), %eax
3164 movl foo@indntpoff, %eax
3165 movl \$foo@tpoff, %eax
3166 subl \$foo@tpoff, %eax
3167 leal foo@ntpoff(%ecx), %eax"
3170 if test x$on_solaris = xyes; then
3172 yes) tls_as_opt="$tls_as_opt --64" ;;
3173 no) tls_as_opt="$tls_as_opt -xarch=amd64" ;;
3176 conftest_s="$conftest_s
3180 leaq foo@tlsgd(%rip), %rdi
3181 leaq foo@tlsld(%rip), %rdi
3182 leaq foo@dtpoff(%rax), %rdx
3183 movq foo@gottpoff(%rip), %rax
3184 movq \$foo@tpoff, %rax"
3190 .section ".tdata","awT",@progbits
3193 addl r16 = @ltoff(@dtpmod(foo#)), gp
3194 addl r17 = @ltoff(@dtprel(foo#)), gp
3195 addl r18 = @ltoff(@tprel(foo#)), gp
3196 addl r19 = @dtprel(foo#), gp
3197 adds r21 = @dtprel(foo#), r13
3198 movl r23 = @dtprel(foo#)
3199 addl r20 = @tprel(foo#), gp
3200 adds r22 = @tprel(foo#), r13
3201 movl r24 = @tprel(foo#)'
3204 tls_as_opt=--fatal-warnings
3208 .section .tdata,"awT",@progbits
3212 addik r5,r20,x@TLSGD
3213 addik r5,r20,x@TLSLDM'
3216 tls_as_opt='--fatal-warnings'
3220 .section .tdata,"awT",@progbits
3224 addiu $4, $28, %tlsgd(x)
3225 addiu $4, $28, %tlsldm(x)
3226 lui $4, %dtprel_hi(x)
3227 addiu $4, $4, %dtprel_lo(x)
3228 lw $4, %gottprel(x)($28)
3229 lui $4, %tprel_hi(x)
3230 addiu $4, $4, %tprel_lo(x)'
3233 tls_as_opt='-32 --fatal-warnings'
3237 .section .tdata,"awT",@progbits
3242 move.l x@TLSGD(%a5),%a0
3243 move.l x@TLSLDM(%a5),%a0
3244 move.l x@TLSLDO(%a5),%a0
3245 move.l x@TLSIE(%a5),%a0
3246 move.l x@TLSLE(%a5),%a0'
3249 tls_as_opt='--fatal-warnings'
3253 .section ".tdata","awT",@progbits'
3256 tls_as_opt="--fatal-warnings"
3260 .section ".tdata","awT",%progbits
3264 add x0, x0, #:tlsgd_lo12:x
3269 tls_as_opt='--fatal-warnings'
3273 .extern __get_tpointer
3291 .section ".tdata","awT",@progbits
3299 addi 3,2,ld0@got@tlsgd
3305 addi 3,2,x1@got@tlsld
3311 addis 9,3,x2@dtprel@ha
3312 addi 9,9,x2@dtprel@l
3315 ld 9,x3@got@dtprel(2)
3321 tls_as_opt="-a64 --fatal-warnings"
3325 .section ".tdata","awT",@progbits
3333 addi 3,31,ld0@got@tlsgd
3335 addi 3,31,x1@got@tlsld
3338 addis 9,3,x2@dtprel@ha
3339 addi 9,9,x2@dtprel@l
3340 lwz 9,x3@got@tprel(31)
3343 addis 9,2,x2@tprel@ha
3344 addi 9,9,x2@tprel@l'
3347 tls_as_opt="-a32 --fatal-warnings"
3351 .section ".tdata","awT",@progbits
3360 l %r1,foo@GOTNTPOFF(%r12)
3361 l %r1,0(%r1):tls_load:foo
3362 bas %r14,0(%r1,%r13):tls_gdcall:foo
3363 bas %r14,0(%r1,%r13):tls_ldcall:foo'
3366 tls_as_opt="-m31 --fatal-warnings"
3370 .section ".tdata","awT",@progbits
3378 lg %r1,foo@GOTNTPOFF(%r12)
3379 larl %r1,foo@INDNTPOFF
3380 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
3381 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
3384 tls_as_opt="-m64 -Aesame --fatal-warnings"
3386 sh-*-* | sh[123456789lbe]*-*-*)
3388 .section ".tdata","awT",@progbits
3398 tls_as_opt=--fatal-warnings
3402 sparc*-sun-solaris2.*)
3409 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3411 .section ".tdata",#alloc,#write,#tls'
3416 .section ".tdata","awT",@progbits'
3419 tls_as_opt="-32 --fatal-warnings"
3421 conftest_s="$conftest_s
3424 sethi %tgd_hi22(foo), %o0
3425 add %o0, %tgd_lo10(foo), %o1
3426 add %l7, %o1, %o0, %tgd_add(foo)
3427 call __tls_get_addr, %tgd_call(foo)
3428 sethi %tldm_hi22(foo), %l1
3429 add %l1, %tldm_lo10(foo), %l2
3430 add %l7, %l2, %o0, %tldm_add(foo)
3431 call __tls_get_addr, %tldm_call(foo)
3432 sethi %tldo_hix22(foo), %l3
3433 xor %l3, %tldo_lox10(foo), %l4
3434 add %o0, %l4, %l5, %tldo_add(foo)
3435 sethi %tie_hi22(foo), %o3
3436 add %o3, %tie_lo10(foo), %o3
3437 ld [%l7 + %o3], %o2, %tie_ld(foo)
3438 add %g7, %o2, %o4, %tie_add(foo)
3439 sethi %tle_hix22(foo), %l1
3440 xor %l1, %tle_lox10(foo), %o5
3441 ld [%g7 + %o5], %o1"
3445 .section ".tdata","awT",@progbits
3448 addli r0, zero, tls_gd(foo)
3449 auli r0, zero, tls_gd_ha16(foo)
3450 addli r0, r0, tls_gd_lo16(foo)
3452 addli r0, zero, tls_ie(foo)
3453 auli r0, r0, tls_ie_ha16(foo)
3454 addli r0, r0, tls_ie_lo16(foo)'
3457 tls_as_opt="--fatal-warnings"
3461 .section ".tdata","awT",@progbits
3464 shl16insli r0, zero, hw0_last_tls_gd(foo)
3465 shl16insli r0, zero, hw1_last_tls_gd(foo)
3466 shl16insli r0, r0, hw0_tls_gd(foo)
3468 shl16insli r0, zero, hw1_last_tls_ie(foo)
3469 shl16insli r0, r0, hw0_tls_ie(foo)'
3472 tls_as_opt="--fatal-warnings"
3476 .section ".tdata","awT",@progbits
3479 movi a8, foo@TLSFUNC
3480 movi a10, foo@TLSARG
3481 callx8.tls a8, foo@TLSCALL'
3488 if test "x$enable_tls" = xno ; then
3489 : # TLS explicitly disabled.
3490 elif test "x$enable_tls" = xyes ; then
3491 set_have_as_tls=yes # TLS explicitly enabled.
3492 elif test -z "$tls_first_major"; then
3493 : # If we don't have a check, assume no support.
3495 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
3496 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
3497 [set_have_as_tls=yes])
3499 if test $set_have_as_tls = yes ; then
3500 AC_DEFINE(HAVE_AS_TLS, 1,
3501 [Define if your assembler and linker support thread-local storage.])
3504 # Target-specific assembler checks.
3506 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3507 gcc_cv_ld_static_dynamic=no
3508 gcc_cv_ld_static_option='-Bstatic'
3509 gcc_cv_ld_dynamic_option='-Bdynamic'
3510 if test $in_tree_ld = yes ; then
3511 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
3512 gcc_cv_ld_static_dynamic=yes
3514 elif test x$gcc_cv_ld != x; then
3515 # Check if linker supports -Bstatic/-Bdynamic option
3516 if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
3517 && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
3518 gcc_cv_ld_static_dynamic=yes
3521 # AIX ld uses -b flags
3522 *-*-aix4.[[23]]* | *-*-aix[[5-9]]*)
3523 gcc_cv_ld_static_dynamic=yes
3524 gcc_cv_ld_static_option="-bstatic"
3525 gcc_cv_ld_dynamic_option="-bdynamic"
3527 # HP-UX ld uses -a flags to select between shared and archive.
3529 if test x"$gnu_ld" = xno; then
3530 gcc_cv_ld_static_dynamic=yes
3531 gcc_cv_ld_static_option="-aarchive_shared"
3532 gcc_cv_ld_dynamic_option="-adefault"
3535 # Solaris 2 ld always supports -Bstatic/-Bdynamic.
3537 gcc_cv_ld_static_dynamic=yes
3542 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3543 AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3544 [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.])
3545 AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option",
3546 [Define to the linker option to disable use of shared objects.])
3547 AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option",
3548 [Define to the linker option to enable use of shared objects.])
3550 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3552 if test x"$demangler_in_ld" = xyes; then
3553 AC_MSG_CHECKING(linker --demangle support)
3554 gcc_cv_ld_demangle=no
3555 if test $in_tree_ld = yes; then
3556 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 \
3557 gcc_cv_ld_demangle=yes
3559 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3560 # Check if the GNU linker supports --demangle option
3561 if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3562 gcc_cv_ld_demangle=yes
3565 if test x"$gcc_cv_ld_demangle" = xyes; then
3566 AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3567 [Define if your linker supports --demangle option.])
3569 AC_MSG_RESULT($gcc_cv_ld_demangle)
3572 AC_MSG_CHECKING(linker plugin support)
3574 if test -f liblto_plugin.la; then
3575 save_ld_ver="$ld_ver"
3576 save_ld_vers_major="$ld_vers_major"
3577 save_ld_vers_minor="$ld_vers_minor"
3578 save_ld_is_gold="$ld_is_gold"
3582 if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
3584 # FIXME: ld_is_gold?
3585 ld_vers_major="$gcc_cv_gld_major_version"
3586 ld_vers_minor="$gcc_cv_gld_minor_version"
3588 # Determine plugin linker version.
3589 # FIXME: Partial duplicate from above, generalize.
3591 ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q`
3592 if echo "$ld_ver" | grep GNU > /dev/null; then
3593 if echo "$ld_ver" | grep "GNU gold" > /dev/null; then
3595 ld_vers=`echo $ld_ver | sed -n \
3596 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
3598 ld_vers=`echo $ld_ver | sed -n \
3599 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
3601 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
3602 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
3607 # Determine plugin support.
3608 if echo "$ld_ver" | grep GNU > /dev/null; then
3609 # Require GNU ld or gold 2.21+ for plugin support by default.
3610 if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then
3612 # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20.
3613 elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then
3618 ld_ver="$save_ld_ver"
3619 ld_vers_major="$save_ld_vers_major"
3620 ld_vers_minor="$save_ld_vers_minor"
3621 ld_is_gold="$save_ld_is_gold"
3623 AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin,
3624 [Define to the level of your linker's plugin support.])
3625 AC_MSG_RESULT($gcc_cv_lto_plugin)
3629 gcc_GAS_CHECK_FEATURE([-mabi option], gcc_cv_as_aarch64_mabi,,
3630 [-mabi=lp64], [.text],,,)
3631 if test x$gcc_cv_as_aarch64_mabi = xyes; then
3632 AC_DEFINE(HAVE_AS_MABI_OPTION, 1,
3633 [Define if your assembler supports the -mabi option.])
3635 if test x$with_abi = xilp32; then
3636 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3637 Upgrade the Assembler.])
3639 if test x"$with_multilib_list" = xdefault; then
3640 TM_MULTILIB_CONFIG=lp64
3642 aarch64_multilibs=`echo $with_multilib_list | sed -e 's/,/ /g'`
3643 for aarch64_multilib in ${aarch64_multilibs}; do
3644 case ${aarch64_multilib} in
3646 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3647 Upgrade the Assembler.])
3655 # Check if we have binutils support for relocations types needed by -fpic
3656 gcc_GAS_CHECK_FEATURE([-fpic relocs], gcc_cv_as_aarch64_picreloc,,,
3659 ldr x0, [[x2, #:gotpage_lo15:globalsym]]
3660 ],,[AC_DEFINE(HAVE_AS_SMALL_PIC_RELOCS, 1,
3661 [Define if your assembler supports relocs needed by -fpic.])])
3662 # Enable default workaround for AArch64 Cortex-A53 erratum 835769.
3663 AC_ARG_ENABLE(fix-cortex-a53-835769,
3665 AS_HELP_STRING([--enable-fix-cortex-a53-835769],
3666 [enable workaround for AArch64 Cortex-A53 erratum 835769 by default])
3667 AS_HELP_STRING([--disable-fix-cortex-a53-835769],
3668 [disable workaround for AArch64 Cortex-A53 erratum 835769 by default])
3673 tm_defines="${tm_defines} TARGET_FIX_ERR_A53_835769_DEFAULT=1"
3678 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-835769.\
3679 Valid choices are 'yes' and 'no'.])
3685 # Enable default workaround for AArch64 Cortex-A53 erratum 843419.
3686 AC_ARG_ENABLE(fix-cortex-a53-843419,
3688 AS_HELP_STRING([--enable-fix-cortex-a53-843419],
3689 [enable workaround for AArch64 Cortex-A53 erratum 843419 by default])
3690 AS_HELP_STRING([--disable-fix-cortex-a53-843419],
3691 [disable workaround for AArch64 Cortex-A53 erratum 843419 by default])
3696 tm_defines="${tm_defines} TARGET_FIX_ERR_A53_843419_DEFAULT=1"
3701 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-843419.\
3702 Valid choices are 'yes' and 'no'.])
3710 # All TARGET_ABI_OSF targets.
3711 alpha*-*-linux* | alpha*-*-*bsd*)
3712 gcc_GAS_CHECK_FEATURE([explicit relocation support],
3713 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3716 extbl $3, $2, $3 !lituse_bytoff!1
3717 ldq $2, a($29) !literal!1
3718 ldq $4, b($29) !literal!2
3719 ldq_u $3, 0($2) !lituse_base!1
3720 ldq $27, f($29) !literal!5
3721 jsr $26, ($27), f !lituse_jsr!5
3722 ldah $29, 0($26) !gpdisp!3
3723 lda $0, c($29) !gprel
3724 ldah $1, d($29) !gprelhigh
3725 lda $1, d($1) !gprellow
3726 lda $29, 0($29) !gpdisp!3],,
3727 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3728 [Define if your assembler supports explicit relocations.])])
3729 gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3730 gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3733 ldq $27, a($29) !literal!1
3734 jsr $26, ($27), a !lituse_jsrdirect!1],,
3735 [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3736 [Define if your assembler supports the lituse_jsrdirect relocation.])])
3740 gcc_GAS_CHECK_FEATURE([--mlink-relax option], gcc_cv_as_avr_mlink_relax,,
3741 [--mlink-relax], [.text],,
3742 [AC_DEFINE(HAVE_AS_AVR_MLINK_RELAX_OPTION, 1,
3743 [Define if your avr assembler supports --mlink-relax option.])])
3745 gcc_GAS_CHECK_FEATURE([-mrmw option], gcc_cv_as_avr_mrmw,,
3747 [AC_DEFINE(HAVE_AS_AVR_MRMW_OPTION, 1,
3748 [Define if your avr assembler supports -mrmw option.])])
3752 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3753 gcc_cv_as_cris_no_mul_bug,[2,15,91],
3754 [-no-mul-bug-abort], [.text],,
3755 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3756 [Define if your assembler supports the -no-mul-bug-abort option.])])
3760 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3761 [.register %g2, #scratch],,
3762 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3763 [Define if your assembler supports .register.])])
3765 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3767 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3768 [Define if your assembler supports -relax option.])])
3770 gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3771 gcc_cv_as_sparc_gotdata_op,,
3778 sethi %gdop_hix22(foo), %g1
3779 xor %g1, %gdop_lox10(foo), %g1
3780 ld [[%l7 + %g1]], %g2, %gdop(foo)],
3781 [if test x$gcc_cv_ld != x \
3782 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3783 if test x$gcc_cv_objdump != x; then
3784 if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3785 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3786 gcc_cv_as_sparc_gotdata_op=no
3788 gcc_cv_as_sparc_gotdata_op=yes
3793 [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3794 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3796 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3797 gcc_cv_as_sparc_ua_pcrel,,
3805 .uaword %r_disp32(foo)],
3806 [if test x$gcc_cv_ld != x \
3807 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3808 gcc_cv_as_sparc_ua_pcrel=yes
3811 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3812 [Define if your assembler and linker support unaligned PC relative relocs.])
3814 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3815 gcc_cv_as_sparc_ua_pcrel_hidden,,
3820 .uaword %r_disp32(foo)
3821 .byte 0x32, 0x33, 0x34
3826 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3827 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3828 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3829 | grep ' 31000000 07323334' > /dev/null 2>&1; then
3830 if $gcc_cv_objdump -R conftest 2> /dev/null \
3831 | grep 'DISP32' > /dev/null 2>&1; then
3834 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3838 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3839 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3840 ]) # unaligned pcrel relocs
3842 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3843 gcc_cv_as_sparc_offsetable_lo10,,
3846 or %g1, %lo(ab) + 12, %g1
3847 or %g1, %lo(ab + 12), %g1],
3848 [if test x$gcc_cv_objdump != x \
3849 && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3850 | grep ' 82106000 82106000' > /dev/null 2>&1; then
3851 gcc_cv_as_sparc_offsetable_lo10=yes
3853 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3854 [Define if your assembler supports offsetable %lo().])])
3856 gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions],
3857 gcc_cv_as_sparc_fmaf,,
3860 .register %g2, #scratch
3861 .register %g3, #scratch
3863 fmaddd %f0, %f2, %f4, %f6
3864 addxccc %g1, %g2, %g3
3865 fsrl32 %f2, %f4, %f8
3866 fnaddd %f10, %f12, %f14],,
3867 [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1,
3868 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])])
3870 gcc_GAS_CHECK_FEATURE([SPARC4 instructions],
3871 gcc_cv_as_sparc_sparc4,,
3874 .register %g2, #scratch
3875 .register %g3, #scratch
3878 1: cwbneg %g2, %g3, 1f
3881 aes_kexpand0 %f4, %f6, %f8
3882 des_round %f38, %f40, %f42, %f44
3883 camellia_f %f54, %f56, %f58, %f60
3884 kasumi_fi_xor %f46, %f48, %f50, %f52],,
3885 [AC_DEFINE(HAVE_AS_SPARC4, 1,
3886 [Define if your assembler supports SPARC4 instructions.])])
3888 gcc_GAS_CHECK_FEATURE([LEON instructions],
3889 gcc_cv_as_sparc_leon,,
3892 .register %g2, #scratch
3893 .register %g3, #scratch
3897 casa [[%g2]] 0xb, %g3, %g1],,
3898 [AC_DEFINE(HAVE_AS_LEON, 1,
3899 [Define if your assembler supports LEON instructions.])])
3903 i[34567]86-*-* | x86_64-*-*)
3907 # Full C++ conformance when using a shared libstdc++-v3 requires some
3908 # support from the Cygwin DLL, which in more recent versions exports
3909 # wrappers to aid in interposing and redirecting operators new, delete,
3910 # etc., as per n2800 #17.6.4.6 [replacement.functions]. Check if we
3911 # are configuring for a version of Cygwin that exports the wrappers.
3912 if test x$host = x$target && test x$host_cpu = xi686; then
3913 AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3915 # Can't check presence of libc functions during cross-compile, so
3916 # we just have to assume we're building for an up-to-date target.
3917 gcc_ac_cygwin_dll_wrappers=yes
3919 AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3920 [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3921 [Define if you want to generate code by default that assumes that the
3922 Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3925 cygwin* | pe | mingw32* | interix*)
3926 # Recent binutils allows the three-operand form of ".comm" on PE. This
3927 # definition is used unconditionally to initialise the default state of
3928 # the target option variable that governs usage of the feature.
3929 gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3930 [2,19,52],,[.comm foo,1,32])
3931 AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3932 [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3933 [Define if your assembler supports specifying the alignment
3934 of objects allocated using the GAS .comm command.])
3935 # Used for DWARF 2 in PE
3936 gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3937 gcc_cv_as_ix86_pe_secrel32,
3943 [if test x$gcc_cv_ld != x \
3944 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3945 gcc_cv_as_ix86_pe_secrel32=yes
3948 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3949 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3950 # Test if the assembler supports the extended form of the .section
3951 # directive that specifies section alignment. LTO support uses this,
3952 # but normally only after installation, so we warn but don't fail the
3953 # configure if LTO is enabled but the assembler does not support it.
3954 gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3955 [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3956 if test x$gcc_cv_as_section_has_align != xyes; then
3957 case ",$enable_languages," in
3959 AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3966 # Test if the assembler supports the section flag 'e' for specifying
3967 # an excluded section.
3968 gcc_GAS_CHECK_FEATURE([.section with e], gcc_cv_as_section_has_e,
3969 [2,22,51], [--fatal-warnings],
3972 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3973 [`if test $gcc_cv_as_section_has_e = yes; then echo 1; else echo 0; fi`],
3974 [Define if your assembler supports specifying the section flag e.])
3976 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3977 gcc_cv_as_ix86_filds,,,
3978 [filds (%ebp); fists (%ebp)],,
3979 [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3980 [Define if your assembler uses filds and fists mnemonics.])])
3982 gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3983 gcc_cv_as_ix86_fildq,,,
3984 [fildq (%ebp); fistpq (%ebp)],,
3985 [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3986 [Define if your assembler uses fildq and fistq mnemonics.])])
3988 gcc_GAS_CHECK_FEATURE([cmov syntax],
3989 gcc_cv_as_ix86_cmov_sun_syntax,,,
3990 [cmovl.l %edx, %eax],,
3991 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3992 [Define if your assembler supports the Sun syntax for cmov.])])
3994 gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3995 gcc_cv_as_ix86_ffreep,,,
3997 [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3998 [Define if your assembler supports the ffreep mnemonic.])])
4000 gcc_GAS_CHECK_FEATURE([.quad directive],
4001 gcc_cv_as_ix86_quad,,,
4003 [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
4004 [Define if your assembler supports the .quad directive.])])
4006 gcc_GAS_CHECK_FEATURE([sahf mnemonic],
4007 gcc_cv_as_ix86_sahf,,,
4010 [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
4011 [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
4013 gcc_GAS_CHECK_FEATURE([interunit movq mnemonic],
4014 gcc_cv_as_ix86_interunit_movq,,,
4018 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_INTERUNIT_MOVQ,
4019 [`if test $gcc_cv_as_ix86_interunit_movq = yes; then echo 1; else echo 0; fi`],
4020 [Define if your assembler supports interunit movq mnemonic.])
4022 gcc_GAS_CHECK_FEATURE([hle prefixes],
4023 gcc_cv_as_ix86_hle,,,
4024 [lock xacquire cmpxchg %esi, (%ecx)],,
4025 [AC_DEFINE(HAVE_AS_IX86_HLE, 1,
4026 [Define if your assembler supports HLE prefixes.])])
4028 gcc_GAS_CHECK_FEATURE([swap suffix],
4029 gcc_cv_as_ix86_swap,,,
4030 [movl.s %esp, %ebp],,
4031 [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
4032 [Define if your assembler supports the swap suffix.])])
4034 gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
4035 gcc_cv_as_ix86_diff_sect_delta,,,
4043 [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
4044 [Define if your assembler supports the subtraction of symbols in different sections.])])
4046 # These two are used unconditionally by i386.[ch]; it is to be defined
4047 # to 1 if the feature is present, 0 otherwise.
4048 as_ix86_gotoff_in_data_opt=
4049 if test x$gas = xyes; then
4050 as_ix86_gotoff_in_data_opt="--32"
4052 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
4053 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],
4054 [$as_ix86_gotoff_in_data_opt],
4060 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
4061 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
4062 [Define true if the assembler supports '.long foo@GOTOFF'.])
4064 gcc_GAS_CHECK_FEATURE([rep and lock prefix],
4065 gcc_cv_as_ix86_rep_lock_prefix,,,
4071 lock addl %edi, (%eax,%esi)
4072 lock orl $0, (%esp)],,
4073 [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
4074 [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
4076 gcc_GAS_CHECK_FEATURE([ud2 mnemonic],
4077 gcc_cv_as_ix86_ud2,,,
4079 [AC_DEFINE(HAVE_AS_IX86_UD2, 1,
4080 [Define if your assembler supports the 'ud2' mnemonic.])])
4082 gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
4083 gcc_cv_as_ix86_tlsgdplt,,,
4084 [call tls_gd@tlsgdplt],
4085 [if test x$gcc_cv_ld != x \
4086 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
4087 gcc_cv_as_ix86_tlsgdplt=yes
4090 [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
4091 [Define if your assembler and linker support @tlsgdplt.])])
4094 .section .tdata,"aw'$tls_section_flag'",@progbits
4096 .section .text,"ax",@progbits
4097 call tls_ld@tlsldmplt'
4098 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
4099 gcc_cv_as_ix86_tlsldmplt,,,
4101 [if test x$gcc_cv_ld != x \
4102 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
4103 gcc_cv_as_ix86_tlsldmplt=yes
4106 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDMPLT,
4107 [`if test $gcc_cv_as_ix86_tlsldmplt = yes; then echo 1; else echo 0; fi`],
4108 [Define to 1 if your assembler and linker support @tlsldmplt.])
4110 # Enforce 32-bit output with gas and gld.
4111 if test x$gas = xyes; then
4112 as_ix86_tls_ldm_opt="--32"
4114 if echo "$ld_ver" | grep GNU > /dev/null; then
4115 if $gcc_cv_ld -V 2>/dev/null | grep elf_i386_sol2 > /dev/null; then
4116 ld_ix86_tls_ldm_opt="-melf_i386_sol2"
4118 ld_ix86_tls_ldm_opt="-melf_i386"
4122 .section .text,"ax",@progbits
4124 .type _start, @function
4126 leal value@tlsldm(%ebx), %eax
4127 call ___tls_get_addr@plt
4129 .section .tdata,"aw'$tls_section_flag'",@progbits
4130 .type value, @object
4132 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM reloc],
4133 gcc_cv_as_ix86_tlsldm,,
4134 [$as_ix86_tls_ldm_opt],
4136 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
4137 && $gcc_cv_ld $ld_ix86_tls_ldm_opt -o conftest conftest.o $ld_tls_libs -lc > /dev/null 2>&1; then
4138 if $gcc_cv_objdump -d conftest 2>/dev/null | grep nop > /dev/null \
4139 || dis conftest 2>/dev/null | grep nop > /dev/null; then
4140 gcc_cv_as_ix86_tlsldm=yes
4144 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDM,
4145 [`if test $gcc_cv_as_ix86_tlsldm = yes; then echo 1; else echo 0; fi`],
4146 [Define to 1 if your assembler and linker support @tlsldm.])
4151 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
4152 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
4154 addl r15 = @ltoffx(x#), gp
4156 ld8.mov r16 = [[r15]], x#],,
4157 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
4158 [Define if your assembler supports ltoffx and ldxmov relocations.])])
4164 *-*-aix*) conftest_s=' .machine "pwr5"
4168 gcc_GAS_CHECK_FEATURE([.machine directive support],
4169 gcc_cv_as_machine_directive,,,
4170 [ .machine ppc7400])
4171 if test x$gcc_cv_as_machine_directive != xyes; then
4172 echo "*** This target requires an assembler supporting \".machine\"" >&2
4173 echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
4174 test x$build = x$target && exit 1
4178 *) conftest_s=' .machine power4
4183 gcc_GAS_CHECK_FEATURE([mfcr field support],
4184 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
4186 [AC_DEFINE(HAVE_AS_MFCRF, 1,
4187 [Define if your assembler supports mfcr field.])])
4190 *-*-aix*) conftest_s=' .machine "pwr5"
4193 *) conftest_s=' .machine power5
4198 gcc_GAS_CHECK_FEATURE([popcntb support],
4199 gcc_cv_as_powerpc_popcntb, [2,17,0],,
4201 [AC_DEFINE(HAVE_AS_POPCNTB, 1,
4202 [Define if your assembler supports popcntb field.])])
4205 *-*-aix*) conftest_s=' .machine "pwr5x"
4208 *) conftest_s=' .machine power5
4213 gcc_GAS_CHECK_FEATURE([fp round support],
4214 gcc_cv_as_powerpc_fprnd, [2,17,0],,
4216 [AC_DEFINE(HAVE_AS_FPRND, 1,
4217 [Define if your assembler supports fprnd.])])
4220 *-*-aix*) conftest_s=' .machine "pwr6"
4223 *) conftest_s=' .machine power6
4228 gcc_GAS_CHECK_FEATURE([move fp gpr support],
4229 gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
4231 [AC_DEFINE(HAVE_AS_MFPGPR, 1,
4232 [Define if your assembler supports mffgpr and mftgpr.])])
4235 *-*-aix*) conftest_s=' .csect .text[[PR]]
4237 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
4241 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
4242 *) conftest_s=' .text
4244 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
4247 gcc_GAS_CHECK_FEATURE([rel16 relocs],
4248 gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
4250 [AC_DEFINE(HAVE_AS_REL16, 1,
4251 [Define if your assembler supports R_PPC_REL16 relocs.])])
4254 *-*-aix*) conftest_s=' .machine "pwr6"
4257 *) conftest_s=' .machine power6
4262 gcc_GAS_CHECK_FEATURE([compare bytes support],
4263 gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
4265 [AC_DEFINE(HAVE_AS_CMPB, 1,
4266 [Define if your assembler supports cmpb.])])
4269 *-*-aix*) conftest_s=' .machine "pwr6"
4272 *) conftest_s=' .machine power6
4277 gcc_GAS_CHECK_FEATURE([decimal float support],
4278 gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
4280 [AC_DEFINE(HAVE_AS_DFP, 1,
4281 [Define if your assembler supports DFP instructions.])])
4284 *-*-aix*) conftest_s=' .machine "pwr7"
4287 *) conftest_s=' .machine power7
4292 gcc_GAS_CHECK_FEATURE([vector-scalar support],
4293 gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
4295 [AC_DEFINE(HAVE_AS_VSX, 1,
4296 [Define if your assembler supports VSX instructions.])])
4299 *-*-aix*) conftest_s=' .machine "pwr7"
4302 *) conftest_s=' .machine power7
4307 gcc_GAS_CHECK_FEATURE([popcntd support],
4308 gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
4310 [AC_DEFINE(HAVE_AS_POPCNTD, 1,
4311 [Define if your assembler supports POPCNTD instructions.])])
4314 *-*-aix*) conftest_s=' .machine "pwr8"
4315 .csect .text[[PR]]';;
4316 *) conftest_s=' .machine power8
4320 gcc_GAS_CHECK_FEATURE([power8 support],
4321 gcc_cv_as_powerpc_power8, [2,19,2], -a32,
4323 [AC_DEFINE(HAVE_AS_POWER8, 1,
4324 [Define if your assembler supports POWER8 instructions.])])
4327 *-*-aix*) conftest_s=' .machine "pwr9"
4328 .csect .text[[PR]]';;
4329 *) conftest_s=' .machine power9
4333 gcc_GAS_CHECK_FEATURE([power9 support],
4334 gcc_cv_as_powerpc_power9, [2,19,2], -a32,
4336 [AC_DEFINE(HAVE_AS_POWER9, 1,
4337 [Define if your assembler supports POWER9 instructions.])])
4340 *-*-aix*) conftest_s=' .csect .text[[PR]]
4342 *) conftest_s=' .text
4346 gcc_GAS_CHECK_FEATURE([lwsync support],
4347 gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
4349 [AC_DEFINE(HAVE_AS_LWSYNC, 1,
4350 [Define if your assembler supports LWSYNC instructions.])])
4353 *-*-aix*) conftest_s=' .machine "476"
4356 *) conftest_s=' .machine "476"
4361 gcc_GAS_CHECK_FEATURE([data cache invalidate support],
4362 gcc_cv_as_powerpc_dci, [9,99,0], -a32,
4364 [AC_DEFINE(HAVE_AS_DCI, 1,
4365 [Define if your assembler supports the DCI/ICI instructions.])])
4367 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4368 gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
4369 [.gnu_attribute 4,1],,
4370 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4371 [Define if your assembler supports .gnu_attribute.])])
4373 gcc_GAS_CHECK_FEATURE([tls marker support],
4374 gcc_cv_as_powerpc_tls_markers, [2,20,0],,
4375 [ bl __tls_get_addr(x@tlsgd)],,
4376 [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
4377 [Define if your assembler supports arg info for __tls_get_addr.])])
4379 gcc_GAS_CHECK_FEATURE([prologue entry point marker support],
4380 gcc_cv_as_powerpc_entry_markers, [2,26,0],-a64 --fatal-warnings,
4381 [ .reloc .,R_PPC64_ENTRY; nop],,
4382 [AC_DEFINE(HAVE_AS_ENTRY_MARKERS, 1,
4383 [Define if your assembler supports the R_PPC64_ENTRY relocation.])])
4387 gcc_GAS_CHECK_FEATURE([.ref support],
4388 gcc_cv_as_aix_ref, [2,21,0],,
4389 [ .csect stuff[[rw]]
4395 [AC_DEFINE(HAVE_AS_REF, 1,
4396 [Define if your assembler supports .ref])])
4402 gcc_GAS_CHECK_FEATURE([dwarf location lists section support],
4403 gcc_cv_as_aix_dwloc, [2,21,0],,
4406 [AC_DEFINE(HAVE_XCOFF_DWARF_EXTRAS, 1,
4407 [Define if your assembler supports .dwsect 0xB0000])])
4413 gcc_GAS_CHECK_FEATURE([explicit relocation support],
4414 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
4415 [ lw $4,%gp_rel(foo)($4)],,
4416 [if test x$target_cpu_default = x
4417 then target_cpu_default=MASK_EXPLICIT_RELOCS
4418 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
4421 gcc_GAS_CHECK_FEATURE([-mno-shared support],
4422 gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
4423 [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
4424 [Define if the assembler understands -mno-shared.])])
4426 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4427 gcc_cv_as_mips_gnu_attribute, [2,18,0],,
4428 [.gnu_attribute 4,1],,
4429 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4430 [Define if your assembler supports .gnu_attribute.])])
4432 gcc_GAS_CHECK_FEATURE([.module support],
4433 gcc_cv_as_mips_dot_module,,[-32],
4436 [AC_DEFINE(HAVE_AS_DOT_MODULE, 1,
4437 [Define if your assembler supports .module.])])
4438 if test x$gcc_cv_as_mips_dot_module = xno \
4439 && test x$with_fp_32 != x; then
4441 [Requesting --with-fp-32= requires assembler support for .module.])
4444 gcc_GAS_CHECK_FEATURE([.micromips support],
4445 gcc_cv_as_micromips_support,,[--fatal-warnings],
4447 [AC_DEFINE(HAVE_GAS_MICROMIPS, 1,
4448 [Define if your assembler supports the .set micromips directive])])
4450 gcc_GAS_CHECK_FEATURE([.dtprelword support],
4451 gcc_cv_as_mips_dtprelword, [2,18,0],,
4452 [.section .tdata,"awT",@progbits
4456 .dtprelword x+0x8000],,
4457 [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
4458 [Define if your assembler supports .dtprelword.])])
4460 gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
4461 gcc_cv_as_mips_dspr1_mult,,,
4471 [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
4472 [Define if your assembler supports DSPR1 mult.])])
4474 AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
4475 gcc_cv_as_ld_jalr_reloc=no
4476 if test $gcc_cv_as_mips_explicit_relocs = yes; then
4477 if test $in_tree_ld = yes ; then
4478 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 \
4479 && test $in_tree_ld_is_elf = yes; then
4480 gcc_cv_as_ld_jalr_reloc=yes
4482 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
4483 echo ' .ent x' > conftest.s
4484 echo 'x: lw $2,%got_disp(y)($3)' >> conftest.s
4485 echo ' lw $25,%call16(y)($28)' >> conftest.s
4486 echo ' .reloc 1f,R_MIPS_JALR,y' >> conftest.s
4487 echo '1: jalr $25' >> conftest.s
4488 echo ' .reloc 1f,R_MIPS_JALR,x' >> conftest.s
4489 echo '1: jalr $25' >> conftest.s
4490 echo ' .end x' >> conftest.s
4491 if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
4492 && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
4493 if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
4494 && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
4495 gcc_cv_as_ld_jalr_reloc=yes
4501 if test $gcc_cv_as_ld_jalr_reloc = yes; then
4502 if test x$target_cpu_default = x; then
4503 target_cpu_default=MASK_RELAX_PIC_CALLS
4505 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
4508 AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
4510 AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
4511 [gcc_cv_ld_mips_personality_relaxation],
4512 [gcc_cv_ld_mips_personality_relaxation=no
4513 if test $in_tree_ld = yes ; then
4514 if test "$gcc_cv_gld_major_version" -eq 2 \
4515 -a "$gcc_cv_gld_minor_version" -ge 21 \
4516 -o "$gcc_cv_gld_major_version" -gt 2; then
4517 gcc_cv_ld_mips_personality_relaxation=yes
4519 elif test x$gcc_cv_as != x \
4520 -a x$gcc_cv_ld != x \
4521 -a x$gcc_cv_readelf != x ; then
4522 cat > conftest.s <<EOF
4524 .cfi_personality 0x80,indirect_ptr
4531 .section .data,"aw",@progbits
4535 if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
4536 && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
4537 if $gcc_cv_readelf -d conftest 2>&1 \
4538 | grep TEXTREL > /dev/null 2>&1; then
4540 elif $gcc_cv_readelf --relocs conftest 2>&1 \
4541 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
4544 gcc_cv_ld_mips_personality_relaxation=yes
4548 rm -f conftest.s conftest.o conftest])
4549 if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
4550 AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
4551 [Define if your linker can relax absolute .eh_frame personality
4552 pointers into PC-relative form.])
4555 gcc_GAS_CHECK_FEATURE([-mnan= support],
4556 gcc_cv_as_mips_nan,,
4558 [AC_DEFINE(HAVE_AS_NAN, 1,
4559 [Define if the assembler understands -mnan=.])])
4560 if test x$gcc_cv_as_mips_nan = xno \
4561 && test x$with_nan != x; then
4563 [Requesting --with-nan= requires assembler support for -mnan=])
4567 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4568 gcc_cv_as_s390_gnu_attribute, [2,18,0],,
4569 [.gnu_attribute 8,1],,
4570 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4571 [Define if your assembler supports .gnu_attribute.])])
4572 gcc_GAS_CHECK_FEATURE([.machine and .machinemode support],
4573 gcc_cv_as_s390_machine_machinemode, [2,24,0],,
4578 [AC_DEFINE(HAVE_AS_MACHINE_MACHINEMODE, 1,
4579 [Define if your assembler supports .machine and .machinemode.])])
4580 gcc_GAS_CHECK_FEATURE([architecture modifiers support],
4581 gcc_cv_as_s390_architecture_modifiers, [2,26,0],,
4582 [ .machine z13+vx ],,
4583 [AC_DEFINE(HAVE_AS_ARCHITECTURE_MODIFIERS, 1,
4584 [Define if your assembler supports architecture modifiers.])])
4588 # Mips and HP-UX need the GNU assembler.
4589 # Linux on IA64 might be able to use the Intel assembler.
4592 mips*-*-* | *-*-hpux* )
4593 if test x$gas_flag = xyes \
4594 || test x"$host" != x"$build" \
4595 || test ! -x "$gcc_cv_as" \
4596 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
4599 echo "*** This configuration requires the GNU assembler" >&2
4605 # ??? Not all targets support dwarf2 debug_line, even within a version
4606 # of gas. Moreover, we need to emit a valid instruction to trigger any
4607 # info to the output file. So, as supported targets are added to gas 2.11,
4608 # add some instruction here to (also) show we expect this might work.
4609 # ??? Once 2.11 is released, probably need to add first known working
4610 # version to the per-target configury.
4612 aarch64 | alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze \
4613 | mips | nios2 | pa | rs6000 | score | sparc | spu | tilegx | tilepro \
4614 | visium | xstormy16 | xtensa)
4624 if test x"$insn" != x; then
4626 .file 1 \"conftest.s\"
4629 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
4630 gcc_cv_as_dwarf2_debug_line,
4631 [elf,2,11,0],, [$conftest_s],
4632 [if test x$gcc_cv_objdump != x \
4633 && $gcc_cv_objdump -h conftest.o 2> /dev/null \
4634 | grep debug_line > /dev/null 2>&1; then
4635 gcc_cv_as_dwarf2_debug_line=yes
4638 # The .debug_line file table must be in the exact order that
4639 # we specified the files, since these indices are also used
4640 # by DW_AT_decl_file. Approximate this test by testing if
4641 # the assembler bitches if the same index is assigned twice.
4642 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
4643 gcc_cv_as_dwarf2_file_buggy,,,
4647 if test $gcc_cv_as_dwarf2_debug_line = yes \
4648 && test $gcc_cv_as_dwarf2_file_buggy = no; then
4649 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
4650 [Define if your assembler supports dwarf2 .file/.loc directives,
4651 and preserves file table indices exactly as given.])
4654 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
4655 gcc_cv_as_gdwarf2_flag,
4656 [elf,2,11,0], [--gdwarf2], [$insn],,
4657 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
4658 [Define if your assembler supports the --gdwarf2 option.])])
4660 gcc_GAS_CHECK_FEATURE([--gstabs option],
4661 gcc_cv_as_gstabs_flag,
4662 [elf,2,11,0], [--gstabs], [$insn],,
4663 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
4664 [Define if your assembler supports the --gstabs option.])])
4666 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
4667 gcc_cv_as_debug_prefix_map_flag,
4668 [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
4669 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
4670 [Define if your assembler supports the --debug-prefix-map option.])])
4673 gcc_GAS_CHECK_FEATURE([compressed debug sections],
4674 gcc_cv_as_compress_debug,,[--compress-debug-sections],,
4675 [# gas compiled without zlib cannot compress debug sections and warns
4676 # about it, but still exits successfully. So check for this, too.
4677 if $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null
4679 gcc_cv_as_compress_debug=0
4680 elif $gcc_cv_as --compress-debug-sections -o conftest.o conftest.s > /dev/null 2>&1
4682 gcc_cv_as_compress_debug=1
4683 gcc_cv_as_compress_debug_option="--compress-debug-sections"
4684 gcc_cv_as_no_compress_debug_option="--nocompress-debug-sections"
4686 gcc_cv_as_compress_debug=0
4687 # FIXME: Future gas versions will support ELF gABI style via
4688 # --compress-debug-sections[=type].
4690 AC_DEFINE_UNQUOTED(HAVE_AS_COMPRESS_DEBUG, $gcc_cv_as_compress_debug,
4691 [Define to the level of your assembler's compressed debug section support.])
4692 AC_DEFINE_UNQUOTED(AS_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_compress_debug_option",
4693 [Define to the assembler option to enable compressed debug sections.])
4694 AC_DEFINE_UNQUOTED(AS_NO_COMPRESS_DEBUG_OPTION, "$gcc_cv_as_no_compress_debug_option",
4695 [Define to the assembler option to disable compressed debug sections.])
4697 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
4700 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
4701 [Define if your assembler supports .lcomm with an alignment field.])])
4703 if test x$with_sysroot = x && test x$host = x$target \
4704 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4705 && test "$prefix" != "NONE"; then
4706 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4707 [Define to PREFIX/include if cpp should also search that directory.])
4710 # Determine the version of glibc, if any, used on the target.
4711 AC_MSG_CHECKING([for target glibc version])
4712 AC_ARG_WITH([glibc-version],
4713 [AS_HELP_STRING([--with-glibc-version=M.N],
4714 [assume GCC used with glibc version M.N or later])], [
4715 if [echo "$with_glibc_version" | grep '^[0-9][0-9]*\.[0-9][0-9]*$']; then
4716 glibc_version_major=`echo "$with_glibc_version" | sed -e 's/\..*//'`
4717 glibc_version_minor=`echo "$with_glibc_version" | sed -e 's/.*\.//'`
4719 AC_MSG_ERROR([option --with-glibc-version requires a version number M.N])
4721 glibc_version_major=0
4722 glibc_version_minor=0
4723 [if test -f $target_header_dir/features.h \
4724 && glibc_version_major_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+[0-9]' $target_header_dir/features.h` \
4725 && glibc_version_minor_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+[0-9]' $target_header_dir/features.h`; then
4726 glibc_version_major=`echo "$glibc_version_major_define" | sed -e 's/.*__GLIBC__[ ]*//'`
4727 glibc_version_minor=`echo "$glibc_version_minor_define" | sed -e 's/.*__GLIBC_MINOR__[ ]*//'`
4729 AC_MSG_RESULT([$glibc_version_major.$glibc_version_minor])
4730 AC_DEFINE_UNQUOTED([TARGET_GLIBC_MAJOR], [$glibc_version_major],
4731 [GNU C Library major version number used on the target, or 0.])
4732 AC_DEFINE_UNQUOTED([TARGET_GLIBC_MINOR], [$glibc_version_minor],
4733 [GNU C Library minor version number used on the target, or 0.])
4735 AC_ARG_ENABLE(gnu-unique-object,
4736 [AS_HELP_STRING([--enable-gnu-unique-object],
4737 [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
4738 [case $enable_gnu_unique_object in
4740 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
4741 Valid choices are 'yes' and 'no'.]) ;;
4743 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
4745 [.type foo, '$target_type_format_char'gnu_unique_object],,
4746 # We need to unquote above to to use the definition from config.gcc.
4747 # Also check for ld.so support, i.e. glibc 2.11 or higher.
4748 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [11], [enable_gnu_unique_object=yes], )]
4750 if test x$enable_gnu_unique_object = xyes; then
4751 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
4752 [Define if your assembler supports @gnu_unique_object.])
4755 AC_CACHE_CHECK([assembler for tolerance to line number 0],
4756 [gcc_cv_as_line_zero],
4757 [gcc_cv_as_line_zero=no
4758 if test $in_tree_gas = yes; then
4759 gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
4760 elif test "x$gcc_cv_as" != x; then
4761 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
4762 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
4763 test "x`cat conftest.out`" = x
4765 gcc_cv_as_line_zero=yes
4767 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
4768 cat conftest.s >&AS_MESSAGE_LOG_FD
4769 echo "configure: error output was" >&AS_MESSAGE_LOG_FD
4770 cat conftest.out >&AS_MESSAGE_LOG_FD
4772 rm -f conftest.o conftest.s conftest.out
4774 if test "x$gcc_cv_as_line_zero" = xyes; then
4775 AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
4776 [Define if the assembler won't complain about a line such as # 0 "" 2.])
4779 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
4780 gcc_cv_ld_eh_frame_hdr=no
4781 if test $in_tree_ld = yes ; then
4782 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 12 -o "$gcc_cv_gld_major_version" -gt 2 \
4783 && test $in_tree_ld_is_elf = yes; then
4784 gcc_cv_ld_eh_frame_hdr=yes
4786 elif test x$gcc_cv_ld != x; then
4787 if echo "$ld_ver" | grep GNU > /dev/null; then
4788 # Check if linker supports --eh-frame-hdr option
4789 if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
4790 gcc_cv_ld_eh_frame_hdr=yes
4795 # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
4796 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
4797 gcc_cv_ld_eh_frame_hdr=yes
4803 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
4804 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
4805 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
4806 [Define if your linker supports .eh_frame_hdr.])
4808 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
4810 AC_MSG_CHECKING(linker CIEv3 in .eh_frame support)
4811 gcc_cv_ld_eh_frame_ciev3=no
4812 if test $in_tree_ld = yes ; then
4813 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 \
4814 && test $in_tree_ld_is_elf = yes; then
4815 gcc_cv_ld_eh_frame_ciev3=yes
4817 elif test x$gcc_cv_ld != x; then
4818 if echo "$ld_ver" | grep GNU > /dev/null; then
4819 gcc_cv_ld_eh_frame_ciev3=yes
4820 if test 0"$ld_date" -lt 20040513; then
4821 if test -n "$ld_date"; then
4822 # If there was date string, but was earlier than 2004-05-13, fail
4823 gcc_cv_ld_eh_frame_ciev3=no
4824 elif test "$ld_vers_major" -lt 2; then
4825 gcc_cv_ld_eh_frame_ciev3=no
4826 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
4827 gcc_cv_ld_eh_frame_ciev3=no
4833 # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1.
4834 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then
4835 gcc_cv_ld_eh_frame_ciev3=yes
4841 AC_DEFINE_UNQUOTED(HAVE_LD_EH_FRAME_CIEV3,
4842 [`if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi`],
4843 [Define 0/1 if your linker supports CIE v3 in .eh_frame.])
4844 AC_MSG_RESULT($gcc_cv_ld_eh_frame_ciev3)
4846 AC_MSG_CHECKING(linker position independent executable support)
4848 if test $in_tree_ld = yes ; then
4850 # Full PIE support on Solaris was only introduced in gld 2.26.
4851 *-*-solaris2*) gcc_gld_pie_min_version=26 ;;
4852 *) gcc_gld_pie_min_version=15 ;;
4854 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 \
4855 && test $in_tree_ld_is_elf = yes; then
4858 elif test x$gcc_cv_ld != x; then
4859 # Check if linker supports -pie option
4860 if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
4864 if echo "$ld_ver" | grep GNU > /dev/null \
4865 && test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 26; then
4872 *-*-solaris2.1[[1-9]]*)
4873 # Solaris 11.x and Solaris 12 added PIE support.
4874 if $gcc_cv_ld -z help 2>&1 | grep -- type.*pie > /dev/null; then
4881 if test x"$gcc_cv_ld_pie" = xyes; then
4882 AC_DEFINE(HAVE_LD_PIE, 1,
4883 [Define if your linker supports PIE option.])
4885 AC_MSG_RESULT($gcc_cv_ld_pie)
4887 AC_MSG_CHECKING(linker PIE support with copy reloc)
4888 gcc_cv_ld_pie_copyreloc=no
4889 if test $gcc_cv_ld_pie = yes ; then
4890 if test $in_tree_ld = yes ; then
4891 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
4892 gcc_cv_ld_pie_copyreloc=yes
4894 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4895 # Check if linker supports -pie option with copy reloc
4897 i?86-*-linux* | x86_64-*-linux*)
4898 cat > conftest1.s <<EOF
4901 .type a_glob, @object
4906 cat > conftest2.s <<EOF
4909 .type main, @function
4911 movl %eax, a_glob(%rip)
4914 .section .data.rel,"aw",@progbits
4919 if $gcc_cv_as --64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4920 && $gcc_cv_ld -shared -melf_x86_64 -o conftest1.so conftest1.o > /dev/null 2>&1 \
4921 && $gcc_cv_as --64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4922 && $gcc_cv_ld -pie -melf_x86_64 -o conftest conftest2.o conftest1.so > /dev/null 2>&1; then
4923 gcc_cv_ld_pie_copyreloc=yes
4925 rm -f conftest conftest1.so conftest1.o conftest2.o conftest1.s conftest2.s
4930 AC_DEFINE_UNQUOTED(HAVE_LD_PIE_COPYRELOC,
4931 [`if test x"$gcc_cv_ld_pie_copyreloc" = xyes; then echo 1; else echo 0; fi`],
4932 [Define 0/1 if your linker supports -pie option with copy reloc.])
4933 AC_MSG_RESULT($gcc_cv_ld_pie_copyreloc)
4935 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
4936 gcc_cv_ld_eh_gc_sections=no
4937 if test $in_tree_ld = yes ; then
4938 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 \
4939 && test $in_tree_ld_is_elf = yes; then
4940 gcc_cv_ld_eh_gc_sections=yes
4942 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
4943 cat > conftest.s <<EOF
4946 .type _start, @function
4949 .size _start, .-_start
4950 .section .text.foo,"ax",@progbits
4951 .type foo, @function
4955 .section .gcc_except_table.foo,"a",@progbits
4958 .section .eh_frame,"a",@progbits
4961 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4962 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4963 | grep "gc-sections option ignored" > /dev/null; then
4964 gcc_cv_ld_eh_gc_sections=no
4965 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4966 | grep gcc_except_table > /dev/null; then
4967 gcc_cv_ld_eh_gc_sections=yes
4968 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
4969 if test x$gcc_cv_as_comdat_group != xyes; then
4970 gcc_cv_ld_eh_gc_sections=no
4971 cat > conftest.s <<EOF
4974 .type _start, @function
4977 .size _start, .-_start
4978 .section .gnu.linkonce.t.foo,"ax",@progbits
4979 .type foo, @function
4983 .section .gcc_except_table.foo,"a",@progbits
4986 .section .eh_frame,"a",@progbits
4989 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4990 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4991 | grep "gc-sections option ignored" > /dev/null; then
4992 gcc_cv_ld_eh_gc_sections=no
4993 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4994 | grep gcc_except_table > /dev/null; then
4995 gcc_cv_ld_eh_gc_sections=yes
5001 rm -f conftest.s conftest.o conftest
5005 # ??? This apparently exposes a binutils bug with PC-relative relocations.
5006 gcc_cv_ld_eh_gc_sections=no
5009 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
5010 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
5011 [Define if your linker supports garbage collection of
5012 sections in presence of EH frames.])
5014 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
5016 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
5017 gcc_cv_ld_eh_gc_sections_bug=no
5018 if test $in_tree_ld = yes ; then
5019 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 \
5020 && test $in_tree_ld_is_elf = yes; then
5021 gcc_cv_ld_eh_gc_sections_bug=yes
5023 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
5024 gcc_cv_ld_eh_gc_sections_bug=yes
5025 cat > conftest.s <<EOF
5028 .type _start, @function
5031 .size _start, .-_start
5032 .section .text.startup.foo,"ax",@progbits
5033 .type foo, @function
5037 .section .gcc_except_table.foo,"a",@progbits
5040 .section .eh_frame,"a",@progbits
5043 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
5044 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
5045 | grep "gc-sections option ignored" > /dev/null; then
5047 elif $gcc_cv_objdump -h conftest 2> /dev/null \
5048 | grep gcc_except_table > /dev/null; then
5049 gcc_cv_ld_eh_gc_sections_bug=no
5052 rm -f conftest.s conftest.o conftest
5054 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
5055 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
5056 [Define if your linker has buggy garbage collection of
5057 sections support when .text.startup.foo like sections are used.])
5059 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
5061 AC_MSG_CHECKING(linker for compressed debug sections)
5062 # gold/gld support compressed debug sections since binutils 2.19/2.21
5063 if test $in_tree_ld = yes ; then
5064 gcc_cv_ld_compress_debug=0
5065 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 \
5066 && test $in_tree_ld_is_elf = yes && test $ld_is_gold = yes; then
5067 gcc_cv_ld_compress_debug=2
5068 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
5069 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 \
5070 && test $in_tree_ld_is_elf = yes; then
5071 gcc_cv_ld_compress_debug=1
5073 elif echo "$ld_ver" | grep GNU > /dev/null; then
5074 gcc_cv_ld_compress_debug=1
5075 if test 0"$ld_date" -lt 20050308; then
5076 if test -n "$ld_date"; then
5077 # If there was date string, but was earlier than 2005-03-08, fail
5078 gcc_cv_ld_compress_debug=0
5079 elif test "$ld_vers_major" -lt 2; then
5080 gcc_cv_ld_compress_debug=0
5081 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 21; then
5082 gcc_cv_ld_compress_debug=0
5085 if test $ld_is_gold = yes; then
5086 gcc_cv_ld_compress_debug=2
5087 gcc_cv_ld_compress_debug_option="--compress-debug-sections"
5093 # Introduced in Solaris 11.2.
5094 if $gcc_cv_ld --help 2>&1 | grep -- '-z compress-sections' > /dev/null; then
5095 gcc_cv_ld_compress_debug=3
5096 gcc_cv_ld_compress_debug_option="-z compress-sections"
5098 gcc_cv_ld_compress_debug=0
5102 # Assume linkers other than GNU ld don't support compessed debug
5104 gcc_cv_ld_compress_debug=0
5109 AC_DEFINE_UNQUOTED(HAVE_LD_COMPRESS_DEBUG, $gcc_cv_ld_compress_debug,
5110 [Define to the level of your linker's compressed debug section support.])
5111 AC_DEFINE_UNQUOTED(LD_COMPRESS_DEBUG_OPTION, "$gcc_cv_ld_compress_debug_option",
5112 [Define to the linker option to enable compressed debug sections.])
5113 AC_MSG_RESULT($gcc_cv_ld_compress_debug)
5119 AC_CACHE_CHECK(linker --as-needed support,
5120 gcc_cv_ld_as_needed,
5121 [gcc_cv_ld_as_needed=no
5122 gcc_cv_ld_as_needed_option='--as-needed'
5123 gcc_cv_ld_no_as_needed_option='--no-as-needed'
5124 if test $in_tree_ld = yes ; then
5125 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 \
5126 && test $in_tree_ld_is_elf = yes; then
5127 gcc_cv_ld_as_needed=yes
5129 elif test x$gcc_cv_ld != x; then
5130 # Check if linker supports --as-needed and --no-as-needed options
5131 if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
5132 gcc_cv_ld_as_needed=yes
5135 # Solaris 2 ld always supports -z ignore/-z record.
5137 gcc_cv_ld_as_needed=yes
5138 gcc_cv_ld_as_needed_option="-z ignore"
5139 gcc_cv_ld_no_as_needed_option="-z record"
5144 # --as-needed/-z ignore can only be used if libgcc_s.so.1 uses
5145 # dl_iterate_phdr, i.e. since Solaris 11.
5147 *-*-solaris2.1[[1-9]]*)
5149 i?86-*-* | x86_64-*-*)
5150 if echo "$ld_ver" | grep GNU > /dev/null; then
5151 # Doesn't work with gld on Solaris/x86 due to PR ld/12320.
5152 gcc_cv_ld_as_needed=no
5158 gcc_cv_ld_as_needed=no
5162 if test x"$gcc_cv_ld_as_needed" = xyes; then
5163 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
5164 [Define if your linker supports --as-needed/--no-as-needed or equivalent options.])
5165 AC_DEFINE_UNQUOTED(LD_AS_NEEDED_OPTION, "$gcc_cv_ld_as_needed_option",
5166 [Define to the linker option to ignore unused dependencies.])
5167 AC_DEFINE_UNQUOTED(LD_NO_AS_NEEDED_OPTION, "$gcc_cv_ld_no_as_needed_option",
5168 [Define to the linker option to keep unused dependencies.])
5171 AC_MSG_CHECKING(linker mapfile support for clearing hardware capabilities)
5172 saved_LDFLAGS="$LDFLAGS"
5173 for clearcap_map in sol2-clearcapv2.map sol2-clearcap.map; do
5174 LDFLAGS="$saved_LDFLAGS -Wl,-M,${srcdir}/config/$clearcap_map"
5175 AC_LINK_IFELSE([int main(void) {return 0;}],
5176 [gcc_cv_ld_clearcap=yes; break], [gcc_cv_ld_clearcap=no])
5178 LDFLAGS="$saved_LDFLAGS"
5179 if test "x$gcc_cv_ld_clearcap" = xyes; then
5180 AC_DEFINE([HAVE_LD_CLEARCAP], 1,
5181 [Define if the linker supports clearing hardware capabilities via mapfile.])
5182 AC_CONFIG_LINKS([clearcap.map:${srcdir}/config/$clearcap_map])
5184 AC_MSG_RESULT($gcc_cv_ld_clearcap)
5186 case "$target:$tm_file" in
5187 powerpc64-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
5190 emul_name="-melf64lppc"
5193 emul_name="-melf64ppc"
5196 emul_name="-melf64ppc_fbsd"
5199 AC_CACHE_CHECK(linker support for omitting dot symbols,
5200 gcc_cv_ld_no_dot_syms,
5201 [gcc_cv_ld_no_dot_syms=no
5202 if test x"$ld_is_gold" = xyes; then
5203 gcc_cv_ld_no_dot_syms=yes
5204 elif test $in_tree_ld = yes ; then
5205 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
5206 gcc_cv_ld_no_dot_syms=yes
5208 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
5209 cat > conftest1.s <<EOF
5213 cat > conftest2.s <<EOF
5214 .section ".opd","aw"
5219 .quad .LEfoo,.TOC.@tocbase,0
5225 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
5226 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
5227 && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
5228 gcc_cv_ld_no_dot_syms=yes
5230 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
5233 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
5234 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
5235 [Define if your PowerPC64 linker only needs function descriptor syms.])
5238 AC_CACHE_CHECK(linker large toc support,
5239 gcc_cv_ld_large_toc,
5240 [gcc_cv_ld_large_toc=no
5241 if test x"$ld_is_gold" = xyes; then
5242 gcc_cv_ld_large_toc=yes
5243 elif test $in_tree_ld = yes ; then
5244 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
5245 gcc_cv_ld_large_toc=yes
5247 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
5248 cat > conftest.s <<EOF
5249 .section ".tbss","awT",@nobits
5255 addis 9,13,ie0@got@tprel@ha
5256 ld 9,ie0@got@tprel@l(9)
5258 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
5259 && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
5260 gcc_cv_ld_large_toc=yes
5262 rm -f conftest conftest.o conftest.s
5265 if test x"$gcc_cv_ld_large_toc" = xyes; then
5266 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
5267 [Define if your PowerPC64 linker supports a large TOC.])
5270 AC_CACHE_CHECK(linker toc pointer alignment,
5271 gcc_cv_ld_toc_align,
5272 [if test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_nm != x; then
5273 cat > conftest.s <<EOF
5278 .section .data.rel.ro,"aw",@progbits
5283 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
5284 && $gcc_cv_ld $emul_name -z norelro -o conftest conftest.o > /dev/null 2>&1; then
5285 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)) }'`
5287 rm -f conftest conftest.o conftest.s
5290 if test -n "$gcc_cv_ld_toc_align" && test $gcc_cv_ld_toc_align -gt 8; then
5291 AC_DEFINE_UNQUOTED(POWERPC64_TOC_POINTER_ALIGNMENT, $gcc_cv_ld_toc_align,
5292 [Define to .TOC. alignment forced by your linker.])
5299 AC_CACHE_CHECK(linker large toc support,
5300 gcc_cv_ld_large_toc,
5301 [gcc_cv_ld_large_toc=no
5302 if test x$gcc_cv_as != x ; then
5303 cat > conftest.s <<EOF
5313 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1; then
5314 gcc_cv_ld_large_toc=yes
5316 rm -f conftest conftest.o conftest.s
5319 if test x"$gcc_cv_ld_large_toc" = xyes; then
5320 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
5321 [Define if your PowerPC64 linker supports a large TOC.])
5326 AC_CACHE_CHECK(linker --build-id support,
5328 [gcc_cv_ld_buildid=no
5329 if test $in_tree_ld = yes ; then
5330 if test "$gcc_cv_gld_major_version" -eq 2 -a \
5331 "$gcc_cv_gld_minor_version" -ge 18 -o \
5332 "$gcc_cv_gld_major_version" -gt 2 \
5333 && test $in_tree_ld_is_elf = yes; then
5334 gcc_cv_ld_buildid=yes
5336 elif test x$gcc_cv_ld != x; then
5337 if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
5338 gcc_cv_ld_buildid=yes
5341 if test x"$gcc_cv_ld_buildid" = xyes; then
5342 AC_DEFINE(HAVE_LD_BUILDID, 1,
5343 [Define if your linker supports --build-id.])
5346 AC_ARG_ENABLE(linker-build-id,
5347 [AS_HELP_STRING([--enable-linker-build-id],
5348 [compiler will always pass --build-id to linker])],
5350 enable_linker_build_id=no)
5352 if test x"$enable_linker_build_id" = xyes; then
5353 if test x"$gcc_cv_ld_buildid" = xyes; then
5354 AC_DEFINE(ENABLE_LD_BUILDID, 1,
5355 [Define if gcc should always pass --build-id to linker.])
5357 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
5361 # In binutils 2.21, GNU ld gained support for new emulations fully
5362 # supporting the Solaris 2 ABI. Detect their presence in the linker used.
5363 AC_CACHE_CHECK(linker *_sol2 emulation support,
5364 gcc_cv_ld_sol2_emulation,
5365 [gcc_cv_ld_sol2_emulation=no
5366 if test $in_tree_ld = yes ; then
5367 if test "$gcc_cv_gld_major_version" -eq 2 -a \
5368 "$gcc_cv_gld_minor_version" -ge 21 -o \
5369 "$gcc_cv_gld_major_version" -gt 2 \
5370 && test $in_tree_ld_is_elf = yes; then
5371 gcc_cv_ld_sol2_emulation=yes
5373 elif test x$gcc_cv_ld != x; then
5374 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
5375 grep _sol2 > /dev/null; then
5376 gcc_cv_ld_sol2_emulation=yes
5379 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
5380 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
5381 [Define if your linker supports the *_sol2 emulations.])
5384 AC_CACHE_CHECK(linker --sysroot support,
5386 [gcc_cv_ld_sysroot=no
5387 if test $in_tree_ld = yes ; then
5388 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
5389 gcc_cv_ld_sysroot=yes
5391 elif test x$gcc_cv_ld != x; then
5392 if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
5393 gcc_cv_ld_sysroot=yes
5396 if test x"$gcc_cv_ld_sysroot" = xyes; then
5397 AC_DEFINE(HAVE_LD_SYSROOT, 1,
5398 [Define if your linker supports --sysroot.])
5403 # Check for system-provided CRTs on Solaris 11.x and Solaris 12.
5404 AC_CACHE_CHECK([system-provided CRTs on Solaris],
5405 gcc_cv_solaris_crts,
5406 [gcc_cv_solaris_crts=no
5407 if test x$host != x$target; then
5408 if test "x$with_sysroot" = xyes; then
5409 target_sysroot="${test_exec_prefix}/${target_noncanonical}/sys-root"
5411 target_sysroot="${with_sysroot}"
5414 target_libdir="$target_sysroot/usr/lib"
5415 # At the time they were added, gcrt1.o became a symlink for backwards
5416 # compatibility on x86, while crt1.o was added on sparc, so check for that.
5418 i?86-*-solaris2* | x86_64-*-solaris2*)
5419 if test -h "$target_libdir/gcrt1.o"; then gcc_cv_solaris_crts=yes; fi
5422 if test -f "$target_libdir/crt1.o"; then gcc_cv_solaris_crts=yes; fi
5427 if test x$gcc_cv_solaris_crts = xyes; then
5428 AC_DEFINE(HAVE_SOLARIS_CRTS, 1,
5429 [Define if the system-provided CRTs are present on Solaris.])
5432 # Test for stack protector support in target C library.
5433 AC_CACHE_CHECK(__stack_chk_fail in target C library,
5434 gcc_cv_libc_provides_ssp,
5435 [gcc_cv_libc_provides_ssp=no
5438 # All versions of musl provide stack protector
5439 gcc_cv_libc_provides_ssp=yes;;
5440 *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
5441 # glibc 2.4 and later provides __stack_chk_fail and
5442 # either __stack_chk_guard, or TLS access to stack guard canary.
5443 GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_libc_provides_ssp=yes], [
5444 [if test -f $target_header_dir/features.h \
5445 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \
5446 $target_header_dir/features.h > /dev/null; then
5447 if $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \
5448 $target_header_dir/features.h > /dev/null && \
5449 test -f $target_header_dir/bits/uClibc_config.h && \
5450 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \
5451 $target_header_dir/bits/uClibc_config.h > /dev/null; then
5452 gcc_cv_libc_provides_ssp=yes
5454 # all versions of Bionic support stack protector
5455 elif test -f $target_header_dir/sys/cdefs.h \
5456 && $EGREP '^[ ]*#[ ]*define[ ]+__BIONIC__[ ]+1' \
5457 $target_header_dir/sys/cdefs.h > /dev/null; then
5458 gcc_cv_libc_provides_ssp=yes
5462 # Avoid complicated tests (see
5463 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
5464 # simply assert that glibc does provide this, which is true for all
5465 # realistically usable GNU/Hurd configurations.
5466 # All supported versions of musl provide it as well
5467 gcc_cv_libc_provides_ssp=yes;;
5468 *-*-darwin* | *-*-freebsd*)
5469 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
5470 [echo "no __stack_chk_fail on this target"])
5472 *) gcc_cv_libc_provides_ssp=no ;;
5475 if test x$gcc_cv_libc_provides_ssp = xyes; then
5476 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
5477 [Define if your target C library provides stack protector support])
5480 # Check whether --enable-default-ssp was given.
5481 AC_ARG_ENABLE(default-ssp,
5482 [AS_HELP_STRING([--enable-default-ssp],
5483 [enable Stack Smashing Protection as default])],[
5484 if test x$gcc_cv_libc_provides_ssp = xyes; then
5486 ia64*-*-*) enable_default_ssp=no ;;
5487 *) enable_default_ssp=$enableval ;;
5490 enable_default_ssp=no
5492 enable_default_ssp=no)
5493 if test x$enable_default_ssp = xyes ; then
5494 AC_DEFINE(ENABLE_DEFAULT_SSP, 1,
5495 [Define if your target supports default stack protector and it is enabled.])
5497 AC_SUBST([enable_default_ssp])
5499 # Test for <sys/sdt.h> on the target.
5500 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
5501 AC_MSG_CHECKING(sys/sdt.h in the target C library)
5503 if test -f $target_header_dir/sys/sdt.h; then
5505 AC_DEFINE(HAVE_SYS_SDT_H, 1,
5506 [Define if your target C library provides sys/sdt.h])
5508 AC_MSG_RESULT($have_sys_sdt_h)
5510 # Check if TFmode long double should be used by default or not.
5511 # Some glibc targets used DFmode long double, but with glibc 2.4
5512 # and later they can use TFmode.
5514 powerpc*-*-linux* | \
5518 AC_ARG_WITH(long-double-128,
5519 [AS_HELP_STRING([--with-long-double-128],
5520 [use 128-bit long double by default])],
5521 gcc_cv_target_ldbl128="$with_long_double_128",
5522 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_target_ldbl128=yes], [
5523 [gcc_cv_target_ldbl128=no
5524 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \
5525 $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
5526 && gcc_cv_target_ldbl128=yes
5530 if test x$gcc_cv_target_ldbl128 = xyes; then
5531 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
5532 [Define if TFmode long double should be the default])
5535 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
5536 gcc_cv_target_dl_iterate_phdr=unknown
5538 # Restrict to Solaris 11+. While most of the Solaris 11 linker changes
5539 # were backported to Solaris 10 Update 10, dl_iterate_phdr only lives in
5540 # libdl there, both complicating its use and breaking compatibility
5541 # between Solaris 10 updates.
5542 *-*-solaris2.1[[1-9]]*)
5543 # <link.h> needs both a dl_iterate_phdr declaration and support for
5544 # compilation with largefile support.
5545 if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
5546 && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
5547 gcc_cv_target_dl_iterate_phdr=yes
5549 gcc_cv_target_dl_iterate_phdr=no
5552 *-*-dragonfly* | *-*-freebsd*)
5553 if grep dl_iterate_phdr $target_header_dir/sys/link_elf.h > /dev/null 2>&1; then
5554 gcc_cv_target_dl_iterate_phdr=yes
5556 gcc_cv_target_dl_iterate_phdr=no
5560 gcc_cv_target_dl_iterate_phdr=yes
5563 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
5564 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
5565 AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
5566 [Define if your target C library provides the `dl_iterate_phdr' function.])
5568 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
5570 # We no longer support different GC mechanisms. Emit an error if
5571 # the user configures with --with-gc.
5573 [AS_HELP_STRING([--with-gc={page,zone}],
5574 [this option is not supported anymore. It used to choose
5575 the garbage collection mechanism to use with the compiler])],
5576 [AC_MSG_ERROR([Configure option --with-gc is only supported up to GCC 4.7.x])],
5579 # Libraries to use on the host. This will normally be set by the top
5580 # level Makefile. Here we simply capture the value for our Makefile.
5581 if test -z "${HOST_LIBS+set}"; then
5586 # Use the system's zlib library.
5589 dnl Very limited version of automake's enable-maintainer-mode
5591 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
5592 dnl maintainer-mode is disabled by default
5593 AC_ARG_ENABLE(maintainer-mode,
5594 [AS_HELP_STRING([--enable-maintainer-mode],
5595 [enable make rules and dependencies not useful
5596 (and sometimes confusing) to the casual installer])],
5597 maintainer_mode=$enableval,
5600 AC_MSG_RESULT($maintainer_mode)
5602 if test "$maintainer_mode" = "yes"; then
5609 dnl Whether to prevent multiple front-ends from linking at the same time
5611 AC_MSG_CHECKING([whether to avoid linking multiple front-ends at once])
5612 AC_ARG_ENABLE(link-mutex,
5613 [AS_HELP_STRING([--enable-link-mutex],
5614 [avoid linking multiple front-ends at once to avoid thrashing
5615 on the build machine])],
5616 do_link_mutex=$enableval,
5618 AC_MSG_RESULT($do_link_mutex)
5620 if test "$do_link_mutex" = "yes"; then
5625 AC_SUBST(DO_LINK_MUTEX)
5631 # Make empty files to contain the specs and options for each language.
5632 # Then add #include lines to for a compiler that has specs and/or options.
5638 # These (without "all_") are set in each config-lang.in.
5639 # `language' must be a single word so is spelled singularly.
5642 all_outputs='Makefile'
5643 # List of language makefile fragments.
5645 # Additional files for gengtype
5646 all_gtfiles="$target_gtfiles"
5648 # These are the languages that are set in --enable-languages,
5649 # and are available in the GCC tree.
5650 all_selected_languages=
5652 # Add the language fragments.
5653 # Languages are added via two mechanisms. Some information must be
5654 # recorded in makefile variables, these are defined in config-lang.in.
5655 # We accumulate them and plug them into the main Makefile.
5656 # The other mechanism is a set of hooks for each of the main targets
5657 # like `clean', `install', etc.
5659 language_hooks="Make-hooks"
5661 for lang in ${srcdir}/*/config-lang.in
5664 test "$lang" = "${srcdir}/*/config-lang.in" && continue
5666 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
5667 if test "x$lang_alias" = x
5669 echo "$lang doesn't set \$language." 1>&2
5672 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
5673 subdirs="$subdirs $subdir"
5675 # $gcc_subdir is where the gcc integration files are to be found
5676 # for a language, both for internal compiler purposes (compiler
5677 # sources implementing front-end to GCC tree converters), and for
5678 # build infrastructure purposes (Make-lang.in, etc.)
5680 # This will be <subdir> (relative to $srcdir) if a line like
5681 # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
5682 # is found in <langdir>/config-lang.in, and will remain <langdir>
5685 # Except for the language alias (fetched above), the regular
5686 # "config-lang.in" contents are always retrieved from $gcc_subdir,
5687 # so a <langdir>/config-lang.in setting gcc_subdir typically sets
5688 # only this and the language alias.
5690 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang`
5691 if [ "$gcc_subdir" = "" ]; then
5692 gcc_subdir="$subdir"
5695 case ",$enable_languages," in
5697 all_selected_languages="$all_selected_languages $lang_alias"
5698 if test -f $srcdir/$gcc_subdir/lang-specs.h; then
5699 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
5711 . ${srcdir}/$gcc_subdir/config-lang.in
5712 if test "x$language" = x
5714 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
5719 case ",$enable_languages," in
5722 for i in $subdir_requires; do
5723 test -f "${srcdir}/$i/config-lang.in" && continue
5731 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
5732 if test -f $srcdir/$gcc_subdir/lang.opt; then
5733 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
5734 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
5736 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
5737 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
5739 all_languages="$all_languages $language"
5740 all_compilers="$all_compilers $compilers"
5741 all_outputs="$all_outputs $outputs"
5742 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
5743 case ",$enable_languages," in
5745 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
5747 AC_SUBST(enable_lto)
5754 for language in $all_selected_languages
5756 check_languages="$check_languages check-$language"
5759 # We link each language in with a set of hooks, reached indirectly via
5760 # lang.${target}. Only do so for selected languages.
5764 target_list="all.cross start.encap rest.encap tags \
5765 install-common install-man install-info install-pdf install-html dvi \
5766 pdf html uninstall info man srcextra srcman srcinfo \
5767 mostlyclean clean distclean maintainer-clean install-plugin"
5769 for t in $target_list
5772 for lang in $all_selected_languages
5776 echo "lang.$t: $x" >> Make-hooks
5780 # Option include files
5783 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
5784 option_includes="option-includes.mk"
5785 AC_SUBST_FILE(option_includes)
5793 echo "dir ." > .gdbinit
5794 echo "dir ${srcdir}" >> .gdbinit
5795 if test x$gdb_needs_out_file_path = xyes
5797 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
5799 if test "x$subdirs" != x; then
5802 echo "dir ${srcdir}/$s" >> .gdbinit
5805 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
5806 echo "python import sys; sys.path.append('${srcdir}'); import gdbhooks" >> .gdbinit
5808 # Put a breakpoint on __asan_report_error to help with debugging buffer
5811 *-fsanitize=address*)
5812 echo "source ${srcdir}/gdbasan.in" >> .gdbinit
5816 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
5817 AC_SUBST(gcc_tooldir)
5820 # Find a directory in which to install a shared libgcc.
5822 AC_ARG_ENABLE(version-specific-runtime-libs,
5823 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
5824 [specify that runtime libraries should be
5825 installed in a compiler-specific directory])])
5827 # Substitute configuration variables
5830 AC_SUBST(all_compilers)
5831 AC_SUBST(all_gtfiles)
5832 AC_SUBST(all_lang_makefrags)
5833 AC_SUBST(all_languages)
5834 AC_SUBST(all_selected_languages)
5835 AC_SUBST(build_exeext)
5836 AC_SUBST(build_install_headers_dir)
5837 AC_SUBST(build_xm_file_list)
5838 AC_SUBST(build_xm_include_list)
5839 AC_SUBST(build_xm_defines)
5840 AC_SUBST(build_file_translate)
5841 AC_SUBST(check_languages)
5842 AC_SUBST(cpp_install_dir)
5843 AC_SUBST(xmake_file)
5844 AC_SUBST(tmake_file)
5845 AC_SUBST(TM_ENDIAN_CONFIG)
5846 AC_SUBST(TM_MULTILIB_CONFIG)
5847 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
5848 AC_SUBST(extra_gcc_objs)
5849 AC_SUBST(user_headers_inc_next_pre)
5850 AC_SUBST(user_headers_inc_next_post)
5851 AC_SUBST(extra_headers_list)
5852 AC_SUBST(extra_objs)
5853 AC_SUBST(extra_programs)
5854 AC_SUBST(float_h_file)
5855 AC_SUBST(gcc_config_arguments)
5856 AC_SUBST(gcc_gxx_include_dir)
5857 AC_SUBST(gcc_gxx_include_dir_add_sysroot)
5858 AC_SUBST(host_exeext)
5859 AC_SUBST(host_xm_file_list)
5860 AC_SUBST(host_xm_include_list)
5861 AC_SUBST(host_xm_defines)
5862 AC_SUBST(out_host_hook_obj)
5864 AC_SUBST(lang_opt_files)
5865 AC_SUBST(lang_specs_files)
5866 AC_SUBST(lang_tree_files)
5867 AC_SUBST(local_prefix)
5869 AC_SUBST(objc_boehm_gc)
5871 AC_SUBST(out_object_file)
5872 AC_SUBST(common_out_file)
5873 AC_SUBST(common_out_object_file)
5874 AC_SUBST(tm_file_list)
5875 AC_SUBST(tm_include_list)
5876 AC_SUBST(tm_defines)
5877 AC_SUBST(tm_p_file_list)
5878 AC_SUBST(tm_p_include_list)
5879 AC_SUBST(xm_file_list)
5880 AC_SUBST(xm_include_list)
5881 AC_SUBST(xm_defines)
5882 AC_SUBST(use_gcc_stdint)
5883 AC_SUBST(c_target_objs)
5884 AC_SUBST(cxx_target_objs)
5885 AC_SUBST(fortran_target_objs)
5886 AC_SUBST(target_cpu_default)
5888 AC_SUBST_FILE(language_hooks)
5891 if test x${build} = x${host} ; then
5892 if test x${host} = x${target} ; then
5893 echo "Links are now set up to build a native compiler for ${target}." 1>&2
5895 echo "Links are now set up to build a cross-compiler" 1>&2
5896 echo " from ${host} to ${target}." 1>&2
5899 if test x${host} = x${target} ; then
5900 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
5901 echo " for ${target}." 1>&2
5903 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
5904 echo " from ${host} to ${target}." 1>&2
5908 AC_ARG_VAR(GMPLIBS,[How to link GMP])
5909 AC_ARG_VAR(GMPINC,[How to find GMP include files])
5911 AC_ARG_VAR(ISLLIBS,[How to link isl])
5912 AC_ARG_VAR(ISLINC,[How to find isl include files])
5913 if test "x${ISLLIBS}" != "x" ; then
5914 AC_DEFINE(HAVE_isl, 1, [Define if isl is in use.])
5917 # Check whether isl_options_set_schedule_serialize_sccs is available;
5918 # it's new in isl 0.15.
5919 if test "x${ISLLIBS}" != "x" ; then
5920 saved_CXXFLAGS="$CXXFLAGS"
5921 CXXFLAGS="$CXXFLAGS $ISLINC"
5923 LIBS="$LIBS $ISLLIBS $GMPLIBS"
5925 AC_MSG_CHECKING([Checking for isl_options_set_schedule_serialize_sccs])
5926 AC_TRY_LINK([#include <isl/schedule.h>],
5927 [isl_options_set_schedule_serialize_sccs (NULL, 0);],
5928 [ac_has_isl_options_set_schedule_serialize_sccs=yes],
5929 [ac_has_isl_options_set_schedule_serialize_sccs=no])
5930 AC_MSG_RESULT($ac_has_isl_options_set_schedule_serialize_sccs)
5933 CXXFLAGS="$saved_CXXFLAGS"
5935 if test x"$ac_has_isl_options_set_schedule_serialize_sccs" = x"yes"; then
5936 AC_DEFINE(HAVE_ISL_OPTIONS_SET_SCHEDULE_SERIALIZE_SCCS, 1,
5937 [Define if isl_options_set_schedule_serialize_sccs exists.])
5942 AC_SUBST(pluginlibs)
5943 AC_SUBST(enable_plugin)
5944 if test x"$enable_plugin" = x"yes"; then
5945 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
5949 # Enable --enable-host-shared
5950 AC_ARG_ENABLE(host-shared,
5951 [AS_HELP_STRING([--enable-host-shared],
5952 [build host code as shared libraries])],
5953 [PICFLAG=-fPIC], [PICFLAG=])
5954 AC_SUBST(enable_host_shared)
5958 AC_ARG_ENABLE(libquadmath-support,
5959 [AS_HELP_STRING([--disable-libquadmath-support],
5960 [disable libquadmath support for Fortran])],
5961 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
5962 ENABLE_LIBQUADMATH_SUPPORT=yes)
5963 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
5964 AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
5965 [Define to 1 to enable libquadmath support])
5969 # Specify what hash style to use by default.
5970 AC_ARG_WITH([linker-hash-style],
5971 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
5972 [specify the linker hash style])],
5973 [case x"$withval" in
5975 LINKER_HASH_STYLE=sysv
5978 LINKER_HASH_STYLE=gnu
5981 LINKER_HASH_STYLE=both
5984 AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
5987 [LINKER_HASH_STYLE=''])
5988 if test x"${LINKER_HASH_STYLE}" != x; then
5989 AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
5990 [The linker hash style])
5993 # Specify what should be the default of -fdiagnostics-color option.
5994 AC_ARG_WITH([diagnostics-color],
5995 [AC_HELP_STRING([--with-diagnostics-color={never,auto,auto-if-env,always}],
5996 [specify the default of -fdiagnostics-color option
5997 auto-if-env stands for -fdiagnostics-color=auto if
5998 GCC_COLOR environment variable is present and
5999 -fdiagnostics-color=never otherwise])],
6000 [case x"$withval" in
6002 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_NO
6005 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_AUTO
6008 DIAGNOSTICS_COLOR_DEFAULT=-1
6011 DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_YES
6014 AC_MSG_ERROR([$withval is an invalid option to --with-diagnostics-color])
6017 [DIAGNOSTICS_COLOR_DEFAULT=DIAGNOSTICS_COLOR_AUTO])
6018 AC_DEFINE_UNQUOTED(DIAGNOSTICS_COLOR_DEFAULT, $DIAGNOSTICS_COLOR_DEFAULT,
6019 [The default for -fdiagnostics-color option])
6021 # Generate gcc-driver-name.h containing GCC_DRIVER_NAME for the benefit
6022 # of jit/jit-playback.c.
6023 cat > gcc-driver-name.h <<EOF
6024 #define GCC_DRIVER_NAME "${target_noncanonical}-gcc-${gcc_BASEVER}${exeext}"
6027 # Check whether --enable-default-pie was given.
6028 AC_ARG_ENABLE(default-pie,
6029 [AS_HELP_STRING([--enable-default-pie],
6030 [enable Position Independent Executable as default])],
6031 enable_default_pie=$enableval,
6032 enable_default_pie=no)
6033 if test x$enable_default_pie = xyes ; then
6034 AC_DEFINE(ENABLE_DEFAULT_PIE, 1,
6035 [Define if your target supports default PIE and it is enabled.])
6037 AC_SUBST([enable_default_pie])
6039 # Check if -fno-PIE works.
6040 AC_CACHE_CHECK([for -fno-PIE option],
6042 [saved_CXXFLAGS="$CXXFLAGS"
6043 CXXFLAGS="$CXXFLAGS -fno-PIE"
6044 AC_COMPILE_IFELSE([int main(void) {return 0;}],
6045 [gcc_cv_c_no_fpie=yes],
6046 [gcc_cv_c_no_fpie=no])
6047 CXXFLAGS="$saved_CXXFLAGS"])
6048 if test "$gcc_cv_c_no_fpie" = "yes"; then
6049 NO_PIE_CFLAGS="-fno-PIE"
6051 AC_SUBST([NO_PIE_CFLAGS])
6053 # Check if -no-pie works.
6054 AC_CACHE_CHECK([for -no-pie option],
6056 [saved_LDFLAGS="$LDFLAGS"
6057 LDFLAGS="$LDFLAGS -no-pie"
6058 AC_LINK_IFELSE([int main(void) {return 0;}],
6059 [gcc_cv_no_pie=yes],
6061 LDFLAGS="$saved_LDFLAGS"])
6062 if test "$gcc_cv_no_pie" = "yes"; then
6063 NO_PIE_FLAG="-no-pie"
6065 AC_SUBST([NO_PIE_FLAG])
6067 # Check linker supports '-z bndplt'
6068 ld_bndplt_support=no
6069 AC_MSG_CHECKING(linker -z bndplt option)
6070 if test x"$ld_is_gold" = xno; then
6071 if test $in_tree_ld = yes ; then
6072 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
6073 ld_bndplt_support=yes
6075 elif test x$gcc_cv_ld != x; then
6076 # Check if linker supports -a bndplt option
6077 if $gcc_cv_ld --help 2>/dev/null | grep -- '-z bndplt' > /dev/null; then
6078 ld_bndplt_support=yes
6082 if test x"$ld_bndplt_support" = xyes; then
6083 AC_DEFINE(HAVE_LD_BNDPLT_SUPPORT, 1,
6084 [Define if your linker supports -z bndplt])
6086 AC_MSG_RESULT($ld_bndplt_support)
6088 # Configure the subdirectories
6089 # AC_CONFIG_SUBDIRS($subdirs)
6091 # Create the Makefile
6092 # and configure language subdirectories
6093 AC_CONFIG_FILES($all_outputs)
6095 AC_CONFIG_COMMANDS([default],
6097 case ${CONFIG_HEADERS} in
6098 *auto-host.h:config.in*)
6101 # Make sure all the subdirs exist.
6102 for d in $subdirs doc build common c-family
6104 test -d $d || mkdir $d
6107 [subdirs='$subdirs'])