2 # Process this file with autoconf to generate a configuration script.
4 # Copyright (C) 1997-2014 Free Software Foundation, Inc.
6 #This file is part of GCC.
8 #GCC is free software; you can redistribute it and/or modify it under
9 #the terms of the GNU General Public License as published by the Free
10 #Software Foundation; either version 3, or (at your option) any later
13 #GCC is distributed in the hope that it will be useful, but WITHOUT
14 #ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 #FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 #You should have received a copy of the GNU General Public License
19 #along with GCC; see the file COPYING3. If not see
20 #<http://www.gnu.org/licenses/>.
22 # --------------------------------
23 # Initialization and sanity checks
24 # --------------------------------
28 AC_CONFIG_SRCDIR(tree.c)
29 AC_CONFIG_HEADER(auto-host.h:config.in)
31 gcc_version=`cat $srcdir/BASE-VER`
33 # Determine the host, build, and target systems
38 # Determine the noncanonical target name, for directory use.
39 ACX_NONCANONICAL_TARGET
41 # Determine the target- and build-specific subdirectories
44 # Set program_transform_name
47 # Check for bogus environment variables.
48 # Test if LIBRARY_PATH contains the notation for the current directory
49 # since this would lead to problems installing/building glibc.
50 # LIBRARY_PATH contains the current directory if one of the following
52 # - one of the terminals (":" and ";") is the first or last sign
53 # - two terminals occur directly after each other
54 # - the path contains an element with a dot in it
55 AC_MSG_CHECKING(LIBRARY_PATH variable)
57 case ${LIBRARY_PATH} in
58 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
59 library_path_setting="contains current directory"
62 library_path_setting="ok"
66 AC_MSG_RESULT($library_path_setting)
67 if test "$library_path_setting" != "ok"; then
69 *** LIBRARY_PATH shouldn't contain the current directory when
70 *** building gcc. Please change the environment variable
71 *** and run configure again.])
74 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
75 # since this would lead to problems installing/building glibc.
76 # GCC_EXEC_PREFIX contains the current directory if one of the following
78 # - one of the terminals (":" and ";") is the first or last sign
79 # - two terminals occur directly after each other
80 # - the path contains an element with a dot in it
81 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
83 case ${GCC_EXEC_PREFIX} in
84 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
85 gcc_exec_prefix_setting="contains current directory"
88 gcc_exec_prefix_setting="ok"
92 AC_MSG_RESULT($gcc_exec_prefix_setting)
93 if test "$gcc_exec_prefix_setting" != "ok"; then
95 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
96 *** building gcc. Please change the environment variable
97 *** and run configure again.])
104 # Specify the local prefix
106 AC_ARG_WITH(local-prefix,
107 [AS_HELP_STRING([--with-local-prefix=DIR],
108 [specifies directory to put local include])],
109 [case "${withval}" in
110 yes) AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
112 *) local_prefix=$with_local_prefix ;;
115 # Default local prefix if it is empty
116 if test x$local_prefix = x; then
117 local_prefix=/usr/local
120 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
121 # passed in by the toplevel make and thus we'd get different behavior
122 # depending on where we built the sources.
124 # Specify the g++ header file directory
125 AC_ARG_WITH(gxx-include-dir,
126 [AS_HELP_STRING([--with-gxx-include-dir=DIR],
127 [specifies directory to put g++ header files])],
128 [case "${withval}" in
129 yes) AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
131 *) gcc_gxx_include_dir=$with_gxx_include_dir ;;
134 # This logic must match libstdc++-v3/acinclude.m4:GLIBCXX_EXPORT_INSTALL_INFO.
135 if test x${gcc_gxx_include_dir} = x; then
136 if test x${enable_version_specific_runtime_libs} = xyes; then
137 gcc_gxx_include_dir='${libsubdir}/include/c++'
139 libstdcxx_incdir='include/c++/$(version)'
140 if test x$host != x$target; then
141 libstdcxx_incdir="$target_alias/$libstdcxx_incdir"
143 gcc_gxx_include_dir="\$(libsubdir)/\$(libsubdir_to_prefix)$libstdcxx_incdir"
147 gcc_gxx_include_dir_add_sysroot=0
148 if test "${with_sysroot+set}" = set; then
149 gcc_gxx_without_sysroot=`expr "${gcc_gxx_include_dir}" : "${with_sysroot}"'\(.*\)'`
150 if test "${gcc_gxx_without_sysroot}"; then
151 gcc_gxx_include_dir="${gcc_gxx_without_sysroot}"
152 gcc_gxx_include_dir_add_sysroot=1
156 AC_ARG_WITH(cpp_install_dir,
157 [AC_HELP_STRING([--with-cpp-install-dir=DIR],
158 [install the user visible C preprocessor in DIR
159 (relative to PREFIX) as well as PREFIX/bin])],
160 [if test x$withval = xyes; then
161 AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
162 elif test x$withval != xno; then
163 cpp_install_dir=$withval
166 # We would like to our source tree to be readonly. However when releases or
167 # pre-releases are generated, the flex/bison generated files as well as the
168 # various formats of manuals need to be included along with the rest of the
169 # sources. Therefore we have --enable-generated-files-in-srcdir to do
172 AC_MSG_CHECKING([whether to place generated files in the source directory])
173 dnl generated-files-in-srcdir is disabled by default
174 AC_ARG_ENABLE(generated-files-in-srcdir,
175 [AS_HELP_STRING([--enable-generated-files-in-srcdir],
176 [put copies of generated files in source dir
177 intended for creating source tarballs for users
178 without texinfo bison or flex])],
179 generated_files_in_srcdir=$enableval,
180 generated_files_in_srcdir=no)
182 AC_MSG_RESULT($generated_files_in_srcdir)
184 if test "$generated_files_in_srcdir" = "yes"; then
191 # -------------------
192 # Find default linker
193 # -------------------
197 [AS_HELP_STRING([--with-gnu-ld], [arrange to work with GNU ld])],
198 gnu_ld_flag="$with_gnu_ld",
201 # With pre-defined ld
203 [AS_HELP_STRING([--with-ld], [arrange to use the specified ld (full pathname)])],
204 DEFAULT_LINKER="$with_ld")
205 if test x"${DEFAULT_LINKER+set}" = x"set"; then
206 if test ! -x "$DEFAULT_LINKER"; then
207 AC_MSG_ERROR([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
208 elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
211 AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
212 [Define to enable the use of a default linker.])
215 AC_MSG_CHECKING([whether a default linker was specified])
216 if test x"${DEFAULT_LINKER+set}" = x"set"; then
217 if test x"$gnu_ld_flag" = x"no"; then
218 AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
220 AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
226 # With demangler in GNU ld
227 AC_ARG_WITH(demangler-in-ld,
228 [AS_HELP_STRING([--with-demangler-in-ld], [try to use demangler in GNU ld])],
229 demangler_in_ld="$with_demangler_in_ld",
232 # ----------------------
233 # Find default assembler
234 # ----------------------
238 [AS_HELP_STRING([--with-gnu-as], [arrange to work with GNU as])],
239 gas_flag="$with_gnu_as",
243 [AS_HELP_STRING([--with-as], [arrange to use the specified as (full pathname)])],
244 DEFAULT_ASSEMBLER="$with_as")
245 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
246 if test ! -x "$DEFAULT_ASSEMBLER"; then
247 AC_MSG_ERROR([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
248 elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
251 AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
252 [Define to enable the use of a default assembler.])
255 AC_MSG_CHECKING([whether a default assembler was specified])
256 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
257 if test x"$gas_flag" = x"no"; then
258 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
260 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
270 # If a non-executable a.out is present (e.g. created by GNU as above even if
271 # invoked with -v only), the IRIX 6 native ld just overwrites the existing
272 # file, even when creating an executable, so an execution test fails.
273 # Remove possible default executable files to avoid this.
275 # FIXME: This really belongs into AC_PROG_CC and can be removed once
276 # Autoconf includes it.
277 rm -f a.out a.exe b.out
279 # Find the native compiler
282 ACX_PROG_GNAT([-I"$srcdir"/ada])
284 # Remove the -O2: for historical reasons, unless bootstrapping we prefer
285 # optimizations to be activated explicitly by the toplevel.
288 *) CFLAGS=`echo "$CFLAGS " | sed -e "s/-Ofast[[ ]]//" -e "s/-O[[gs]][[ ]]//" -e "s/-O[[0-9]]*[[ ]]//" `
289 CXXFLAGS=`echo "$CXXFLAGS " | sed -e "s/-Ofast[[ ]]//" -e "s/-O[[gs]][[ ]]//" -e "s/-O[[0-9]]*[[ ]]//" ` ;;
294 # Determine PICFLAG for target gnatlib.
295 GCC_PICFLAG_FOR_TARGET
296 AC_SUBST(PICFLAG_FOR_TARGET)
298 # -------------------------
299 # Check C compiler features
300 # -------------------------
302 AC_USE_SYSTEM_EXTENSIONS
308 # sizeof(char) is 1 by definition.
309 AC_CHECK_SIZEOF(void *)
310 AC_CHECK_SIZEOF(short)
312 AC_CHECK_SIZEOF(long)
313 AC_CHECK_TYPES([long long], [AC_CHECK_SIZEOF(long long)])
315 if test x"$ac_cv_c_uint64_t" = x"no" -o x"$ac_cv_c_int64_t" = x"no"; then
316 AC_MSG_ERROR([uint64_t or int64_t not found])
319 # ---------------------
320 # Warnings and checking
321 # ---------------------
323 # Check $CC warning features (if it's GCC).
324 # We want to use -pedantic, but we don't want warnings about
328 # * C++11 narrowing conversions in { }
329 # So, we only use -pedantic if we can disable those warnings.
331 # In stage 1, disable -Wformat warnings from old GCCs about new % codes
332 AC_ARG_ENABLE(build-format-warnings,
333 AS_HELP_STRING([--disable-build-format-warnings],[don't use -Wformat while building GCC]),
334 [],[enable_build_format_warnings=yes])
335 AS_IF([test $enable_build_format_warnings = no],
336 [wf_opt=-Wno-format],[wf_opt=])
337 ACX_PROG_CC_WARNING_OPTS(
338 m4_quote(m4_do([-W -Wall -Wno-narrowing -Wwrite-strings -Wcast-qual $wf_opt])), [loose_warn])
339 ACX_PROG_CC_WARNING_OPTS(
340 m4_quote(m4_do([-Wstrict-prototypes -Wmissing-prototypes])),
342 ACX_PROG_CC_WARNING_OPTS(
343 m4_quote(m4_do([-Wmissing-format-attribute])), [strict_warn])
344 ACX_PROG_CC_WARNING_OPTS(
345 m4_quote(m4_do([-Woverloaded-virtual])), [strict_warn])
346 ACX_PROG_CC_WARNING_OPTS(
347 m4_quote(m4_do([-Wold-style-definition -Wc++-compat])), [c_strict_warn])
348 ACX_PROG_CC_WARNING_ALMOST_PEDANTIC(
349 m4_quote(m4_do([-Wno-long-long -Wno-variadic-macros ],
350 [-Wno-overlength-strings])), [strict_warn])
351 ACX_PROG_CC_WARNINGS_ARE_ERRORS([manual], [strict_warn])
353 # The above macros do nothing if the compiler is not GCC. However, the
354 # Makefile has more goo to add other flags, so these variables are used
355 # to enable warnings only for GCC.
358 if test "x$GCC" = "xyes"; then
359 warn_cflags='$(GCC_WARN_CFLAGS)'
360 warn_cxxflags='$(GCC_WARN_CXXFLAGS)'
362 AC_SUBST(warn_cflags)
363 AC_SUBST(warn_cxxflags)
365 # Disable exceptions and RTTI if building with g++
366 ACX_PROG_CC_WARNING_OPTS(
367 m4_quote(m4_do([-fno-exceptions -fno-rtti -fasynchronous-unwind-tables])),
370 # Enable expensive internal checks
372 if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then
376 AC_ARG_ENABLE(checking,
377 [AS_HELP_STRING([[--enable-checking[=LIST]]],
378 [enable expensive run-time checks. With LIST,
379 enable only specific categories of checks.
380 Categories are: yes,no,all,none,release.
381 Flags are: assert,df,fold,gc,gcac,gimple,misc,
382 rtlflag,rtl,runtime,tree,valgrind,types])],
383 [ac_checking_flags="${enableval}"],[
384 # Determine the default checks.
385 if test x$is_release = x ; then
386 ac_checking_flags=yes
388 ac_checking_flags=release
390 IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
391 for check in release $ac_checking_flags
394 # these set all the flags to specific states
395 yes) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking= ;
396 ac_fold_checking= ; ac_gc_checking=1 ;
397 ac_gc_always_collect= ; ac_gimple_checking=1 ; ac_rtl_checking= ;
398 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
399 ac_tree_checking=1 ; ac_valgrind_checking= ;
400 ac_types_checking=1 ;;
401 no|none) ac_assert_checking= ; ac_checking= ; ac_df_checking= ;
402 ac_fold_checking= ; ac_gc_checking= ;
403 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
404 ac_rtlflag_checking= ; ac_runtime_checking= ;
405 ac_tree_checking= ; ac_valgrind_checking= ;
406 ac_types_checking= ;;
407 all) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking=1 ;
408 ac_fold_checking=1 ; ac_gc_checking=1 ;
409 ac_gc_always_collect=1 ; ac_gimple_checking=1 ; ac_rtl_checking=1 ;
410 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
411 ac_tree_checking=1 ; ac_valgrind_checking= ;
412 ac_types_checking=1 ;;
413 release) ac_assert_checking=1 ; ac_checking= ; ac_df_checking= ;
414 ac_fold_checking= ; ac_gc_checking= ;
415 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
416 ac_rtlflag_checking= ; ac_runtime_checking=1 ;
417 ac_tree_checking= ; ac_valgrind_checking= ;
418 ac_types_checking= ;;
419 # these enable particular checks
420 assert) ac_assert_checking=1 ;;
421 df) ac_df_checking=1 ;;
422 fold) ac_fold_checking=1 ;;
423 gc) ac_gc_checking=1 ;;
424 gcac) ac_gc_always_collect=1 ;;
425 gimple) ac_gimple_checking=1 ;;
426 misc) ac_checking=1 ;;
427 rtl) ac_rtl_checking=1 ;;
428 rtlflag) ac_rtlflag_checking=1 ;;
429 runtime) ac_runtime_checking=1 ;;
430 tree) ac_tree_checking=1 ;;
431 types) ac_types_checking=1 ;;
432 valgrind) ac_valgrind_checking=1 ;;
433 *) AC_MSG_ERROR(unknown check category $check) ;;
439 if test x$ac_checking != x ; then
440 AC_DEFINE(ENABLE_CHECKING, 1,
441 [Define if you want more run-time sanity checks. This one gets a grab
442 bag of miscellaneous but relatively cheap checks.])
443 nocommon_flag=-fno-common
445 AC_SUBST(nocommon_flag)
446 if test x$ac_df_checking != x ; then
447 AC_DEFINE(ENABLE_DF_CHECKING, 1,
448 [Define if you want more run-time sanity checks for dataflow.])
450 if test x$ac_assert_checking != x ; then
451 AC_DEFINE(ENABLE_ASSERT_CHECKING, 1,
452 [Define if you want assertions enabled. This is a cheap check.])
454 if test x$ac_gimple_checking != x ; then
455 AC_DEFINE(ENABLE_GIMPLE_CHECKING, 1,
456 [Define if you want operations on GIMPLE (the basic data structure of
457 the high-level optimizers) to be checked for dynamic type safety at
458 runtime. This is moderately expensive.])
460 GCC_TARGET_TEMPLATE(ENABLE_RUNTIME_CHECKING)
461 if test x$ac_runtime_checking != x ; then
462 AC_DEFINE(ENABLE_RUNTIME_CHECKING, 1,
463 [Define if you want runtime assertions enabled. This is a cheap check.])
465 if test x$ac_tree_checking != x ; then
466 AC_DEFINE(ENABLE_TREE_CHECKING, 1,
467 [Define if you want all operations on trees (the basic data
468 structure of the front ends) to be checked for dynamic type safety
469 at runtime. This is moderately expensive. The tree browser debugging
470 routines will also be enabled by this option.
472 TREEBROWSER=tree-browser.o
475 if test x$ac_types_checking != x ; then
476 AC_DEFINE(ENABLE_TYPES_CHECKING, 1,
477 [Define if you want all gimple types to be verified after gimplifiation.
481 AC_SUBST(TREEBROWSER)
482 AC_SUBST(TREECHECKING)
483 if test x$ac_rtl_checking != x ; then
484 AC_DEFINE(ENABLE_RTL_CHECKING, 1,
485 [Define if you want all operations on RTL (the basic data structure
486 of the optimizer and back end) to be checked for dynamic type safety
487 at runtime. This is quite expensive.])
489 if test x$ac_rtlflag_checking != x ; then
490 AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
491 [Define if you want RTL flag accesses to be checked against the RTL
492 codes that are supported for each access macro. This is relatively
495 if test x$ac_gc_checking != x ; then
496 AC_DEFINE(ENABLE_GC_CHECKING, 1,
497 [Define if you want the garbage collector to do object poisoning and
498 other memory allocation checks. This is quite expensive.])
500 if test x$ac_gc_always_collect != x ; then
501 AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
502 [Define if you want the garbage collector to operate in maximally
503 paranoid mode, validating the entire heap and collecting garbage at
504 every opportunity. This is extremely expensive.])
506 if test x$ac_fold_checking != x ; then
507 AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
508 [Define if you want fold checked that it never destructs its argument.
509 This is quite expensive.])
511 valgrind_path_defines=
514 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
515 dnl # an if statement. This was the source of very frustrating bugs
516 dnl # in converting to autoconf 2.5x!
517 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
519 # It is certainly possible that there's valgrind but no valgrind.h.
520 # GCC relies on making annotations so we must have both.
521 AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
522 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
523 [[#include <valgrind/memcheck.h>
524 #ifndef VALGRIND_DISCARD
525 #error VALGRIND_DISCARD not defined
527 [gcc_cv_header_valgrind_memcheck_h=yes],
528 [gcc_cv_header_valgrind_memcheck_h=no])
529 AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
530 AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
531 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
532 [[#include <memcheck.h>
533 #ifndef VALGRIND_DISCARD
534 #error VALGRIND_DISCARD not defined
536 [gcc_cv_header_memcheck_h=yes],
537 [gcc_cv_header_memcheck_h=no])
538 AC_MSG_RESULT($gcc_cv_header_memcheck_h)
539 if test $gcc_cv_header_valgrind_memcheck_h = yes; then
540 AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
541 [Define if valgrind's valgrind/memcheck.h header is installed.])
543 if test $gcc_cv_header_memcheck_h = yes; then
544 AC_DEFINE(HAVE_MEMCHECK_H, 1,
545 [Define if valgrind's memcheck.h header is installed.])
548 if test x$ac_valgrind_checking != x ; then
549 AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
550 [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
551 if test "x$valgrind_path" = "x" \
552 || (test $have_valgrind_h = no \
553 && test $gcc_cv_header_memcheck_h = no \
554 && test $gcc_cv_header_valgrind_memcheck_h = no); then
555 AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
557 valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
558 valgrind_command="$valgrind_path -q"
559 AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
560 [Define if you want to run subprograms and generated programs
561 through valgrind (a memory checker). This is extremely expensive.])
563 AC_SUBST(valgrind_path_defines)
564 AC_SUBST(valgrind_command)
566 # Enable code coverage collection
567 AC_ARG_ENABLE(coverage,
568 [AS_HELP_STRING([[--enable-coverage[=LEVEL]]],
569 [enable compiler's code coverage collection.
570 Use to measure compiler performance and locate
571 unused parts of the compiler. With LEVEL, specify
572 optimization. Values are opt, noopt,
574 [case "${enableval}" in
576 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
579 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
582 # a.k.a. --disable-coverage
586 AC_MSG_ERROR(unknown coverage setting $enableval)
590 AC_SUBST(coverage_flags)
592 AC_ARG_ENABLE(gather-detailed-mem-stats,
593 [AS_HELP_STRING([--enable-gather-detailed-mem-stats],
594 [enable detailed memory allocation stats gathering])], [],
595 [enable_gather_detailed_mem_stats=no])
596 gather_stats=`if test $enable_gather_detailed_mem_stats != no; then echo 1; else echo 0; fi`
597 AC_DEFINE_UNQUOTED(GATHER_STATISTICS, $gather_stats,
598 [Define to enable detailed memory allocation stats gathering.])
600 AC_ARG_ENABLE(valgrind-annotations,
601 [AS_HELP_STRING([--enable-valgrind-annotations],
602 [enable valgrind runtime interaction])], [],
603 [enable_valgrind_annotations=no])
604 if test x$enable_valgrind_annotations != xno \
605 || test x$ac_valgrind_checking != x; then
606 if (test $have_valgrind_h = no \
607 && test $gcc_cv_header_memcheck_h = no \
608 && test $gcc_cv_header_valgrind_memcheck_h = no); then
609 AC_MSG_ERROR([*** Can't find valgrind/memcheck.h, memcheck.h or valgrind.h])
611 AC_DEFINE(ENABLE_VALGRIND_ANNOTATIONS, 1,
612 [Define to get calls to the valgrind runtime enabled.])
615 # -------------------------------
616 # Miscenalleous configure options
617 # -------------------------------
621 [AS_HELP_STRING([--with-stabs],
622 [arrange to use stabs instead of host debug format])],
626 # Determine whether or not multilibs are enabled.
627 AC_ARG_ENABLE(multilib,
628 [AS_HELP_STRING([--enable-multilib],
629 [enable library support for multiple ABIs])],
630 [], [enable_multilib=yes])
631 AC_SUBST(enable_multilib)
633 # Determine whether or not multiarch is enabled.
634 AC_ARG_ENABLE(multiarch,
635 [AS_HELP_STRING([--enable-multiarch],
636 [enable support for multiarch paths])],
637 [case "${enableval}" in
638 yes|no|auto) enable_multiarch=$enableval;;
639 *) AC_MSG_ERROR(bad value ${enableval} given for --enable-multiarch option) ;;
640 esac], [enable_multiarch=auto])
641 if test x${enable_multiarch} = xauto; then
642 if test x${with_native_system_header_dir} != x; then
643 ma_msg_suffix=", disabled auto check (configured with --native-system-header-dir)"
646 if test x$host != x$target && test "x$with_sysroot" = x; then
647 ma_msg_suffix=", disabled auto check (cross build configured without --with-sysroot)"
651 AC_MSG_CHECKING(for multiarch configuration)
652 AC_SUBST(enable_multiarch)
653 AC_MSG_RESULT($enable_multiarch$ma_msg_suffix)
655 # needed for setting the multiarch name for soft-float/hard-float ABIs
659 # Enable __cxa_atexit for C++.
660 AC_ARG_ENABLE(__cxa_atexit,
661 [AS_HELP_STRING([--enable-__cxa_atexit], [enable __cxa_atexit for C++])],
664 # Enable C extension for decimal float if target supports it.
665 GCC_AC_ENABLE_DECIMAL_FLOAT([$target])
667 dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi`
668 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp,
669 [Define to 1 to enable decimal float extension to C.])
671 # Use default_decimal_float for dependency.
672 enable_decimal_float=$default_decimal_float
674 bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi`
675 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid,
676 [Define to 1 to specify that we are using the BID decimal floating
677 point format instead of DPD])
679 # Enable C extension for fixed-point arithmetic.
680 AC_ARG_ENABLE(fixed-point,
681 [AS_HELP_STRING([--enable-fixed-point],
682 [enable fixed-point arithmetic extension to C])],
687 enable_fixed_point=yes
691 enable_fixed_point=yes
694 AC_MSG_WARN([fixed-point is not supported for this target, ignored])
695 enable_fixed_point=no
699 AC_SUBST(enable_fixed_point)
701 fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi`
702 AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint,
703 [Define to 1 to enable fixed-point arithmetic extension to C.])
706 # Pass with no value to take the default
707 # Pass with a value to specify a thread package
708 AC_ARG_ENABLE(threads,
709 [AS_HELP_STRING([[--enable-threads[=LIB]]],
710 [enable thread usage for target GCC,
711 using LIB thread package])],,
715 [AS_HELP_STRING([--enable-tls],
716 [enable or disable generation of tls code
717 overriding the assembler check for tls support])],
721 *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
722 Valid choices are 'yes' and 'no'.]) ;;
726 AC_ARG_ENABLE(objc-gc,
727 [AS_HELP_STRING([--enable-objc-gc],
728 [enable the use of Boehm's garbage collector with
729 the GNU Objective-C runtime])],
730 if test x$enable_objc_gc = xno; then
738 [AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2])],
739 dwarf2="$with_dwarf2",
742 AC_ARG_ENABLE(shared,
743 [AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])],
745 case $enable_shared in
749 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
750 for pkg in $enableval; do
751 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
758 ], [enable_shared=yes])
759 AC_SUBST(enable_shared)
761 AC_ARG_WITH([native-system-header-dir],
762 [ --with-native-system-header-dir=dir
763 use dir as the directory to look for standard
764 system header files in. Defaults to /usr/include.],
766 case ${with_native_system_header_dir} in
767 yes|no) AC_MSG_ERROR([bad value ${withval} given for --with-native-system-header-dir]) ;;
768 /* | [[A-Za-z]]:[[\\/]]*) ;;
769 *) AC_MSG_ERROR([--with-native-system-header-dir argument ${withval} must be an absolute directory]) ;;
771 configured_native_system_header_dir="${withval}"
772 ], [configured_native_system_header_dir=])
774 AC_ARG_WITH(build-sysroot,
775 [AS_HELP_STRING([--with-build-sysroot=sysroot],
776 [use sysroot as the system root during the build])],
777 [if test x"$withval" != x ; then
778 SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
780 [SYSROOT_CFLAGS_FOR_TARGET=])
781 AC_SUBST(SYSROOT_CFLAGS_FOR_TARGET)
783 if test "x$prefix" = xNONE; then
784 test_prefix=/usr/local
788 if test "x$exec_prefix" = xNONE; then
789 test_exec_prefix=$test_prefix
791 test_exec_prefix=$exec_prefix
795 [AS_HELP_STRING([[--with-sysroot[=DIR]]],
796 [search for usr/lib, usr/include, et al, within DIR])],
798 case ${with_sysroot} in
799 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
800 *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
803 TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
804 CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
806 case ${TARGET_SYSTEM_ROOT} in
807 "${test_prefix}"|"${test_prefix}/"*|\
808 "${test_exec_prefix}"|"${test_exec_prefix}/"*|\
809 '${prefix}'|'${prefix}/'*|\
810 '${exec_prefix}'|'${exec_prefix}/'*)
811 t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
812 TARGET_SYSTEM_ROOT_DEFINE="$t"
817 TARGET_SYSTEM_ROOT_DEFINE=
818 CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
820 AC_SUBST(TARGET_SYSTEM_ROOT)
821 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
822 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
825 [AS_HELP_STRING([--with-specs=SPECS],
826 [add SPECS to driver command-line processing])],
827 [CONFIGURE_SPECS=$withval],
830 AC_SUBST(CONFIGURE_SPECS)
832 ACX_PKGVERSION([GCC])
833 ACX_BUGURL([http://gcc.gnu.org/bugs.html])
835 # Sanity check enable_languages in case someone does not run the toplevel
836 # configure # script.
837 AC_ARG_ENABLE(languages,
838 [AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])],
839 [case ,${enable_languages}, in
841 # go safe -- we cannot be much sure without the toplevel
843 # analysis of which target libs are present and usable
847 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
852 enable_languages=c,${enable_languages}
855 [enable_languages=c])
857 AC_ARG_WITH(multilib-list,
858 [AS_HELP_STRING([--with-multilib-list], [select multilibs (AArch64, SH and x86-64 only)])],
860 with_multilib_list=default)
862 # -------------------------
863 # Checks for other programs
864 # -------------------------
868 # Find some useful tools
870 # We need awk to create options.c and options.h.
871 # Bail out if it's missing.
873 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
880 AC_SUBST(ranlib_flags)
884 # See if cmp has --ignore-initial.
885 gcc_AC_PROG_CMP_IGNORE_INITIAL
887 # See if we have the mktemp command.
888 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
890 # See if makeinfo has been installed and is modern enough
891 # that we can use it.
892 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
893 [GNU texinfo.* \([0-9][0-9.]*\)],
894 [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
895 if test $gcc_cv_prog_makeinfo_modern = no; then
897 *** Makeinfo is missing or too old.
898 *** Info documentation will not be built.])
905 # Is pod2man recent enough to regenerate manpages?
906 AC_MSG_CHECKING([for recent Pod::Man])
907 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
909 GENERATED_MANPAGES=generated-manpages
914 AC_SUBST(GENERATED_MANPAGES)
916 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
919 dnl Don't use AC_PROG_LEX; we insist on flex.
920 dnl LEXLIB is not useful in gcc.
921 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
924 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
926 # Binutils are not build modules, unlike bison/flex/makeinfo. So we
927 # check for build == host before using them.
930 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
931 && test -d ../binutils ; then
932 NM='${objdir}/../binutils/nm-new'
934 AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
938 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
939 && test -d ../binutils ; then
940 AR='${objdir}/../binutils/ar'
942 AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
946 # --------------------
947 # Checks for C headers
948 # --------------------
950 # Need to reject headers which give warnings, so that the -Werror bootstrap
951 # works later. *sigh* This needs to come before all header checks.
959 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
960 fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
961 sys/resource.h sys/param.h sys/times.h sys/stat.h \
962 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
964 # Check for thread headers.
965 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
966 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
968 # These tests can't be done till we know if we have limits.h.
972 # ----------------------
973 # Checks for C++ headers
974 # ----------------------
976 dnl Autoconf will give an error in the configure script if there is no
977 dnl C++ preprocessor. Hack to prevent that.
978 m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl
980 m4_popdef([AC_MSG_ERROR])[]dnl
984 AC_CHECK_HEADERS(unordered_map)
985 AC_CHECK_HEADERS(tr1/unordered_map)
986 AC_CHECK_HEADERS(ext/hash_map)
991 # Dependency checking.
996 AC_CONFIG_COMMANDS([gccdepdir],[
997 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs build/$DEPDIR
998 for lang in $subdirs c-family common
1000 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs $lang/$DEPDIR
1001 done], [subdirs="$subdirs" ac_aux_dir=$ac_aux_dir DEPDIR=$DEPDIR])
1003 ZW_PROG_COMPILER_DEPENDENCIES([CXX])
1011 # These libraries may be used by collect2.
1012 # We may need a special search path to get them linked.
1013 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
1015 for libs in '' -lld -lmld \
1016 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
1017 '-L/usr/lib/cmplrs/cc3.11 -lmld'
1020 AC_TRY_LINK_FUNC(ldopen,
1021 [gcc_cv_collect2_libs="$libs"; break])
1024 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
1025 case $gcc_cv_collect2_libs in
1027 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
1029 AC_SUBST(COLLECT2_LIBS)
1031 # When building Ada code on Alpha, we need exc_resume which is usually in
1032 # -lexc. So test for it.
1035 AC_SEARCH_LIBS(exc_resume, exc)
1038 AC_SUBST(GNAT_LIBEXC)
1040 # To support -mcpu=native on Solaris/SPARC, we need libkstat.
1043 AC_SEARCH_LIBS(kstat_open, kstat)
1044 EXTRA_GCC_LIBS="$LIBS"
1046 AC_SUBST(EXTRA_GCC_LIBS)
1048 # Some systems put ldexp and frexp in libm instead of libc; assume
1049 # they're both in the same place. jcf-dump needs them.
1052 AC_SEARCH_LIBS(ldexp, m)
1057 # Use <inttypes.h> only if it exists,
1058 # doesn't clash with <sys/types.h>, and declares intmax_t.
1059 AC_MSG_CHECKING(for inttypes.h)
1060 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
1061 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1062 [[#include <sys/types.h>
1063 #include <inttypes.h>]],
1064 [[intmax_t i = -1;]])],
1065 [gcc_cv_header_inttypes_h=yes],
1066 [gcc_cv_header_inttypes_h=no])])
1067 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
1068 if test $gcc_cv_header_inttypes_h = yes; then
1069 AC_DEFINE(HAVE_INTTYPES_H, 1,
1070 [Define if you have a working <inttypes.h> header file.])
1073 dnl Disabled until we have a complete test for buggy enum bitfields.
1074 dnl gcc_AC_C_ENUM_BF_UNSIGNED
1076 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
1077 ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
1078 fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
1079 fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
1080 putchar_unlocked putc_unlocked)
1081 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoll atoq \
1082 sysconf strsignal getrusage nl_langinfo \
1083 gettimeofday mbstowcs wcswidth mmap setlocale \
1084 gcc_UNLOCKED_FUNCS madvise)
1086 if test x$ac_cv_func_mbstowcs = xyes; then
1087 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
1088 [ AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
1094 [gcc_cv_func_mbstowcs_works=yes],
1095 [gcc_cv_func_mbstowcs_works=no],
1096 [gcc_cv_func_mbstowcs_works=yes])])
1097 if test x$gcc_cv_func_mbstowcs_works = xyes; then
1098 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
1099 [Define this macro if mbstowcs does not crash when its
1100 first argument is NULL.])
1104 AC_CHECK_TYPE(ssize_t, int)
1105 AC_CHECK_TYPE(caddr_t, char *)
1107 GCC_AC_FUNC_MMAP_BLACKLIST
1111 # Under VMS, vfork works very differently than on Unix. The standard test
1112 # won't work, and it isn't easily adaptable. It makes more sense to
1114 ac_cv_func_vfork_works=yes
1119 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which exposes a different
1120 # iconv() prototype.
1125 # Until we have in-tree GNU iconv:
1127 AC_SUBST(LIBICONV_DEP)
1133 # We will need to find libiberty.h and ansidecl.h
1134 saved_CFLAGS="$CFLAGS"
1135 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1136 saved_CXXFLAGS="$CXXFLAGS"
1137 CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1138 gcc_AC_CHECK_DECLS(getenv atol asprintf sbrk abort atof getcwd getwd \
1139 strsignal strstr stpcpy strverscmp \
1140 errno snprintf vsnprintf vasprintf malloc realloc calloc \
1141 free basename getopt clock getpagesize ffs gcc_UNLOCKED_FUNCS, , ,[
1142 #include "ansidecl.h"
1143 #include "system.h"])
1145 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1146 #include "ansidecl.h"
1148 #ifdef HAVE_SYS_RESOURCE_H
1149 #include <sys/resource.h>
1153 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1154 #include "ansidecl.h"
1156 #ifdef HAVE_SYS_RESOURCE_H
1157 #include <sys/resource.h>
1159 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1160 [Define to `long' if <sys/resource.h> doesn't define.])])
1162 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1163 # FREAD and FWRITE macros. Fortunately, for GCC's single usage of ldgetname
1164 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1165 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1166 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1167 #include "ansidecl.h"
1176 gcc_AC_CHECK_DECLS(times, , ,[
1177 #include "ansidecl.h"
1179 #ifdef HAVE_SYS_TIMES_H
1180 #include <sys/times.h>
1184 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1185 #include "ansidecl.h"
1190 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which hides the madvise()
1193 gcc_AC_CHECK_DECLS(madvise, , ,[
1194 #include "ansidecl.h"
1199 # More time-related stuff.
1200 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1201 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1202 #include "ansidecl.h"
1204 #ifdef HAVE_SYS_TIMES_H
1205 #include <sys/times.h>
1207 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1208 if test $ac_cv_struct_tms = yes; then
1209 AC_DEFINE(HAVE_STRUCT_TMS, 1,
1210 [Define if <sys/times.h> defines struct tms.])
1213 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1214 # revisit after autoconf 2.50.
1215 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1216 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1217 #include "ansidecl.h"
1219 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1220 if test $gcc_cv_type_clock_t = yes; then
1221 AC_DEFINE(HAVE_CLOCK_T, 1,
1222 [Define if <time.h> defines clock_t.])
1225 # Check if F_SETLKW is supported by fcntl.
1226 AC_CACHE_CHECK(for F_SETLKW, ac_cv_f_setlkw, [
1227 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1228 #include <fcntl.h>]], [[
1234 return fcntl (1, F_SETLKW, &fl);]])],
1235 [ac_cv_f_setlkw=yes],[ac_cv_f_setlkw=no])])
1236 if test $ac_cv_f_setlkw = yes; then
1237 AC_DEFINE(HOST_HAS_F_SETLKW, 1,
1238 [Define if F_SETLKW supported by fcntl.])
1241 # Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1242 CFLAGS="$saved_CFLAGS"
1243 CXXFLAGS="$saved_CXXFLAGS"
1245 # mkdir takes a single argument on some systems.
1246 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1254 # With Setjmp/Longjmp based exception handling.
1255 AC_ARG_ENABLE(sjlj-exceptions,
1256 [AS_HELP_STRING([--enable-sjlj-exceptions],
1257 [arrange to use setjmp/longjmp exception handling])],
1260 if test $enableval != yes; then
1261 AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1266 force_sjlj_exceptions=yes],
1269 force_sjlj_exceptions=yes
1273 force_sjlj_exceptions=yes
1277 force_sjlj_exceptions=no
1280 if test $force_sjlj_exceptions = yes; then
1281 sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1282 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1283 [Define 0/1 to force the choice for exception handling model.])
1286 # --------------------------------------------------------
1287 # Build, host, and target specific configuration fragments
1288 # --------------------------------------------------------
1290 # Collect build-machine-specific information.
1291 . ${srcdir}/config.build
1293 # Collect host-machine-specific information.
1294 . ${srcdir}/config.host
1298 # Collect target-machine-specific information.
1299 . ${srcdir}/config.gcc
1301 extra_objs="${host_extra_objs} ${extra_objs}"
1302 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1304 # Default the target-machine variables that were not explicitly set.
1305 if test x"$tm_file" = x
1306 then tm_file=$cpu_type/$cpu_type.h; fi
1308 if test x"$extra_headers" = x
1309 then extra_headers=; fi
1311 if test x$md_file = x
1312 then md_file=$cpu_type/$cpu_type.md; fi
1314 if test x$out_file = x
1315 then out_file=$cpu_type/$cpu_type.c; fi
1317 if test x"$tmake_file" = x
1318 then tmake_file=$cpu_type/t-$cpu_type
1321 # Support --enable-initfini-array.
1322 if test x$enable_initfini_array != xno; then
1323 tm_file="${tm_file} initfini-array.h"
1326 if test x"$dwarf2" = xyes
1327 then tm_file="$tm_file tm-dwarf2.h"
1330 # Say what files are being used for the output code and MD file.
1331 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1332 echo "Using \`$srcdir/config/$md_file' as machine description file."
1334 # If any of the xm_file variables contain nonexistent files, warn
1335 # about them and drop them.
1338 for x in $build_xm_file; do
1339 if test -f $srcdir/config/$x
1341 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1347 for x in $host_xm_file; do
1348 if test -f $srcdir/config/$x
1350 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1356 for x in $xm_file; do
1357 if test -f $srcdir/config/$x
1359 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1365 for f in $tm_file; do
1368 if test $count = ax; then
1369 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1371 echo "Using the following target machine macro files:"
1372 for f in $tm_file; do
1373 echo " $srcdir/config/$f"
1377 if test x$use_long_long_for_widest_fast_int = xyes; then
1378 AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1379 [Define to 1 if the 'long long' type is wider than 'long' but still
1380 efficiently supported by the host hardware.])
1383 gnu_ld_bool=`if test x"$gnu_ld" = x"yes"; then echo 1; else echo 0; fi`
1384 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld_bool, [Define to 1 if using GNU ld.])
1386 gnu_as_bool=`if test x"$gas" = x"yes"; then echo 1; else echo 0; fi`
1387 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as_bool, [Define to 1 if using GNU as.])
1390 for f in $host_xm_file; do
1393 if test $count = a; then
1395 elif test $count = ax; then
1396 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1398 echo "Using the following host machine macro files:"
1399 for f in $host_xm_file; do
1400 echo " $srcdir/config/$f"
1403 echo "Using ${out_host_hook_obj} for host machine hooks."
1405 if test "$host_xm_file" != "$build_xm_file"; then
1407 for f in $build_xm_file; do
1410 if test $count = a; then
1412 elif test $count = ax; then
1413 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1415 echo "Using the following build machine macro files:"
1416 for f in $build_xm_file; do
1417 echo " $srcdir/config/$f"
1422 if test -n "$configured_native_system_header_dir"; then
1423 native_system_header_dir=$configured_native_system_header_dir
1425 NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir"
1426 AC_SUBST(NATIVE_SYSTEM_HEADER_DIR)
1430 AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1431 gcc_cv_mcontext_underscores,
1433 #include <sys/cdefs.h>
1434 #include <sys/signal.h>
1435 #include <ucontext.h>
1436 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1438 gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1439 if test $gcc_cv_mcontext_underscores = yes; then
1440 AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1441 [mcontext_t fields start with __])
1450 # Check if a valid thread package
1451 case ${enable_threads} in
1454 target_thread_file='single'
1458 target_thread_file='single'
1460 aix | dce | lynx | mipssde | posix | rtems | \
1461 single | tpf | vxworks | win32)
1462 target_thread_file=${enable_threads}
1465 echo "${enable_threads} is an unknown thread package" 1>&2
1470 if test x${thread_file} = x; then
1471 # No thread file set by target-specific clauses in config.gcc,
1472 # so use file chosen by default logic above
1473 thread_file=${target_thread_file}
1481 if test x$enable___cxa_atexit = xyes || \
1482 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1483 if test x$host = x$target; then
1485 # mingw32 doesn't have __cxa_atexit but uses atexit registration
1486 # keyed to flag_use_cxa_atexit
1494 AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1495 [echo "__cxa_atexit can't be enabled on this target"])
1499 # We can't check for __cxa_atexit when building a cross, so assume
1503 if test x$use_cxa_atexit = xyes; then
1504 AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1505 [Define if you want to use __cxa_atexit, rather than atexit, to
1506 register C++ destructors for local statics and global objects.
1507 This is essential for fully standards-compliant handling of
1508 destructors, but requires __cxa_atexit in libc.])
1512 # Look for a file containing extra machine modes.
1513 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1514 extra_modes_file='$(srcdir)'/config/${extra_modes}
1515 AC_SUBST(extra_modes_file)
1516 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1517 [Define to the name of a file containing a list of extra machine modes
1518 for this architecture.])
1521 # Convert extra_options into a form suitable for Makefile use.
1524 for f in $extra_options; do
1525 extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1526 all_opt_files="$all_opt_files $srcdir/config/$f"
1528 AC_SUBST(extra_opt_files)
1530 # auto-host.h is the file containing items generated by autoconf and is
1531 # the first file included by config.h.
1532 # If host=build, it is correct to have bconfig include auto-host.h
1533 # as well. If host!=build, we are in error and need to do more
1534 # work to find out the build config parameters.
1535 if test x$host = x$build
1537 build_auto=auto-host.h
1539 # We create a subdir, then run autoconf in the subdir.
1540 # To prevent recursion we set host and build for the new
1541 # invocation of configure to the build for this invocation
1548 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1549 *) realsrcdir=../${srcdir};;
1551 # Clearing GMPINC is necessary to prevent host headers being
1552 # used by the build compiler. Defining GENERATOR_FILE stops
1553 # system.h from including gmp.h.
1554 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1555 CXX="${CXX_FOR_BUILD}" CXXFLAGS="${CXXFLAGS_FOR_BUILD}" \
1556 LD="${LD_FOR_BUILD}" LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1557 GMPINC="" CPPFLAGS="${CPPFLAGS} -DGENERATOR_FILE" \
1558 ${realsrcdir}/configure \
1559 --enable-languages=${enable_languages-all} \
1560 --target=$target_alias --host=$build_alias --build=$build_alias
1562 # We just finished tests for the build machine, so rename
1563 # the file auto-build.h in the gcc directory.
1564 mv auto-host.h ../auto-build.h
1567 build_auto=auto-build.h
1569 AC_SUBST(build_subdir)
1571 tm_file="${tm_file} defaults.h"
1572 tm_p_file="${tm_p_file} tm-preds.h"
1573 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1574 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1575 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1576 # put this back in temporarily.
1577 xm_file="auto-host.h ansidecl.h ${xm_file}"
1584 # Compile in configure arguments.
1585 if test -f configargs.h ; then
1586 # Being re-configured.
1587 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1588 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1590 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1593 # Double all backslashes and backslash all quotes to turn
1594 # gcc_config_arguments into a C string.
1595 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1596 $gcc_config_arguments
1598 gcc_config_arguments_str=`cat conftest.out`
1601 cat > configargs.h <<EOF
1602 /* Generated automatically. */
1603 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1604 static const char thread_model[] = "$thread_file";
1606 static const struct {
1607 const char *name, *value;
1608 } configure_default_options[] = $configure_default_options;
1613 gcc_BASEVER=`cat $srcdir/BASE-VER`
1614 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
1615 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
1616 if test -f $srcdir/REVISION ; then
1617 gcc_REVISION=`cat $srcdir/REVISION`
1621 cat > plugin-version.h <<EOF
1622 #include "configargs.h"
1624 #define GCCPLUGIN_VERSION_MAJOR `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'`
1625 #define GCCPLUGIN_VERSION_MINOR `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'`
1626 #define GCCPLUGIN_VERSION_PATCHLEVEL `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'`
1627 #define GCCPLUGIN_VERSION (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR)
1629 static char basever[] = "$gcc_BASEVER";
1630 static char datestamp[] = "$gcc_DATESTAMP";
1631 static char devphase[] = "$gcc_DEVPHASE";
1632 static char revision[] = "$gcc_REVISION";
1634 /* FIXME plugins: We should make the version information more precise.
1635 One way to do is to add a checksum. */
1637 static struct plugin_gcc_version gcc_version = {basever, datestamp,
1639 configuration_arguments};
1643 # Internationalization
1644 ZW_GNU_GETTEXT_SISTER_DIR
1646 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1647 # -liconv on the link line twice.
1648 case "$LIBINTL" in *$LIBICONV*)
1652 AC_ARG_ENABLE(secureplt,
1653 [AS_HELP_STRING([--enable-secureplt],
1654 [enable -msecure-plt by default for PowerPC])],
1657 AC_ARG_ENABLE(leading-mingw64-underscores,
1658 AS_HELP_STRING([--enable-leading-mingw64-underscores],
1659 [enable leading underscores on 64 bit mingw targets]),
1661 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
1662 [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
1663 [Define if we should use leading underscore on 64 bit mingw targets])])
1666 [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [],
1669 AC_ARG_ENABLE(frame-pointer,
1670 [AS_HELP_STRING([--enable-frame-pointer],
1671 [enable -fno-omit-frame-pointer by default for 32bit x86])], [],
1674 linux* | darwin[[8912]]*)
1675 # Enable -fomit-frame-pointer by default for Linux and Darwin with
1677 enable_frame_pointer=no
1680 enable_frame_pointer=yes
1685 # Windows32 Registry support for specifying GCC installation paths.
1686 AC_ARG_ENABLE(win32-registry,
1687 [AS_HELP_STRING([--disable-win32-registry],
1688 [disable lookup of installation paths in the
1689 Registry on Windows hosts])
1690 AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)])
1691 AS_HELP_STRING([--enable-win32-registry=KEY],
1692 [use KEY instead of GCC version as the last portion
1693 of the registry key])],,)
1696 win32 | pe | cygwin* | mingw32* | uwin*)
1697 if test "x$enable_win32_registry" != xno; then
1698 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1701 if test "x$enable_win32_registry" != xno; then
1702 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1703 [Define to 1 if installation paths should be looked up in the Windows
1704 Registry. Ignored on non-Windows hosts.])
1706 if test "x$enable_win32_registry" != xyes \
1707 && test "x$enable_win32_registry" != x; then
1708 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1709 [Define to be the last component of the Windows registry key under which
1710 to look for installation paths. The full key used will be
1711 HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1712 The default is the GCC version number.])
1718 # Get an absolute path to the GCC top-level source directory
1719 holddir=`${PWDCMD-pwd}`
1721 topdir=`${PWDCMD-pwd}`
1724 # Conditionalize the makefile for this host machine.
1726 for f in ${host_xmake_file}
1728 if test -f ${srcdir}/config/$f
1730 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1734 # Conditionalize the makefile for this target machine.
1736 for f in ${tmake_file}
1738 if test -f ${srcdir}/config/$f
1740 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1743 tmake_file="${tmake_file_}"
1745 out_object_file=`basename $out_file .c`.o
1746 common_out_object_file=`basename $common_out_file .c`.o
1748 tm_file_list="options.h"
1749 tm_include_list="options.h insn-constants.h"
1750 for f in $tm_file; do
1753 f=`echo $f | sed 's/^..//'`
1754 tm_file_list="${tm_file_list} $f"
1755 tm_include_list="${tm_include_list} $f"
1758 tm_file_list="${tm_file_list} \$(srcdir)/$f"
1759 tm_include_list="${tm_include_list} $f"
1762 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1763 tm_include_list="${tm_include_list} config/$f"
1770 for f in $tm_p_file; do
1773 tm_p_file_list="${tm_p_file_list} $f"
1774 tm_p_include_list="${tm_p_include_list} $f"
1777 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1778 tm_p_include_list="${tm_p_include_list} config/$f"
1784 for f in $xm_file; do
1787 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1788 xm_include_list="${xm_include_list} $f"
1791 xm_file_list="${xm_file_list} $f"
1792 xm_include_list="${xm_include_list} $f"
1795 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1796 xm_include_list="${xm_include_list} config/$f"
1802 host_xm_include_list=
1803 for f in $host_xm_file; do
1806 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1807 host_xm_include_list="${host_xm_include_list} $f"
1810 host_xm_file_list="${host_xm_file_list} $f"
1811 host_xm_include_list="${host_xm_include_list} $f"
1814 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1815 host_xm_include_list="${host_xm_include_list} config/$f"
1821 for f in $build_xm_file; do
1824 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1825 build_xm_include_list="${build_xm_include_list} $f"
1827 auto-build.h | auto-host.h )
1828 build_xm_file_list="${build_xm_file_list} $f"
1829 build_xm_include_list="${build_xm_include_list} $f"
1832 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1833 build_xm_include_list="${build_xm_include_list} config/$f"
1838 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1839 # cross-compiler which does not use the native headers and libraries.
1840 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1841 CROSS= AC_SUBST(CROSS)
1842 ALL=all.internal AC_SUBST(ALL)
1843 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1845 if test "x$with_build_sysroot" != x; then
1846 build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1848 # This value is used, even on a native system, because
1849 # CROSS_SYSTEM_HEADER_DIR is just
1850 # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1851 build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1854 if test x$host != x$target
1856 CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1858 SYSTEM_HEADER_DIR=$build_system_header_dir
1859 case "$host","$target" in
1860 # Darwin crosses can use the host system's libraries and headers,
1861 # because of the fat library support. Of course, it must be the
1862 # same version of Darwin on both sides. Allow the user to
1863 # just say --target=foo-darwin without a version number to mean
1864 # "the version on this system".
1865 *-*-darwin*,*-*-darwin*)
1866 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1867 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1868 if test $hostos = $targetos -o $targetos = darwin ; then
1870 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1875 i?86-*-*,x86_64-*-* \
1876 | powerpc*-*-*,powerpc64*-*-*)
1877 CROSS="$CROSS -DNATIVE_CROSS" ;;
1882 if test "x$with_headers" = x; then
1889 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1890 SYSTEM_HEADER_DIR=$build_system_header_dir
1893 # If this is a cross-compiler that does not
1894 # have its own set of headers then define
1897 # If this is using newlib, without having the headers available now,
1898 # then define inhibit_libc in LIBGCC2_CFLAGS.
1899 # This prevents libgcc2 from containing any code which requires libc
1901 : ${inhibit_libc=false}
1902 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1903 test x$with_newlib = xyes ; } &&
1904 { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1907 AC_SUBST(inhibit_libc)
1909 # When building gcc with a cross-compiler, we need to adjust things so
1910 # that the generator programs are still built with the native compiler.
1911 # Also, we cannot run fixincludes.
1913 # These are the normal (build=host) settings:
1914 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
1915 CXX_FOR_BUILD='$(CXX)' AC_SUBST(CXX_FOR_BUILD)
1916 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
1917 BUILD_CXXFLAGS='$(ALL_CXXFLAGS)' AC_SUBST(BUILD_CXXFLAGS)
1918 BUILD_LDFLAGS='$(LDFLAGS)' AC_SUBST(BUILD_LDFLAGS)
1919 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
1921 # And these apply if build != host, or we are generating coverage data
1922 if test x$build != x$host || test "x$coverage_flags" != x
1924 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1925 BUILD_CXXFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CXXFLAGS_FOR_BUILD)'
1926 BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
1929 # Expand extra_headers to include complete path.
1930 # This substitutes for lots of t-* files.
1932 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1933 for file in ${extra_headers} ; do
1934 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1937 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
1938 if test x"$use_gcc_tgmath" = xyes
1939 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
1942 # Define collect2 in Makefile.
1943 case $host_can_use_collect2 in
1945 *) collect2='collect2$(exeext)' ;;
1947 AC_SUBST([collect2])
1949 # Add a definition of USE_COLLECT2 if system wants one.
1950 case $use_collect2 in
1951 no) use_collect2= ;;
1954 host_xm_defines="${host_xm_defines} USE_COLLECT2"
1955 xm_defines="${xm_defines} USE_COLLECT2"
1956 case $host_can_use_collect2 in
1958 AC_MSG_ERROR([collect2 is required but cannot be built on this system])
1964 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
1965 [Define to the name of the LTO plugin DSO that must be
1966 passed to the linker's -plugin=LIB option.])
1968 # ---------------------------
1969 # Assembler & linker features
1970 # ---------------------------
1972 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
1973 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
1974 # However when ld-new is first executed from the build tree, libtool will
1975 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
1976 # to the build tree. While doing this we need to use the previous-stage
1977 # linker, or we have an infinite loop. The presence of a shell script as
1978 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
1979 # the gcc/collect-ld script. So we need to know how libtool works, or
1980 # exec-tool will fail.
1982 m4_defun([_LT_CONFIG_COMMANDS], [])
1985 AC_SUBST(enable_fast_install)
1987 # Identify the assembler which will work hand-in-glove with the newly
1988 # built GCC, so that we can examine its features. This is the assembler
1989 # which will be driven by the driver program.
1991 # If build != host, and we aren't building gas in-tree, we identify a
1992 # build->target assembler and hope that it will have the same features
1993 # as the host->target assembler we'll be using.
1994 gcc_cv_gas_major_version=
1995 gcc_cv_gas_minor_version=
1996 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1998 m4_pattern_allow([AS_FOR_TARGET])dnl
1999 AS_VAR_SET_IF(gcc_cv_as,, [
2000 if test -x "$DEFAULT_ASSEMBLER"; then
2001 gcc_cv_as="$DEFAULT_ASSEMBLER"
2002 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
2003 && test -f ../gas/Makefile \
2004 && test x$build = x$host; then
2005 gcc_cv_as=../gas/as-new$build_exeext
2006 elif test -x as$build_exeext; then
2007 # Build using assembler in the current directory.
2008 gcc_cv_as=./as$build_exeext
2009 elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then
2010 gcc_cv_as="$AS_FOR_TARGET"
2012 AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
2015 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
2016 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
2017 case "$ORIGINAL_AS_FOR_TARGET" in
2018 ./as | ./as$build_exeext) ;;
2019 *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
2022 AC_MSG_CHECKING(what assembler to use)
2023 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
2024 # Single tree build which includes gas. We want to prefer it
2025 # over whatever linker top-level may have detected, since
2026 # we'll use what we're building after installation anyway.
2027 AC_MSG_RESULT(newly built gas)
2029 _gcc_COMPUTE_GAS_VERSION
2030 in_tree_gas_is_elf=no
2031 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2032 || (grep 'obj_format = multi' ../gas/Makefile \
2033 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
2035 in_tree_gas_is_elf=yes
2038 AC_MSG_RESULT($gcc_cv_as)
2044 [[ --enable-ld[=ARG] build ld [ARG={default,yes,no}]]],
2045 [case "${enableval}" in
2052 [[ --enable-gold[=ARG] build gold [ARG={default,yes,no}]]],
2053 [case "${enableval}" in
2055 install_gold_as_default=yes
2058 if test x${default_ld} != x; then
2059 install_gold_as_default=yes
2065 AC_MSG_ERROR([invalid --enable-gold argument])
2068 [install_gold_as_default=no])
2070 # Identify the linker which will work hand-in-glove with the newly
2071 # built GCC, so that we can examine its features. This is the linker
2072 # which will be driven by the driver program.
2074 # If build != host, and we aren't building gas in-tree, we identify a
2075 # build->target linker and hope that it will have the same features
2076 # as the host->target linker we'll be using.
2077 gcc_cv_gld_major_version=
2078 gcc_cv_gld_minor_version=
2079 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
2080 gcc_cv_ld_gold_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gold
2081 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
2083 AS_VAR_SET_IF(gcc_cv_ld,, [
2084 if test -x "$DEFAULT_LINKER"; then
2085 gcc_cv_ld="$DEFAULT_LINKER"
2086 elif test $install_gold_as_default = yes \
2087 && test -f $gcc_cv_ld_gold_srcdir/configure.ac \
2088 && test -f ../gold/Makefile \
2089 && test x$build = x$host; then
2090 gcc_cv_ld=../gold/ld-new$build_exeext
2091 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
2092 && test -f ../ld/Makefile \
2093 && test x$build = x$host; then
2094 gcc_cv_ld=../ld/ld-new$build_exeext
2095 elif test -x collect-ld$build_exeext; then
2096 # Build using linker in the current directory.
2097 gcc_cv_ld=./collect-ld$build_exeext
2098 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
2099 gcc_cv_ld="$LD_FOR_TARGET"
2101 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
2104 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
2105 PLUGIN_LD_SUFFIX=`basename $gcc_cv_ld | sed -e "s,$target_alias-,,"`
2106 # if the PLUGIN_LD is set ld-new, just have it as ld
2107 # as that is the installed named.
2108 if test x$PLUGIN_LD_SUFFIX = xld-new \
2109 || test x$PLUGIN_LD_SUFFIX = xcollect-ld ; then
2112 AC_ARG_WITH(plugin-ld,
2113 [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])],
2114 [if test x"$withval" != x; then
2115 ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
2116 PLUGIN_LD_SUFFIX=`echo $withval | sed -e "s,$target_alias-,,"`
2118 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
2119 AC_DEFINE_UNQUOTED(PLUGIN_LD_SUFFIX, "$PLUGIN_LD_SUFFIX", [Specify plugin linker])
2121 # Check to see if we are using gold instead of ld
2122 AC_MSG_CHECKING(whether we are using gold)
2124 if test x$gcc_cv_ld != x; then
2125 if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2126 | grep "GNU gold" > /dev/null; then
2130 AC_MSG_RESULT($ld_is_gold)
2132 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
2133 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
2134 case "$ORIGINAL_LD_FOR_TARGET" in
2135 ./collect-ld | ./collect-ld$build_exeext) ;;
2136 *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
2139 AC_MSG_CHECKING(what linker to use)
2140 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \
2141 || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then
2142 # Single tree build which includes ld. We want to prefer it
2143 # over whatever linker top-level may have detected, since
2144 # we'll use what we're building after installation anyway.
2145 AC_MSG_RESULT(newly built ld)
2147 in_tree_ld_is_elf=no
2148 if (grep 'EMUL = .*elf' ../ld/Makefile \
2149 || grep 'EMUL = .*linux' ../ld/Makefile \
2150 || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
2151 in_tree_ld_is_elf=yes
2152 elif test "$ld_is_gold" = yes; then
2153 in_tree_ld_is_elf=yes
2155 for f in $gcc_cv_ld_bfd_srcdir/configure $gcc_cv_ld_gld_srcdir/configure $gcc_cv_ld_gld_srcdir/configure.in $gcc_cv_ld_gld_srcdir/Makefile.in
2158 gcc_cv_gld_version=`sed -n -e 's/^[ ]*VERSION=[^0-9A-Za-z_]*\([0-9]*\.[0-9]*.*\)/VERSION=\1/p' < $f`
2159 if test x$gcc_cv_gld_version != x; then
2163 case $gcc_cv_gld_version in
2166 *) AC_MSG_ERROR([[cannot find version of in-tree linker]]) ;;
2169 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2170 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2172 ORIGINAL_LD_BFD_FOR_TARGET=../ld/ld-new$build_exeext
2173 ORIGINAL_LD_GOLD_FOR_TARGET=../gold/ld-new$build_exeext
2175 AC_MSG_RESULT($gcc_cv_ld)
2177 gcc_cvs_ld_program=`dirname $gcc_cv_ld`/`basename $gcc_cv_ld $host_exeext`
2178 ORIGINAL_LD_BFD_FOR_TARGET=${gcc_cvs_ld_program}.bfd$host_exeext
2179 ORIGINAL_LD_GOLD_FOR_TARGET=${gcc_cvs_ld_program}.gold$host_exeext
2182 AC_SUBST(ORIGINAL_LD_BFD_FOR_TARGET)
2183 AC_SUBST(ORIGINAL_LD_GOLD_FOR_TARGET)
2185 # Figure out what nm we will be using.
2186 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2187 AS_VAR_SET_IF(gcc_cv_nm,, [
2188 if test -f $gcc_cv_binutils_srcdir/configure.in \
2189 && test -f ../binutils/Makefile \
2190 && test x$build = x$host; then
2191 gcc_cv_nm=../binutils/nm-new$build_exeext
2192 elif test -x nm$build_exeext; then
2193 gcc_cv_nm=./nm$build_exeext
2194 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
2195 gcc_cv_nm="$NM_FOR_TARGET"
2197 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2200 AC_MSG_CHECKING(what nm to use)
2201 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2202 # Single tree build which includes binutils.
2203 AC_MSG_RESULT(newly built nm)
2206 AC_MSG_RESULT($gcc_cv_nm)
2210 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2211 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2212 case "$ORIGINAL_NM_FOR_TARGET" in
2213 ./nm | ./nm$build_exeext) ;;
2214 *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2218 # Figure out what objdump we will be using.
2219 AS_VAR_SET_IF(gcc_cv_objdump,, [
2220 if test -f $gcc_cv_binutils_srcdir/configure.in \
2221 && test -f ../binutils/Makefile \
2222 && test x$build = x$host; then
2223 # Single tree build which includes binutils.
2224 gcc_cv_objdump=../binutils/objdump$build_exeext
2225 elif test -x objdump$build_exeext; then
2226 gcc_cv_objdump=./objdump$build_exeext
2227 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2228 gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2230 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2233 AC_MSG_CHECKING(what objdump to use)
2234 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2235 # Single tree build which includes binutils.
2236 AC_MSG_RESULT(newly built objdump)
2237 elif test x$gcc_cv_objdump = x; then
2238 AC_MSG_RESULT(not found)
2240 AC_MSG_RESULT($gcc_cv_objdump)
2243 # Figure out what readelf we will be using.
2244 AS_VAR_SET_IF(gcc_cv_readelf,, [
2245 if test -f $gcc_cv_binutils_srcdir/configure.in \
2246 && test -f ../binutils/Makefile \
2247 && test x$build = x$host; then
2248 # Single tree build which includes binutils.
2249 gcc_cv_readelf=../binutils/readelf$build_exeext
2250 elif test -x readelf$build_exeext; then
2251 gcc_cv_readelf=./readelf$build_exeext
2253 AC_PATH_PROG(gcc_cv_readelf, readelf)
2256 AC_MSG_CHECKING(what readelf to use)
2257 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2258 # Single tree build which includes binutils.
2259 AC_MSG_RESULT(newly built readelf)
2260 elif test x$gcc_cv_readelf = x; then
2261 AC_MSG_RESULT(not found)
2263 AC_MSG_RESULT($gcc_cv_readelf)
2266 # Figure out what assembler alignment features are present.
2267 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2271 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2272 [Define if your assembler supports .balign and .p2align.])])
2274 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2277 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2278 [Define if your assembler supports specifying the maximum number
2279 of bytes to skip when using the GAS .p2align command.])])
2281 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2284 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2285 [Define if your assembler supports .literal16.])])
2287 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2289 [conftest_label1: .word 0
2291 conftest_label2: .word 0
2293 [if test x$gcc_cv_nm != x; then
2294 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2295 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2296 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2298 else gcc_cv_as_subsection_m1=yes
2300 rm -f conftest.nm1 conftest.nm2
2302 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2303 [Define if your assembler supports .subsection and .subsection -1 starts
2304 emitting at the beginning of your section.])])
2306 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2309 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2311 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2313 [ .weakref foobar, barfnot],,
2314 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2316 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2319 .NSUBSPA $CODE$,COMDAT],,
2320 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2322 # .hidden needs to be supported in both the assembler and the linker,
2323 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2324 # This is irritatingly difficult to feature test for; we have to check the
2325 # date string after the version number. If we've got an in-tree
2326 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2328 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2329 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2335 # Darwin as has some visibility support, though with a different syntax.
2336 gcc_cv_as_hidden=yes
2340 # gnu_indirect_function type is an extension proposed at
2341 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2342 # selection of function implementation
2343 AC_ARG_ENABLE(gnu-indirect-function,
2344 [AS_HELP_STRING([--enable-gnu-indirect-function],
2345 [enable the use of the @gnu_indirect_function to glibc systems])],
2346 [case $enable_gnu_indirect_function in
2348 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2349 Valid choices are 'yes' and 'no'.]) ;;
2351 [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2353 gif=`if test x$enable_gnu_indirect_function = xyes; then echo 1; else echo 0; fi`
2354 AC_DEFINE_UNQUOTED(HAVE_GNU_INDIRECT_FUNCTION, $gif,
2355 [Define if your system supports gnu indirect functions.])
2359 if test $in_tree_ld != yes ; then
2360 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2361 if echo "$ld_ver" | grep GNU > /dev/null; then
2362 if test x"$ld_is_gold" = xyes; then
2363 # GNU gold --version looks like this:
2365 # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
2367 # We extract the binutils version which is more familiar and specific
2368 # than the gold version.
2369 ld_vers=`echo $ld_ver | sed -n \
2370 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
2372 # GNU ld --version looks like this:
2374 # GNU ld (GNU Binutils) 2.21.51.20110225
2375 ld_vers=`echo $ld_ver | sed -n \
2376 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2378 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'`
2379 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2380 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2381 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2385 # See acinclude.m4 (gcc_SUN_LD_VERSION) for the version number
2388 # Don't reuse gcc_gv_sun_ld_vers_* in case a linker other than
2389 # /usr/ccs/bin/ld has been configured.
2390 ld_ver=`$gcc_cv_ld -V 2>&1`
2391 if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2392 ld_vers=`echo $ld_ver | sed -n \
2393 -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2394 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2395 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2403 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2404 [[if test $in_tree_ld = yes ; then
2406 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 \
2407 && test $in_tree_ld_is_elf = yes; then
2408 gcc_cv_ld_hidden=yes
2411 gcc_cv_ld_hidden=yes
2412 if test x"$ld_is_gold" = xyes; then
2414 elif echo "$ld_ver" | grep GNU > /dev/null; then
2416 mmix-knuth-mmixware)
2417 # The linker emits by default mmo, not ELF, so "no" is appropriate.
2421 if test 0"$ld_date" -lt 20020404; then
2422 if test -n "$ld_date"; then
2423 # If there was date string, but was earlier than 2002-04-04, fail
2425 elif test -z "$ld_vers"; then
2426 # If there was no date string nor ld version number, something is wrong
2429 test -z "$ld_vers_patch" && ld_vers_patch=0
2430 if test "$ld_vers_major" -lt 2; then
2432 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2433 gcc_cv_ld_hidden="no"
2434 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2442 # Darwin ld has some visibility support.
2443 gcc_cv_ld_hidden=yes
2445 hppa64*-*-hpux* | ia64*-*-hpux*)
2446 gcc_cv_ld_hidden=yes
2448 *-*-solaris2.1[0-9]*)
2449 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2450 # .symbolic was only added in Solaris 9 12/02.
2451 gcc_cv_ld_hidden=yes
2459 libgcc_visibility=no
2460 AC_SUBST(libgcc_visibility)
2461 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2462 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2463 libgcc_visibility=yes
2464 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2465 [Define if your assembler and linker support .hidden.])
2468 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2469 gcc_cv_ld_ro_rw_mix=unknown
2470 if test $in_tree_ld = yes ; then
2471 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 \
2472 && test $in_tree_ld_is_elf = yes; then
2473 gcc_cv_ld_ro_rw_mix=read-write
2475 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2476 echo '.section myfoosect, "a"' > conftest1.s
2477 echo '.section myfoosect, "aw"' > conftest2.s
2478 echo '.byte 1' >> conftest2.s
2479 echo '.section myfoosect, "a"' > conftest3.s
2480 echo '.byte 0' >> conftest3.s
2481 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2482 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2483 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2484 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2485 conftest2.o conftest3.o > /dev/null 2>&1; then
2486 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2487 | sed -e '/myfoosect/!d' -e N`
2488 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2489 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2490 gcc_cv_ld_ro_rw_mix=read-only
2492 gcc_cv_ld_ro_rw_mix=read-write
2497 rm -f conftest.* conftest[123].*
2500 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2501 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2502 [Define if your linker links a mix of read-only
2503 and read-write sections into a read-write section.])
2505 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2507 gcc_AC_INITFINI_ARRAY
2509 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2510 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2518 [[# GAS versions before 2.11 do not support uleb128,
2519 # despite appearing to.
2520 # ??? There exists an elf-specific test that will crash
2521 # the assembler. Perhaps it's better to figure out whether
2522 # arbitrary sections are supported and try the test.
2523 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2524 if echo "$as_ver" | grep GNU > /dev/null; then
2525 as_vers=`echo $as_ver | sed -n \
2526 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2527 as_major=`expr "$as_vers" : '\([0-9]*\)'`
2528 as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2529 if test $as_major -eq 2 && test $as_minor -lt 11
2531 else gcc_cv_as_leb128=yes
2534 [AC_DEFINE(HAVE_AS_LEB128, 1,
2535 [Define if your assembler supports .sleb128 and .uleb128.])])
2537 # Check if we have assembler support for unwind directives.
2538 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2545 .cfi_escape 1, 2, 3, 4, 5
2549 # If the linker used on Solaris (like Sun ld) isn't capable of merging
2550 # read-only and read-write sections, we need to make sure that the
2551 # assembler used emits read-write .eh_frame sections.
2552 if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2553 if test "x$gcc_cv_objdump" != x; then
2554 if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2555 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2556 gcc_cv_as_cfi_directive=no
2559 i?86-*-solaris2.1[[0-9]]* | x86_64-*-solaris2.1[[0-9]]*)
2560 # On Solaris/x86, make sure that GCC and assembler agree on using
2561 # read-only .eh_frame sections for 64-bit.
2562 if test x$gas = xyes; then
2563 as_ix86_64_opt="--64"
2565 as_ix86_64_opt="-xarch=amd64"
2567 if $gcc_cv_as $as_ix86_64_opt -o conftest.o conftest.s > /dev/null 2>&1 && \
2568 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2569 sed -e /.eh_frame/!d -e N | \
2570 grep READONLY > /dev/null; then
2571 gcc_cv_as_cfi_directive=yes
2573 gcc_cv_as_cfi_directive=no
2577 gcc_cv_as_cfi_directive=yes
2582 # no objdump, err on the side of caution
2583 gcc_cv_as_cfi_directive=no
2586 gcc_cv_as_cfi_directive=yes
2590 gcc_cv_as_cfi_directive=yes
2593 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
2594 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2598 .cfi_adjust_cfa_offset 64
2600 .cfi_adjust_cfa_offset 128
2603 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
2604 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then
2605 gcc_cv_as_cfi_advance_working=yes
2609 # no objdump, err on the side of caution
2610 gcc_cv_as_cfi_advance_working=no
2612 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
2613 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2614 [`if test $gcc_cv_as_cfi_directive = yes \
2615 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2616 [Define 0/1 if your assembler supports CFI directives.])
2618 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
2619 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2620 gcc_cv_as_cfi_personality_directive, ,,
2623 .cfi_personality 0, symbol
2625 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2626 [`if test $gcc_cv_as_cfi_personality_directive = yes;
2627 then echo 1; else echo 0; fi`],
2628 [Define 0/1 if your assembler supports .cfi_personality.])
2630 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2631 gcc_cv_as_cfi_sections_directive, ,,
2633 .cfi_sections .debug_frame, .eh_frame
2637 win32 | pe | cygwin* | mingw32* | uwin*)
2638 # Need to check that we generated the correct relocation for the
2639 # .debug_frame section. This was fixed for binutils 2.21.
2640 gcc_cv_as_cfi_sections_directive=no
2641 if test "x$gcc_cv_objdump" != x; then
2642 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
2643 grep secrel > /dev/null; then
2644 gcc_cv_as_cfi_sections_directive=yes
2649 gcc_cv_as_cfi_sections_directive=yes
2652 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
2653 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2654 [`if test $gcc_cv_as_cfi_sections_directive = yes;
2655 then echo 1; else echo 0; fi`],
2656 [Define 0/1 if your assembler supports .cfi_sections.])
2658 # GAS versions up to and including 2.11.0 may mis-optimize
2660 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2668 .section .eh_frame,"aw",@progbits
2670 .4byte .LECIE1-.LSCIE1
2684 .4byte .LEFDE1-.LASFDE1
2686 .4byte .LASFDE1-__FRAME_BEGIN__
2694 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2695 cat > conftest.lit <<EOF
2696 0000 10000000 00000000 017a0001 781a0004 .........z..x...
2697 0010 01000000 12000000 18000000 00000000 ................
2698 0020 08000000 04080000 0044 .........D @&t@
2700 cat > conftest.big <<EOF
2701 0000 00000010 00000000 017a0001 781a0004 .........z..x...
2702 0010 00000001 00000012 00000018 00000000 ................
2703 0020 00000008 04000000 0844 .........D @&t@
2705 # If the assembler didn't choke, and we can objdump,
2706 # and we got the correct data, then succeed.
2707 # The text in the here-document typically retains its unix-style line
2708 # endings, while the output of objdump will use host line endings.
2709 # Therefore, use diff -b for the comparisons.
2710 if test x$gcc_cv_objdump != x \
2711 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2712 | tail -3 > conftest.got \
2713 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2714 || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2716 gcc_cv_as_eh_frame=yes
2717 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2718 gcc_cv_as_eh_frame=buggy
2720 # Uh oh, what do we do now?
2721 gcc_cv_as_eh_frame=no
2724 if test $gcc_cv_as_eh_frame = buggy; then
2725 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2726 [Define if your assembler mis-optimizes .eh_frame data.])
2729 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2730 [elf,2,12,0], [--fatal-warnings],
2731 [.section .rodata.str, "aMS", @progbits, 1])
2732 if test $gcc_cv_as_shf_merge = no; then
2733 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2734 [elf,2,12,0], [--fatal-warnings],
2735 [.section .rodata.str, "aMS", %progbits, 1])
2737 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2738 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2739 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2741 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)],
2742 gcc_cv_as_comdat_group,
2743 [elf,2,16,0], [--fatal-warnings],
2744 [.section .text,"axG",@progbits,.foo,comdat])
2745 if test $gcc_cv_as_comdat_group = yes; then
2746 gcc_cv_as_comdat_group_percent=no
2747 gcc_cv_as_comdat_group_group=no
2749 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
2750 gcc_cv_as_comdat_group_percent,
2751 [elf,2,16,0], [--fatal-warnings],
2752 [.section .text,"axG",%progbits,.foo,comdat])
2753 if test $gcc_cv_as_comdat_group_percent = yes; then
2754 gcc_cv_as_comdat_group_group=no
2756 if test -z "${gcc_cv_as_comdat_group_group+set}"; then
2757 gcc_cv_as_comdat_group_group=no
2760 # Sun as uses a completely different syntax.
2765 .group foo,".text%foo",#comdat
2766 .section ".text%foo", #alloc,#execinstr,#progbits
2771 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2773 .group foo,.text%foo,#comdat
2774 .section .text%foo, "ax", @progbits
2780 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
2781 gcc_cv_as_comdat_group_group,
2787 if test x"$ld_is_gold" = xyes; then
2789 elif test $in_tree_ld = yes ; then
2791 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 \
2792 && test $in_tree_ld_is_elf = yes; then
2795 elif echo "$ld_ver" | grep GNU > /dev/null; then
2797 if test 0"$ld_date" -lt 20050308; then
2798 if test -n "$ld_date"; then
2799 # If there was date string, but was earlier than 2005-03-08, fail
2801 elif test "$ld_vers_major" -lt 2; then
2803 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2810 *-*-solaris2.1[1-9]*)
2812 # Sun ld has COMDAT group support since Solaris 9, but it doesn't
2813 # interoperate with GNU as until Solaris 11 build 130, i.e. ld
2816 # If using Sun as for COMDAT group as emitted by GCC, one needs at
2817 # least ld version 1.2267.
2818 if test "$ld_vers_major" -gt 1; then
2820 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
2822 elif test "$ld_vers_minor" -ge 2267; then
2827 # Assume linkers other than GNU ld don't support COMDAT group.
2833 # Allow overriding the automatic COMDAT group tests above.
2834 AC_ARG_ENABLE(comdat,
2835 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
2836 [comdat_group="$enable_comdat"])
2837 if test $comdat_group = no; then
2838 gcc_cv_as_comdat_group=no
2839 gcc_cv_as_comdat_group_percent=no
2840 gcc_cv_as_comdat_group_group=no
2842 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2843 [`if test $gcc_cv_as_comdat_group = yes \
2844 || test $gcc_cv_as_comdat_group_percent = yes \
2845 || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`],
2846 [Define 0/1 if your assembler and linker support COMDAT groups.])
2848 gcc_GAS_CHECK_FEATURE([line table discriminator support],
2849 gcc_cv_as_discriminator,
2853 .loc 1 1 0 discriminator 1],,
2854 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
2855 [Define if your assembler supports the .loc discriminator sub-directive.])])
2857 # Thread-local storage - the check is heavily parameterized.
2866 .section ".tdata","awT",@progbits
2869 ldq $27,__tls_get_addr($29) !literal!1
2870 lda $16,foo($29) !tlsgd!1
2871 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
2872 ldq $27,__tls_get_addr($29) !literal!2
2873 lda $16,foo($29) !tlsldm!2
2874 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
2875 ldq $1,foo($29) !gotdtprel
2876 ldah $2,foo($29) !dtprelhi
2877 lda $3,foo($2) !dtprello
2878 lda $4,foo($29) !dtprel
2879 ldq $1,foo($29) !gottprel
2880 ldah $2,foo($29) !tprelhi
2881 lda $3,foo($2) !tprello
2882 lda $4,foo($29) !tprel'
2885 tls_as_opt=--fatal-warnings
2887 cris-*-*|crisv32-*-*)
2889 .section ".tdata","awT",@progbits
2896 tls_as_opt=--fatal-warnings
2900 .section ".tdata","awT",@progbits
2912 .section ".tdata","awT",@progbits
2916 addil LT%foo-$tls_gdidx$,gp
2917 ldo RT%foo-$tls_gdidx$(%r1),%arg0
2920 addil LT%foo-$tls_ldidx$,gp
2922 ldo RT%foo-$tls_ldidx$(%r1),%arg0
2923 addil LR%foo-$tls_dtpoff$,%ret0
2924 ldo RR%foo-$tls_dtpoff$(%r1),%t1
2926 addil LT%foo-$tls_ieoff$,gp
2927 ldw RT%foo-$tls_ieoff$(%r1),%t2
2930 addil LR%foo-$tls_leoff$,%t1
2931 ldo RR%foo-$tls_leoff$(%r1),%t2'
2934 tls_as_opt=--fatal-warnings
2938 .section ".tdata","awT",%progbits
2949 i[34567]86-*-* | x86_64-*-*)
2951 i[34567]86-*-solaris2.* | x86_64-*-solaris2.1[0-9]*)
2958 if test x$on_solaris = xyes && test x$gas_flag = xno; then
2960 .section .tdata,"awt",@progbits'
2965 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
2966 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
2970 .section ".tdata","awT",@progbits'
2974 tls_as_opt="--fatal-warnings"
2978 conftest_s="$conftest_s
2982 leal foo@tlsgd(,%ebx,1), %eax
2983 leal foo@tlsldm(%ebx), %eax
2984 leal foo@dtpoff(%eax), %edx
2985 movl foo@gottpoff(%ebx), %eax
2986 subl foo@gottpoff(%ebx), %eax
2987 addl foo@gotntpoff(%ebx), %eax
2988 movl foo@indntpoff, %eax
2989 movl \$foo@tpoff, %eax
2990 subl \$foo@tpoff, %eax
2991 leal foo@ntpoff(%ecx), %eax"
2994 if test x$on_solaris = xyes; then
2996 yes) tls_as_opt="$tls_as_opt --64" ;;
2997 no) tls_as_opt="$tls_as_opt -xarch=amd64" ;;
3000 conftest_s="$conftest_s
3004 leaq foo@tlsgd(%rip), %rdi
3005 leaq foo@tlsld(%rip), %rdi
3006 leaq foo@dtpoff(%rax), %rdx
3007 movq foo@gottpoff(%rip), %rax
3008 movq \$foo@tpoff, %rax"
3014 .section ".tdata","awT",@progbits
3017 addl r16 = @ltoff(@dtpmod(foo#)), gp
3018 addl r17 = @ltoff(@dtprel(foo#)), gp
3019 addl r18 = @ltoff(@tprel(foo#)), gp
3020 addl r19 = @dtprel(foo#), gp
3021 adds r21 = @dtprel(foo#), r13
3022 movl r23 = @dtprel(foo#)
3023 addl r20 = @tprel(foo#), gp
3024 adds r22 = @tprel(foo#), r13
3025 movl r24 = @tprel(foo#)'
3028 tls_as_opt=--fatal-warnings
3032 .section .tdata,"awT",@progbits
3036 addik r5,r20,x@TLSGD
3037 addik r5,r20,x@TLSLDM'
3040 tls_as_opt='--fatal-warnings'
3044 .section .tdata,"awT",@progbits
3048 addiu $4, $28, %tlsgd(x)
3049 addiu $4, $28, %tlsldm(x)
3050 lui $4, %dtprel_hi(x)
3051 addiu $4, $4, %dtprel_lo(x)
3052 lw $4, %gottprel(x)($28)
3053 lui $4, %tprel_hi(x)
3054 addiu $4, $4, %tprel_lo(x)'
3057 tls_as_opt='-32 --fatal-warnings'
3061 .section .tdata,"awT",@progbits
3066 move.l x@TLSGD(%a5),%a0
3067 move.l x@TLSLDM(%a5),%a0
3068 move.l x@TLSLDO(%a5),%a0
3069 move.l x@TLSIE(%a5),%a0
3070 move.l x@TLSLE(%a5),%a0'
3073 tls_as_opt='--fatal-warnings'
3077 .section ".tdata","awT",@progbits'
3080 tls_as_opt="--fatal-warnings"
3084 .section ".tdata","awT",%progbits
3088 add x0, x0, #:tlsgd_lo12:x
3093 tls_as_opt='--fatal-warnings'
3097 .extern __get_tpointer
3115 .section ".tdata","awT",@progbits
3123 addi 3,2,ld0@got@tlsgd
3129 addi 3,2,x1@got@tlsld
3135 addis 9,3,x2@dtprel@ha
3136 addi 9,9,x2@dtprel@l
3139 ld 9,x3@got@dtprel(2)
3145 tls_as_opt="-a64 --fatal-warnings"
3149 .section ".tdata","awT",@progbits
3157 addi 3,31,ld0@got@tlsgd
3159 addi 3,31,x1@got@tlsld
3162 addis 9,3,x2@dtprel@ha
3163 addi 9,9,x2@dtprel@l
3164 lwz 9,x3@got@tprel(31)
3167 addis 9,2,x2@tprel@ha
3168 addi 9,9,x2@tprel@l'
3171 tls_as_opt="-a32 --fatal-warnings"
3175 .section ".tdata","awT",@progbits
3184 l %r1,foo@GOTNTPOFF(%r12)
3185 l %r1,0(%r1):tls_load:foo
3186 bas %r14,0(%r1,%r13):tls_gdcall:foo
3187 bas %r14,0(%r1,%r13):tls_ldcall:foo'
3190 tls_as_opt="-m31 --fatal-warnings"
3194 .section ".tdata","awT",@progbits
3202 lg %r1,foo@GOTNTPOFF(%r12)
3203 larl %r1,foo@INDNTPOFF
3204 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
3205 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
3208 tls_as_opt="-m64 -Aesame --fatal-warnings"
3210 sh-*-* | sh[34]-*-*)
3212 .section ".tdata","awT",@progbits
3222 tls_as_opt=--fatal-warnings
3226 sparc*-sun-solaris2.*)
3233 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3235 .section ".tdata",#alloc,#write,#tls'
3240 .section ".tdata","awT",@progbits'
3243 tls_as_opt="-32 --fatal-warnings"
3245 conftest_s="$conftest_s
3248 sethi %tgd_hi22(foo), %o0
3249 add %o0, %tgd_lo10(foo), %o1
3250 add %l7, %o1, %o0, %tgd_add(foo)
3251 call __tls_get_addr, %tgd_call(foo)
3252 sethi %tldm_hi22(foo), %l1
3253 add %l1, %tldm_lo10(foo), %l2
3254 add %l7, %l2, %o0, %tldm_add(foo)
3255 call __tls_get_addr, %tldm_call(foo)
3256 sethi %tldo_hix22(foo), %l3
3257 xor %l3, %tldo_lox10(foo), %l4
3258 add %o0, %l4, %l5, %tldo_add(foo)
3259 sethi %tie_hi22(foo), %o3
3260 add %o3, %tie_lo10(foo), %o3
3261 ld [%l7 + %o3], %o2, %tie_ld(foo)
3262 add %g7, %o2, %o4, %tie_add(foo)
3263 sethi %tle_hix22(foo), %l1
3264 xor %l1, %tle_lox10(foo), %o5
3265 ld [%g7 + %o5], %o1"
3269 .section ".tdata","awT",@progbits
3272 addli r0, zero, tls_gd(foo)
3273 auli r0, zero, tls_gd_ha16(foo)
3274 addli r0, r0, tls_gd_lo16(foo)
3276 addli r0, zero, tls_ie(foo)
3277 auli r0, r0, tls_ie_ha16(foo)
3278 addli r0, r0, tls_ie_lo16(foo)'
3281 tls_as_opt="--fatal-warnings"
3285 .section ".tdata","awT",@progbits
3288 shl16insli r0, zero, hw0_last_tls_gd(foo)
3289 shl16insli r0, zero, hw1_last_tls_gd(foo)
3290 shl16insli r0, r0, hw0_tls_gd(foo)
3292 shl16insli r0, zero, hw1_last_tls_ie(foo)
3293 shl16insli r0, r0, hw0_tls_ie(foo)'
3296 tls_as_opt="--fatal-warnings"
3300 .section ".tdata","awT",@progbits
3303 movi a8, foo@TLSFUNC
3304 movi a10, foo@TLSARG
3305 callx8.tls a8, foo@TLSCALL'
3312 if test "x$enable_tls" = xno ; then
3313 : # TLS explicitly disabled.
3314 elif test "x$enable_tls" = xyes ; then
3315 set_have_as_tls=yes # TLS explicitly enabled.
3316 elif test -z "$tls_first_major"; then
3317 : # If we don't have a check, assume no support.
3319 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
3320 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
3321 [set_have_as_tls=yes])
3323 if test $set_have_as_tls = yes ; then
3324 AC_DEFINE(HAVE_AS_TLS, 1,
3325 [Define if your assembler and linker support thread-local storage.])
3328 # Target-specific assembler checks.
3330 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3331 gcc_cv_ld_static_dynamic=no
3332 gcc_cv_ld_static_option='-Bstatic'
3333 gcc_cv_ld_dynamic_option='-Bdynamic'
3334 if test $in_tree_ld = yes ; then
3335 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
3336 gcc_cv_ld_static_dynamic=yes
3338 elif test x$gcc_cv_ld != x; then
3339 # Check if linker supports -Bstatic/-Bdynamic option
3340 if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
3341 && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
3342 gcc_cv_ld_static_dynamic=yes
3345 # AIX ld uses -b flags
3346 *-*-aix4.[[23]]* | *-*-aix[[5-9]]*)
3347 gcc_cv_ld_static_dynamic=yes
3348 gcc_cv_ld_static_option="-bstatic"
3349 gcc_cv_ld_dynamic_option="-bdynamic"
3351 # HP-UX ld uses -a flags to select between shared and archive.
3353 if test x"$gnu_ld" = xno; then
3354 gcc_cv_ld_static_dynamic=yes
3355 gcc_cv_ld_static_option="-aarchive_shared"
3356 gcc_cv_ld_dynamic_option="-adefault"
3359 # Solaris 2 ld always supports -Bstatic/-Bdynamic.
3361 gcc_cv_ld_static_dynamic=yes
3366 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3367 AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3368 [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.])
3369 AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option",
3370 [Define to the linker option to disable use of shared objects.])
3371 AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option",
3372 [Define to the linker option to enable use of shared objects.])
3374 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3376 if test x"$demangler_in_ld" = xyes; then
3377 AC_MSG_CHECKING(linker --demangle support)
3378 gcc_cv_ld_demangle=no
3379 if test $in_tree_ld = yes; then
3380 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 \
3381 gcc_cv_ld_demangle=yes
3383 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3384 # Check if the GNU linker supports --demangle option
3385 if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3386 gcc_cv_ld_demangle=yes
3389 if test x"$gcc_cv_ld_demangle" = xyes; then
3390 AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3391 [Define if your linker supports --demangle option.])
3393 AC_MSG_RESULT($gcc_cv_ld_demangle)
3396 AC_MSG_CHECKING(linker plugin support)
3398 if test -f liblto_plugin.la; then
3399 save_ld_ver="$ld_ver"
3400 save_ld_vers_major="$ld_vers_major"
3401 save_ld_vers_minor="$ld_vers_minor"
3402 save_ld_is_gold="$ld_is_gold"
3406 if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
3408 # FIXME: ld_is_gold?
3409 ld_vers_major="$gcc_cv_gld_major_version"
3410 ld_vers_minor="$gcc_cv_gld_minor_version"
3412 # Determine plugin linker version.
3413 # FIXME: Partial duplicate from above, generalize.
3415 ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q`
3416 if echo "$ld_ver" | grep GNU > /dev/null; then
3417 if echo "$ld_ver" | grep "GNU gold" > /dev/null; then
3419 ld_vers=`echo $ld_ver | sed -n \
3420 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
3422 ld_vers=`echo $ld_ver | sed -n \
3423 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
3425 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
3426 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
3431 # Determine plugin support.
3432 if echo "$ld_ver" | grep GNU > /dev/null; then
3433 # Require GNU ld or gold 2.21+ for plugin support by default.
3434 if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then
3436 # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20.
3437 elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then
3442 ld_ver="$save_ld_ver"
3443 ld_vers_major="$save_ld_vers_major"
3444 ld_vers_minor="$save_ld_vers_minor"
3445 ld_is_gold="$save_ld_is_gold"
3447 AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin,
3448 [Define to the level of your linker's plugin support.])
3449 AC_MSG_RESULT($gcc_cv_lto_plugin)
3453 gcc_GAS_CHECK_FEATURE([-mabi option], gcc_cv_as_aarch64_mabi,,
3454 [-mabi=lp64], [.text],,,)
3455 if test x$gcc_cv_as_aarch64_mabi = xyes; then
3456 AC_DEFINE(HAVE_AS_MABI_OPTION, 1,
3457 [Define if your assembler supports the -mabi option.])
3459 if test x$with_abi = xilp32; then
3460 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3461 Upgrade the Assembler.])
3463 if test x"$with_multilib_list" = xdefault; then
3464 TM_MULTILIB_CONFIG=lp64
3466 aarch64_multilibs=`echo $with_multilib_list | sed -e 's/,/ /g'`
3467 for aarch64_multilib in ${aarch64_multilibs}; do
3468 case ${aarch64_multilib} in
3470 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3471 Upgrade the Assembler.])
3481 # All TARGET_ABI_OSF targets.
3482 alpha*-*-linux* | alpha*-*-*bsd*)
3483 gcc_GAS_CHECK_FEATURE([explicit relocation support],
3484 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3487 extbl $3, $2, $3 !lituse_bytoff!1
3488 ldq $2, a($29) !literal!1
3489 ldq $4, b($29) !literal!2
3490 ldq_u $3, 0($2) !lituse_base!1
3491 ldq $27, f($29) !literal!5
3492 jsr $26, ($27), f !lituse_jsr!5
3493 ldah $29, 0($26) !gpdisp!3
3494 lda $0, c($29) !gprel
3495 ldah $1, d($29) !gprelhigh
3496 lda $1, d($1) !gprellow
3497 lda $29, 0($29) !gpdisp!3],,
3498 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3499 [Define if your assembler supports explicit relocations.])])
3500 gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3501 gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3504 ldq $27, a($29) !literal!1
3505 jsr $26, ($27), a !lituse_jsrdirect!1],,
3506 [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3507 [Define if your assembler supports the lituse_jsrdirect relocation.])])
3511 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3512 gcc_cv_as_cris_no_mul_bug,[2,15,91],
3513 [-no-mul-bug-abort], [.text],,
3514 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3515 [Define if your assembler supports the -no-mul-bug-abort option.])])
3519 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3520 [.register %g2, #scratch],,
3521 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3522 [Define if your assembler supports .register.])])
3524 gcc_GAS_CHECK_FEATURE([@%:@nobits], gcc_cv_as_sparc_nobits,,,
3525 [.section "nobits",#alloc,#write,#nobits
3526 .section "progbits",#alloc,#write,#progbits])
3527 AC_DEFINE_UNQUOTED(HAVE_AS_SPARC_NOBITS,
3528 [`if test $gcc_cv_as_sparc_nobits = yes; then echo 1; else echo 0; fi`],
3529 [Define to 1 if your assembler supports #nobits, 0 otherwise.])
3531 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3533 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3534 [Define if your assembler supports -relax option.])])
3536 gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3537 gcc_cv_as_sparc_gotdata_op,,
3544 sethi %gdop_hix22(foo), %g1
3545 xor %g1, %gdop_lox10(foo), %g1
3546 ld [[%l7 + %g1]], %g2, %gdop(foo)],
3547 [if test x$gcc_cv_ld != x \
3548 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3549 if test x$gcc_cv_objdump != x; then
3550 if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3551 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3552 gcc_cv_as_sparc_gotdata_op=no
3554 gcc_cv_as_sparc_gotdata_op=yes
3559 [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3560 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3562 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3563 gcc_cv_as_sparc_ua_pcrel,,
3571 .uaword %r_disp32(foo)],
3572 [if test x$gcc_cv_ld != x \
3573 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3574 gcc_cv_as_sparc_ua_pcrel=yes
3577 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3578 [Define if your assembler and linker support unaligned PC relative relocs.])
3580 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3581 gcc_cv_as_sparc_ua_pcrel_hidden,,
3586 .uaword %r_disp32(foo)
3587 .byte 0x32, 0x33, 0x34
3592 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3593 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3594 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3595 | grep ' 31000000 07323334' > /dev/null 2>&1; then
3596 if $gcc_cv_objdump -R conftest 2> /dev/null \
3597 | grep 'DISP32' > /dev/null 2>&1; then
3600 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3604 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3605 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3606 ]) # unaligned pcrel relocs
3608 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3609 gcc_cv_as_sparc_offsetable_lo10,,
3612 or %g1, %lo(ab) + 12, %g1
3613 or %g1, %lo(ab + 12), %g1],
3614 [if test x$gcc_cv_objdump != x \
3615 && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3616 | grep ' 82106000 82106000' > /dev/null 2>&1; then
3617 gcc_cv_as_sparc_offsetable_lo10=yes
3619 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3620 [Define if your assembler supports offsetable %lo().])])
3622 gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions],
3623 gcc_cv_as_sparc_fmaf,,
3626 .register %g2, #scratch
3627 .register %g3, #scratch
3629 fmaddd %f0, %f2, %f4, %f6
3630 addxccc %g1, %g2, %g3
3631 fsrl32 %f2, %f4, %f8
3632 fnaddd %f10, %f12, %f14],,
3633 [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1,
3634 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])])
3636 gcc_GAS_CHECK_FEATURE([SPARC4 instructions],
3637 gcc_cv_as_sparc_sparc4,,
3640 .register %g2, #scratch
3641 .register %g3, #scratch
3644 1: cwbneg %g2, %g3, 1f
3647 aes_kexpand0 %f4, %f6, %f8
3648 des_round %f38, %f40, %f42, %f44
3649 camellia_f %f54, %f56, %f58, %f60
3650 kasumi_fi_xor %f46, %f48, %f50, %f52],,
3651 [AC_DEFINE(HAVE_AS_SPARC4, 1,
3652 [Define if your assembler supports SPARC4 instructions.])])
3654 gcc_GAS_CHECK_FEATURE([LEON instructions],
3655 gcc_cv_as_sparc_leon,,
3658 .register %g2, #scratch
3659 .register %g3, #scratch
3663 casa [[%g2]] 0xb, %g3, %g1],,
3664 [AC_DEFINE(HAVE_AS_LEON, 1,
3665 [Define if your assembler supports LEON instructions.])])
3669 i[34567]86-*-* | x86_64-*-*)
3673 # Full C++ conformance when using a shared libstdc++-v3 requires some
3674 # support from the Cygwin DLL, which in more recent versions exports
3675 # wrappers to aid in interposing and redirecting operators new, delete,
3676 # etc., as per n2800 #17.6.4.6 [replacement.functions]. Check if we
3677 # are configuring for a version of Cygwin that exports the wrappers.
3678 if test x$host = x$target && test x$host_cpu = xi686; then
3679 AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3681 # Can't check presence of libc functions during cross-compile, so
3682 # we just have to assume we're building for an up-to-date target.
3683 gcc_ac_cygwin_dll_wrappers=yes
3685 AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3686 [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3687 [Define if you want to generate code by default that assumes that the
3688 Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3691 cygwin* | pe | mingw32* | interix*)
3692 # Recent binutils allows the three-operand form of ".comm" on PE. This
3693 # definition is used unconditionally to initialise the default state of
3694 # the target option variable that governs usage of the feature.
3695 gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3696 [2,19,52],,[.comm foo,1,32])
3697 AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3698 [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3699 [Define if your assembler supports specifying the alignment
3700 of objects allocated using the GAS .comm command.])
3701 # Used for DWARF 2 in PE
3702 gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3703 gcc_cv_as_ix86_pe_secrel32,
3709 [if test x$gcc_cv_ld != x \
3710 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3711 gcc_cv_as_ix86_pe_secrel32=yes
3714 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3715 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3716 # Test if the assembler supports the extended form of the .section
3717 # directive that specifies section alignment. LTO support uses this,
3718 # but normally only after installation, so we warn but don't fail the
3719 # configure if LTO is enabled but the assembler does not support it.
3720 gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3721 [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3722 if test x$gcc_cv_as_section_has_align != xyes; then
3723 case ",$enable_languages," in
3725 AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3729 # Test if the assembler supports the section flag 'e' for specifying
3730 # an excluded section.
3731 gcc_GAS_CHECK_FEATURE([.section with e], gcc_cv_as_section_has_e,
3735 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3736 [`if test $gcc_cv_as_section_has_e = yes; then echo 1; else echo 0; fi`],
3737 [Define if your assembler supports specifying the section flag e.])
3741 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3742 gcc_cv_as_ix86_filds,,,
3743 [filds mem; fists mem],,
3744 [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3745 [Define if your assembler uses filds and fists mnemonics.])])
3747 gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3748 gcc_cv_as_ix86_fildq,,,
3749 [fildq mem; fistpq mem],,
3750 [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3751 [Define if your assembler uses fildq and fistq mnemonics.])])
3753 gcc_GAS_CHECK_FEATURE([cmov syntax],
3754 gcc_cv_as_ix86_cmov_sun_syntax,,,
3755 [cmovl.l %edx, %eax],,
3756 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3757 [Define if your assembler supports the Sun syntax for cmov.])])
3759 gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3760 gcc_cv_as_ix86_ffreep,,,
3762 [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3763 [Define if your assembler supports the ffreep mnemonic.])])
3765 gcc_GAS_CHECK_FEATURE([.quad directive],
3766 gcc_cv_as_ix86_quad,,,
3768 [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
3769 [Define if your assembler supports the .quad directive.])])
3771 gcc_GAS_CHECK_FEATURE([sahf mnemonic],
3772 gcc_cv_as_ix86_sahf,,,
3775 [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
3776 [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
3778 gcc_GAS_CHECK_FEATURE([interunit movq mnemonic],
3779 gcc_cv_as_ix86_interunit_movq,,,
3783 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_INTERUNIT_MOVQ,
3784 [`if test $gcc_cv_as_ix86_interunit_movq = yes; then echo 1; else echo 0; fi`],
3785 [Define if your assembler supports interunit movq mnemonic.])
3787 gcc_GAS_CHECK_FEATURE([hle prefixes],
3788 gcc_cv_as_ix86_hle,,,
3789 [lock xacquire cmpxchg %esi, (%ecx)],,
3790 [AC_DEFINE(HAVE_AS_IX86_HLE, 1,
3791 [Define if your assembler supports HLE prefixes.])])
3793 gcc_GAS_CHECK_FEATURE([swap suffix],
3794 gcc_cv_as_ix86_swap,,,
3795 [movl.s %esp, %ebp],,
3796 [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
3797 [Define if your assembler supports the swap suffix.])])
3799 gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
3800 gcc_cv_as_ix86_diff_sect_delta,,,
3808 [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
3809 [Define if your assembler supports the subtraction of symbols in different sections.])])
3811 # These two are used unconditionally by i386.[ch]; it is to be defined
3812 # to 1 if the feature is present, 0 otherwise.
3813 as_ix86_gotoff_in_data_opt=
3814 if test x$gas = xyes; then
3815 as_ix86_gotoff_in_data_opt="--32"
3817 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
3818 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],
3819 [$as_ix86_gotoff_in_data_opt],
3825 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
3826 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
3827 [Define true if the assembler supports '.long foo@GOTOFF'.])
3829 gcc_GAS_CHECK_FEATURE([rep and lock prefix],
3830 gcc_cv_as_ix86_rep_lock_prefix,,,
3836 lock addl %edi, (%eax,%esi)
3837 lock orl $0, (%esp)],,
3838 [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
3839 [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
3841 gcc_GAS_CHECK_FEATURE([ud2 mnemonic],
3842 gcc_cv_as_ix86_ud2,,,
3844 [AC_DEFINE(HAVE_AS_IX86_UD2, 1,
3845 [Define if your assembler supports the 'ud2' mnemonic.])])
3847 gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
3848 gcc_cv_as_ix86_tlsgdplt,,,
3849 [call tls_gd@tlsgdplt],
3850 [if test x$gcc_cv_ld != x \
3851 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3852 gcc_cv_as_ix86_tlsgdplt=yes
3855 [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
3856 [Define if your assembler and linker support @tlsgdplt.])])
3859 .section .tdata,"aw'$tls_section_flag'",@progbits
3861 .section .text,"ax",@progbits
3862 call tls_ld@tlsldmplt'
3863 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
3864 gcc_cv_as_ix86_tlsldmplt,,,
3866 [if test x$gcc_cv_ld != x \
3867 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3868 gcc_cv_as_ix86_tlsldmplt=yes
3871 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDMPLT,
3872 [`if test $gcc_cv_as_ix86_tlsldmplt = yes; then echo 1; else echo 0; fi`],
3873 [Define to 1 if your assembler and linker support @tlsldmplt.])
3875 # Enforce 32-bit output with gas and gld.
3876 if test x$gas = xyes; then
3877 as_ix86_tls_ldm_opt="--32"
3879 if echo "$ld_ver" | grep GNU > /dev/null; then
3880 if $gcc_cv_ld -V 2>/dev/null | grep elf_i386_sol2 > /dev/null; then
3881 ld_ix86_tls_ldm_opt="-melf_i386_sol2"
3883 ld_ix86_tls_ldm_opt="-melf_i386"
3887 .section .text,"ax",@progbits
3889 .type _start, @function
3891 leal value@tlsldm(%ebx), %eax
3892 call ___tls_get_addr@plt
3894 .section .tdata,"aw'$tls_section_flag'",@progbits
3895 .type value, @object
3897 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM reloc],
3898 gcc_cv_as_ix86_tlsldm,,
3899 [$as_ix86_tls_ldm_opt],
3901 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3902 && $gcc_cv_ld $ld_ix86_tls_ldm_opt -o conftest conftest.o $ld_tls_libs -lc > /dev/null 2>&1; then
3903 if $gcc_cv_objdump -d conftest 2>/dev/null | grep nop > /dev/null \
3904 || dis conftest 2>/dev/null | grep nop > /dev/null; then
3905 gcc_cv_as_ix86_tlsldm=yes
3909 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDM,
3910 [`if test $gcc_cv_as_ix86_tlsldm = yes; then echo 1; else echo 0; fi`],
3911 [Define to 1 if your assembler and linker support @tlsldm.])
3916 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
3917 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
3919 addl r15 = @ltoffx(x#), gp
3921 ld8.mov r16 = [[r15]], x#],,
3922 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
3923 [Define if your assembler supports ltoffx and ldxmov relocations.])])
3929 *-*-aix*) conftest_s=' .machine "pwr5"
3933 gcc_GAS_CHECK_FEATURE([.machine directive support],
3934 gcc_cv_as_machine_directive,,,
3935 [ .machine ppc7400])
3936 if test x$gcc_cv_as_machine_directive != xyes; then
3937 echo "*** This target requires an assembler supporting \".machine\"" >&2
3938 echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
3939 test x$build = x$target && exit 1
3943 *) conftest_s=' .machine power4
3948 gcc_GAS_CHECK_FEATURE([mfcr field support],
3949 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
3951 [AC_DEFINE(HAVE_AS_MFCRF, 1,
3952 [Define if your assembler supports mfcr field.])])
3955 *-*-aix*) conftest_s=' .machine "pwr5"
3958 *) conftest_s=' .machine power5
3963 gcc_GAS_CHECK_FEATURE([popcntb support],
3964 gcc_cv_as_powerpc_popcntb, [2,17,0],,
3966 [AC_DEFINE(HAVE_AS_POPCNTB, 1,
3967 [Define if your assembler supports popcntb field.])])
3970 *-*-aix*) conftest_s=' .machine "pwr5x"
3973 *) conftest_s=' .machine power5
3978 gcc_GAS_CHECK_FEATURE([fp round support],
3979 gcc_cv_as_powerpc_fprnd, [2,17,0],,
3981 [AC_DEFINE(HAVE_AS_FPRND, 1,
3982 [Define if your assembler supports fprnd.])])
3985 *-*-aix*) conftest_s=' .machine "pwr6"
3988 *) conftest_s=' .machine power6
3993 gcc_GAS_CHECK_FEATURE([move fp gpr support],
3994 gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
3996 [AC_DEFINE(HAVE_AS_MFPGPR, 1,
3997 [Define if your assembler supports mffgpr and mftgpr.])])
4000 *-*-aix*) conftest_s=' .csect .text[[PR]]
4002 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
4006 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
4007 *) conftest_s=' .text
4009 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
4012 gcc_GAS_CHECK_FEATURE([rel16 relocs],
4013 gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
4015 [AC_DEFINE(HAVE_AS_REL16, 1,
4016 [Define if your assembler supports R_PPC_REL16 relocs.])])
4019 *-*-aix*) conftest_s=' .machine "pwr6"
4022 *) conftest_s=' .machine power6
4027 gcc_GAS_CHECK_FEATURE([compare bytes support],
4028 gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
4030 [AC_DEFINE(HAVE_AS_CMPB, 1,
4031 [Define if your assembler supports cmpb.])])
4034 *-*-aix*) conftest_s=' .machine "pwr6"
4037 *) conftest_s=' .machine power6
4042 gcc_GAS_CHECK_FEATURE([decimal float support],
4043 gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
4045 [AC_DEFINE(HAVE_AS_DFP, 1,
4046 [Define if your assembler supports DFP instructions.])])
4049 *-*-aix*) conftest_s=' .machine "pwr7"
4052 *) conftest_s=' .machine power7
4057 gcc_GAS_CHECK_FEATURE([vector-scalar support],
4058 gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
4060 [AC_DEFINE(HAVE_AS_VSX, 1,
4061 [Define if your assembler supports VSX instructions.])])
4064 *-*-aix*) conftest_s=' .machine "pwr7"
4067 *) conftest_s=' .machine power7
4072 gcc_GAS_CHECK_FEATURE([popcntd support],
4073 gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
4075 [AC_DEFINE(HAVE_AS_POPCNTD, 1,
4076 [Define if your assembler supports POPCNTD instructions.])])
4079 *-*-aix*) conftest_s=' .machine "pwr8"
4080 .csect .text[[PR]]';;
4081 *) conftest_s=' .machine power8
4085 gcc_GAS_CHECK_FEATURE([power8 support],
4086 gcc_cv_as_powerpc_power8, [2,19,2], -a32,
4088 [AC_DEFINE(HAVE_AS_POWER8, 1,
4089 [Define if your assembler supports POWER8 instructions.])])
4092 *-*-aix*) conftest_s=' .csect .text[[PR]]
4094 *) conftest_s=' .text
4098 gcc_GAS_CHECK_FEATURE([lwsync support],
4099 gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
4101 [AC_DEFINE(HAVE_AS_LWSYNC, 1,
4102 [Define if your assembler supports LWSYNC instructions.])])
4105 *-*-aix*) conftest_s=' .machine "476"
4108 *) conftest_s=' .machine "476"
4113 gcc_GAS_CHECK_FEATURE([data cache invalidate support],
4114 gcc_cv_as_powerpc_dci, [9,99,0], -a32,
4116 [AC_DEFINE(HAVE_AS_DCI, 1,
4117 [Define if your assembler supports the DCI/ICI instructions.])])
4119 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4120 gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
4121 [.gnu_attribute 4,1],,
4122 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4123 [Define if your assembler supports .gnu_attribute.])])
4125 gcc_GAS_CHECK_FEATURE([tls marker support],
4126 gcc_cv_as_powerpc_tls_markers, [2,20,0],,
4127 [ bl __tls_get_addr(x@tlsgd)],,
4128 [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
4129 [Define if your assembler supports arg info for __tls_get_addr.])])
4133 gcc_GAS_CHECK_FEATURE([.ref support],
4134 gcc_cv_as_aix_ref, [2,21,0],,
4135 [ .csect stuff[[rw]]
4141 [AC_DEFINE(HAVE_AS_REF, 1,
4142 [Define if your assembler supports .ref])])
4148 gcc_GAS_CHECK_FEATURE([explicit relocation support],
4149 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
4150 [ lw $4,%gp_rel(foo)($4)],,
4151 [if test x$target_cpu_default = x
4152 then target_cpu_default=MASK_EXPLICIT_RELOCS
4153 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
4155 gcc_GAS_CHECK_FEATURE([-mno-shared support],
4156 gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
4157 [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
4158 [Define if the assembler understands -mno-shared.])])
4160 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4161 gcc_cv_as_mips_gnu_attribute, [2,18,0],,
4162 [.gnu_attribute 4,1],,
4163 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4164 [Define if your assembler supports .gnu_attribute.])])
4166 gcc_GAS_CHECK_FEATURE([.micromips support],
4167 gcc_cv_as_micromips_support,,[--fatal-warnings],
4169 [AC_DEFINE(HAVE_GAS_MICROMIPS, 1,
4170 [Define if your assembler supports the .set micromips directive])])
4172 gcc_GAS_CHECK_FEATURE([.dtprelword support],
4173 gcc_cv_as_mips_dtprelword, [2,18,0],,
4174 [.section .tdata,"awT",@progbits
4178 .dtprelword x+0x8000],,
4179 [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
4180 [Define if your assembler supports .dtprelword.])])
4182 gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
4183 gcc_cv_as_mips_dspr1_mult,,,
4193 [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
4194 [Define if your assembler supports DSPR1 mult.])])
4196 AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
4197 gcc_cv_as_ld_jalr_reloc=no
4198 if test $gcc_cv_as_mips_explicit_relocs = yes; then
4199 if test $in_tree_ld = yes ; then
4200 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 \
4201 && test $in_tree_ld_is_elf = yes; then
4202 gcc_cv_as_ld_jalr_reloc=yes
4204 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
4205 echo ' .ent x' > conftest.s
4206 echo 'x: lw $2,%got_disp(y)($3)' >> conftest.s
4207 echo ' lw $25,%call16(y)($28)' >> conftest.s
4208 echo ' .reloc 1f,R_MIPS_JALR,y' >> conftest.s
4209 echo '1: jalr $25' >> conftest.s
4210 echo ' .reloc 1f,R_MIPS_JALR,x' >> conftest.s
4211 echo '1: jalr $25' >> conftest.s
4212 echo ' .end x' >> conftest.s
4213 if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
4214 && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
4215 if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
4216 && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
4217 gcc_cv_as_ld_jalr_reloc=yes
4223 if test $gcc_cv_as_ld_jalr_reloc = yes; then
4224 if test x$target_cpu_default = x; then
4225 target_cpu_default=MASK_RELAX_PIC_CALLS
4227 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
4230 AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
4232 AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
4233 [gcc_cv_ld_mips_personality_relaxation],
4234 [gcc_cv_ld_mips_personality_relaxation=no
4235 if test $in_tree_ld = yes ; then
4236 if test "$gcc_cv_gld_major_version" -eq 2 \
4237 -a "$gcc_cv_gld_minor_version" -ge 21 \
4238 -o "$gcc_cv_gld_major_version" -gt 2; then
4239 gcc_cv_ld_mips_personality_relaxation=yes
4241 elif test x$gcc_cv_as != x \
4242 -a x$gcc_cv_ld != x \
4243 -a x$gcc_cv_readelf != x ; then
4244 cat > conftest.s <<EOF
4246 .cfi_personality 0x80,indirect_ptr
4253 .section .data,"aw",@progbits
4257 if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
4258 && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
4259 if $gcc_cv_readelf -d conftest 2>&1 \
4260 | grep TEXTREL > /dev/null 2>&1; then
4262 elif $gcc_cv_readelf --relocs conftest 2>&1 \
4263 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
4266 gcc_cv_ld_mips_personality_relaxation=yes
4270 rm -f conftest.s conftest.o conftest])
4271 if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
4272 AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
4273 [Define if your linker can relax absolute .eh_frame personality
4274 pointers into PC-relative form.])
4277 gcc_GAS_CHECK_FEATURE([-mnan= support],
4278 gcc_cv_as_mips_nan,,
4280 [AC_DEFINE(HAVE_AS_NAN, 1,
4281 [Define if the assembler understands -mnan=.])])
4282 if test x$gcc_cv_as_mips_nan = xno \
4283 && test x$with_nan != x; then
4285 [Requesting --with-nan= requires assembler support for -mnan=])
4290 # Mips and HP-UX need the GNU assembler.
4291 # Linux on IA64 might be able to use the Intel assembler.
4294 mips*-*-* | *-*-hpux* )
4295 if test x$gas_flag = xyes \
4296 || test x"$host" != x"$build" \
4297 || test ! -x "$gcc_cv_as" \
4298 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
4301 echo "*** This configuration requires the GNU assembler" >&2
4307 # ??? Not all targets support dwarf2 debug_line, even within a version
4308 # of gas. Moreover, we need to emit a valid instruction to trigger any
4309 # info to the output file. So, as supported targets are added to gas 2.11,
4310 # add some instruction here to (also) show we expect this might work.
4311 # ??? Once 2.11 is released, probably need to add first known working
4312 # version to the per-target configury.
4314 aarch64 | alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze \
4315 | mips | nios2 | pa | rs6000 | score | sparc | spu | tilegx | tilepro \
4316 | xstormy16 | xtensa)
4326 if test x"$insn" != x; then
4328 .file 1 \"conftest.s\"
4331 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
4332 gcc_cv_as_dwarf2_debug_line,
4333 [elf,2,11,0],, [$conftest_s],
4334 [if test x$gcc_cv_objdump != x \
4335 && $gcc_cv_objdump -h conftest.o 2> /dev/null \
4336 | grep debug_line > /dev/null 2>&1; then
4337 gcc_cv_as_dwarf2_debug_line=yes
4340 # The .debug_line file table must be in the exact order that
4341 # we specified the files, since these indices are also used
4342 # by DW_AT_decl_file. Approximate this test by testing if
4343 # the assembler bitches if the same index is assigned twice.
4344 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
4345 gcc_cv_as_dwarf2_file_buggy,,,
4349 if test $gcc_cv_as_dwarf2_debug_line = yes \
4350 && test $gcc_cv_as_dwarf2_file_buggy = no; then
4351 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
4352 [Define if your assembler supports dwarf2 .file/.loc directives,
4353 and preserves file table indices exactly as given.])
4356 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
4357 gcc_cv_as_gdwarf2_flag,
4358 [elf,2,11,0], [--gdwarf2], [$insn],,
4359 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
4360 [Define if your assembler supports the --gdwarf2 option.])])
4362 gcc_GAS_CHECK_FEATURE([--gstabs option],
4363 gcc_cv_as_gstabs_flag,
4364 [elf,2,11,0], [--gstabs], [$insn],,
4365 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
4366 [Define if your assembler supports the --gstabs option.])])
4368 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
4369 gcc_cv_as_debug_prefix_map_flag,
4370 [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
4371 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
4372 [Define if your assembler supports the --debug-prefix-map option.])])
4375 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
4378 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
4379 [Define if your assembler supports .lcomm with an alignment field.])])
4381 if test x$with_sysroot = x && test x$host = x$target \
4382 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4383 && test "$prefix" != "NONE"; then
4384 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4385 [Define to PREFIX/include if cpp should also search that directory.])
4388 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4389 if test "x$with_headers" != x; then
4390 target_header_dir=$with_headers
4391 elif test "x$with_sysroot" = x; then
4392 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include"
4393 elif test "x$with_build_sysroot" != "x"; then
4394 target_header_dir="${with_build_sysroot}${native_system_header_dir}"
4395 elif test "x$with_sysroot" = xyes; then
4396 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
4398 target_header_dir="${with_sysroot}${native_system_header_dir}"
4401 target_header_dir=${native_system_header_dir}
4404 # Determine the version of glibc, if any, used on the target.
4405 AC_MSG_CHECKING([for target glibc version])
4406 AC_ARG_WITH([glibc-version],
4407 [AS_HELP_STRING([--with-glibc-version=M.N],
4408 [assume GCC used with glibc version M.N or later])], [
4409 if [echo "$with_glibc_version" | grep '^[0-9][0-9]*\.[0-9][0-9]*$']; then
4410 glibc_version_major=`echo "$with_glibc_version" | sed -e 's/\..*//'`
4411 glibc_version_minor=`echo "$with_glibc_version" | sed -e 's/.*\.//'`
4413 AC_MSG_ERROR([option --with-glibc-version requires a version number M.N])
4415 glibc_version_major=0
4416 glibc_version_minor=0
4417 [if test -f $target_header_dir/features.h \
4418 && glibc_version_major_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+[0-9]' $target_header_dir/features.h` \
4419 && glibc_version_minor_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+[0-9]' $target_header_dir/features.h`; then
4420 glibc_version_major=`echo "$glibc_version_major_define" | sed -e 's/.*__GLIBC__[ ]*//'`
4421 glibc_version_minor=`echo "$glibc_version_minor_define" | sed -e 's/.*__GLIBC_MINOR__[ ]*//'`
4423 AC_MSG_RESULT([$glibc_version_major.$glibc_version_minor])
4425 AC_ARG_ENABLE(gnu-unique-object,
4426 [AS_HELP_STRING([--enable-gnu-unique-object],
4427 [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
4428 [case $enable_gnu_unique_object in
4430 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
4431 Valid choices are 'yes' and 'no'.]) ;;
4433 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
4435 [.type foo, '$target_type_format_char'gnu_unique_object],,
4436 # We need to unquote above to to use the definition from config.gcc.
4437 # Also check for ld.so support, i.e. glibc 2.11 or higher.
4438 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [11], [enable_gnu_unique_object=yes], )]
4440 if test x$enable_gnu_unique_object = xyes; then
4441 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
4442 [Define if your assembler supports @gnu_unique_object.])
4445 AC_CACHE_CHECK([assembler for tolerance to line number 0],
4446 [gcc_cv_as_line_zero],
4447 [gcc_cv_as_line_zero=no
4448 if test $in_tree_gas = yes; then
4449 gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
4450 elif test "x$gcc_cv_as" != x; then
4451 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
4452 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
4453 test "x`cat conftest.out`" = x
4455 gcc_cv_as_line_zero=yes
4457 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
4458 cat conftest.s >&AS_MESSAGE_LOG_FD
4459 echo "configure: error output was" >&AS_MESSAGE_LOG_FD
4460 cat conftest.out >&AS_MESSAGE_LOG_FD
4462 rm -f conftest.o conftest.s conftest.out
4464 if test "x$gcc_cv_as_line_zero" = xyes; then
4465 AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
4466 [Define if the assembler won't complain about a line such as # 0 "" 2.])
4469 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
4470 gcc_cv_ld_eh_frame_hdr=no
4471 if test $in_tree_ld = yes ; then
4472 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 \
4473 && test $in_tree_ld_is_elf = yes; then
4474 gcc_cv_ld_eh_frame_hdr=yes
4476 elif test x$gcc_cv_ld != x; then
4477 if echo "$ld_ver" | grep GNU > /dev/null; then
4478 # Check if linker supports --eh-frame-hdr option
4479 if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
4480 gcc_cv_ld_eh_frame_hdr=yes
4485 # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
4486 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
4487 gcc_cv_ld_eh_frame_hdr=yes
4493 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
4494 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
4495 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
4496 [Define if your linker supports .eh_frame_hdr.])
4498 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
4500 AC_MSG_CHECKING(linker CIEv3 in .eh_frame support)
4501 gcc_cv_ld_eh_frame_ciev3=no
4502 if test $in_tree_ld = yes ; then
4503 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 \
4504 && test $in_tree_ld_is_elf = yes; then
4505 gcc_cv_ld_eh_frame_ciev3=yes
4507 elif test x$gcc_cv_ld != x; then
4508 if echo "$ld_ver" | grep GNU > /dev/null; then
4509 gcc_cv_ld_eh_frame_ciev3=yes
4510 if test 0"$ld_date" -lt 20040513; then
4511 if test -n "$ld_date"; then
4512 # If there was date string, but was earlier than 2004-05-13, fail
4513 gcc_cv_ld_eh_frame_ciev3=no
4514 elif test "$ld_vers_major" -lt 2; then
4515 gcc_cv_ld_eh_frame_ciev3=no
4516 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
4517 gcc_cv_ld_eh_frame_ciev3=no
4523 # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1.
4524 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then
4525 gcc_cv_ld_eh_frame_ciev3=yes
4531 AC_DEFINE_UNQUOTED(HAVE_LD_EH_FRAME_CIEV3,
4532 [`if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi`],
4533 [Define 0/1 if your linker supports CIE v3 in .eh_frame.])
4534 AC_MSG_RESULT($gcc_cv_ld_eh_frame_ciev3)
4536 AC_MSG_CHECKING(linker position independent executable support)
4538 if test $in_tree_ld = yes ; then
4539 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 15 -o "$gcc_cv_gld_major_version" -gt 2 \
4540 && test $in_tree_ld_is_elf = yes; then
4543 elif test x$gcc_cv_ld != x; then
4544 # Check if linker supports -pie option
4545 if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
4549 if test x"$gcc_cv_ld_pie" = xyes; then
4550 AC_DEFINE(HAVE_LD_PIE, 1,
4551 [Define if your linker supports -pie option.])
4553 AC_MSG_RESULT($gcc_cv_ld_pie)
4555 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
4556 gcc_cv_ld_eh_gc_sections=no
4557 if test $in_tree_ld = yes ; then
4558 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 \
4559 && test $in_tree_ld_is_elf = yes; then
4560 gcc_cv_ld_eh_gc_sections=yes
4562 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
4563 cat > conftest.s <<EOF
4566 .type _start, @function
4569 .size _start, .-_start
4570 .section .text.foo,"ax",@progbits
4571 .type foo, @function
4575 .section .gcc_except_table.foo,"a",@progbits
4578 .section .eh_frame,"a",@progbits
4581 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4582 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4583 | grep "gc-sections option ignored" > /dev/null; then
4584 gcc_cv_ld_eh_gc_sections=no
4585 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4586 | grep gcc_except_table > /dev/null; then
4587 gcc_cv_ld_eh_gc_sections=yes
4588 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
4589 if test x$gcc_cv_as_comdat_group != xyes; then
4590 gcc_cv_ld_eh_gc_sections=no
4591 cat > conftest.s <<EOF
4594 .type _start, @function
4597 .size _start, .-_start
4598 .section .gnu.linkonce.t.foo,"ax",@progbits
4599 .type foo, @function
4603 .section .gcc_except_table.foo,"a",@progbits
4606 .section .eh_frame,"a",@progbits
4609 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4610 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4611 | grep "gc-sections option ignored" > /dev/null; then
4612 gcc_cv_ld_eh_gc_sections=no
4613 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4614 | grep gcc_except_table > /dev/null; then
4615 gcc_cv_ld_eh_gc_sections=yes
4621 rm -f conftest.s conftest.o conftest
4625 # ??? This apparently exposes a binutils bug with PC-relative relocations.
4626 gcc_cv_ld_eh_gc_sections=no
4629 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
4630 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
4631 [Define if your linker supports garbage collection of
4632 sections in presence of EH frames.])
4634 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
4636 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
4637 gcc_cv_ld_eh_gc_sections_bug=no
4638 if test $in_tree_ld = yes ; then
4639 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 \
4640 && test $in_tree_ld_is_elf = yes; then
4641 gcc_cv_ld_eh_gc_sections_bug=yes
4643 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
4644 gcc_cv_ld_eh_gc_sections_bug=yes
4645 cat > conftest.s <<EOF
4648 .type _start, @function
4651 .size _start, .-_start
4652 .section .text.startup.foo,"ax",@progbits
4653 .type foo, @function
4657 .section .gcc_except_table.foo,"a",@progbits
4660 .section .eh_frame,"a",@progbits
4663 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4664 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4665 | grep "gc-sections option ignored" > /dev/null; then
4667 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4668 | grep gcc_except_table > /dev/null; then
4669 gcc_cv_ld_eh_gc_sections_bug=no
4672 rm -f conftest.s conftest.o conftest
4674 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
4675 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
4676 [Define if your linker has buggy garbage collection of
4677 sections support when .text.startup.foo like sections are used.])
4679 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
4685 AC_CACHE_CHECK(linker --as-needed support,
4686 gcc_cv_ld_as_needed,
4687 [gcc_cv_ld_as_needed=no
4688 gcc_cv_ld_as_needed_option='--as-needed'
4689 gcc_cv_ld_no_as_needed_option='--no-as-needed'
4690 if test $in_tree_ld = yes ; then
4691 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 \
4692 && test $in_tree_ld_is_elf = yes; then
4693 gcc_cv_ld_as_needed=yes
4695 elif test x$gcc_cv_ld != x; then
4696 # Check if linker supports --as-needed and --no-as-needed options
4697 if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
4698 gcc_cv_ld_as_needed=yes
4701 # Solaris 2 ld always supports -z ignore/-z record.
4703 gcc_cv_ld_as_needed=yes
4704 gcc_cv_ld_as_needed_option="-z ignore"
4705 gcc_cv_ld_no_as_needed_option="-z record"
4710 # --as-needed/-z ignore can only be used if libgcc_s.so.1 uses
4711 # dl_iterate_phdr, i.e. since Solaris 11.
4713 *-*-solaris2.1[[1-9]]*)
4715 i?86-*-* | x86_64-*-*)
4716 if echo "$ld_ver" | grep GNU > /dev/null; then
4717 # Doesn't work with gld on Solaris/x86 due to PR ld/12320.
4718 gcc_cv_ld_as_needed=no
4724 gcc_cv_ld_as_needed=no
4728 if test x"$gcc_cv_ld_as_needed" = xyes; then
4729 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
4730 [Define if your linker supports --as-needed/--no-as-needed or equivalent options.])
4731 AC_DEFINE_UNQUOTED(LD_AS_NEEDED_OPTION, "$gcc_cv_ld_as_needed_option",
4732 [Define to the linker option to ignore unused dependencies.])
4733 AC_DEFINE_UNQUOTED(LD_NO_AS_NEEDED_OPTION, "$gcc_cv_ld_no_as_needed_option",
4734 [Define to the linker option to keep unused dependencies.])
4737 AC_MSG_CHECKING(linker mapfile support for clearing hardware capabilities)
4738 saved_LDFLAGS="$LDFLAGS"
4739 for clearcap_map in sol2-clearcapv2.map sol2-clearcap.map; do
4740 LDFLAGS="$saved_LDFLAGS -Wl,-M,${srcdir}/config/$clearcap_map"
4741 AC_LINK_IFELSE([int main(void) {return 0;}],
4742 [gcc_cv_ld_clearcap=yes; break], [gcc_cv_ld_clearcap=no])
4744 LDFLAGS="$saved_LDFLAGS"
4745 if test "x$gcc_cv_ld_clearcap" = xyes; then
4746 AC_DEFINE([HAVE_LD_CLEARCAP], 1,
4747 [Define if the linker supports clearing hardware capabilities via mapfile.])
4748 AC_CONFIG_LINKS([clearcap.map:${srcdir}/config/$clearcap_map])
4750 AC_MSG_RESULT($gcc_cv_ld_clearcap)
4752 case "$target:$tm_file" in
4753 powerpc64-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
4756 emul_name="-melf64lppc"
4759 emul_name="-melf64ppc"
4762 emul_name="-melf64ppc_fbsd"
4765 AC_CACHE_CHECK(linker support for omitting dot symbols,
4766 gcc_cv_ld_no_dot_syms,
4767 [gcc_cv_ld_no_dot_syms=no
4768 if test x"$ld_is_gold" = xyes; then
4769 gcc_cv_ld_no_dot_syms=yes
4770 elif test $in_tree_ld = yes ; then
4771 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
4772 gcc_cv_ld_no_dot_syms=yes
4774 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4775 cat > conftest1.s <<EOF
4779 cat > conftest2.s <<EOF
4780 .section ".opd","aw"
4785 .quad .LEfoo,.TOC.@tocbase,0
4791 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4792 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4793 && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
4794 gcc_cv_ld_no_dot_syms=yes
4796 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
4799 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
4800 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
4801 [Define if your PowerPC64 linker only needs function descriptor syms.])
4804 AC_CACHE_CHECK(linker large toc support,
4805 gcc_cv_ld_large_toc,
4806 [gcc_cv_ld_large_toc=no
4807 if test x"$ld_is_gold" = xyes; then
4808 gcc_cv_ld_large_toc=yes
4809 elif test $in_tree_ld = yes ; then
4810 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
4811 gcc_cv_ld_large_toc=yes
4813 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4814 cat > conftest.s <<EOF
4815 .section ".tbss","awT",@nobits
4821 addis 9,13,ie0@got@tprel@ha
4822 ld 9,ie0@got@tprel@l(9)
4824 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
4825 && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
4826 gcc_cv_ld_large_toc=yes
4828 rm -f conftest conftest.o conftest.s
4831 if test x"$gcc_cv_ld_large_toc" = xyes; then
4832 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4833 [Define if your PowerPC64 linker supports a large TOC.])
4840 AC_CACHE_CHECK(linker large toc support,
4841 gcc_cv_ld_large_toc,
4842 [gcc_cv_ld_large_toc=no
4843 if test x$gcc_cv_as != x ; then
4844 cat > conftest.s <<EOF
4854 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1; then
4855 gcc_cv_ld_large_toc=yes
4857 rm -f conftest conftest.o conftest.s
4860 if test x"$gcc_cv_ld_large_toc" = xyes; then
4861 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4862 [Define if your PowerPC64 linker supports a large TOC.])
4867 AC_CACHE_CHECK(linker --build-id support,
4869 [gcc_cv_ld_buildid=no
4870 if test $in_tree_ld = yes ; then
4871 if test "$gcc_cv_gld_major_version" -eq 2 -a \
4872 "$gcc_cv_gld_minor_version" -ge 18 -o \
4873 "$gcc_cv_gld_major_version" -gt 2 \
4874 && test $in_tree_ld_is_elf = yes; then
4875 gcc_cv_ld_buildid=yes
4877 elif test x$gcc_cv_ld != x; then
4878 if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
4879 gcc_cv_ld_buildid=yes
4882 if test x"$gcc_cv_ld_buildid" = xyes; then
4883 AC_DEFINE(HAVE_LD_BUILDID, 1,
4884 [Define if your linker supports --build-id.])
4887 AC_ARG_ENABLE(linker-build-id,
4888 [AS_HELP_STRING([--enable-linker-build-id],
4889 [compiler will always pass --build-id to linker])],
4891 enable_linker_build_id=no)
4893 if test x"$enable_linker_build_id" = xyes; then
4894 if test x"$gcc_cv_ld_buildid" = xyes; then
4895 AC_DEFINE(ENABLE_LD_BUILDID, 1,
4896 [Define if gcc should always pass --build-id to linker.])
4898 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
4902 # In binutils 2.21, GNU ld gained support for new emulations fully
4903 # supporting the Solaris 2 ABI. Detect their presence in the linker used.
4904 AC_CACHE_CHECK(linker *_sol2 emulation support,
4905 gcc_cv_ld_sol2_emulation,
4906 [gcc_cv_ld_sol2_emulation=no
4907 if test $in_tree_ld = yes ; then
4908 if test "$gcc_cv_gld_major_version" -eq 2 -a \
4909 "$gcc_cv_gld_minor_version" -ge 21 -o \
4910 "$gcc_cv_gld_major_version" -gt 2 \
4911 && test $in_tree_ld_is_elf = yes; then
4912 gcc_cv_ld_sol2_emulation=yes
4914 elif test x$gcc_cv_ld != x; then
4915 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
4916 grep _sol2 > /dev/null; then
4917 gcc_cv_ld_sol2_emulation=yes
4920 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
4921 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
4922 [Define if your linker supports the *_sol2 emulations.])
4925 AC_CACHE_CHECK(linker --sysroot support,
4927 [gcc_cv_ld_sysroot=no
4928 if test $in_tree_ld = yes ; then
4929 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
4930 gcc_cv_ld_sysroot=yes
4932 elif test x$gcc_cv_ld != x; then
4933 if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
4934 gcc_cv_ld_sysroot=yes
4937 if test x"$gcc_cv_ld_sysroot" = xyes; then
4938 AC_DEFINE(HAVE_LD_SYSROOT, 1,
4939 [Define if your linker supports --sysroot.])
4942 # Test for stack protector support in target C library.
4943 AC_CACHE_CHECK(__stack_chk_fail in target C library,
4944 gcc_cv_libc_provides_ssp,
4945 [gcc_cv_libc_provides_ssp=no
4947 *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
4948 # glibc 2.4 and later provides __stack_chk_fail and
4949 # either __stack_chk_guard, or TLS access to stack guard canary.
4950 GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_libc_provides_ssp=yes], [
4951 [if test -f $target_header_dir/features.h \
4952 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \
4953 $target_header_dir/features.h > /dev/null; then
4954 if $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \
4955 $target_header_dir/features.h > /dev/null && \
4956 test -f $target_header_dir/bits/uClibc_config.h && \
4957 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \
4958 $target_header_dir/bits/uClibc_config.h > /dev/null; then
4959 gcc_cv_libc_provides_ssp=yes
4961 # all versions of Bionic support stack protector
4962 elif test -f $target_header_dir/sys/cdefs.h \
4963 && $EGREP '^[ ]*#[ ]*define[ ]+__BIONIC__[ ]+1' \
4964 $target_header_dir/sys/cdefs.h > /dev/null; then
4965 gcc_cv_libc_provides_ssp=yes
4969 # Avoid complicated tests (see
4970 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
4971 # simply assert that glibc does provide this, which is true for all
4972 # realistically usable GNU/Hurd configurations.
4973 gcc_cv_libc_provides_ssp=yes;;
4974 *-*-darwin* | *-*-freebsd*)
4975 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
4976 [echo "no __stack_chk_fail on this target"])
4978 *) gcc_cv_libc_provides_ssp=no ;;
4981 if test x$gcc_cv_libc_provides_ssp = xyes; then
4982 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
4983 [Define if your target C library provides stack protector support])
4986 # Test for <sys/sdt.h> on the target.
4987 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
4988 AC_MSG_CHECKING(sys/sdt.h in the target C library)
4990 if test -f $target_header_dir/sys/sdt.h; then
4992 AC_DEFINE(HAVE_SYS_SDT_H, 1,
4993 [Define if your target C library provides sys/sdt.h])
4995 AC_MSG_RESULT($have_sys_sdt_h)
4997 # Check if TFmode long double should be used by default or not.
4998 # Some glibc targets used DFmode long double, but with glibc 2.4
4999 # and later they can use TFmode.
5001 powerpc*-*-linux* | \
5005 AC_ARG_WITH(long-double-128,
5006 [AS_HELP_STRING([--with-long-double-128],
5007 [use 128-bit long double by default])],
5008 gcc_cv_target_ldbl128="$with_long_double_128",
5009 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_target_ldbl128=yes], [
5010 [gcc_cv_target_ldbl128=no
5011 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \
5012 $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
5013 && gcc_cv_target_ldbl128=yes
5017 if test x$gcc_cv_target_ldbl128 = xyes; then
5018 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
5019 [Define if TFmode long double should be the default])
5022 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
5023 gcc_cv_target_dl_iterate_phdr=unknown
5025 # Restrict to Solaris 11+. While most of the Solaris 11 linker changes
5026 # were backported to Solaris 10 Update 10, dl_iterate_phdr only lives in
5027 # libdl there, both complicating its use and breaking compatibility
5028 # between Solaris 10 updates.
5029 *-*-solaris2.1[[1-9]]*)
5030 # <link.h> needs both a dl_iterate_phdr declaration and support for
5031 # compilation with largefile support.
5032 if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
5033 && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
5034 gcc_cv_target_dl_iterate_phdr=yes
5036 gcc_cv_target_dl_iterate_phdr=no
5039 *-*-dragonfly* | *-*-freebsd*)
5040 if grep dl_iterate_phdr $target_header_dir/sys/link_elf.h > /dev/null 2>&1; then
5041 gcc_cv_target_dl_iterate_phdr=yes
5043 gcc_cv_target_dl_iterate_phdr=no
5047 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
5048 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
5049 AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
5050 [Define if your target C library provides the `dl_iterate_phdr' function.])
5052 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
5054 # We no longer support different GC mechanisms. Emit an error if
5055 # the user configures with --with-gc.
5057 [AS_HELP_STRING([--with-gc={page,zone}],
5058 [this option is not supported anymore. It used to choose
5059 the garbage collection mechanism to use with the compiler])],
5060 [AC_MSG_ERROR([Configure option --with-gc is only supported up to GCC 4.7.x])],
5063 # Libraries to use on the host. This will normally be set by the top
5064 # level Makefile. Here we simply capture the value for our Makefile.
5065 if test -z "${HOST_LIBS+set}"; then
5070 # Use the system's zlib library.
5072 zlibinc="-I\$(srcdir)/../zlib"
5073 AC_ARG_WITH(system-zlib,
5074 [AS_HELP_STRING([--with-system-zlib], [use installed libz])],
5081 dnl Very limited version of automake's enable-maintainer-mode
5083 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
5084 dnl maintainer-mode is disabled by default
5085 AC_ARG_ENABLE(maintainer-mode,
5086 [AS_HELP_STRING([--enable-maintainer-mode],
5087 [enable make rules and dependencies not useful
5088 (and sometimes confusing) to the casual installer])],
5089 maintainer_mode=$enableval,
5092 AC_MSG_RESULT($maintainer_mode)
5094 if test "$maintainer_mode" = "yes"; then
5101 dnl Whether to prevent multiple front-ends from linking at the same time
5103 AC_MSG_CHECKING([whether to avoid linking multiple front-ends at once])
5104 AC_ARG_ENABLE(link-mutex,
5105 [AS_HELP_STRING([--enable-link-mutex],
5106 [avoid linking multiple front-ends at once to avoid thrashing
5107 on the build machine])],
5108 do_link_mutex=$enableval,
5110 AC_MSG_RESULT($do_link_mutex)
5112 if test "$do_link_mutex" = "yes"; then
5117 AC_SUBST(DO_LINK_MUTEX)
5123 # Make empty files to contain the specs and options for each language.
5124 # Then add #include lines to for a compiler that has specs and/or options.
5130 # These (without "all_") are set in each config-lang.in.
5131 # `language' must be a single word so is spelled singularly.
5134 all_outputs='Makefile'
5135 # List of language makefile fragments.
5137 # Additional files for gengtype
5138 all_gtfiles="$target_gtfiles"
5140 # These are the languages that are set in --enable-languages,
5141 # and are available in the GCC tree.
5142 all_selected_languages=
5144 # Add the language fragments.
5145 # Languages are added via two mechanisms. Some information must be
5146 # recorded in makefile variables, these are defined in config-lang.in.
5147 # We accumulate them and plug them into the main Makefile.
5148 # The other mechanism is a set of hooks for each of the main targets
5149 # like `clean', `install', etc.
5151 language_hooks="Make-hooks"
5153 for lang in ${srcdir}/*/config-lang.in
5156 test "$lang" = "${srcdir}/*/config-lang.in" && continue
5158 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
5159 if test "x$lang_alias" = x
5161 echo "$lang doesn't set \$language." 1>&2
5164 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
5165 subdirs="$subdirs $subdir"
5167 # $gcc_subdir is where the gcc integration files are to be found
5168 # for a language, both for internal compiler purposes (compiler
5169 # sources implementing front-end to GCC tree converters), and for
5170 # build infrastructure purposes (Make-lang.in, etc.)
5172 # This will be <subdir> (relative to $srcdir) if a line like
5173 # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
5174 # is found in <langdir>/config-lang.in, and will remain <langdir>
5177 # Except for the language alias (fetched above), the regular
5178 # "config-lang.in" contents are always retrieved from $gcc_subdir,
5179 # so a <langdir>/config-lang.in setting gcc_subdir typically sets
5180 # only this and the language alias.
5182 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang`
5183 if [ "$gcc_subdir" = "" ]; then
5184 gcc_subdir="$subdir"
5187 case ",$enable_languages," in
5189 all_selected_languages="$all_selected_languages $lang_alias"
5190 if test -f $srcdir/$gcc_subdir/lang-specs.h; then
5191 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
5203 . ${srcdir}/$gcc_subdir/config-lang.in
5204 if test "x$language" = x
5206 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
5211 case ",$enable_languages," in
5214 for i in $subdir_requires; do
5215 test -f "${srcdir}/$i/config-lang.in" && continue
5223 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
5224 if test -f $srcdir/$gcc_subdir/lang.opt; then
5225 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
5226 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
5228 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
5229 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
5231 all_languages="$all_languages $language"
5232 all_compilers="$all_compilers $compilers"
5233 all_outputs="$all_outputs $outputs"
5234 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
5235 case ",$enable_languages," in
5237 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
5239 AC_SUBST(enable_lto)
5246 for language in $all_selected_languages
5248 check_languages="$check_languages check-$language"
5251 # We link each language in with a set of hooks, reached indirectly via
5252 # lang.${target}. Only do so for selected languages.
5256 target_list="all.cross start.encap rest.encap tags \
5257 install-common install-man install-info install-pdf install-html dvi \
5258 pdf html uninstall info man srcextra srcman srcinfo \
5259 mostlyclean clean distclean maintainer-clean install-plugin"
5261 for t in $target_list
5264 for lang in $all_selected_languages
5268 echo "lang.$t: $x" >> Make-hooks
5272 # Option include files
5275 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
5276 option_includes="option-includes.mk"
5277 AC_SUBST_FILE(option_includes)
5285 echo "dir ." > .gdbinit
5286 echo "dir ${srcdir}" >> .gdbinit
5287 if test x$gdb_needs_out_file_path = xyes
5289 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
5291 if test "x$subdirs" != x; then
5294 echo "dir ${srcdir}/$s" >> .gdbinit
5297 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
5298 echo "python import sys; sys.path.append('${srcdir}'); import gdbhooks" >> .gdbinit
5300 # Put a breakpoint on __asan_report_error to help with debugging buffer
5303 *-fsanitize=address*)
5304 echo "source ${srcdir}/gdbasan.in" >> .gdbinit
5308 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
5309 AC_SUBST(gcc_tooldir)
5312 # Find a directory in which to install a shared libgcc.
5314 AC_ARG_ENABLE(version-specific-runtime-libs,
5315 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
5316 [specify that runtime libraries should be
5317 installed in a compiler-specific directory])])
5319 # Substitute configuration variables
5322 AC_SUBST(all_compilers)
5323 AC_SUBST(all_gtfiles)
5324 AC_SUBST(all_lang_makefrags)
5325 AC_SUBST(all_languages)
5326 AC_SUBST(all_selected_languages)
5327 AC_SUBST(build_exeext)
5328 AC_SUBST(build_install_headers_dir)
5329 AC_SUBST(build_xm_file_list)
5330 AC_SUBST(build_xm_include_list)
5331 AC_SUBST(build_xm_defines)
5332 AC_SUBST(build_file_translate)
5333 AC_SUBST(check_languages)
5334 AC_SUBST(cpp_install_dir)
5335 AC_SUBST(xmake_file)
5336 AC_SUBST(tmake_file)
5337 AC_SUBST(TM_ENDIAN_CONFIG)
5338 AC_SUBST(TM_MULTILIB_CONFIG)
5339 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
5340 AC_SUBST(extra_gcc_objs)
5341 AC_SUBST(user_headers_inc_next_pre)
5342 AC_SUBST(user_headers_inc_next_post)
5343 AC_SUBST(extra_headers_list)
5344 AC_SUBST(extra_objs)
5345 AC_SUBST(extra_programs)
5346 AC_SUBST(float_h_file)
5347 AC_SUBST(gcc_config_arguments)
5348 AC_SUBST(gcc_gxx_include_dir)
5349 AC_SUBST(gcc_gxx_include_dir_add_sysroot)
5350 AC_SUBST(host_exeext)
5351 AC_SUBST(host_xm_file_list)
5352 AC_SUBST(host_xm_include_list)
5353 AC_SUBST(host_xm_defines)
5354 AC_SUBST(out_host_hook_obj)
5356 AC_SUBST(lang_opt_files)
5357 AC_SUBST(lang_specs_files)
5358 AC_SUBST(lang_tree_files)
5359 AC_SUBST(local_prefix)
5361 AC_SUBST(objc_boehm_gc)
5363 AC_SUBST(out_object_file)
5364 AC_SUBST(common_out_file)
5365 AC_SUBST(common_out_object_file)
5366 AC_SUBST(tm_file_list)
5367 AC_SUBST(tm_include_list)
5368 AC_SUBST(tm_defines)
5369 AC_SUBST(tm_p_file_list)
5370 AC_SUBST(tm_p_include_list)
5371 AC_SUBST(xm_file_list)
5372 AC_SUBST(xm_include_list)
5373 AC_SUBST(xm_defines)
5374 AC_SUBST(use_gcc_stdint)
5375 AC_SUBST(c_target_objs)
5376 AC_SUBST(cxx_target_objs)
5377 AC_SUBST(fortran_target_objs)
5378 AC_SUBST(target_cpu_default)
5380 AC_SUBST_FILE(language_hooks)
5383 if test x${build} = x${host} ; then
5384 if test x${host} = x${target} ; then
5385 echo "Links are now set up to build a native compiler for ${target}." 1>&2
5387 echo "Links are now set up to build a cross-compiler" 1>&2
5388 echo " from ${host} to ${target}." 1>&2
5391 if test x${host} = x${target} ; then
5392 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
5393 echo " for ${target}." 1>&2
5395 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
5396 echo " from ${host} to ${target}." 1>&2
5400 AC_ARG_VAR(GMPLIBS,[How to link GMP])
5401 AC_ARG_VAR(GMPINC,[How to find GMP include files])
5403 AC_ARG_VAR(ISLLIBS,[How to link ISL])
5404 AC_ARG_VAR(ISLINC,[How to find ISL include files])
5406 AC_ARG_VAR(CLOOGLIBS,[How to link CLOOG])
5407 AC_ARG_VAR(CLOOGINC,[How to find CLOOG include files])
5408 if test "x${CLOOGLIBS}" != "x" ; then
5409 AC_DEFINE(HAVE_cloog, 1, [Define if cloog is in use.])
5412 # Check for plugin support
5413 AC_ARG_ENABLE(plugin,
5414 [AS_HELP_STRING([--enable-plugin], [enable plugin support])],
5415 enable_plugin=$enableval,
5416 enable_plugin=yes; default_plugin=yes)
5422 if test x$build = x$host; then
5423 export_sym_check="nm${exeext} -g"
5424 elif test x$host = x$target; then
5425 export_sym_check="$gcc_cv_nm -g"
5431 if test x$build = x$host; then
5432 export_sym_check="objdump${exeext} -T"
5433 elif test x$host = x$target; then
5434 export_sym_check="$gcc_cv_objdump -T"
5441 if test x"$enable_plugin" = x"yes"; then
5443 AC_MSG_CHECKING([for exported symbols])
5444 if test "x$export_sym_check" != x; then
5445 echo "int main() {return 0;} int foobar() {return 0;}" > conftest.c
5446 ${CC} ${CFLAGS} ${LDFLAGS} conftest.c -o conftest$ac_exeext > /dev/null 2>&1
5447 if $export_sym_check conftest$ac_exeext | grep -q foobar > /dev/null; then
5448 : # No need to use a flag
5449 AC_MSG_RESULT([yes])
5451 AC_MSG_RESULT([yes])
5452 AC_MSG_CHECKING([for -rdynamic])
5453 ${CC} ${CFLAGS} ${LDFLAGS} -rdynamic conftest.c -o conftest$ac_exeext > /dev/null 2>&1
5454 if $export_sym_check conftest$ac_exeext | grep -q foobar > /dev/null; then
5456 pluginlibs="-rdynamic"
5461 AC_MSG_RESULT([$plugin_rdynamic])
5464 AC_MSG_RESULT([unable to check])
5469 AC_SEARCH_LIBS([dlopen], [dl])
5470 if test x"$ac_cv_search_dlopen" = x"-ldl"; then
5471 pluginlibs="$pluginlibs -ldl"
5475 # Check that we can build shared objects with -fPIC -shared
5476 saved_LDFLAGS="$LDFLAGS"
5477 saved_CFLAGS="$CFLAGS"
5480 CFLAGS=`echo $CFLAGS | sed s/-mdynamic-no-pic//g`
5481 CFLAGS="$CFLAGS -fPIC"
5482 LDFLAGS="$LDFLAGS -shared -undefined dynamic_lookup"
5485 CFLAGS="$CFLAGS -fPIC"
5486 LDFLAGS="$LDFLAGS -fPIC -shared"
5489 AC_MSG_CHECKING([for -fPIC -shared])
5491 [extern int X;],[return X == 0;],
5492 [AC_MSG_RESULT([yes]); have_pic_shared=yes],
5493 [AC_MSG_RESULT([no]); have_pic_shared=no])
5494 if test x"$have_pic_shared" != x"yes" -o x"$ac_cv_search_dlopen" = x"no"; then
5498 LDFLAGS="$saved_LDFLAGS"
5499 CFLAGS="$saved_CFLAGS"
5501 # If plugin support had been requested but not available, fail.
5502 if test x"$enable_plugin" = x"no" ; then
5503 if test x"$default_plugin" != x"yes"; then
5505 Building GCC with plugin support requires a host that supports
5506 -fPIC, -shared, -ldl and -rdynamic.])
5511 AC_SUBST(pluginlibs)
5512 AC_SUBST(enable_plugin)
5513 if test x"$enable_plugin" = x"yes"; then
5514 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
5518 # Enable --enable-host-shared
5519 AC_ARG_ENABLE(host-shared,
5520 [AS_HELP_STRING([--enable-host-shared],
5521 [build host code as shared libraries])],
5522 [PICFLAG=-fPIC], [PICFLAG=])
5523 AC_SUBST(enable_host_shared)
5527 AC_ARG_ENABLE(libquadmath-support,
5528 [AS_HELP_STRING([--disable-libquadmath-support],
5529 [disable libquadmath support for Fortran])],
5530 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
5531 ENABLE_LIBQUADMATH_SUPPORT=yes)
5532 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
5533 AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
5534 [Define to 1 to enable libquadmath support])
5538 # Specify what hash style to use by default.
5539 AC_ARG_WITH([linker-hash-style],
5540 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
5541 [specify the linker hash style])],
5542 [case x"$withval" in
5544 LINKER_HASH_STYLE=sysv
5547 LINKER_HASH_STYLE=gnu
5550 LINKER_HASH_STYLE=both
5553 AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
5556 [LINKER_HASH_STYLE=''])
5557 if test x"${LINKER_HASH_STYLE}" != x; then
5558 AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
5559 [The linker hash style])
5562 # Configure the subdirectories
5563 # AC_CONFIG_SUBDIRS($subdirs)
5565 # Create the Makefile
5566 # and configure language subdirectories
5567 AC_CONFIG_FILES($all_outputs)
5569 AC_CONFIG_COMMANDS([default],
5571 case ${CONFIG_HEADERS} in
5572 *auto-host.h:config.in*)
5575 # Make sure all the subdirs exist.
5576 for d in $subdirs doc build common c-family
5578 test -d $d || mkdir $d
5581 [subdirs='$subdirs'])